Make AppWindowCreateFunction UIThreadExtensionFunction.

extensions/browser/api/app_window/app_window_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 "extensions/browser/api/app_window/app_window_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 111 matching lines @@
   if (input_spec->max_width.get())
     create_spec->maximum_size.set_width(*input_spec->max_width);
   if (input_spec->max_height.get())
     create_spec->maximum_size.set_height(*input_spec->max_height);
 }
 
 }  // namespace
 
 AppWindowCreateFunction::AppWindowCreateFunction() {}
 
-bool AppWindowCreateFunction::RunAsync() {
+ExtensionFunction::ResponseAction AppWindowCreateFunction::Run() {
   // Don't create app window if the system is shutting down.
   if (ExtensionsBrowserClient::Get()->IsShuttingDown())
-    return false;
+    return RespondNow(Error(kUnknownErrorDoNotUse));
 
   std::unique_ptr<Create::Params> params(Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GURL url = extension()->GetResourceURL(params->url);
   // Allow absolute URLs for component apps, otherwise prepend the extension
   // path.
   // TODO(devlin): Investigate if this is still used. If not, kill it dead!
   GURL absolute = GURL(params->url);
   if (absolute.has_scheme()) {
     if (extension()->location() == Manifest::COMPONENT) {
       url = absolute;
     } else {
       // Show error when url passed isn't local.
-      error_ = app_window_constants::kInvalidUrlParameter;
-      return false;
+      return RespondNow(Error(app_window_constants::kInvalidUrlParameter));
     }
   }
 
   // TODO(jeremya): figure out a way to pass the opening WebContents through to
   // AppWindow::Create so we can set the opener at create time rather than
   // with a hack in AppWindowCustomBindings::GetView().
   AppWindow::CreateParams create_params;
   app_window::CreateWindowOptions* options = params->options.get();
   if (options) {
     if (options->id.get()) {
       // TODO(mek): use URL if no id specified?
       // Limit length of id to 256 characters.
-      if (options->id->length() > 256) {
-        error_ = app_window_constants::kInvalidWindowId;
-        return false;
-      }
+      if (options->id->length() > 256)
+        return RespondNow(Error(app_window_constants::kInvalidWindowId));
 
       create_params.window_key = *options->id;
 
       if (options->singleton && *options->singleton == false) {
         WriteToConsole(
           content::CONSOLE_MESSAGE_LEVEL_WARNING,
           "The 'singleton' option in chrome.apps.window.create() is deprecated!"
           " Change your code to no longer rely on this.");
       }
 
@@ skipping 16 matching lines @@
               existing_window->Show(AppWindow::SHOW_INACTIVE);
             else
               existing_window->Show(AppWindow::SHOW_ACTIVE);
           }
 
           std::unique_ptr<base::DictionaryValue> result(
               new base::DictionaryValue);
           result->Set("frameId", new base::Value(frame_id));
           existing_window->GetSerializedState(result.get());
           result->SetBoolean("existingWindow", true);
-          SetResult(std::move(result));
-          SendResponse(true);
-          return true;
+          return RespondNow(OneArgument(std::move(result)));
         }
       }
     }
 
-    if (!GetBoundsSpec(*options, &create_params, &error_))
-      return false;
+    std::string error;
+    if (!GetBoundsSpec(*options, &create_params, &error))
+      return RespondNow(Error(error));
 
     if (options->type == app_window::WINDOW_TYPE_PANEL) {
 #if defined(OS_CHROMEOS)
       // Panels for v2 apps are only supported on Chrome OS.
       create_params.window_type = AppWindow::WINDOW_TYPE_PANEL;
 #else
       WriteToConsole(content::CONSOLE_MESSAGE_LEVEL_WARNING,
                      "Panels are not supported on this platform");
 #endif
     }
 
-    if (!GetFrameOptions(*options, &create_params))
-      return false;
+    if (!GetFrameOptions(*options, &create_params, &error))
+      return RespondNow(Error(error));
 
     if (extension()->GetType() == Manifest::TYPE_EXTENSION) {
       // Whitelisted IME extensions are allowed to use this API to create IME
       // specific windows to show accented characters or suggestions.
       if (!extension()->permissions_data()->HasAPIPermission(
               APIPermission::kImeWindowEnabled)) {
-        error_ = app_window_constants::kImeWindowMissingPermission;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kImeWindowMissingPermission));
       }
 
 #if !defined(OS_CHROMEOS)
       // IME window is only supported on ChromeOS.
-      error_ = app_window_constants::kImeWindowUnsupportedPlatform;
-      return false;
+      return RespondNow(
+          Error(app_window_constants::kImeWindowUnsupportedPlatform));
 #else
       // IME extensions must create ime window (with "ime: true" and
       // "frame: none") or panel window (with "type: panel").
       if (options->ime.get() && *options->ime.get() &&
           create_params.frame == AppWindow::FRAME_NONE) {
         create_params.is_ime_window = true;
       } else if (options->type == app_window::WINDOW_TYPE_PANEL) {
         create_params.window_type = AppWindow::WINDOW_TYPE_PANEL;
       } else {
-        error_ = app_window_constants::kImeWindowMustBeImeWindowOrPanel;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kImeWindowMustBeImeWindowOrPanel));
       }
 #endif  // OS_CHROMEOS
     } else {
       if (options->ime.get()) {
-        error_ = app_window_constants::kImeOptionIsNotSupported;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kImeOptionIsNotSupported));
       }
     }
 
     if (options->alpha_enabled.get()) {
       const char* const kWhitelist[] = {
 #if defined(OS_CHROMEOS)
         "B58B99751225318C7EB8CF4688B5434661083E07",  // http://crbug.com/410550
         "06BE211D5F014BAB34BC22D9DDA09C63A81D828E",  // http://crbug.com/425539
         "F94EE6AB36D6C6588670B2B01EB65212D9C64E33",
         "B9EF10DDFEA11EF77873CC5009809E5037FC4C7A",  // http://crbug.com/435380
 #endif
         "0F42756099D914A026DADFA182871C015735DD95",  // http://crbug.com/323773
         "2D22CDB6583FD0A13758AEBE8B15E45208B4E9A7",
         "E7E2461CE072DF036CF9592740196159E2D7C089",  // http://crbug.com/356200
         "A74A4D44C7CFCD8844830E6140C8D763E12DD8F3",
         "312745D9BF916161191143F6490085EEA0434997",
         "53041A2FA309EECED01FFC751E7399186E860B2C",
         "A07A5B743CD82A1C2579DB77D353C98A23201EEF",  // http://crbug.com/413748
         "F16F23C83C5F6DAD9B65A120448B34056DD80691",
         "0F585FB1D0FDFBEBCE1FEB5E9DFFB6DA476B8C9B"
       };
       if (AppWindowClient::Get()->IsCurrentChannelOlderThanDev() &&
           !SimpleFeature::IsIdInArray(
               extension_id(), kWhitelist, arraysize(kWhitelist))) {
-        error_ = app_window_constants::kAlphaEnabledWrongChannel;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kAlphaEnabledWrongChannel));
       }
       if (!extension()->permissions_data()->HasAPIPermission(
               APIPermission::kAlphaEnabled)) {
-        error_ = app_window_constants::kAlphaEnabledMissingPermission;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kAlphaEnabledMissingPermission));
       }
       if (create_params.frame != AppWindow::FRAME_NONE) {
-        error_ = app_window_constants::kAlphaEnabledNeedsFrameNone;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kAlphaEnabledNeedsFrameNone));
       }
 #if defined(USE_AURA)
       create_params.alpha_enabled = *options->alpha_enabled;
 #else
       // Transparency is only supported on Aura.
       // Fallback to creating an opaque window (by ignoring alphaEnabled).
 #endif
     }
 
     if (options->hidden.get())
       create_params.hidden = *options->hidden;
 
     if (options->resizable.get())
       create_params.resizable = *options->resizable;
 
     if (options->always_on_top.get()) {
       create_params.always_on_top = *options->always_on_top;
 
       if (create_params.always_on_top &&
           !extension()->permissions_data()->HasAPIPermission(
               APIPermission::kAlwaysOnTopWindows)) {
-        error_ = app_window_constants::kAlwaysOnTopPermission;
-        return false;
+        return RespondNow(Error(app_window_constants::kAlwaysOnTopPermission));
       }
     }
 
     if (options->focused.get())
       create_params.focused = *options->focused;
 
     if (options->visible_on_all_workspaces.get()) {
       create_params.visible_on_all_workspaces =
           *options->visible_on_all_workspaces;
     }
 
     if (options->show_in_shelf.get()) {
       create_params.show_in_shelf = *options->show_in_shelf.get();
 
       if (create_params.show_in_shelf && create_params.window_key.empty()) {
-        error_ = app_window_constants::kShowInShelfWindowKeyNotSet;
-        return false;
+        return RespondNow(
+            Error(app_window_constants::kShowInShelfWindowKeyNotSet));
       }
     }
 
     if (options->icon.get()) {
       // First, check if the window icon URL is a valid global URL.
       create_params.window_icon_url = GURL(*options->icon.get());
 
       // If the URL is not global, check for a valid extension local URL.
       if (!create_params.window_icon_url.is_valid()) {
         create_params.window_icon_url =
@@ skipping 35 matching lines @@
   content::RenderFrameHost* created_frame =
       app_window->web_contents()->GetMainFrame();
   int frame_id = MSG_ROUTING_NONE;
   if (create_params.creator_process_id == created_frame->GetProcess()->GetID())
     frame_id = created_frame->GetRoutingID();
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   result->Set("frameId", new base::Value(frame_id));
   result->Set("id", new base::Value(app_window->window_key()));
   app_window->GetSerializedState(result.get());
-  SetResult(std::move(result));
+  ResponseValue result_arg = OneArgument(std::move(result));
 
   if (AppWindowRegistry::Get(browser_context())
           ->HadDevToolsAttached(app_window->web_contents())) {
     AppWindowClient::Get()->OpenDevToolsWindow(
         app_window->web_contents(),
-        base::Bind(&AppWindowCreateFunction::SendResponse, this, true));
-    return true;
+        base::Bind(&AppWindowCreateFunction::Respond, this,
+                   base::Passed(&result_arg)));
+    // OpenDevToolsWindow might have already responded.
+    return did_respond() ? AlreadyResponded() : RespondLater();
   }
 
   // PlzNavigate: delay sending the response until the newly created window has
   // been told to navigate, and blink has been correctly initialized in the
   // renderer.
   if (content::IsBrowserSideNavigationEnabled()) {
-    app_window->SetOnFirstCommitCallback(
-        base::Bind(&AppWindowCreateFunction::SendResponse, this, true));
-    return true;
+    // SetOnFirstCommitCallback() will respond asynchronously.
+    app_window->SetOnFirstCommitCallback(base::Bind(
+        &AppWindowCreateFunction::Respond, this, base::Passed(&result_arg)));
+    return RespondLater();
   }
-
-  SendResponse(true);
-
-  return true;
+  return RespondNow(std::move(result_arg));
 }
 
 bool AppWindowCreateFunction::GetBoundsSpec(
     const app_window::CreateWindowOptions& options,
     AppWindow::CreateParams* params,
     std::string* error) {
   DCHECK(params);
   DCHECK(error);
 
   if (options.inner_bounds.get() || options.outer_bounds.get()) {
@@ skipping 104 matching lines @@
 AppWindow::Frame AppWindowCreateFunction::GetFrameFromString(
     const std::string& frame_string) {
   if (frame_string == kNoneFrameOption)
     return AppWindow::FRAME_NONE;
 
   return AppWindow::FRAME_CHROME;
 }
 
 bool AppWindowCreateFunction::GetFrameOptions(
     const app_window::CreateWindowOptions& options,
-    AppWindow::CreateParams* create_params) {
+    AppWindow::CreateParams* create_params,
+    std::string* error) {
   if (!options.frame)
     return true;
 
   DCHECK(options.frame->as_string || options.frame->as_frame_options);
   if (options.frame->as_string) {
     create_params->frame = GetFrameFromString(*options.frame->as_string);
     return true;
   }
 
   if (options.frame->as_frame_options->type)
     create_params->frame =
         GetFrameFromString(*options.frame->as_frame_options->type);
 
   if (options.frame->as_frame_options->color.get()) {
     if (create_params->frame != AppWindow::FRAME_CHROME) {
-      error_ = app_window_constants::kColorWithFrameNone;
+      *error = app_window_constants::kColorWithFrameNone;
       return false;
     }
 
     if (!image_util::ParseHexColorString(
             *options.frame->as_frame_options->color,
             &create_params->active_frame_color)) {
-      error_ = app_window_constants::kInvalidColorSpecification;
+      *error = app_window_constants::kInvalidColorSpecification;
       return false;
     }
 
     create_params->has_frame_color = true;
     create_params->inactive_frame_color = create_params->active_frame_color;
 
     if (options.frame->as_frame_options->inactive_color.get()) {
       if (!image_util::ParseHexColorString(
               *options.frame->as_frame_options->inactive_color,
               &create_params->inactive_frame_color)) {
-        error_ = app_window_constants::kInvalidColorSpecification;
+        *error = app_window_constants::kInvalidColorSpecification;
         return false;
       }
     }
 
     return true;
   }
 
   if (options.frame->as_frame_options->inactive_color.get()) {
-    error_ = app_window_constants::kInactiveColorWithoutColor;
+    *error = app_window_constants::kInactiveColorWithoutColor;
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions