Move extension_error_utils.* and url_pattern_set.* into

chrome/common/extensions/matcher/url_matcher_factory.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/common/extensions/matcher/url_matcher_factory.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
 #include "chrome/common/extensions/matcher/url_matcher_helpers.h"
+#include "extensions/common/error_utils.h"
 #include "third_party/re2/re2/re2.h"
 
 namespace helpers = extensions::url_matcher_helpers;
 namespace keys = extensions::url_matcher_constants;
 
 namespace {
 // Error messages:
 const char kInvalidPortRanges[] = "Invalid port ranges in UrlFilter.";
 const char kVectorOfStringsExpected[] =
     "UrlFilter attribute '*' expected a vector of strings as parameter.";
@@ skipping 103 matching lines @@
       if (!error->empty())
         return scoped_refptr<URLMatcherConditionSet>(NULL);
     } else if (condition_attribute_name == keys::kPortsKey) {
       // Handle ports.
       url_matcher_port_filter = CreateURLMatcherPorts(
           &condition_attribute_value, error);
       if (!error->empty())
         return scoped_refptr<URLMatcherConditionSet>(NULL);
     } else {
       // Handle unknown attributes.
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ErrorUtils::FormatErrorMessage(
           kUnknownURLFilterAttribute,
           condition_attribute_name);
       return scoped_refptr<URLMatcherConditionSet>(NULL);
     }
   }
 
   // As the URL is the preliminary matching criterion that triggers the tests
   // for the remaining condition attributes, we insert an empty URL match if
   // no other url match conditions were specified. Such an empty URL is always
   // matched.
@@ skipping 16 matching lines @@
 }
 
 // static
 URLMatcherCondition URLMatcherFactory::CreateURLMatcherCondition(
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const std::string& condition_attribute_name,
     const base::Value* value,
     std::string* error) {
   std::string str_value;
   if (!value->GetAsString(&str_value)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kAttributeExpectedString,
+    *error = ErrorUtils::FormatErrorMessage(kAttributeExpectedString,
                                                      condition_attribute_name);
     return URLMatcherCondition();
   }
   // Test regular expressions for validity.
   if (condition_attribute_name == keys::kURLMatchesKey) {
     re2::RE2 regex(str_value);
     if (!regex.ok()) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(kUnparseableRegexString,
+      *error = ErrorUtils::FormatErrorMessage(kUnparseableRegexString,
                                                        str_value,
                                                        regex.error());
       return URLMatcherCondition();
     }
   }
   return g_url_matcher_condition_factory_methods.Get().Call(
       url_matcher_condition_factory, condition_attribute_name, str_value);
 }
 
 // static
 scoped_ptr<URLMatcherSchemeFilter> URLMatcherFactory::CreateURLMatcherScheme(
     const base::Value* value,
     std::string* error) {
   std::vector<std::string> schemas;
   if (!helpers::GetAsStringVector(value, &schemas)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kVectorOfStringsExpected,
+    *error = ErrorUtils::FormatErrorMessage(kVectorOfStringsExpected,
                                                      keys::kSchemesKey);
     return scoped_ptr<URLMatcherSchemeFilter>(NULL);
   }
   return scoped_ptr<URLMatcherSchemeFilter>(
       new URLMatcherSchemeFilter(schemas));
 }
 
 // static
 scoped_ptr<URLMatcherPortFilter> URLMatcherFactory::CreateURLMatcherPorts(
     const base::Value* value,
@@ skipping 24 matching lines @@
     } else {
       *error = kInvalidPortRanges;
       return scoped_ptr<URLMatcherPortFilter>(NULL);
     }
   }
 
   return scoped_ptr<URLMatcherPortFilter>(new URLMatcherPortFilter(ranges));
 }
 
 }  // namespace extensions