Refactor fake Connection subclasses in proximity_auth/ tests to a single file.

components/proximity_auth/messenger_impl_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/messenger_impl.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/proximity_auth/connection.h"
+#include "components/proximity_auth/fake_connection.h"
 #include "components/proximity_auth/messenger_observer.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/remote_status_update.h"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/wire_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AllOf;
@@ skipping 34 matching lines @@
     EXPECT_THAT(encoded_message, EndsWith(kFakeEncodingSuffix));
     std::string decoded_message = encoded_message;
     decoded_message.erase(decoded_message.rfind(kFakeEncodingSuffix));
     callback.Run(decoded_message);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSecureContext);
 };
 
-class FakeConnection : public Connection {
- public:
-  FakeConnection() : Connection(RemoteDevice()) { Connect(); }
-  ~FakeConnection() override { Disconnect(); }
-
-  void Connect() override { SetStatus(CONNECTED); }
-
-  void Disconnect() override { SetStatus(DISCONNECTED); }
-
-  void SendMessageImpl(scoped_ptr<WireMessage> message) override {
-    ASSERT_FALSE(current_message_);
-    current_message_ = message.Pass();
-  }
-
-  // Completes the current send operation with success |success|.
-  void FinishSendingMessageWithSuccess(bool success) {
-    ASSERT_TRUE(current_message_);
-    // Capture a copy of the message, as OnDidSendMessage() might reentrantly
-    // call SendMessage().
-    scoped_ptr<WireMessage> sent_message = current_message_.Pass();
-    OnDidSendMessage(*sent_message, success);
-  }
-
-  // Simulates receiving a wire message with the given |payload|.
-  void ReceiveMessageWithPayload(const std::string& payload) {
-    pending_payload_ = payload;
-    OnBytesReceived(std::string());
-    pending_payload_.clear();
-  }
-
-  // Returns a message containing the payload set via
-  // ReceiveMessageWithPayload().
-  scoped_ptr<WireMessage> DeserializeWireMessage(
-      bool* is_incomplete_message) override {
-    *is_incomplete_message = false;
-    return make_scoped_ptr(new WireMessage(pending_payload_));
-  }
-
-  WireMessage* current_message() { return current_message_.get(); }
-
- private:
-  // The message currently being sent. Only set between a call to
-  // SendMessageImpl() and FinishSendingMessageWithSuccess().
-  scoped_ptr<WireMessage> current_message_;
-
-  // The payload that should be returned when DeserializeWireMessage() is
-  // called.
-  std::string pending_payload_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeConnection);
-};
-
 class MockMessengerObserver : public MessengerObserver {
  public:
   explicit MockMessengerObserver(Messenger* messenger) : messenger_(messenger) {
     messenger_->AddObserver(this);
   }
   virtual ~MockMessengerObserver() { messenger_->RemoveObserver(this); }
 
   MOCK_METHOD1(OnUnlockEventSent, void(bool success));
   MOCK_METHOD1(OnRemoteStatusUpdate,
                void(const RemoteStatusUpdate& status_update));
   MOCK_METHOD1(OnDecryptResponseProxy,
                void(const std::string* decrypted_bytes));
   MOCK_METHOD1(OnUnlockResponse, void(bool success));
   MOCK_METHOD0(OnDisconnected, void());
 
   virtual void OnDecryptResponse(scoped_ptr<std::string> decrypted_bytes) {
     OnDecryptResponseProxy(decrypted_bytes.get());
   }
 
  private:
   // The messenger that |this| instance observes.
   Messenger* const messenger_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMessengerObserver);
 };
 
 class TestMessenger : public MessengerImpl {
  public:
   TestMessenger()
-      : MessengerImpl(make_scoped_ptr(new NiceMock<FakeConnection>()),
+      : MessengerImpl(make_scoped_ptr(new FakeConnection(RemoteDevice())),
                       make_scoped_ptr(new NiceMock<MockSecureContext>())) {}
   ~TestMessenger() override {}
 
   // Simple getters for the mock objects owned by |this| messenger.
   FakeConnection* GetFakeConnection() {
     return static_cast<FakeConnection*>(connection());
   }
   MockSecureContext* GetMockSecureContext() {
     return static_cast<MockSecureContext*>(secure_context());
   }
@@ skipping 354 matching lines @@
       "\"data\":\"YSB3aW5uZXIgaXMgeW91\""
       "}, but encoded");
 
   // The unlock request should have remained buffered, and should only now be
   // sent.
   EXPECT_CALL(observer, OnUnlockResponse(false));
   messenger.GetFakeConnection()->FinishSendingMessageWithSuccess(false);
 }
 
 }  // namespace proximity_auth