Decouple Blimp transport output from BlimpConnections using MessagePort.

blimp/net/engine_connection_manager_unittest.cc

Index: blimp/net/engine_connection_manager_unittest.cc
diff --git a/blimp/net/engine_connection_manager_unittest.cc b/blimp/net/engine_connection_manager_unittest.cc
index d178bb734bfc7a66d4906212d96e79fc789ad548..bd67c77e0471143fadc00f9ee4089b05bfcb2864 100644
--- a/blimp/net/engine_connection_manager_unittest.cc
+++ b/blimp/net/engine_connection_manager_unittest.cc
@@ -7,6 +7,7 @@
 #include <stddef.h>
 
 #include <string>
+#include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
@@ -39,40 +40,43 @@ class EngineConnectionManagerTest : public testing::Test {
   ~EngineConnectionManagerTest() override {}
 
   std::unique_ptr<BlimpConnection> CreateConnection() {
-    return base::WrapUnique(
-        new BlimpConnection(base::WrapUnique(new MockPacketReader),
-                            base::WrapUnique(new MockPacketWriter)));
+    return base::MakeUnique<BlimpConnection>(
+        base::MakeUnique<MessagePort>(base::MakeUnique<MockPacketReader>(),
+                                      base::MakeUnique<MockPacketWriter>()));
   }
 
  protected:
-  base::MessageLoopForIO message_loop_;
   testing::StrictMock<MockConnectionHandler> connection_handler_;
   std::unique_ptr<EngineConnectionManager> manager_;
 };
 
 TEST_F(EngineConnectionManagerTest, ConnectionSucceeds) {
   std::unique_ptr<testing::StrictMock<MockTransport>> transport1(
-      new testing::StrictMock<MockTransport>);
+      new testing::StrictMock<MockTransport>());
   std::unique_ptr<testing::StrictMock<MockTransport>> transport2(
-      new testing::StrictMock<MockTransport>);
+      new testing::StrictMock<MockTransport>());
 
-  std::unique_ptr<BlimpConnection> connection1 = CreateConnection();
   net::CompletionCallback connect_cb_1;
+  net::CompletionCallback connect_cb_2;
   EXPECT_CALL(*transport1, Connect(_))
       .Times(2)
       .WillRepeatedly(SaveArg<0>(&connect_cb_1));
-  EXPECT_CALL(connection_handler_, HandleConnectionPtr(Eq(connection1.get())));
-  EXPECT_CALL(*transport1, TakeConnectionPtr())
-      .WillOnce(Return(connection1.release()));
-
-  std::unique_ptr<BlimpConnection> connection2 = CreateConnection();
-  net::CompletionCallback connect_cb_2;
   EXPECT_CALL(*transport2, Connect(_))
       .Times(2)
       .WillRepeatedly(SaveArg<0>(&connect_cb_2));
-  EXPECT_CALL(connection_handler_, HandleConnectionPtr(Eq(connection2.get())));
-  EXPECT_CALL(*transport2, TakeConnectionPtr())
-      .WillOnce(Return(connection2.release()));
+
+  std::unique_ptr<MessagePort> port1 =
+      base::MakeUnique<MessagePort>(base::MakeUnique<MockPacketReader>(),
+                                    base::MakeUnique<MockPacketWriter>());
+  std::unique_ptr<MessagePort> port2 =
+      base::MakeUnique<MessagePort>(base::MakeUnique<MockPacketReader>(),
+                                    base::MakeUnique<MockPacketWriter>());
+  EXPECT_CALL(connection_handler_, HandleConnectionPtr(_)).Times(2);
+
+  EXPECT_CALL(*transport1, TakeMessagePortPtr())
+      .WillOnce(Return(port1.release()));
+  EXPECT_CALL(*transport2, TakeMessagePortPtr())
+      .WillOnce(Return(port2.release()));
 
   ASSERT_TRUE(connect_cb_1.is_null());
   manager_->AddTransport(std::move(transport1));