Implemented BluetoothExtensionFunction.

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
 
@@ skipping 25 matching lines @@
 using device::BluetoothDevice;
 using device::BluetoothServiceRecord;
 using device::BluetoothSocket;
 
 namespace {
 
 extensions::ExtensionBluetoothEventRouter* GetEventRouter(Profile* profile) {
   return extensions::BluetoothAPI::Get(profile)->bluetooth_event_router();
 }
 
-const BluetoothAdapter* GetAdapter(Profile* profile) {
-  return GetEventRouter(profile)->adapter();
-}
-
-BluetoothAdapter* GetMutableAdapter(Profile* profile) {
-  return GetEventRouter(profile)->GetMutableAdapter();
-}
-
-bool IsBluetoothSupported(Profile* profile) {
-  return GetAdapter(profile) != NULL;
-}
-
 }  // namespace
 
 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 kDevicePermissionDenied[] = "Permission to access device denied";
 const char kFailedToConnect[] = "Connection failed";
@@ skipping 46 matching lines @@
 void BluetoothAPI::OnListenerAdded(const EventListenerInfo& details) {
   bluetooth_event_router()->OnListenerAdded();
 }
 
 void BluetoothAPI::OnListenerRemoved(const EventListenerInfo& details) {
   bluetooth_event_router()->OnListenerRemoved();
 }
 
 namespace api {
 
-bool BluetoothGetAdapterStateFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothGetAdapterStateFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   bluetooth::AdapterState state;
-  PopulateAdapterState(*GetAdapter(profile()), &state);
+  PopulateAdapterState(*adapter, &state);
   SetResult(state.ToValue().release());
+  SendResponse(true);
   return true;
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0),
       device_events_sent_(0) {}
 
 void BluetoothGetDevicesFunction::DispatchDeviceSearchResult(
     const BluetoothDevice& device) {
   bluetooth::Device extension_device;
@@ skipping 25 matching lines @@
   args->Append(info.release());
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::event_names::kBluetoothOnDeviceSearchFinished, args.Pass()));
   extensions::ExtensionSystem::Get(profile())->event_router()->
       BroadcastEvent(event.Pass());
 
   SendResponse(true);
 }
 
-bool BluetoothGetDevicesFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothGetDevicesFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::GetDevicesOptions& options = params->options;
 
   std::string uuid;
   if (options.uuid.get() != NULL) {
     uuid = device::bluetooth_utils::CanonicalUuid(*options.uuid.get());
     if (uuid.empty()) {
       SetError(kInvalidUuid);
+      SendResponse(false);
       return false;
     }
   }
 
   CHECK_EQ(0, callbacks_pending_);
 
-  BluetoothAdapter::DeviceList devices =
-      GetMutableAdapter(profile())->GetDevices();
+  BluetoothAdapter::DeviceList devices = adapter->GetDevices();
   for (BluetoothAdapter::DeviceList::iterator i = devices.begin();
       i != devices.end(); ++i) {
     BluetoothDevice* device = *i;
     CHECK(device);
 
     if (!uuid.empty() && !(device->ProvidesServiceWithUUID(uuid)))
       continue;
 
     if (options.name.get() == NULL) {
       DispatchDeviceSearchResult(*device);
@@ skipping 32 matching lines @@
   }
 
   SendResponse(true);
 }
 
 void BluetoothGetServicesFunction::OnErrorCallback() {
   SetError(kServiceDiscoveryFailed);
   SendResponse(false);
 }
 
-bool BluetoothGetServicesFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothGetServicesFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   scoped_ptr<GetServices::Params> params(GetServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::GetServicesOptions& options = params->options;
 
-  BluetoothDevice* device =
-      GetMutableAdapter(profile())->GetDevice(options.device_address);
+  BluetoothDevice* device = adapter->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
+    SendResponse(false);
     return false;
   }
 
   ListValue* services = new ListValue;
   SetResult(services);
 
   device->GetServiceRecords(
       base::Bind(&BluetoothGetServicesFunction::GetServiceRecordsCallback,
                  this,
                  services),
@@ skipping 15 matching lines @@
     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() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothConnectFunction::DoWork(scoped_refptr<BluetoothAdapter> adapter) {
   scoped_ptr<Connect::Params> params(Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::ConnectOptions& options = params->options;
 
   BluetoothDevicePermission::CheckParam param(options.device_address);
   if (!GetExtension()->CheckAPIPermissionWithParam(
         APIPermission::kBluetoothDevice, &param)) {
     SetError(kDevicePermissionDenied);
+    SendResponse(false);
     return false;
   }
 
   std::string uuid = device::bluetooth_utils::CanonicalUuid(
       options.service_uuid);
   if (uuid.empty()) {
     SetError(kInvalidUuid);
+    SendResponse(false);
     return false;
   }
 
-  BluetoothDevice* device =
-      GetMutableAdapter(profile())->GetDevice(options.device_address);
+  BluetoothDevice* device = adapter->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
+    SendResponse(false);
     return false;
   }
 
   device->ConnectToService(uuid,
       base::Bind(&BluetoothConnectFunction::ConnectToServiceCallback,
                  this,
                  device,
                  uuid));
+
   return true;
 }
 
 bool BluetoothDisconnectFunction::RunImpl() {
   scoped_ptr<Disconnect::Params> params(Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const bluetooth::DisconnectOptions& options = params->options;
   return GetEventRouter(profile())->ReleaseSocket(options.socket_id);
 }
 
@@ skipping 117 matching lines @@
 
 void BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback() {
   SetError(kCouldNotSetOutOfBandPairingData);
   SendResponse(false);
 }
 
-bool BluetoothSetOutOfBandPairingDataFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothSetOutOfBandPairingDataFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   // 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));
 
-  BluetoothDevice* device = GetMutableAdapter(profile())->GetDevice(address);
+  BluetoothDevice* device = adapter->GetDevice(address);
   if (!device) {
     SetError(kInvalidDevice);
+    SendResponse(false);
     return false;
   }
 
   if (options->HasKey("data")) {
     DictionaryValue* data_in;
     EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
 
     device::BluetoothOutOfBandPairingData data_out;
 
     base::BinaryValue* tmp_data;
@@ skipping 46 matching lines @@
   SetResult(result);
 
   SendResponse(true);
 }
 
 void BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback() {
   SetError(kCouldNotGetLocalOutOfBandPairingData);
   SendResponse(false);
 }
 
-bool BluetoothGetLocalOutOfBandPairingDataFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
-  GetMutableAdapter(profile())->ReadLocalOutOfBandPairingData(
+bool BluetoothGetLocalOutOfBandPairingDataFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
+  adapter->ReadLocalOutOfBandPairingData(
       base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ReadCallback,
           this),
       base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback,
           this));
+
   return true;
 }
 
 void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
   GetEventRouter(profile())->SetResponsibleForDiscovery(true);
   SendResponse(true);
 }
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
   SetError(kStartDiscoveryFailed);
   SendResponse(false);
 }
 
-bool BluetoothStartDiscoveryFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothStartDiscoveryFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   GetEventRouter(profile())->SetSendDiscoveryEvents(true);
 
   // If the adapter is already discovering, there is nothing else to do.
-  if (GetAdapter(profile())->IsDiscovering()) {
+  if (adapter->IsDiscovering()) {
     SendResponse(true);
     return true;
   }
 
-  GetMutableAdapter(profile())->SetDiscovering(true,
+  adapter->SetDiscovering(true,
       base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
+
   return true;
 }
 
 void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothStopDiscoveryFunction::OnErrorCallback() {
   SetError(kStopDiscoveryFailed);
   SendResponse(false);
 }
 
-bool BluetoothStopDiscoveryFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+bool BluetoothStopDiscoveryFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   GetEventRouter(profile())->SetSendDiscoveryEvents(false);
   if (GetEventRouter(profile())->IsResponsibleForDiscovery()) {
-    GetMutableAdapter(profile())->SetDiscovering(false,
+    adapter->SetDiscovering(false,
         base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
         base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
   }
+
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions