Refactor request parameters into RequestData struct. Also make RequestStage singular.

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/request_stage.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 "net/url_request/url_request.h"
 
 namespace extensions {
 
 namespace helpers = extension_web_request_api_helpers;
@@ skipping 247 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(
     const ExtensionInfoMap* extension_info_map,
     const std::string& extension_id,
-    net::URLRequest* request,
+    const WebRequestRule::RequestData& request_data,
     bool crosses_incognito,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
     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,
-                             crosses_incognito))
+    if (!(*i)->HasPermission(extension_info_map, extension_id,
+                             request_data.request, crosses_incognito))
       continue;
-    if ((*i)->GetStages() & request_stage) {
-      LinkedPtrEventResponseDelta delta = (*i)->CreateDelta(request,
-          request_stage, optional_request_data, extension_id,
-          extension_install_time);
+    if ((*i)->GetStages() & request_data.stage) {
+      LinkedPtrEventResponseDelta delta = (*i)->CreateDelta(
+          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 13 matching lines @@
 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;
 }
 
 LinkedPtrEventResponseDelta WebRequestCancelAction::CreateDelta(
-    net::URLRequest* request,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  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) {}
 
 WebRequestRedirectAction::~WebRequestRedirectAction() {}
 
 int WebRequestRedirectAction::GetStages() const {
   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 WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
-  if (request->url() == redirect_url_)
+  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
 //
@@ skipping 13 matching lines @@
   return WebRequestAction::ACTION_REDIRECT_TO_TRANSPARENT_IMAGE;
 }
 
 bool WebRequestRedirectToTransparentImageAction::ShouldEnforceHostPermissions()
     const {
   return false;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToTransparentImageAction::CreateDelta(
-    net::URLRequest* request,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kTransparentImageUrl);
   return result;
 }
 
 //
 // WebRequestRedirectToEmptyDocumentAction
 //
 
@@ skipping 12 matching lines @@
   return WebRequestAction::ACTION_REDIRECT_TO_EMPTY_DOCUMENT;
 }
 
 bool
 WebRequestRedirectToEmptyDocumentAction::ShouldEnforceHostPermissions() const {
   return false;
 }
 
 LinkedPtrEventResponseDelta
 WebRequestRedirectToEmptyDocumentAction::CreateDelta(
-    net::URLRequest* request,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
 }
 
 //
 // WebRequestRedirectByRegExAction
 //
 
@@ skipping 60 matching lines @@
 
 int WebRequestRedirectByRegExAction::GetStages() const {
   return ON_BEFORE_REQUEST;
 }
 
 WebRequestAction::Type WebRequestRedirectByRegExAction::GetType() const {
   return WebRequestAction::ACTION_REDIRECT_BY_REGEX_DOCUMENT;
 }
 
 LinkedPtrEventResponseDelta WebRequestRedirectByRegExAction::CreateDelta(
-    net::URLRequest* request,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   CHECK(from_pattern_.get());
 
   UErrorCode status = U_ZERO_ERROR;
-  const std::string& old_url = request->url().spec();
+  const std::string& old_url = request_data.request->url().spec();
   icu::UnicodeString old_url_unicode(old_url.data(), old_url.size());
 
   scoped_ptr<icu::RegexMatcher> matcher(
       from_pattern_->matcher(old_url_unicode, status));
   if (U_FAILURE(status) || !matcher.get())
     return LinkedPtrEventResponseDelta(NULL);
 
   icu::UnicodeString new_url = matcher->replaceAll(to_pattern_, status);
   if (U_FAILURE(status))
     return LinkedPtrEventResponseDelta(NULL);
 
   std::string new_url_utf8;
   UTF16ToUTF8(new_url.getBuffer(), new_url.length(), &new_url_utf8);
 
-  if (new_url_utf8 == request->url().spec())
+  if (new_url_utf8 == request_data.request->url().spec())
     return LinkedPtrEventResponseDelta(NULL);
 
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->new_url = GURL(new_url_utf8);
   return result;
 }
 
 //
@@ skipping 13 matching lines @@
   return ON_BEFORE_SEND_HEADERS;
 }
 
 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 WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->modified_request_headers.SetHeader(name_, value_);
   return result;
 }
 
 //
 // WebRequestRemoveRequestHeaderAction
 //
 
 WebRequestRemoveRequestHeaderAction::WebRequestRemoveRequestHeaderAction(
     const std::string& name)
     : name_(name) {
 }
 
 WebRequestRemoveRequestHeaderAction::~WebRequestRemoveRequestHeaderAction() {}
 
 int WebRequestRemoveRequestHeaderAction::GetStages() const {
   return ON_BEFORE_SEND_HEADERS;
 }
 
 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 WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->deleted_request_headers.push_back(name_);
   return result;
 }
 
 //
 // WebRequestAddResponseHeaderAction
 //
 
@@ skipping 10 matching lines @@
   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 WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   net::HttpResponseHeaders* headers =
-      optional_request_data.original_response_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_))
     return LinkedPtrEventResponseDelta(NULL);
 
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->added_response_headers.push_back(make_pair(name_, value_));
@@ skipping 19 matching lines @@
   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 WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   net::HttpResponseHeaders* headers =
-      optional_request_data.original_response_headers;
+      request_data.original_response_headers;
   if (!headers)
     return LinkedPtrEventResponseDelta(NULL);
 
   LinkedPtrEventResponseDelta result(
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   void* iter = NULL;
   std::string current_value;
   while (headers->EnumerateHeader(&iter, name_, &current_value)) {
     if (has_value_ &&
            (current_value.size() != value_.size() ||
@@ skipping 29 matching lines @@
 
 int WebRequestIgnoreRulesAction::GetMinimumPriority() const {
   return minimum_priority_;
 }
 
 bool WebRequestIgnoreRulesAction::ShouldEnforceHostPermissions() const {
   return false;
 }
 
 LinkedPtrEventResponseDelta WebRequestIgnoreRulesAction::CreateDelta(
-    net::URLRequest* request,
-    RequestStages request_stage,
-    const WebRequestRule::OptionalRequestData& optional_request_data,
+    const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
-  CHECK(request_stage & GetStages());
+  CHECK(request_data.stage & GetStages());
   return LinkedPtrEventResponseDelta(NULL);
 }
 
 }  // namespace extensions