Bluetooth: remove Out of Band Pairing APIs

chrome/browser/extensions/api/bluetooth/bluetooth_apitest.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 <string.h>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_profile.h"
 #include "device/bluetooth/test/mock_bluetooth_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothDiscoverySession;
-using device::BluetoothOutOfBandPairingData;
 using device::BluetoothProfile;
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
 using device::MockBluetoothProfile;
 using extensions::Extension;
 
 namespace utils = extension_function_test_utils;
 namespace api = extensions::api;
@@ skipping 90 matching lines @@
       const device::BluetoothProfile::Options& options,
       const device::BluetoothProfile::ProfileCallback& callback) OVERRIDE {
     callback.Run(profile_);
   }
 
  private:
   // TestBluetoothAddProfileFunction does not own |profile_|.
   BluetoothProfile* profile_;
 };
 
-// This is the canonical UUID for the short UUID 0010.
-static const char kOutOfBandPairingDataHash[] = "0123456789ABCDEh";
-static const char kOutOfBandPairingDataRandomizer[] = "0123456789ABCDEr";
-
-static BluetoothOutOfBandPairingData GetOutOfBandPairingData() {
-  BluetoothOutOfBandPairingData data;
-  memcpy(&(data.hash), kOutOfBandPairingDataHash,
-      device::kBluetoothOutOfBandPairingDataSize);
-  memcpy(&(data.randomizer), kOutOfBandPairingDataRandomizer,
-      device::kBluetoothOutOfBandPairingDataSize);
-  return data;
-}
-
-static bool CallClosure(const base::Closure& callback) {
-  callback.Run();
-  return true;
-}
-
-static bool CallErrorClosure(const BluetoothDevice::ErrorCallback& callback) {
-  callback.Run();
-  return true;
-}
-
 static void StopDiscoverySessionCallback(const base::Closure& callback,
                                          const base::Closure& error_callback) {
   callback.Run();
 }
 
-static void CallOutOfBandPairingDataCallback(
-    const BluetoothAdapter::BluetoothOutOfBandPairingDataCallback& callback,
-    const BluetoothAdapter::ErrorCallback& error_callback) {
-  callback.Run(GetOutOfBandPairingData());
-}
-
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Profiles) {
   // Run in context of an extension that has permissions for the profiles
   // we intend to register.
   scoped_refptr<const Extension> extension(
       LoadExtension(test_data_dir_.AppendASCII("bluetooth/profiles")));
   ASSERT_TRUE(extension.get());
 
   EXPECT_CALL(*profile1_, SetConnectionCallback(testing::_));
@@ skipping 73 matching lines @@
   api::bluetooth::AdapterState state;
   ASSERT_TRUE(api::bluetooth::AdapterState::Populate(*result, &state));
 
   EXPECT_FALSE(state.available);
   EXPECT_TRUE(state.powered);
   EXPECT_FALSE(state.discovering);
   EXPECT_EQ(kName, state.name);
   EXPECT_EQ(kAdapterAddress, state.address);
 }
 
-IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetLocalOutOfBandPairingData) {
-  EXPECT_CALL(*mock_adapter_,
-              ReadLocalOutOfBandPairingData(testing::_, testing::_))
-      .WillOnce(testing::Invoke(CallOutOfBandPairingDataCallback));
-
-  scoped_refptr<api::BluetoothGetLocalOutOfBandPairingDataFunction>
-      get_oob_function(setupFunction(
-            new api::BluetoothGetLocalOutOfBandPairingDataFunction));
-
-  scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
-      get_oob_function.get(), "[]", browser()));
-
-  base::DictionaryValue* dict;
-  EXPECT_TRUE(result->GetAsDictionary(&dict));
-
-  base::BinaryValue* binary_value;
-  EXPECT_TRUE(dict->GetBinary("hash", &binary_value));
-  EXPECT_STREQ(kOutOfBandPairingDataHash,
-      std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
-  EXPECT_TRUE(dict->GetBinary("randomizer", &binary_value));
-  EXPECT_STREQ(kOutOfBandPairingDataRandomizer,
-      std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
-
-  // Try again with an error
-  testing::Mock::VerifyAndClearExpectations(mock_adapter_);
-  EXPECT_CALL(*mock_adapter_,
-              ReadLocalOutOfBandPairingData(
-                  testing::_,
-                  testing::Truly(CallClosure)));
-
-  get_oob_function =
-      setupFunction(new api::BluetoothGetLocalOutOfBandPairingDataFunction);
-
-  std::string error(utils::RunFunctionAndReturnError(
-      get_oob_function.get(), "[]", browser()));
-  EXPECT_FALSE(error.empty());
-}
-
-IN_PROC_BROWSER_TEST_F(BluetoothApiTest, SetOutOfBandPairingData) {
-  EXPECT_CALL(*mock_adapter_, GetDevice(device1_->GetAddress()))
-      .WillOnce(testing::Return(device1_.get()));
-  EXPECT_CALL(*device1_,
-              ClearOutOfBandPairingData(testing::Truly(CallClosure),
-                                        testing::_));
-
-  std::string params = base::StringPrintf(
-      "[{\"deviceAddress\":\"%s\"}]", device1_->GetAddress().c_str());
-
-  scoped_refptr<api::BluetoothSetOutOfBandPairingDataFunction> set_oob_function;
-  set_oob_function = setupFunction(
-      new api::BluetoothSetOutOfBandPairingDataFunction);
-  // There isn't actually a result.
-  (void) utils::RunFunctionAndReturnSingleResult(
-      set_oob_function.get(), params, browser());
-
-  // Try again with an error
-  testing::Mock::VerifyAndClearExpectations(mock_adapter_);
-  testing::Mock::VerifyAndClearExpectations(device1_.get());
-  EXPECT_CALL(*mock_adapter_, GetDevice(device1_->GetAddress()))
-      .WillOnce(testing::Return(device1_.get()));
-  EXPECT_CALL(
-      *device1_,
-      ClearOutOfBandPairingData(testing::_, testing::Truly(CallErrorClosure)));
-
-  set_oob_function = setupFunction(
-      new api::BluetoothSetOutOfBandPairingDataFunction);
-  std::string error(utils::RunFunctionAndReturnError(
-      set_oob_function.get(), params, browser()));
-  EXPECT_FALSE(error.empty());
-
-  // TODO(bryeung): Also test setting the data when there is support for
-  // ArrayBuffers in the arguments to the RunFunctionAnd* methods.
-  // crbug.com/132796
-}
-
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DeviceEvents) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   ASSERT_TRUE(LoadExtension(
         test_data_dir_.AppendASCII("bluetooth/device_events")));
 
   ExtensionTestMessageListener events_received("ready", true);
   event_router()->DeviceAdded(mock_adapter_, device1_.get());
   event_router()->DeviceAdded(mock_adapter_, device2_.get());
@@ skipping 328 matching lines @@
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
   ASSERT_TRUE(
       LoadExtension(test_data_dir_.AppendASCII("bluetooth/device_info")));
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }