request_context.h

Go to the documentation of this file.

/*
 * Copyright 2012 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 PAGESPEED_OPT_HTTP_REQUEST_CONTEXT_H_
#define PAGESPEED_OPT_HTTP_REQUEST_CONTEXT_H_

#include <set>

#include "base/logging.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/http_options.h"
#include "pagespeed/opt/logging/request_timing_info.h"

namespace net_instaweb {

class AbstractLogRecord;
class AbstractMutex;
class RequestContext;
class RequestTrace;
class ThreadSystem;
class Timer;

typedef RefCountedPtr<RequestContext> RequestContextPtr;

class RequestContext : public RefCounted<RequestContext> {
 public:
  RequestContext(const HttpOptions& options, AbstractMutex* logging_mutex,
                 Timer* timer);
  RequestContext(AbstractMutex* logging_mutex, Timer* timer);

  static RequestContextPtr NewTestRequestContext(ThreadSystem* thread_system) {
    return NewTestRequestContextWithTimer(thread_system, NULL);
  }
  static RequestContextPtr NewTestRequestContextWithTimer(
      ThreadSystem* thread_system, Timer* timer);
  static RequestContextPtr NewTestRequestContext(AbstractLogRecord* log_record);

  virtual AbstractLogRecord* NewSubordinateLogRecord(
      AbstractMutex* logging_mutex);

  RequestTrace* root_trace_context() { return root_trace_context_.get(); }
  void set_root_trace_context(RequestTrace* x);

  virtual RequestTrace* CreateDependentTraceContext(const StringPiece& label) {
    return NULL;
  }

  virtual void ReleaseDependentTraceContext(RequestTrace* t);

  virtual AbstractLogRecord* log_record();

  bool using_http2() const { return using_http2_; }
  void set_using_http2(bool x) { using_http2_ = x; }

  void SetHttp2SupportFromViaHeader(StringPiece header);

  const GoogleString& minimal_private_suffix() const {
    return minimal_private_suffix_;
  }
  void set_minimal_private_suffix(StringPiece minimal_private_suffix) {
    minimal_private_suffix.CopyToString(&minimal_private_suffix_);
  }

  void SetAcceptsWebp(bool x);
  bool accepts_webp() const { return accepts_webp_; }

  void SetAcceptsGzip(bool x);
  bool accepts_gzip() const { return accepts_gzip_; }

  int64 request_id() const {
    return request_id_;
  }
  void set_request_id(int64 x) {
    request_id_ = x;
  }

  const GoogleString& sticky_query_parameters_token() const {
    return sticky_query_parameters_token_;
  }
  void set_sticky_query_parameters_token(StringPiece x) {
    x.CopyToString(&sticky_query_parameters_token_);
  }

  void AddSessionAuthorizedFetchOrigin(const GoogleString& origin) {
    session_authorized_fetch_origins_.insert(origin);
  }

  bool IsSessionAuthorizedFetchOrigin(const GoogleString& origin) const {
    return session_authorized_fetch_origins_.find(origin)
           != session_authorized_fetch_origins_.end();
  }

  void PrepareLogRecordForOutput();

  void WriteBackgroundRewriteLog();

  AbstractLogRecord* GetBackgroundRewriteLog(
      ThreadSystem* thread_system,
      bool log_urls,
      bool log_url_indices,
      int max_rewrite_info_log_size);

  const RequestTimingInfo& timing_info() const { return timing_info_; }
  RequestTimingInfo* mutable_timing_info() { return &timing_info_; }

  void set_options(const HttpOptions& options) {
    DCHECK(!options_set_);
    options_set_ = true;
    options_ = options;
  }
  void ResetOptions(const HttpOptions& options) {
    options_set_ = true;
    options_ = options;
  }
  const HttpOptions& options() const {
    DCHECK(options_set_);
    return options_;
  }

  void Freeze() { frozen_ = true; }
  bool frozen() const { return frozen_; }

 protected:
  RequestContext(const HttpOptions& options, AbstractMutex* mutex,
                 Timer* timer, AbstractLogRecord* log_record);
  virtual ~RequestContext();
  REFCOUNT_FRIEND_DECLARATION(RequestContext);

 private:
  void Init();

  scoped_ptr<AbstractLogRecord> log_record_;

  RequestTimingInfo timing_info_;

  scoped_ptr<RequestTrace> root_trace_context_;

  scoped_ptr<AbstractLogRecord> background_rewrite_log_record_;

  StringSet session_authorized_fetch_origins_;

  bool using_http2_;
  bool accepts_webp_;
  bool accepts_gzip_;
  bool frozen_;
  GoogleString minimal_private_suffix_;

  int64 request_id_;

  GoogleString sticky_query_parameters_token_;

  bool options_set_;
  HttpOptions options_;

  
};

}  

#endif