[Cast Channel] Add real SSL tests to CastSocketTest

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 <stdint.h>
 
 #include <utility>
 #include <vector>
 
+#include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/mock_timer.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "crypto/rsa_private_key.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_test_util.h"
 #include "extensions/browser/api/cast_channel/cast_transport.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
+#include "net/cert/pem_tokenizer.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
+#include "net/socket/ssl_server_socket.h"
 #include "net/socket/tcp_client_socket.h"
+#include "net/socket/tcp_server_socket.h"
 #include "net/ssl/ssl_info.h"
+#include "net/ssl/ssl_server_config.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int64_t kDistantTimeoutMillis = 100000;  // 100 seconds (never hit).
 
 using ::testing::_;
 using ::testing::A;
 using ::testing::DoAll;
@@ skipping 116 matching lines @@
   CompleteHandler() {}
   MOCK_METHOD1(OnCloseComplete, void(int result));
   MOCK_METHOD1(OnConnectComplete, void(ChannelError error_state));
   MOCK_METHOD1(OnWriteComplete, void(int result));
   MOCK_METHOD1(OnReadComplete, void(int result));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
-class TestCastSocket : public CastSocketImpl {
+class TestCastSocketBase : public CastSocketImpl {
  public:
-  static std::unique_ptr<TestCastSocket> Create(
-      Logger* logger,
-      uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
-    return std::unique_ptr<TestCastSocket>(
-        new TestCastSocket(CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL,
-                           kDistantTimeoutMillis, logger, device_capabilities));
-  }
+  TestCastSocketBase(const net::IPEndPoint& ip_endpoint,
+                     ChannelAuthType channel_auth,
+                     int64_t timeout_ms,
+                     Logger* logger,
+                     uint64_t device_capabilities)
+      : TestCastSocketBase(ip_endpoint,
+                           channel_auth,
+                           timeout_ms,
+                           logger,
+                           new net::TestNetLog(),
+                           device_capabilities) {}
 
-  static std::unique_ptr<TestCastSocket> CreateSecure(
-      Logger* logger,
-      uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
-    return std::unique_ptr<TestCastSocket>(new TestCastSocket(
-        CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
-        kDistantTimeoutMillis, logger, device_capabilities));
-  }
-
-  TestCastSocket(const net::IPEndPoint& ip_endpoint,
-                 ChannelAuthType channel_auth,
-                 int64_t timeout_ms,
-                 Logger* logger,
-                 uint64_t device_capabilities)
-      : TestCastSocket(ip_endpoint,
-                       channel_auth,
-                       timeout_ms,
-                       logger,
-                       new net::TestNetLog(),
-                       device_capabilities) {}
-
-  TestCastSocket(const net::IPEndPoint& ip_endpoint,
-                 ChannelAuthType channel_auth,
-                 int64_t timeout_ms,
-                 Logger* logger,
-                 net::TestNetLog* capturing_net_log,
-                 uint64_t device_capabilities)
+  TestCastSocketBase(const net::IPEndPoint& ip_endpoint,
+                     ChannelAuthType channel_auth,
+                     int64_t timeout_ms,
+                     Logger* logger,
+                     net::TestNetLog* capturing_net_log,
+                     uint64_t device_capabilities)
       : CastSocketImpl("some_extension_id",
                        ip_endpoint,
                        channel_auth,
                        capturing_net_log,
                        base::TimeDelta::FromMilliseconds(timeout_ms),
                        false,
                        logger,
                        device_capabilities),
         capturing_net_log_(capturing_net_log),
         ip_(ip_endpoint),
         extract_cert_result_(true),
         verify_challenge_result_(true),
         verify_challenge_disallow_(false),
+        mock_timer_(new base::MockTimer(false, false)) {}
+
+  ~TestCastSocketBase() override {}
+
+  void SetExtractCertResult(bool value) { extract_cert_result_ = value; }

[mark a. foltz, 2016/07/28 00:10:01]

s/value/extract_result/

[btolsch, 2016/08/11 22:31:33]

Done.

+
+  void SetVerifyChallengeResult(bool value) {

[mark a. foltz, 2016/07/28 00:10:01]

s/value/verify_challenge/

[btolsch, 2016/08/11 22:31:33]

Done.

+    verify_challenge_result_ = value;
+  }
+
+  void TriggerTimeout() { mock_timer_->Fire(); }
+
+  bool TestVerifyChannelPolicyNone() {

[mark a. foltz, 2016/07/28 00:10:01]

nit: This isn't actually "testing" in the sense there aren't ASSERT or EXPECT
statments.  Instead, maybe just HasChannelPolicyNone().

[btolsch, 2016/08/11 22:31:33]

Done.

+    AuthResult authResult;
+    return VerifyChannelPolicy(authResult);
+  }
+
+  bool TestVerifyChannelPolicyAudioOnly() {

[mark a. foltz, 2016/07/28 00:10:01]

HasChannelPolicyAudioOnly()

[btolsch, 2016/08/11 22:31:33]

Done.

+    AuthResult authResult;
+    authResult.channel_policies |= AuthResult::POLICY_AUDIO_ONLY;
+    return VerifyChannelPolicy(authResult);
+  }
+
+  void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }

[mark a. foltz, 2016/07/28 00:10:01]

Why not SetDisallowVerifyChallengeResult like the other flags here?

[btolsch, 2016/08/11 22:31:33]

Copied from original class, and this is actually dead because there is a
SetVerifyChallengeResult().  Removed this.

+
+ protected:
+  scoped_refptr<net::X509Certificate> ExtractPeerCert() override {
+    return extract_cert_result_
+               ? net::ImportCertFromFile(net::GetTestCertsDirectory(),

[mark a. foltz, 2016/07/28 00:10:01]

Can net::ImportCertFromFile return an error?  Should the result be tested with
an ASSERT to fail fast?

[btolsch, 2016/08/11 22:31:33]

Done but with EXPECT, can't use ASSERT in functions that return a value.

+                                         "ok_cert.pem")
+               : nullptr;
+  }
+
+  bool VerifyChallengeReply() override {
+    EXPECT_FALSE(verify_challenge_disallow_);

[mark a. foltz, 2016/07/28 00:10:01]

But this flag is set by the the test fixture, not the socket being tested.
Do you mean ASSERT_FALSE()?

[btolsch, 2016/08/11 22:31:33]

ASSERT_* can't be used in functions that return a value.

+    return verify_challenge_result_;
+  }
+
+  base::Timer* GetTimer() override { return mock_timer_.get(); }
+
+  std::unique_ptr<net::TestNetLog> capturing_net_log_;
+  net::IPEndPoint ip_;
+  // Simulated result of peer cert extraction.
+  bool extract_cert_result_;
+  // Simulated result of verifying challenge reply.
+  bool verify_challenge_result_;
+  bool verify_challenge_disallow_;
+  std::unique_ptr<base::MockTimer> mock_timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCastSocketBase);
+};
+
+class MockTestCastSocket : public TestCastSocketBase {
+ public:
+  static std::unique_ptr<MockTestCastSocket> Create(
+      Logger* logger,
+      uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
+    return std::unique_ptr<MockTestCastSocket>(new MockTestCastSocket(
+        CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL, kDistantTimeoutMillis,

[mark a. foltz, 2016/07/28 00:10:01]

I wonder if anyone actually uses CHANNEL_AUTH_TYPE_SSL.  If not, it would be a
good cleanup to remove it.

[mark a. foltz, 2016/07/28 00:11:49]

Note, I was thinking this would be a separate patch as there is a lot of code in
other files that would be deleted.

[btolsch, 2016/08/11 22:31:33]

Acknowledged.

[btolsch, 2016/08/11 22:31:33]

It looks like there are no legitimate uses so a follow-up to this could remove
it.

+        logger, device_capabilities));
+  }
+
+  static std::unique_ptr<MockTestCastSocket> CreateSecure(
+      Logger* logger,
+      uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
+    return std::unique_ptr<MockTestCastSocket>(new MockTestCastSocket(
+        CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
+        kDistantTimeoutMillis, logger, device_capabilities));
+  }
+
+  MockTestCastSocket(const net::IPEndPoint& ip_endpoint,
+                     ChannelAuthType channel_auth,
+                     int64_t timeout_ms,
+                     Logger* logger,
+                     uint64_t device_capabilities)
+      : MockTestCastSocket(ip_endpoint,
+                           channel_auth,
+                           timeout_ms,
+                           logger,
+                           new net::TestNetLog(),
+                           device_capabilities) {}
+
+  MockTestCastSocket(const net::IPEndPoint& ip_endpoint,
+                     ChannelAuthType channel_auth,
+                     int64_t timeout_ms,
+                     Logger* logger,
+                     net::TestNetLog* capturing_net_log,
+                     uint64_t device_capabilities)
+      : TestCastSocketBase(ip_endpoint,
+                           channel_auth,
+                           timeout_ms,
+                           logger,
+                           capturing_net_log,
+                           device_capabilities),
         tcp_unresponsive_(false),
-        mock_timer_(new base::MockTimer(false, false)),
         mock_transport_(nullptr) {}
 
-  ~TestCastSocket() override {}
-
   void SetupMockTransport() {
     mock_transport_ = new MockCastTransport;
     SetTransportForTesting(base::WrapUnique(mock_transport_));
   }
 
   // Socket connection helpers.
   void SetupTcpConnect(net::IoMode mode, int result) {
     tcp_connect_data_.reset(new net::MockConnect(mode, result));
   }
   void SetupSslConnect(net::IoMode mode, int result) {
@@ skipping 16 matching lines @@
   void AddReadResult(net::IoMode mode, int result) {
     AddReadResult(net::MockRead(mode, result));
   }
   void AddReadResultForData(net::IoMode mode, const std::string& data) {
     AddReadResult(net::MockRead(mode, data.c_str(), data.size()));
   }
 
   // Helpers for modifying other connection-related behaviors.
   void SetupTcpConnectUnresponsive() { tcp_unresponsive_ = true; }
 
-  void SetExtractCertResult(bool value) {
-    extract_cert_result_ = value;
-  }
-
-  void SetVerifyChallengeResult(bool value) {
-    verify_challenge_result_ = value;
-  }
-
-  void TriggerTimeout() {
-    mock_timer_->Fire();
-  }
-
-  bool TestVerifyChannelPolicyNone() {
-    AuthResult authResult;
-    return VerifyChannelPolicy(authResult);
-  }
-
-  bool TestVerifyChannelPolicyAudioOnly() {
-    AuthResult authResult;
-    authResult.channel_policies |= AuthResult::POLICY_AUDIO_ONLY;
-    return VerifyChannelPolicy(authResult);
-  }
-
-  void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }
-
   MockCastTransport* GetMockTransport() {
     CHECK(mock_transport_);
     return mock_transport_;
   }
 
  private:
   std::unique_ptr<net::TCPClientSocket> CreateTcpSocket() override {
     if (tcp_unresponsive_) {
       return std::unique_ptr<net::TCPClientSocket>(new MockTCPSocket(true));
     } else {
@@ skipping 10 matching lines @@
     connect_data->peer_addr = ip_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
     return std::unique_ptr<net::SSLClientSocket>(new net::MockTCPClientSocket(
         net::AddressList(), capturing_net_log_.get(), ssl_data_.get()));
   }
 
-  scoped_refptr<net::X509Certificate> ExtractPeerCert() override {
-    return extract_cert_result_
-               ? net::ImportCertFromFile(net::GetTestCertsDirectory(),
-                                         "ok_cert.pem")
-               : nullptr;
-  }
-
-  bool VerifyChallengeReply() override {
-    EXPECT_FALSE(verify_challenge_disallow_);
-    return verify_challenge_result_;
-  }
-
-  base::Timer* GetTimer() override { return mock_timer_.get(); }
-
-  std::unique_ptr<net::TestNetLog> capturing_net_log_;
-  net::IPEndPoint ip_;
   // Simulated connect data
   std::unique_ptr<net::MockConnect> tcp_connect_data_;
   std::unique_ptr<net::MockConnect> ssl_connect_data_;
   // Simulated read / write data
   std::vector<net::MockWrite> writes_;
   std::vector<net::MockRead> reads_;
   std::unique_ptr<net::SocketDataProvider> ssl_data_;
-  // 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_;
-  std::unique_ptr<base::MockTimer> mock_timer_;
   MockCastTransport* mock_transport_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestCastSocket);
 };
 
-class CastSocketTest : public testing::Test {
+class SslTestCastSocket : public TestCastSocketBase {
  public:
-  CastSocketTest()
-      : logger_(
+  static std::unique_ptr<SslTestCastSocket> Create(
+      Logger* logger,
+      uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
+    return std::unique_ptr<SslTestCastSocket>(new SslTestCastSocket(
+        CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
+        kDistantTimeoutMillis, logger, device_capabilities));
+  }
+
+  using TestCastSocketBase::TestCastSocketBase;
+
+  void SetTcpSocket(std::unique_ptr<net::TCPClientSocket> tcp_client_socket) {
+    tcp_client_socket_ = std::move(tcp_client_socket);
+  }
+
+ private:
+  std::unique_ptr<net::TCPClientSocket> CreateTcpSocket() override {
+    return std::move(tcp_client_socket_);
+  }
+
+  using CastSocketImpl::CreateSslSocket;
+
+  std::unique_ptr<net::TCPClientSocket> tcp_client_socket_;
+};
+
+class CastSocketTestBase : public testing::Test {
+ public:
+  CastSocketTestBase()
+      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+        logger_(
             new Logger(base::WrapUnique<base::Clock>(new base::SimpleTestClock),
                        base::Time())),
         delegate_(new MockDelegate) {}
-  ~CastSocketTest() override {}
+  ~CastSocketTestBase() override {}
 
   void SetUp() override { EXPECT_CALL(*delegate_, OnMessage(_)).Times(0); }
 
   void TearDown() override {
     if (socket_.get()) {
       EXPECT_CALL(handler_, OnCloseComplete(net::OK));
       socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                                 base::Unretained(&handler_)));
     }
   }
 
-  void CreateCastSocket() { socket_ = TestCastSocket::Create(logger_); }
-
-  void CreateCastSocketSecure() {
-    socket_ = TestCastSocket::CreateSecure(logger_);
-  }
-
-  void HandleAuthHandshake() {
-    socket_->SetupMockTransport();
-    CastMessage challenge_proto = CreateAuthChallenge();
-    EXPECT_CALL(*socket_->GetMockTransport(),
-                SendMessage(EqualsProto(challenge_proto), _))
-        .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-    EXPECT_CALL(*socket_->GetMockTransport(), Start());
-    EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
-    socket_->Connect(std::move(delegate_),
-                     base::Bind(&CompleteHandler::OnConnectComplete,
-                                base::Unretained(&handler_)));
-    RunPendingTasks();
-    socket_->GetMockTransport()->current_delegate()->OnMessage(
-        CreateAuthReply());
-    RunPendingTasks();
-  }
-
  protected:
   // Runs all pending tasks in the message loop.
   void RunPendingTasks() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
-  base::MessageLoop message_loop_;
+  content::TestBrowserThreadBundle thread_bundle_;
   Logger* logger_;
-  std::unique_ptr<TestCastSocket> socket_;
   CompleteHandler handler_;
   std::unique_ptr<MockDelegate> delegate_;
+  std::unique_ptr<TestCastSocketBase> socket_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(CastSocketTest);
+  DISALLOW_COPY_AND_ASSIGN(CastSocketTestBase);

[mark a. foltz, 2016/07/28 00:10:01]

I don't think test objects are normally copied/assigned by gtest, but I suppose
this can't hurt.

[btolsch, 2016/08/11 22:31:33]

Carried over from old code.  Removed.

 };
 
+class MockCastSocketTest : public CastSocketTestBase {
+ protected:
+  void CreateCastSocket() { socket_ = MockTestCastSocket::Create(logger_); }
+
+  void CreateCastSocketSecure() {
+    socket_ = MockTestCastSocket::CreateSecure(logger_);
+  }
+
+  void HandleAuthHandshake() {
+    socket()->SetupMockTransport();
+    CastMessage challenge_proto = CreateAuthChallenge();
+    EXPECT_CALL(*socket()->GetMockTransport(),
+                SendMessage(EqualsProto(challenge_proto), _))
+        .WillOnce(PostCompletionCallbackTask<1>(net::OK));
+    EXPECT_CALL(*socket()->GetMockTransport(), Start());
+    EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+    socket()->Connect(std::move(delegate_),
+                      base::Bind(&CompleteHandler::OnConnectComplete,
+                                 base::Unretained(&handler_)));
+    RunPendingTasks();
+    socket()->GetMockTransport()->current_delegate()->OnMessage(
+        CreateAuthReply());
+    RunPendingTasks();
+  }
+
+  MockTestCastSocket* socket() {
+    return static_cast<MockTestCastSocket*>(socket_.get());
+  }
+};
+
+class SslCastSocketTest : public CastSocketTestBase {
+ protected:
+  void CreateSslCastSocket() { socket_ = SslTestCastSocket::Create(logger_); }
+
+  // Initializes the SSLServerSocket |server_socket_| and the TCP socket
+  // |tcp_client_socket_| to be used by the CastSocket |socket_| as transport
+  // to |server_socket_|.
+  void CreateSslSockets() {
+    server_cert_ =
+        net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
+    ASSERT_TRUE(server_cert_);
+    server_private_key_ = ReadTestKeyFromPEM("ok_cert.pem");
+    ASSERT_TRUE(server_private_key_);
+    server_context_ = CreateSSLServerContext(
+        server_cert_.get(), *server_private_key_, server_ssl_config_);
+
+    tcp_server_socket_.reset(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    ASSERT_EQ(net::OK,
+              tcp_server_socket_->ListenWithAddressAndPort("127.0.0.1", 0, 1));
+    net::IPEndPoint server_address;
+    ASSERT_EQ(net::OK, tcp_server_socket_->GetLocalAddress(&server_address));
+    tcp_client_socket_.reset(
+        new net::TCPClientSocket(net::AddressList(server_address), nullptr,
+                                 nullptr, net::NetLog::Source()));
+
+    std::unique_ptr<net::StreamSocket> accepted_socket;
+    ASSERT_EQ(
+        net::ERR_IO_PENDING,
+        tcp_server_socket_->Accept(
+            &accepted_socket, base::Bind(&SslCastSocketTest::TcpAcceptCallback,
+                                         base::Unretained(this))));
+    ASSERT_EQ(net::ERR_IO_PENDING, tcp_client_socket_->Connect(base::Bind(
+                                       &SslCastSocketTest::TcpConnectCallback,
+                                       base::Unretained(this))));
+    RunPendingTasks();
+    ASSERT_TRUE(accepted_socket);
+    ASSERT_TRUE(tcp_client_socket_->IsConnected());
+
+    server_socket_ =
+        server_context_->CreateSSLServerSocket(std::move(accepted_socket));
+    ASSERT_TRUE(server_socket_);
+  }
+
+  void TcpAcceptCallback(int result) { ASSERT_EQ(net::OK, result); }
+
+  void TcpConnectCallback(int result) { ASSERT_EQ(net::OK, result); }
+
+  std::unique_ptr<crypto::RSAPrivateKey> ReadTestKeyFromPEM(
+      const base::StringPiece& name) {
+    base::FilePath certs_dir(net::GetTestCertsDirectory());
+    base::FilePath key_path = certs_dir.AppendASCII(name);
+    std::vector<std::string> headers;
+    headers.push_back("PRIVATE KEY");
+    std::string pem_data;
+    if (!base::ReadFileToString(key_path, &pem_data)) {
+      return nullptr;
+    }
+    net::PEMTokenizer pem_tokenizer(pem_data, headers);
+    if (!pem_tokenizer.GetNext()) {
+      return nullptr;
+    }
+    std::vector<uint8_t> key_vector(pem_tokenizer.data().begin(),
+                                    pem_tokenizer.data().end());
+
+    std::unique_ptr<crypto::RSAPrivateKey> key(
+        crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_vector));
+    return key;
+  }
+
+  int ReadExactLength(net::IOBuffer* buffer,
+                      int buffer_length,
+                      net::Socket* socket) {
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
+        new net::DrainableIOBuffer(buffer, buffer_length));
+    while (draining_buffer->BytesRemaining() > 0) {
+      net::TestCompletionCallback read_callback;
+      int read_result = read_callback.GetResult(server_socket_->Read(
+          draining_buffer.get(), buffer_length, read_callback.callback()));
+      EXPECT_GT(read_result, 0);
+      draining_buffer->DidConsume(read_result);
+    }
+    return buffer_length;
+  }
+
+  int WriteExactLength(net::IOBuffer* buffer,
+                       int buffer_length,
+                       net::Socket* socket) {
+    scoped_refptr<net::DrainableIOBuffer> draining_buffer(
+        new net::DrainableIOBuffer(buffer, buffer_length));
+    while (draining_buffer->BytesRemaining() > 0) {
+      net::TestCompletionCallback write_callback;
+      int write_result = write_callback.GetResult(server_socket_->Write(
+          draining_buffer.get(), buffer_length, write_callback.callback()));
+      EXPECT_GT(write_result, 0);
+      draining_buffer->DidConsume(write_result);
+    }
+    return buffer_length;
+  }
+
+  SslTestCastSocket* socket() {
+    return static_cast<SslTestCastSocket*>(socket_.get());
+  }
+
+  // Underlying TCP sockets for |socket_| to communicate with |server_socket_|
+  // when testing with the real SSL implementation.
+  std::unique_ptr<net::TCPClientSocket> tcp_client_socket_;
+  std::unique_ptr<net::TCPServerSocket> tcp_server_socket_;
+
+  // |server_socket_| is used for the *RealSSL tests in order to test the
+  // CastSocket over a real SSL socket. The other members below are used to
+  // initialize |server_socket_|.
+  std::unique_ptr<net::SSLServerSocket> server_socket_;
+  std::unique_ptr<net::SSLServerContext> server_context_;
+  std::unique_ptr<crypto::RSAPrivateKey> server_private_key_;
+  scoped_refptr<net::X509Certificate> server_cert_;
+  net::SSLServerConfig server_ssl_config_;
+};
+
 // Tests connecting and closing the socket.
-TEST_F(CastSocketTest, TestConnectAndClose) {
+TEST_F(MockCastSocketTest, TestConnectAndClose) {
   CreateCastSocket();
-  socket_->SetupMockTransport();
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupMockTransport();
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
+  socket()->Connect(std::move(delegate_),
+                    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());
+  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());
+  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) {
+TEST_F(MockCastSocketTest, TestConnect) {
   CreateCastSocket();
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
-  socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
+  socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
+  socket()->Connect(std::move(delegate_),
+                    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());
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection fails (async)
-TEST_F(CastSocketTest, TestConnectFails) {
+TEST_F(MockCastSocketTest, TestConnectFails) {
   CreateCastSocket();
-  socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
+  socket()->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
+  socket()->Connect(std::move(delegate_),
+                    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());
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket()->error_state());
   EXPECT_EQ(proto::TCP_SOCKET_CONNECT_COMPLETE,
-            logger_->GetLastErrors(socket_->id()).event_type);
+            logger_->GetLastErrors(socket()->id()).event_type);
   EXPECT_EQ(net::ERR_FAILED,
-            logger_->GetLastErrors(socket_->id()).net_return_value);
+            logger_->GetLastErrors(socket()->id()).net_return_value);
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection succeeds (async)
 // - Cert is extracted successfully
 // - Challenge request is sent (async)
 // - Challenge response is received (async)
 // - Credentials are verified successfuly
-TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
+TEST_F(MockCastSocketTest, TestConnectFullSecureFlowAsync) {
   CreateCastSocketSecure();
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
 
   HandleAuthHandshake();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (sync)
 // - SSL connection succeeds (sync)
 // - Cert is extracted successfully
 // - Challenge request is sent (sync)
 // - Challenge response is received (sync)
 // - Credentials are verified successfuly
-TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
-  CreateCastSocketSecure();
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+TEST_F(MockCastSocketTest, TestConnectFullSecureFlowSync) {
+  CreateCastSocketSecure();
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
 
   HandleAuthHandshake();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  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();
-  socket_->SetupMockTransport();
-
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
+TEST_F(MockCastSocketTest, TestConnectAuthMessageCorrupted) {
+  CreateCastSocketSecure();
+  socket()->SetupMockTransport();
+
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
 
   CastMessage challenge_proto = CreateAuthChallenge();
-  EXPECT_CALL(*socket_->GetMockTransport(),
+  EXPECT_CALL(*socket()->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-  EXPECT_CALL(*socket_->GetMockTransport(), Start());
+  EXPECT_CALL(*socket()->GetMockTransport(), Start());
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_TRANSPORT_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
   RunPendingTasks();
   CastMessage mangled_auth_reply = CreateAuthReply();
   mangled_auth_reply.set_namespace_("BOGUS_NAMESPACE");
 
-  socket_->GetMockTransport()->current_delegate()->OnMessage(
+  socket()->GetMockTransport()->current_delegate()->OnMessage(
       mangled_auth_reply);
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_TRANSPORT_ERROR,
-            socket_->error_state());
+            socket()->error_state());
 
   // Verifies that the CastSocket's resources were torn down during channel
   // close. (see http://crbug.com/504078)
-  EXPECT_EQ(nullptr, socket_->transport());
+  EXPECT_EQ(nullptr, socket()->transport());
 }
 
 // Test connection error - TCP connect fails (async)
-TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
-  CreateCastSocketSecure();
-
-  socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
+TEST_F(MockCastSocketTest, TestConnectTcpConnectErrorAsync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   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());
+  socket()->Connect(std::move(delegate_),
+                    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();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED);
+TEST_F(MockCastSocketTest, TestConnectTcpConnectErrorSync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   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());
+  socket()->Connect(std::move(delegate_),
+                    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();
-  socket_->SetupTcpConnectUnresponsive();
+TEST_F(MockCastSocketTest, TestConnectTcpTimeoutError) {
+  CreateCastSocketSecure();
+  socket()->SetupTcpConnectUnresponsive();
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   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());
+  socket()->Connect(std::move(delegate_),
+                    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());
+            socket()->error_state());
 }
 
 // Test connection error - TCP socket returns timeout
-TEST_F(CastSocketTest, TestConnectTcpSocketTimeoutError) {
-  CreateCastSocketSecure();
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
+TEST_F(MockCastSocketTest, TestConnectTcpSocketTimeoutError) {
+  CreateCastSocketSecure();
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    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_TIMEOUT,
-            socket_->error_state());
+            socket()->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
-            logger_->GetLastErrors(socket_->id()).net_return_value);
+            logger_->GetLastErrors(socket()->id()).net_return_value);
 }
 
 // Test connection error - SSL connect fails (async)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
-  CreateCastSocketSecure();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
+TEST_F(MockCastSocketTest, TestConnectSslConnectErrorAsync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+            socket()->error_state());
 }
 
 // Test connection error - SSL connect fails (sync)
-TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
-  CreateCastSocketSecure();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
+TEST_F(MockCastSocketTest, TestConnectSslConnectErrorSync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+            socket()->error_state());
   EXPECT_EQ(net::ERR_FAILED,
-            logger_->GetLastErrors(socket_->id()).net_return_value);
+            logger_->GetLastErrors(socket()->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (sync)
-TEST_F(CastSocketTest, TestConnectSslConnectTimeoutSync) {
-  CreateCastSocketSecure();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
+TEST_F(MockCastSocketTest, TestConnectSslConnectTimeoutSync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    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_TIMEOUT,
-            socket_->error_state());
+            socket()->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
-            logger_->GetLastErrors(socket_->id()).net_return_value);
+            logger_->GetLastErrors(socket()->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (async)
-TEST_F(CastSocketTest, TestConnectSslConnectTimeoutAsync) {
-  CreateCastSocketSecure();
-
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT);
+TEST_F(MockCastSocketTest, TestConnectSslConnectTimeoutAsync) {
+  CreateCastSocketSecure();
+
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    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_TIMEOUT,
-            socket_->error_state());
+            socket()->error_state());
 }
 
 // Test connection error - cert extraction error (async)
-TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
+TEST_F(MockCastSocketTest, TestConnectCertExtractionErrorAsync) {
   CreateCastSocket();
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
   // Set cert extraction to fail
-  socket_->SetExtractCertResult(false);
+  socket()->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+            socket()->error_state());
 }
 
 // Test connection error - cert extraction error (sync)
-TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
+TEST_F(MockCastSocketTest, TestConnectCertExtractionErrorSync) {
   CreateCastSocket();
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   // Set cert extraction to fail
-  socket_->SetExtractCertResult(false);
+  socket()->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+            socket()->error_state());
 }
 
 // Test connection error - challenge send fails
-TEST_F(CastSocketTest, TestConnectChallengeSendError) {
-  CreateCastSocketSecure();
-  socket_->SetupMockTransport();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
-  EXPECT_CALL(*socket_->GetMockTransport(),
+TEST_F(MockCastSocketTest, TestConnectChallengeSendError) {
+  CreateCastSocketSecure();
+  socket()->SetupMockTransport();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+  EXPECT_CALL(*socket()->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET));
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              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());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               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 connection error - challenge reply receive fails
-TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
-  CreateCastSocketSecure();
-  socket_->SetupMockTransport();
-
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
-  EXPECT_CALL(*socket_->GetMockTransport(),
+TEST_F(MockCastSocketTest, TestConnectChallengeReplyReceiveError) {
+  CreateCastSocketSecure();
+  socket()->SetupMockTransport();
+
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+  EXPECT_CALL(*socket()->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-  socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
+  socket()->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR));
-  EXPECT_CALL(*socket_->GetMockTransport(), Start());
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-  socket_->GetMockTransport()->current_delegate()->OnError(
+  EXPECT_CALL(*socket()->GetMockTransport(), Start());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+  socket()->GetMockTransport()->current_delegate()->OnError(
       CHANNEL_ERROR_SOCKET_ERROR);
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
-}
-
-TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
-  CreateCastSocketSecure();
-  socket_->SetupMockTransport();
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
-  socket_->SetVerifyChallengeResult(false);
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket()->error_state());
+}
+
+TEST_F(MockCastSocketTest, TestConnectChallengeVerificationFails) {
+  CreateCastSocketSecure();
+  socket()->SetupMockTransport();
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
+  socket()->SetVerifyChallengeResult(false);
 
   EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_AUTHENTICATION_ERROR));
   CastMessage challenge_proto = CreateAuthChallenge();
-  EXPECT_CALL(*socket_->GetMockTransport(),
+  EXPECT_CALL(*socket()->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
-  EXPECT_CALL(*socket_->GetMockTransport(), Start());
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
-                              base::Unretained(&handler_)));
-  RunPendingTasks();
-  socket_->GetMockTransport()->current_delegate()->OnMessage(CreateAuthReply());
-  RunPendingTasks();
-
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  EXPECT_CALL(*socket()->GetMockTransport(), Start());
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+  socket()->GetMockTransport()->current_delegate()->OnMessage(
+      CreateAuthReply());
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket()->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
-}
-
-// Sends message data through an actual non-mocked CastTransport object,
-// testing the two components in integration.
-TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportAsync) {
-  CreateCastSocketSecure();
-  socket_->SetupTcpConnect(net::ASYNC, net::OK);
-  socket_->SetupSslConnect(net::ASYNC, net::OK);
+            socket()->error_state());
+}
+
+// Tests connecting through an actual non-mocked CastTransport object and
+// non-mocked SSLClientSocket, testing the components in integration.
+TEST_F(SslCastSocketTest, TestConnectEndToEndWithRealSSL) {
+  CreateSslCastSocket();
+  CreateSslSockets();
+  socket()->SetTcpSocket(std::move(tcp_client_socket_));
+
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+
+  net::TestCompletionCallback handshake_callback;
+  int server_ret = handshake_callback.GetResult(
+      server_socket_->Handshake(handshake_callback.callback()));
+
+  ASSERT_EQ(net::OK, server_ret);
 
   // Set low-level auth challenge expectations.
   CastMessage challenge = CreateAuthChallenge();
   std::string challenge_str;
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
-  socket_->AddWriteResultForData(net::ASYNC, challenge_str);
+
+  int challenge_buffer_length = challenge_str.size();
+  scoped_refptr<net::IOBuffer> challenge_buffer(
+      new net::IOBuffer(challenge_buffer_length));
+  int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
+                             server_socket_.get());
+
+  EXPECT_EQ(challenge_buffer_length, read);
+  EXPECT_EQ(challenge_str,
+            std::string(challenge_buffer->data(), challenge_buffer_length));
 
   // Set low-level auth reply expectations.
   CastMessage reply = CreateAuthReply();
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
-  socket_->AddReadResultForData(net::ASYNC, reply_str);
-  socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
-
-  CastMessage test_message = CreateTestMessage();
-  std::string test_message_str;
-  EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
-  socket_->AddWriteResultForData(net::ASYNC, test_message_str);
-
+
+  scoped_refptr<net::StringIOBuffer> reply_buffer(
+      new net::StringIOBuffer(reply_str));
+  int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
+                                 server_socket_.get());
+
+  EXPECT_EQ(reply_buffer->size(), written);
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
-  socket_->Connect(std::move(delegate_),
-                   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());
-
-  // Send the test message through a real transport object.
-  EXPECT_CALL(handler_, OnWriteComplete(net::OK));
-  socket_->transport()->SendMessage(
-      test_message, 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());
-}
-
-// Same as TestConnectEndToEndWithRealTransportAsync, except synchronous.
-TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportSync) {
-  CreateCastSocketSecure();
-  socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
-  socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
+}
+
+// Sends message data through an actual non-mocked CastTransport object and
+// non-mocked SSLClientSocket, testing the components in integration.
+TEST_F(SslCastSocketTest, TestMessageEndToEndWithRealSSL) {
+  CreateSslCastSocket();
+  CreateSslSockets();
+  socket()->SetTcpSocket(std::move(tcp_client_socket_));
+
+  socket()->Connect(std::move(delegate_),
+                    base::Bind(&CompleteHandler::OnConnectComplete,
+                               base::Unretained(&handler_)));
+
+  net::TestCompletionCallback handshake_callback;
+  int server_ret = handshake_callback.GetResult(
+      server_socket_->Handshake(handshake_callback.callback()));
+
+  ASSERT_EQ(net::OK, server_ret);
 
   // Set low-level auth challenge expectations.
   CastMessage challenge = CreateAuthChallenge();
   std::string challenge_str;
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
-  socket_->AddWriteResultForData(net::SYNCHRONOUS, challenge_str);
+
+  int challenge_buffer_length = challenge_str.size();
+  scoped_refptr<net::IOBuffer> challenge_buffer(
+      new net::IOBuffer(challenge_buffer_length));
+
+  int read = ReadExactLength(challenge_buffer.get(), challenge_buffer_length,
+                             server_socket_.get());
+
+  EXPECT_EQ(challenge_buffer_length, read);
+  EXPECT_EQ(challenge_str,
+            std::string(challenge_buffer->data(), challenge_buffer_length));
 
   // Set low-level auth reply expectations.
   CastMessage reply = CreateAuthReply();
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
-  socket_->AddReadResultForData(net::SYNCHRONOUS, reply_str);
-  socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
-
+
+  scoped_refptr<net::StringIOBuffer> reply_buffer(
+      new net::StringIOBuffer(reply_str));
+  int written = WriteExactLength(reply_buffer.get(), reply_buffer->size(),
+                                 server_socket_.get());
+
+  EXPECT_EQ(reply_buffer->size(), written);
+  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
+
+  // Send a test message through the ssl socket.
   CastMessage test_message = CreateTestMessage();
   std::string test_message_str;
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
-  socket_->AddWriteResultForData(net::SYNCHRONOUS, test_message_str);
+
+  int test_message_length = test_message_str.size();
+  scoped_refptr<net::IOBuffer> test_message_buffer(
+      new net::IOBuffer(test_message_length));
+
+  EXPECT_CALL(handler_, OnWriteComplete(net::OK));
+  socket()->transport()->SendMessage(
+      test_message, base::Bind(&CompleteHandler::OnWriteComplete,
+                               base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  read = ReadExactLength(test_message_buffer.get(), test_message_length,
+                         server_socket_.get());
+
+  EXPECT_EQ(test_message_length, read);
+  EXPECT_EQ(test_message_str,
+            std::string(test_message_buffer->data(), test_message_length));
+
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
+}
+
+// Sends message data through an actual non-mocked CastTransport object,
+// testing the two components in integration.
+TEST_F(MockCastSocketTest, TestConnectEndToEndWithRealTransportAsync) {
+  CreateCastSocketSecure();
+  socket()->SetupTcpConnect(net::ASYNC, net::OK);
+  socket()->SetupSslConnect(net::ASYNC, net::OK);
+
+  // Set low-level auth challenge expectations.
+  CastMessage challenge = CreateAuthChallenge();
+  std::string challenge_str;
+  EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
+  socket()->AddWriteResultForData(net::ASYNC, challenge_str);
+
+  // Set low-level auth reply expectations.
+  CastMessage reply = CreateAuthReply();
+  std::string reply_str;
+  EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
+  socket()->AddReadResultForData(net::ASYNC, reply_str);
+  socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
+
+  CastMessage test_message = CreateTestMessage();
+  std::string test_message_str;
+  EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
+  socket()->AddWriteResultForData(net::ASYNC, test_message_str);
 
   EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
-  socket_->Connect(std::move(delegate_),
-                   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());
+  socket()->Connect(std::move(delegate_),
+                    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());
 
   // Send the test message through a real transport object.
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
-  socket_->transport()->SendMessage(
+  socket()->transport()->SendMessage(
       test_message, 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());
+  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket()->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket()->error_state());
+}
+
+// Same as TestConnectEndToEndWithRealTransportAsync, except synchronous.
+TEST_F(MockCastSocketTest, TestConnectEndToEndWithRealTransportSync) {
+  CreateCastSocketSecure();
+  socket()->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
+  socket()->SetupSslConnect(net::SYNCHRONOUS, net::OK);
+
+  // Set low-level auth challenge expectations.
+  CastMessage challenge = CreateAuthChallenge();
+  std::string challenge_str;
+  EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
+  socket()->AddWriteResultForData(net::SYNCHRONOUS, challenge_str);
+
+  // Set low-level auth reply expectations.
+  CastMessage reply = CreateAuthReply();
+  std::string reply_str;
+  EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
+  socket()->AddReadResultForData(net::SYNCHRONOUS, reply_str);
+  socket()->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
+
+  CastMessage test_message = CreateTestMessage();
+  std::string test_message_str;
+  EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
+  socket()->AddWriteResultForData(net::SYNCHRONOUS, test_message_str);
+
+  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  socket()->Connect(std::move(delegate_),
+                    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());
+
+  // Send the test message through a real transport object.
+  EXPECT_CALL(handler_, OnWriteComplete(net::OK));
+  socket()->transport()->SendMessage(
+      test_message, 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());
 }
 
 // Tests channel policy verification for device with no capabilities.
-TEST_F(CastSocketTest, TestChannelPolicyVerificationCapabilitiesNone) {
-  socket_ =
-      TestCastSocket::Create(logger_, cast_channel::CastDeviceCapability::NONE);
-  EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone());
-  EXPECT_TRUE(socket_->TestVerifyChannelPolicyAudioOnly());
+TEST_F(MockCastSocketTest, TestChannelPolicyVerificationCapabilitiesNone) {
+  socket_ = MockTestCastSocket::Create(
+      logger_, cast_channel::CastDeviceCapability::NONE);
+  EXPECT_TRUE(socket()->TestVerifyChannelPolicyNone());
+  EXPECT_TRUE(socket()->TestVerifyChannelPolicyAudioOnly());
 }
 
 // Tests channel policy verification for device with video out capability.
-TEST_F(CastSocketTest, TestChannelPolicyVerificationCapabilitiesVideoOut) {
-  socket_ = TestCastSocket::Create(
+TEST_F(MockCastSocketTest, TestChannelPolicyVerificationCapabilitiesVideoOut) {
+  socket_ = MockTestCastSocket::Create(
       logger_, cast_channel::CastDeviceCapability::VIDEO_OUT);
-  EXPECT_FALSE(socket_->audio_only());
-  EXPECT_TRUE(socket_->TestVerifyChannelPolicyNone());
-  EXPECT_FALSE(socket_->audio_only());
-  EXPECT_FALSE(socket_->TestVerifyChannelPolicyAudioOnly());
-  EXPECT_TRUE(socket_->audio_only());
+  EXPECT_FALSE(socket()->audio_only());
+  EXPECT_TRUE(socket()->TestVerifyChannelPolicyNone());
+  EXPECT_FALSE(socket()->audio_only());
+  EXPECT_FALSE(socket()->TestVerifyChannelPolicyAudioOnly());
+  EXPECT_TRUE(socket()->audio_only());
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions