Add RemoteDeviceLoader to create RemoteDevice from CryptAuth data.

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/proximity_auth_test_util.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 "device/bluetooth/test/mock_bluetooth_socket.h"
 #include "net/base/io_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::NiceMock;
 using testing::Ref;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
 namespace proximity_auth {
 namespace {
 
-const char kDeviceName[] = "Device name";
 const char kOtherDeviceName[] = "Other device name";
-
-const char kBluetoothAddress[] = "11:22:33:44:55:66";
-const char kOtherBluetoothAddress[] = "AA:BB:CC:DD:EE:FF";
-
-const char kPublicKey[] = "Public key";
-const char kPersistentSymmetricKey[] = "PSK";
+const char kOtherBluetoothAddress[] = "FF:BB:CC:DD:EE:FF";
 
 const char kSerializedMessage[] = "Yarrr, this be a serialized message. Yarr!";
 const int kSerializedMessageLength = strlen(kSerializedMessage);
 
 const char kUuid[] = "DEADBEEF-CAFE-FEED-FOOD-D15EA5EBEEF";
 
 const int kReceiveBufferSize = 6;
 const char kReceiveBufferContents[] = "bytes";
 
 // Create a buffer for testing received data.
 scoped_refptr<net::IOBuffer> CreateReceiveBuffer() {
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kReceiveBufferSize);
   memcpy(buffer->data(), kReceiveBufferContents, kReceiveBufferSize);
   return buffer;
 }
 
 class MockBluetoothConnection : public BluetoothConnection {
  public:
   MockBluetoothConnection()
-      : BluetoothConnection(CreateRemoteDevice(),
+      : BluetoothConnection(CreateClassicRemoteDeviceForTest(),
                             device::BluetoothUUID(kUuid)) {}
 
   // 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));
 
   void SetStatus(Status status) override {
     SetStatusProxy(status);
     BluetoothConnection::SetStatus(status);
   }
 
   using BluetoothConnection::status;
   using BluetoothConnection::Connect;
   using BluetoothConnection::DeviceRemoved;
   using BluetoothConnection::Disconnect;
 
  private:
-  RemoteDevice CreateRemoteDevice() {
-    return RemoteDevice(kDeviceName, kPublicKey, kBluetoothAddress,
-                        kPersistentSymmetricKey);
-  }
-
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothConnection);
 };
 
 class TestWireMessage : public WireMessage {
  public:
   TestWireMessage() : WireMessage("permit id", "payload") {}
   ~TestWireMessage() override {}
 
   std::string Serialize() const override { return kSerializedMessage; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestWireMessage);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothConnectionTest : public testing::Test {
  public:
   ProximityAuthBluetoothConnectionTest()
       : adapter_(new device::MockBluetoothAdapter),
-        device_(adapter_.get(), 0, kDeviceName, kBluetoothAddress, true, true),
+        device_(adapter_.get(),
+                0,
+                kTestRemoteDeviceName,
+                kTestRemoteDeviceBluetoothAddress,
+                true,
+                true),
         socket_(new StrictMock<device::MockBluetoothSocket>),
         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) {
@@ skipping 334 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