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;
   }
-  adapter->StartDiscoverySession(
-      base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 callback),
-      error_callback);
+

[armansito, 2015/04/16 19:13:54]

Add comments explaining what's going on here.

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+  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);

[armansito, 2015/04/16 19:13:55]

Do an early return and drop 'else'.

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+  } else {
+    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);
 }
 
+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) {
+  VLOG(1) << __func__;

[armansito, 2015/04/16 19:13:54]

Prefer DVLOG

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+  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()) {
+    VLOG(1) << "No active discovery session exists for extension.";

[armansito, 2015/04/16 19:13:55]

This may be interpreted incorrectly as an error case in the logs, so I would
explain more:

"No active discovery session exists for extension, so caching filter for later
use." or something along those.

[armansito, 2015/04/16 19:13:55]

DVLOG

[jpawlowski1, 2015/04/16 19:36:27]

Done.

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+    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 (PreSetFilterMap::iterator it = pre_set_filter_map_.begin();
+       it != pre_set_filter_map_.end(); it++) {

[armansito, 2015/04/16 19:13:54]

for (auto& it : pre_set_filter_map_)

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+    delete it->second;
+  }
+  pre_set_filter_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);
 }
 
 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) {

[armansito, 2015/04/16 19:13:55]

DVLOG success?

[jpawlowski1, 2015/04/16 19:36:27]

Done.

+  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