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

extensions/browser/api/cast_channel/cast_socket.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 <stdlib.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 191 matching lines @@
     GetTimer()->Start(FROM_HERE,
                       connect_timeout_,
                       connect_timeout_callback_.callback());
   }
   DoConnectLoop(net::OK);
 }
 
 void CastSocket::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(&CastSocket::DoConnectLoop, base::Unretained(this), result));
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          connect_loop_callback_.callback());
 }
 
 void CastSocket::OnConnectTimeout() {
   DCHECK(CalledOnValidThread());
   // Stop all pending connection setup tasks and report back to the client.
   is_canceled_ = true;
   logger_->LogSocketEvent(channel_id_, proto::CONNECT_TIMED_OUT);
   VLOG_WITH_CONNECTION(1) << "Timeout while establishing a connection.";
@@ skipping 415 matching lines @@
     WriteRequest& request = write_queue_.front();
     request.callback.Run(result);
     write_queue_.pop();
   }
   return net::ERR_FAILED;
 }
 
 void CastSocket::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(&CastSocket::StartReadLoop, base::Unretained(this)));
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          read_loop_callback_.callback());
 }
 
 void CastSocket::StartReadLoop() {
   read_loop_callback_.Cancel();
   // Read loop would have already been started if read state is not NONE
   if (read_state_ == proto::READ_STATE_NONE) {
     SetReadState(proto::READ_STATE_READ);
     DoReadLoop(net::OK);
@@ skipping 193 matching lines @@
 }
 
 void CastSocket::SetWriteState(proto::WriteState write_state) {
   if (write_state_ != write_state) {
     write_state_ = write_state;
     logger_->LogSocketWriteState(channel_id_, write_state_);
   }
 }
 
 CastSocket::WriteRequest::WriteRequest(const net::CompletionCallback& callback)
-  : callback(callback) { }
+    : callback(callback) {
+}
 
 bool CastSocket::WriteRequest::SetContent(const CastMessage& message_proto) {
   DCHECK(!io_buffer.get());
   std::string message_data;
   if (!MessageFramer::Serialize(message_proto, &message_data)) {
     return false;
   }
   message_namespace = message_proto.namespace_();
   io_buffer = new net::DrainableIOBuffer(new net::StringIOBuffer(message_data),
                                          message_data.size());
   return true;
 }
 
-CastSocket::WriteRequest::~WriteRequest() { }
+CastSocket::WriteRequest::~WriteRequest() {
+}
+
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions
 
 #undef VLOG_WITH_CONNECTION