Support redirects by regular expression 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/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/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 28 matching lines @@
     std::string* error,
     bool* bad_message) {
   std::string redirect_url_string;
   INPUT_FORMAT_VALIDATE(
       dict->GetString(keys::kRedirectUrlKey, &redirect_url_string));
   GURL redirect_url(redirect_url_string);
   return scoped_ptr<WebRequestAction>(
       new WebRequestRedirectAction(redirect_url));
 }
 
+scoped_ptr<WebRequestAction> CreateRedirectRequestByRegExAction(
+    const base::DictionaryValue* dict,
+    std::string* error,
+    bool* bad_message) {
+  std::string from;
+  std::string to;
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kFromKey, &from));
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kToKey, &to));
+
+  UParseError parse_error;
+  UErrorCode status = U_ZERO_ERROR;
+  scoped_ptr<icu::RegexPattern> pattern(
+      icu::RegexPattern::compile(icu::UnicodeString(from.c_str(), from.size()),

[Matt Perry, 2012/05/30 18:55:50]

I thought the consensus on the thread was to evaluate the regex in the
originating renderer?

[battre, 2012/05/31 16:01:32]

As discussed, we will change this to RE2 before releasing this API into the beta
branch and consider RE2 sufficiently safe for execution in the browser.

+                                 0, parse_error, status));
+  if (U_FAILURE(status) || !pattern.get()) {
+    *error = "Invalid pattern '" + from + "' -> '" + to + "'";
+    return scoped_ptr<WebRequestAction>(NULL);
+  }
+  return scoped_ptr<WebRequestAction>(
+      new WebRequestRedirectByRegExAction(pattern.Pass(), to));
+}
+
 scoped_ptr<WebRequestAction> CreateSetRequestHeaderAction(
     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 WebRequestSetRequestHeaderAction(name, value));
@@ skipping 54 matching lines @@
       (* 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::kRedirectByRegExType] =
+        &CreateRedirectRequestByRegExAction;
     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] =
@@ skipping 232 matching lines @@
     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;
 }
 
 //
+// WebRequestRedirectByRegExAction
+//
+
+WebRequestRedirectByRegExAction::WebRequestRedirectByRegExAction(
+    scoped_ptr<icu::RegexPattern> from_pattern,
+    const std::string& to_pattern)
+    : from_pattern_(from_pattern.Pass()),
+      to_pattern_(to_pattern.c_str(), to_pattern.size()) {}

[Matt Perry, 2012/05/30 19:18:26]

nit: prefer data() instead of c_str() when you're passing a size, since c_str()
might end up reallocating the string to add a null terminator.

[battre, 2012/05/31 16:01:32]

Done.

+
+WebRequestRedirectByRegExAction::~WebRequestRedirectByRegExAction() {}
+
+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 std::string& extension_id,
+    const base::Time& extension_install_time) const {
+  CHECK(request_stage & GetStages());
+  CHECK(from_pattern_.get());
+
+  UErrorCode status = U_ZERO_ERROR;
+  const std::string& old_url = request->url().spec();
+  icu::UnicodeString old_url_unicode(old_url.c_str(), 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())
+    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;
+}
+
+//
 // WebRequestSetRequestHeaderAction
 //
 
 WebRequestSetRequestHeaderAction::WebRequestSetRequestHeaderAction(
     const std::string& name,
     const std::string& value)
     : name_(name),
       value_(value) {
 }
 
@@ skipping 81 matching lines @@
 }
 
 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());
+  net::HttpResponseHeaders* headers =
+      optional_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 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,
@@ skipping 16 matching lines @@
 }
 
 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());
+  net::HttpResponseHeaders* headers =
+      optional_request_data.original_response_headers;
+  if (!headers)
+    return LinkedPtrEventResponseDelta(NULL);
+
   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;
     }
@@ skipping 30 matching lines @@
     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