Make getBluetoothManualChooserEvents() asynchronous.

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 <limits>
 
 #include "base/logging.h"
 #include "components/test_runner/mock_credential_manager_client.h"
@@ skipping 278 matching lines @@
   void LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback);
   void GetManifestThen(v8::Local<v8::Function> callback);
   void CapturePixelsAsyncThen(v8::Local<v8::Function> callback);
   void CopyImageAtAndCapturePixelsAsyncThen(int x,
                                             int y,
                                             v8::Local<v8::Function> callback);
   void SetCustomTextOutput(std::string output);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void SetBluetoothMockDataSet(const std::string& dataset_name);
   void SetBluetoothManualChooser();
-  std::vector<std::string> GetBluetoothManualChooserEvents();
+  void GetBluetoothManualChooserEvents(v8::Local<v8::Function> callback);
   void SendBluetoothManualChooserEvent(const std::string& event,
                                        const std::string& argument);
   void SetGeofencingMockProvider(bool service_available);
   void ClearGeofencingMockProvider();
   void SetGeofencingMockPosition(double latitude, double longitude);
   void SetPermission(const std::string& name,
                      const std::string& value,
                      const std::string& origin,
                      const std::string& embedding_origin);
   void DispatchBeforeInstallPromptEvent(
@@ skipping 1033 matching lines @@
 void TestRunnerBindings::SetBluetoothMockDataSet(const std::string& name) {
   if (runner_)
     runner_->SetBluetoothMockDataSet(name);
 }
 
 void TestRunnerBindings::SetBluetoothManualChooser() {
   if (runner_)
     runner_->SetBluetoothManualChooser();
 }
 
-std::vector<std::string> TestRunnerBindings::GetBluetoothManualChooserEvents() {
+void TestRunnerBindings::GetBluetoothManualChooserEvents(
+    v8::Local<v8::Function> callback) {
   if (runner_)
-    return runner_->GetBluetoothManualChooserEvents();
-  return std::vector<std::string>(1, "No Test Runner");
+    return runner_->GetBluetoothManualChooserEvents(callback);
 }
 
 void TestRunnerBindings::SendBluetoothManualChooserEvent(
     const std::string& event,
     const std::string& argument) {
   if (runner_)
     runner_->SendBluetoothManualChooserEvent(event, argument);
 }
 
 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) {
@@ skipping 1472 matching lines @@
 }
 
 void TestRunner::SetBluetoothMockDataSet(const std::string& name) {
   delegate_->SetBluetoothMockDataSet(name);
 }
 
 void TestRunner::SetBluetoothManualChooser() {
   delegate_->SetBluetoothManualChooser();
 }
 
-std::vector<std::string> TestRunner::GetBluetoothManualChooserEvents() {
-  return delegate_->GetBluetoothManualChooserEvents();
+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)));
 }
 
 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 194 matching lines @@
     return;
 
   v8::Context::Scope context_scope(context);
   v8::Local<v8::Value> argv[1];
   argv[0] = v8::Boolean::New(isolate, canceled);
 
   task->SetArguments(1, argv);
   InvokeCallback(task.Pass());
 }
 
+void TestRunner::GetBluetoothManualChooserEventsCallback(
+    scoped_ptr<InvokeCallbackTask> task,
+    const std::vector<std::string>& events) {
+  // 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]))
+    return;
+
+  // Call the callback.
+  task->SetArguments(1, arg);
+  InvokeCallback(task.Pass());
+}
+
 void TestRunner::LocationChangeDone() {
   web_history_item_count_ = delegate_->NavigationEntryCount();
 
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
   if (!wait_until_done_)
     work_queue_.ProcessWorkSoon();
 }
 
@@ skipping 34 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner