bluetooth: Create Mojo equivalent of SetBluetoothMockDataSet

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>
 
@@ skipping 239 matching lines @@
   void SendBluetoothManualChooserEvent(const std::string& event,
                                        const std::string& argument);
   void SetAcceptLanguages(const std::string& accept_languages);
   void SetAllowDisplayOfInsecureContent(bool allowed);
   void SetAllowFileAccessFromFileURLs(bool allow);
   void SetAllowRunningOfInsecureContent(bool allowed);
   void SetAllowUniversalAccessFromFileURLs(bool allow);
   void SetAlwaysAcceptCookies(bool accept);
   void SetAudioData(const gin::ArrayBufferView& view);
   void SetBackingScaleFactor(double value, v8::Local<v8::Function> callback);
-  void SetBluetoothManualChooser();
-  void SetBluetoothMockDataSet(const std::string& dataset_name);
+  void SetBluetoothFakeAdapter(const std::string& adapter_name,
+                               v8::Local<v8::Function> callback);
+  void SetBluetoothManualChooser(bool enable);
   void SetCanOpenWindows();
   void SetCloseRemainingWindowsWhenComplete(gin::Arguments* args);
   void SetColorProfile(const std::string& name,
                        v8::Local<v8::Function> callback);
   void SetCustomPolicyDelegate(gin::Arguments* args);
   void SetCustomTextOutput(const std::string& output);
   void SetDatabaseQuota(int quota);
   void SetDomainRelaxationForbiddenForURLScheme(bool forbidden,
                                                 const std::string& scheme);
   void SetGeofencingMockPosition(double latitude, double longitude);
@@ skipping 295 matching lines @@
                  &TestRunnerBindings::SetAllowRunningOfInsecureContent)
       .SetMethod("setAllowUniversalAccessFromFileURLs",
                  &TestRunnerBindings::SetAllowUniversalAccessFromFileURLs)
       .SetMethod("setAlwaysAcceptCookies",
                  &TestRunnerBindings::SetAlwaysAcceptCookies)
       .SetMethod("setApplicationCacheOriginQuota",
                  &TestRunnerBindings::NotImplemented)
       .SetMethod("setAudioData", &TestRunnerBindings::SetAudioData)
       .SetMethod("setBackingScaleFactor",
                  &TestRunnerBindings::SetBackingScaleFactor)
-
+      .SetMethod("setBluetoothFakeAdapter",

[Jeffrey Yasskin, 2016/03/29 01:59:13]

I think keep this below the link to the spec that'll hold its definition, even
though the definition isn't there yet.

[ortuno, 2016/03/29 16:05:16]

Done.

+                 &TestRunnerBindings::SetBluetoothFakeAdapter)
       // The Bluetooth functions are specified at
       // https://webbluetoothcg.github.io/web-bluetooth/tests/.
       .SetMethod("setBluetoothManualChooser",
                  &TestRunnerBindings::SetBluetoothManualChooser)
-      .SetMethod("setBluetoothMockDataSet",
-                 &TestRunnerBindings::SetBluetoothMockDataSet)
       .SetMethod("setCallCloseOnWebViews", &TestRunnerBindings::NotImplemented)
       .SetMethod("setCanOpenWindows", &TestRunnerBindings::SetCanOpenWindows)
       .SetMethod("setCloseRemainingWindowsWhenComplete",
                  &TestRunnerBindings::SetCloseRemainingWindowsWhenComplete)
       .SetMethod("setColorProfile", &TestRunnerBindings::SetColorProfile)
       .SetMethod("setCustomPolicyDelegate",
                  &TestRunnerBindings::SetCustomPolicyDelegate)
       .SetMethod("setCustomTextOutput",
                  &TestRunnerBindings::SetCustomTextOutput)
       .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota)
@@ skipping 779 matching lines @@
   if (runner_)
     runner_->EnableUseZoomForDSF(callback);
 }
 
 void TestRunnerBindings::SetColorProfile(
     const std::string& name, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->SetColorProfile(name, callback);
 }
 
-void TestRunnerBindings::SetBluetoothMockDataSet(const std::string& name) {
+void TestRunnerBindings::SetBluetoothFakeAdapter(
+    const std::string& adapter_name,
+    v8::Local<v8::Function> callback) {
   if (runner_)
-    runner_->SetBluetoothMockDataSet(name);
+    runner_->SetBluetoothFakeAdapter(adapter_name, callback);
 }
 
-void TestRunnerBindings::SetBluetoothManualChooser() {
+void TestRunnerBindings::SetBluetoothManualChooser(bool enable) {
   if (runner_)
-    runner_->SetBluetoothManualChooser();
+    runner_->SetBluetoothManualChooser(enable);
 }
 
 void TestRunnerBindings::GetBluetoothManualChooserEvents(
     v8::Local<v8::Function> callback) {
   if (runner_)
     return runner_->GetBluetoothManualChooserEvents(callback);
 }
 
 void TestRunnerBindings::SendBluetoothManualChooserEvent(
     const std::string& event,
@@ skipping 318 matching lines @@
   if (delegate_) {
     // Reset the default quota for each origin to 5MB
     delegate_->SetDatabaseQuota(5 * 1024 * 1024);
     delegate_->SetDeviceColorProfile("reset");
     delegate_->SetDeviceScaleFactor(GetDefaultDeviceScaleFactor());
     delegate_->SetAcceptAllCookies(false);
     delegate_->SetLocale("");
     delegate_->UseUnfortunateSynchronousResizeMode(false);
     delegate_->DisableAutoResizeMode(WebSize());
     delegate_->DeleteAllCookies();
-    delegate_->SetBluetoothMockDataSet("");
+    delegate_->SetBluetoothManualChooser(false);
     delegate_->ClearGeofencingMockProvider();
     delegate_->ResetPermissions();
     ResetDeviceLight();
   }
 
   dump_editting_callbacks_ = false;
   dump_icon_changes_ = false;
   dump_as_audio_ = false;
   dump_frame_load_callbacks_ = false;
   dump_ping_loader_callbacks_ = false;
@@ skipping 1151 matching lines @@
   delegate_->EnableUseZoomForDSF();
   delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetColorProfile(const std::string& name,
                                  v8::Local<v8::Function> callback) {
   delegate_->SetDeviceColorProfile(name);
   delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
-void TestRunner::SetBluetoothMockDataSet(const std::string& name) {
-  delegate_->SetBluetoothMockDataSet(name);
+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)));
 }
 
-void TestRunner::SetBluetoothManualChooser() {
-  delegate_->SetBluetoothManualChooser();
+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)));
 }
 
@@ skipping 305 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner