[Extensions] DCHECK that ExtensionFunctions respond (and only once)

extensions/browser/api/guest_view/web_view/web_view_internal_api.cc

 // Copyright 2014 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/guest_view/web_view/web_view_internal_api.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 230 matching lines @@
     script.set_consumer_instance_type(UserScript::WEBVIEW);
     result->insert(script);
   }
   return true;
 }
 
 }  // namespace
 
 namespace extensions {
 
-bool WebViewInternalExtensionFunction::RunAsync() {
+bool LegacyWebViewInternalExtensionFunction::RunAsync() {
   int instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &instance_id));
   WebViewGuest* guest = WebViewGuest::From(
       render_frame_host()->GetProcess()->GetID(), instance_id);
   if (!guest)
     return false;
 
   return RunAsyncSafe(guest);
 }
 
+bool WebViewInternalExtensionFunction::PreRunValidation(std::string* error) {
+  int instance_id = 0;
+  EXTENSION_FUNCTION_PRERUN_VALIDATE(args_->GetInteger(0, &instance_id));
+  guest_ = WebViewGuest::From(render_frame_host()->GetProcess()->GetID(),
+                              instance_id);
+  if (!guest_) {
+    *error = "Could not find guest";
+    return false;
+  }
+  return true;
+}
+
 WebViewInternalCaptureVisibleRegionFunction::
     WebViewInternalCaptureVisibleRegionFunction()
     : is_guest_transparent_(false) {}
 
 bool WebViewInternalCaptureVisibleRegionFunction::RunAsyncSafe(
     WebViewGuest* guest) {
   using api::extension_types::ImageDetails;
 
   std::unique_ptr<web_view_internal::CaptureVisibleRegion::Params> params(
       web_view_internal::CaptureVisibleRegion::Params::Create(*args_));
@@ skipping 45 matching lines @@
       break;
     case FAILURE_REASON_VIEW_INVISIBLE:
       reason_description = "view is invisible";
       break;
   }
   error_ = ErrorUtils::FormatErrorMessage("Failed to capture webview: *",
                                           reason_description);
   SendResponse(false);
 }
 
-bool WebViewInternalNavigateFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalNavigateFunction::Run() {
   std::unique_ptr<web_view_internal::Navigate::Params> params(
       web_view_internal::Navigate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   std::string src = params->src;
-  guest->NavigateGuest(src, true /* force_navigation */);
-  return true;
+  guest_->NavigateGuest(src, true /* force_navigation */);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalExecuteCodeFunction::WebViewInternalExecuteCodeFunction()
-    : guest_instance_id_(0), guest_src_(GURL::EmptyGURL()) {
-}
+    : guest_instance_id_(0) {}
 
 WebViewInternalExecuteCodeFunction::~WebViewInternalExecuteCodeFunction() {
 }
 
 bool WebViewInternalExecuteCodeFunction::Init() {
   if (details_.get())
     return true;
 
   if (!args_->GetInteger(0, &guest_instance_id_))
     return false;
@@ skipping 190 matching lines @@
       params->instance_id, host_id, script_name_list);
   return RespondNow(NoArguments());
 }
 
 WebViewInternalSetNameFunction::WebViewInternalSetNameFunction() {
 }
 
 WebViewInternalSetNameFunction::~WebViewInternalSetNameFunction() {
 }
 
-bool WebViewInternalSetNameFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalSetNameFunction::Run() {
   std::unique_ptr<web_view_internal::SetName::Params> params(
       web_view_internal::SetName::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  guest->SetName(params->frame_name);
-  SendResponse(true);
-  return true;
+  guest_->SetName(params->frame_name);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 WebViewInternalSetAllowTransparencyFunction() {
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 ~WebViewInternalSetAllowTransparencyFunction() {
 }
 
-bool WebViewInternalSetAllowTransparencyFunction::RunAsyncSafe(
-    WebViewGuest* guest) {
+ExtensionFunction::ResponseAction
+WebViewInternalSetAllowTransparencyFunction::Run() {
   std::unique_ptr<web_view_internal::SetAllowTransparency::Params> params(
       web_view_internal::SetAllowTransparency::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  guest->SetAllowTransparency(params->allow);
-  SendResponse(true);
-  return true;
+  guest_->SetAllowTransparency(params->allow);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalSetAllowScalingFunction::
     WebViewInternalSetAllowScalingFunction() {
 }
 
 WebViewInternalSetAllowScalingFunction::
     ~WebViewInternalSetAllowScalingFunction() {
 }
 
-bool WebViewInternalSetAllowScalingFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction
+WebViewInternalSetAllowScalingFunction::Run() {
   std::unique_ptr<web_view_internal::SetAllowScaling::Params> params(
       web_view_internal::SetAllowScaling::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  guest->SetAllowScaling(params->allow);
-  SendResponse(true);
-  return true;
+  guest_->SetAllowScaling(params->allow);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalSetZoomFunction::WebViewInternalSetZoomFunction() {
 }
 
 WebViewInternalSetZoomFunction::~WebViewInternalSetZoomFunction() {
 }
 
-bool WebViewInternalSetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalSetZoomFunction::Run() {
   std::unique_ptr<web_view_internal::SetZoom::Params> params(
       web_view_internal::SetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  guest->SetZoom(params->zoom_factor);
-
-  SendResponse(true);
-  return true;
+  guest_->SetZoom(params->zoom_factor);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalGetZoomFunction::WebViewInternalGetZoomFunction() {
 }
 
 WebViewInternalGetZoomFunction::~WebViewInternalGetZoomFunction() {
 }
 
-bool WebViewInternalGetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalGetZoomFunction::Run() {
   std::unique_ptr<web_view_internal::GetZoom::Params> params(
       web_view_internal::GetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  double zoom_factor = guest->GetZoom();
-  SetResult(base::MakeUnique<base::FundamentalValue>(zoom_factor));
-  SendResponse(true);
-  return true;
+  double zoom_factor = guest_->GetZoom();
+  return RespondNow(
+      OneArgument(base::MakeUnique<base::FundamentalValue>(zoom_factor)));
 }
 
 WebViewInternalSetZoomModeFunction::WebViewInternalSetZoomModeFunction() {
 }
 
 WebViewInternalSetZoomModeFunction::~WebViewInternalSetZoomModeFunction() {
 }
 
-bool WebViewInternalSetZoomModeFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalSetZoomModeFunction::Run() {
   std::unique_ptr<web_view_internal::SetZoomMode::Params> params(
       web_view_internal::SetZoomMode::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ZoomController::ZoomMode zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
   switch (params->zoom_mode) {
     case web_view_internal::ZOOM_MODE_PER_ORIGIN:
       zoom_mode = ZoomController::ZOOM_MODE_DEFAULT;
       break;
     case web_view_internal::ZOOM_MODE_PER_VIEW:
       zoom_mode = ZoomController::ZOOM_MODE_ISOLATED;
       break;
     case web_view_internal::ZOOM_MODE_DISABLED:
       zoom_mode = ZoomController::ZOOM_MODE_DISABLED;
       break;
     default:
       NOTREACHED();
   }
 
-  guest->SetZoomMode(zoom_mode);
-
-  SendResponse(true);
-  return true;
+  guest_->SetZoomMode(zoom_mode);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalGetZoomModeFunction::WebViewInternalGetZoomModeFunction() {
 }
 
 WebViewInternalGetZoomModeFunction::~WebViewInternalGetZoomModeFunction() {
 }
 
-bool WebViewInternalGetZoomModeFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalGetZoomModeFunction::Run() {
   std::unique_ptr<web_view_internal::GetZoomMode::Params> params(
       web_view_internal::GetZoomMode::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   web_view_internal::ZoomMode zoom_mode = web_view_internal::ZOOM_MODE_NONE;
-  switch (guest->GetZoomMode()) {
+  switch (guest_->GetZoomMode()) {
     case ZoomController::ZOOM_MODE_DEFAULT:
       zoom_mode = web_view_internal::ZOOM_MODE_PER_ORIGIN;
       break;
     case ZoomController::ZOOM_MODE_ISOLATED:
       zoom_mode = web_view_internal::ZOOM_MODE_PER_VIEW;
       break;
     case ZoomController::ZOOM_MODE_DISABLED:
       zoom_mode = web_view_internal::ZOOM_MODE_DISABLED;
       break;
     default:
       NOTREACHED();
   }
 
-  SetResult(base::MakeUnique<base::StringValue>(
-      web_view_internal::ToString(zoom_mode)));
-  SendResponse(true);
-  return true;
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      web_view_internal::ToString(zoom_mode))));
 }
 
 WebViewInternalFindFunction::WebViewInternalFindFunction() {
 }
 
 WebViewInternalFindFunction::~WebViewInternalFindFunction() {
 }
 
 bool WebViewInternalFindFunction::RunAsyncSafe(WebViewGuest* guest) {
   std::unique_ptr<web_view_internal::Find::Params> params(
@@ skipping 17 matching lines @@
   guest->StartFind(search_text, options, this);
   return true;
 }
 
 WebViewInternalStopFindingFunction::WebViewInternalStopFindingFunction() {
 }
 
 WebViewInternalStopFindingFunction::~WebViewInternalStopFindingFunction() {
 }
 
-bool WebViewInternalStopFindingFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalStopFindingFunction::Run() {
   std::unique_ptr<web_view_internal::StopFinding::Params> params(
       web_view_internal::StopFinding::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Set the StopFindAction.
   content::StopFindAction action;
   switch (params->action) {
     case web_view_internal::STOP_FINDING_ACTION_CLEAR:
       action = content::STOP_FIND_ACTION_CLEAR_SELECTION;
       break;
     case web_view_internal::STOP_FINDING_ACTION_KEEP:
       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
       break;
     case web_view_internal::STOP_FINDING_ACTION_ACTIVATE:
       action = content::STOP_FIND_ACTION_ACTIVATE_SELECTION;
       break;
     default:
       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
   }
 
-  guest->StopFinding(action);
-  return true;
+  guest_->StopFinding(action);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalLoadDataWithBaseUrlFunction::
     WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
 WebViewInternalLoadDataWithBaseUrlFunction::
     ~WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
-bool WebViewInternalLoadDataWithBaseUrlFunction::RunAsyncSafe(
-    WebViewGuest* guest) {
+ExtensionFunction::ResponseAction
+WebViewInternalLoadDataWithBaseUrlFunction::Run() {
   std::unique_ptr<web_view_internal::LoadDataWithBaseUrl::Params> params(
       web_view_internal::LoadDataWithBaseUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // If a virtual URL was provided, use it. Otherwise, the user will be shown
   // the data URL.
   std::string virtual_url =
       params->virtual_url ? *params->virtual_url : params->data_url;
 
-  bool successful = guest->LoadDataWithBaseURL(
+  bool successful = guest_->LoadDataWithBaseURL(
       params->data_url, params->base_url, virtual_url, &error_);
-  SendResponse(successful);
-  return successful;
+  if (successful)
+    return RespondNow(NoArguments());
+  return RespondNow(Error(error_));
 }
 
 WebViewInternalGoFunction::WebViewInternalGoFunction() {
 }
 
 WebViewInternalGoFunction::~WebViewInternalGoFunction() {
 }
 
-bool WebViewInternalGoFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalGoFunction::Run() {
   std::unique_ptr<web_view_internal::Go::Params> params(
       web_view_internal::Go::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  bool successful = guest->Go(params->relative_index);
-  SetResult(base::MakeUnique<base::FundamentalValue>(successful));
-  SendResponse(true);
-  return true;
+  bool successful = guest_->Go(params->relative_index);
+  return RespondNow(
+      OneArgument(base::MakeUnique<base::FundamentalValue>(successful)));
 }
 
 WebViewInternalReloadFunction::WebViewInternalReloadFunction() {
 }
 
 WebViewInternalReloadFunction::~WebViewInternalReloadFunction() {
 }
 
-bool WebViewInternalReloadFunction::RunAsyncSafe(WebViewGuest* guest) {
-  guest->Reload();
-  return true;
+ExtensionFunction::ResponseAction WebViewInternalReloadFunction::Run() {
+  guest_->Reload();
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalSetPermissionFunction::WebViewInternalSetPermissionFunction() {
 }
 
 WebViewInternalSetPermissionFunction::~WebViewInternalSetPermissionFunction() {
 }
 
-bool WebViewInternalSetPermissionFunction::RunAsyncSafe(WebViewGuest* guest) {
+ExtensionFunction::ResponseAction WebViewInternalSetPermissionFunction::Run() {
   std::unique_ptr<web_view_internal::SetPermission::Params> params(
       web_view_internal::SetPermission::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebViewPermissionHelper::PermissionResponseAction action =
       WebViewPermissionHelper::DEFAULT;
   switch (params->action) {
     case api::web_view_internal::SET_PERMISSION_ACTION_ALLOW:
       action = WebViewPermissionHelper::ALLOW;
       break;
     case api::web_view_internal::SET_PERMISSION_ACTION_DENY:
       action = WebViewPermissionHelper::DENY;
       break;
     case api::web_view_internal::SET_PERMISSION_ACTION_DEFAULT:
       break;
     default:
       NOTREACHED();
   }
 
   std::string user_input;
   if (params->user_input)
     user_input = *params->user_input;
 
   WebViewPermissionHelper* web_view_permission_helper =
-      WebViewPermissionHelper::FromWebContents(guest->web_contents());
+      WebViewPermissionHelper::FromWebContents(guest_->web_contents());
 
   WebViewPermissionHelper::SetPermissionResult result =
       web_view_permission_helper->SetPermission(
           params->request_id, action, user_input);
 
   EXTENSION_FUNCTION_VALIDATE(result !=
                               WebViewPermissionHelper::SET_PERMISSION_INVALID);
 
-  SetResult(base::MakeUnique<base::FundamentalValue>(
-      result == WebViewPermissionHelper::SET_PERMISSION_ALLOWED));
-  SendResponse(true);
-  return true;
+  return RespondNow(OneArgument(base::MakeUnique<base::FundamentalValue>(
+      result == WebViewPermissionHelper::SET_PERMISSION_ALLOWED)));
 }
 
 WebViewInternalOverrideUserAgentFunction::
     WebViewInternalOverrideUserAgentFunction() {
 }
 
 WebViewInternalOverrideUserAgentFunction::
     ~WebViewInternalOverrideUserAgentFunction() {
 }
 
-bool WebViewInternalOverrideUserAgentFunction::RunAsyncSafe(
-    WebViewGuest* guest) {
+ExtensionFunction::ResponseAction
+WebViewInternalOverrideUserAgentFunction::Run() {
   std::unique_ptr<web_view_internal::OverrideUserAgent::Params> params(
       web_view_internal::OverrideUserAgent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  guest->SetUserAgentOverride(params->user_agent_override);
-  return true;
+  guest_->SetUserAgentOverride(params->user_agent_override);
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalStopFunction::WebViewInternalStopFunction() {
 }
 
 WebViewInternalStopFunction::~WebViewInternalStopFunction() {
 }
 
-bool WebViewInternalStopFunction::RunAsyncSafe(WebViewGuest* guest) {
-  guest->Stop();
-  return true;
+ExtensionFunction::ResponseAction WebViewInternalStopFunction::Run() {
+  guest_->Stop();
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalTerminateFunction::WebViewInternalTerminateFunction() {
 }
 
 WebViewInternalTerminateFunction::~WebViewInternalTerminateFunction() {
 }
 
-bool WebViewInternalTerminateFunction::RunAsyncSafe(WebViewGuest* guest) {
-  guest->Terminate();
-  return true;
+ExtensionFunction::ResponseAction WebViewInternalTerminateFunction::Run() {
+  guest_->Terminate();
+  return RespondNow(NoArguments());
 }
 
 WebViewInternalClearDataFunction::WebViewInternalClearDataFunction()
     : remove_mask_(0), bad_message_(false) {
 }
 
 WebViewInternalClearDataFunction::~WebViewInternalClearDataFunction() {
 }
 
 // Parses the |dataToRemove| argument to generate the remove mask. Sets
@@ skipping 65 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions