Add support for response header manipulation 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/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;
 
@@ skipping 50 matching lines @@
 scoped_ptr<WebRequestAction> CreateRemoveRequestHeaderAction(
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   std::string name;
   INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name));
   return scoped_ptr<WebRequestAction>(
       new WebRequestRemoveRequestHeaderAction(name));
 }
 
+scoped_ptr<WebRequestAction> CreateAddResponseHeaderAction(
+    const base::DictionaryValue* dict,
+    std::string* error,
+    bool* bad_message) {
+  std::string name;
+  std::string value;
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name));
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kValueKey, &value));
+  return scoped_ptr<WebRequestAction>(
+      new WebRequestAddResponseHeaderAction(name, value));
+}
+
+scoped_ptr<WebRequestAction> CreateRemoveResponseHeaderAction(
+    const base::DictionaryValue* dict,
+    std::string* error,
+    bool* bad_message) {
+  std::string name;
+  std::string value;
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kNameKey, &name));
+  bool has_value = dict->GetString(keys::kValueKey, &value);
+  return scoped_ptr<WebRequestAction>(
+      new WebRequestRemoveResponseHeaderAction(name, value, has_value));
+}
+
 scoped_ptr<WebRequestAction> CreateIgnoreRulesAction(
     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));
 }
 
 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::kAddResponseHeaderType] =
+        &CreateAddResponseHeaderAction;
     factory_methods[keys::kCancelRequestType] =
         &CallConstructorFactoryMethod<WebRequestCancelAction>;
     factory_methods[keys::kRedirectRequestType] =
         &CreateRedirectRequestAction;
     factory_methods[keys::kRedirectToTransparentImageType] =
         &CallConstructorFactoryMethod<
             WebRequestRedirectToTransparentImageAction>;
     factory_methods[keys::kRedirectToEmptyDocumentType] =
         &CallConstructorFactoryMethod<WebRequestRedirectToEmptyDocumentAction>;
     factory_methods[keys::kSetRequestHeaderType] =
         &CreateSetRequestHeaderAction;
     factory_methods[keys::kRemoveRequestHeaderType] =
         &CreateRemoveRequestHeaderAction;
+    factory_methods[keys::kRemoveResponseHeaderType] =
+        &CreateRemoveResponseHeaderAction;
     factory_methods[keys::kIgnoreRulesType] =
         &CreateIgnoreRulesAction;
   }
 };
 
 base::LazyInstance<WebRequestActionFactory>::Leaky
     g_web_request_action_factory = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
@@ skipping 62 matching lines @@
       return scoped_ptr<WebRequestActionSet>(NULL);
     result.push_back(make_linked_ptr(action.release()));
   }
 
   return scoped_ptr<WebRequestActionSet>(new WebRequestActionSet(result));
 }
 
 std::list<LinkedPtrEventResponseDelta> WebRequestActionSet::CreateDeltas(
     net::URLRequest* request,
     RequestStages request_stage,
+    const WebRequestRule::OptionalRequestData& optional_request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   std::list<LinkedPtrEventResponseDelta> result;
   for (Actions::const_iterator i = actions_.begin(); i != actions_.end(); ++i) {
     if ((*i)->GetStages() & request_stage) {
       LinkedPtrEventResponseDelta delta = (*i)->CreateDelta(request,
-          request_stage, extension_id, extension_install_time);
+          request_stage, optional_request_data, extension_id,
+          extension_install_time);
       if (delta.get())
         result.push_back(delta);
     }
   }
   return result;
 }
 
 int WebRequestActionSet::GetMinimumPriority() const {
   int minimum_priority = std::numeric_limits<int>::min();
   for (Actions::const_iterator i = actions_.begin(); i != actions_.end(); ++i) {
@@ skipping 15 matching lines @@
       ON_AUTH_REQUIRED;
 }
 
 WebRequestAction::Type WebRequestCancelAction::GetType() const {
   return WebRequestAction::ACTION_CANCEL_REQUEST;
 }
 
 LinkedPtrEventResponseDelta WebRequestCancelAction::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));
   result->cancel = true;
   return result;
 }
 
@@ skipping 10 matching lines @@
   return ON_BEFORE_REQUEST;
 }
 
 WebRequestAction::Type WebRequestRedirectAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_REQUEST;
 }
 
 LinkedPtrEventResponseDelta WebRequestRedirectAction::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());
   if (request->url() == redirect_url_)
     return LinkedPtrEventResponseDelta(NULL);
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->new_url = redirect_url_;
   return result;
@@ skipping 15 matching lines @@
 
 WebRequestAction::Type
 WebRequestRedirectToTransparentImageAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_TO_TRANSPARENT_IMAGE;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToTransparentImageAction::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));
   result->new_url = GURL(kTransparentImageUrl);
   return result;
 }
 
@@ skipping 13 matching lines @@
 
 WebRequestAction::Type
 WebRequestRedirectToEmptyDocumentAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_TO_EMPTY_DOCUMENT;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToEmptyDocumentAction::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));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
 }
 
@@ skipping 16 matching lines @@
 
 WebRequestAction::Type
 WebRequestSetRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_SET_REQUEST_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestSetRequestHeaderAction::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));
   result->modified_request_headers.SetHeader(name_, value_);
   return result;
 }
 
@@ skipping 14 matching lines @@
 
 WebRequestAction::Type
 WebRequestRemoveRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_REMOVE_REQUEST_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRemoveRequestHeaderAction::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));
   result->deleted_request_headers.push_back(name_);
   return result;
 }
 
 //
+// WebRequestAddResponseHeaderAction
+//
+
+WebRequestAddResponseHeaderAction::WebRequestAddResponseHeaderAction(
+    const std::string& name,
+    const std::string& value)
+    : name_(name),
+      value_(value) {
+}
+
+WebRequestAddResponseHeaderAction::~WebRequestAddResponseHeaderAction() {}
+
+int WebRequestAddResponseHeaderAction::GetStages() const {
+  return ON_HEADERS_RECEIVED;
+}
+
+WebRequestAction::Type
+WebRequestAddResponseHeaderAction::GetType() const {
+  return WebRequestAction::ACTION_ADD_RESPONSE_HEADER;
+}
+
+LinkedPtrEventResponseDelta
+WebRequestAddResponseHeaderAction::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));
+
+  net::HttpResponseHeaders* headers =
+      optional_request_data.original_response_headers;
+  if (!headers)
+    return result;
+
+  // Don't generate the header if it exists already.
+  if (headers->HasHeaderValue(name_, value_))
+    return result;
+
+  result->added_response_headers.push_back(make_pair(name_, value_));
+  return result;
+}
+
+//
+// WebRequestRemoveResponseHeaderAction
+//
+
+WebRequestRemoveResponseHeaderAction::WebRequestRemoveResponseHeaderAction(
+    const std::string& name,
+    const std::string& value,
+    bool has_value)
+    : name_(name),
+      value_(value),
+      has_value_(has_value) {
+}
+
+WebRequestRemoveResponseHeaderAction::~WebRequestRemoveResponseHeaderAction() {}
+
+int WebRequestRemoveResponseHeaderAction::GetStages() const {
+  return ON_HEADERS_RECEIVED;
+}
+
+WebRequestAction::Type
+WebRequestRemoveResponseHeaderAction::GetType() const {
+  return WebRequestAction::ACTION_REMOVE_RESPONSE_HEADER;
+}
+
+LinkedPtrEventResponseDelta
+WebRequestRemoveResponseHeaderAction::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));
+  net::HttpResponseHeaders* headers =
+      optional_request_data.original_response_headers;
+  if (!headers)
+    return result;
+  void* iter = NULL;
+  std::string current_value;
+  while (headers->EnumerateHeader(&iter, name_, &current_value)) {
+    if (has_value_ &&
+           (current_value.size() != value_.size() ||
+            !std::equal(current_value.begin(), current_value.end(),
+                        value_.begin(),
+                        base::CaseInsensitiveCompare<char>()))) {
+      continue;
+    }
+    result->deleted_response_headers.push_back(make_pair(name_, current_value));
+  }
+  return result;
+}
+
+//
 // WebRequestIgnoreRulesAction
 //
 
 WebRequestIgnoreRulesAction::WebRequestIgnoreRulesAction(
     int minimum_priority)
     : minimum_priority_(minimum_priority) {
 }
 
 WebRequestIgnoreRulesAction::~WebRequestIgnoreRulesAction() {}
 
 int WebRequestIgnoreRulesAction::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_HEADERS_RECEIVED |
       ON_AUTH_REQUIRED;
 }
 
 WebRequestAction::Type WebRequestIgnoreRulesAction::GetType() const {
   return WebRequestAction::ACTION_IGNORE_RULES;
 }
 
 int WebRequestIgnoreRulesAction::GetMinimumPriority() const {
   return minimum_priority_;
 }
 
 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);
 }
 
 }  // namespace extensions