Make WebRequestAction::GetName a pure virtual function

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 328 matching lines @@
     bool* bad_message) {
   const base::DictionaryValue* dict = NULL;
   CHECK(value->GetAsDictionary(&dict));
   std::string message;
   INPUT_FORMAT_VALIDATE(dict->GetString(keys::kMessageKey, &message));
   return scoped_refptr<const WebRequestAction>(
       new WebRequestSendMessageToExtensionAction(message));
 }
 
 struct WebRequestActionFactory {
-  typedef std::map<WebRequestAction::Type, const std::string> ActionNames;
-
   DedupingFactory<WebRequestAction> factory;
 
-  // Translates action types into the corresponding JavaScript names.
-  ActionNames action_names;
-
   WebRequestActionFactory() : factory(5) {
     factory.RegisterFactoryMethod(
         keys::kAddRequestCookieType,
         DedupingFactory<WebRequestAction>::IS_PARAMETERIZED,
         &CreateRequestCookieAction);
     factory.RegisterFactoryMethod(
         keys::kAddResponseCookieType,
         DedupingFactory<WebRequestAction>::IS_PARAMETERIZED,
         &CreateResponseCookieAction);
     factory.RegisterFactoryMethod(
@@ skipping 50 matching lines @@
         DedupingFactory<WebRequestAction>::IS_PARAMETERIZED,
         &CreateRemoveResponseHeaderAction);
     factory.RegisterFactoryMethod(
         keys::kIgnoreRulesType,
         DedupingFactory<WebRequestAction>::IS_PARAMETERIZED,
         &CreateIgnoreRulesAction);
     factory.RegisterFactoryMethod(
         keys::kSendMessageToExtensionType,
         DedupingFactory<WebRequestAction>::IS_PARAMETERIZED,
         &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() {}
 
 bool WebRequestAction::Equals(const WebRequestAction* other) const {
   return type() == other->type();
 }
 
-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(type());
-  CHECK(it != names.end());
-  return it->second;
-}
-
 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)
@@ skipping 72 matching lines @@
 
 WebRequestCancelAction::WebRequestCancelAction()
     : WebRequestAction(ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS |
                            ON_HEADERS_RECEIVED | ON_AUTH_REQUIRED,
                        ACTION_CANCEL_REQUEST,
                        std::numeric_limits<int>::min(),
                        STRATEGY_NONE) {}
 
 WebRequestCancelAction::~WebRequestCancelAction() {}
 
+std::string WebRequestCancelAction::GetName() const {
+  return keys::kCancelRequestType;
+}
+
 LinkedPtrEventResponseDelta WebRequestCancelAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->cancel = true;
   return result;
 }
@@ skipping 10 matching lines @@
       redirect_url_(redirect_url) {}
 
 WebRequestRedirectAction::~WebRequestRedirectAction() {}
 
 bool WebRequestRedirectAction::Equals(const WebRequestAction* other) const {
   return WebRequestAction::Equals(other) &&
          redirect_url_ ==
              static_cast<const WebRequestRedirectAction*>(other)->redirect_url_;
 }
 
+std::string WebRequestRedirectAction::GetName() const {
+  return keys::kRedirectRequestType;
+}
+
 LinkedPtrEventResponseDelta WebRequestRedirectAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   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()
     : WebRequestAction(ON_BEFORE_REQUEST,
                        ACTION_REDIRECT_TO_TRANSPARENT_IMAGE,
                        std::numeric_limits<int>::min(),
                        STRATEGY_NONE) {}
 
 WebRequestRedirectToTransparentImageAction::
 ~WebRequestRedirectToTransparentImageAction() {}
 
+std::string WebRequestRedirectToTransparentImageAction::GetName() const {
+  return keys::kRedirectToTransparentImageType;
+}
+
 LinkedPtrEventResponseDelta
 WebRequestRedirectToTransparentImageAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kTransparentImageUrl);
   return result;
 }
 
 //
 // WebRequestRedirectToEmptyDocumentAction
 //
 
 WebRequestRedirectToEmptyDocumentAction::
     WebRequestRedirectToEmptyDocumentAction()
     : WebRequestAction(ON_BEFORE_REQUEST,
                        ACTION_REDIRECT_TO_EMPTY_DOCUMENT,
                        std::numeric_limits<int>::min(),
                        STRATEGY_NONE) {}
 
 WebRequestRedirectToEmptyDocumentAction::
 ~WebRequestRedirectToEmptyDocumentAction() {}
 
+std::string WebRequestRedirectToEmptyDocumentAction::GetName() const {
+  return keys::kRedirectToEmptyDocumentType;
+}
+
 LinkedPtrEventResponseDelta
 WebRequestRedirectToEmptyDocumentAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
@@ skipping 71 matching lines @@
 bool WebRequestRedirectByRegExAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestRedirectByRegExAction* casted_other =
       static_cast<const WebRequestRedirectByRegExAction*>(other);
   return from_pattern_->pattern() == casted_other->from_pattern_->pattern() &&
          to_pattern_ == casted_other->to_pattern_;
 }
 
+std::string WebRequestRedirectByRegExAction::GetName() const {
+  return keys::kRedirectByRegExType;
+}
+
 LinkedPtrEventResponseDelta WebRequestRedirectByRegExAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   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_) ||
@@ skipping 26 matching lines @@
 
 bool WebRequestSetRequestHeaderAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestSetRequestHeaderAction* casted_other =
       static_cast<const WebRequestSetRequestHeaderAction*>(other);
   return name_ == casted_other->name_ && value_ == casted_other->value_;
 }
 
+std::string WebRequestSetRequestHeaderAction::GetName() const {
+  return keys::kSetRequestHeaderType;
+}
+
+
 LinkedPtrEventResponseDelta
 WebRequestSetRequestHeaderAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->modified_request_headers.SetHeader(name_, value_);
   return result;
@@ skipping 15 matching lines @@
 
 bool WebRequestRemoveRequestHeaderAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestRemoveRequestHeaderAction* casted_other =
       static_cast<const WebRequestRemoveRequestHeaderAction*>(other);
   return name_ == casted_other->name_;
 }
 
+std::string WebRequestRemoveRequestHeaderAction::GetName() const {
+  return keys::kRemoveRequestHeaderType;
+}
+
 LinkedPtrEventResponseDelta
 WebRequestRemoveRequestHeaderAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->deleted_request_headers.push_back(name_);
   return result;
@@ skipping 17 matching lines @@
 
 bool WebRequestAddResponseHeaderAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestAddResponseHeaderAction* casted_other =
       static_cast<const WebRequestAddResponseHeaderAction*>(other);
   return name_ == casted_other->name_ && value_ == casted_other->value_;
 }
 
+std::string WebRequestAddResponseHeaderAction::GetName() const {
+  return keys::kAddResponseHeaderType;
+}
+
 LinkedPtrEventResponseDelta
 WebRequestAddResponseHeaderAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
   if (!headers)
     return LinkedPtrEventResponseDelta(NULL);
@@ skipping 29 matching lines @@
 bool WebRequestRemoveResponseHeaderAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestRemoveResponseHeaderAction* casted_other =
       static_cast<const WebRequestRemoveResponseHeaderAction*>(other);
   return name_ == casted_other->name_ && value_ == casted_other->value_ &&
          has_value_ == casted_other->has_value_;
 }
 
+std::string WebRequestRemoveResponseHeaderAction::GetName() const {
+  return keys::kRemoveResponseHeaderType;
+}
+
 LinkedPtrEventResponseDelta
 WebRequestRemoveResponseHeaderAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
   if (!headers)
     return LinkedPtrEventResponseDelta(NULL);
@@ skipping 33 matching lines @@
 
 bool WebRequestIgnoreRulesAction::Equals(const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestIgnoreRulesAction* casted_other =
       static_cast<const WebRequestIgnoreRulesAction*>(other);
   return minimum_priority() == casted_other->minimum_priority() &&
          ignore_tag_ == casted_other->ignore_tag_;
 }
 
+std::string WebRequestIgnoreRulesAction::GetName() const {
+  return keys::kIgnoreRulesType;
+}
+
 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   return LinkedPtrEventResponseDelta(NULL);
 }
 
 //
 // WebRequestRequestCookieAction
@@ skipping 15 matching lines @@
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestRequestCookieAction* casted_other =
       static_cast<const WebRequestRequestCookieAction*>(other);
   return helpers::NullableEquals(
       request_cookie_modification_.get(),
       casted_other->request_cookie_modification_.get());
 }
 
+std::string WebRequestRequestCookieAction::GetName() const {
+  switch (request_cookie_modification_->type) {
+    case helpers::ADD:
+      return keys::kAddRequestCookieType;
+    case helpers::EDIT:
+      return keys::kEditRequestCookieType;
+    case helpers::REMOVE:
+      return keys::kRemoveRequestCookieType;
+  }
+  NOTREACHED();
+  return "";
+}
+
 LinkedPtrEventResponseDelta WebRequestRequestCookieAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->request_cookie_modifications.push_back(
       request_cookie_modification_);
@@ skipping 20 matching lines @@
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestResponseCookieAction* casted_other =
       static_cast<const WebRequestResponseCookieAction*>(other);
   return helpers::NullableEquals(
       response_cookie_modification_.get(),
       casted_other->response_cookie_modification_.get());
 }
 
+std::string WebRequestResponseCookieAction::GetName() const {
+  switch (response_cookie_modification_->type) {
+    case helpers::ADD:
+      return keys::kAddResponseCookieType;
+    case helpers::EDIT:
+      return keys::kEditResponseCookieType;
+    case helpers::REMOVE:
+      return keys::kRemoveResponseCookieType;
+  }
+  NOTREACHED();
+  return "";
+}
+
 LinkedPtrEventResponseDelta WebRequestResponseCookieAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->response_cookie_modifications.push_back(
       response_cookie_modification_);
@@ skipping 18 matching lines @@
 
 bool WebRequestSendMessageToExtensionAction::Equals(
     const WebRequestAction* other) const {
   if (!WebRequestAction::Equals(other))
     return false;
   const WebRequestSendMessageToExtensionAction* casted_other =
       static_cast<const WebRequestSendMessageToExtensionAction*>(other);
   return message_ == casted_other->message_;
 }
 
+std::string WebRequestSendMessageToExtensionAction::GetName() const {
+  return keys::kSendMessageToExtensionType;
+}
+
 LinkedPtrEventResponseDelta WebRequestSendMessageToExtensionAction::CreateDelta(
     const WebRequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & stages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->messages_to_extension.insert(message_);
   return result;
 }
 
 }  // namespace extensions