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;
-  }
-
+void BluetoothGetAdapterStateFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
   bluetooth::AdapterState state;
-  PopulateAdapterState(*GetAdapter(profile()), &state);
+  PopulateAdapterState(*adapter, &state);
   SetResult(state.ToValue().release());
-  return true;
+  SendResponse(true);
 }
 
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0),
       device_events_sent_(0) {}
 
 void BluetoothGetDevicesFunction::DispatchDeviceSearchResult(
     const BluetoothDevice& device) {
   bluetooth::Device extension_device;
   bluetooth::BluetoothDeviceToApiDevice(device, &extension_device);
@@ skipping 24 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;
-  }
-
+void 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);
+  if (!params) {
+    bad_message_ = true;
+    SendResponse(false);
+    return;
+  }

[asargent_no_longer_on_chrome, 2013/01/04 21:54:22]

Instead of manually putting in the code to essentially duplicate
EXTENSION_FUNCTION_VALIDATE, maybe it would be simpler to just change the
signature of DoWork to return a boolean?

[youngki, 2013/01/04 23:44:44]

Done.

   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);
-      return false;
+      SendResponse(false);
+      return;
     }
   }
 
   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);
       continue;
     }
 
     callbacks_pending_++;
     device->ProvidesServiceWithName(
         *(options.name),
         base::Bind(&BluetoothGetDevicesFunction::ProvidesServiceCallback,
                    this,
                    device));
   }
   callbacks_pending_--;
 
   // The count is checked for -1 because of the extra decrement after the
   // for-loop, which ensures that all requests have been made before
   // SendResponse happens.
   if (callbacks_pending_ == -1)
     FinishDeviceSearch();
-
-  return true;
 }
 
 void BluetoothGetServicesFunction::GetServiceRecordsCallback(
     base::ListValue* services,
     const BluetoothDevice::ServiceRecordList& records) {
   for (BluetoothDevice::ServiceRecordList::const_iterator i = records.begin();
       i != records.end(); ++i) {
     const BluetoothServiceRecord& record = **i;
     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() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
+void BluetoothGetServicesFunction::DoWork(
+    scoped_refptr<BluetoothAdapter> adapter) {
+  scoped_ptr<GetServices::Params> params(GetServices::Params::Create(*args_));
+  if (!params) {
+    bad_message_ = true;
+    SendResponse(false);
+    return;
   }
-
-  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);
-    return false;
+    SendResponse(false);
+    return;
   }
 
   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 BluetoothDevice* device,
     const std::string& service_uuid,
     scoped_refptr<BluetoothSocket> socket) {
   if (socket.get()) {
     int socket_id = GetEventRouter(profile())->RegisterSocket(socket);
 
     bluetooth::Socket result_socket;
     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() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
+void BluetoothConnectFunction::DoWork(scoped_refptr<BluetoothAdapter> adapter) {
+  scoped_ptr<Connect::Params> params(Connect::Params::Create(*args_));
+  if (!params) {
+    bad_message_ = true;
+    SendResponse(false);
+    return;
   }
-
-  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);
-    return false;
+    SendResponse(false);
+    return;
   }
 
   std::string uuid = device::bluetooth_utils::CanonicalUuid(
       options.service_uuid);
   if (uuid.empty()) {
     SetError(kInvalidUuid);
-    return false;
+    SendResponse(false);
+    return;
   }
 
-  BluetoothDevice* device =
-      GetMutableAdapter(profile())->GetDevice(options.device_address);
+  BluetoothDevice* device = adapter->GetDevice(options.device_address);
   if (!device) {
     SetError(kInvalidDevice);
-    return false;
+    SendResponse(false);
+    return;
   }
 
   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);
 }
 
 BluetoothReadFunction::BluetoothReadFunction() : success_(false) {}
@@ skipping 116 matching lines @@
 
 void BluetoothSetOutOfBandPairingDataFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothSetOutOfBandPairingDataFunction::OnErrorCallback() {
   SetError(kCouldNotSetOutOfBandPairingData);
   SendResponse(false);
 }
 
-bool BluetoothSetOutOfBandPairingDataFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
+void 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));
+  if (!args_->GetDictionary(0, &options) ||
+      !options->GetString("deviceAddress", &address)) {
+    bad_message_ = true;
+    SendResponse(false);
+    return;
+  }
 
-  BluetoothDevice* device = GetMutableAdapter(profile())->GetDevice(address);
+  BluetoothDevice* device = adapter->GetDevice(address);
   if (!device) {
     SetError(kInvalidDevice);
-    return false;
+    SendResponse(false);
+    return;
   }
 
   if (options->HasKey("data")) {
     DictionaryValue* data_in;
-    EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
+    device::BluetoothOutOfBandPairingData data_out;
+    base::BinaryValue* tmp_data;
 
-    device::BluetoothOutOfBandPairingData data_out;
+    if (!options->GetDictionary("data", &data_in) ||
+        !data_in->GetBinary("hash", &tmp_data) ||
+        tmp_data->GetSize() != device::kBluetoothOutOfBandPairingDataSize) {
+      bad_message_ = true;
+      SendResponse(false);
+      return;
+    }
 
-    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);
+    if (!data_in->GetBinary("randomizer", &tmp_data) ||
+        tmp_data->GetSize() != device::kBluetoothOutOfBandPairingDataSize) {
+      bad_message_ = true;
+      SendResponse(false);
+      return;
+    }
     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.
   DictionaryValue* result = new DictionaryValue();
   result->Set("hash", hash);
   result->Set("randomizer", randomizer);
 
   SetResult(result);
 
   SendResponse(true);
 }
 
 void BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback() {
   SetError(kCouldNotGetLocalOutOfBandPairingData);
   SendResponse(false);
 }
 
-bool BluetoothGetLocalOutOfBandPairingDataFunction::RunImpl() {
-  if (!IsBluetoothSupported(profile())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
-
-  GetMutableAdapter(profile())->ReadLocalOutOfBandPairingData(
+void 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;
-  }
-
+void 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;
+    return;
   }
 
-  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;
-  }
-
+void 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