Bluetooth: remove Out of Band Pairing APIs

chrome/browser/extensions/api/bluetooth/bluetooth_api.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 "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/bluetooth.h"
 #include "chrome/common/extensions/api/bluetooth/bluetooth_manifest_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_service_record.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/io_buffer.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothProfile;
 using device::BluetoothServiceRecord;
 using device::BluetoothSocket;
 
 using extensions::BluetoothApiSocket;
 
 namespace AddProfile = extensions::api::bluetooth::AddProfile;
 namespace bluetooth = extensions::api::bluetooth;
 namespace Connect = extensions::api::bluetooth::Connect;
 namespace Disconnect = extensions::api::bluetooth::Disconnect;
 namespace GetDevice = extensions::api::bluetooth::GetDevice;
 namespace GetDevices = extensions::api::bluetooth::GetDevices;
 namespace RemoveProfile = extensions::api::bluetooth::RemoveProfile;
-namespace SetOutOfBandPairingData =
-    extensions::api::bluetooth::SetOutOfBandPairingData;
 namespace Send = extensions::api::bluetooth::Send;
 
 namespace {
 
-const char kCouldNotGetLocalOutOfBandPairingData[] =
-    "Could not get local Out Of Band Pairing Data";
-const char kCouldNotSetOutOfBandPairingData[] =
-    "Could not set Out Of Band Pairing Data";
 const char kInvalidDevice[] = "Invalid device";
 const char kInvalidUuid[] = "Invalid UUID";
 const char kPermissionDenied[] = "Permission to add profile denied.";
 const char kProfileAlreadyRegistered[] =
     "This profile has already been registered";
 const char kProfileNotFound[] = "Profile not found: invalid uuid";
 const char kProfileRegistrationFailed[] = "Profile registration failed";
 const char kStartDiscoveryFailed[] = "Starting discovery failed";
 const char kStopDiscoveryFailed[] = "Failed to stop discovery";
 
@@ skipping 460 matching lines @@
   SetError("Removed. Use chrome.bluetoothSocket.getInfo() instead.");
   return false;
 }
 
 bool BluetoothGetSocketsFunction::RunAsync() {
   // TODO(keybuk): Remove.
   SetError("Removed. Use chrome.bluetoothSocket.getSockets() instead.");
   return false;
 }
 
-void BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback() {
-  SendResponse(true);
-}
-
-void BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback() {
-  SetError(kCouldNotSetOutOfBandPairingData);
-  SendResponse(false);
-}
-
-bool BluetoothSetOutOfBandPairingDataFunction::DoWork(
-    scoped_refptr<BluetoothAdapter> adapter) {
-  // TODO(bryeung): update to new-style parameter passing when ArrayBuffer
-  // support is added
-  base::DictionaryValue* options;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
-  std::string address;
-  EXTENSION_FUNCTION_VALIDATE(options->GetString("deviceAddress", &address));
-
-  BluetoothDevice* device = adapter->GetDevice(address);
-  if (!device) {
-    SetError(kInvalidDevice);
-    SendResponse(false);
-    return false;
-  }
-
-  if (options->HasKey("data")) {
-    base::DictionaryValue* data_in;
-    EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
-
-    device::BluetoothOutOfBandPairingData data_out;
-
-    base::BinaryValue* tmp_data;
-    EXTENSION_FUNCTION_VALIDATE(data_in->GetBinary("hash", &tmp_data));
-    EXTENSION_FUNCTION_VALIDATE(
-        tmp_data->GetSize() == device::kBluetoothOutOfBandPairingDataSize);
-    memcpy(data_out.hash,
-        reinterpret_cast<uint8_t*>(tmp_data->GetBuffer()),
-        device::kBluetoothOutOfBandPairingDataSize);
-
-    EXTENSION_FUNCTION_VALIDATE(data_in->GetBinary("randomizer", &tmp_data));
-    EXTENSION_FUNCTION_VALIDATE(
-        tmp_data->GetSize() == device::kBluetoothOutOfBandPairingDataSize);
-    memcpy(data_out.randomizer,
-        reinterpret_cast<uint8_t*>(tmp_data->GetBuffer()),
-        device::kBluetoothOutOfBandPairingDataSize);
-
-    device->SetOutOfBandPairingData(
-        data_out,
-        base::Bind(&BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback,
-            this),
-        base::Bind(&BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback,
-            this));
-  } else {
-    device->ClearOutOfBandPairingData(
-        base::Bind(&BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback,
-            this),
-        base::Bind(&BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback,
-            this));
-  }
-
-  return true;
-}
-
-void BluetoothGetLocalOutOfBandPairingDataFunction::ReadCallback(
-    const device::BluetoothOutOfBandPairingData& data) {
-  base::BinaryValue* hash = base::BinaryValue::CreateWithCopiedBuffer(
-      reinterpret_cast<const char*>(data.hash),
-      device::kBluetoothOutOfBandPairingDataSize);
-  base::BinaryValue* randomizer = base::BinaryValue::CreateWithCopiedBuffer(
-      reinterpret_cast<const char*>(data.randomizer),
-      device::kBluetoothOutOfBandPairingDataSize);
-
-  // TODO(bryeung): convert to bluetooth::OutOfBandPairingData
-  // when ArrayBuffer support within objects is completed.
-  base::DictionaryValue* result = new base::DictionaryValue();
-  result->Set("hash", hash);
-  result->Set("randomizer", randomizer);
-
-  SetResult(result);
-
-  SendResponse(true);
-}
-
-void BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback() {
-  SetError(kCouldNotGetLocalOutOfBandPairingData);
-  SendResponse(false);
-}
-
-bool BluetoothGetLocalOutOfBandPairingDataFunction::DoWork(
-    scoped_refptr<BluetoothAdapter> adapter) {
-  adapter->ReadLocalOutOfBandPairingData(
-      base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ReadCallback,
-          this),
-      base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback,
-          this));
-
-  return true;
-}
-
 void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
   SetError(kStartDiscoveryFailed);
   SendResponse(false);
 }
 
 bool BluetoothStartDiscoveryFunction::DoWork(
@@ skipping 22 matching lines @@
       adapter,
       extension_id(),
       base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
 
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions