Migrate WebRequestRedirectByRegExAction to use RE2 and roll RE2 to revision 97:401ab4168e8e

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_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"
+#include "third_party/re2/re2/re2.h"
 
 namespace extensions {
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = declarative_webrequest_constants;
 
 namespace {
 // Error messages.
 const char kInvalidInstanceTypeError[] =
     "An action has an invalid instanceType: %s";
@@ skipping 69 matching lines @@
 
 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));
 
-  // TODO(battre): Add this line once we migrate from ICU RegEx to RE2 RegEx.s
-  // to = WebRequestRedirectByRegExAction::PerlToRe2Style(to);
+  to = WebRequestRedirectByRegExAction::PerlToRe2Style(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()) {
+  RE2::Options options;
+  options.set_case_sensitive(false);
+  scoped_ptr<RE2> from_pattern(new RE2(from, options));
+
+  if (!from_pattern->ok()) {
     *error = "Invalid pattern '" + from + "' -> '" + to + "'";
     return scoped_ptr<WebRequestAction>(NULL);
   }
   return scoped_ptr<WebRequestAction>(
-      new WebRequestRedirectByRegExAction(pattern.Pass(), to));
+      new WebRequestRedirectByRegExAction(from_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));
@@ skipping 437 matching lines @@
       new helpers::EventResponseDelta(extension_id, extension_install_time));
   result->new_url = GURL(kEmptyDocumentUrl);
   return result;
 }
 
 //
 // WebRequestRedirectByRegExAction
 //
 
 WebRequestRedirectByRegExAction::WebRequestRedirectByRegExAction(
-    scoped_ptr<icu::RegexPattern> from_pattern,
+    scoped_ptr<RE2> 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
@@ skipping 54 matching lines @@
   return WebRequestAction::ACTION_REDIRECT_BY_REGEX_DOCUMENT;
 }
 
 LinkedPtrEventResponseDelta WebRequestRedirectByRegExAction::CreateDelta(
     const WebRequestRule::RequestData& request_data,
     const std::string& extension_id,
     const base::Time& extension_install_time) const {
   CHECK(request_data.stage & GetStages());
   CHECK(from_pattern_.get());
 
-  UErrorCode status = U_ZERO_ERROR;
   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())
+  std::string new_url = old_url;
+  if (!RE2::Replace(&new_url, *from_pattern_, to_pattern_) ||
+      new_url == old_url) {
     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_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);
+  result->new_url = GURL(new_url);
   return result;
 }
 
 //
 // WebRequestSetRequestHeaderAction
 //
 
 WebRequestSetRequestHeaderAction::WebRequestSetRequestHeaderAction(
     const std::string& name,
     const std::string& value)
@@ skipping 247 matching lines @@
   CHECK(request_data.stage & GetStages());
   LinkedPtrEventResponseDelta result(
       new extension_web_request_api_helpers::EventResponseDelta(
           extension_id, extension_install_time));
   result->response_cookie_modifications.push_back(
       response_cookie_modification_);
   return result;
 }
 
 }  // namespace extensions