00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00021
00022 #ifndef NET_INSTAWEB_HTTP_PUBLIC_ASYNC_FETCH_H_
00023 #define NET_INSTAWEB_HTTP_PUBLIC_ASYNC_FETCH_H_
00024
00025 #include "net/instaweb/http/public/http_value.h"
00026 #include "net/instaweb/http/public/response_headers.h"
00027 #include "net/instaweb/util/public/basictypes.h"
00028 #include "net/instaweb/util/public/string.h"
00029 #include "net/instaweb/util/public/string_util.h"
00030 #include "net/instaweb/util/public/writer.h"
00031
00032 namespace net_instaweb {
00033
00034 class MessageHandler;
00035 class RequestHeaders;
00036 class TimingInfo;
00037 class Variable;
00038
00051 class AsyncFetch : public Writer {
00052 public:
00053 AsyncFetch() :
00054 request_headers_(NULL),
00055 response_headers_(NULL),
00056 timing_info_(NULL),
00057 owns_request_headers_(false),
00058 owns_response_headers_(false),
00059 headers_complete_(false),
00060 owns_timing_info_(false) {
00061 }
00062
00063 virtual ~AsyncFetch();
00064
00071 void HeadersComplete();
00072
00075 void Done(bool success);
00076
00079 virtual bool Write(const StringPiece& sp, MessageHandler* handler);
00080 virtual bool Flush(MessageHandler* handler);
00081
00088 virtual bool IsCachedResultValid(const ResponseHeaders& headers) {
00089 return true;
00090 }
00091
00096 RequestHeaders* request_headers();
00097
00101 void set_request_headers(RequestHeaders* headers);
00102
00106 const RequestHeaders* request_headers() const;
00107
00109 ResponseHeaders* response_headers();
00110 void set_response_headers(ResponseHeaders* headers);
00111
00112 virtual bool EnableThreaded() const { return false; }
00113
00116 virtual bool IsBackgroundFetch() const { return false; }
00117
00120 virtual void Reset() { headers_complete_ = false; }
00121
00122 bool headers_complete() const { return headers_complete_; }
00123
00127 void set_timing_info(TimingInfo* timing_info);
00128
00133 virtual TimingInfo* timing_info();
00134
00137 GoogleString TimingString() const;
00138
00139 protected:
00140 virtual bool HandleWrite(const StringPiece& sp, MessageHandler* handler) = 0;
00141 virtual bool HandleFlush(MessageHandler* handler) = 0;
00142 virtual void HandleDone(bool success) = 0;
00143 virtual void HandleHeadersComplete() = 0;
00144
00145 private:
00146 RequestHeaders* request_headers_;
00147 ResponseHeaders* response_headers_;
00148 TimingInfo* timing_info_;
00149 bool owns_request_headers_;
00150 bool owns_response_headers_;
00151 bool headers_complete_;
00152 bool owns_timing_info_;
00153
00154 DISALLOW_COPY_AND_ASSIGN(AsyncFetch);
00155 };
00156
00161 class StringAsyncFetch : public AsyncFetch {
00162 public:
00163 StringAsyncFetch() : buffer_pointer_(&buffer_) { Init(); }
00164
00165 explicit StringAsyncFetch(GoogleString* buffer) : buffer_pointer_(buffer) {
00166 Init();
00167 }
00168 virtual ~StringAsyncFetch();
00169
00170 virtual bool HandleWrite(const StringPiece& content,
00171 MessageHandler* handler) {
00172 content.AppendToString(buffer_pointer_);
00173 return true;
00174 }
00175 virtual bool HandleFlush(MessageHandler* handler) { return true; }
00176 virtual void HandleHeadersComplete() {}
00177 virtual void HandleDone(bool success) {
00178 success_ = success;
00179 done_ = true;
00180 }
00181
00182 bool success() const { return success_; }
00183 bool done() const { return done_; }
00184 const GoogleString& buffer() const { return *buffer_pointer_; }
00185
00186 void Reset() {
00187 done_ = false;
00188 success_ = false;
00189 buffer_pointer_->clear();
00190 response_headers()->Clear();
00191 AsyncFetch::Reset();
00192 }
00193
00194 private:
00195 void Init() {
00196 success_ = false;
00197 done_ = false;
00198 }
00199
00200 GoogleString buffer_;
00201 GoogleString* buffer_pointer_;
00202 bool success_;
00203 bool done_;
00204
00205 DISALLOW_COPY_AND_ASSIGN(StringAsyncFetch);
00206 };
00207
00211 class AsyncFetchUsingWriter : public AsyncFetch {
00212 public:
00213 explicit AsyncFetchUsingWriter(Writer* writer) : writer_(writer) {}
00214 virtual ~AsyncFetchUsingWriter();
00215
00216 protected:
00217 virtual bool HandleWrite(const StringPiece& sp, MessageHandler* handler);
00218 virtual bool HandleFlush(MessageHandler* handler);
00219
00220 private:
00221 Writer* writer_;
00222 DISALLOW_COPY_AND_ASSIGN(AsyncFetchUsingWriter);
00223 };
00224
00229 class SharedAsyncFetch : public AsyncFetch {
00230 public:
00231 explicit SharedAsyncFetch(AsyncFetch* base_fetch);
00232 virtual ~SharedAsyncFetch();
00233
00234 AsyncFetch* base_fetch() { return base_fetch_; }
00235 const AsyncFetch* base_fetch() const { return base_fetch_; }
00236
00237 protected:
00238 virtual void HandleDone(bool success) {
00239 base_fetch_->Done(success);
00240 }
00241
00242 virtual bool HandleWrite(const StringPiece& content,
00243 MessageHandler* handler) {
00244 return base_fetch_->Write(content, handler);
00245 }
00246
00247 virtual bool HandleFlush(MessageHandler* handler) {
00248 return base_fetch_->Flush(handler);
00249 }
00250
00251 virtual void HandleHeadersComplete() {
00252 base_fetch_->HeadersComplete();
00253 }
00254
00255 virtual bool EnableThreaded() const {
00256 return base_fetch_->EnableThreaded();
00257 }
00258
00259 virtual bool IsCachedResultValid(const ResponseHeaders& headers) {
00260 return base_fetch_->IsCachedResultValid(headers);
00261 }
00262
00263 virtual bool IsBackgroundFetch() const {
00264 return base_fetch_->IsBackgroundFetch();
00265 }
00266
00267 private:
00268 AsyncFetch* base_fetch_;
00269 DISALLOW_COPY_AND_ASSIGN(SharedAsyncFetch);
00270 };
00271
00277 class FallbackSharedAsyncFetch : public SharedAsyncFetch {
00278 public:
00280 static const char kStaleWarningHeaderValue[];
00281
00282 FallbackSharedAsyncFetch(AsyncFetch* base_fetch, HTTPValue* fallback,
00283 MessageHandler* handler);
00284 virtual ~FallbackSharedAsyncFetch();
00285
00286 void set_fallback_responses_served(Variable* x) {
00287 fallback_responses_served_ = x;
00288 }
00289
00290 bool serving_fallback() const { return serving_fallback_; }
00291
00292 protected:
00293 virtual void HandleDone(bool success);
00294 virtual bool HandleWrite(const StringPiece& content, MessageHandler* handler);
00295 virtual bool HandleFlush(MessageHandler* handler);
00296 virtual void HandleHeadersComplete();
00297
00298 private:
00300 MessageHandler* handler_;
00301 HTTPValue fallback_;
00302 bool serving_fallback_;
00303 Variable* fallback_responses_served_;
00304
00305 DISALLOW_COPY_AND_ASSIGN(FallbackSharedAsyncFetch);
00306 };
00307
00317 class ConditionalSharedAsyncFetch : public SharedAsyncFetch {
00318 public:
00319 ConditionalSharedAsyncFetch(AsyncFetch* base_fetch, HTTPValue* cached_value,
00320 MessageHandler* handler);
00321 virtual ~ConditionalSharedAsyncFetch();
00322
00323 void set_num_conditional_refreshes(Variable* x) {
00324 num_conditional_refreshes_ = x;
00325 }
00326
00327 protected:
00328 virtual void HandleDone(bool success);
00329 virtual bool HandleWrite(const StringPiece& content, MessageHandler* handler);
00330 virtual bool HandleFlush(MessageHandler* handler);
00331 virtual void HandleHeadersComplete();
00332
00333 private:
00335 MessageHandler* handler_;
00336 HTTPValue cached_value_;
00339 bool serving_cached_value_;
00341 bool added_conditional_headers_to_request_;
00342
00343 Variable* num_conditional_refreshes_;
00344
00345 DISALLOW_COPY_AND_ASSIGN(ConditionalSharedAsyncFetch);
00346 };
00347
00348 }
00349
00350 #endif ///< NET_INSTAWEB_HTTP_PUBLIC_ASYNC_FETCH_H_