Migrate chrome/browser/download/download_query.cc to RE2 regex engine

chrome/browser/download/download_query.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/download/download_query.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 11 matching lines @@
 #include "base/strings/string_split.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_item.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
-#include "third_party/icu/public/i18n/unicode/regex.h"
+#include "third_party/re2/re2/re2.h"
 
 using content::DownloadDangerType;
 using content::DownloadItem;
 
 namespace {
 
 // Templatized base::Value::GetAs*().
 template <typename T> bool GetAs(const base::Value& in, T* out);
 template<> bool GetAs(const base::Value& in, bool* out) {
   return in.GetAsBoolean(out);
@@ skipping 138 matching lines @@
     const base::Value& value, ComparisonType cmptype,
     ValueType (*accessor)(const DownloadItem&)) {
   ValueType cpp_value;
   if (!GetAs(value, &cpp_value)) return DownloadQuery::FilterCallback();
   return base::Bind(&FieldMatches<ValueType>, cpp_value, cmptype,
                     base::Bind(accessor));
 }
 
 // Returns true if |accessor.Run(item)| matches |pattern|.
 static bool FindRegex(
-    icu::RegexPattern* pattern,
+    RE2* pattern,
     const base::Callback<std::string(const DownloadItem&)>& accessor,
     const DownloadItem& item) {
-  icu::UnicodeString input(accessor.Run(item).c_str());
-  UErrorCode status = U_ZERO_ERROR;
-  scoped_ptr<icu::RegexMatcher> matcher(pattern->matcher(input, status));
-  return matcher->find() == TRUE;  // Ugh, VS complains bool != UBool.
+  return RE2::PartialMatch(accessor.Run(item), *pattern);
 }
 
 // Helper for building a Callback to FindRegex().
 DownloadQuery::FilterCallback BuildRegexFilter(
     const base::Value& regex_value,
     std::string (*accessor)(const DownloadItem&)) {
   std::string regex_str;
   if (!GetAs(regex_value, &regex_str)) return DownloadQuery::FilterCallback();
-  UParseError re_err;
-  UErrorCode re_status = U_ZERO_ERROR;
-  scoped_ptr<icu::RegexPattern> pattern(icu::RegexPattern::compile(
-      icu::UnicodeString::fromUTF8(regex_str.c_str()), re_err, re_status));
-  if (!U_SUCCESS(re_status)) return DownloadQuery::FilterCallback();
+  scoped_ptr<RE2> pattern(new RE2(regex_str));
+  if (!pattern->ok()) return DownloadQuery::FilterCallback();
   return base::Bind(&FindRegex, base::Owned(pattern.release()),
                     base::Bind(accessor));
 }
 
 // Returns a ComparisonType to indicate whether a field in |left| is less than,
 // greater than or equal to the same field in |right|.
 template<typename ValueType>
 static ComparisonType Compare(
     const base::Callback<ValueType(const DownloadItem&)>& accessor,
     const DownloadItem& left, const DownloadItem& right) {
@@ skipping 201 matching lines @@
 
 void DownloadQuery::FinishSearch(DownloadQuery::DownloadVector* results) const {
   if (!sorters_.empty())
     std::partial_sort(results->begin(),
                       results->begin() + std::min(limit_, results->size()),
                       results->end(),
                       DownloadComparator(sorters_));
   if (results->size() > limit_)
     results->resize(limit_);
 }