Expose SetDiscoveryFilter from BluetoothEventRouter

extensions/browser/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 "extensions/browser/api/bluetooth/bluetooth_event_router.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 72 matching lines @@
     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;
   }
+
+  // Check whether user pre set discovery filter by calling SetDiscoveryFilter
+  // before. If the user has set a discovery filter then start a filtered
+  // discovery session, otherwise start a regular session
+  PreSetFilterMap::iterator pre_set_iter =
+      pre_set_filter_map_.find(extension_id);
+  if (pre_set_iter != pre_set_filter_map_.end()) {
+    adapter->StartDiscoverySessionWithFilter(
+        scoped_ptr<device::BluetoothDiscoveryFilter>(pre_set_iter->second),
+        base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
+                   weak_ptr_factory_.GetWeakPtr(), extension_id, callback),
+        error_callback);
+    pre_set_filter_map_.erase(pre_set_iter);
+    return;
+  }
   adapter->StartDiscoverySession(
       base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 callback),
+                 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);
 }
 
+void BluetoothEventRouter::SetDiscoveryFilter(
+    scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter,
+    device::BluetoothAdapter* adapter,
+    const std::string& extension_id,
+    const base::Closure& callback,
+    const base::Closure& error_callback) {
+  DVLOG(1) << "SetDiscoveryFilter";
+  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, so caching "
+                "filter for later use.";
+    pre_set_filter_map_[extension_id] = discovery_filter.release();
+    callback.Run();
+    return;
+  }
+
+  // extension is already running discovery, update it's discovery filter
+  iter->second->SetDiscoveryFilter(discovery_filter.Pass(), 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) {
@@ 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);
 
+  PreSetFilterMap::iterator pre_set_iter =
+      pre_set_filter_map_.find(extension_id);
+  if (pre_set_iter != pre_set_filter_map_.end()) {
+    delete pre_set_iter->second;
+    pre_set_filter_map_.erase(pre_set_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 (DiscoverySessionMap::iterator it = discovery_session_map_.begin();
-       it != discovery_session_map_.end();
-       ++it) {
-    delete it->second;
-  }
+  for (auto& it : pre_set_filter_map_)
+    delete it.second;
+
+  pre_set_filter_map_.clear();
+
+  for (auto& it : discovery_session_map_)
+    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::OnSetDiscoveryFilter(const std::string& extension_id,
+                                                const base::Closure& callback) {
+  DVLOG(1) << "Successfully set DiscoveryFilter.";
+  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