Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.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_condition_attribute.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.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/common/extensions/extension_error_utils.h"
 #include "content/public/browser/resource_request_info.h"
+#include "extensions/common/error_utils.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/static_cookie_policy.h"
+#include "net/http/http_request_headers.h"
 #include "net/http/http_util.h"
-#include "net/http/http_request_headers.h"
 #include "net/url_request/url_request.h"
 
 using base::CaseInsensitiveCompareASCII;
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 
 namespace {
 // Error messages.
@@ skipping 47 matching lines @@
   } else if (WebRequestConditionAttributeResponseHeaders::IsMatchingType(
       name)) {
     return WebRequestConditionAttributeResponseHeaders::Create(
         name, value, error);
   } else if (WebRequestConditionAttributeThirdParty::IsMatchingType(name)) {
     return WebRequestConditionAttributeThirdParty::Create(name, value, error);
   } else if (WebRequestConditionAttributeStages::IsMatchingType(name)) {
     return WebRequestConditionAttributeStages::Create(name, value, error);
   }
 
-  *error = ExtensionErrorUtils::FormatErrorMessage(kUnknownConditionAttribute,
+  *error = ErrorUtils::FormatErrorMessage(kUnknownConditionAttribute,
                                                    name);
   return scoped_ptr<WebRequestConditionAttribute>(NULL);
 }
 
 //
 // WebRequestConditionAttributeResourceType
 //
 
 WebRequestConditionAttributeResourceType::
 WebRequestConditionAttributeResourceType(
@@ skipping 12 matching lines @@
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeResourceType::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   DCHECK(IsMatchingType(name));
 
   const ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kResourceTypeKey);
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
   }
 
   size_t number_types = value_as_list->GetSize();
 
   std::vector<ResourceType::Type> passed_types(number_types);
   for (size_t i = 0; i < number_types; ++i) {
     std::string resource_type_string;
     ResourceType::Type type = ResourceType::LAST_TYPE;
     if (!value_as_list->GetString(i, &resource_type_string) ||
         !helpers::ParseResourceType(resource_type_string, &type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
+      *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                        keys::kResourceTypeKey);
       return scoped_ptr<WebRequestConditionAttribute>(NULL);
     }
     passed_types.push_back(type);
   }
 
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResourceType(passed_types));
 }
 
@@ skipping 44 matching lines @@
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeContentType::Create(
       const std::string& name,
       const base::Value* value,
       std::string* error) {
   DCHECK(IsMatchingType(name));
 
   const ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
   }
   std::vector<std::string> content_types;
   for (ListValue::const_iterator it = value_as_list->begin();
        it != value_as_list->end(); ++it) {
     std::string content_type;
     if (!(*it)->GetAsString(&content_type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+      *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
       return scoped_ptr<WebRequestConditionAttribute>(NULL);
     }
     content_types.push_back(content_type);
   }
 
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeContentType(
           content_types, name == keys::kContentTypeKey));
 }
 
@@ skipping 300 matching lines @@
 }
 
 namespace {
 
 scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   const ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_ptr<const HeaderMatcher>(NULL);
   }
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       HeaderMatcher::Create(value_as_list));
   if (header_matcher.get() == NULL)
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue, name);
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
   return header_matcher.Pass();
 }
 
 }  // namespace
 
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeRequestHeaders::Create(
     const std::string& name,
     const base::Value* value,
@@ skipping 131 matching lines @@
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeThirdParty::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   DCHECK(IsMatchingType(name));
 
   bool third_party = false;  // Dummy value, gets overwritten.
   if (!value->GetAsBoolean(&third_party)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kThirdPartyKey);
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
   }
 
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeThirdParty(third_party));
 }
 
 int WebRequestConditionAttributeThirdParty::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_SEND_HEADERS |
@@ skipping 76 matching lines @@
 
 // static
 scoped_ptr<WebRequestConditionAttribute>
 WebRequestConditionAttributeStages::Create(const std::string& name,
                                            const Value* value,
                                            std::string* error) {
   DCHECK(IsMatchingType(name));
 
   int allowed_stages = 0;
   if (!ParseListOfStages(*value, &allowed_stages)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidValue,
+    *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kStagesKey);
     return scoped_ptr<WebRequestConditionAttribute>(NULL);
   }
 
   return scoped_ptr<WebRequestConditionAttribute>(
       new WebRequestConditionAttributeStages(allowed_stages));
 }
 
 int WebRequestConditionAttributeStages::GetStages() const {
   return allowed_stages_;
 }
 
 bool WebRequestConditionAttributeStages::IsFulfilled(
     const WebRequestRule::RequestData& request_data) const {
   // Note: removing '!=' triggers warning C4800 on the VS compiler.
   return (request_data.stage & GetStages()) != 0;
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeStages::GetType() const {
   return CONDITION_STAGES;
 }
 
 }  // namespace extensions