Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/preference/preference_api.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/preference/preference_api.h"
 
 #include <map>
 #include <utility>
 
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/preference/preference_api_constants.h"
 #include "chrome/browser/extensions/api/preference/preference_helpers.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_prefs_scope.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "extensions/common/extension_error_utils.h"
 
 namespace keys = extensions::preference_api_constants;
 namespace helpers = extensions::preference_helpers;
 
 namespace extensions {
 
 namespace {
 
 struct PrefMappingEntry {
   // Name of the preference referenced by the extension API JSON.
@@ skipping 236 matching lines @@
   const PrefServiceBase::Preference* pref =
       pref_service->FindPreference(browser_pref.c_str());
   CHECK(pref);
   ExtensionService* extension_service = profile_->GetExtensionService();
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   Value* transformed_value =
       transformer->BrowserToExtensionPref(pref->GetValue());
   if (!transformed_value) {
     LOG(ERROR) <<
-        ExtensionErrorUtils::FormatErrorMessage(kConversionErrorMessage,
+        ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                 pref->name());
     return;
   }
 
   dict->Set(keys::kValue, transformed_value);
   if (incognito) {
     extensions::ExtensionPrefs* ep = extension_service->extension_prefs();
     dict->SetBoolean(keys::kIncognitoSpecific,
                      ep->HasIncognitoPrefValue(browser_pref));
   }
 
   helpers::DispatchEventToExtensions(profile_,
                                      event_name,
                                      &args,
                                      permission,
                                      incognito,
                                      browser_pref);
 }
 
 PreferenceFunction::~PreferenceFunction() { }
 
 bool PreferenceFunction::ValidateBrowserPref(
     const std::string& extension_pref_key,
     std::string* browser_pref_key) {
   APIPermission::ID permission = APIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
           extension_pref_key, browser_pref_key, &permission));
   if (!GetExtension()->HasAPIPermission(permission)) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kPermissionErrorMessage, extension_pref_key);
     return false;
   }
   return true;
 }
 
 GetPreferenceFunction::~GetPreferenceFunction() { }
 
 bool GetPreferenceFunction::RunImpl() {
   std::string pref_key;
@@ skipping 30 matching lines @@
                                  incognito);
   result->SetString(keys::kLevelOfControl, level_of_control);
 
   // Retrieve pref value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   Value* transformed_value =
       transformer->BrowserToExtensionPref(pref->GetValue());
   if (!transformed_value) {
     LOG(ERROR) <<
-        ExtensionErrorUtils::FormatErrorMessage(kConversionErrorMessage,
+        ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                 pref->name());
     return false;
   }
   result->Set(keys::kValue, transformed_value);
 
   // Retrieve incognito status.
   if (incognito) {
     extensions::ExtensionPrefs* ep =
         profile_->GetExtensionService()->extension_prefs();
     result->SetBoolean(keys::kIncognitoSpecific,
@@ skipping 72 matching lines @@
     error_ = error;
     bad_message_ = bad_message;
     return false;
   }
 
   // Validate also that the stored value can be converted back by the
   // transformer.
   scoped_ptr<Value> extensionPrefValue(
       transformer->BrowserToExtensionPref(browser_pref_value.get()));
   if (!extensionPrefValue) {
-    error_ =  ExtensionErrorUtils::FormatErrorMessage(kConversionErrorMessage,
+    error_ =  ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                       pref->name());
     bad_message_ = true;
     return false;
   }
 
   prefs->SetExtensionControlledPref(extension_id(),
                                     browser_pref,
                                     scope,
                                     browser_pref_value.release());
   return true;
@@ skipping 37 matching lines @@
   if (!ValidateBrowserPref(pref_key, &browser_pref))
     return false;
 
   extensions::ExtensionPrefs* prefs =
       profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;
 }
 
 }  // namespace extensions