[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/content_settings/content_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.
 
 #include "chrome/browser/extensions/api/content_settings/content_settings_api.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 49 matching lines @@
   return *content_type != CONTENT_SETTINGS_TYPE_DEFAULT;
 }
 
 }  // namespace
 
 namespace extensions {
 
 namespace helpers = content_settings_helpers;
 namespace keys = content_settings_api_constants;
 
-bool ContentSettingsContentSettingClearFunction::RunSync() {
+ExtensionFunction::ResponseAction
+ContentSettingsContentSettingClearFunction::Run() {
   ContentSettingsType content_type;
   EXTENSION_FUNCTION_VALIDATE(RemoveContentType(args_.get(), &content_type));
 
   std::unique_ptr<Clear::Params> params(Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionPrefsScope scope = kExtensionPrefsScopeRegular;
   bool incognito = false;
   if (params->details.scope ==
       api::content_settings::SCOPE_INCOGNITO_SESSION_ONLY) {
     scope = kExtensionPrefsScopeIncognitoSessionOnly;
     incognito = true;
   }
 
   if (incognito) {
     // We don't check incognito permissions here, as an extension should be
     // always allowed to clear its own settings.
-  } else {
+  } else if (browser_context()->IsOffTheRecord()) {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
-    if (GetProfile()->IsOffTheRecord()) {
-      error_ = keys::kIncognitoContextError;
-      return false;
-    }
+    return RespondNow(Error(keys::kIncognitoContextError));
   }
 
   scoped_refptr<ContentSettingsStore> store =
-      ContentSettingsService::Get(GetProfile())->content_settings_store();
+      ContentSettingsService::Get(browser_context())->content_settings_store();
   store->ClearContentSettingsForExtension(extension_id(), scope);
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ContentSettingsContentSettingGetFunction::RunSync() {
+ExtensionFunction::ResponseAction
+ContentSettingsContentSettingGetFunction::Run() {
   ContentSettingsType content_type;
   EXTENSION_FUNCTION_VALIDATE(RemoveContentType(args_.get(), &content_type));
 
   std::unique_ptr<Get::Params> params(Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL primary_url(params->details.primary_url);
   if (!primary_url.is_valid()) {
-    error_ = ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
-        params->details.primary_url);
-    return false;
+    return RespondNow(
+        Error(keys::kInvalidUrlError, params->details.primary_url));
   }
 
   GURL secondary_url(primary_url);
   if (params->details.secondary_url.get()) {
     secondary_url = GURL(*params->details.secondary_url);
     if (!secondary_url.is_valid()) {
-      error_ = ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
-        *params->details.secondary_url);
-      return false;
+      return RespondNow(
+          Error(keys::kInvalidUrlError, *params->details.secondary_url));
     }
   }
 
   std::string resource_identifier;
   if (params->details.resource_identifier.get())
     resource_identifier = params->details.resource_identifier->id;
 
   bool incognito = false;
   if (params->details.incognito.get())
     incognito = *params->details.incognito;
-  if (incognito && !include_incognito()) {
-    error_ = pref_keys::kIncognitoErrorMessage;
-    return false;
-  }
+  if (incognito && !include_incognito())
+    return RespondNow(Error(pref_keys::kIncognitoErrorMessage));
 
   HostContentSettingsMap* map;
   content_settings::CookieSettings* cookie_settings;
+  Profile* profile = Profile::FromBrowserContext(browser_context());
   if (incognito) {
-    if (!GetProfile()->HasOffTheRecordProfile()) {
+    if (!profile->HasOffTheRecordProfile()) {
       // TODO(bauerb): Allow reading incognito content settings
       // outside of an incognito session.
-      error_ = keys::kIncognitoSessionOnlyError;
-      return false;
+      return RespondNow(Error(keys::kIncognitoSessionOnlyError));
     }
     map = HostContentSettingsMapFactory::GetForProfile(
-        GetProfile()->GetOffTheRecordProfile());
-    cookie_settings = CookieSettingsFactory::GetForProfile(
-                          GetProfile()->GetOffTheRecordProfile()).get();
+        profile->GetOffTheRecordProfile());
+    cookie_settings =
+        CookieSettingsFactory::GetForProfile(profile->GetOffTheRecordProfile())
+            .get();
   } else {
-    map = HostContentSettingsMapFactory::GetForProfile(GetProfile());
-    cookie_settings = CookieSettingsFactory::GetForProfile(GetProfile()).get();
+    map = HostContentSettingsMapFactory::GetForProfile(profile);
+    cookie_settings = CookieSettingsFactory::GetForProfile(profile).get();
   }
 
   ContentSetting setting;
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
     // TODO(jochen): Do we return the value for setting or for reading cookies?
     bool setting_cookie = false;
     setting = cookie_settings->GetCookieSetting(primary_url, secondary_url,
                                                 setting_cookie, NULL);
   } else {
     setting = map->GetContentSetting(primary_url, secondary_url, content_type,
                                      resource_identifier);
   }
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   std::string setting_string =
       content_settings::ContentSettingToString(setting);
   DCHECK(!setting_string.empty());
   result->SetString(keys::kContentSettingKey, setting_string);
 
-  SetResult(std::move(result));
-
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool ContentSettingsContentSettingSetFunction::RunSync() {
+ExtensionFunction::ResponseAction
+ContentSettingsContentSettingSetFunction::Run() {
   ContentSettingsType content_type;
   EXTENSION_FUNCTION_VALIDATE(RemoveContentType(args_.get(), &content_type));
 
   std::unique_ptr<Set::Params> params(Set::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string primary_error;
   ContentSettingsPattern primary_pattern =
       helpers::ParseExtensionPattern(params->details.primary_pattern,
                                      &primary_error);
-  if (!primary_pattern.IsValid()) {
-    error_ = primary_error;
-    return false;
-  }
+  if (!primary_pattern.IsValid())
+    return RespondNow(Error(primary_error));
 
   ContentSettingsPattern secondary_pattern = ContentSettingsPattern::Wildcard();
   if (params->details.secondary_pattern.get()) {
     std::string secondary_error;
     secondary_pattern =
         helpers::ParseExtensionPattern(*params->details.secondary_pattern,
                                        &secondary_error);
-    if (!secondary_pattern.IsValid()) {
-      error_ = secondary_error;
-      return false;
-    }
+    if (!secondary_pattern.IsValid())
+      return RespondNow(Error(secondary_error));
   }
 
   std::string resource_identifier;
   if (params->details.resource_identifier.get())
     resource_identifier = params->details.resource_identifier->id;
 
   std::string setting_str;
   EXTENSION_FUNCTION_VALIDATE(
       params->details.setting->GetAsString(&setting_str));
   ContentSetting setting;
@@ skipping 20 matching lines @@
     // externally in the API, i.e. chrome.contentSettings.<name>.set().
     std::string readable_type_name;
     if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC) {
       readable_type_name = "microphone";
     } else if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
       readable_type_name = "camera";
     } else {
       NOTREACHED() << "No human-readable type name defined for this type.";
     }
 
-    error_ = base::StringPrintf(
-        kUnsupportedDefaultSettingError,
-        setting_str.c_str(),
-        readable_type_name.c_str());
-    return false;
+    return RespondNow(Error(base::StringPrintf(kUnsupportedDefaultSettingError,
+                                               setting_str.c_str(),
+                                               readable_type_name.c_str())));
   }
 
   ExtensionPrefsScope scope = kExtensionPrefsScopeRegular;
   bool incognito = false;
   if (params->details.scope ==
       api::content_settings::SCOPE_INCOGNITO_SESSION_ONLY) {
     scope = kExtensionPrefsScopeIncognitoSessionOnly;
     incognito = true;
   }
 
   if (incognito) {
     // Regular profiles can't access incognito unless include_incognito is true.
-    if (!GetProfile()->IsOffTheRecord() && !include_incognito()) {
-      error_ = pref_keys::kIncognitoErrorMessage;
-      return false;
-    }
+    if (!browser_context()->IsOffTheRecord() && !include_incognito())
+      return RespondNow(Error(pref_keys::kIncognitoErrorMessage));
   } else {
     // Incognito profiles can't access regular mode ever, they only exist in
     // split mode.
-    if (GetProfile()->IsOffTheRecord()) {
-      error_ = keys::kIncognitoContextError;
-      return false;
-    }
+    if (browser_context()->IsOffTheRecord())
+      return RespondNow(Error(keys::kIncognitoContextError));
   }
 
   if (scope == kExtensionPrefsScopeIncognitoSessionOnly &&
-      !GetProfile()->HasOffTheRecordProfile()) {
-    error_ = pref_keys::kIncognitoSessionOnlyErrorMessage;
-    return false;
+      !Profile::FromBrowserContext(browser_context())
+           ->HasOffTheRecordProfile()) {
+    return RespondNow(Error(pref_keys::kIncognitoSessionOnlyErrorMessage));
   }
 
   scoped_refptr<ContentSettingsStore> store =
-      ContentSettingsService::Get(GetProfile())->content_settings_store();
+      ContentSettingsService::Get(browser_context())->content_settings_store();
   store->SetExtensionContentSetting(extension_id(), primary_pattern,
                                     secondary_pattern, content_type,
                                     resource_identifier, setting, scope);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 bool ContentSettingsContentSettingGetResourceIdentifiersFunction::RunAsync() {
   ContentSettingsType content_type;
   EXTENSION_FUNCTION_VALIDATE(RemoveContentType(args_.get(), &content_type));
 
   if (content_type != CONTENT_SETTINGS_TYPE_PLUGINS) {
     SendResponse(true);
     return true;
   }
@@ skipping 27 matching lines @@
   SetResult(std::move(list));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           &ContentSettingsContentSettingGetResourceIdentifiersFunction::
           SendResponse,
           this,
           true));
 }
 
 }  // namespace extensions