[Extensions] Convert some ChromeSyncExtensionFunctions

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 <stddef.h>
 
@@ skipping 209 matching lines @@
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<FontSettingsAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<FontSettingsAPI>*
 FontSettingsAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
-bool FontSettingsClearFontFunction::RunSync() {
-  if (GetProfile()->IsOffTheRecord()) {
-    error_ = kSetFromIncognitoError;
-    return false;
-  }
+ExtensionFunction::ResponseAction FontSettingsClearFontFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsOffTheRecord())
+    return RespondNow(Error(kSetFromIncognitoError));
 
   std::unique_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(
-      GetProfile()->GetPrefs()->FindPreference(pref_path));
+  EXTENSION_FUNCTION_VALIDATE(profile->GetPrefs()->FindPreference(pref_path));
 
-  PreferenceAPI::Get(GetProfile())->RemoveExtensionControlledPref(
+  PreferenceAPI::Get(profile)->RemoveExtensionControlledPref(
       extension_id(), pref_path, kExtensionPrefsScopeRegular);
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool FontSettingsGetFontFunction::RunSync() {
+ExtensionFunction::ResponseAction FontSettingsGetFontFunction::Run() {
   std::unique_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 = GetProfile()->GetPrefs();
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  PrefService* prefs = profile->GetPrefs();
   const PrefService::Preference* pref =
       prefs->FindPreference(pref_path);
 
   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 =
-      extensions::preference_helpers::GetLevelOfControl(
-          GetProfile(), extension_id(), pref_path, kIncognito);
+      extensions::preference_helpers::GetLevelOfControl(profile, extension_id(),
+                                                        pref_path, kIncognito);
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetString(kFontIdKey, font_name);
   result->SetString(kLevelOfControlKey, level_of_control);
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool FontSettingsSetFontFunction::RunSync() {
-  if (GetProfile()->IsOffTheRecord()) {
-    error_ = kSetFromIncognitoError;
-    return false;
-  }
+ExtensionFunction::ResponseAction FontSettingsSetFontFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsOffTheRecord())
+    return RespondNow(Error(kSetFromIncognitoError));
 
   std::unique_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(
-      GetProfile()->GetPrefs()->FindPreference(pref_path));
+  EXTENSION_FUNCTION_VALIDATE(profile->GetPrefs()->FindPreference(pref_path));
 
-  PreferenceAPI::Get(GetProfile())->SetExtensionControlledPref(
-      extension_id(),
-      pref_path,
-      kExtensionPrefsScopeRegular,
+  PreferenceAPI::Get(profile)->SetExtensionControlledPref(
+      extension_id(), pref_path, kExtensionPrefsScopeRegular,
       new base::StringValue(params->details.font_id));
-  return true;
+  return RespondNow(NoArguments());
 }
 
 bool FontSettingsGetFontListFunction::RunAsync() {
   content::GetFontListAsync(
       Bind(&FontSettingsGetFontListFunction::FontListHasLoaded, this));
   return true;
 }
 
 void FontSettingsGetFontListFunction::FontListHasLoaded(
     std::unique_ptr<base::ListValue> list) {
@@ skipping 28 matching lines @@
         new base::DictionaryValue());
     font_name->Set(kFontIdKey, new base::StringValue(name));
     font_name->Set(kDisplayNameKey, new base::StringValue(localized_name));
     result->Append(std::move(font_name));
   }
 
   SetResult(std::move(result));
   return true;
 }
 
-bool ClearFontPrefExtensionFunction::RunSync() {
-  if (GetProfile()->IsOffTheRecord()) {
-    error_ = kSetFromIncognitoError;
-    return false;
-  }
+ExtensionFunction::ResponseAction ClearFontPrefExtensionFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsOffTheRecord())
+    return RespondNow(Error(kSetFromIncognitoError));
 
-  PreferenceAPI::Get(GetProfile())->RemoveExtensionControlledPref(
+  PreferenceAPI::Get(profile)->RemoveExtensionControlledPref(
       extension_id(), GetPrefName(), kExtensionPrefsScopeRegular);
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool GetFontPrefExtensionFunction::RunSync() {
-  PrefService* prefs = GetProfile()->GetPrefs();
+ExtensionFunction::ResponseAction GetFontPrefExtensionFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  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 =
       extensions::preference_helpers::GetLevelOfControl(
-          GetProfile(), extension_id(), GetPrefName(), kIncognito);
+          profile, extension_id(), GetPrefName(), kIncognito);
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->Set(GetKey(), pref->GetValue()->DeepCopy());
   result->SetString(kLevelOfControlKey, level_of_control);
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool SetFontPrefExtensionFunction::RunSync() {
-  if (GetProfile()->IsOffTheRecord()) {
-    error_ = kSetFromIncognitoError;
-    return false;
-  }
+ExtensionFunction::ResponseAction SetFontPrefExtensionFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsOffTheRecord())
+    return RespondNow(Error(kSetFromIncognitoError));
 
   base::DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
   base::Value* value;
   EXTENSION_FUNCTION_VALIDATE(details->Get(GetKey(), &value));
 
-  PreferenceAPI::Get(GetProfile())
-      ->SetExtensionControlledPref(extension_id(),
-                                   GetPrefName(),
-                                   kExtensionPrefsScopeRegular,
-                                   value->DeepCopy());
-  return true;
+  PreferenceAPI::Get(profile)->SetExtensionControlledPref(
+      extension_id(), GetPrefName(), kExtensionPrefsScopeRegular,
+      value->DeepCopy());
+  return RespondNow(NoArguments());
 }
 
 const char* FontSettingsClearDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
 const char* FontSettingsGetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitDefaultFontSize;
 }
 
@@ skipping 43 matching lines @@
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions