Bluetooth: remove Profile 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/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/chrome_notification_types.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 "device/bluetooth/bluetooth_profile.h"
-#include "device/bluetooth/bluetooth_socket.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 
 namespace extensions {
 
 namespace bluetooth = api::bluetooth;
 namespace bt_private = api::bluetooth_private;
 
-// A struct storing a Bluetooth profile and the extension that added it.
-struct BluetoothEventRouter::ExtensionBluetoothProfileRecord {
-  std::string extension_id;
-  device::BluetoothProfile* profile;
-};
-
 BluetoothEventRouter::BluetoothEventRouter(content::BrowserContext* context)
     : browser_context_(context),
       adapter_(NULL),
       num_event_listeners_(0),
       weak_ptr_factory_(this) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(browser_context_);
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<content::BrowserContext>(browser_context_));
@@ skipping 19 matching lines @@
 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::AddProfile(
-    const device::BluetoothUUID& uuid,
-    const std::string& extension_id,
-    device::BluetoothProfile* bluetooth_profile) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(!HasProfile(uuid));
-  ExtensionBluetoothProfileRecord record = { extension_id, bluetooth_profile };
-  bluetooth_profile_map_[uuid] = record;
-}
-
-void BluetoothEventRouter::RemoveProfile(const device::BluetoothUUID& uuid) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  BluetoothProfileMap::iterator iter = bluetooth_profile_map_.find(uuid);
-  if (iter != bluetooth_profile_map_.end()) {
-    device::BluetoothProfile* bluetooth_profile = iter->second.profile;
-    bluetooth_profile_map_.erase(iter);
-    bluetooth_profile->Unregister();
-  }
-}
-
-bool BluetoothEventRouter::HasProfile(const device::BluetoothUUID& uuid) const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  return bluetooth_profile_map_.find(uuid) != bluetooth_profile_map_.end();
-}
-
 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 =
@@ skipping 24 matching lines @@
       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);
 }
 
-device::BluetoothProfile* BluetoothEventRouter::GetProfile(
-    const device::BluetoothUUID& uuid) const {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  BluetoothProfileMap::const_iterator iter = bluetooth_profile_map_.find(uuid);
-  if (iter != bluetooth_profile_map_.end())
-    return iter->second.profile;
-
-  return NULL;
-}
-
 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) {
@@ skipping 174 matching lines @@
       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 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 {
-      profile_iter++;
-    }
-  }
-
   // 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 (BluetoothProfileMap::iterator it = bluetooth_profile_map_.begin();
-       it != bluetooth_profile_map_.end();
-       ++it) {
-    it->second.profile->Unregister();
-  }
-  bluetooth_profile_map_.clear();
-
   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);
@@ skipping 26 matching lines @@
     }
     case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       CleanUpForExtension(host->extension_id());
       break;
     }
   }
 }
 
 }  // namespace extensions