Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/proxy/proxy_api_helpers.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.
 
 // Implementation of helper functions for the Chrome Extensions Proxy Settings
 // API.
 //
 // Throughout this code, we report errors to the user by setting an |error|
 // parameter, if and only if these errors can be cause by invalid input
 // from the extension and we cannot expect that the extensions API has
 // caught this error before. In all other cases we are dealing with internal
 // errors and log to LOG(ERROR).
 
 #include "chrome/browser/extensions/api/proxy/proxy_api_helpers.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api_constants.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
-#include "chrome/common/extensions/extension_error_utils.h"
+#include "extensions/common/error_utils.h"
 #include "net/base/data_url.h"
 #include "net/proxy/proxy_config.h"
 
 namespace extensions {
 
 namespace keys = proxy_api_constants;
 
 namespace proxy_api_helpers {
 
 bool CreateDataURLFromPACScript(const std::string& pac_script,
@@ skipping 129 matching lines @@
     scheme = default_scheme;
 
   // TODO(battre): handle UTF-8 in hostnames (http://crbug.com/72692).
   string16 host16;
   if (!proxy_server->GetString(keys::kProxyConfigRuleHost, &host16)) {
     LOG(ERROR) << "Could not parse a 'rules.*.host' entry.";
     *bad_message = true;
     return false;
   }
   if (!IsStringASCII(host16)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(
+    *error = ErrorUtils::FormatErrorMessage(
         "Invalid 'rules.???.host' entry '*'. 'host' field supports only ASCII "
         "URLs (encode URLs in Punycode format).",
         UTF16ToUTF8(host16));
     return false;
   }
   std::string host = UTF16ToASCII(host16);
 
   int port;  // optional.
   if (!proxy_server->GetInteger(keys::kProxyConfigRulePort, &port))
     port = net::ProxyServer::GetDefaultPortForScheme(scheme);
@@ skipping 34 matching lines @@
       }
     }
   }
 
   COMPILE_ASSERT(keys::SCHEME_ALL == 0, singleProxy_must_be_first_option);
 
   // Handle case that only singleProxy is specified.
   if (has_proxy[keys::SCHEME_ALL]) {
     for (size_t i = 1; i <= keys::SCHEME_MAX; ++i) {
       if (has_proxy[i]) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ErrorUtils::FormatErrorMessage(
             "Proxy rule for * and * cannot be set at the same time.",
             keys::field_name[keys::SCHEME_ALL], keys::field_name[i]);
         return false;
       }
     }
     *out = proxy_server[keys::SCHEME_ALL].ToURI();
     return true;
   }
 
   // Handle case that anything but singleProxy is specified.
@@ skipping 241 matching lines @@
                                 const std::string& delims) {
   ListValue* out = new ListValue;
   StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->Append(Value::CreateStringValue(entries.token()));
   return out;
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions