Extensions: Move bluetooth APIs to extensions/.

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/bind_helpers.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
-#include "base/stl_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/extensions/api/bluetooth/bluetooth_api_pairing_delegate.h"
-#include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
-#include "chrome/browser/extensions/api/bluetooth/bluetooth_private_api.h"
-#include "chrome/common/extensions/api/bluetooth.h"
-#include "chrome/common/extensions/api/bluetooth_private.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 "extensions/browser/event_router.h"
-#include "extensions/browser/extension_host.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/notification_types.h"
-
-namespace extensions {
-
-namespace bluetooth = api::bluetooth;
-namespace bt_private = api::bluetooth_private;
-
-BluetoothEventRouter::BluetoothEventRouter(content::BrowserContext* context)
-    : browser_context_(context),
-      adapter_(NULL),
-      num_event_listeners_(0),
-      extension_registry_observer_(this),
-      weak_ptr_factory_(this) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(browser_context_);
-  registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
-                 content::Source<content::BrowserContext>(browser_context_));
-  extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
-}
-
-BluetoothEventRouter::~BluetoothEventRouter() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter_.get()) {
-    adapter_->RemoveObserver(this);
-    adapter_ = NULL;
-  }
-  CleanUpAllExtensions();
-}
-
-bool BluetoothEventRouter::IsBluetoothSupported() const {
-  return adapter_.get() ||
-         device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
-}
-
-void BluetoothEventRouter::GetAdapter(
-    const device::BluetoothAdapterFactory::AdapterCallback& callback) {
-  if (adapter_.get()) {
-    callback.Run(scoped_refptr<device::BluetoothAdapter>(adapter_));
-    return;
-  }
-
-  device::BluetoothAdapterFactory::GetAdapter(callback);
-}
-
-void BluetoothEventRouter::StartDiscoverySession(
-    device::BluetoothAdapter* adapter,
-    const std::string& extension_id,
-    const base::Closure& callback,
-    const base::Closure& error_callback) {
-  if (adapter != adapter_.get()) {
-    error_callback.Run();
-    return;
-  }
-  DiscoverySessionMap::iterator iter =
-      discovery_session_map_.find(extension_id);
-  if (iter != discovery_session_map_.end() && iter->second->IsActive()) {
-    DVLOG(1) << "An active discovery session exists for extension.";
-    error_callback.Run();
-    return;
-  }
-  adapter->StartDiscoverySession(
-      base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 callback),
-      error_callback);
-}
-
-void BluetoothEventRouter::StopDiscoverySession(
-    device::BluetoothAdapter* adapter,
-    const std::string& extension_id,
-    const base::Closure& callback,
-    const base::Closure& error_callback) {
-  if (adapter != adapter_.get()) {
-    error_callback.Run();
-    return;
-  }
-  DiscoverySessionMap::iterator iter =
-      discovery_session_map_.find(extension_id);
-  if (iter == discovery_session_map_.end() || !iter->second->IsActive()) {
-    DVLOG(1) << "No active discovery session exists for extension.";
-    error_callback.Run();
-    return;
-  }
-  device::BluetoothDiscoverySession* session = iter->second;
-  session->Stop(callback, error_callback);
-}
-
-BluetoothApiPairingDelegate* BluetoothEventRouter::GetPairingDelegate(
-    const std::string& extension_id) {
-  return ContainsKey(pairing_delegate_map_, extension_id)
-             ? pairing_delegate_map_[extension_id]
-             : NULL;
-}
-
-void BluetoothEventRouter::OnAdapterInitialized(
-    const base::Closure& callback,
-    scoped_refptr<device::BluetoothAdapter> adapter) {
-  if (!adapter_.get()) {
-    adapter_ = adapter;
-    adapter_->AddObserver(this);
-  }
-
-  callback.Run();
-}
-
-void BluetoothEventRouter::MaybeReleaseAdapter() {
-  if (adapter_.get() && num_event_listeners_ == 0 &&
-      pairing_delegate_map_.empty()) {
-    adapter_->RemoveObserver(this);
-    adapter_ = NULL;
-  }
-}
-
-void BluetoothEventRouter::AddPairingDelegate(const std::string& extension_id) {
-  if (!adapter_.get()) {
-    base::Closure self_callback =
-        base::Bind(&BluetoothEventRouter::AddPairingDelegate,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   extension_id);
-    GetAdapter(base::Bind(&BluetoothEventRouter::OnAdapterInitialized,
-                          weak_ptr_factory_.GetWeakPtr(),
-                          self_callback));
-    return;
-  }
-
-  if (!ContainsKey(pairing_delegate_map_, extension_id)) {
-    BluetoothApiPairingDelegate* delegate =
-        new BluetoothApiPairingDelegate(extension_id, browser_context_);
-    DCHECK(adapter_.get());
-    adapter_->AddPairingDelegate(
-        delegate, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
-    pairing_delegate_map_[extension_id] = delegate;
-  } else {
-    LOG(ERROR) << "Pairing delegate already exists for extension. "
-               << "There should be at most one onPairing listener.";
-    NOTREACHED();
-  }
-}
-
-void BluetoothEventRouter::RemovePairingDelegate(
-    const std::string& extension_id) {
-  if (ContainsKey(pairing_delegate_map_, extension_id)) {
-    BluetoothApiPairingDelegate* delegate = pairing_delegate_map_[extension_id];
-    if (adapter_.get())
-      adapter_->RemovePairingDelegate(delegate);
-    pairing_delegate_map_.erase(extension_id);
-    delete delegate;
-    MaybeReleaseAdapter();
-  }
-}
-
-void BluetoothEventRouter::AdapterPresentChanged(
-    device::BluetoothAdapter* adapter,
-    bool present) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-  DispatchAdapterStateEvent();
-}
-
-void BluetoothEventRouter::AdapterPoweredChanged(
-    device::BluetoothAdapter* adapter,
-    bool has_power) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-  DispatchAdapterStateEvent();
-}
-
-void BluetoothEventRouter::AdapterDiscoveringChanged(
-    device::BluetoothAdapter* adapter,
-    bool discovering) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-
-  if (!discovering) {
-    // If any discovery sessions are inactive, clean them up.
-    DiscoverySessionMap active_session_map;
-    for (DiscoverySessionMap::iterator iter = discovery_session_map_.begin();
-         iter != discovery_session_map_.end();
-         ++iter) {
-      device::BluetoothDiscoverySession* session = iter->second;
-      if (session->IsActive()) {
-        active_session_map[iter->first] = session;
-        continue;
-      }
-      delete session;
-    }
-    discovery_session_map_.swap(active_session_map);
-    MaybeReleaseAdapter();
-  }
-
-  DispatchAdapterStateEvent();
-}
-
-void BluetoothEventRouter::DeviceAdded(device::BluetoothAdapter* adapter,
-                                       device::BluetoothDevice* device) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-
-  DispatchDeviceEvent(bluetooth::OnDeviceAdded::kEventName, device);
-}
-
-void BluetoothEventRouter::DeviceChanged(device::BluetoothAdapter* adapter,
-                                         device::BluetoothDevice* device) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-
-  DispatchDeviceEvent(bluetooth::OnDeviceChanged::kEventName, device);
-}
-
-void BluetoothEventRouter::DeviceRemoved(device::BluetoothAdapter* adapter,
-                                         device::BluetoothDevice* device) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (adapter != adapter_.get()) {
-    DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
-    return;
-  }
-
-  DispatchDeviceEvent(bluetooth::OnDeviceRemoved::kEventName, device);
-}
-
-void BluetoothEventRouter::OnListenerAdded() {
-  num_event_listeners_++;
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (!adapter_.get()) {
-    GetAdapter(base::Bind(&BluetoothEventRouter::OnAdapterInitialized,
-                          weak_ptr_factory_.GetWeakPtr(),
-                          base::Bind(&base::DoNothing)));
-  }
-}
-
-void BluetoothEventRouter::OnListenerRemoved() {
-  if (num_event_listeners_ > 0)
-    num_event_listeners_--;
-  MaybeReleaseAdapter();
-}
-
-void BluetoothEventRouter::DispatchAdapterStateEvent() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  api::bluetooth::AdapterState state;
-  PopulateAdapterState(*adapter_.get(), &state);
-
-  scoped_ptr<base::ListValue> args =
-      bluetooth::OnAdapterStateChanged::Create(state);
-  scoped_ptr<Event> event(new Event(
-      bluetooth::OnAdapterStateChanged::kEventName,
-      args.Pass()));
-  EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
-}
-
-void BluetoothEventRouter::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()));
-  EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
-}
-
-void BluetoothEventRouter::CleanUpForExtension(
-    const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  RemovePairingDelegate(extension_id);
-
-  // Remove any discovery session initiated by the extension.
-  DiscoverySessionMap::iterator session_iter =
-      discovery_session_map_.find(extension_id);
-  if (session_iter == discovery_session_map_.end())
-    return;
-  delete session_iter->second;
-  discovery_session_map_.erase(session_iter);
-}
-
-void BluetoothEventRouter::CleanUpAllExtensions() {
-  for (DiscoverySessionMap::iterator it = discovery_session_map_.begin();
-       it != discovery_session_map_.end();
-       ++it) {
-    delete it->second;
-  }
-  discovery_session_map_.clear();
-
-  PairingDelegateMap::iterator pairing_iter = pairing_delegate_map_.begin();
-  while (pairing_iter != pairing_delegate_map_.end())
-    RemovePairingDelegate(pairing_iter++->first);
-}
-
-void BluetoothEventRouter::OnStartDiscoverySession(
-    const std::string& extension_id,
-    const base::Closure& callback,
-    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
-  // Clean up any existing session instance for the extension.
-  DiscoverySessionMap::iterator iter =
-      discovery_session_map_.find(extension_id);
-  if (iter != discovery_session_map_.end())
-    delete iter->second;
-  discovery_session_map_[extension_id] = discovery_session.release();
-  callback.Run();
-}
-
-void BluetoothEventRouter::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, type);
-  ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
-  CleanUpForExtension(host->extension_id());
-}
-
-void BluetoothEventRouter::OnExtensionUnloaded(
-    content::BrowserContext* browser_context,
-    const Extension* extension,
-    UnloadedExtensionInfo::Reason reason) {
-  CleanUpForExtension(extension->id());
-}
-
-}  // namespace extensions