[Clean up] Expose ConnectToServiceInsecurely as a BluetoothDevice API on all platforms.

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 39 matching lines @@
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kReceiveBufferSize);
   memcpy(buffer->data(), kReceiveBufferContents, kReceiveBufferSize);
   return buffer;
 }
 
 class MockBluetoothConnection : public BluetoothConnection {
  public:
   MockBluetoothConnection()
       : BluetoothConnection(kRemoteDevice, device::BluetoothUUID(kUuid)) {}
 
-  // Bluetooth dependencies.
-  typedef device::BluetoothDevice::ConnectToServiceCallback
-      ConnectToServiceCallback;
-  typedef device::BluetoothDevice::ConnectToServiceErrorCallback
-      ConnectToServiceErrorCallback;
-  MOCK_METHOD4(ConnectToService,
-               void(device::BluetoothDevice* device,
-                    const device::BluetoothUUID& uuid,
-                    const ConnectToServiceCallback& callback,
-                    const ConnectToServiceErrorCallback& error_callback));
-
   // Calls back into the parent Connection class.
   MOCK_METHOD1(SetStatusProxy, void(Status status));
   MOCK_METHOD1(OnBytesReceived, void(const std::string& bytes));
   MOCK_METHOD2(OnDidSendMessage,
                void(const WireMessage& message, bool success));
 
   virtual void SetStatus(Status status) override {
     SetStatusProxy(status);
     BluetoothConnection::SetStatus(status);
   }
@@ skipping 33 matching lines @@
     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(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
     EXPECT_CALL(*connection, SetStatusProxy(Connection::IN_PROGRESS));
     EXPECT_CALL(*adapter_, AddObserver(connection));
-    EXPECT_CALL(*connection, ConnectToService(&device_, uuid_, _, _));
+    EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _));
     connection->Connect();
 
     EXPECT_EQ(Connection::IN_PROGRESS, connection->status());
   }
 
   // Transition the connection into a connected state.
   // Saves the success and error callbacks passed into OnReceive(), which can be
   // accessed via receive_callback() and receive_success_callback().
   void Connect(MockBluetoothConnection* connection) {
     EXPECT_EQ(Connection::DISCONNECTED, connection->status());
 
     device::BluetoothDevice::ConnectToServiceCallback callback;
     ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
     EXPECT_CALL(*connection, SetStatusProxy(Connection::IN_PROGRESS));
     EXPECT_CALL(*adapter_, AddObserver(connection));
-    EXPECT_CALL(*connection, ConnectToService(_, _, _, _))
-        .WillOnce(SaveArg<2>(&callback));
+    EXPECT_CALL(device_, ConnectToServiceInsecurely(_, _, _))
+        .WillOnce(SaveArg<1>(&callback));
     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());
@@ skipping 102 matching lines @@
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, Connect_ConnectionFails) {
   StrictMock<MockBluetoothConnection> connection;
 
   device::BluetoothDevice::ConnectToServiceErrorCallback error_callback;
   ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
   EXPECT_CALL(connection, SetStatusProxy(Connection::IN_PROGRESS));
   EXPECT_CALL(*adapter_, AddObserver(&connection));
-  EXPECT_CALL(connection, ConnectToService(&device_, uuid_, _, _))
-      .WillOnce(SaveArg<3>(&error_callback));
+  EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _))
+      .WillOnce(SaveArg<2>(&error_callback));
   connection.Connect();
   ASSERT_FALSE(error_callback.is_null());
 
   EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   error_callback.Run("super descriptive error message");
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest, Connect_ConnectionSucceeds) {
   StrictMock<MockBluetoothConnection> connection;
@@ skipping 99 matching lines @@
   connection.Disconnect();
 }
 
 TEST_F(ProximityAuthBluetoothConnectionTest,
        Connect_ThenDisconnectWhileInProgress_ThenBackingConnectionSucceeds) {
   StrictMock<MockBluetoothConnection> connection;
   device::BluetoothDevice::ConnectToServiceCallback callback;
   ON_CALL(*adapter_, GetDevice(_)).WillByDefault(Return(&device_));
   EXPECT_CALL(connection, SetStatusProxy(Connection::IN_PROGRESS));
   EXPECT_CALL(*adapter_, AddObserver(&connection));
-  EXPECT_CALL(connection, ConnectToService(&device_, uuid_, _, _))
-      .WillOnce(SaveArg<2>(&callback));
+  EXPECT_CALL(device_, ConnectToServiceInsecurely(uuid_, _, _))
+      .WillOnce(SaveArg<1>(&callback));
   connection.Connect();
   ASSERT_FALSE(callback.is_null());
 
   EXPECT_CALL(connection, SetStatusProxy(Connection::DISCONNECTED));
   EXPECT_CALL(*adapter_, RemoveObserver(&connection));
   connection.Disconnect();
 
   EXPECT_CALL(connection, SetStatusProxy(_)).Times(0);
   EXPECT_CALL(*socket_, Receive(_, _, _)).Times(0);
   callback.Run(socket_);
@@ skipping 56 matching lines @@
 
   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");
 }
 
 }  // namespace proximity_auth