Implement finding BLE connections in chrome://proximity-auth.

components/proximity_auth/bluetooth_connection_finder_unittest.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 "components/proximity_auth/bluetooth_connection_finder.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
 using testing::StrictMock;
 
 namespace proximity_auth {
 namespace {
@@ skipping 45 matching lines @@
     scoped_ptr<MockConnection> connection(new NiceMock<MockConnection>());
     MockConnection* connection_alias = connection.get();
     EXPECT_CALL(*this, CreateConnectionProxy())
         .WillOnce(Return(connection.release()));
     return connection_alias;
   }
 
   using BluetoothConnectionFinder::AdapterPresentChanged;
   using BluetoothConnectionFinder::AdapterPoweredChanged;
 
+  void ClearSeekCallbacks() {
+    seek_callback_ = base::Closure();
+    seek_error_callback_ = bluetooth_util::ErrorCallback();
+  }
+
+  const base::Closure& seek_callback() { return seek_callback_; }
+  const bluetooth_util::ErrorCallback& seek_error_callback() {
+    return seek_error_callback_;
+  }
+
  protected:
+  // BluetoothConnectionFinder:
   scoped_ptr<Connection> CreateConnection() override {
     return make_scoped_ptr(CreateConnectionProxy());
   }
 
+  void SeekDeviceByAddress(
+      const std::string& bluetooth_address,
+      const base::Closure& callback,
+      const bluetooth_util::ErrorCallback& error_callback) override {
+    EXPECT_EQ(kBluetoothAddress, bluetooth_address);
+    seek_callback_ = callback;
+    seek_error_callback_ = error_callback;
+  }
+
  private:
+  base::Closure seek_callback_;
+  bluetooth_util::ErrorCallback seek_error_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnectionFinder);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothConnectionFinderTest : public testing::Test {
  protected:
   ProximityAuthBluetoothConnectionFinderTest()
       : adapter_(new NiceMock<device::MockBluetoothAdapter>),
+        bluetooth_device_(new NiceMock<device::MockBluetoothDevice>(
+            adapter_.get(),
+            device::BluetoothDevice::DEVICE_PHONE,
+            kDeviceName,
+            kBluetoothAddress,
+            true,
+            false)),
         connection_callback_(base::Bind(
             &ProximityAuthBluetoothConnectionFinderTest::OnConnectionFound,
             base::Unretained(this))) {
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     // By default, configure the environment to allow polling. Individual tests
     // can override this as needed.
     ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
     ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(true));
+    ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+        .WillByDefault(Return(bluetooth_device_.get()));

[sacomoto, 2015/08/10 19:40:28]

nit: add a comment that by default the device is know and |SeekByDeviceAddress|
is not called.

[Tim Song, 2015/08/10 22:17:55]

Done.

   }
 
   MOCK_METHOD1(OnConnectionFoundProxy, void(Connection* connection));
   void OnConnectionFound(scoped_ptr<Connection> connection) {
     OnConnectionFoundProxy(connection.get());
     last_found_connection_ = connection.Pass();
   }
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
+  scoped_ptr<device::MockBluetoothDevice> bluetooth_device_;
   ConnectionFinder::ConnectionCallback connection_callback_;
 
  private:
   // Save a pointer to the last found connection, to extend its lifetime.
   scoped_ptr<Connection> last_found_connection_;
 
   base::MessageLoop message_loop_;
 };
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
@@ skipping 31 matching lines @@
   StrictMock<MockBluetoothConnectionFinder> connection_finder;
   ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(false));
   connection_finder.Find(connection_callback_);
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest, Find_ConnectionSucceeds) {
   StrictMock<MockBluetoothConnectionFinder> connection_finder;
 
   MockConnection* connection = connection_finder.ExpectCreateConnection();
   connection_finder.Find(connection_callback_);
+  EXPECT_TRUE(connection_finder.seek_callback().is_null());
+  EXPECT_TRUE(connection_finder.seek_error_callback().is_null());
 
   connection->SetStatus(Connection::IN_PROGRESS);
 
+  base::RunLoop run_loop;
   EXPECT_CALL(*this, OnConnectionFoundProxy(_));
   connection->SetStatus(Connection::CONNECTED);
+  run_loop.RunUntilIdle();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        Find_ConnectionSucceeds_UnregistersAsObserver) {
   StrictMock<MockBluetoothConnectionFinder> connection_finder;
 
   MockConnection* connection = connection_finder.ExpectCreateConnection();
   connection_finder.Find(connection_callback_);
 
   connection->SetStatus(Connection::IN_PROGRESS);
 
-  EXPECT_CALL(*this, OnConnectionFoundProxy(_));
-  EXPECT_CALL(*adapter_, RemoveObserver(&connection_finder));
-  connection->SetStatus(Connection::CONNECTED);
+  {
+    base::RunLoop run_loop;
+    EXPECT_CALL(*this, OnConnectionFoundProxy(_));
+    EXPECT_CALL(*adapter_, RemoveObserver(&connection_finder));
+    connection->SetStatus(Connection::CONNECTED);
+    run_loop.RunUntilIdle();
+  }
 
-  // If for some reason the connection sends more status updates, they should be
-  // ignored.
-  EXPECT_CALL(*this, OnConnectionFoundProxy(_)).Times(0);
-  connection->SetStatus(Connection::IN_PROGRESS);
-  connection->SetStatus(Connection::CONNECTED);
+  {
+    // If for some reason the connection sends more status updates, they should
+    // be

[sacomoto, 2015/08/10 19:40:28]

nit: kill the extra line.

[Tim Song, 2015/08/10 22:17:55]

Done.

+    // ignored.
+    base::RunLoop run_loop;
+    EXPECT_CALL(*this, OnConnectionFoundProxy(_)).Times(0);
+    connection->SetStatus(Connection::IN_PROGRESS);
+    connection->SetStatus(Connection::CONNECTED);
+    run_loop.RunUntilIdle();
+  }
 }
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        Find_ConnectionFails_PostsTaskToPollAgain) {
   StrictMock<MockBluetoothConnectionFinder> connection_finder;
 
   MockConnection* connection = connection_finder.ExpectCreateConnection();
   connection_finder.Find(connection_callback_);
 
   // Simulate a connection that fails to connect.
@@ skipping 70 matching lines @@
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
   ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
 
   // Now that there is no pending task, events should once again trigger new
   // polling iterations.
   connection_finder.ExpectCreateConnection();
   connection_finder.AdapterPresentChanged(adapter_.get(), true);
 }
 
+TEST_F(ProximityAuthBluetoothConnectionFinderTest,
+       Find_DeviceNotKnown_SeekDeviceSucceeds) {
+  // If the BluetoothDevice is not known by the adapter, |connection_finder|
+  // will call SeekDeviceByAddress() first to make it known.
+  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+      .WillByDefault(Return(nullptr));
+  StrictMock<MockBluetoothConnectionFinder> connection_finder;
+  connection_finder.Find(connection_callback_);
+  ASSERT_FALSE(connection_finder.seek_callback().is_null());
+  EXPECT_FALSE(connection_finder.seek_error_callback().is_null());
+
+  // After seeking is successful, the normal flow should resume.

[sacomoto, 2015/08/10 19:40:28]

optional: you could refactor this in a helper method.

[Tim Song, 2015/08/10 22:17:55]

Done.

+  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+      .WillByDefault(Return(bluetooth_device_.get()));
+  MockConnection* connection = connection_finder.ExpectCreateConnection();
+  connection_finder.seek_callback().Run();
+
+  connection->SetStatus(Connection::IN_PROGRESS);
+  base::RunLoop run_loop;
+  EXPECT_CALL(*this, OnConnectionFoundProxy(_));
+  connection->SetStatus(Connection::CONNECTED);
+  run_loop.RunUntilIdle();
+}
+
+TEST_F(ProximityAuthBluetoothConnectionFinderTest,
+       Find_DeviceNotKnown_SeekDeviceFailThenSucceeds) {
+  // If the BluetoothDevice is not known by the adapter, |connection_finder|
+  // will call SeekDeviceByAddress() first to make it known.
+  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+      .WillByDefault(Return(nullptr));
+  StrictMock<MockBluetoothConnectionFinder> connection_finder;
+  connection_finder.Find(connection_callback_);
+  EXPECT_FALSE(connection_finder.seek_callback().is_null());
+  ASSERT_FALSE(connection_finder.seek_error_callback().is_null());
+
+  // If the seek fails, then |connection_finder| will post a delayed poll to
+  // reattempt the seek.
+  connection_finder.seek_error_callback().Run("Seek failed for test.");
+  connection_finder.ClearSeekCallbacks();
+  EXPECT_TRUE(connection_finder.seek_callback().is_null());
+  EXPECT_TRUE(connection_finder.seek_error_callback().is_null());
+
+  // Check that seek is reattempted.
+  {
+    base::RunLoop run_loop;
+    run_loop.RunUntilIdle();
+    ASSERT_FALSE(connection_finder.seek_callback().is_null());
+    EXPECT_FALSE(connection_finder.seek_error_callback().is_null());
+  }
+
+  // Successfully connect to the Bluetooth device.
+  ON_CALL(*adapter_, GetDevice(kBluetoothAddress))
+      .WillByDefault(Return(bluetooth_device_.get()));
+  MockConnection* connection = connection_finder.ExpectCreateConnection();
+  connection_finder.seek_callback().Run();
+
+  connection->SetStatus(Connection::IN_PROGRESS);
+  {
+    base::RunLoop run_loop;
+    EXPECT_CALL(*this, OnConnectionFoundProxy(_));
+    connection->SetStatus(Connection::CONNECTED);
+    run_loop.RunUntilIdle();
+  }
+}
+
 }  // namespace proximity_auth