Revert 255262 "Migrate chrome.bluetooth API backend to use devic..."

Reverted due to memory leaks.

> Migrate chrome.bluetooth API backend to use device::BluetoothDiscoverySession.
> 
> Modified chrome.bluetooth API code to use the new discovery session API for
> device discovery.
> 
> BUG=346982
> TEST=1. unit_tests, browser_tests
>      2. Use multiple running extension instances with the bluetooth permission and check for the following behavior:
>         - Only one session per extension. Calling chrome.bluetooth.stopDiscovery from one running app should fail if that app never called chrome.bluetooth.startDiscovery.
>         - An app's discovery sessions should get cleaned up if that app crashes or unloads.
>         - Use bt_console and run "power off". This should cause all discovery sessions that have been assigned to apps to get marked as inactive. Verify by requesting a new discovery session from apps, which should succeed.
> 
> Review URL: https://codereview.chromium.org/179123008

TBR=armansito@chromium.org
BUG=349942

Review URL: https://codereview.chromium.org/188663003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255372 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/extensions/api/bluetooth/bluetooth_api.cc

@@ -636,18 +636,24 @@ void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
   SetError(kStartDiscoveryFailed);
+  GetEventRouter(browser_context())->SetResponsibleForDiscovery(false);
   SendResponse(false);
   GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStartDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  GetEventRouter(browser_context())->OnListenerAdded();
-  GetEventRouter(browser_context())->StartDiscoverySession(
-      adapter,
-      extension_id(),
-      base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
-      base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
+  GetEventRouter(browser_context())->SetSendDiscoveryEvents(true);
+
+  // If this profile is already discovering devices, there should be nothing
+  // else to do.
+  if (!GetEventRouter(browser_context())->IsResponsibleForDiscovery()) {
+    GetEventRouter(browser_context())->SetResponsibleForDiscovery(true);
+    GetEventRouter(browser_context())->OnListenerAdded();
+    adapter->StartDiscovering(
+        base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
+        base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
+  }
 
   return true;
 }
@@ -659,17 +665,19 @@ void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
 
 void BluetoothStopDiscoveryFunction::OnErrorCallback() {
   SetError(kStopDiscoveryFailed);
+  GetEventRouter(browser_context())->SetResponsibleForDiscovery(true);
   SendResponse(false);
   GetEventRouter(browser_context())->OnListenerRemoved();
 }
 
 bool BluetoothStopDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
-  GetEventRouter(browser_context())->StopDiscoverySession(
-      adapter,
-      extension_id(),
-      base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
-      base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
+  GetEventRouter(browser_context())->SetSendDiscoveryEvents(false);
+  if (GetEventRouter(browser_context())->IsResponsibleForDiscovery()) {
+    adapter->StopDiscovering(
+        base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
+        base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
+  }
 
   return true;
 }

chrome/browser/extensions/api/bluetooth/bluetooth_apitest.cc

@@ -17,19 +17,16 @@
 #include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
-#include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_profile.h"
 #include "device/bluetooth/test/mock_bluetooth_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
-using device::BluetoothDiscoverySession;
 using device::BluetoothOutOfBandPairingData;
 using device::BluetoothProfile;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
-using device::MockBluetoothDiscoverySession;
 using device::MockBluetoothProfile;
 using extensions::Extension;
 
@@ -68,17 +65,6 @@ class BluetoothApiTest : public ExtensionApiTest {
         false /* paired */, false /* connected */));
   }
 
-  void DiscoverySessionCallback(
-      const BluetoothAdapter::DiscoverySessionCallback& callback,
-      const BluetoothAdapter::ErrorCallback& error_callback) {
-    if (mock_session_.get()) {
-      callback.Run(
-          scoped_ptr<BluetoothDiscoverySession>(mock_session_.release()));
-      return;
-    }
-    error_callback.Run();
-  }
-
   template <class T>
   T* setupFunction(T* function) {
     function->set_extension(empty_extension_.get());
@@ -88,7 +74,6 @@ class BluetoothApiTest : public ExtensionApiTest {
 
  protected:
   testing::StrictMock<MockBluetoothAdapter>* mock_adapter_;
-  scoped_ptr<testing::NiceMock<MockBluetoothDiscoverySession> > mock_session_;
   scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device1_;
   scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device2_;
   scoped_ptr<testing::NiceMock<MockBluetoothProfile> > profile1_;
@@ -144,11 +129,18 @@ static bool CallClosure(const base::Closure& callback) {
   return true;
 }
 
-static void StopDiscoverySessionCallback(const base::Closure& callback,
-                                         const base::Closure& error_callback) {
+static void CallDiscoveryCallback(
+    const base::Closure& callback,
+    const BluetoothAdapter::ErrorCallback& error_callback) {
   callback.Run();
 }
 
+static void CallDiscoveryErrorCallback(
+    const base::Closure& callback,
+    const BluetoothAdapter::ErrorCallback& error_callback) {
+  error_callback.Run();
+}
+
 static void CallOutOfBandPairingDataCallback(
     const BluetoothAdapter::BluetoothOutOfBandPairingDataCallback& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
@@ -324,12 +316,9 @@ IN_PROC_BROWSER_TEST_F(BluetoothApiTest, SetOutOfBandPairingData) {
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
-  // Try with a failure to start. This will return an error as we haven't
-  // initialied a session object.
-  EXPECT_CALL(*mock_adapter_, StartDiscoverySession(testing::_, testing::_))
-      .WillOnce(
-          testing::Invoke(this, &BluetoothApiTest::DiscoverySessionCallback));
-
+  // Try with a failure to start
+  EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryErrorCallback));
   // StartDiscovery failure will remove the adapter that is no longer used.
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   scoped_refptr<api::BluetoothStartDiscoveryFunction> start_function;
@@ -338,28 +327,19 @@ IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
       utils::RunFunctionAndReturnError(start_function.get(), "[]", browser()));
   ASSERT_FALSE(error.empty());
 
-  // Reset the adapter and initiate a discovery session. The ownership of the
-  // mock session will be passed to the event router.
-  ASSERT_FALSE(mock_session_.get());
+  // Reset for a successful start
   SetUpMockAdapter();
+  EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
 
-  // Create a mock session to be returned as a result. Get a handle to it as
-  // its ownership will be passed and |mock_session_| will be reset.
-  mock_session_.reset(new testing::NiceMock<MockBluetoothDiscoverySession>());
-  MockBluetoothDiscoverySession* session = mock_session_.get();
-  EXPECT_CALL(*mock_adapter_, StartDiscoverySession(testing::_, testing::_))
-      .WillOnce(
-          testing::Invoke(this, &BluetoothApiTest::DiscoverySessionCallback));
   start_function = setupFunction(new api::BluetoothStartDiscoveryFunction);
   (void)
       utils::RunFunctionAndReturnError(start_function.get(), "[]", browser());
 
-  // End the discovery session. The StopDiscovery function should succeed.
+  // Reset to try stopping
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
-  EXPECT_CALL(*session, IsActive()).WillOnce(testing::Return(true));
-  EXPECT_CALL(*session, Stop(testing::_, testing::_))
-      .WillOnce(testing::Invoke(StopDiscoverySessionCallback));
-
+  EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
   // StopDiscovery success will remove the adapter that is no longer used.
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   scoped_refptr<api::BluetoothStopDiscoveryFunction> stop_function;
@@ -367,10 +347,10 @@ IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
   (void) utils::RunFunctionAndReturnSingleResult(
       stop_function.get(), "[]", browser());
 
-  // Reset the adapter. Simulate failure for stop discovery. The event router
-  // still owns the session. Make it appear inactive.
+  // Reset to try stopping with an error
   SetUpMockAdapter();
-  EXPECT_CALL(*session, IsActive()).WillOnce(testing::Return(false));
+  EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryErrorCallback));
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
   error =
@@ -380,14 +360,10 @@ IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DiscoveryCallback) {
-  mock_session_.reset(new testing::NiceMock<MockBluetoothDiscoverySession>());
-  MockBluetoothDiscoverySession* session = mock_session_.get();
-  EXPECT_CALL(*mock_adapter_, StartDiscoverySession(testing::_, testing::_))
-      .WillOnce(
-          testing::Invoke(this, &BluetoothApiTest::DiscoverySessionCallback));
-  EXPECT_CALL(*session, IsActive()).WillOnce(testing::Return(true));
-  EXPECT_CALL(*session, Stop(testing::_, testing::_))
-      .WillOnce(testing::Invoke(StopDiscoverySessionCallback));
+  EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
+  EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
 
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
@@ -432,22 +408,17 @@ IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DiscoveryInProgress) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
-  mock_session_.reset(new testing::NiceMock<MockBluetoothDiscoverySession>());
-  MockBluetoothDiscoverySession* session = mock_session_.get();
-  EXPECT_CALL(*mock_adapter_, StartDiscoverySession(testing::_, testing::_))
-      .WillOnce(
-          testing::Invoke(this, &BluetoothApiTest::DiscoverySessionCallback));
-  EXPECT_CALL(*session, IsActive()).WillOnce(testing::Return(true));
-  EXPECT_CALL(*session, Stop(testing::_, testing::_))
-      .WillOnce(testing::Invoke(StopDiscoverySessionCallback));
+  EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
+  EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
+      .WillOnce(testing::Invoke(CallDiscoveryCallback));
 
   ExtensionTestMessageListener discovery_started("ready", true);
   ASSERT_TRUE(LoadExtension(
         test_data_dir_.AppendASCII("bluetooth/discovery_in_progress")));
   EXPECT_TRUE(discovery_started.WaitUntilSatisfied());
 
-  // Only this should be received. No additional notification should be sent for
-  // devices discovered before the discovery session started.
+  // This should be received in addition to the cached device above.
   event_router()->DeviceAdded(mock_adapter_, device2_.get());
 
   discovery_started.Reply("go");

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.cc

@@ -22,7 +22,6 @@
 #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"
@@ -46,7 +45,9 @@ struct ExtensionBluetoothProfileRecord {
 
 ExtensionBluetoothEventRouter::ExtensionBluetoothEventRouter(
     content::BrowserContext* context)
-    : browser_context_(context),
+    : send_discovery_events_(false),
+      responsible_for_discovery_(false),
+      browser_context_(context),
       adapter_(NULL),
       num_event_listeners_(0),
       next_socket_id_(1),
@@ -71,11 +72,6 @@ ExtensionBluetoothEventRouter::~ExtensionBluetoothEventRouter() {
        ++iter) {
     iter->second.profile->Unregister();
   }
-  for (DiscoverySessionMap::iterator iter = discovery_session_map_.begin();
-       iter != discovery_session_map_.end();
-       ++iter) {
-    delete iter->second;
-  }
 }
 
 bool ExtensionBluetoothEventRouter::IsBluetoothSupported() const {
@@ -149,50 +145,6 @@ bool ExtensionBluetoothEventRouter::HasProfile(const std::string& uuid) const {
   return bluetooth_profile_map_.find(uuid) != bluetooth_profile_map_.end();
 }
 
-void ExtensionBluetoothEventRouter::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(&ExtensionBluetoothEventRouter::OnStartDiscoverySession,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 extension_id,
-                 callback),
-      error_callback);
-}
-
-void ExtensionBluetoothEventRouter::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);
-}
-
 device::BluetoothProfile* ExtensionBluetoothEventRouter::GetProfile(
     const std::string& uuid) const {
   BluetoothProfileMap::const_iterator iter = bluetooth_profile_map_.find(uuid);
@@ -210,6 +162,29 @@ ExtensionBluetoothEventRouter::GetSocket(int id) {
   return socket_entry->second.socket;
 }
 
+void ExtensionBluetoothEventRouter::SetResponsibleForDiscovery(
+    bool responsible) {
+  responsible_for_discovery_ = responsible;
+}
+
+bool ExtensionBluetoothEventRouter::IsResponsibleForDiscovery() const {
+  return responsible_for_discovery_;
+}
+
+void ExtensionBluetoothEventRouter::SetSendDiscoveryEvents(bool should_send) {
+  // At the transition into sending devices, also send past devices that
+  // were discovered as they will not be discovered again.
+  if (should_send && !send_discovery_events_) {
+    for (DeviceList::const_iterator i = discovered_devices_.begin();
+        i != discovered_devices_.end(); ++i) {
+      DispatchDeviceEvent(extensions::event_names::kBluetoothOnDeviceDiscovered,
+                          **i);
+    }
+  }
+
+  send_discovery_events_ = should_send;
+}
+
 void ExtensionBluetoothEventRouter::DispatchDeviceEvent(
     const std::string& event_name, const bluetooth::Device& device) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
@@ -268,19 +243,9 @@ void ExtensionBluetoothEventRouter::AdapterDiscoveringChanged(
   }
 
   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);
+    send_discovery_events_ = false;
+    responsible_for_discovery_ = false;
+    discovered_devices_.clear();
   }
 
   DispatchAdapterStateEvent();
@@ -298,6 +263,10 @@ void ExtensionBluetoothEventRouter::DeviceAdded(
       new bluetooth::Device();
   bluetooth::BluetoothDeviceToApiDevice(
       *device, extension_device);
+  discovered_devices_.push_back(extension_device);
+
+  if (!send_discovery_events_)
+    return;
 
   DispatchDeviceEvent(extensions::event_names::kBluetoothOnDeviceDiscovered,
                       *extension_device);
@@ -362,27 +331,6 @@ void ExtensionBluetoothEventRouter::CleanUpForExtension(
       ReleaseSocket(socket_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 ExtensionBluetoothEventRouter::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 ExtensionBluetoothEventRouter::Observe(

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h

@@ -24,7 +24,6 @@ class BrowserContext;
 namespace device {
 
 class BluetoothDevice;
-class BluetoothDiscoverySession;
 class BluetoothProfile;
 
 }  // namespace device
@@ -82,25 +81,6 @@ class ExtensionBluetoothEventRouter
   // registered.
   bool HasProfile(const std::string& uuid) const;
 
-  // Requests that a new device discovery session be initiated for extension
-  // with id |extension_id|. |callback| is called, if a session has been
-  // initiated. |error_callback| is called, if the adapter failed to initiate
-  // the session or if an active session already exists for the extension.
-  void StartDiscoverySession(device::BluetoothAdapter* adapter,
-                             const std::string& extension_id,
-                             const base::Closure& callback,
-                             const base::Closure& error_callback);
-
-  // Requests that the active discovery session that belongs to the extension
-  // with id |extension_id| be terminated. |callback| is called, if the session
-  // successfully ended. |error_callback| is called, if the adapter failed to
-  // terminate the session or if no active discovery session exists for the
-  // extension.
-  void StopDiscoverySession(device::BluetoothAdapter* adapter,
-                            const std::string& extension_id,
-                            const base::Closure& callback,
-                            const base::Closure& error_callback);
-
   // Returns the BluetoothProfile that corresponds to |uuid|. It returns NULL
   // if the BluetoothProfile with |uuid| does not exist.
   device::BluetoothProfile* GetProfile(const std::string& uuid) const;
@@ -108,6 +88,14 @@ class ExtensionBluetoothEventRouter
   // Get the BluetoothSocket corresponding to |id|.
   scoped_refptr<device::BluetoothSocket> GetSocket(int id);
 
+  // Sets whether this Profile is responsible for the discovering state of the
+  // adapter.
+  void SetResponsibleForDiscovery(bool responsible);
+  bool IsResponsibleForDiscovery() const;
+
+  // Sets whether or not DeviceAdded events will be dispatched to extensions.
+  void SetSendDiscoveryEvents(bool should_send);
+
   // Dispatch an event that takes a device as a parameter to all renderers.
   void DispatchDeviceEvent(
       const std::string& event_name,
@@ -139,17 +127,15 @@ class ExtensionBluetoothEventRouter
   void SetAdapterForTest(device::BluetoothAdapter* adapter) {
     adapter_ = adapter;
   }
-
  private:
   void InitializeAdapterIfNeeded();
   void InitializeAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
   void MaybeReleaseAdapter();
   void DispatchAdapterStateEvent();
   void CleanUpForExtension(const std::string& extension_id);
-  void OnStartDiscoverySession(
-      const std::string& extension_id,
-      const base::Closure& callback,
-      scoped_ptr<device::BluetoothDiscoverySession> discovery_session);
+
+  bool send_discovery_events_;
+  bool responsible_for_discovery_;
 
   content::BrowserContext* browser_context_;
   scoped_refptr<device::BluetoothAdapter> adapter_;
@@ -164,16 +150,15 @@ class ExtensionBluetoothEventRouter
   typedef std::map<int, ExtensionBluetoothSocketRecord> SocketMap;
   SocketMap socket_map_;
 
+  typedef ScopedVector<extensions::api::bluetooth::Device>
+      DeviceList;
+  DeviceList discovered_devices_;
+
   // A map that maps uuids to ExtensionBluetoothProfileRecord.
   typedef std::map<std::string, ExtensionBluetoothProfileRecord>
       BluetoothProfileMap;
   BluetoothProfileMap bluetooth_profile_map_;
 
-  // A map that maps extension ids to BluetoothDiscoverySession pointers.
-  typedef std::map<std::string, device::BluetoothDiscoverySession*>
-      DiscoverySessionMap;
-  DiscoverySessionMap discovery_session_map_;
-
   content::NotificationRegistrar registrar_;
 
   base::WeakPtrFactory<ExtensionBluetoothEventRouter> weak_ptr_factory_;

chrome/test/data/extensions/api_test/bluetooth/discovery_in_progress/runtest.js

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-var kExpectedDeviceNames = ["d2"];
+var kExpectedDeviceNames = ["d1", "d2"];
 
 function testDiscovery() {
   chrome.test.assertEq(kExpectedDeviceNames.length,

device/bluetooth/bluetooth.gyp

@@ -123,8 +123,6 @@
         'test/mock_bluetooth_adapter.h',
         'test/mock_bluetooth_device.cc',
         'test/mock_bluetooth_device.h',
-        'test/mock_bluetooth_discovery_session.cc',
-        'test/mock_bluetooth_discovery_session.h',
         'test/mock_bluetooth_profile.cc',
         'test/mock_bluetooth_profile.h',
         'test/mock_bluetooth_socket.cc',

device/bluetooth/bluetooth_adapter.cc

@@ -113,7 +113,7 @@ void BluetoothAdapter::OnStartDiscoverySession(
     const DiscoverySessionCallback& callback) {
   VLOG(1) << "Discovery session started!";
   scoped_ptr<BluetoothDiscoverySession> discovery_session(
-      new BluetoothDiscoverySession(scoped_refptr<BluetoothAdapter>(this)));
+      new BluetoothDiscoverySession(this));
   discovery_sessions_.insert(discovery_session.get());
   callback.Run(discovery_session.Pass());
 }

device/bluetooth/bluetooth_discovery_session.cc

@@ -9,23 +9,13 @@
 
 namespace device {
 
-BluetoothDiscoverySession::BluetoothDiscoverySession(
-    scoped_refptr<BluetoothAdapter> adapter)
+BluetoothDiscoverySession::BluetoothDiscoverySession(BluetoothAdapter* adapter)
     : active_(true),
       adapter_(adapter),
       weak_ptr_factory_(this) {
-  DCHECK(adapter_.get());
-}
-
-BluetoothDiscoverySession::BluetoothDiscoverySession()
-    : active_(false),
-      weak_ptr_factory_(this) {
 }
 
 BluetoothDiscoverySession::~BluetoothDiscoverySession() {
-  if (!active_)
-    return;
-  DCHECK(adapter_.get());
   Stop(base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
   adapter_->DiscoverySessionDestroyed(this);
 }
@@ -38,12 +28,11 @@ void BluetoothDiscoverySession::Stop(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!active_) {
-    LOG(WARNING) << "Discovery session not active. Cannot stop.";
+    LOG(ERROR) << "Discovery session not active. Cannot stop.";
     error_callback.Run();
     return;
   }
   VLOG(1) << "Stopping device discovery session.";
-  DCHECK(adapter_.get());
   adapter_->RemoveDiscoverySession(
       base::Bind(&BluetoothDiscoverySession::OnStop,
                  weak_ptr_factory_.GetWeakPtr(),

device/bluetooth/bluetooth_discovery_session.h

@@ -58,12 +58,10 @@ class BluetoothDiscoverySession {
                     const ErrorCallback& error_callback);
 
  protected:
-  BluetoothDiscoverySession();  // Called by mock.
-
- private:
   friend class BluetoothAdapter;
-  explicit BluetoothDiscoverySession(scoped_refptr<BluetoothAdapter> adapter);
+  explicit BluetoothDiscoverySession(BluetoothAdapter* adapter);
 
+ private:
   // Internal callback invoked when a call to Stop has succeeded.
   void OnStop(const base::Closure& callback);
 

device/bluetooth/test/mock_bluetooth_adapter.cc

@@ -14,14 +14,4 @@ MockBluetoothAdapter::MockBluetoothAdapter() {
 
 MockBluetoothAdapter::~MockBluetoothAdapter() {}
 
-void MockBluetoothAdapter::AddDiscoverySession(
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-}
-
-void MockBluetoothAdapter::RemoveDiscoverySession(
-    const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-}
-
 }  // namespace device

device/bluetooth/test/mock_bluetooth_adapter.h

@@ -52,9 +52,6 @@ class MockBluetoothAdapter : public BluetoothAdapter {
                     const base::Closure& callback,
                     const ErrorCallback& error_callback));
   MOCK_CONST_METHOD0(IsDiscovering, bool());
-  MOCK_METHOD2(StartDiscoverySession,
-               void(const DiscoverySessionCallback& callback,
-                    const ErrorCallback& error_callback));
   MOCK_METHOD2(StartDiscovering,
                void(const base::Closure& callback,
                     const ErrorCallback& error_callback));
@@ -77,10 +74,12 @@ class MockBluetoothAdapter : public BluetoothAdapter {
   MOCK_METHOD0(DefaultPairingDelegate, BluetoothDevice::PairingDelegate*());
 
  protected:
-  virtual void AddDiscoverySession(const base::Closure& callback,
-                                   const ErrorCallback& error_callback);
-  virtual void RemoveDiscoverySession(const base::Closure& callback,
-                                      const ErrorCallback& error_callback);
+  MOCK_METHOD2(AddDiscoverySession,
+               void(const base::Closure& callback,
+                    const ErrorCallback& error_callback));
+  MOCK_METHOD2(RemoveDiscoverySession,
+               void(const base::Closure& callback,
+                    const ErrorCallback& error_callback));
   virtual ~MockBluetoothAdapter();
 
   MOCK_METHOD1(RemovePairingDelegateInternal,

device/bluetooth/test/mock_bluetooth_discovery_session.cc

-// Copyright 2014 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 "device/bluetooth/test/mock_bluetooth_discovery_session.h"
-
-#include "device/bluetooth/bluetooth_adapter.h"
-
-namespace device {
-
-MockBluetoothDiscoverySession::MockBluetoothDiscoverySession() {}
-MockBluetoothDiscoverySession::~MockBluetoothDiscoverySession() {}
-
-}  // namespace device

device/bluetooth/test/mock_bluetooth_discovery_session.h

-// Copyright 2014 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.
-
-#ifndef DEVICE_BLUETOOTH_TEST_MOCK_BLUETOOTH_DISCOVERY_SESSION_H_
-#define DEVICE_BLUETOOTH_TEST_MOCK_BLUETOOTH_DISCOVERY_SESSION_H_
-
-#include "base/callback.h"
-#include "device/bluetooth/bluetooth_discovery_session.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace device {
-
-class BluetoothAdapter;
-
-class MockBluetoothDiscoverySession : public BluetoothDiscoverySession {
- public:
-  MockBluetoothDiscoverySession();
-  virtual ~MockBluetoothDiscoverySession();
-
-  MOCK_CONST_METHOD0(IsActive, bool());
-  MOCK_METHOD2(Stop,
-               void(const base::Closure& callback,
-                    const ErrorCallback& error_callback));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockBluetoothDiscoverySession);
-};
-
-}  // namespac device
-
-#endif  // DEVICE_BLUETOOTH_TEST_MOCK_BLUETOOTH_DISCOVERY_SESSION_H_