rewrite_query.h

// Copyright 2011 Google Inc.

#ifndef NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_QUERY_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_QUERY_H_

#include "net/instaweb/rewriter/public/device_properties.h"
#include "net/instaweb/http/public/request_context.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/gtest_prod.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/headers.h"
#include "pagespeed/kernel/http/query_params.h"
#include "pagespeed/kernel/http/request_headers.h"

namespace net_instaweb {

class GoogleUrl;
class MessageHandler;
class RequestProperties;
class ResponseHeaders;
class RewriteDriver;
class RewriteDriverFactory;
class RewriteFilter;
class RewriteOptions;
class ServerContext;

class RewriteQuery {
 public:
  static const char kModPagespeed[];
  static const char kPageSpeed[];
  static const char kModPagespeedFilters[];
  static const char kPageSpeedFilters[];
  static const char kNoscriptValue[];

  enum Status {
    kSuccess,
    kInvalid,
    kNoneFound
  };

  RewriteQuery();
  ~RewriteQuery();

  Status Scan(bool allow_related_options,
              bool allow_options_to_be_specified_by_cookies,
              const GoogleString& request_option_override,
              const RequestContextPtr& request_context,
              RewriteDriverFactory* factory,
              ServerContext* server_context,
              GoogleUrl* request_url,
              RequestHeaders* request_headers,
              ResponseHeaders* response_headers,
              MessageHandler* handler);

  template <class HeaderT>
  static Status ScanHeader(bool allow_options,
                           const GoogleString& request_option_override,
                           const RequestContextPtr& request_context,
                           HeaderT* headers,
                           RequestProperties* request_properties,
                           RewriteOptions* options,
                           MessageHandler* handler);


  static GoogleString GenerateResourceOption(StringPiece filter_id,
                                             RewriteDriver* driver);

  static bool MightBeCustomOption(StringPiece name);

  const QueryParams& query_params() const { return query_params_; }
  const QueryParams& pagespeed_query_params() const {
    return pagespeed_query_params_;
  }
  const QueryParams& pagespeed_option_cookies() const {
    return pagespeed_option_cookies_;
  }
  const RewriteOptions* options() const { return options_.get(); }
  RewriteOptions* ReleaseOptions() { return options_.release(); }

  static bool IsOK(Status status) {
    return (status == kNoneFound) || (status == kSuccess);
  }

 private:
  friend class RewriteQueryTest;
  FRIEND_TEST(RewriteQueryTest, ClientOptionsEmptyHeader);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsMultipleHeaders);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsOrder1);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsOrder2);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsCaseInsensitive);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsNonDefaultProxyMode);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsValidVersionBadOptions);
  FRIEND_TEST(RewriteQueryTest, ClientOptionsInvalidVersion);

  enum ProxyMode {
    kProxyModeDefault,
    kProxyModeNoImageTransform,
    kProxyModeNoTransform,
  };

  static bool MayHaveCustomOptions(
      const QueryParams& params, const RequestHeaders* req_headers,
      const ResponseHeaders* resp_headers,
      const RequestHeaders::CookieMultimap& cookies);

  template <class HeaderT>
  static bool HeadersMayHaveCustomOptions(const QueryParams& params,
                                          const HeaderT* headers);

  static bool CookiesMayHaveCustomOptions(
      const RequestHeaders::CookieMultimap& cookies);

  static Status ScanNameValue(const StringPiece& name,
                              const StringPiece& value,
                              bool allow_options,
                              const RequestContextPtr& request_context,
                              RequestProperties* request_properties,
                              RewriteOptions* options,
                              MessageHandler* handler);

  static Status ParseResourceOption(StringPiece value, RewriteOptions* options,
                                    const RewriteFilter* rewrite_filter);

  static bool ParseClientOptions(
      const StringPiece& client_options,
      ProxyMode* proxy_mode,
      DeviceProperties::ImageQualityPreference* image_quality);

  static bool SetEffectiveImageQualities(
      DeviceProperties::ImageQualityPreference quality_preference,
      RequestProperties* request_properties,
      RewriteOptions* options);

  static bool UpdateRewriteOptionsWithClientOptions(
      StringPiece header_value, RequestProperties* request_properties,
      RewriteOptions* options);

  static bool ParseProxyMode(const GoogleString* mode_name, ProxyMode* mode);

  static bool ParseImageQualityPreference(
      const GoogleString* preference_name,
      DeviceProperties::ImageQualityPreference* preference);

  QueryParams query_params_;
  QueryParams pagespeed_query_params_;
  QueryParams pagespeed_option_cookies_;
  scoped_ptr<RewriteOptions> options_;

  
};

}  

#endif