Moving font_settings extensions API to api/

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/extension_font_settings_api.h"
+#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/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"
 
 #if defined(OS_WIN)
 #include "ui/gfx/font.h"
 #include "ui/gfx/platform_font_win.h"
 #endif
 
-using extensions::APIPermission;
+namespace extensions {
 
-namespace fonts = extensions::api::font_settings;
+namespace fonts = api::font_settings;
 
 namespace {
 
 const char kFontIdKey[] = "fontId";
 const char kGenericFamilyKey[] = "genericFamily";
 const char kLevelOfControlKey[] = "levelOfControl";
 const char kDisplayNameKey[] = "displayName";
 const char kPixelSizeKey[] = "pixelSize";
 const char kScriptKey[] = "script";
 
@@ skipping 57 matching lines @@
                                    content::NotificationObserver* obs) {
   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
     std::string pref_name = base::StringPrintf("%s.%s", map_name, script);
     registrar->Add(pref_name.c_str(), obs);
   }
 }
 
 }  // namespace
 
-ExtensionFontSettingsEventRouter::ExtensionFontSettingsEventRouter(
+FontSettingsEventRouter::FontSettingsEventRouter(
     Profile* profile) : profile_(profile) {}
 
-ExtensionFontSettingsEventRouter::~ExtensionFontSettingsEventRouter() {}
+FontSettingsEventRouter::~FontSettingsEventRouter() {}
 
-void ExtensionFontSettingsEventRouter::Init() {
+void FontSettingsEventRouter::Init() {
   registrar_.Init(profile_->GetPrefs());
 
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize,
                    kOnDefaultFixedFontSizeChanged,
                    kPixelSizeKey);
   AddPrefToObserve(prefs::kWebKitDefaultFontSize,
                    kOnDefaultFontSizeChanged,
                    kPixelSizeKey);
   AddPrefToObserve(prefs::kWebKitMinimumFontSize,
                    kOnMinimumFontSizeChanged,
                    kPixelSizeKey);
 
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitStandardFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSerifFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSansSerifFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFixedFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitCursiveFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFantasyFontFamilyMap, this);
 }
 
-void ExtensionFontSettingsEventRouter::AddPrefToObserve(const char* pref_name,
+void FontSettingsEventRouter::AddPrefToObserve(const char* pref_name,
                                                         const char* event_name,
                                                         const char* key) {
   registrar_.Add(pref_name, this);
   pref_event_map_[pref_name] = std::make_pair(event_name, key);
 }
 
-void ExtensionFontSettingsEventRouter::Observe(
+void FontSettingsEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type != chrome::NOTIFICATION_PREF_CHANGED) {
     NOTREACHED();
     return;
   }
 
   PrefService* pref_service = content::Source<PrefService>(source).ptr();
   bool incognito = (pref_service != profile_->GetPrefs());
@@ skipping 14 matching lines @@
   std::string script;
   if (ParseFontNamePrefPath(*pref_name, &generic_family, &script)) {
     OnFontNamePrefChanged(pref_service, *pref_name, generic_family, script,
                           incognito);
     return;
   }
 
   NOTREACHED();
 }
 
-void ExtensionFontSettingsEventRouter::OnFontNamePrefChanged(
+void FontSettingsEventRouter::OnFontNamePrefChanged(
     PrefService* pref_service,
     const std::string& pref_name,
     const std::string& generic_family,
     const std::string& script,
     bool incognito) {
   const PrefService::Preference* pref = pref_service->FindPreference(
       pref_name.c_str());
   CHECK(pref);
 
   std::string font_name;
@@ skipping 12 matching lines @@
 
   extension_preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       APIPermission::kFontSettings,
       incognito,
       pref_name);
 }
 
-void ExtensionFontSettingsEventRouter::OnFontPrefChanged(
+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;
@@ skipping 20 matching lines @@
       fonts::ClearFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script.get());
 
   // Ensure |pref_path| really is for a registered per-script font pref.
   EXTENSION_FUNCTION_VALIDATE(
       profile_->GetPrefs()->FindPreference(pref_path.c_str()));
 
-  extensions::ExtensionPrefs* prefs =
-      profile_->GetExtensionService()->extension_prefs();
+  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(),
                                        pref_path.c_str(),
-                                       extensions::kExtensionPrefsScopeRegular);
+                                       kExtensionPrefsScopeRegular);
   return true;
 }
 
 bool GetFontFunction::RunImpl() {
   scoped_ptr<fonts::GetFont::Params> params(
       fonts::GetFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script.get());
@@ skipping 31 matching lines @@
   scoped_ptr<fonts::SetFont::Params> params(
       fonts::SetFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script.get());
   // Ensure |pref_path| really is for a registered font pref.
   EXTENSION_FUNCTION_VALIDATE(
       profile_->GetPrefs()->FindPreference(pref_path.c_str()));
 
-  extensions::ExtensionPrefs* prefs =
-      profile_->GetExtensionService()->extension_prefs();
+  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->SetExtensionControlledPref(
       extension_id(),
       pref_path.c_str(),
-      extensions::kExtensionPrefsScopeRegular,
+      kExtensionPrefsScopeRegular,
       Value::CreateStringValue(params->details.font_id));
   return true;
 }
 
 bool GetFontListFunction::RunImpl() {
   content::GetFontListAsync(
       Bind(&GetFontListFunction::FontListHasLoaded, this));
   return true;
 }
 
@@ skipping 32 matching lines @@
   SetResult(result.release());
   return true;
 }
 
 bool ClearFontPrefExtensionFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
     return false;
   }
 
-  extensions::ExtensionPrefs* prefs =
-      profile_->GetExtensionService()->extension_prefs();
+  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(),
                                        GetPrefName(),
-                                       extensions::kExtensionPrefsScopeRegular);
+                                       kExtensionPrefsScopeRegular);
   return true;
 }
 
 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.
@@ skipping 17 matching lines @@
     error_ = kSetFromIncognitoError;
     return false;
   }
 
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
   Value* value;
   EXTENSION_FUNCTION_VALIDATE(details->Get(GetKey(), &value));
 
-  extensions::ExtensionPrefs* prefs =
-      profile_->GetExtensionService()->extension_prefs();
+  ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->SetExtensionControlledPref(extension_id(),
                                     GetPrefName(),
-                                    extensions::kExtensionPrefsScopeRegular,
+                                    kExtensionPrefsScopeRegular,
                                     value->DeepCopy());
   return true;
 }
 
 const char* ClearDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
 const char* GetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
@@ skipping 43 matching lines @@
   return kPixelSizeKey;
 }
 
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* SetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
+
+}  // namespace extensions