[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/tab_capture/tab_capture_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.
 
 // Implements the Chrome Extensions Tab Capture API.
 
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_api.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 181 matching lines @@
     kBetaChromecastExtensionId,          // Google Cast Beta
     kStableChromecastExtensionId,        // Google Cast Stable
     "hlgmmjhlnlapooncikdpiiokdjcdpjme",  // Test cast extension
 };
 
 const char* const kMediaRouterExtensionIds[] = {
     "pkedcjkdefgpdelpbcmbmeomcjbeemfm",  // Stable
     "ekpaaapppgpmolpcldedioblbkmijaca",  // Beta
 };
 
-bool TabCaptureCaptureFunction::RunSync() {
+ExtensionFunction::ResponseAction TabCaptureCaptureFunction::Run() {
   std::unique_ptr<api::tab_capture::Capture::Params> params =
       TabCapture::Capture::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Figure out the active WebContents and retrieve the needed ids.
-  Browser* target_browser =
-      chrome::FindAnyBrowser(GetProfile(), include_incognito());
-  if (!target_browser) {
-    error_ = kFindingTabError;
-    return false;
-  }
+  Browser* target_browser = chrome::FindAnyBrowser(
+      Profile::FromBrowserContext(browser_context()), include_incognito());
+  if (!target_browser)
+    return RespondNow(Error(kFindingTabError));
 
   content::WebContents* target_contents =
       target_browser->tab_strip_model()->GetActiveWebContents();
-  if (!target_contents) {
-    error_ = kFindingTabError;
-    return false;
-  }
+  if (!target_contents)
+    return RespondNow(Error(kFindingTabError));
 
   const std::string& extension_id = extension()->id();
 
   // Make sure either we have been granted permission to capture through an
   // extension icon click or our extension is whitelisted.
   if (!extension()->permissions_data()->HasAPIPermissionForTab(
           SessionTabHelper::IdForTab(target_contents),
           APIPermission::kTabCaptureForTab) &&
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kWhitelistedExtensionID) != extension_id &&
       !SimpleFeature::IsIdInArray(extension_id, kChromecastExtensionIds,
                                   arraysize(kChromecastExtensionIds)) &&
       !SimpleFeature::IsIdInArray(extension_id, kMediaRouterExtensionIds,
                                   arraysize(kMediaRouterExtensionIds))) {
-    error_ = kGrantError;
-    return false;
+    return RespondNow(Error(kGrantError));
   }
 
-  if (!OptionsSpecifyAudioOrVideo(params->options)) {
-    error_ = kNoAudioOrVideo;
-    return false;
-  }
+  if (!OptionsSpecifyAudioOrVideo(params->options))
+    return RespondNow(Error(kNoAudioOrVideo));
 
-  TabCaptureRegistry* registry = TabCaptureRegistry::Get(GetProfile());
+  TabCaptureRegistry* registry = TabCaptureRegistry::Get(browser_context());
   if (!registry->AddRequest(target_contents, extension_id, false)) {
     // TODO(miu): Allow multiple consumers of single tab capture.
     // http://crbug.com/535336
-    error_ = kCapturingSameTab;
-    return false;
+    return RespondNow(Error(kCapturingSameTab));
   }
   FilterDeprecatedGoogConstraints(&params->options);
   AddMediaStreamSourceConstraints(target_contents, &params->options);
 
   // At this point, everything is set up in the browser process.  It's now up to
   // the custom JS bindings in the extension's render process to request a
   // MediaStream using navigator.webkitGetUserMedia().  The result dictionary,
   // passed to SetResult() here, contains the extra "hidden options" that will
   // allow the Chrome platform implementation for getUserMedia() to start the
   // virtual audio/video capture devices and set up all the data flows.  The
   // custom JS bindings can be found here:
   // chrome/renderer/resources/extensions/tab_capture_custom_bindings.js
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->MergeDictionary(params->options.ToValue().get());
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool TabCaptureGetCapturedTabsFunction::RunSync() {
-  TabCaptureRegistry* registry = TabCaptureRegistry::Get(GetProfile());
+ExtensionFunction::ResponseAction TabCaptureGetCapturedTabsFunction::Run() {
+  TabCaptureRegistry* registry = TabCaptureRegistry::Get(browser_context());
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   if (registry)
     registry->GetCapturedTabs(extension()->id(), list.get());
-  SetResult(std::move(list));
-  return true;
+  return RespondNow(OneArgument(std::move(list)));
 }
 
 ExtensionFunction::ResponseAction TabCaptureCaptureOffscreenTabFunction::Run() {
   std::unique_ptr<TabCapture::CaptureOffscreenTab::Params> params =
       TabCapture::CaptureOffscreenTab::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Make sure the extension is whitelisted for using this API, regardless of
   // Chrome channel.
   //
@@ skipping 87 matching lines @@
     }
   }
 
   // No maximum size was provided, so just return the default size bounded by
   // the minimum size.
   return gfx::Size(std::max(kDefaultWidth, min_size.width()),
                    std::max(kDefaultHeight, min_size.height()));
 }
 
 }  // namespace extensions