Support Cookie modifications in Declarative WebRequest API

chrome/browser/extensions/api/declarative_webrequest/webrequest_action.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_action.h"
 
 #include <limits>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stages.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "net/url_request/url_request.h"
 
 namespace extensions {
 
 namespace keys = declarative_webrequest_constants;
+namespace helpers = extension_web_request_api_helpers;
 
 namespace {
 // Error messages.
 const char kInvalidInstanceTypeError[] =
     "An action has an invalid instanceType: %s";
 
 const char kTransparentImageUrl[] = "data:image/png;base64,iVBORw0KGgoAAAANSUh"
     "EUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==";
 const char kEmptyDocumentUrl[] = "data:text/html,";
 
 #define INPUT_FORMAT_VALIDATE(test) do { \
     if (!(test)) { \
       *bad_message = true; \
       return scoped_ptr<WebRequestAction>(NULL); \
     } \
   } while (0)
 
+scoped_ptr<helpers::RequestCookie> ParseRequestCookie(
+    const DictionaryValue* dict) {
+  scoped_ptr<helpers::RequestCookie> result(new helpers::RequestCookie);
+  std::string tmp;
+  if (dict->GetString(keys::kNameKey, &tmp))
+    result->name.reset(new std::string(tmp));
+  if (dict->GetString(keys::kValueKey, &tmp))
+    result->value.reset(new std::string(tmp));
+  return result.Pass();
+}
+
+scoped_ptr<helpers::ResponseCookie> ParseResponseCookie(
+    const DictionaryValue* dict) {
+  scoped_ptr<helpers::ResponseCookie> result(new helpers::ResponseCookie);
+  std::string tmp;
+  int int_tmp = 0;
+  bool bool_tmp = false;
+  if (dict->GetString(keys::kNameKey, &tmp))
+    result->name.reset(new std::string(tmp));
+  if (dict->GetString(keys::kValueKey, &tmp))
+    result->value.reset(new std::string(tmp));
+  if (dict->GetString(keys::kExpiresKey, &tmp))
+    result->expires.reset(new std::string(tmp));
+  if (dict->GetInteger(keys::kMaxAgeKey, &int_tmp))
+    result->max_age.reset(new int(int_tmp));
+  if (dict->GetString(keys::kDomainKey, &tmp))
+    result->domain.reset(new std::string(tmp));
+  if (dict->GetString(keys::kPathKey, &tmp))
+    result->path.reset(new std::string(tmp));
+  if (dict->GetBoolean(keys::kSecureKey, &bool_tmp))
+    result->secure.reset(new bool(bool_tmp));
+  if (dict->GetBoolean(keys::kHttpOnlyKey, &bool_tmp))
+    result->http_only.reset(new bool(bool_tmp));
+  return result.Pass();
+}
+
 // Helper function for WebRequestActions that can be instantiated by just
 // calling the constructor.
 template <class T>
 scoped_ptr<WebRequestAction> CallConstructorFactoryMethod(
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   return scoped_ptr<WebRequestAction>(new T);
 }
 
@@ skipping 84 matching lines @@
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   int minium_priority;
   INPUT_FORMAT_VALIDATE(
       dict->GetInteger(keys::kLowerPriorityThanKey, &minium_priority));
   return scoped_ptr<WebRequestAction>(
       new WebRequestIgnoreRulesAction(minium_priority));
 }
 
+scoped_ptr<WebRequestAction> CreateRequestCookieAction(
+    const base::DictionaryValue* dict,
+    std::string* error,
+    bool* bad_message) {
+  using extension_web_request_api_helpers::RequestCookieModification;
+  using extension_web_request_api_helpers::ResponseCookieModification;
+
+  linked_ptr<RequestCookieModification> modification(
+      new RequestCookieModification);
+
+  // Get modification type.
+  std::string instance_type;
+  INPUT_FORMAT_VALIDATE(
+      dict->GetString(keys::kInstanceTypeKey, &instance_type));
+  if (instance_type == keys::kAddRequestCookieType)
+    modification->type = helpers::ADD;
+  else if (instance_type == keys::kEditRequestCookieType)
+    modification->type = helpers::EDIT;
+  else if (instance_type == keys::kRemoveRequestCookieType)
+    modification->type = helpers::REMOVE;
+  else
+    INPUT_FORMAT_VALIDATE(false);
+
+  // Get filter.
+  if (modification->type == helpers::EDIT ||
+      modification->type == helpers::REMOVE) {
+    DictionaryValue* filter = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter));
+    modification->filter = ParseRequestCookie(filter);
+  }
+
+  // Get new value.
+  if (modification->type == helpers::ADD) {
+    DictionaryValue* value = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value));
+    modification->modification = ParseRequestCookie(value);
+  } else if (modification->type == helpers::EDIT) {
+    DictionaryValue* value = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value));
+    modification->modification = ParseRequestCookie(value);
+  }
+
+  return scoped_ptr<WebRequestAction>(
+      new WebRequestCookieAction(modification,
+                                 linked_ptr<ResponseCookieModification>()));
+}
+
+scoped_ptr<WebRequestAction> CreateResponseCookieAction(
+    const base::DictionaryValue* dict,
+    std::string* error,
+    bool* bad_message) {
+  using extension_web_request_api_helpers::RequestCookieModification;
+  using extension_web_request_api_helpers::ResponseCookieModification;
+
+  linked_ptr<ResponseCookieModification> modification(
+      new ResponseCookieModification);
+
+  // Get modification type.
+  std::string instance_type;
+  INPUT_FORMAT_VALIDATE(
+      dict->GetString(keys::kInstanceTypeKey, &instance_type));
+  if (instance_type == keys::kAddResponseCookieType)
+    modification->type = helpers::ADD;
+  else if (instance_type == keys::kEditResponseCookieType)
+    modification->type = helpers::EDIT;
+  else if (instance_type == keys::kRemoveResponseCookieType)
+    modification->type = helpers::REMOVE;
+  else
+    INPUT_FORMAT_VALIDATE(false);
+
+  // Get filter.
+  if (modification->type == helpers::EDIT ||
+      modification->type == helpers::REMOVE) {
+    DictionaryValue* filter = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kFilterKey, &filter));
+    modification->filter = ParseResponseCookie(filter);
+  }
+
+  // Get new value.
+  if (modification->type == helpers::ADD) {
+    DictionaryValue* value = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kCookieKey, &value));
+    modification->modification = ParseResponseCookie(value);
+  } else if (modification->type == helpers::EDIT) {
+    DictionaryValue* value = NULL;
+    INPUT_FORMAT_VALIDATE(dict->GetDictionary(keys::kModificationKey, &value));
+    modification->modification = ParseResponseCookie(value);
+  }
+
+  return scoped_ptr<WebRequestAction>(
+      new WebRequestCookieAction(linked_ptr<RequestCookieModification>(),
+                                 modification));
+}
+
 struct WebRequestActionFactory {
   // Factory methods for WebRequestAction instances. |dict| contains the json
   // dictionary that describes the action. |error| is used to return error
   // messages in case the extension passed an action that was syntactically
   // correct but semantically incorrect. |bad_message| is set to true in case
   // |dict| does not confirm to the validated JSON specification.
   typedef scoped_ptr<WebRequestAction>
       (* FactoryMethod)(const base::DictionaryValue* /* dict */ ,
                         std::string* /* error */,
                         bool* /* bad_message */);
   std::map<std::string, FactoryMethod> factory_methods;
 
   WebRequestActionFactory() {
+    factory_methods[keys::kAddRequestCookieType] =
+        &CreateRequestCookieAction;
+    factory_methods[keys::kAddResponseCookieType] =
+        &CreateResponseCookieAction;
     factory_methods[keys::kAddResponseHeaderType] =
         &CreateAddResponseHeaderAction;
     factory_methods[keys::kCancelRequestType] =
         &CallConstructorFactoryMethod<WebRequestCancelAction>;
+    factory_methods[keys::kEditRequestCookieType] =
+        &CreateRequestCookieAction;
+    factory_methods[keys::kEditResponseCookieType] =
+        &CreateResponseCookieAction;
     factory_methods[keys::kRedirectByRegExType] =
         &CreateRedirectRequestByRegExAction;
     factory_methods[keys::kRedirectRequestType] =
         &CreateRedirectRequestAction;
     factory_methods[keys::kRedirectToTransparentImageType] =
         &CallConstructorFactoryMethod<
             WebRequestRedirectToTransparentImageAction>;
     factory_methods[keys::kRedirectToEmptyDocumentType] =
         &CallConstructorFactoryMethod<WebRequestRedirectToEmptyDocumentAction>;
+    factory_methods[keys::kRemoveRequestCookieType] =
+        &CreateRequestCookieAction;
+    factory_methods[keys::kRemoveResponseCookieType] =
+        &CreateResponseCookieAction;
     factory_methods[keys::kSetRequestHeaderType] =
         &CreateSetRequestHeaderAction;
     factory_methods[keys::kRemoveRequestHeaderType] =
         &CreateRemoveRequestHeaderAction;
     factory_methods[keys::kRemoveResponseHeaderType] =
         &CreateRemoveResponseHeaderAction;
     factory_methods[keys::kIgnoreRulesType] =
         &CreateIgnoreRulesAction;
   }
 };
@@ skipping 539 matching lines @@
 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta(
     net::URLRequest* request,
     RequestStages request_stage,
     const WebRequestRule::OptionalRequestData& optional_request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_stage & GetStages());
   return LinkedPtrEventResponseDelta(NULL);
 }
 
+//
+// WebRequestCookieAction
+//
+
+WebRequestCookieAction::WebRequestCookieAction(

[Matt Perry, 2012/07/09 23:26:13]

It looks like the logic for the 2 types of cookies are completely different.
What's the advantage of putting them in a combined Action class?

[battre, 2012/08/02 17:17:34]

Just saving a couple of lines of builder plate code. I have split this.

Done.

+    linked_ptr<RequestCookieModification> request_cookie_modification,
+    linked_ptr<ResponseCookieModification> response_cookie_modification)
+    : request_cookie_modification_(request_cookie_modification),
+      response_cookie_modification_(response_cookie_modification) {
+  // Either one needs to be set.
+  CHECK(!!request_cookie_modification_.get() ^
+        !!response_cookie_modification_.get());
+}
+
+WebRequestCookieAction::~WebRequestCookieAction() {}
+
+int WebRequestCookieAction::GetStages() const {
+  if (request_cookie_modification_.get()) {
+    return ON_BEFORE_SEND_HEADERS;
+  } else if (response_cookie_modification_.get()) {
+    return ON_HEADERS_RECEIVED;
+  } else {
+    NOTREACHED();
+    return 0;
+  }
+}
+
+WebRequestAction::Type WebRequestCookieAction::GetType() const {
+  return WebRequestAction::ACTION_MODIFY_COOKIE;
+}
+
+LinkedPtrEventResponseDelta WebRequestCookieAction::CreateDelta(
+    net::URLRequest* request,
+    RequestStages request_stage,
+    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const std::string& extension_id,
+    const base::Time& extension_install_time) const {
+  CHECK(request_stage & GetStages());
+  LinkedPtrEventResponseDelta result(
+      new extension_web_request_api_helpers::EventResponseDelta(
+          extension_id, extension_install_time));
+  if (request_cookie_modification_.get()) {
+    result->request_cookie_modifications.push_back(
+        request_cookie_modification_);
+  }
+  if (response_cookie_modification_.get()) {
+      result->response_cookie_modifications.push_back(
+          response_cookie_modification_);
+  }
+  return result;
+}
+
 }  // namespace extensions