[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 extract_result) {
+    extract_cert_result_ = extract_result;
+  }
+
+  void SetVerifyChallengeResult(bool verify_challenge) {
+    verify_challenge_result_ = verify_challenge;
+  }
+
+  void TriggerTimeout() { mock_timer_->Fire(); }
+
+  bool HasChannelPolicyNone() {
+    AuthResult authResult;
+    return VerifyChannelPolicy(authResult);
+  }
+
+  bool HasChannelPolicyAudioOnly() {
+    AuthResult authResult;
+    authResult.channel_policies |= AuthResult::POLICY_AUDIO_ONLY;
+    return VerifyChannelPolicy(authResult);
+  }
+
+ protected:
+  scoped_refptr<net::X509Certificate> ExtractPeerCert() override {
+    if (!extract_cert_result_) {
+      return nullptr;
+    }
+    auto cert =
+        net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
+    EXPECT_NE(nullptr, cert);
+    return cert;
+  }
+
+  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 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,
+        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;

[Ryan Sleevi, 2016/09/16 01:39:06]

I've rarely seen this pattern in Chrome, and when I've seen it in not-Chrome,
it's usually a signal that the object hierarchy is weird or not right.

It's unclear to me why this (and line 413), but they are big warning signs.

[btolsch, 2017/06/22 04:23:53]

This line is just so I don't have to repeat the constructor arguments of
TestCastSocketBase because nothing is added.

Line 413 is not actually doing anything other than to say "MockTestCastSocket
overrides this method, but I'm not."  I removed it since this might actually be
confusing.

+
+  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_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CastSocketTest);
+  std::unique_ptr<TestCastSocketBase> socket_;
 };
 
+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_),

[Ryan Sleevi, 2016/09/16 01:39:06]

It still continues to surprise me that Cast sockets are designed async-only,
given how much in //net we've tried to focus on sync-or-async (w/ state
machines), to resolve UAF and other lifetime issues.

Because of this weirdness (which is preexisting), it makes it really hard for me
to reassure myself that the following code (on line 471) is correct.

[btolsch, 2017/06/22 04:23:52]

Acknowledged.

+                      base::Bind(&CompleteHandler::OnConnectComplete,
+                                 base::Unretained(&handler_)));
+    RunPendingTasks();

[Ryan Sleevi, 2016/09/16 01:39:06]

What happens if Connect() failed? Isn't line 472 intrinsically dangerous then -
since you may be accessing the socket outside of its guarantees?

One way to resolve this would be to have the OnConnectComplete handler_ be
responsible for setting up this OnMessage/CreateAuthReply

[btolsch, 2017/06/22 04:23:53]

This is existing code that I just moved here.  472 isn't really accessing
socket_, it's accessing the transport directly and injecting an auth reply as if
the socket were connecting to a real device.

+    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");

[Ryan Sleevi, 2016/09/16 01:39:06]

net::GetTestCertsDirectory() is more of an 'internal implementation detail' of
//net, at least for purposes of "serve using this cert".

That's because we can, have, and will change aspects of things like ok_cert.pem,
which is 'safe' if you're using [Spawned/Embedded]TestServer (which are part of
//net), but 'not safe' if you're outside (read: it's not always easy or obvious
to maintain "Some Other Server's Code")

Since you're in effect setting up your own EmbeddedCastTestServer-like thing
here, it may be useful to create & maintain your own test certs for the purpose
of Cast; that way your tests don't have the additional dependency on //net
policies || needs.

[btolsch, 2017/06/22 04:23:53]

Added a new cert to //components/test/data/cast_channel/ and also used it in
ExtractPeerCert() above.

+    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;
+    tcp_server_socket_->Accept(&accepted_socket,
+                               base::Bind(&SslCastSocketTest::TcpAcceptCallback,
+                                          base::Unretained(this)));
+    tcp_client_socket_->Connect(base::Bind(
+        &SslCastSocketTest::TcpConnectCallback, base::Unretained(this)));
+    while (!accept_succeeded_ && !connect_succeeded_) {
+      RunPendingTasks();

[Ryan Sleevi, 2016/09/16 01:39:06]

This will run indefinitely if either Accept() or Connect() synchronously
complete, which they totally can. You need to check the result value of both
(for things like net::ERR_IO_PENDING)

[btolsch, 2017/06/22 04:23:53]

Done.

+    }

[Ryan Sleevi, 2016/09/16 01:39:06]

Because of how you've structured TcpAcceptCallback & TcpConnectCallback, if the
callbacks are invoked with an error code, then accept/connect_succeeded_ will
never be true, and the loop will run indefinitely.

[btolsch, 2017/06/22 04:23:53]

I revised this to simply save the result so the main loop can check it instead.

+    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);
+    accept_succeeded_ = true;
+  }
+
+  void TcpConnectCallback(int result) {
+    ASSERT_EQ(net::OK, result);
+    connect_succeeded_ = true;
+  }
+
+  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());
+  }
+
+  // Booleans used for TCP socket setup.
+  bool accept_succeeded_ = false;
+  bool connect_succeeded_ = false;
+
+  // 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()->HasChannelPolicyNone());
+  EXPECT_TRUE(socket()->HasChannelPolicyAudioOnly());
 }
 
 // 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()->HasChannelPolicyNone());
+  EXPECT_FALSE(socket()->audio_only());
+  EXPECT_FALSE(socket()->HasChannelPolicyAudioOnly());
+  EXPECT_TRUE(socket()->audio_only());
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions