Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

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"
@@ skipping 199 matching lines @@
       pref_name);
 }
 
 FontSettingsAPI::FontSettingsAPI(Profile* profile)
     : font_settings_event_router_(new FontSettingsEventRouter(profile)) {
 }
 
 FontSettingsAPI::~FontSettingsAPI() {
 }
 
-bool ClearFontFunction::RunImpl() {
+bool FontSettingsClearFontFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
     return false;
   }
 
   scoped_ptr<fonts::ClearFont::Params> params(
       fonts::ClearFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script);
 
   // Ensure |pref_path| really is for a registered per-script font pref.
   EXTENSION_FUNCTION_VALIDATE(
       profile_->GetPrefs()->FindPreference(pref_path.c_str()));
 
   ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(),
                                        pref_path.c_str(),
                                        kExtensionPrefsScopeRegular);
   return true;
 }
 
-bool GetFontFunction::RunImpl() {
+bool FontSettingsGetFontFunction::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);
 
   PrefService* prefs = profile_->GetPrefs();
   const PrefService::Preference* pref =
       prefs->FindPreference(pref_path.c_str());
@@ skipping 12 matching lines @@
                                                         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() {
+bool FontSettingsSetFontFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
     return false;
   }
 
   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);
 
   // Ensure |pref_path| really is for a registered font pref.
   EXTENSION_FUNCTION_VALIDATE(
       profile_->GetPrefs()->FindPreference(pref_path.c_str()));
 
   ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->extension_prefs();
   prefs->SetExtensionControlledPref(
       extension_id(),
       pref_path.c_str(),
       kExtensionPrefsScopeRegular,
       Value::CreateStringValue(params->details.font_id));
   return true;
 }
 
-bool GetFontListFunction::RunImpl() {
+bool FontSettingsGetFontListFunction::RunImpl() {
   content::GetFontListAsync(
-      Bind(&GetFontListFunction::FontListHasLoaded, this));
+      Bind(&FontSettingsGetFontListFunction::FontListHasLoaded, this));
   return true;
 }
 
-void GetFontListFunction::FontListHasLoaded(scoped_ptr<ListValue> list) {
+void FontSettingsGetFontListFunction::FontListHasLoaded(
+    scoped_ptr<ListValue> list) {
   bool success = CopyFontsToResult(list.get());
   SendResponse(success);
 }
 
-bool GetFontListFunction::CopyFontsToResult(ListValue* fonts) {
+bool FontSettingsGetFontListFunction::CopyFontsToResult(ListValue* fonts) {
   scoped_ptr<ListValue> result(new ListValue());
   for (ListValue::iterator it = fonts->begin(); it != fonts->end(); ++it) {
     ListValue* font_list_value;
     if (!(*it)->GetAsList(&font_list_value)) {
       NOTREACHED();
       return false;
     }
 
     std::string name;
     if (!font_list_value->GetString(0, &name)) {
@@ skipping 67 matching lines @@
 
   ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->extension_prefs();
   prefs->SetExtensionControlledPref(extension_id(),
                                     GetPrefName(),
                                     kExtensionPrefsScopeRegular,
                                     value->DeepCopy());
   return true;
 }
 
-const char* ClearDefaultFontSizeFunction::GetPrefName() {
+const char* FontSettingsClearDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
-const char* GetDefaultFontSizeFunction::GetPrefName() {
+const char* FontSettingsGetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
-const char* GetDefaultFontSizeFunction::GetKey() {
+const char* FontSettingsGetDefaultFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
-const char* SetDefaultFontSizeFunction::GetPrefName() {
+const char* FontSettingsSetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
-const char* SetDefaultFontSizeFunction::GetKey() {
+const char* FontSettingsSetDefaultFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
-const char* ClearDefaultFixedFontSizeFunction::GetPrefName() {
+const char* FontSettingsClearDefaultFixedFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFixedFontSize;
 }
 
-const char* GetDefaultFixedFontSizeFunction::GetPrefName() {
+const char* FontSettingsGetDefaultFixedFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFixedFontSize;
 }
 
-const char* GetDefaultFixedFontSizeFunction::GetKey() {
+const char* FontSettingsGetDefaultFixedFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
-const char* SetDefaultFixedFontSizeFunction::GetPrefName() {
+const char* FontSettingsSetDefaultFixedFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFixedFontSize;
 }
 
-const char* SetDefaultFixedFontSizeFunction::GetKey() {
+const char* FontSettingsSetDefaultFixedFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
-const char* ClearMinimumFontSizeFunction::GetPrefName() {
+const char* FontSettingsClearMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
-const char* GetMinimumFontSizeFunction::GetPrefName() {
+const char* FontSettingsGetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
-const char* GetMinimumFontSizeFunction::GetKey() {
+const char* FontSettingsGetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
-const char* SetMinimumFontSizeFunction::GetPrefName() {
+const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
-const char* SetMinimumFontSizeFunction::GetKey() {
+const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions