in_place_resource_recorder.h

Go to the documentation of this file.

// Copyright 2013 Google Inc.

#ifndef PAGESPEED_SYSTEM_IN_PLACE_RESOURCE_RECORDER_H_
#define PAGESPEED_SYSTEM_IN_PLACE_RESOURCE_RECORDER_H_

#include "net/instaweb/http/public/async_fetch.h"
#include "net/instaweb/http/public/http_value.h"
#include "net/instaweb/http/public/inflating_fetch.h"
#include "net/instaweb/http/public/request_context.h"
#include "pagespeed/kernel/base/atomic_int32.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/http_options.h"
#include "pagespeed/kernel/http/request_headers.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

class HTTPCache;
class MessageHandler;
class Statistics;
class Variable;

class InPlaceResourceRecorder : public Writer {
 public:
  enum HeadersKind {
    kPreliminaryHeaders,

    kFullHeaders
  };

  InPlaceResourceRecorder(
      const RequestContextPtr& request_context,
      StringPiece url, StringPiece fragment,
      const RequestHeaders::Properties& request_properties,
      int max_response_bytes, int max_concurrent_recordings,
      HTTPCache* cache, Statistics* statistics, MessageHandler* handler);

  virtual ~InPlaceResourceRecorder();

  static void InitStats(Statistics* statistics);

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

  virtual bool Flush(MessageHandler* handler) { return true; }

  void ConsiderResponseHeaders(HeadersKind headers_kind,
                               ResponseHeaders* response_headers);

  void SaveCacheControl(const char* cache_control);

  void Fail() { failure_ = true; }

  void DoneAndSetHeaders(ResponseHeaders* response_headers,
                         bool entire_response_received);

  const GoogleString& url() const { return url_; }
  MessageHandler* handler() { return handler_; }

  bool failed() { return failure_; }
  bool limit_active_recordings() { return max_concurrent_recordings_ != 0; }

  const HttpOptions& http_options() const { return http_options_; }

 private:
  class HTTPValueFetch : public AsyncFetchUsingWriter {
   public:
    HTTPValueFetch(const RequestContextPtr& request_context, HTTPValue* value)
        : AsyncFetchUsingWriter(request_context, value) {}
    virtual void HandleDone(bool ) {}
    virtual void HandleHeadersComplete() {}
  };

  bool IsIproContentType(ResponseHeaders* response_headers);

  void DroppedDueToSize();
  void DroppedAsUncacheable();

  const GoogleString url_;
  const GoogleString fragment_;
  const RequestHeaders::Properties request_properties_;
  const HttpOptions http_options_;

  int64 max_response_bytes_;
  const int max_concurrent_recordings_;

  HTTPValue resource_value_;
  HTTPValueFetch write_to_resource_value_;
  InflatingFetch inflating_fetch_;

  HTTPCache* cache_;
  MessageHandler* handler_;

  Variable* num_resources_;
  Variable* num_inserted_into_cache_;
  Variable* num_not_cacheable_;
  Variable* num_failed_;
  Variable* num_dropped_due_to_load_;
  Variable* num_dropped_due_to_size_;

  static AtomicInt32 active_recordings_;
  int status_code_;
  bool failure_;

  bool full_response_headers_considered_;

  bool consider_response_headers_called_;

  bool cache_control_set_;
  GoogleString cache_control_;

  
};

}  

#endif