[Font Settings API]: Rename fontName and localizedName to fontId and displayName

chrome/browser/extensions/extension_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 "base/bind.h"
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
 #include "ui/gfx/font.h"
 #include "ui/gfx/platform_font_win.h"
 #endif
 
 using extensions::APIPermission;
 
 namespace fonts = extensions::api::experimental_font_settings;
 
 namespace {
 
-const char kFontNameKey[] = "fontName";
+const char kFontIdKey[] = "fontId";
 const char kGenericFamilyKey[] = "genericFamily";
 const char kLevelOfControlKey[] = "levelOfControl";
-const char kLocalizedNameKey[] = "localizedName";
+const char kDisplayNameKey[] = "displayName";
 const char kPixelSizeKey[] = "pixelSize";
 const char kScriptKey[] = "script";
 
 const char kSetFromIncognitoError[] =
     "Can't modify regular settings from an incognito context.";
 
 const char kOnDefaultFixedFontSizeChanged[] =
     "experimental.fontSettings.onDefaultFixedFontSizeChanged";
 const char kOnDefaultFontSizeChanged[] =
     "experimental.fontSettings.onDefaultFontSizeChanged";
@@ skipping 144 matching lines @@
   std::string font_name;
   if (!pref->GetValue()->GetAsString(&font_name)) {
     NOTREACHED();
     return;
   }
   font_name = MaybeGetLocalizedFontName(font_name);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
-  dict->SetString(kFontNameKey, font_name);
+  dict->SetString(kFontIdKey, font_name);
   dict->SetString(kGenericFamilyKey, generic_family);
   dict->SetString(kScriptKey, script);
 
   extension_preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       APIPermission::kExperimental,
       incognito,
       pref_name);
@@ skipping 67 matching lines @@
   // 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);
 
   DictionaryValue* result = new DictionaryValue();
-  result->SetString(kFontNameKey, font_name);
+  result->SetString(kFontIdKey, font_name);
   result->SetString(kLevelOfControlKey, level_of_control);
   result_.reset(result);
   return true;
 }
 
 bool SetFontFunction::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.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();
   prefs->SetExtensionControlledPref(
       extension_id(),
       pref_path.c_str(),
       extensions::kExtensionPrefsScopeRegular,
-      Value::CreateStringValue(params->details.font_name));
+      Value::CreateStringValue(params->details.font_id));
   return true;
 }
 
 bool GetFontListFunction::RunImpl() {
   content::GetFontListAsync(
       Bind(&GetFontListFunction::FontListHasLoaded, this));
   return true;
 }
 
 void GetFontListFunction::FontListHasLoaded(scoped_ptr<ListValue> list) {
@@ skipping 16 matching lines @@
       return false;
     }
 
     std::string localized_name;
     if (!font_list_value->GetString(1, &localized_name)) {
       NOTREACHED();
       return false;
     }
 
     DictionaryValue* font_name = new DictionaryValue();
-    font_name->Set(kFontNameKey, Value::CreateStringValue(name));
-    font_name->Set(kLocalizedNameKey, Value::CreateStringValue(localized_name));
+    font_name->Set(kFontIdKey, Value::CreateStringValue(name));
+    font_name->Set(kDisplayNameKey, Value::CreateStringValue(localized_name));
     result->Append(font_name);
   }
 
   result_.reset(result.release());
   return true;
 }
 
 bool ClearFontPrefExtensionFunction::RunImpl() {
   if (profile_->IsOffTheRecord()) {
     error_ = kSetFromIncognitoError;
@@ skipping 103 matching lines @@
   return kPixelSizeKey;
 }
 
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* SetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }