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

extensions/browser/api/cast_channel/cast_socket_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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 56 matching lines @@
                                 const std::string& destination_id,
                                 const std::string& data,
                                 MessageInfo* message) {
   message->namespace_ = namespace_;
   message->source_id = source_id;
   message->destination_id = destination_id;
   message->data.reset(base::BinaryValue::CreateWithCopiedBuffer(
       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 {
  public:
   explicit MockTCPSocket(const net::MockConnect& connect_data) :
       TCPClientSocket(net::AddressList(), NULL, net::NetLog::Source()),
       connect_data_(connect_data),
       do_nothing_(false) { }
 
   explicit MockTCPSocket(bool do_nothing) :
@@ skipping 46 matching lines @@
 class CompleteHandler {
  public:
   CompleteHandler() {}
   MOCK_METHOD1(OnCloseComplete, void(int result));
   MOCK_METHOD1(OnConnectComplete, void(int result));
   MOCK_METHOD1(OnWriteComplete, void(int result));
  private:
   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),
         verify_challenge_result_(true),
         verify_challenge_disallow_(false),
         tcp_unresponsive_(false),
         mock_timer_(new base::MockTimer(false, false)) {}
 
   static net::IPEndPoint CreateIPEndPoint() {
     net::IPAddressNumber number;
     number.push_back(192);
     number.push_back(0);
     number.push_back(0);
     number.push_back(1);
     return net::IPEndPoint(number, 8009);
   }
 
   // Returns the size of the body (in bytes) of the given serialized message.
   static size_t ComputeBodySize(const std::string& msg) {
     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) {
     tcp_connect_data_[0].reset(new net::MockConnect(mode, result));
   }
   void SetupSsl1Connect(net::IoMode mode, int result) {
     ssl_connect_data_[0].reset(new net::MockConnect(mode, result));
   }
   void SetupTcp2Connect(net::IoMode mode, int result) {
     tcp_connect_data_[1].reset(new net::MockConnect(mode, result));
@@ skipping 120 matching lines @@
   // Simulated result of peer cert extraction.
   bool extract_cert_result_;
   // Simulated result of verifying challenge reply.
   bool verify_challenge_result_;
   bool verify_challenge_disallow_;
   // If true, makes TCP connection process stall. For timeout testing.
   bool tcp_unresponsive_;
   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
     for (size_t i = 0; i < arraysize(test_messages_); i++) {
       CreateStringMessage("urn:cast", "1", "2", kTestData[i],
                           &test_messages_[i]);
       ASSERT_TRUE(MessageInfoToCastMessage(
           test_messages_[i], &test_protos_[i]));
       ASSERT_TRUE(
           MessageFramer::Serialize(test_protos_[i], &test_proto_strs_[i]));
@@ skipping 19 matching lines @@
 
     // Create a test auth reply.
     MessageInfo reply;
     CreateBinaryMessage(
         auth_namespace, "sender-0", "receiver-0", "abcd", &reply);
     CastMessage reply_msg;
     ASSERT_TRUE(MessageInfoToCastMessage(reply, &reply_msg));
     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() {
     socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
     socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
     socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
     EXPECT_CALL(handler_, OnConnectComplete(net::OK));
     socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                                 base::Unretained(&handler_)));
     RunPendingTasks();
   }
 
  protected:
   // Runs all pending tasks in the message loop.
   void RunPendingTasks() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   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)];
   std::string test_proto_strs_[arraysize(kTestData)];
   std::string auth_request_;
   std::string auth_reply_;
 };
 
 // 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());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 
   EXPECT_CALL(handler_, OnCloseComplete(net::OK));
   socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                             base::Unretained(&handler_)));
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - 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);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
   socket_->SetupSsl2Connect(net::ASYNC, net::OK);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - Cert is extracted successfully
 // - 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);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
   socket_->SetupSsl2Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - Cert is extracted successfully
 // - Second TCP connection succeeds (async)
 // - Second SSL connection succeeds (async)
 // - 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);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
   socket_->SetupSsl2Connect(net::ASYNC, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous.
-TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectFullSecureFlowSync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
   socket_->SetupTcp2Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl2Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, auth_request_);
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
   socket_->SetupSsl2Connect(net::ASYNC, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
   // Guard against VerifyChallengeResult() being triggered.
   socket_->DisallowVerifyChallengeResult();
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CONNECTING, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
   socket_->TriggerTimeout();
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
             socket_->error_state());
 }
 
 // Test connection error - SSL connect fails (async)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectSslConnectErrorAsync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - SSL connect fails (sync)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectSslConnectErrorSync) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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);
   // Set cert extraction to fail
   socket_->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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);
   // Set cert extraction to fail
   socket_->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - challenge send fails
-TEST_F(CastSocketTest, TestConnectChallengeSendError) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeSendError) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - challenge reply receive fails
-TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeReplyReceiveError) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - challenge reply verification fails
-TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
-  CreateCastSocketSecure();
+TEST_F(CastSocketImplTest, TestConnectChallengeVerificationFails) {
+  CreateCastSocketImplSecure();
   SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
   socket_->SetVerifyChallengeResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CONNECTION_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR,
                       A<const LastErrors&>()));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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);
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
   SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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);
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
   SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write error - not connected
-TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorNotConnected) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
 
   EXPECT_EQ(cast_channel::READY_STATE_NONE, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write error - very large message
-TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestWriteErrorLargeMessage) {
+  CreateCastSocketImpl();
   ConnectHelper();
   SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   size_t size = MessageFramer::MessageHeader::max_message_size() + 1;
   test_messages_[0].data.reset(
       new base::StringValue(std::string(size, 'a')));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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();
 
   const int num_writes = arraysize(test_messages_);
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED))
       .Times(num_writes);
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   for (int i = 0; i < num_writes; i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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&>()));
   ConnectHelper();
   SetupAuthMessage();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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++)
     socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[i]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()))
       .Times(num_reads);
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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++)
     socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[i]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()))
       .Times(num_reads);
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR,
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test read error - header parse error
-TEST_F(CastSocketTest, TestReadHeaderParseError) {
-  CreateCastSocket();
+TEST_F(CastSocketImplTest, TestReadHeaderParseError) {
+  CreateCastSocketImpl();
   SetupAuthMessage();
 
   uint32 body_size =
       base::HostToNet32(MessageFramer::MessageHeader::max_message_size() + 1);
   // TODO(munjal): Add a method to cast_message_util.h to serialize messages
   char header[sizeof(body_size)];
   memcpy(&header, &body_size, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 
 // 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));
   char header[sizeof(body_size)];
   memcpy(&header, &body_size, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, body, arraysize(body));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
                       A<const LastErrors&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions