Make getBluetoothManualChooserEvents() asynchronous.

content/shell/renderer/layout_test/blink_test_runner.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 "content/shell/renderer/layout_test/blink_test_runner.h"
 
 #include <algorithm>
 #include <clocale>
 #include <cmath>
 
@@ skipping 466 matching lines @@
 void BlinkTestRunner::SetBluetoothMockDataSet(const std::string& name) {
   Send(new LayoutTestHostMsg_SetBluetoothAdapter(name));
   // Auto-reset the chooser type so we don't get order dependence when some
   // tests forget to do it explicitly.
   Send(new ShellViewHostMsg_SetBluetoothManualChooser(routing_id(), false));
 }
 
 void BlinkTestRunner::SetBluetoothManualChooser() {
   Send(new ShellViewHostMsg_SetBluetoothManualChooser(routing_id(), true));
 }
-std::vector<std::string> BlinkTestRunner::GetBluetoothManualChooserEvents() {
-  std::vector<std::string> result;
-  Send(new ShellViewHostMsg_GetBluetoothManualChooserEvents(routing_id(),
-                                                            &result));
-  return result;
+
+void BlinkTestRunner::GetBluetoothManualChooserEvents(
+    const base::Callback<void(const std::vector<std::string>&)>& callback) {
+  get_bluetooth_events_callbacks_.push_back(callback);
+  Send(new ShellViewHostMsg_GetBluetoothManualChooserEvents(routing_id()));
 }
+
 void BlinkTestRunner::SendBluetoothManualChooserEvent(
     const std::string& event,
     const std::string& argument) {
   Send(new ShellViewHostMsg_SendBluetoothManualChooserEvent(routing_id(), event,
                                                             argument));
 }
 
 void BlinkTestRunner::SetGeofencingMockProvider(bool service_available) {
   content::SetGeofencingMockProvider(service_available);
 }
@@ skipping 222 matching lines @@
 
 bool BlinkTestRunner::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BlinkTestRunner, message)
     IPC_MESSAGE_HANDLER(ShellViewMsg_SetTestConfiguration,
                         OnSetTestConfiguration)
     IPC_MESSAGE_HANDLER(ShellViewMsg_SessionHistory, OnSessionHistory)
     IPC_MESSAGE_HANDLER(ShellViewMsg_Reset, OnReset)
     IPC_MESSAGE_HANDLER(ShellViewMsg_NotifyDone, OnNotifyDone)
     IPC_MESSAGE_HANDLER(ShellViewMsg_TryLeakDetection, OnTryLeakDetection)
+    IPC_MESSAGE_HANDLER(ShellViewMsg_ReplyBluetoothManualChooserEvents,
+                        OnReplyBluetoothManualChooserEvents)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void BlinkTestRunner::Navigate(const GURL& url) {
   focus_on_next_commit_ = true;
   if (!is_main_window_ &&
       LayoutTestRenderProcessObserver::GetInstance()->main_test_runner() ==
@@ skipping 159 matching lines @@
 
 void BlinkTestRunner::OnTryLeakDetection() {
   WebLocalFrame* main_frame =
       render_view()->GetWebView()->mainFrame()->toWebLocalFrame();
   DCHECK_EQ(GURL(url::kAboutBlankURL), GURL(main_frame->document().url()));
   DCHECK(!main_frame->isLoading());
 
   leak_detector_->TryLeakDetection(main_frame);
 }
 
+void BlinkTestRunner::OnReplyBluetoothManualChooserEvents(
+    const std::vector<std::string>& events) {
+  DCHECK(!get_bluetooth_events_callbacks_.empty());
+  base::Callback<void(const std::vector<std::string>&)> callback =
+      get_bluetooth_events_callbacks_.front();
+  get_bluetooth_events_callbacks_.pop_front();
+  callback.Run(events);
+}
+
 void BlinkTestRunner::ReportLeakDetectionResult(
     const LeakDetectionResult& report) {
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), report));
 }
 
 }  // namespace content