async_fetch.h

Go to the documentation of this file.

/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_HTTP_PUBLIC_ASYNC_FETCH_H_
#define NET_INSTAWEB_HTTP_PUBLIC_ASYNC_FETCH_H_

#include "net/instaweb/http/public/http_value.h"
#include "net/instaweb/http/public/request_context.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/writer.h"
#include "pagespeed/kernel/http/request_headers.h"
#include "pagespeed/kernel/http/response_headers.h"


namespace net_instaweb {

class AbstractLogRecord;
class MessageHandler;
class Variable;

class AsyncFetch : public Writer {
 public:
  static const int kContentLengthUnknown = -1;

  AsyncFetch();
  explicit AsyncFetch(const RequestContextPtr& request_ctx);

  virtual ~AsyncFetch();

  void HeadersComplete();

  void Done(bool success);

  virtual bool Write(const StringPiece& content, MessageHandler* handler);
  virtual bool Flush(MessageHandler* handler);

  virtual bool IsCachedResultValid(const ResponseHeaders& headers) {
    return true;
  }

  RequestHeaders* request_headers();

  void set_request_headers(RequestHeaders* headers);

  void SetRequestHeadersTakingOwnership(RequestHeaders* headers);

  const RequestHeaders* request_headers() const;

  ResponseHeaders* response_headers();
  void set_response_headers(ResponseHeaders* headers);

  ResponseHeaders* extra_response_headers();
  void set_extra_response_headers(ResponseHeaders* headers);

  virtual bool IsBackgroundFetch() const { return false; }

  virtual void Reset() { headers_complete_ = false; }

  bool headers_complete() const { return headers_complete_; }

  bool content_length_known() const {
    return content_length_ != kContentLengthUnknown;
  }
  int64 content_length() const { return content_length_; }
  void set_content_length(int64 x) { content_length_ = x; }

  GoogleString LoggingString();

  virtual const RequestContextPtr& request_context() { return request_ctx_; }

  virtual AbstractLogRecord* log_record();

  void FixCacheControlForGoogleCache();

  static bool IsGoogleCacheVia(StringPiece via_value);

 protected:
  virtual bool HandleWrite(const StringPiece& sp, MessageHandler* handler) = 0;
  virtual bool HandleFlush(MessageHandler* handler) = 0;
  virtual void HandleDone(bool success) = 0;
  virtual void HandleHeadersComplete() = 0;

 private:
  RequestHeaders* request_headers_;
  ResponseHeaders* response_headers_;
  ResponseHeaders* extra_response_headers_;
  RequestContextPtr request_ctx_;
  bool owns_request_headers_;
  bool owns_response_headers_;
  bool owns_extra_response_headers_;
  bool headers_complete_;
  int64 content_length_;

  
};

class StringAsyncFetch : public AsyncFetch {
 public:
  explicit StringAsyncFetch(const RequestContextPtr& request_ctx)
      : AsyncFetch(request_ctx), buffer_pointer_(&buffer_) {
    Init();
  }

  StringAsyncFetch(const RequestContextPtr& request_ctx, GoogleString* buffer)
      : AsyncFetch(request_ctx), buffer_pointer_(buffer) {
    Init();
  }

  virtual ~StringAsyncFetch();

  virtual bool HandleWrite(const StringPiece& content,
                           MessageHandler* handler) {
    content.AppendToString(buffer_pointer_);
    return true;
  }
  virtual bool HandleFlush(MessageHandler* handler) { return true; }
  virtual void HandleHeadersComplete() {}
  virtual void HandleDone(bool success) {
    success_ = success;
    done_ = true;
  }

  bool success() const { return success_; }
  bool done() const { return done_; }
  const GoogleString& buffer() const { return *buffer_pointer_; }

  virtual void Reset() {
    done_ = false;
    success_ = false;
    buffer_pointer_->clear();
    response_headers()->Clear();
    extra_response_headers()->Clear();
    request_headers()->Clear();
    AsyncFetch::Reset();
  }

 protected:
  void set_success(bool success) { success_ = success; }
  void set_done(bool done) { done_ = done; }

 private:
  void Init() {
    success_ = false;
    done_ = false;
  }

  GoogleString buffer_;
  GoogleString* buffer_pointer_;
  bool success_;
  bool done_;

  
};

class AsyncFetchUsingWriter : public AsyncFetch {
 public:
  AsyncFetchUsingWriter(const RequestContextPtr& request_context,
                        Writer* writer)
     : AsyncFetch(request_context),
       writer_(writer) {}
  virtual ~AsyncFetchUsingWriter();

 protected:
  virtual bool HandleWrite(const StringPiece& sp, MessageHandler* handler);
  virtual bool HandleFlush(MessageHandler* handler);

 private:
  Writer* writer_;
  
};

class SharedAsyncFetch : public AsyncFetch {
 public:
  explicit SharedAsyncFetch(AsyncFetch* base_fetch);
  virtual ~SharedAsyncFetch();

  virtual const RequestContextPtr& request_context() {
    return base_fetch_->request_context();
  }

 protected:
  virtual void HandleDone(bool success) {
    base_fetch_->Done(success);
  }

  virtual bool HandleWrite(const StringPiece& content,
                           MessageHandler* handler) {
    return base_fetch_->Write(content, handler);
  }

  virtual bool HandleFlush(MessageHandler* handler) {
    return base_fetch_->Flush(handler);
  }

  virtual void HandleHeadersComplete();

  virtual bool IsCachedResultValid(const ResponseHeaders& headers) {
    return base_fetch_->IsCachedResultValid(headers);
  }

  virtual bool IsBackgroundFetch() const {
    return base_fetch_->IsBackgroundFetch();
  }

  void PropagateContentLength();

 private:
  AsyncFetch* base_fetch_;
  
};

class FallbackSharedAsyncFetch : public SharedAsyncFetch {
 public:
  static const char kStaleWarningHeaderValue[];

  FallbackSharedAsyncFetch(AsyncFetch* base_fetch, HTTPValue* fallback,
                           MessageHandler* handler);
  virtual ~FallbackSharedAsyncFetch();

  void set_fallback_responses_served(Variable* x) {
    fallback_responses_served_ = x;
  }

  bool serving_fallback() const { return serving_fallback_; }

 protected:
  virtual void HandleDone(bool success);
  virtual bool HandleWrite(const StringPiece& content, MessageHandler* handler);
  virtual bool HandleFlush(MessageHandler* handler);
  virtual void HandleHeadersComplete();

 private:
  MessageHandler* handler_;
  HTTPValue fallback_;
  bool serving_fallback_;
  Variable* fallback_responses_served_; 

  
};

class ConditionalSharedAsyncFetch : public SharedAsyncFetch {
 public:
  ConditionalSharedAsyncFetch(AsyncFetch* base_fetch, HTTPValue* cached_value,
                              MessageHandler* handler);
  virtual ~ConditionalSharedAsyncFetch();

  void set_num_conditional_refreshes(Variable* x) {
    num_conditional_refreshes_ = x;
  }

 protected:
  virtual void HandleDone(bool success);
  virtual bool HandleWrite(const StringPiece& content, MessageHandler* handler);
  virtual bool HandleFlush(MessageHandler* handler);
  virtual void HandleHeadersComplete();

 private:
  MessageHandler* handler_;
  HTTPValue cached_value_;
  bool serving_cached_value_;
  bool added_conditional_headers_to_request_;

  Variable* num_conditional_refreshes_; 

  
};

}  

#endif