Replacing most of web_task.h with base::Closure + base::WeakPtrFactory.

components/test_runner/test_runner.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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "components/test_runner/app_banner_client.h"
 #include "components/test_runner/layout_dump.h"
 #include "components/test_runner/mock_credential_manager_client.h"
 #include "components/test_runner/mock_screen_orientation_client.h"
 #include "components/test_runner/mock_web_speech_recognizer.h"
 #include "components/test_runner/mock_web_user_media_client.h"
 #include "components/test_runner/pixel_dump.h"
 #include "components/test_runner/spell_check_client.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/test_preferences.h"
 #include "components/test_runner/web_content_settings.h"
+#include "components/test_runner/web_task.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/test_runner/web_test_proxy.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
 #include "third_party/WebKit/public/platform/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebPasswordCredential.h"
@@ skipping 48 matching lines @@
   if (command_line->HasSwitch(switches::kForceDeviceScaleFactor)) {
     double scale;
     std::string value =
         command_line->GetSwitchValueASCII(switches::kForceDeviceScaleFactor);
     if (base::StringToDouble(value, &scale))
       return scale;
   }
   return 1.f;
 }
 
-class HostMethodTask : public WebMethodTask<TestRunner> {
- public:
-  typedef void (TestRunner::*CallbackMethodType)();
-  HostMethodTask(TestRunner* object, CallbackMethodType callback)
-      : WebMethodTask<TestRunner>(object), callback_(callback) {}
-
-  void RunIfValid() override { (object_->*callback_)(); }
-
- private:
-  CallbackMethodType callback_;
-};
-
 }  // namespace
 
-class InvokeCallbackTask : public WebMethodTask<TestRunner> {
- public:
-  InvokeCallbackTask(TestRunner* object, v8::Local<v8::Function> callback)
-      : WebMethodTask<TestRunner>(object),
-        callback_(blink::mainThreadIsolate(), callback),
-        argc_(0) {}
-
-  void RunIfValid() override {
-    v8::Isolate* isolate = blink::mainThreadIsolate();
-    v8::HandleScope handle_scope(isolate);
-    WebFrame* frame = object_->web_view_->mainFrame();
-
-    v8::Local<v8::Context> context = frame->mainWorldScriptContext();
-    if (context.IsEmpty())
-      return;
-
-    v8::Context::Scope context_scope(context);
-
-    scoped_ptr<v8::Local<v8::Value>[]> local_argv;
-    if (argc_) {
-        local_argv.reset(new v8::Local<v8::Value>[argc_]);
-        for (int i = 0; i < argc_; ++i)
-          local_argv[i] = v8::Local<v8::Value>::New(isolate, argv_[i]);
-    }
-
-    frame->callFunctionEvenIfScriptDisabled(
-        v8::Local<v8::Function>::New(isolate, callback_),
-        context->Global(),
-        argc_,
-        local_argv.get());
-  }
-
-  void SetArguments(int argc, v8::Local<v8::Value> argv[]) {
-    v8::Isolate* isolate = blink::mainThreadIsolate();
-    argc_ = argc;
-    argv_.reset(new v8::UniquePersistent<v8::Value>[argc]);
-    for (int i = 0; i < argc; ++i)
-      argv_[i] = v8::UniquePersistent<v8::Value>(isolate, argv[i]);
-  }
-
- private:
-  v8::UniquePersistent<v8::Function> callback_;
-  int argc_;
-  scoped_ptr<v8::UniquePersistent<v8::Value>[]> argv_;
-};
-
 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<TestRunner> controller,
                       WebFrame* frame);
 
  private:
   explicit TestRunnerBindings(
       base::WeakPtr<TestRunner> controller);
@@ skipping 1330 matching lines @@
     runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
 }
 
 void TestRunnerBindings::SetCustomTextOutput(const std::string& output) {
-  runner_->setCustomTextOutput(output);
+  if (runner_)
+    runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
   if (runner_ && runner_->web_view_) {
     WebFrame* target_frame =
         runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
     if (target_frame)
       target_frame->enableViewSourceMode(enabled);
   }
@@ skipping 82 matching lines @@
 
 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() {
   if (runner_)
     runner_->ForceNextDrawingBufferCreationToFail();
 }
 
 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
 }
 
 TestRunner::WorkQueue::WorkQueue(TestRunner* controller)
-    : frozen_(false)
-    , controller_(controller) {}
+    : frozen_(false), controller_(controller), weak_factory_(this) {}
 
 TestRunner::WorkQueue::~WorkQueue() {
   Reset();
 }
 
 void TestRunner::WorkQueue::ProcessWorkSoon() {
   if (controller_->topLoadingFrame())
     return;
 
   if (!queue_.empty()) {
     // We delay processing queued work to avoid recursion problems.
-    controller_->delegate_->PostTask(new WorkQueueTask(this));
+    controller_->PostTask(base::Bind(&TestRunner::WorkQueue::ProcessWork,
+                                     weak_factory_.GetWeakPtr()));
   } else if (!controller_->layout_test_runtime_flags_.wait_until_done()) {
     controller_->delegate_->TestFinished();
   }
 }
 
 void TestRunner::WorkQueue::Reset() {
   frozen_ = false;
   while (!queue_.empty()) {
     delete queue_.front();
     queue_.pop_front();
@@ skipping 17 matching lines @@
     queue_.pop_front();
     if (startedLoad)
       return;
   }
 
   if (!controller_->layout_test_runtime_flags_.wait_until_done() &&
       !controller_->topLoadingFrame())
     controller_->delegate_->TestFinished();
 }
 
-void TestRunner::WorkQueue::WorkQueueTask::RunIfValid() {
-  object_->ProcessWork();
-}
-
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
       web_history_item_count_(0),
       intercept_post_message_(false),
       test_interfaces_(interfaces),
       delegate_(nullptr),
       web_view_(nullptr),
       web_content_settings_(new WebContentSettings()),
@@ skipping 98 matching lines @@
   web_history_item_count_ = 0;
   intercept_post_message_ = false;
 
   web_content_settings_->Reset();
 
   SetUseMockTheme(true);
 
   pointer_locked_ = false;
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 
-  task_list_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
     delegate_->CloseRemainingWindows();
   else
     close_remaining_windows_ = true;
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
 }
 
-void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
-  delegate_->PostTask(task.release());
+void TestRunner::PostTask(const base::Closure& callback) {
+  delegate_->PostTask(new WebCallbackTask(callback));
+}
+
+void TestRunner::PostDelayedTask(long long delay,
+                                 const base::Closure& callback) {
+  delegate_->PostDelayedTask(new WebCallbackTask(callback), delay);
+}
+
+void TestRunner::PostV8Callback(const v8::Local<v8::Function>& callback) {
+  PostTask(base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
+                      v8::UniquePersistent<v8::Function>(
+                          blink::mainThreadIsolate(), callback)));
+}
+
+void TestRunner::PostV8CallbackWithArgs(
+    v8::UniquePersistent<v8::Function> callback,
+    int argc,
+    v8::Local<v8::Value> argv[]) {
+  std::vector<v8::UniquePersistent<v8::Value>> args;
+  for (int i = 0; i < argc; i++) {
+    args.push_back(
+        v8::UniquePersistent<v8::Value>(blink::mainThreadIsolate(), argv[i]));
+  }
+
+  PostTask(base::Bind(&TestRunner::InvokeV8CallbackWithArgs,
+                      weak_factory_.GetWeakPtr(), std::move(callback),
+                      std::move(args)));
+}
+
+void TestRunner::InvokeV8Callback(
+    const v8::UniquePersistent<v8::Function>& callback) {
+  std::vector<v8::UniquePersistent<v8::Value>> empty_args;
+  InvokeV8CallbackWithArgs(callback, std::move(empty_args));
+}
+
+void TestRunner::InvokeV8CallbackWithArgs(
+    const v8::UniquePersistent<v8::Function>& callback,
+    const std::vector<v8::UniquePersistent<v8::Value>>& args) {
+  v8::Isolate* isolate = blink::mainThreadIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  if (!web_view_)
+    return;
+  WebFrame* frame = web_view_->mainFrame();
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
+  if (context.IsEmpty())
+    return;
+  v8::Context::Scope context_scope(context);
+
+  std::vector<v8::Local<v8::Value>> local_args;
+  for (const auto& arg : args) {
+    local_args.push_back(v8::Local<v8::Value>::New(isolate, arg));
+  }
+
+  frame->callFunctionEvenIfScriptDisabled(
+      v8::Local<v8::Function>::New(isolate, callback), context->Global(),
+      local_args.size(), local_args.data());
+}
+
+base::Closure TestRunner::CreateClosureThatPostsV8Callback(
+    const v8::Local<v8::Function>& callback) {
+  return base::Bind(
+      &TestRunner::PostTask, weak_factory_.GetWeakPtr(),
+      base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
+                 v8::UniquePersistent<v8::Function>(blink::mainThreadIsolate(),
+                                                    callback)));
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return dump_editting_callbacks_;
 }
 
 void TestRunner::setShouldDumpAsText(bool value) {
   layout_test_runtime_flags_.set_dump_as_text(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
@@ skipping 215 matching lines @@
   return intercept_post_message_;
 }
 
 bool TestRunner::shouldDumpResourcePriorities() const {
   return should_dump_resource_priorities_;
 }
 
 bool TestRunner::RequestPointerLock() {
   switch (pointer_lock_planned_result_) {
     case PointerLockWillSucceed:
-      delegate_->PostDelayedTask(
-          new HostMethodTask(this, &TestRunner::DidAcquirePointerLockInternal),
-          0);
+      PostDelayedTask(0, base::Bind(&TestRunner::DidAcquirePointerLockInternal,
+                                    weak_factory_.GetWeakPtr()));
       return true;
     case PointerLockWillRespondAsync:
       DCHECK(!pointer_locked_);
       return true;
     case PointerLockWillFailSync:
       DCHECK(!pointer_locked_);
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 void TestRunner::RequestPointerUnlock() {
-  delegate_->PostDelayedTask(
-      new HostMethodTask(this, &TestRunner::DidLosePointerLockInternal), 0);
+  PostDelayedTask(0, base::Bind(&TestRunner::DidLosePointerLockInternal,
+                                weak_factory_.GetWeakPtr()));
 }
 
 bool TestRunner::isPointerLocked() {
   return pointer_locked_;
 }
 
 void TestRunner::setToolTipText(const WebString& text) {
   tooltip_text_ = text.utf8();
 }
 
@@ skipping 29 matching lines @@
   bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->GoToOffset(distance_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   int distance_;
 };
 
 void TestRunner::NotifyDone() {
-  // Test didn't timeout. Kill the timeout timer.
-  task_list_.RevokeAll();
+  // Test didn't timeout. Kill the pending callbacks.
+  weak_factory_.InvalidateWeakPtrs();
 
   CompleteNotifyDone();
 }
 
 void TestRunner::WaitUntilDone() {
   layout_test_runtime_flags_.set_wait_until_done(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::QueueBackNavigation(int how_far_back) {
@@ skipping 853 matching lines @@
   delegate_->SetFocus(proxy_->web_view(), value);
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
   return delegate_->PathToLocalResource(path);
 }
 
 void TestRunner::SetBackingScaleFactor(double value,
                                        v8::Local<v8::Function> callback) {
   delegate_->SetDeviceScaleFactor(value);
-  delegate_->PostTask(new InvokeCallbackTask(this, callback));
+  PostV8Callback(callback);
 }
 
 void TestRunner::EnableUseZoomForDSF(v8::Local<v8::Function> callback) {
   delegate_->EnableUseZoomForDSF();
-  delegate_->PostTask(new InvokeCallbackTask(this, callback));
+  PostV8Callback(callback);
 }
 
 void TestRunner::SetColorProfile(const std::string& name,
                                  v8::Local<v8::Function> callback) {
   delegate_->SetDeviceColorProfile(name);
-  delegate_->PostTask(new InvokeCallbackTask(this, callback));
+  PostV8Callback(callback);
 }
 
 void TestRunner::SetBluetoothFakeAdapter(const std::string& adapter_name,
                                          v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(new InvokeCallbackTask(this, callback));
   delegate_->SetBluetoothFakeAdapter(
-      adapter_name,
-      base::Bind(&TestRunner::InvokeCallback, weak_factory_.GetWeakPtr(),
-                 base::Passed(&task)));
+      adapter_name, CreateClosureThatPostsV8Callback(callback));
 }
 
 void TestRunner::SetBluetoothManualChooser(bool enable) {
   delegate_->SetBluetoothManualChooser(enable);
 }
 
 void TestRunner::GetBluetoothManualChooserEvents(
     v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(new InvokeCallbackTask(this, callback));
   return delegate_->GetBluetoothManualChooserEvents(
       base::Bind(&TestRunner::GetBluetoothManualChooserEventsCallback,
-                 weak_factory_.GetWeakPtr(), base::Passed(&task)));
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(v8::UniquePersistent<v8::Function>(
+                     blink::mainThreadIsolate(), callback))));
 }
 
 void TestRunner::SendBluetoothManualChooserEvent(const std::string& event,
                                                  const std::string& argument) {
   delegate_->SendBluetoothManualChooserEvent(event, argument);
 }
 
 void TestRunner::SetGeofencingMockProvider(bool service_available) {
   delegate_->SetGeofencingMockProvider(service_available);
 }
@@ skipping 10 matching lines @@
                                const std::string& value,
                                const GURL& origin,
                                const GURL& embedding_origin) {
   delegate_->SetPermission(name, value, origin, embedding_origin);
 }
 
 void TestRunner::DispatchBeforeInstallPromptEvent(
     int request_id,
     const std::vector<std::string>& event_platforms,
     v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(
-      new InvokeCallbackTask(this, callback));
-
   delegate_->DispatchBeforeInstallPromptEvent(
       request_id, event_platforms,
       base::Bind(&TestRunner::DispatchBeforeInstallPromptCallback,
-                 weak_factory_.GetWeakPtr(), base::Passed(&task)));
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(v8::UniquePersistent<v8::Function>(
+                     blink::mainThreadIsolate(), callback))));
 }
 
 void TestRunner::ResolveBeforeInstallPromptPromise(
     int request_id,
     const std::string& platform) {
   test_interfaces_->GetAppBannerClient()->ResolvePromise(request_id, platform);
 }
 
 void TestRunner::SetPOSIXLocale(const std::string& locale) {
   delegate_->SetLocale(locale);
@@ skipping 50 matching lines @@
 void TestRunner::RemoveWebPageOverlay() {
   if (web_view_)
     web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
 }
 
 void TestRunner::LayoutAndPaintAsync() {
   proxy_->LayoutAndPaintAsyncThen(base::Closure());
 }
 
 void TestRunner::LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(
-      new InvokeCallbackTask(this, callback));
-  proxy_->LayoutAndPaintAsyncThen(base::Bind(&TestRunner::InvokeCallback,
-                                             weak_factory_.GetWeakPtr(),
-                                             base::Passed(&task)));
+  proxy_->LayoutAndPaintAsyncThen(CreateClosureThatPostsV8Callback(callback));
 }
 
 void TestRunner::GetManifestThen(v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(
-      new InvokeCallbackTask(this, callback));
+  v8::UniquePersistent<v8::Function> persistent_callback(
+      blink::mainThreadIsolate(), callback);
+
+  if (!web_view_) {
+    WebURLResponse response;
+    response.setHTTPStatusCode(404);
+    GetManifestCallback(std::move(persistent_callback), response, "");
+    return;
+  }
 
   delegate_->FetchManifest(
       web_view_, web_view_->mainFrame()->document().manifestURL(),
       base::Bind(&TestRunner::GetManifestCallback, weak_factory_.GetWeakPtr(),
-                 base::Passed(&task)));
+                 base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(new InvokeCallbackTask(this, callback));
-  DumpPixelsAsync(proxy_->web_view(),
-                  base::Bind(&TestRunner::CapturePixelsCallback,
-                             weak_factory_.GetWeakPtr(), base::Passed(&task)));
+  v8::UniquePersistent<v8::Function> persistent_callback(
+      blink::mainThreadIsolate(), callback);
+
+  if (!web_view_) {
+    CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
+    return;
+  }
+
+  DumpPixelsAsync(
+      proxy_->web_view(),
+      base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::OnLayoutTestRuntimeFlagsChanged() {
   if (layout_test_runtime_flags_.tracked_dictionary().changed_values().empty())
     return;
 
   delegate_->OnLayoutTestRuntimeFlagsChanged(
       layout_test_runtime_flags_.tracked_dictionary().changed_values());
   layout_test_runtime_flags_.tracked_dictionary().ResetChangeTracking();
 }
 
 void TestRunner::ForceNextWebGLContextCreationToFail() {
   if (web_view_)
     web_view_->forceNextWebGLContextCreationToFail();
 }
 
 void TestRunner::ForceNextDrawingBufferCreationToFail() {
   if (web_view_)
     web_view_->forceNextDrawingBufferCreationToFail();
 }
 
 void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(
-      new InvokeCallbackTask(this, callback));
+  v8::UniquePersistent<v8::Function> persistent_callback(
+      blink::mainThreadIsolate(), callback);
+
+  if (!web_view_) {
+    CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
+    return;
+  }
+
   CopyImageAtAndCapturePixels(
       proxy_->web_view(), x, y,
       base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
-                 base::Passed(&task)));
+                 base::Passed(std::move(persistent_callback))));
 }
 
-void TestRunner::GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
-                                     const blink::WebURLResponse& response,
-                                     const std::string& data) {
-  InvokeCallback(std::move(task));
+void TestRunner::GetManifestCallback(
+    v8::UniquePersistent<v8::Function> callback,
+    const blink::WebURLResponse& response,
+    const std::string& data) {
+  PostV8CallbackWithArgs(std::move(callback), 0, nullptr);
 }
 
-void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
-                                       const SkBitmap& snapshot) {
+void TestRunner::CapturePixelsCallback(
+    v8::UniquePersistent<v8::Function> callback,
+    const SkBitmap& snapshot) {
+  if (!web_view_)
+    return;
+
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
   v8::Local<v8::Context> context =
       web_view_->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
   v8::Local<v8::Value> argv[3];
@@ skipping 18 matching lines @@
                            buffer.data(),
                            bufferRowBytes,
                            0, 0)) {
     // We only expect readPixels to fail for null bitmaps.
     DCHECK(snapshot.isNull());
   }
 
   argv[2] = blink::WebArrayBufferConverter::toV8Value(
       &buffer, context->Global(), isolate);
 
-  task->SetArguments(3, argv);
-  InvokeCallback(std::move(task));
+  PostV8CallbackWithArgs(std::move(callback), arraysize(argv), argv);
 }
 
 void TestRunner::DispatchBeforeInstallPromptCallback(
-    scoped_ptr<InvokeCallbackTask> task,
+    v8::UniquePersistent<v8::Function> callback,
     bool canceled) {
+  if (!web_view_)
+    return;
+
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
   v8::Local<v8::Context> context =
       web_view_->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
-  v8::Local<v8::Value> argv[1];
-  argv[0] = v8::Boolean::New(isolate, canceled);
+  v8::Local<v8::Value> arg;
+  arg = v8::Boolean::New(isolate, canceled);
 
-  task->SetArguments(1, argv);
-  InvokeCallback(std::move(task));
+  PostV8CallbackWithArgs(std::move(callback), 1, &arg);
 }
 
 void TestRunner::GetBluetoothManualChooserEventsCallback(
-    scoped_ptr<InvokeCallbackTask> task,
+    v8::UniquePersistent<v8::Function> callback,
     const std::vector<std::string>& events) {
+  if (!web_view_)
+    return;
+
   // Build the V8 context.
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       web_view_->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
   v8::Context::Scope context_scope(context);
 
   // Convert the argument.
-  v8::Local<v8::Value> arg[1];
-  if (!gin::TryConvertToV8(isolate, events, &arg[0]))
+  v8::Local<v8::Value> arg;
+  if (!gin::TryConvertToV8(isolate, events, &arg))
     return;
 
   // Call the callback.
-  task->SetArguments(1, arg);
-  InvokeCallback(std::move(task));
+  PostV8CallbackWithArgs(std::move(callback), 1, &arg);
 }
 
 void TestRunner::LocationChangeDone() {
   web_history_item_count_ = delegate_->NavigationEntryCount();
 
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
   if (!layout_test_runtime_flags_.wait_until_done())
     work_queue_.ProcessWorkSoon();
@@ skipping 45 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner