Moving preference API into api/preferences

chrome/browser/extensions/api/font_settings/font_settings_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.
 
 // Font Settings Extension API implementation.
 
 #include "chrome/browser/extensions/api/font_settings/font_settings_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/extension_preference_helpers.h"
+#include "chrome/browser/extensions/api/preference/preference_helpers.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/api/font_settings.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/font_list_async.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 174 matching lines @@
   }
   font_name = MaybeGetLocalizedFontName(font_name);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
   dict->SetString(kFontIdKey, font_name);
   dict->SetString(kGenericFamilyKey, generic_family);
   dict->SetString(kScriptKey, script);
 
-  extension_preference_helpers::DispatchEventToExtensions(
+  extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       APIPermission::kFontSettings,
       incognito,
       pref_name);
 }
 
 void FontSettingsEventRouter::OnFontPrefChanged(
     PrefService* pref_service,
     const std::string& pref_name,
     const std::string& event_name,
     const std::string& key,
     bool incognito) {
   const PrefService::Preference* pref = pref_service->FindPreference(
       pref_name.c_str());
   CHECK(pref);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
   dict->Set(key, pref->GetValue()->DeepCopy());
 
-  extension_preference_helpers::DispatchEventToExtensions(
+  extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       event_name,
       &args,
       APIPermission::kFontSettings,
       incognito,
       pref_name);
 }
 
 bool ClearFontFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
@@ skipping 32 matching lines @@
 
   std::string font_name;
   EXTENSION_FUNCTION_VALIDATE(
       pref && pref->GetValue()->GetAsString(&font_name));
   font_name = MaybeGetLocalizedFontName(font_name);
 
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
   std::string level_of_control =
-      extension_preference_helpers::GetLevelOfControl(profile_,
-                                                      extension_id(),
-                                                      pref_path,
-                                                      kIncognito);
+      extensions::preference_helpers::GetLevelOfControl(profile_,
+                                                        extension_id(),
+                                                        pref_path,
+                                                        kIncognito);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetString(kFontIdKey, font_name);
   result->SetString(kLevelOfControlKey, level_of_control);
   SetResult(result);
   return true;
 }
 
 bool SetFontFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
@@ skipping 78 matching lines @@
 bool GetFontPrefExtensionFunction::RunImpl() {
   PrefService* prefs = profile_->GetPrefs();
   const PrefService::Preference* pref = prefs->FindPreference(GetPrefName());
   EXTENSION_FUNCTION_VALIDATE(pref);
 
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
 
   std::string level_of_control =
-      extension_preference_helpers::GetLevelOfControl(profile_,
-                                                      extension_id(),
-                                                      GetPrefName(),
-                                                      kIncognito);
+      extensions::preference_helpers::GetLevelOfControl(profile_,
+                                                        extension_id(),
+                                                        GetPrefName(),
+                                                        kIncognito);
 
   DictionaryValue* result = new DictionaryValue();
   result->Set(GetKey(), pref->GetValue()->DeepCopy());
   result->SetString(kLevelOfControlKey, level_of_control);
   SetResult(result);
   return true;
 }
 
 bool SetFontPrefExtensionFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
@@ skipping 69 matching lines @@
 
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* SetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions