Extensions Docs Server: Enum values do not show up if enum is a type

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 41 matching lines @@
 const char kOnFontChanged[] = "fontSettings.onFontChanged";
 const char kOnMinimumFontSizeChanged[] =
     "fontSettings.onMinimumFontSizeChanged";
 
 // Format for font name preference paths.
 const char kWebKitFontPrefFormat[] = "webkit.webprefs.fonts.%s.%s";
 const char kWebKitFontPrefPrefix[] = "webkit.webprefs.fonts.";
 
 // Gets the font name preference path for |generic_family| and |script|. If
 // |script| is NULL, uses prefs::kWebKitCommonScript.
-std::string GetFontNamePrefPath(const std::string& generic_family,
-                                const std::string* script) {
+std::string GetFontNamePrefPath(fonts::GenericFamily generic_family_enum,
+                                fonts::ScriptCode script_enum) {
+  std::string script;
+  scoped_ptr<Value> script_value = fonts::CreateEnumValue(script_enum);
+  if (script_value.get())
+    script_value->GetAsString(&script);

[not at google - send to devlin, 2012/09/14 01:44:51]

etc

[cduvall, 2012/09/17 22:07:46]

Done.

+  else
+    script = prefs::kWebKitCommonScript;
+  std::string generic_family;
+  fonts::CreateEnumValue(generic_family_enum)->GetAsString(&generic_family);
   return StringPrintf(kWebKitFontPrefFormat,
                       generic_family.c_str(),
-                      script ? script->c_str() : prefs::kWebKitCommonScript);
+                      script.c_str());
 }
 
 // Extracts the generic family and script from font name pref path |pref_path|.
 bool ParseFontNamePrefPath(std::string pref_path,
                            std::string* generic_family,
                            std::string* script) {
   if (!StartsWithASCII(pref_path, kWebKitFontPrefPrefix, true))
     return false;
 
   size_t start = strlen(kWebKitFontPrefPrefix);
@@ skipping 167 matching lines @@
   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.get());
+                                              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 = profile_->GetExtensionService()->extension_prefs();
   prefs->RemoveExtensionControlledPref(extension_id(),
                                        pref_path.c_str(),
                                        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());
+                                              params->details.script);
+
   PrefService* prefs = profile_->GetPrefs();
   const PrefService::Preference* pref =
       prefs->FindPreference(pref_path.c_str());
 
   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
@@ skipping 16 matching lines @@
   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());
+                                              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 = profile_->GetExtensionService()->extension_prefs();
   prefs->SetExtensionControlledPref(
       extension_id(),
       pref_path.c_str(),
       kExtensionPrefsScopeRegular,
       Value::CreateStringValue(params->details.font_id));
@@ skipping 151 matching lines @@
 
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* SetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions