[Extensions] Convert some SyncExtensionFunctions

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 256 matching lines @@
 
 bool TabCaptureGetCapturedTabsFunction::RunSync() {
   TabCaptureRegistry* registry = TabCaptureRegistry::Get(GetProfile());
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   if (registry)
     registry->GetCapturedTabs(extension()->id(), list.get());
   SetResult(std::move(list));
   return true;
 }
 
-bool TabCaptureCaptureOffscreenTabFunction::RunSync() {
+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.
   //
   // TODO(miu): Use _api_features.json and extensions::Feature library instead.
   // http://crbug.com/537732
   const bool is_whitelisted_extension =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kWhitelistedExtensionID) == extension()->id() ||
       SimpleFeature::IsIdInArray(extension()->id(), kChromecastExtensionIds,
                                  arraysize(kChromecastExtensionIds)) ||
       SimpleFeature::IsIdInArray(extension()->id(), kMediaRouterExtensionIds,
                                  arraysize(kMediaRouterExtensionIds));
-  if (!is_whitelisted_extension) {
-    error_ = kNotWhitelistedForOffscreenTabApi;
-    return false;
-  }
+  if (!is_whitelisted_extension)
+    return RespondNow(Error(kNotWhitelistedForOffscreenTabApi));
 
   const GURL start_url(params->start_url);
-  if (!IsAcceptableOffscreenTabUrl(start_url)) {
-    SetError(kInvalidStartUrl);
-    return false;
-  }
+  if (!IsAcceptableOffscreenTabUrl(start_url))
+    return RespondNow(Error(kInvalidStartUrl));
 
-  if (!OptionsSpecifyAudioOrVideo(params->options)) {
-    SetError(kNoAudioOrVideo);
-    return false;
-  }
+  if (!OptionsSpecifyAudioOrVideo(params->options))
+    return RespondNow(Error(kNoAudioOrVideo));
 
   content::WebContents* const extension_web_contents = GetSenderWebContents();
   EXTENSION_FUNCTION_VALIDATE(extension_web_contents);
   OffscreenTab* const offscreen_tab =
       OffscreenTabsOwner::Get(extension_web_contents)->OpenNewTab(
           start_url,
           DetermineInitialSize(params->options),
           (is_whitelisted_extension && params->options.presentation_id) ?
               *params->options.presentation_id : std::string());
-  if (!offscreen_tab) {
-    SetError(kTooManyOffscreenTabs);
-    return false;
-  }
+  if (!offscreen_tab)
+    return RespondNow(Error(kTooManyOffscreenTabs));
 
   if (!TabCaptureRegistry::Get(browser_context())->AddRequest(
           offscreen_tab->web_contents(), extension()->id(), true)) {
     // TODO(miu): Allow multiple consumers of single tab capture.
     // http://crbug.com/535336
-    SetError(kCapturingSameOffscreenTab);
-    return false;
+    return RespondNow(Error(kCapturingSameOffscreenTab));
   }
   FilterDeprecatedGoogConstraints(&params->options);
   AddMediaStreamSourceConstraints(offscreen_tab->web_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 complete the
   // request.  See the comment at end of TabCaptureCaptureFunction::RunSync()
   // for more details.
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-  result->MergeDictionary(params->options.ToValue().get());
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(params->options.ToValue()));
 }
 
 // static
 gfx::Size TabCaptureCaptureOffscreenTabFunction::DetermineInitialSize(
     const TabCapture::CaptureOptions& options) {
   static const int kDefaultWidth = 1280;
   static const int kDefaultHeight = 720;
 
   if (!options.video_constraints)
     return gfx::Size(kDefaultWidth, kDefaultHeight);
@@ skipping 32 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