Fix BluetoothConnection to disconnect when the underlying device disconnects.

components/proximity_auth/bluetooth_connection_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.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "components/proximity_auth/remote_device.h"
@@ skipping 55 matching lines @@
   MOCK_METHOD2(OnDidSendMessage,
                void(const WireMessage& message, bool success));
 
   void SetStatus(Status status) override {
     SetStatusProxy(status);
     BluetoothConnection::SetStatus(status);
   }
 
   using BluetoothConnection::status;
   using BluetoothConnection::Connect;
+  using BluetoothConnection::DeviceChanged;
   using BluetoothConnection::DeviceRemoved;
   using BluetoothConnection::Disconnect;
 
  private:
   RemoteDevice CreateRemoteDevice() {
     return RemoteDevice(kDeviceUserId, kDeviceName, kPublicKey,
                         kBluetoothAddress, kPersistentSymmetricKey);
   }
 
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnection);
@@ skipping 21 matching lines @@
         uuid_(kUuid) {
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     // Suppress uninteresting Gmock call warnings.
     EXPECT_CALL(*adapter_, GetDevice(_)).Times(AnyNumber());
   }
 
   // Transition the connection into an in-progress state.
   void BeginConnecting(MockBluetoothConnection* connection) {
     EXPECT_EQ(Connection::DISCONNECTED, connection->status());
+    ON_CALL(device_, IsConnected()).WillByDefault(Return(false));
 
     ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
     EXPECT_CALL(*connection, SetStatusProxy(Connection::IN_PROGRESS));
     EXPECT_CALL(*adapter_, AddObserver(connection));
     EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _));
     connection->Connect();
 
     EXPECT_EQ(Connection::IN_PROGRESS, connection->status());
   }
 
@@ skipping 12 matching lines @@
     connection->Connect();
     ASSERT_FALSE(callback.is_null());
 
     EXPECT_CALL(*connection, SetStatusProxy(Connection::CONNECTED));
     EXPECT_CALL(*socket_, Receive(_, _, _))
         .WillOnce(DoAll(SaveArg<1>(&receive_callback_),
                         SaveArg<2>(&receive_error_callback_)));
     callback.Run(socket_);
 
     EXPECT_EQ(Connection::CONNECTED, connection->status());
+    ON_CALL(device_, IsConnected()).WillByDefault(Return(true));
   }
 
   device::BluetoothSocket::ReceiveCompletionCallback* receive_callback() {
     return &receive_callback_;
   }
   device::BluetoothSocket::ReceiveErrorCompletionCallback*
   receive_error_callback() {
     return &receive_error_callback_;
   }
 
@@ skipping 290 matching lines @@
   connection.SendMessage(wire_message.Pass());
 
   ASSERT_FALSE(error_callback.is_null());
   EXPECT_CALL(connection, OnDidSendMessage(Ref(*expected_wire_message), false));
   EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
   EXPECT_CALL(*socket_, Disconnect(_));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   error_callback.Run("The most helpful of error messages");
 }
 
+TEST_F(ProximityAuthBluetoothConnectionTest, DeviceChanged_Disconnected) {
+  // Create a connected connection.
+  StrictMock<MockBluetoothConnection> connection;
+  Connect(&connection);
+  EXPECT_TRUE(connection.IsConnected());
+
+  // If the remote device disconnects, |connection| should also disconnect.
+  ON_CALL(device_, IsConnected()).WillByDefault(Return(false));
+  EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
+  EXPECT_CALL(*socket_, Disconnect(_));
+  EXPECT_CALL(*adapter_, RemoveObserver(&connection));
+  connection.DeviceChanged(adapter_.get(), &device_);
+  EXPECT_FALSE(connection.IsConnected());
+}
+
+TEST_F(ProximityAuthBluetoothConnectionTest, DeviceChanged_NotDisconnected) {
+  // Nothing should happen if DeviceChanged is called, but the remote device is
+  // not disconnected.
+  StrictMock<MockBluetoothConnection> connection;
+  Connect(&connection);
+  EXPECT_TRUE(connection.IsConnected());
+  connection.DeviceChanged(adapter_.get(), &device_);
+  EXPECT_TRUE(connection.IsConnected());
+
+  // The connection disconnects and unregisters as an observer upon destruction.
+  EXPECT_CALL(*socket_, Disconnect(_));
+  EXPECT_CALL(*adapter_, RemoveObserver(&connection));
+}
+
 }  // namespace proximity_auth