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;
+  bool use_perl_capture_group_style = false;
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kFromKey, &from));
+  INPUT_FORMAT_VALIDATE(dict->GetString(keys::kToKey, &to));
+  if (dict->HasKey(keys::kPerlCaptureGroupStyleKey)) {
+    INPUT_FORMAT_VALIDATE(dict->GetBoolean(keys::kPerlCaptureGroupStyleKey,
+                                           &use_perl_capture_group_style));
+  }
+
+  // TODO(battre): Invert this once we use RE2.
+  if (!use_perl_capture_group_style)
+    to = WebRequestRedirectByRegExAction::Re2ToPerlStyle(to);
+
+  UParseError parse_error;
+  UErrorCode status = U_ZERO_ERROR;
+  scoped_ptr<icu::RegexPattern> pattern(
+      icu::RegexPattern::compile(icu::UnicodeString(from.data(), from.size()),
+                                 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.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
+//    as itself, a $.
+// \  Treat the following character as a literal, suppressing any special
+//    meaning. Backslash escaping in substitution text is only required for
+//    '$' and '\', but may be used on any other character without bad effects.
+//
+// RE2, derived from RE2::Rewrite()
+// \  May only be followed by a digit or another \. If followed by a single
+//    digit, both characters represent the respective capture group. If followed
+//    by another \, it is used as an escape sequence.
+
+// static
+std::string WebRequestRedirectByRegExAction::PerlToRe2Style(
+    const std::string& perl) {
+  std::string::const_iterator i = perl.begin();
+  std::string result;
+  while (i != perl.end()) {
+    if (*i == '$') {
+      ++i;
+      if (i == perl.end()) {
+        result += '$';
+      } else if (isdigit(*i)) {
+        result += '\\';
+        result += *i;
+      } else {
+        result += '$';
+        result += *i;
+      }
+    } else if (*i == '\\') {
+      ++i;
+      if (i == perl.end()) {
+        result += '\\';
+      } else if (*i == '$'){
+        result += '$';
+      } else if (*i == '\\'){
+        result += "\\\\";
+      } else {
+        result += *i;
+      }
+    } else {
+      result += *i;
+    }
+    ++i;
+  }
+  return result;
+}
+
+// static
+std::string WebRequestRedirectByRegExAction::Re2ToPerlStyle(
+    const std::string& re2) {
+  std::string::const_iterator i = re2.begin();
+  std::string result;
+  while (i != re2.end()) {
+    if (*i == '\\') {
+      ++i;
+      if (i == re2.end()) {
+        result += '\\';  // Illegal, treat as best effort.
+      } else if (isdigit(*i)) {
+        result += '$';
+        result += *i;
+      } else if (*i == '\\') {
+        result += "\\\\";
+      } else {  // Illegal, treat as best effort.
+        result += '\\';
+        result += *i;
+      }
+    } else {
+      result += *i;
+    }
+    ++i;
+  }
+  return result;
+}
+
+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.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())
+    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