Almost all actions in Declarative Web Request require all_urls host permissions

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"
@@ skipping 311 matching lines @@
 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 */);
+
+  typedef std::map<WebRequestAction::Type, const std::string> ActionNames;
+
   // Maps the name of a declarativeWebRequest action type to the factory
   // function creating it.
   std::map<std::string, FactoryMethod> factory_methods;
 
+  // Translates action types into the corresponding JavaScript names.
+  ActionNames action_names;
+
   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] =
@@ skipping 16 matching lines @@
     factory_methods[keys::kSetRequestHeaderType] =
         &CreateSetRequestHeaderAction;
     factory_methods[keys::kRemoveRequestHeaderType] =
         &CreateRemoveRequestHeaderAction;
     factory_methods[keys::kRemoveResponseHeaderType] =
         &CreateRemoveResponseHeaderAction;
     factory_methods[keys::kIgnoreRulesType] =
         &CreateIgnoreRulesAction;
     factory_methods[keys::kSendMessageToExtensionType] =
         &CreateSendMessageToExtensionAction;
+
+#define INSERT_ACTION_NAME(type, name) \
+    action_names.insert(ActionNames::value_type(type, name));
+    std::vector<std::string> names_buffer;
+    names_buffer.push_back(keys::kAddRequestCookieType);
+    names_buffer.push_back(keys::kEditRequestCookieType);
+    names_buffer.push_back(keys::kRemoveRequestCookieType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_MODIFY_REQUEST_COOKIE,
+                       JoinString(names_buffer, ", "));
+    names_buffer.clear();
+    names_buffer.push_back(keys::kAddResponseCookieType);
+    names_buffer.push_back(keys::kEditResponseCookieType);
+    names_buffer.push_back(keys::kRemoveResponseCookieType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_MODIFY_RESPONSE_COOKIE,
+                       JoinString(names_buffer, ", "));
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_ADD_RESPONSE_HEADER,
+                       keys::kAddResponseHeaderType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_CANCEL_REQUEST,
+                       keys::kCancelRequestType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REDIRECT_BY_REGEX_DOCUMENT,
+                       keys::kRedirectByRegExType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REDIRECT_REQUEST,
+                       keys::kRedirectRequestType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REDIRECT_TO_TRANSPARENT_IMAGE,
+                       keys::kRedirectToTransparentImageType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REDIRECT_TO_EMPTY_DOCUMENT,
+                       keys::kRedirectToEmptyDocumentType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_SET_REQUEST_HEADER,
+                       keys::kSetRequestHeaderType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REMOVE_REQUEST_HEADER,
+                       keys::kRemoveRequestHeaderType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_REMOVE_RESPONSE_HEADER,
+                       keys::kRemoveResponseHeaderType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_IGNORE_RULES,
+                       keys::kIgnoreRulesType);
+    INSERT_ACTION_NAME(WebRequestAction::ACTION_SEND_MESSAGE_TO_EXTENSION,
+                       keys::kSendMessageToExtensionType);
+#undef INSERT_ACTION_NAME
   }
 };
 
 base::LazyInstance<WebRequestActionFactory>::Leaky
     g_web_request_action_factory = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 //
 // WebRequestAction
 //
 
-WebRequestAction::WebRequestAction() {}
+WebRequestAction::~WebRequestAction() {}
 
-WebRequestAction::~WebRequestAction() {}
+const std::string& WebRequestAction::GetName() const {
+  const WebRequestActionFactory::ActionNames& names =
+      g_web_request_action_factory.Get().action_names;
+  std::map<WebRequestAction::Type, const std::string>::const_iterator it =
+      names.find(GetType());
+  CHECK(it != names.end());
+  return it->second;
+}
 
 int WebRequestAction::GetMinimumPriority() const {
   return std::numeric_limits<int>::min();
 }
 
-WebRequestAction::HostPermissionsStrategy
-WebRequestAction::GetHostPermissionsStrategy() const {
-  return STRATEGY_DEFAULT;
-}
-
 bool WebRequestAction::HasPermission(const ExtensionInfoMap* extension_info_map,
                                      const std::string& extension_id,
                                      const net::URLRequest* request,
                                      bool crosses_incognito) const {
   if (WebRequestPermissions::HideRequest(extension_info_map, request))
     return false;
 
   // In unit tests we don't have an extension_info_map object here and skip host
   // permission checks.
   if (!extension_info_map)
     return true;
 
-  HostPermissionsStrategy strategy = GetHostPermissionsStrategy();
-  if (strategy == STRATEGY_NONE || strategy == STRATEGY_DEFAULT) {
-    bool check_host_permissions = strategy != STRATEGY_NONE;
-    return WebRequestPermissions::CanExtensionAccessURL(
-        extension_info_map, extension_id, request->url(), crosses_incognito,
-        check_host_permissions);
+  WebRequestPermissions::HostPermissionsCheck permission_check =
+      WebRequestPermissions::REQUIRE_ALL_URLS;
+  switch (host_permissions_strategy()) {
+    case STRATEGY_DEFAULT:  // Default value is already set.
+      break;
+    case STRATEGY_NONE:
+      permission_check = WebRequestPermissions::DO_NOT_CHECK_HOST;
+      break;
+    case STRATEGY_HOST:
+      permission_check = WebRequestPermissions::REQUIRE_HOST_PERMISSION;
+      break;
   }
-  return true;
-}
-
-bool WebRequestAction::DeltaHasPermission(
-    const ExtensionInfoMap* extension_info_map,
-    const std::string& extension_id,
-    const net::URLRequest* request,
-    bool crosses_incognito,
-    const LinkedPtrEventResponseDelta& delta) const {
-  if (GetHostPermissionsStrategy() == STRATEGY_ALLOW_SAME_DOMAIN) {
-    return
-        net::RegistryControlledDomainService::SameDomainOrHost(
-            request->url(), delta->new_url) ||
-        WebRequestPermissions::CanExtensionAccessURL(
-            extension_info_map, extension_id, request->url(), crosses_incognito,
-            true);
-  }
-  return true;
+  return WebRequestPermissions::CanExtensionAccessURL(
+      extension_info_map, extension_id, request->url(), crosses_incognito,
+      permission_check);
 }
 
 // static
 scoped_ptr<WebRequestAction> WebRequestAction::Create(
     const base::Value& json_action,
     std::string* error,
     bool* bad_message) {
   *error = "";
   *bad_message = false;
 
@@ skipping 17 matching lines @@
 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);
-    }
+    if (delta.get())
+      apply_info->deltas->push_back(delta);
     if (GetType() == WebRequestAction::ACTION_IGNORE_RULES) {
       const WebRequestIgnoreRulesAction* ignore_action =
           static_cast<const WebRequestIgnoreRulesAction*>(this);
       if (!ignore_action->ignore_tag().empty())
         apply_info->ignored_tags->insert(ignore_action->ignore_tag());
     }
   }
 }
 
+WebRequestAction::WebRequestAction(HostPermissionsStrategy strategy)
+    : host_permissions_strategy_(strategy) {}
 
 //
 // WebRequestCancelAction
 //
 
-WebRequestCancelAction::WebRequestCancelAction() {}
+WebRequestCancelAction::WebRequestCancelAction()
+    : WebRequestAction(STRATEGY_NONE) {}
 
 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 WebRequestData& 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;
 }
 
 //
 // WebRequestRedirectAction
 //
 
 WebRequestRedirectAction::WebRequestRedirectAction(const GURL& redirect_url)
-    : redirect_url_(redirect_url) {}
+    : WebRequestAction(STRATEGY_DEFAULT), redirect_url_(redirect_url) {}
 
 WebRequestRedirectAction::~WebRequestRedirectAction() {}
 
 int WebRequestRedirectAction::GetStages() const {
   return ON_BEFORE_REQUEST;
 }
 
 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 WebRequestData& 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;
 }
 
 //
 // WebRequestRedirectToTransparentImageAction
 //
 
 WebRequestRedirectToTransparentImageAction::
-WebRequestRedirectToTransparentImageAction() {}
+    WebRequestRedirectToTransparentImageAction()
+    : WebRequestAction(STRATEGY_NONE) {}
 
 WebRequestRedirectToTransparentImageAction::
 ~WebRequestRedirectToTransparentImageAction() {}
 
 int WebRequestRedirectToTransparentImageAction::GetStages() const {
   return ON_BEFORE_REQUEST;
 }
 
 WebRequestAction::Type
 WebRequestRedirectToTransparentImageAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_TO_TRANSPARENT_IMAGE;
 }
 
-WebRequestAction::HostPermissionsStrategy
-WebRequestRedirectToTransparentImageAction::GetHostPermissionsStrategy() const {
-  return WebRequestAction::STRATEGY_NONE;
-}
-
 LinkedPtrEventResponseDelta
 WebRequestRedirectToTransparentImageAction::CreateDelta(
     const WebRequestData& 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;
 }
 
 //
 // WebRequestRedirectToEmptyDocumentAction
 //
 
 WebRequestRedirectToEmptyDocumentAction::
-WebRequestRedirectToEmptyDocumentAction() {}
+    WebRequestRedirectToEmptyDocumentAction()
+    : WebRequestAction(STRATEGY_NONE) {}
 
 WebRequestRedirectToEmptyDocumentAction::
 ~WebRequestRedirectToEmptyDocumentAction() {}
 
 int WebRequestRedirectToEmptyDocumentAction::GetStages() const {
   return ON_BEFORE_REQUEST;
 }
 
 WebRequestAction::Type
 WebRequestRedirectToEmptyDocumentAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_TO_EMPTY_DOCUMENT;
 }
 
-WebRequestAction::HostPermissionsStrategy
-WebRequestRedirectToEmptyDocumentAction::GetHostPermissionsStrategy() const {
-  return WebRequestAction::STRATEGY_NONE;
-}
-
 LinkedPtrEventResponseDelta
 WebRequestRedirectToEmptyDocumentAction::CreateDelta(
     const WebRequestData& 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;
 }
 
 //
 // WebRequestRedirectByRegExAction
 //
 
 WebRequestRedirectByRegExAction::WebRequestRedirectByRegExAction(
     scoped_ptr<RE2> from_pattern,
     const std::string& to_pattern)
-    : from_pattern_(from_pattern.Pass()),
+    : WebRequestAction(STRATEGY_DEFAULT),
+      from_pattern_(from_pattern.Pass()),
       to_pattern_(to_pattern.data(), to_pattern.size()) {}
 
 WebRequestRedirectByRegExAction::~WebRequestRedirectByRegExAction() {}
 
 // About the syntax of the two languages:
 //
 // ICU (Perl) states:
 // $n The text of capture group n will be substituted for $n. n must be >= 0
 //    and not greater than the number of capture groups. A $ not followed by a
 //    digit has no special meaning, and will appear in the substitution text
@@ skipping 45 matching lines @@
 }
 
 int WebRequestRedirectByRegExAction::GetStages() const {
   return ON_BEFORE_REQUEST;
 }
 
 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 WebRequestData& 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);
   }
 
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->new_url = GURL(new_url);
   return result;
 }
 
 //
 // WebRequestSetRequestHeaderAction
 //
 
 WebRequestSetRequestHeaderAction::WebRequestSetRequestHeaderAction(
     const std::string& name,
     const std::string& value)
-    : name_(name),
-      value_(value) {
-}
+    : WebRequestAction(STRATEGY_DEFAULT), name_(name), value_(value) {}
 
 WebRequestSetRequestHeaderAction::~WebRequestSetRequestHeaderAction() {}
 
 int WebRequestSetRequestHeaderAction::GetStages() const {
   return ON_BEFORE_SEND_HEADERS;
 }
 
 WebRequestAction::Type
 WebRequestSetRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_SET_REQUEST_HEADER;
@@ skipping 10 matching lines @@
   result->modified_request_headers.SetHeader(name_, value_);
   return result;
 }
 
 //
 // WebRequestRemoveRequestHeaderAction
 //
 
 WebRequestRemoveRequestHeaderAction::WebRequestRemoveRequestHeaderAction(
     const std::string& name)
-    : name_(name) {
-}
+    : WebRequestAction(STRATEGY_DEFAULT), name_(name) {}
 
 WebRequestRemoveRequestHeaderAction::~WebRequestRemoveRequestHeaderAction() {}
 
 int WebRequestRemoveRequestHeaderAction::GetStages() const {
   return ON_BEFORE_SEND_HEADERS;
 }
 
 WebRequestAction::Type
 WebRequestRemoveRequestHeaderAction::GetType() const {
   return WebRequestAction::ACTION_REMOVE_REQUEST_HEADER;
@@ skipping 11 matching lines @@
   return result;
 }
 
 //
 // WebRequestAddResponseHeaderAction
 //
 
 WebRequestAddResponseHeaderAction::WebRequestAddResponseHeaderAction(
     const std::string& name,
     const std::string& value)
-    : name_(name),
-      value_(value) {
-}
+    : WebRequestAction(STRATEGY_DEFAULT), 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;
@@ skipping 21 matching lines @@
 }
 
 //
 // WebRequestRemoveResponseHeaderAction
 //
 
 WebRequestRemoveResponseHeaderAction::WebRequestRemoveResponseHeaderAction(
     const std::string& name,
     const std::string& value,
     bool has_value)
-    : name_(name),
+    : WebRequestAction(STRATEGY_DEFAULT),
+      name_(name),
       value_(value),
-      has_value_(has_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;
@@ skipping 27 matching lines @@
   return result;
 }
 
 //
 // WebRequestIgnoreRulesAction
 //
 
 WebRequestIgnoreRulesAction::WebRequestIgnoreRulesAction(
     int minimum_priority,
     const std::string& ignore_tag)
-    : minimum_priority_(minimum_priority),
-      ignore_tag_(ignore_tag) {
-}
+    : WebRequestAction(STRATEGY_NONE),
+      minimum_priority_(minimum_priority),
+      ignore_tag_(ignore_tag) {}
 
 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_;
 }
 
-WebRequestAction::HostPermissionsStrategy
-WebRequestIgnoreRulesAction::GetHostPermissionsStrategy() const {
-  return WebRequestAction::STRATEGY_NONE;
-}
-
 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta(
     const WebRequestData& 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) {
+    : WebRequestAction(STRATEGY_DEFAULT),
+      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 {
@@ skipping 12 matching lines @@
       request_cookie_modification_);
   return result;
 }
 
 //
 // WebRequestResponseCookieAction
 //
 
 WebRequestResponseCookieAction::WebRequestResponseCookieAction(
     linked_ptr<ResponseCookieModification> response_cookie_modification)
-    : response_cookie_modification_(response_cookie_modification) {
+    : WebRequestAction(STRATEGY_DEFAULT),
+      response_cookie_modification_(response_cookie_modification) {
   CHECK(response_cookie_modification_.get());
 }
 
 WebRequestResponseCookieAction::~WebRequestResponseCookieAction() {}
 
 int WebRequestResponseCookieAction::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 WebRequestAction::Type WebRequestResponseCookieAction::GetType() const {
@@ skipping 12 matching lines @@
       response_cookie_modification_);
   return result;
 }
 
 //
 // WebRequestSendMessageToExtensionAction
 //
 
 WebRequestSendMessageToExtensionAction::WebRequestSendMessageToExtensionAction(
     const std::string& message)
-    : message_(message) {
-}
+    : WebRequestAction(STRATEGY_HOST), message_(message) {}
 
 WebRequestSendMessageToExtensionAction::
 ~WebRequestSendMessageToExtensionAction() {}
 
 int WebRequestSendMessageToExtensionAction::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_HEADERS_RECEIVED |
       ON_AUTH_REQUIRED;
 }
 
 WebRequestAction::Type WebRequestSendMessageToExtensionAction::GetType() const {
   return WebRequestAction::ACTION_SEND_MESSAGE_TO_EXTENSION;
 }
 
 LinkedPtrEventResponseDelta WebRequestSendMessageToExtensionAction::CreateDelta(
     const WebRequestData& 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->messages_to_extension.insert(message_);
   return result;
 }
 
 }  // namespace extensions