Create DeclarativeConditionSet, DeclarativeActionSet, and DeclarativeRule templates

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_stage.h"
+#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_permissions.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/url_request/url_request.h"
 #include "third_party/re2/re2/re2.h"
 
@@ skipping 396 matching lines @@
   WebRequestActionFactory& factory = g_web_request_action_factory.Get();
   std::map<std::string, WebRequestActionFactory::FactoryMethod>::iterator
       factory_method_iter = factory.factory_methods.find(instance_type);
   if (factory_method_iter != factory.factory_methods.end())
     return (*factory_method_iter->second)(action_dict, error, bad_message);
 
   *error = base::StringPrintf(kInvalidInstanceTypeError, instance_type.c_str());
   return scoped_ptr<WebRequestAction>();
 }
 
+void WebRequestAction::Apply(const std::string& extension_id,
+                             base::Time extension_install_time,
+                             ApplyInfo* apply_info) const {
+  if (!HasPermission(apply_info->extension_info_map, extension_id,
+                     apply_info->request_data.request,
+                     apply_info->crosses_incognito))
+    return;
+  if (GetStages() & apply_info->request_data.stage) {
+    LinkedPtrEventResponseDelta delta = CreateDelta(
+        apply_info->request_data, extension_id,
+        extension_install_time);
+    if (delta.get()) {
+      if (DeltaHasPermission(apply_info->extension_info_map, extension_id,
+                             apply_info->request_data.request,
+                             apply_info->crosses_incognito,
+                             delta))
+        apply_info->deltas->push_back(delta);
+    }
+  }
+}
+
 
 //
-// WebRequestActionSet
-//
-
-WebRequestActionSet::WebRequestActionSet(const Actions& actions)
-    : actions_(actions) {}
-
-WebRequestActionSet::~WebRequestActionSet() {}
-
-// static
-scoped_ptr<WebRequestActionSet> WebRequestActionSet::Create(
-    const AnyVector& actions,
-    std::string* error,
-    bool* bad_message) {
-  *error = "";
-  *bad_message = false;
-  Actions result;
-
-  for (AnyVector::const_iterator i = actions.begin();
-       i != actions.end(); ++i) {
-    CHECK(i->get());
-    scoped_ptr<WebRequestAction> action =
-        WebRequestAction::Create((*i)->value(), error, bad_message);
-    if (!error->empty() || *bad_message)
-      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(
-    const ExtensionInfoMap* extension_info_map,
-    const std::string& extension_id,
-    const WebRequestRule::RequestData& request_data,
-    bool crosses_incognito,
-    const base::Time& extension_install_time) const {
-  std::list<LinkedPtrEventResponseDelta> result;
-  for (Actions::const_iterator i = actions_.begin(); i != actions_.end(); ++i) {
-    if (!(*i)->HasPermission(extension_info_map, extension_id,
-                             request_data.request, crosses_incognito))
-      continue;
-    if ((*i)->GetStages() & request_data.stage) {
-      LinkedPtrEventResponseDelta delta = (*i)->CreateDelta(
-          request_data, extension_id, extension_install_time);
-      if (delta.get()) {
-        if ((*i)->DeltaHasPermission(extension_info_map, extension_id,
-                                     request_data.request, crosses_incognito,
-                                     delta))
-          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) {
-    minimum_priority = std::max(minimum_priority, (*i)->GetMinimumPriority());
-  }
-  return minimum_priority;
-}
-
-//
 // WebRequestCancelAction
 //
 
 WebRequestCancelAction::WebRequestCancelAction() {}
 
 WebRequestCancelAction::~WebRequestCancelAction() {}
 
 int WebRequestCancelAction::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_HEADERS_RECEIVED |
       ON_AUTH_REQUIRED;
 }
 
 WebRequestAction::Type WebRequestCancelAction::GetType() const {
   return WebRequestAction::ACTION_CANCEL_REQUEST;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestCancelAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_NONE;
 }
 
 LinkedPtrEventResponseDelta WebRequestCancelAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->cancel = true;
   return result;
 }
 
 //
@@ skipping 12 matching lines @@
 WebRequestAction::Type WebRequestRedirectAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_REQUEST;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestRedirectAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_ALLOW_SAME_DOMAIN;
 }
 
 LinkedPtrEventResponseDelta WebRequestRedirectAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   if (request_data.request->url() == redirect_url_)
     return LinkedPtrEventResponseDelta(NULL);
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = redirect_url_;
   return result;
 }
@@ skipping 17 matching lines @@
   return WebRequestAction::ACTION_REDIRECT_TO_TRANSPARENT_IMAGE;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestRedirectToTransparentImageAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_NONE;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToTransparentImageAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kTransparentImageUrl);
   return result;
 }
 
 //
@@ skipping 15 matching lines @@
   return WebRequestAction::ACTION_REDIRECT_TO_EMPTY_DOCUMENT;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestRedirectToEmptyDocumentAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_NONE;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToEmptyDocumentAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
 }
 
 //
@@ skipping 68 matching lines @@
 WebRequestAction::Type WebRequestRedirectByRegExAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_BY_REGEX_DOCUMENT;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestRedirectByRegExAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_ALLOW_SAME_DOMAIN;
 }
 
 LinkedPtrEventResponseDelta WebRequestRedirectByRegExAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   CHECK(from_pattern_.get());
 
   const std::string& old_url = request_data.request->url().spec();
   std::string new_url = old_url;
   if (!RE2::Replace(&new_url, *from_pattern_, to_pattern_) ||
       new_url == old_url) {
     return LinkedPtrEventResponseDelta(NULL);
@@ skipping 23 matching lines @@
   return ON_BEFORE_SEND_HEADERS;
 }
 
 WebRequestAction::Type
 WebRequestSetRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_SET_REQUEST_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestSetRequestHeaderAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->modified_request_headers.SetHeader(name_, value_);
   return result;
 }
 
 //
@@ skipping 11 matching lines @@
   return ON_BEFORE_SEND_HEADERS;
 }
 
 WebRequestAction::Type
 WebRequestRemoveRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_REMOVE_REQUEST_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRemoveRequestHeaderAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->deleted_request_headers.push_back(name_);
   return result;
 }
 
 //
@@ skipping 13 matching lines @@
   return ON_HEADERS_RECEIVED;
 }
 
 WebRequestAction::Type
 WebRequestAddResponseHeaderAction::GetType() const {
   return WebRequestAction::ACTION_ADD_RESPONSE_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestAddResponseHeaderAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
   if (!headers)
     return LinkedPtrEventResponseDelta(NULL);
 
   // Don't generate the header if it exists already.
   if (headers->HasHeaderValue(name_, value_))
@@ skipping 24 matching lines @@
   return ON_HEADERS_RECEIVED;
 }
 
 WebRequestAction::Type
 WebRequestRemoveResponseHeaderAction::GetType() const {
   return WebRequestAction::ACTION_REMOVE_RESPONSE_HEADER;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRemoveResponseHeaderAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
   if (!headers)
     return LinkedPtrEventResponseDelta(NULL);
 
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
@@ skipping 35 matching lines @@
 int WebRequestIgnoreRulesAction::GetMinimumPriority() const {
   return minimum_priority_;
 }
 
 WebRequestAction::HostPermissionsStrategy
 WebRequestIgnoreRulesAction::GetHostPermissionsStrategy() const {
   return WebRequestAction::STRATEGY_NONE;
 }
 
 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   return LinkedPtrEventResponseDelta(NULL);
 }
 
 //
 // WebRequestRequestCookieAction
 //
 
 WebRequestRequestCookieAction::WebRequestRequestCookieAction(
     linked_ptr<RequestCookieModification> request_cookie_modification)
     : request_cookie_modification_(request_cookie_modification) {
   CHECK(request_cookie_modification_.get());
 }
 
 WebRequestRequestCookieAction::~WebRequestRequestCookieAction() {}
 
 int WebRequestRequestCookieAction::GetStages() const {
   return ON_BEFORE_SEND_HEADERS;
 }
 
 WebRequestAction::Type WebRequestRequestCookieAction::GetType() const {
   return WebRequestAction::ACTION_MODIFY_REQUEST_COOKIE;
 }
 
 LinkedPtrEventResponseDelta WebRequestRequestCookieAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->request_cookie_modifications.push_back(
       request_cookie_modification_);
   return result;
 }
@@ skipping 12 matching lines @@
 
 int WebRequestResponseCookieAction::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 WebRequestAction::Type WebRequestResponseCookieAction::GetType() const {
   return WebRequestAction::ACTION_MODIFY_RESPONSE_COOKIE;
 }
 
 LinkedPtrEventResponseDelta WebRequestResponseCookieAction::CreateDelta(
-    const WebRequestRule::RequestData& request_data,
+    const DeclarativeWebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->response_cookie_modifications.push_back(
       response_cookie_modification_);
   return result;
 }
 
 }  // namespace extensions