Bluetooth: add Device events, and cleanup JS API

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.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_event_router.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
-#include "chrome/browser/extensions/event_names.h"
 #include "chrome/common/extensions/api/bluetooth.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_profile.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "extensions/browser/event_router.h"
@@ skipping 174 matching lines @@
 }
 
 scoped_refptr<device::BluetoothSocket>
 ExtensionBluetoothEventRouter::GetSocket(int id) {
   SocketMap::iterator socket_entry = socket_map_.find(id);
   if (socket_entry == socket_map_.end())
     return NULL;
   return socket_entry->second.socket;
 }
 
-void ExtensionBluetoothEventRouter::DispatchDeviceEvent(
-    const std::string& event_name, const bluetooth::Device& device) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(device.ToValue().release());
-  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
-  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
-      event.Pass());
-}
-
 void ExtensionBluetoothEventRouter::DispatchConnectionEvent(
     const std::string& extension_id,
     const std::string& uuid,
     const device::BluetoothDevice* device,
     scoped_refptr<device::BluetoothSocket> socket) {
   if (!HasProfile(uuid))
     return;
 
   int socket_id = RegisterSocket(extension_id, socket);
-  api::bluetooth::Socket result_socket;
-  api::bluetooth::BluetoothDeviceToApiDevice(*device, &result_socket.device);
+  bluetooth::Socket result_socket;
+  bluetooth::BluetoothDeviceToApiDevice(*device, &result_socket.device);
   result_socket.profile.uuid = uuid;
   result_socket.id = socket_id;
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(result_socket.ToValue().release());
+  scoped_ptr<base::ListValue> args =
+      bluetooth::OnConnection::Create(result_socket);
   scoped_ptr<Event> event(new Event(
       bluetooth::OnConnection::kEventName, args.Pass()));
   ExtensionSystem::Get(browser_context_)
       ->event_router()
       ->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void ExtensionBluetoothEventRouter::AdapterPresentChanged(
     device::BluetoothAdapter* adapter, bool present) {
   if (adapter != adapter_.get()) {
@@ skipping 39 matching lines @@
 }
 
 void ExtensionBluetoothEventRouter::DeviceAdded(
     device::BluetoothAdapter* adapter,
     device::BluetoothDevice* device) {
   if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
 
-  bluetooth::Device extension_device;
-  bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
+  DispatchDeviceEvent(bluetooth::OnDeviceAdded::kEventName, device);
+}
 
-  DispatchDeviceEvent(extensions::event_names::kBluetoothOnDeviceDiscovered,
-                      extension_device);
+void ExtensionBluetoothEventRouter::DeviceChanged(
+    device::BluetoothAdapter* adapter,
+    device::BluetoothDevice* device) {
+  if (adapter != adapter_.get()) {
+    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
+    return;
+  }
+
+  DispatchDeviceEvent(bluetooth::OnDeviceChanged::kEventName, device);
+}
+
+void ExtensionBluetoothEventRouter::DeviceRemoved(
+    device::BluetoothAdapter* adapter,
+    device::BluetoothDevice* device) {
+  if (adapter != adapter_.get()) {
+    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
+    return;
+  }
+
+  DispatchDeviceEvent(bluetooth::OnDeviceRemoved::kEventName, device);
 }
 
 void ExtensionBluetoothEventRouter::InitializeAdapterIfNeeded() {
   if (!adapter_.get()) {
     GetAdapter(base::Bind(&ExtensionBluetoothEventRouter::InitializeAdapter,
                           weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void ExtensionBluetoothEventRouter::InitializeAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   if (!adapter_.get()) {
     adapter_ = adapter;
     adapter_->AddObserver(this);
   }
 }
 
 void ExtensionBluetoothEventRouter::MaybeReleaseAdapter() {
   if (adapter_.get() && num_event_listeners_ == 0) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void ExtensionBluetoothEventRouter::DispatchAdapterStateEvent() {
-  api::bluetooth::AdapterState state;
+  bluetooth::AdapterState state;
   PopulateAdapterState(*adapter_.get(), &state);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(state.ToValue().release());
+  scoped_ptr<base::ListValue> args =
+      bluetooth::OnAdapterStateChanged::Create(state);
   scoped_ptr<Event> event(new Event(
       bluetooth::OnAdapterStateChanged::kEventName,
       args.Pass()));
   ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
       event.Pass());
 }
 
+void ExtensionBluetoothEventRouter::DispatchDeviceEvent(
+    const std::string& event_name,
+    device::BluetoothDevice* device) {
+  bluetooth::Device extension_device;
+  bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
+
+  scoped_ptr<base::ListValue> args =
+      bluetooth::OnDeviceAdded::Create(extension_device);
+  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
+  ExtensionSystem::Get(browser_context_)->event_router()->BroadcastEvent(
+      event.Pass());
+}
+
 void ExtensionBluetoothEventRouter::CleanUpForExtension(
     const std::string& extension_id) {
   // Remove all profiles added by the extension.
   BluetoothProfileMap::iterator profile_iter = bluetooth_profile_map_.begin();
   while (profile_iter != bluetooth_profile_map_.end()) {
     ExtensionBluetoothProfileRecord record = profile_iter->second;
     if (record.extension_id == extension_id) {
       bluetooth_profile_map_.erase(profile_iter++);
       record.profile->Unregister();
     } else {
@@ skipping 42 matching lines @@
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       extensions::UnloadedExtensionInfo* info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       CleanUpForExtension(info->extension->id());
       break;
     }
   }
 }
 
 }  // namespace extensions