[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/extension_action/extension_action_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/extension_action/extension_action_api.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 305 matching lines @@
 ExtensionActionFunction::ExtensionActionFunction()
     : details_(NULL),
       tab_id_(ExtensionAction::kDefaultTabId),
       contents_(NULL),
       extension_action_(NULL) {
 }
 
 ExtensionActionFunction::~ExtensionActionFunction() {
 }
 
-bool ExtensionActionFunction::RunSync() {
-  ExtensionActionManager* manager = ExtensionActionManager::Get(GetProfile());
+ExtensionFunction::ResponseAction ExtensionActionFunction::Run() {
+  ExtensionActionManager* manager =
+      ExtensionActionManager::Get(browser_context());
   if (base::StartsWith(name(), "systemIndicator.",
                        base::CompareCase::INSENSITIVE_ASCII)) {
     extension_action_ = manager->GetSystemIndicator(*extension());
   } else {
     extension_action_ = manager->GetBrowserAction(*extension());
     if (!extension_action_) {
       extension_action_ = manager->GetPageAction(*extension());
     }
   }
   if (!extension_action_) {
     // TODO(kalman): ideally the browserAction/pageAction APIs wouldn't event
     // exist for extensions that don't have one declared. This should come as
     // part of the Feature system.
-    error_ = kNoExtensionActionError;
-    return false;
+    return RespondNow(Error(kNoExtensionActionError));
   }
 
   // Populates the tab_id_ and details_ members.
   EXTENSION_FUNCTION_VALIDATE(ExtractDataFromArguments());
 
   // Find the WebContents that contains this tab id if one is required.
   if (tab_id_ != ExtensionAction::kDefaultTabId) {
-    ExtensionTabUtil::GetTabById(tab_id_,
-                                 GetProfile(),
-                                 include_incognito(),
-                                 NULL,
-                                 NULL,
-                                 &contents_,
-                                 NULL);
-    if (!contents_) {
-      error_ = ErrorUtils::FormatErrorMessage(
-          kNoTabError, base::IntToString(tab_id_));
-      return false;
-    }
+    ExtensionTabUtil::GetTabById(tab_id_, browser_context(),
+                                 include_incognito(), nullptr, nullptr,
+                                 &contents_, nullptr);
+    if (!contents_)
+      return RespondNow(Error(kNoTabError, base::IntToString(tab_id_)));
   } else {
     // Only browser actions and system indicators have a default tabId.
     ActionInfo::Type action_type = extension_action_->action_type();
     EXTENSION_FUNCTION_VALIDATE(
         action_type == ActionInfo::TYPE_BROWSER ||
         action_type == ActionInfo::TYPE_SYSTEM_INDICATOR);
   }
   return RunExtensionAction();
 }
 
@@ skipping 38 matching lines @@
       break;
 
     default:
       return false;
   }
 
   return true;
 }
 
 void ExtensionActionFunction::NotifyChange() {
-  ExtensionActionAPI::Get(GetProfile())->NotifyChange(
-      extension_action_, contents_, GetProfile());
+  ExtensionActionAPI::Get(browser_context())
+      ->NotifyChange(extension_action_, contents_, browser_context());
 }
 
-bool ExtensionActionFunction::SetVisible(bool visible) {
+void ExtensionActionFunction::SetVisible(bool visible) {
   if (extension_action_->GetIsVisible(tab_id_) == visible)
-    return true;
+    return;
   extension_action_->SetIsVisible(tab_id_, visible);
   NotifyChange();
-  return true;
 }
 
-bool ExtensionActionShowFunction::RunExtensionAction() {
-  return SetVisible(true);
+ExtensionFunction::ResponseAction
+ExtensionActionShowFunction::RunExtensionAction() {
+  SetVisible(true);
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionHideFunction::RunExtensionAction() {
-  return SetVisible(false);
+ExtensionFunction::ResponseAction
+ExtensionActionHideFunction::RunExtensionAction() {
+  SetVisible(false);
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionSetIconFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionSetIconFunction::RunExtensionAction() {
   EXTENSION_FUNCTION_VALIDATE(details_);
 
   // setIcon can take a variant argument: either a dictionary of canvas
   // ImageData, or an icon index.
   base::DictionaryValue* canvas_set = NULL;
   int icon_index;
   if (details_->GetDictionary("imageData", &canvas_set)) {
     gfx::ImageSkia icon;
 
     EXTENSION_FUNCTION_VALIDATE(
         ExtensionAction::ParseIconFromCanvasDictionary(*canvas_set, &icon));
 
-    if (icon.isNull()) {
-      error_ = "Icon invalid.";
-      return false;
-    }
+    if (icon.isNull())
+      return RespondNow(Error("Icon invalid."));
 
     extension_action_->SetIcon(tab_id_, gfx::Image(icon));
   } else if (details_->GetInteger("iconIndex", &icon_index)) {
     // Obsolete argument: ignore it.
-    return true;
+    return RespondNow(NoArguments());
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
   NotifyChange();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionSetTitleFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionSetTitleFunction::RunExtensionAction() {
   EXTENSION_FUNCTION_VALIDATE(details_);
   std::string title;
   EXTENSION_FUNCTION_VALIDATE(details_->GetString("title", &title));
   extension_action_->SetTitle(tab_id_, title);
   NotifyChange();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionSetPopupFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionSetPopupFunction::RunExtensionAction() {
   EXTENSION_FUNCTION_VALIDATE(details_);
   std::string popup_string;
   EXTENSION_FUNCTION_VALIDATE(details_->GetString("popup", &popup_string));
 
   GURL popup_url;
   if (!popup_string.empty())
     popup_url = extension()->GetResourceURL(popup_string);
 
   extension_action_->SetPopupUrl(tab_id_, popup_url);
   NotifyChange();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionSetBadgeTextFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionSetBadgeTextFunction::RunExtensionAction() {
   EXTENSION_FUNCTION_VALIDATE(details_);
   std::string badge_text;
   EXTENSION_FUNCTION_VALIDATE(details_->GetString("text", &badge_text));
   extension_action_->SetBadgeText(tab_id_, badge_text);
   NotifyChange();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() {
   EXTENSION_FUNCTION_VALIDATE(details_);
   base::Value* color_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(details_->Get("color", &color_value));
   SkColor color = 0;
   if (color_value->IsType(base::Value::TYPE_LIST)) {
     base::ListValue* list = NULL;
     EXTENSION_FUNCTION_VALIDATE(details_->GetList("color", &list));
     EXTENSION_FUNCTION_VALIDATE(list->GetSize() == 4);
 
     int color_array[4] = {0};
     for (size_t i = 0; i < arraysize(color_array); ++i) {
       EXTENSION_FUNCTION_VALIDATE(list->GetInteger(i, &color_array[i]));
     }
 
     color = SkColorSetARGB(color_array[3], color_array[0],
                            color_array[1], color_array[2]);
   } else if (color_value->IsType(base::Value::TYPE_STRING)) {
     std::string color_string;
     EXTENSION_FUNCTION_VALIDATE(details_->GetString("color", &color_string));
-    if (!image_util::ParseCssColorString(color_string, &color)) {
-      error_ = kInvalidColorError;
-      return false;
-    }
+    if (!image_util::ParseCssColorString(color_string, &color))
+      return RespondNow(Error(kInvalidColorError));
   }
 
   extension_action_->SetBadgeBackgroundColor(tab_id_, color);
   NotifyChange();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool ExtensionActionGetTitleFunction::RunExtensionAction() {
-  SetResult(base::MakeUnique<base::StringValue>(
-      extension_action_->GetTitle(tab_id_)));
-  return true;
+ExtensionFunction::ResponseAction
+ExtensionActionGetTitleFunction::RunExtensionAction() {
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      extension_action_->GetTitle(tab_id_))));
 }
 
-bool ExtensionActionGetPopupFunction::RunExtensionAction() {
-  SetResult(base::MakeUnique<base::StringValue>(
-      extension_action_->GetPopupUrl(tab_id_).spec()));
-  return true;
+ExtensionFunction::ResponseAction
+ExtensionActionGetPopupFunction::RunExtensionAction() {
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      extension_action_->GetPopupUrl(tab_id_).spec())));
 }
 
-bool ExtensionActionGetBadgeTextFunction::RunExtensionAction() {
-  SetResult(base::MakeUnique<base::StringValue>(
-      extension_action_->GetBadgeText(tab_id_)));
-  return true;
+ExtensionFunction::ResponseAction
+ExtensionActionGetBadgeTextFunction::RunExtensionAction() {
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      extension_action_->GetBadgeText(tab_id_))));
 }
 
-bool ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() {
+ExtensionFunction::ResponseAction
+ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() {
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   SkColor color = extension_action_->GetBadgeBackgroundColor(tab_id_);
   list->AppendInteger(static_cast<int>(SkColorGetR(color)));
   list->AppendInteger(static_cast<int>(SkColorGetG(color)));
   list->AppendInteger(static_cast<int>(SkColorGetB(color)));
   list->AppendInteger(static_cast<int>(SkColorGetA(color)));
-  SetResult(std::move(list));
-  return true;
+  return RespondNow(OneArgument(std::move(list)));
 }
 
 BrowserActionOpenPopupFunction::BrowserActionOpenPopupFunction()
     : response_sent_(false) {
 }
 
 bool BrowserActionOpenPopupFunction::RunAsync() {
   // We only allow the popup in the active window.
   Profile* profile = GetProfile();
   Browser* browser = chrome::FindLastActiveWithProfile(profile);
@@ skipping 61 matching lines @@
   if (host->extension_host_type() != VIEW_TYPE_EXTENSION_POPUP ||
       host->extension()->id() != extension_->id())
     return;
 
   SendResponse(true);
   response_sent_ = true;
   registrar_.RemoveAll();
 }
 
 }  // namespace extensions