Create new class "CastTransport", which encapsulates the message read and write event loops.

extensions/browser/api/cast_channel/cast_socket_unittest.cc

Index: extensions/browser/api/cast_channel/cast_socket_unittest.cc
diff --git a/extensions/browser/api/cast_channel/cast_socket_unittest.cc b/extensions/browser/api/cast_channel/cast_socket_unittest.cc
index fefed36841eb4337bd35d540d6c4ad936c5a7c48..27266d0d3074abe777bea0a097b922619660ce2c 100644
--- a/extensions/browser/api/cast_channel/cast_socket_unittest.cc
+++ b/extensions/browser/api/cast_channel/cast_socket_unittest.cc
@@ -74,14 +74,14 @@ static void CreateBinaryMessage(const std::string& namespace_,
       data.c_str(), data.size()));
 }
 
-class MockCastSocketDelegate : public CastSocket::Delegate {
+class MockCastSocketImplDelegate : public CastSocketImpl::Delegate {
  public:
   MOCK_METHOD3(OnError,
-               void(const CastSocket* socket,
+               void(const CastSocketImpl* socket,
                     ChannelError error,
                     const LastErrors& last_errors));
-  MOCK_METHOD2(OnMessage, void(const CastSocket* socket,
-                               const MessageInfo& message));
+  MOCK_METHOD2(OnMessage,
+               void(const CastSocketImpl* socket, const MessageInfo& message));
 };
 
 class MockTCPSocket : public net::TCPClientSocket {
@@ -148,40 +148,42 @@ class CompleteHandler {
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
-class TestCastSocket : public CastSocket {
+class TestCastSocketImpl : public CastSocketImpl {
  public:
-  static scoped_ptr<TestCastSocket> Create(MockCastSocketDelegate* delegate,
-                                           Logger* logger) {
-    return scoped_ptr<TestCastSocket>(new TestCastSocket(delegate,
-                                                         CreateIPEndPoint(),
-                                                         CHANNEL_AUTH_TYPE_SSL,
-                                                         kDistantTimeoutMillis,
-                                                         logger));
+  static scoped_ptr<TestCastSocketImpl> Create(
+      MockCastSocketImplDelegate* delegate,
+      Logger* logger) {
+    return scoped_ptr<TestCastSocketImpl>(
+        new TestCastSocketImpl(delegate,
+                               CreateIPEndPoint(),
+                               CHANNEL_AUTH_TYPE_SSL,
+                               kDistantTimeoutMillis,
+                               logger));
   }
 
-  static scoped_ptr<TestCastSocket> CreateSecure(
-      MockCastSocketDelegate* delegate,
+  static scoped_ptr<TestCastSocketImpl> CreateSecure(
+      MockCastSocketImplDelegate* delegate,
       Logger* logger) {
-    return scoped_ptr<TestCastSocket>(
-        new TestCastSocket(delegate,
-                           CreateIPEndPoint(),
-                           CHANNEL_AUTH_TYPE_SSL_VERIFIED,
-                           kDistantTimeoutMillis,
-                           logger));
+    return scoped_ptr<TestCastSocketImpl>(
+        new TestCastSocketImpl(delegate,
+                               CreateIPEndPoint(),
+                               CHANNEL_AUTH_TYPE_SSL_VERIFIED,
+                               kDistantTimeoutMillis,
+                               logger));
   }
 
-  explicit TestCastSocket(MockCastSocketDelegate* delegate,
-                          const net::IPEndPoint& ip_endpoint,
-                          ChannelAuthType channel_auth,
-                          int64 timeout_ms,
-                          Logger* logger)
-      : CastSocket("abcdefg",
-                   ip_endpoint,
-                   channel_auth,
-                   delegate,
-                   &capturing_net_log_,
-                   base::TimeDelta::FromMilliseconds(timeout_ms),
-                   logger),
+  explicit TestCastSocketImpl(MockCastSocketImplDelegate* delegate,
+                              const net::IPEndPoint& ip_endpoint,
+                              ChannelAuthType channel_auth,
+                              int64 timeout_ms,
+                              Logger* logger)
+      : CastSocketImpl("abcdefg",
+                       ip_endpoint,
+                       channel_auth,
+                       delegate,
+                       &capturing_net_log_,
+                       base::TimeDelta::FromMilliseconds(timeout_ms),
+                       logger),
         ip_(ip_endpoint),
         connect_index_(0),
         extract_cert_result_(true),
@@ -204,8 +206,7 @@ class TestCastSocket : public CastSocket {
     return msg.length() - MessageFramer::MessageHeader::header_size();
   }
 
-  virtual ~TestCastSocket() {
-  }
+  virtual ~TestCastSocketImpl() {}
 
   // Helpers to set mock results for various operations.
   void SetupTcp1Connect(net::IoMode mode, int result) {
@@ -346,13 +347,13 @@ class TestCastSocket : public CastSocket {
   scoped_ptr<base::MockTimer> mock_timer_;
 };
 
-class CastSocketTest : public testing::Test {
+class CastSocketImplTest : public testing::Test {
  public:
-  CastSocketTest()
+  CastSocketImplTest()
       : logger_(new Logger(
             scoped_ptr<base::TickClock>(new base::SimpleTestTickClock),
             base::TimeTicks())) {}
-  virtual ~CastSocketTest() {}
+  virtual ~CastSocketImplTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Create a few test messages
@@ -392,15 +393,15 @@ class CastSocketTest : public testing::Test {
     ASSERT_TRUE(MessageFramer::Serialize(reply_msg, &auth_reply_));
   }
 
-  void CreateCastSocket() {
-    socket_ = TestCastSocket::Create(&mock_delegate_, logger_.get());
+  void CreateCastSocketImpl() {
+    socket_ = TestCastSocketImpl::Create(&mock_delegate_, logger_.get());
   }
 
-  void CreateCastSocketSecure() {
-    socket_ = TestCastSocket::CreateSecure(&mock_delegate_, logger_.get());
+  void CreateCastSocketImplSecure() {
+    socket_ = TestCastSocketImpl::CreateSecure(&mock_delegate_, logger_.get());
   }
 
-  // Sets up CastSocket::Connect to succeed.
+  // Sets up CastSocketImpl::Connect to succeed.
   // Connecting the socket also starts the read loop; so we add a mock
   // read result that returns IO_PENDING and callback is never fired.
   void ConnectHelper() {
@@ -422,9 +423,9 @@ class CastSocketTest : public testing::Test {
   }
 
   base::MessageLoop message_loop_;
-  MockCastSocketDelegate mock_delegate_;
+  MockCastSocketImplDelegate mock_delegate_;
   scoped_refptr<Logger> logger_;
-  scoped_ptr<TestCastSocket> socket_;
+  scoped_ptr<TestCastSocketImpl> socket_;
   CompleteHandler handler_;
   MessageInfo test_messages_[arraysize(kTestData)];
   CastMessage test_protos_[arraysize(kTestData)];
@@ -434,8 +435,8 @@ class CastSocketTest : public testing::Test {
 };
 
 // Tests connecting and closing the socket.
-TEST_F(CastSocketTest, TestConnectAndClose) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnectAndClose) {
+  CreateCastSocketImpl();
   ConnectHelper();
   SetupAuthMessage();
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
@@ -451,8 +452,8 @@ TEST_F(CastSocketTest, TestConnectAndClose) {
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection succeeds (async)
-TEST_F(CastSocketTest, TestConnect) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnect) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::OK);
@@ -473,8 +474,8 @@ TEST_F(CastSocketTest, TestConnect) {
 // - Cert is extracted successfully
 // - Second TCP connection succeeds (async)
 // - Second SSL connection succeeds (async)
-TEST_F(CastSocketTest, TestConnectTwoStep) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnectTwoStep) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
@@ -498,8 +499,8 @@ TEST_F(CastSocketTest, TestConnectTwoStep) {
 // - Second TCP connection succeeds (async)
 // - Second SSL connection fails (async)
 // - The flow should NOT be tried again
-TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnectMaxTwoAttempts) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
@@ -528,8 +529,8 @@ TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) {
 // - Challenge request is sent (async)
 // - Challenge response is received (async)
 // - Credentials are verified successfuly
-TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectFullSecureFlowAsync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
@@ -550,8 +551,8 @@ TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
 }
 
 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous.
-TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectFullSecureFlowSync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -573,8 +574,8 @@ TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
 
 // Test that an AuthMessage with a mangled namespace triggers cancelation
 // of the connection event loop.
-TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectAuthMessageCorrupted) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage("bogus_namespace");
 
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
@@ -601,8 +602,8 @@ TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) {
 }
 
 // Test connection error - TCP connect fails (async)
-TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectTcpConnectErrorAsync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::ASYNC, net::ERR_FAILED);
@@ -621,8 +622,8 @@ TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
 }
 
 // Test connection error - TCP connect fails (sync)
-TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectTcpConnectErrorSync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
@@ -641,8 +642,8 @@ TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
 }
 
 // Test connection error - timeout
-TEST_F(CastSocketTest, TestConnectTcpTimeoutError) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectTcpTimeoutError) {
+  CreateCastSocketImplSecure();
   socket_->SetupTcp1ConnectUnresponsive();
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
@@ -664,8 +665,8 @@ TEST_F(CastSocketTest, TestConnectTcpTimeoutError) {
 }
 
 // Test connection error - SSL connect fails (async)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectSslConnectErrorAsync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -685,8 +686,8 @@ TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
 }
 
 // Test connection error - SSL connect fails (sync)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectSslConnectErrorSync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -706,8 +707,8 @@ TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
 }
 
 // Test connection error - cert extraction error (async)
-TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnectCertExtractionErrorAsync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
@@ -728,8 +729,8 @@ TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
 }
 
 // Test connection error - cert extraction error (sync)
-TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestConnectCertExtractionErrorSync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
@@ -750,8 +751,8 @@ TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
 }
 
 // Test connection error - challenge send fails
-TEST_F(CastSocketTest, TestConnectChallengeSendError) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeSendError) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -772,8 +773,8 @@ TEST_F(CastSocketTest, TestConnectChallengeSendError) {
 }
 
 // Test connection error - challenge reply receive fails
-TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeReplyReceiveError) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -795,8 +796,8 @@ TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
 }
 
 // Test connection error - challenge reply verification fails
-TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeVerificationFails) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
@@ -820,8 +821,8 @@ TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
 }
 
 // Test write success - single message (async)
-TEST_F(CastSocketTest, TestWriteAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteAsync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0]);
   ConnectHelper();
   SetupAuthMessage();
@@ -837,8 +838,8 @@ TEST_F(CastSocketTest, TestWriteAsync) {
 }
 
 // Test write success - single message (sync)
-TEST_F(CastSocketTest, TestWriteSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteSync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
   ConnectHelper();
   SetupAuthMessage();
@@ -854,8 +855,8 @@ TEST_F(CastSocketTest, TestWriteSync) {
 }
 
 // Test write success - single message sent in multiple chunks (async)
-TEST_F(CastSocketTest, TestWriteChunkedAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteChunkedAsync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
   ConnectHelper();
   SetupAuthMessage();
@@ -871,8 +872,8 @@ TEST_F(CastSocketTest, TestWriteChunkedAsync) {
 }
 
 // Test write success - single message sent in multiple chunks (sync)
-TEST_F(CastSocketTest, TestWriteChunkedSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteChunkedSync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
   ConnectHelper();
   SetupAuthMessage();
@@ -888,8 +889,8 @@ TEST_F(CastSocketTest, TestWriteChunkedSync) {
 }
 
 // Test write success - multiple messages (async)
-TEST_F(CastSocketTest, TestWriteManyAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteManyAsync) {
+  CreateCastSocketImpl();
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     size_t msg_size = test_proto_strs_[i].size();
     socket_->AddWriteResult(net::ASYNC, msg_size);
@@ -910,8 +911,8 @@ TEST_F(CastSocketTest, TestWriteManyAsync) {
 }
 
 // Test write success - multiple messages (sync)
-TEST_F(CastSocketTest, TestWriteManySync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteManySync) {
+  CreateCastSocketImpl();
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     size_t msg_size = test_proto_strs_[i].size();
     socket_->AddWriteResult(net::SYNCHRONOUS, msg_size);
@@ -932,8 +933,8 @@ TEST_F(CastSocketTest, TestWriteManySync) {
 }
 
 // Test write error - not connected
-TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorNotConnected) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
@@ -946,8 +947,8 @@ TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
 }
 
 // Test write error - very large message
-TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorLargeMessage) {
+  CreateCastSocketImpl();
   ConnectHelper();
   SetupAuthMessage();
 
@@ -964,8 +965,8 @@ TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
 }
 
 // Test write error - network error (sync)
-TEST_F(CastSocketTest, TestWriteNetworkErrorSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteNetworkErrorSync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
   ConnectHelper();
   SetupAuthMessage();
@@ -985,8 +986,8 @@ TEST_F(CastSocketTest, TestWriteNetworkErrorSync) {
 }
 
 // Test write error - network error (async)
-TEST_F(CastSocketTest, TestWriteErrorAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorAsync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResult(net::ASYNC, net::ERR_FAILED);
   ConnectHelper();
   SetupAuthMessage();
@@ -1006,8 +1007,8 @@ TEST_F(CastSocketTest, TestWriteErrorAsync) {
 }
 
 // Test write error - 0 bytes written should be considered an error
-TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorZeroBytesWritten) {
+  CreateCastSocketImpl();
   socket_->AddWriteResult(net::SYNCHRONOUS, 0);
   ConnectHelper();
   SetupAuthMessage();
@@ -1028,8 +1029,8 @@ TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) {
 
 // Test that when an error occurrs in one write, write callback is invoked for
 // all pending writes with the error
-TEST_F(CastSocketTest, TestWriteErrorWithMultiplePendingWritesAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorWithMultiplePendingWritesAsync) {
+  CreateCastSocketImpl();
   socket_->AddWriteResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
   ConnectHelper();
   SetupAuthMessage();
@@ -1053,8 +1054,8 @@ TEST_F(CastSocketTest, TestWriteErrorWithMultiplePendingWritesAsync) {
 }
 
 // Test read success - single message (async)
-TEST_F(CastSocketTest, TestReadAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadAsync) {
+  CreateCastSocketImpl();
   socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
@@ -1066,8 +1067,8 @@ TEST_F(CastSocketTest, TestReadAsync) {
 }
 
 // Test read success - single message (sync)
-TEST_F(CastSocketTest, TestReadSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadSync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
   EXPECT_CALL(mock_delegate_,
@@ -1079,8 +1080,8 @@ TEST_F(CastSocketTest, TestReadSync) {
 }
 
 // Test read success - single message received in multiple chunks (async)
-TEST_F(CastSocketTest, TestReadChunkedAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadChunkedAsync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
   EXPECT_CALL(mock_delegate_,
@@ -1092,8 +1093,8 @@ TEST_F(CastSocketTest, TestReadChunkedAsync) {
 }
 
 // Test read success - single message received in multiple chunks (sync)
-TEST_F(CastSocketTest, TestReadChunkedSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadChunkedSync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
   EXPECT_CALL(mock_delegate_,
@@ -1105,8 +1106,8 @@ TEST_F(CastSocketTest, TestReadChunkedSync) {
 }
 
 // Test read success - multiple messages (async)
-TEST_F(CastSocketTest, TestReadManyAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadManyAsync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   size_t num_reads = arraysize(test_proto_strs_);
   for (size_t i = 0; i < num_reads; i++)
@@ -1121,8 +1122,8 @@ TEST_F(CastSocketTest, TestReadManyAsync) {
 }
 
 // Test read success - multiple messages (sync)
-TEST_F(CastSocketTest, TestReadManySync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadManySync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   size_t num_reads = arraysize(test_proto_strs_);
   for (size_t i = 0; i < num_reads; i++)
@@ -1137,8 +1138,8 @@ TEST_F(CastSocketTest, TestReadManySync) {
 }
 
 // Test read error - network error (async)
-TEST_F(CastSocketTest, TestReadErrorAsync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadErrorAsync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->AddReadResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
   EXPECT_CALL(mock_delegate_,
@@ -1152,8 +1153,8 @@ TEST_F(CastSocketTest, TestReadErrorAsync) {
 }
 
 // Test read error - network error (sync)
-TEST_F(CastSocketTest, TestReadErrorSync) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadErrorSync) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_SOCKET_NOT_CONNECTED);
   EXPECT_CALL(mock_delegate_,
@@ -1167,8 +1168,8 @@ TEST_F(CastSocketTest, TestReadErrorSync) {
 }
 
 // Test read error - header parse error
-TEST_F(CastSocketTest, TestReadHeaderParseError) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadHeaderParseError) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
 
   uint32 body_size =
@@ -1189,8 +1190,8 @@ TEST_F(CastSocketTest, TestReadHeaderParseError) {
 }
 
 // Test read error - body parse error
-TEST_F(CastSocketTest, TestReadBodyParseError) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadBodyParseError) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
   char body[] = "some body";
   uint32 body_size = base::HostToNet32(arraysize(body));