Bluetooth: add Device events, and cleanup JS API

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/lazy_instance.h"
 #include "base/memory/ref_counted.h"
@@ skipping 77 matching lines @@
 
 // static
 BluetoothAPI* BluetoothAPI::Get(BrowserContext* context) {
   return GetFactoryInstance()->GetForProfile(context);
 }
 
 BluetoothAPI::BluetoothAPI(BrowserContext* context)
     : browser_context_(context) {
   ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
       this, bluetooth::OnAdapterStateChanged::kEventName);
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
+      this, bluetooth::OnDeviceAdded::kEventName);
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
+      this, bluetooth::OnDeviceChanged::kEventName);
+  ExtensionSystem::Get(browser_context_)->event_router()->RegisterObserver(
+      this, bluetooth::OnDeviceRemoved::kEventName);
 }
 
 BluetoothAPI::~BluetoothAPI() {
 }
 
 ExtensionBluetoothEventRouter* BluetoothAPI::bluetooth_event_router() {
   if (!bluetooth_event_router_)
     bluetooth_event_router_.reset(
         new ExtensionBluetoothEventRouter(browser_context_));
 
@@ skipping 156 matching lines @@
 
 bool BluetoothGetAdapterStateFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   bluetooth::AdapterState state;
   PopulateAdapterState(*adapter.get(), &state);
   SetResult(state.ToValue().release());
   SendResponse(true);
   return true;
 }
 
-BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
-    : device_events_sent_(0) {}
-
-void BluetoothGetDevicesFunction::DispatchDeviceSearchResult(
-    const BluetoothDevice& device) {
-  bluetooth::Device extension_device;
-  bluetooth::BluetoothDeviceToApiDevice(device, &extension_device);
-  GetEventRouter(browser_context())->DispatchDeviceEvent(
-      extensions::event_names::kBluetoothOnDeviceSearchResult,
-      extension_device);
-
-  device_events_sent_++;
-}
-
-void BluetoothGetDevicesFunction::FinishDeviceSearch() {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue());
-  info->SetInteger("expectedEventCount", device_events_sent_);
-  args->Append(info.release());
-
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      extensions::event_names::kBluetoothOnDeviceSearchFinished, args.Pass()));
-  extensions::ExtensionSystem::Get(browser_context())
-      ->event_router()
-      ->BroadcastEvent(event.Pass());
-
-  SendResponse(true);
-}
-
 bool BluetoothGetDevicesFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

[armansito, 2014/03/05 21:44:15]

Keep this assertion?

[keybuk, 2014/03/06 21:33:44]

Done.

-
-  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.profile.get() != NULL) {
-    uuid = options.profile->uuid;
-    if (!BluetoothDevice::IsUUIDValid(uuid)) {
-      SetError(kInvalidUuid);
-      SendResponse(false);
-      return false;
-    }
-  }
+  base::ListValue* device_list = new base::ListValue;
+  SetResult(device_list);
 
   BluetoothAdapter::DeviceList devices = adapter->GetDevices();
   for (BluetoothAdapter::DeviceList::const_iterator iter = devices.begin();
        iter != devices.end();
        ++iter) {
     const BluetoothDevice* device = *iter;
     DCHECK(device);
-    if (uuid.empty() || device->ProvidesServiceWithUUID(uuid))
-      DispatchDeviceSearchResult(*device);
+
+    bluetooth::Device extension_device;
+    bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
+
+    device_list->Append(extension_device.ToValue().release());
   }
 
-  FinishDeviceSearch();
+  SendResponse(true);
 
   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;
@@ skipping 287 matching lines @@
   return true;
 }
 
 void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
 }
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
   SetError(kStartDiscoveryFailed);
   SendResponse(false);
-  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStartDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  GetEventRouter(browser_context())->OnListenerAdded();
   GetEventRouter(browser_context())->StartDiscoverySession(
       adapter,
       extension_id(),
       base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
 
   return true;
 }
 
 void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
   SendResponse(true);
-  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 void BluetoothStopDiscoveryFunction::OnErrorCallback() {
   SetError(kStopDiscoveryFailed);
   SendResponse(false);
-  GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStopDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   GetEventRouter(browser_context())->StopDiscoverySession(
       adapter,
       extension_id(),
       base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
 
   return true;
 }
 
 }  // namespace api
 }  // namespace extensions