Refactoring bluetooth API code.

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"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
 #include <string>
 
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/experimental_bluetooth.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/memory/ref_counted.h"
 #include "base/safe_strerror_posix.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_socket.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_interface.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_device_interface.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_service_record_interface.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_socket_posix.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_utils.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
+#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 
 namespace {
 
 chromeos::ExtensionBluetoothEventRouter* GetEventRouter(Profile* profile) {
   return profile->GetExtensionService()->bluetooth_event_router();
 }
 
-const chromeos::BluetoothAdapter& GetAdapter(Profile* profile) {
+const chromeos::BluetoothAdapterInterface& GetAdapter(Profile* profile) {
   return GetEventRouter(profile)->adapter();
 }
 
-chromeos::BluetoothAdapter* GetMutableAdapter(Profile* profile) {
-  chromeos::BluetoothAdapter* adapter =
+chromeos::BluetoothAdapterInterface* GetMutableAdapter(Profile* profile) {
+  chromeos::BluetoothAdapterInterface* adapter =
       GetEventRouter(profile)->GetMutableAdapter();
   CHECK(adapter);
   return adapter;
 }
 
 }  // namespace
 #endif
 
 namespace {
 
@@ skipping 43 matching lines @@
 bool BluetoothGetNameFunction::RunImpl() {
   SetResult(Value::CreateStringValue(GetAdapter(profile()).name()));
   return true;
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0) {}
 
 void BluetoothGetDevicesFunction::AddDeviceIfTrueCallback(
     ListValue* list,
-    const chromeos::BluetoothDevice* device,
+    const chromeos::BluetoothDeviceInterface* device,
     bool shouldAdd) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (shouldAdd)
     list->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
 
   callbacks_pending_--;
   if (callbacks_pending_ == -1)
     SendResponse(true);
 }
@@ skipping 12 matching lines @@
       SetError(kInvalidUuid);
       return false;
     }
   }
 
   ListValue* matches = new ListValue;
   SetResult(matches);
 
   CHECK_EQ(0, callbacks_pending_);
 
-  chromeos::BluetoothAdapter::DeviceList devices =
+  chromeos::BluetoothAdapterInterface::DeviceList devices =
       GetMutableAdapter(profile())->GetDevices();
-  for (chromeos::BluetoothAdapter::DeviceList::iterator i = devices.begin();
-      i != devices.end(); ++i) {
-    chromeos::BluetoothDevice* device = *i;
+  for (chromeos::BluetoothAdapterInterface::DeviceList::iterator i =
+           devices.begin();
+       i != devices.end(); ++i) {
+    chromeos::BluetoothDeviceInterface* device = *i;
 
     if (!uuid.empty() && !(device->ProvidesServiceWithUUID(uuid)))
       continue;
 
     if (options.name.get() == NULL) {
       matches->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
       continue;
     }
 
     callbacks_pending_++;
@@ skipping 10 matching lines @@
   // for-loop, which ensures that all requests have been made before
   // SendResponse happens.
   if (callbacks_pending_ == -1)
     SendResponse(true);
 
   return true;
 }
 
 void BluetoothGetServicesFunction::GetServiceRecordsCallback(
     base::ListValue* services,
-    const chromeos::BluetoothDevice::ServiceRecordList& records) {
-  for (chromeos::BluetoothDevice::ServiceRecordList::const_iterator i =
+    const chromeos::BluetoothDeviceInterface::ServiceRecordList& records) {
+  for (chromeos::BluetoothDeviceInterface::ServiceRecordList::const_iterator i =
       records.begin(); i != records.end(); ++i) {
-    const chromeos::BluetoothServiceRecord& record = **i;
+    const chromeos::BluetoothServiceRecordInterface& record = **i;
     experimental_bluetooth::ServiceRecord api_record;
     api_record.name = record.name();
     if (!record.uuid().empty())
       api_record.uuid.reset(new std::string(record.uuid()));
     services->Append(api_record.ToValue().release());
   }
 
   SendResponse(true);
 }
 
 void BluetoothGetServicesFunction::OnErrorCallback() {
   SetError(kServiceDiscoveryFailed);
   SendResponse(false);
 }
 
 bool BluetoothGetServicesFunction::RunImpl() {
   scoped_ptr<GetServices::Params> params(GetServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::GetServicesOptions& options = params->options;
 
-  chromeos::BluetoothDevice* device =
+  chromeos::BluetoothDeviceInterface* device =
       GetMutableAdapter(profile())->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
     return false;
   }
 
   ListValue* services = new ListValue;
   SetResult(services);
 
   device->GetServiceRecords(
       base::Bind(&BluetoothGetServicesFunction::GetServiceRecordsCallback,
                  this,
                  services),
       base::Bind(&BluetoothGetServicesFunction::OnErrorCallback,
                  this));
 
   return true;
 }
 
 void BluetoothConnectFunction::ConnectToServiceCallback(
-    const chromeos::BluetoothDevice* device,
+    const chromeos::BluetoothDeviceInterface* device,
     const std::string& service_uuid,
-    scoped_refptr<chromeos::BluetoothSocket> socket) {
+    scoped_refptr<chromeos::BluetoothSocketPosix> socket) {
   if (socket.get()) {
     int socket_id = GetEventRouter(profile())->RegisterSocket(socket);
 
     experimental_bluetooth::Socket result_socket;
     experimental_bluetooth::BluetoothDeviceToApiDevice(
         *device, &result_socket.device);
     result_socket.service_uuid = service_uuid;
     result_socket.id = socket_id;
     SetResult(result_socket.ToValue().release());
     SendResponse(true);
   } else {
     SetError(kFailedToConnect);
     SendResponse(false);
   }
 }
 
 bool BluetoothConnectFunction::RunImpl() {
   scoped_ptr<Connect::Params> params(Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::ConnectOptions& options = params->options;
 
   std::string uuid = chromeos::bluetooth_utils::CanonicalUuid(
       options.service_uuid);
   if (uuid.empty()) {
     SetError(kInvalidUuid);
     return false;
   }
 
-  chromeos::BluetoothDevice* device =
+  chromeos::BluetoothDeviceInterface* device =
       GetMutableAdapter(profile())->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
     return false;
   }
 
   device->ConnectToService(uuid,
       base::Bind(&BluetoothConnectFunction::ConnectToServiceCallback,
                  this,
                  device,
@@ skipping 120 matching lines @@
 }
 
 bool BluetoothSetOutOfBandPairingDataFunction::RunImpl() {
   // TODO(bryeung): update to new-style parameter passing when ArrayBuffer
   // support is added
   DictionaryValue* options;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
   std::string address;
   EXTENSION_FUNCTION_VALIDATE(options->GetString("deviceAddress", &address));
 
-  chromeos::BluetoothDevice* device =
+  chromeos::BluetoothDeviceInterface* device =
       GetMutableAdapter(profile())->GetDevice(address);
   if (!device) {
     SetError(kInvalidDevice);
     return false;
   }
 
   if (options->HasKey("data")) {
     DictionaryValue* data_in;
     EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
 
@@ skipping 201 matching lines @@
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 }  // namespace api
 }  // namespace extensions