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

extensions/browser/api/cast_channel/cast_socket.cc

Index: extensions/browser/api/cast_channel/cast_socket.cc
diff --git a/extensions/browser/api/cast_channel/cast_socket.cc b/extensions/browser/api/cast_channel/cast_socket.cc
index 650857ce3694e0b0b0af3bf6039bc4910a129a63..fa9a6b6b3be90e0c7da36a9736bb95a96fb6a3b4 100644
--- a/extensions/browser/api/cast_channel/cast_socket.cc
+++ b/extensions/browser/api/cast_channel/cast_socket.cc
@@ -53,14 +53,15 @@ const int kTcpKeepAliveDelaySecs = 10;
 namespace extensions {
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<
-    ApiResourceManager<core_api::cast_channel::CastSocket> > > g_factory =
+    ApiResourceManager<core_api::cast_channel::CastSocketImpl> > > g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 template <>
 BrowserContextKeyedAPIFactory<
-    ApiResourceManager<core_api::cast_channel::CastSocket> >*
-ApiResourceManager<core_api::cast_channel::CastSocket>::GetFactoryInstance() {
+    ApiResourceManager<core_api::cast_channel::CastSocketImpl> >*
+ApiResourceManager<
+    core_api::cast_channel::CastSocketImpl>::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
@@ -87,23 +88,24 @@ proto::ReadyState ReadyStateToProto(ReadyState state) {
   }
 }
 
-proto::ConnectionState ConnectStateToProto(CastSocket::ConnectionState state) {
+proto::ConnectionState ConnectStateToProto(
+    CastSocketImpl::ConnectionState state) {
   switch (state) {
-    case CastSocket::CONN_STATE_NONE:
+    case CastSocketImpl::CONN_STATE_NONE:
       return proto::CONN_STATE_NONE;
-    case CastSocket::CONN_STATE_TCP_CONNECT:
+    case CastSocketImpl::CONN_STATE_TCP_CONNECT:
       return proto::CONN_STATE_TCP_CONNECT;
-    case CastSocket::CONN_STATE_TCP_CONNECT_COMPLETE:
+    case CastSocketImpl::CONN_STATE_TCP_CONNECT_COMPLETE:
       return proto::CONN_STATE_TCP_CONNECT_COMPLETE;
-    case CastSocket::CONN_STATE_SSL_CONNECT:
+    case CastSocketImpl::CONN_STATE_SSL_CONNECT:
       return proto::CONN_STATE_SSL_CONNECT;
-    case CastSocket::CONN_STATE_SSL_CONNECT_COMPLETE:
+    case CastSocketImpl::CONN_STATE_SSL_CONNECT_COMPLETE:
       return proto::CONN_STATE_SSL_CONNECT_COMPLETE;
-    case CastSocket::CONN_STATE_AUTH_CHALLENGE_SEND:
+    case CastSocketImpl::CONN_STATE_AUTH_CHALLENGE_SEND:
       return proto::CONN_STATE_AUTH_CHALLENGE_SEND;
-    case CastSocket::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE:
+    case CastSocketImpl::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE:
       return proto::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE;
-    case CastSocket::CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE:
+    case CastSocketImpl::CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE:
       return proto::CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE;
     default:
       NOTREACHED();
@@ -111,17 +113,17 @@ proto::ConnectionState ConnectStateToProto(CastSocket::ConnectionState state) {
   }
 }
 
-proto::ReadState ReadStateToProto(CastSocket::ReadState state) {
+proto::ReadState ReadStateToProto(CastSocketImpl::ReadState state) {
   switch (state) {
-    case CastSocket::READ_STATE_NONE:
+    case CastSocketImpl::READ_STATE_NONE:
       return proto::READ_STATE_NONE;
-    case CastSocket::READ_STATE_READ:
+    case CastSocketImpl::READ_STATE_READ:
       return proto::READ_STATE_READ;
-    case CastSocket::READ_STATE_READ_COMPLETE:
+    case CastSocketImpl::READ_STATE_READ_COMPLETE:
       return proto::READ_STATE_READ_COMPLETE;
-    case CastSocket::READ_STATE_DO_CALLBACK:
+    case CastSocketImpl::READ_STATE_DO_CALLBACK:
       return proto::READ_STATE_DO_CALLBACK;
-    case CastSocket::READ_STATE_ERROR:
+    case CastSocketImpl::READ_STATE_ERROR:
       return proto::READ_STATE_ERROR;
     default:
       NOTREACHED();
@@ -129,17 +131,17 @@ proto::ReadState ReadStateToProto(CastSocket::ReadState state) {
   }
 }
 
-proto::WriteState WriteStateToProto(CastSocket::WriteState state) {
+proto::WriteState WriteStateToProto(CastSocketImpl::WriteState state) {
   switch (state) {
-    case CastSocket::WRITE_STATE_NONE:
+    case CastSocketImpl::WRITE_STATE_NONE:
       return proto::WRITE_STATE_NONE;
-    case CastSocket::WRITE_STATE_WRITE:
+    case CastSocketImpl::WRITE_STATE_WRITE:
       return proto::WRITE_STATE_WRITE;
-    case CastSocket::WRITE_STATE_WRITE_COMPLETE:
+    case CastSocketImpl::WRITE_STATE_WRITE_COMPLETE:
       return proto::WRITE_STATE_WRITE_COMPLETE;
-    case CastSocket::WRITE_STATE_DO_CALLBACK:
+    case CastSocketImpl::WRITE_STATE_DO_CALLBACK:
       return proto::WRITE_STATE_DO_CALLBACK;
-    case CastSocket::WRITE_STATE_ERROR:
+    case CastSocketImpl::WRITE_STATE_ERROR:
       return proto::WRITE_STATE_ERROR;
     default:
       NOTREACHED();
@@ -177,13 +179,13 @@ proto::ErrorState ErrorStateToProto(ChannelError state) {
 
 }  // namespace
 
-CastSocket::CastSocket(const std::string& owner_extension_id,
-                       const net::IPEndPoint& ip_endpoint,
-                       ChannelAuthType channel_auth,
-                       CastSocket::Delegate* delegate,
-                       net::NetLog* net_log,
-                       const base::TimeDelta& timeout,
-                       const scoped_refptr<Logger>& logger)
+CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
+                               const net::IPEndPoint& ip_endpoint,
+                               ChannelAuthType channel_auth,
+                               CastSocketImpl::Delegate* delegate,
+                               net::NetLog* net_log,
+                               const base::TimeDelta& timeout,
+                               const scoped_refptr<Logger>& logger)
     : ApiResource(owner_extension_id),
       channel_id_(0),
       ip_endpoint_(ip_endpoint),
@@ -192,7 +194,7 @@ CastSocket::CastSocket(const std::string& owner_extension_id,
       net_log_(net_log),
       logger_(logger),
       connect_timeout_(timeout),
-      connect_timeout_timer_(new base::OneShotTimer<CastSocket>),
+      connect_timeout_timer_(new base::OneShotTimer<CastSocketImpl>),
       is_canceled_(false),
       connect_state_(CONN_STATE_NONE),
       write_state_(WRITE_STATE_NONE),
@@ -211,21 +213,21 @@ CastSocket::CastSocket(const std::string& owner_extension_id,
   framer_.reset(new MessageFramer(read_buffer_));
 }
 
-CastSocket::~CastSocket() {
+CastSocketImpl::~CastSocketImpl() {
   // Ensure that resources are freed but do not run pending callbacks to avoid
   // any re-entrancy.
   CloseInternal();
 }
 
-ReadyState CastSocket::ready_state() const {
+ReadyState CastSocketImpl::ready_state() const {
   return ready_state_;
 }
 
-ChannelError CastSocket::error_state() const {
+ChannelError CastSocketImpl::error_state() const {
   return error_state_;
 }
 
-scoped_ptr<net::TCPClientSocket> CastSocket::CreateTcpSocket() {
+scoped_ptr<net::TCPClientSocket> CastSocketImpl::CreateTcpSocket() {
   net::AddressList addresses(ip_endpoint_);
   return scoped_ptr<net::TCPClientSocket>(
       new net::TCPClientSocket(addresses, net_log_, net_log_source_));
@@ -234,7 +236,7 @@ scoped_ptr<net::TCPClientSocket> CastSocket::CreateTcpSocket() {
   // or Connect() is called.
 }
 
-scoped_ptr<net::SSLClientSocket> CastSocket::CreateSslSocket(
+scoped_ptr<net::SSLClientSocket> CastSocketImpl::CreateSslSocket(
     scoped_ptr<net::StreamSocket> socket) {
   net::SSLConfig ssl_config;
   // If a peer cert was extracted in a previous attempt to connect, then
@@ -264,7 +266,7 @@ scoped_ptr<net::SSLClientSocket> CastSocket::CreateSslSocket(
       connection.Pass(), host_and_port, ssl_config, context);
 }
 
-bool CastSocket::ExtractPeerCert(std::string* cert) {
+bool CastSocketImpl::ExtractPeerCert(std::string* cert) {
   DCHECK(cert);
   DCHECK(peer_cert_.empty());
   net::SSLInfo ssl_info;
@@ -286,13 +288,13 @@ bool CastSocket::ExtractPeerCert(std::string* cert) {
   return result;
 }
 
-bool CastSocket::VerifyChallengeReply() {
+bool CastSocketImpl::VerifyChallengeReply() {
   AuthResult result = AuthenticateChallengeReply(*challenge_reply_, peer_cert_);
   logger_->LogSocketChallengeReplyEvent(channel_id_, result);
   return result.success();
 }
 
-void CastSocket::Connect(const net::CompletionCallback& callback) {
+void CastSocketImpl::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "Connect readyState = " << ready_state_;
   if (ready_state_ != READY_STATE_NONE) {
@@ -309,7 +311,7 @@ void CastSocket::Connect(const net::CompletionCallback& callback) {
   if (connect_timeout_.InMicroseconds() > 0) {
     DCHECK(connect_timeout_callback_.IsCancelled());
     connect_timeout_callback_.Reset(
-        base::Bind(&CastSocket::OnConnectTimeout, base::Unretained(this)));
+        base::Bind(&CastSocketImpl::OnConnectTimeout, base::Unretained(this)));
     GetTimer()->Start(FROM_HERE,
                       connect_timeout_,
                       connect_timeout_callback_.callback());
@@ -317,17 +319,16 @@ void CastSocket::Connect(const net::CompletionCallback& callback) {
   DoConnectLoop(net::OK);
 }
 
-void CastSocket::PostTaskToStartConnectLoop(int result) {
+void CastSocketImpl::PostTaskToStartConnectLoop(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK(connect_loop_callback_.IsCancelled());
-  connect_loop_callback_.Reset(base::Bind(&CastSocket::DoConnectLoop,
-                                          base::Unretained(this),
-                                          result));
+  connect_loop_callback_.Reset(base::Bind(
+      &CastSocketImpl::DoConnectLoop, base::Unretained(this), result));
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          connect_loop_callback_.callback());
 }
 
-void CastSocket::OnConnectTimeout() {
+void CastSocketImpl::OnConnectTimeout() {
   DCHECK(CalledOnValidThread());
   // Stop all pending connection setup tasks and report back to the client.
   is_canceled_ = true;
@@ -340,7 +341,7 @@ void CastSocket::OnConnectTimeout() {
 // There are two entry points to this method:
 // 1. Connect method: this starts the flow
 // 2. Callback from network operations that finish asynchronously
-void CastSocket::DoConnectLoop(int result) {
+void CastSocketImpl::DoConnectLoop(int result) {
   connect_loop_callback_.Cancel();
   if (is_canceled_) {
     LOG(ERROR) << "CANCELLED - Aborting DoConnectLoop.";
@@ -402,19 +403,19 @@ void CastSocket::DoConnectLoop(int result) {
   }
 }
 
-int CastSocket::DoTcpConnect() {
+int CastSocketImpl::DoTcpConnect() {
   DCHECK(connect_loop_callback_.IsCancelled());
   VLOG_WITH_CONNECTION(1) << "DoTcpConnect";
   SetConnectState(CONN_STATE_TCP_CONNECT_COMPLETE);
   tcp_socket_ = CreateTcpSocket();
 
   int rv = tcp_socket_->Connect(
-      base::Bind(&CastSocket::DoConnectLoop, base::Unretained(this)));
+      base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
   logger_->LogSocketEventWithRv(channel_id_, proto::TCP_SOCKET_CONNECT, rv);
   return rv;
 }
 
-int CastSocket::DoTcpConnectComplete(int result) {
+int CastSocketImpl::DoTcpConnectComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoTcpConnectComplete: " << result;
   if (result == net::OK) {
     // Enable TCP protocol-level keep-alive.
@@ -427,19 +428,19 @@ int CastSocket::DoTcpConnectComplete(int result) {
   return result;
 }
 
-int CastSocket::DoSslConnect() {
+int CastSocketImpl::DoSslConnect() {
   DCHECK(connect_loop_callback_.IsCancelled());
   VLOG_WITH_CONNECTION(1) << "DoSslConnect";
   SetConnectState(CONN_STATE_SSL_CONNECT_COMPLETE);
   socket_ = CreateSslSocket(tcp_socket_.PassAs<net::StreamSocket>());
 
   int rv = socket_->Connect(
-      base::Bind(&CastSocket::DoConnectLoop, base::Unretained(this)));
+      base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
   logger_->LogSocketEventWithRv(channel_id_, proto::SSL_SOCKET_CONNECT, rv);
   return rv;
 }
 
-int CastSocket::DoSslConnectComplete(int result) {
+int CastSocketImpl::DoSslConnectComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoSslConnectComplete: " << result;
   if (result == net::ERR_CERT_AUTHORITY_INVALID &&
       peer_cert_.empty() && ExtractPeerCert(&peer_cert_)) {
@@ -451,7 +452,7 @@ int CastSocket::DoSslConnectComplete(int result) {
   return result;
 }
 
-int CastSocket::DoAuthChallengeSend() {
+int CastSocketImpl::DoAuthChallengeSend() {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSend";
   SetConnectState(CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE);
 
@@ -464,10 +465,10 @@ int CastSocket::DoAuthChallengeSend() {
   // code decoupled from connect loop code.
   DCHECK(send_auth_challenge_callback_.IsCancelled());
   send_auth_challenge_callback_.Reset(
-      base::Bind(&CastSocket::SendCastMessageInternal,
+      base::Bind(&CastSocketImpl::SendCastMessageInternal,
                  base::Unretained(this),
                  challenge_message,
-                 base::Bind(&CastSocket::DoAuthChallengeSendWriteComplete,
+                 base::Bind(&CastSocketImpl::DoAuthChallengeSendWriteComplete,
                             base::Unretained(this))));
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
@@ -476,7 +477,7 @@ int CastSocket::DoAuthChallengeSend() {
   return net::ERR_IO_PENDING;
 }
 
-void CastSocket::DoAuthChallengeSendWriteComplete(int result) {
+void CastSocketImpl::DoAuthChallengeSendWriteComplete(int result) {
   send_auth_challenge_callback_.Cancel();
   VLOG_WITH_CONNECTION(2) << "DoAuthChallengeSendWriteComplete: " << result;
   DCHECK_GT(result, 0);
@@ -484,7 +485,7 @@ void CastSocket::DoAuthChallengeSendWriteComplete(int result) {
   PostTaskToStartConnectLoop(result);
 }
 
-int CastSocket::DoAuthChallengeSendComplete(int result) {
+int CastSocketImpl::DoAuthChallengeSendComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSendComplete: " << result;
   if (result < 0) {
     return result;
@@ -499,7 +500,7 @@ int CastSocket::DoAuthChallengeSendComplete(int result) {
   return net::ERR_IO_PENDING;
 }
 
-int CastSocket::DoAuthChallengeReplyComplete(int result) {
+int CastSocketImpl::DoAuthChallengeReplyComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeReplyComplete: " << result;
   if (result < 0) {
     return result;
@@ -511,7 +512,7 @@ int CastSocket::DoAuthChallengeReplyComplete(int result) {
   return net::OK;
 }
 
-void CastSocket::DoConnectCallback(int result) {
+void CastSocketImpl::DoConnectCallback(int result) {
   SetReadyState((result == net::OK) ? READY_STATE_OPEN : READY_STATE_CLOSED);
   if (result == net::OK) {
     SetErrorState(CHANNEL_ERROR_NONE);
@@ -528,14 +529,14 @@ void CastSocket::DoConnectCallback(int result) {
   CloseWithError();
 }
 
-void CastSocket::Close(const net::CompletionCallback& callback) {
+void CastSocketImpl::Close(const net::CompletionCallback& callback) {
   CloseInternal();
   RunPendingCallbacksOnClose();
   // Run this callback last.  It may delete the socket.
   callback.Run(net::OK);
 }
 
-void CastSocket::CloseInternal() {
+void CastSocketImpl::CloseInternal() {
   // TODO(mfoltz): Enforce this when CastChannelAPITest is rewritten to create
   // and free sockets on the same thread.  crbug.com/398242
   // DCHECK(CalledOnValidThread());
@@ -560,7 +561,7 @@ void CastSocket::CloseInternal() {
   logger_->LogSocketEvent(channel_id_, proto::SOCKET_CLOSED);
 }
 
-void CastSocket::RunPendingCallbacksOnClose() {
+void CastSocketImpl::RunPendingCallbacksOnClose() {
   DCHECK_EQ(ready_state_, READY_STATE_CLOSED);
   if (!connect_callback_.is_null()) {
     connect_callback_.Run(net::ERR_CONNECTION_FAILED);
@@ -573,8 +574,8 @@ void CastSocket::RunPendingCallbacksOnClose() {
   }
 }
 
-void CastSocket::SendMessage(const MessageInfo& message,
-                             const net::CompletionCallback& callback) {
+void CastSocketImpl::SendMessage(const MessageInfo& message,
+                                 const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   if (ready_state_ != READY_STATE_OPEN) {
     logger_->LogSocketEventForMessage(channel_id_,
@@ -596,7 +597,7 @@ void CastSocket::SendMessage(const MessageInfo& message,
   SendCastMessageInternal(message_proto, callback);
 }
 
-void CastSocket::SendCastMessageInternal(
+void CastSocketImpl::SendCastMessageInternal(
     const CastMessage& message,
     const net::CompletionCallback& callback) {
   WriteRequest write_request(callback);
@@ -621,7 +622,7 @@ void CastSocket::SendCastMessageInternal(
   }
 }
 
-void CastSocket::DoWriteLoop(int result) {
+void CastSocketImpl::DoWriteLoop(int result) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "DoWriteLoop queue size: " << write_queue_.size();
 
@@ -677,7 +678,7 @@ void CastSocket::DoWriteLoop(int result) {
   }
 }
 
-int CastSocket::DoWrite() {
+int CastSocketImpl::DoWrite() {
   DCHECK(!write_queue_.empty());
   WriteRequest& request = write_queue_.front();
 
@@ -690,13 +691,13 @@ int CastSocket::DoWrite() {
   int rv = socket_->Write(
       request.io_buffer.get(),
       request.io_buffer->BytesRemaining(),
-      base::Bind(&CastSocket::DoWriteLoop, base::Unretained(this)));
+      base::Bind(&CastSocketImpl::DoWriteLoop, base::Unretained(this)));
   logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_WRITE, rv);
 
   return rv;
 }
 
-int CastSocket::DoWriteComplete(int result) {
+int CastSocketImpl::DoWriteComplete(int result) {
   DCHECK(!write_queue_.empty());
   if (result <= 0) {  // NOTE that 0 also indicates an error
     SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
@@ -717,7 +718,7 @@ int CastSocket::DoWriteComplete(int result) {
   return net::OK;
 }
 
-int CastSocket::DoWriteCallback() {
+int CastSocketImpl::DoWriteCallback() {
   DCHECK(!write_queue_.empty());
 
   SetWriteState(WRITE_STATE_WRITE);
@@ -734,7 +735,7 @@ int CastSocket::DoWriteCallback() {
   return net::OK;
 }
 
-int CastSocket::DoWriteError(int result) {
+int CastSocketImpl::DoWriteError(int result) {
   DCHECK(!write_queue_.empty());
   DCHECK_LT(result, 0);
 
@@ -757,16 +758,16 @@ int CastSocket::DoWriteError(int result) {
   return net::ERR_FAILED;
 }
 
-void CastSocket::PostTaskToStartReadLoop() {
+void CastSocketImpl::PostTaskToStartReadLoop() {
   DCHECK(CalledOnValidThread());
   DCHECK(read_loop_callback_.IsCancelled());
-  read_loop_callback_.Reset(base::Bind(&CastSocket::StartReadLoop,
-                                       base::Unretained(this)));
+  read_loop_callback_.Reset(
+      base::Bind(&CastSocketImpl::StartReadLoop, base::Unretained(this)));
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          read_loop_callback_.callback());
 }
 
-void CastSocket::StartReadLoop() {
+void CastSocketImpl::StartReadLoop() {
   read_loop_callback_.Cancel();
   // Read loop would have already been started if read state is not NONE
   if (read_state_ == READ_STATE_NONE) {
@@ -775,7 +776,7 @@ void CastSocket::StartReadLoop() {
   }
 }
 
-void CastSocket::DoReadLoop(int result) {
+void CastSocketImpl::DoReadLoop(int result) {
   DCHECK(CalledOnValidThread());
   // Network operations can either finish synchronously or asynchronously.
   // This method executes the state machine transitions in a loop so that
@@ -826,7 +827,7 @@ void CastSocket::DoReadLoop(int result) {
   }
 }
 
-int CastSocket::DoRead() {
+int CastSocketImpl::DoRead() {
   SetReadState(READ_STATE_READ_COMPLETE);
 
   // Determine how many bytes need to be read.
@@ -836,13 +837,13 @@ int CastSocket::DoRead() {
   int rv = socket_->Read(
       read_buffer_.get(),
       base::checked_cast<uint32>(num_bytes_to_read),
-      base::Bind(&CastSocket::DoReadLoop, base::Unretained(this)));
+      base::Bind(&CastSocketImpl::DoReadLoop, base::Unretained(this)));
   logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_READ, rv);
 
   return rv;
 }
 
-int CastSocket::DoReadComplete(int result) {
+int CastSocketImpl::DoReadComplete(int result) {
   VLOG_WITH_CONNECTION(2) << "DoReadComplete result = " << result;
 
   if (result <= 0) {  // 0 means EOF: the peer closed the socket
@@ -875,7 +876,7 @@ int CastSocket::DoReadComplete(int result) {
   return net::OK;
 }
 
-int CastSocket::DoReadCallback() {
+int CastSocketImpl::DoReadCallback() {
   SetReadState(READ_STATE_READ);
   const CastMessage& message = *current_message_;
   if (ready_state_ == READY_STATE_CONNECTING) {
@@ -911,12 +912,12 @@ int CastSocket::DoReadCallback() {
   return net::OK;
 }
 
-int CastSocket::DoReadError(int result) {
+int CastSocketImpl::DoReadError(int result) {
   DCHECK_LE(result, 0);
   return net::ERR_FAILED;
 }
 
-void CastSocket::CloseWithError() {
+void CastSocketImpl::CloseWithError() {
   DCHECK(CalledOnValidThread());
   CloseInternal();
   RunPendingCallbacksOnClose();
@@ -926,20 +927,20 @@ void CastSocket::CloseWithError() {
   }
 }
 
-std::string CastSocket::CastUrl() const {
+std::string CastSocketImpl::CastUrl() const {
   return ((channel_auth_ == CHANNEL_AUTH_TYPE_SSL_VERIFIED) ?
           "casts://" : "cast://") + ip_endpoint_.ToString();
 }
 
-bool CastSocket::CalledOnValidThread() const {
+bool CastSocketImpl::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
-base::Timer* CastSocket::GetTimer() {
+base::Timer* CastSocketImpl::GetTimer() {
   return connect_timeout_timer_.get();
 }
 
-void CastSocket::SetConnectState(ConnectionState connect_state) {
+void CastSocketImpl::SetConnectState(ConnectionState connect_state) {
   if (connect_state_ != connect_state) {
     connect_state_ = connect_state;
     logger_->LogSocketConnectState(channel_id_,
@@ -947,38 +948,41 @@ void CastSocket::SetConnectState(ConnectionState connect_state) {
   }
 }
 
-void CastSocket::SetReadyState(ReadyState ready_state) {
+void CastSocketImpl::SetReadyState(ReadyState ready_state) {
   if (ready_state_ != ready_state) {
     ready_state_ = ready_state;
     logger_->LogSocketReadyState(channel_id_, ReadyStateToProto(ready_state_));
   }
 }
 
-void CastSocket::SetErrorState(ChannelError error_state) {
+void CastSocketImpl::SetErrorState(ChannelError error_state) {
   if (error_state_ != error_state) {
     error_state_ = error_state;
     logger_->LogSocketErrorState(channel_id_, ErrorStateToProto(error_state_));
   }
 }
 
-void CastSocket::SetReadState(ReadState read_state) {
+void CastSocketImpl::SetReadState(ReadState read_state) {
   if (read_state_ != read_state) {
     read_state_ = read_state;
     logger_->LogSocketReadState(channel_id_, ReadStateToProto(read_state_));
   }
 }
 
-void CastSocket::SetWriteState(WriteState write_state) {
+void CastSocketImpl::SetWriteState(WriteState write_state) {
   if (write_state_ != write_state) {
     write_state_ = write_state;
     logger_->LogSocketWriteState(channel_id_, WriteStateToProto(write_state_));
   }
 }
 
-CastSocket::WriteRequest::WriteRequest(const net::CompletionCallback& callback)
-  : callback(callback) { }
+CastSocketImpl::WriteRequest::WriteRequest(
+    const net::CompletionCallback& callback)
+    : callback(callback) {
+}
 
-bool CastSocket::WriteRequest::SetContent(const CastMessage& message_proto) {
+bool CastSocketImpl::WriteRequest::SetContent(
+    const CastMessage& message_proto) {
   DCHECK(!io_buffer.get());
   std::string message_data;
   if (!MessageFramer::Serialize(message_proto, &message_data)) {
@@ -990,7 +994,8 @@ bool CastSocket::WriteRequest::SetContent(const CastMessage& message_proto) {
   return true;
 }
 
-CastSocket::WriteRequest::~WriteRequest() { }
+CastSocketImpl::WriteRequest::~WriteRequest() {
+}
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions