response_headers.h

Go to the documentation of this file.

// Copyright 2011 Google Inc.


#ifndef PAGESPEED_KERNEL_HTTP_RESPONSE_HEADERS_H_
#define PAGESPEED_KERNEL_HTTP_RESPONSE_HEADERS_H_

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/content_type.h"
#include "pagespeed/kernel/http/headers.h"
#include "pagespeed/kernel/http/http_options.h"
#include "pagespeed/kernel/http/http_names.h"
#include "pagespeed/kernel/http/request_headers.h"

namespace net_instaweb {

class GoogleUrl;
class HttpResponseHeaders;
class MessageHandler;
class Writer;

class ResponseHeaders : public Headers<HttpResponseHeaders> {
 public:
  enum VaryOption { kRespectVaryOnResources, kIgnoreVaryOnResources };
  enum ValidatorOption { kHasValidator, kNoValidator };

  explicit ResponseHeaders(const HttpOptions& options) { Init(options); }

  explicit ResponseHeaders(const ResponseHeaders& other);
  ResponseHeaders& operator=(const ResponseHeaders& other);

  ResponseHeaders() { Init(kDeprecatedDefaultHttpOptions); }

  virtual ~ResponseHeaders();

  static bool IsImminentlyExpiring(
      int64 start_date_ms, int64 expire_ms, int64 now_ms,
      const HttpOptions& options);

  void FixDateHeaders(int64 now_ms);

  bool cache_fields_dirty() const { return cache_fields_dirty_; }

  virtual void Clear();

  void CopyFrom(const ResponseHeaders& other);

  bool MergeContentType(const StringPiece& content_type);

  virtual void UpdateFrom(const Headers<HttpResponseHeaders>& other);

  void UpdateFromProto(const HttpResponseHeaders& proto);

  virtual bool WriteAsBinary(Writer* writer, MessageHandler* message_handler);

  virtual bool ReadFromBinary(const StringPiece& buf, MessageHandler* handler);

  virtual bool WriteAsHttp(Writer* writer, MessageHandler* handler) const;

  void ComputeCaching();

  bool IsProxyCacheable(RequestHeaders::Properties properties,
                        VaryOption respect_vary_on_resources,
                        ValidatorOption has_request_validator) const;

  static VaryOption GetVaryOption(bool respect_vary) {
    return respect_vary ? kRespectVaryOnResources : kIgnoreVaryOnResources;
  }

  bool IsProxyCacheable() const {
    return IsProxyCacheable(
        RequestHeaders::Properties(), kRespectVaryOnResources, kNoValidator);
  }

  bool IsBrowserCacheable() const;

  bool RequiresBrowserRevalidation() const;

  bool RequiresProxyRevalidation() const;

  int64 CacheExpirationTimeMs() const;

  void SetDateAndCaching(int64 date_ms, int64 ttl_ms,
                         const StringPiece& cache_control_suffix);
  void SetDateAndCaching(int64 date_ms, int64 ttl_ms) {
    SetDateAndCaching(date_ms, ttl_ms, "");
  }
  GoogleString CacheControlValuesToPreserve();

  void SetTimeHeader(const StringPiece& header, int64 time_ms);
  void SetDate(int64 date_ms) { SetTimeHeader(HttpAttributes::kDate, date_ms); }
  void SetLastModified(int64 last_modified_ms) {
    SetTimeHeader(HttpAttributes::kLastModified, last_modified_ms);
  }

  void SetCacheControlMaxAge(int64 ttl_ms);

  void SetCacheControlPublic();

  void SetOriginalContentLength(int64 content_length);

  void SetContentLength(int64 content_length);

  bool Sanitize();

  void GetSanitizedProto(HttpResponseHeaders* proto) const;

  bool headers_complete() const { return has_status_code(); }

  int status_code() const;
  bool has_status_code() const;
  void set_status_code(const int code);
  const char* reason_phrase() const;
  void set_reason_phrase(const StringPiece& reason_phrase);

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

  int64 implicit_cache_ttl_ms() const {
    return http_options_.implicit_cache_ttl_ms;
  }
  void set_implicit_cache_ttl_ms(const int64 ttl) {
    http_options_.implicit_cache_ttl_ms = ttl;
  }

  bool has_last_modified_time_ms() const;
  int64 last_modified_time_ms() const;
  int64 date_ms() const; 
  bool has_date_ms() const;
  int64 cache_ttl_ms() const;
  bool is_implicitly_cacheable() const;

  GoogleString ToString() const;

  void SetStatusAndReason(HttpStatus::Code code);

  void DebugPrint() const;

  static bool ParseTime(const char* time_str, int64* time_ms);

  inline bool IsErrorStatus() const {
    int status = status_code();
    return status >= 400 && status <= 599;
  }

  inline bool IsServerErrorStatus() const {
    int status = status_code();
    return status >= 500 && status <= 599;
  }

  bool IsRedirectStatus() const {
    int status = status_code();
    return status >= 300 && status <= 399 && status != 304;
  }

  bool IsGzipped() const;
  bool WasGzippedLast() const;

  const ContentType* DetermineContentType() const;

  bool IsHtmlLike() const {
    const ContentType* type = DetermineContentType();
    return (type != NULL && type->IsHtmlLike());
  }

  GoogleString DetermineCharset() const;

  void DetermineContentTypeAndCharset(const ContentType** content_type_out,
                                      GoogleString* charset_out) const;


  bool ParseDateHeader(const StringPiece& attr, int64* date_ms) const;

  void ParseFirstLine(const StringPiece& first_line);

  void ParseFirstLineHelper(const StringPiece& first_line);

  void set_first_line(int major_version, int minor_version, int status_code,
                      const StringPiece& reason_phrase) {
    set_major_version(major_version);
    set_minor_version(minor_version);
    set_status_code(status_code);
    set_reason_phrase(reason_phrase);
  }

  bool FindContentLength(int64* content_length) const;

  void ForceCaching(int64 ttl_ms);

  bool UpdateCacheHeadersIfForceCached();

  int64 SizeEstimate() const;

  bool GetCookieString(GoogleString* cookie_str) const;

  bool HasCookie(StringPiece name, StringPieceVector* values,
                 StringPieceVector* attributes) const;

  bool HasAnyCookiesWithAttribute(StringPiece attribute_name,
                                  StringPiece* attribute_value);

  bool SetQueryParamsAsCookies(const GoogleUrl& gurl, StringPiece query_params,
                               const StringPieceVector& to_exclude,
                               int64 expiration_time);
  bool ClearOptionCookies(const GoogleUrl& gurl, StringPiece option_cookies,
                          const StringPieceVector& to_exclude);

  bool HasLinkRelCanonical() const;

  static GoogleString RelCanonicalHeaderValue(StringPiece url);

  void SetSMaxAge(int s_maxage_sec);
  static bool ApplySMaxAge(int s_maxage_sec,
                           StringPiece existing_cache_control,
                           GoogleString* updated_cache_control);

  static bool IsHopByHopIndication(StringPiece val);

 protected:
  virtual void UpdateHook();

 private:
  void Init(const HttpOptions& options);

  bool CombineContentTypes(const StringPiece& orig, const StringPiece& fresh);

  friend class ResponseHeadersTest;
  bool cache_fields_dirty_;

  HttpOptions http_options_;

  int64 force_cache_ttl_ms_;
  bool force_cached_;

};

}  

#endif