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

extensions/browser/api/cast_channel/cast_channel_api.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_channel_api.h"
 
 #include <limits>
 #include <string>
 
 #include "base/json/json_writer.h"
@@ skipping 15 matching lines @@
 // Used if not otherwise specified at ConnectInfo::timeout.
 const int kDefaultConnectTimeoutMillis = 5000;  // 5 seconds.
 
 namespace extensions {
 
 namespace Close = cast_channel::Close;
 namespace OnError = cast_channel::OnError;
 namespace OnMessage = cast_channel::OnMessage;
 namespace Open = cast_channel::Open;
 namespace Send = cast_channel::Send;
-using cast_channel::CastSocket;
+using cast_channel::CastSocketImpl;
 using cast_channel::ChannelAuthType;
 using cast_channel::ChannelError;
 using cast_channel::ChannelInfo;
 using cast_channel::ConnectInfo;
 using cast_channel::ErrorInfo;
 using cast_channel::LastErrors;
 using cast_channel::Logger;
 using cast_channel::MessageInfo;
 using cast_channel::ReadyState;
 using content::BrowserThread;
 
 namespace {
 
 // T is an extension dictionary (MessageInfo or ChannelInfo)
 template <class T>
 std::string ParamToString(const T& info) {
   scoped_ptr<base::DictionaryValue> dict = info.ToValue();
   std::string out;
   base::JSONWriter::Write(dict.get(), &out);
   return out;
 }
 
 // Fills |channel_info| from the destination and state of |socket|.
-void FillChannelInfo(const CastSocket& socket, ChannelInfo* channel_info) {
+void FillChannelInfo(const CastSocketImpl& socket, ChannelInfo* channel_info) {
   DCHECK(channel_info);
   channel_info->channel_id = socket.id();
   channel_info->url = socket.CastUrl();
   const net::IPEndPoint& ip_endpoint = socket.ip_endpoint();
   channel_info->connect_info.ip_address = ip_endpoint.ToStringWithoutPort();
   channel_info->connect_info.port = ip_endpoint.port();
   channel_info->connect_info.auth = socket.channel_auth();
   channel_info->ready_state = socket.ready_state();
   channel_info->error_state = socket.error_state();
 }
@@ skipping 52 matching lines @@
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<CastChannelAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CastChannelAPI>*
 CastChannelAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
-scoped_ptr<CastSocket> CastChannelAPI::CreateCastSocket(
-    const std::string& extension_id, const net::IPEndPoint& ip_endpoint,
-    ChannelAuthType channel_auth, const base::TimeDelta& timeout) {
+scoped_ptr<CastSocketImpl> CastChannelAPI::CreateCastSocketImpl(
+    const std::string& extension_id,
+    const net::IPEndPoint& ip_endpoint,
+    ChannelAuthType channel_auth,
+    const base::TimeDelta& timeout) {
   if (socket_for_test_.get()) {
     return socket_for_test_.Pass();
   } else {
-    return scoped_ptr<CastSocket>(
-        new CastSocket(extension_id,
-                       ip_endpoint,
-                       channel_auth,
-                       this,
-                       ExtensionsBrowserClient::Get()->GetNetLog(),
-                       timeout,
-                       logger_));
+    return scoped_ptr<CastSocketImpl>(
+        new CastSocketImpl(extension_id,
+                           ip_endpoint,
+                           channel_auth,
+                           this,
+                           ExtensionsBrowserClient::Get()->GetNetLog(),
+                           timeout,
+                           logger_));
   }
 }
 
-void CastChannelAPI::SetSocketForTest(scoped_ptr<CastSocket> socket_for_test) {
+void CastChannelAPI::SetSocketForTest(
+    scoped_ptr<CastSocketImpl> socket_for_test) {
   socket_for_test_ = socket_for_test.Pass();
 }
 
-void CastChannelAPI::OnError(const CastSocket* socket,
+void CastChannelAPI::OnError(const CastSocketImpl* socket,
                              cast_channel::ChannelError error_state,
                              const cast_channel::LastErrors& last_errors) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ChannelInfo channel_info;
   FillChannelInfo(*socket, &channel_info);
   channel_info.error_state = error_state;
   ErrorInfo error_info;
   FillErrorInfo(error_state, last_errors, &error_info);
   scoped_ptr<base::ListValue> results =
       OnError::Create(channel_info, error_info);
   scoped_ptr<Event> event(new Event(OnError::kEventName, results.Pass()));
   extensions::EventRouter::Get(browser_context_)
       ->DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
 }
 
-void CastChannelAPI::OnMessage(const CastSocket* socket,
+void CastChannelAPI::OnMessage(const CastSocketImpl* socket,
                                const MessageInfo& message_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ChannelInfo channel_info;
   FillChannelInfo(*socket, &channel_info);
   scoped_ptr<base::ListValue> results =
     OnMessage::Create(channel_info, message_info);
   VLOG(1) << "Sending message " << ParamToString(message_info)
           << " to channel " << ParamToString(channel_info);
   scoped_ptr<Event> event(new Event(OnMessage::kEventName, results.Pass()));
   extensions::EventRouter::Get(browser_context_)
       ->DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
   : manager_(NULL), error_(cast_channel::CHANNEL_ERROR_NONE) { }
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
-  manager_ = ApiResourceManager<CastSocket>::Get(browser_context());
+  manager_ = ApiResourceManager<CastSocketImpl>::Get(browser_context());
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return error_ == cast_channel::CHANNEL_ERROR_NONE;
 }
 
-CastSocket* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
+CastSocketImpl* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
     int channel_id) {
-  CastSocket* socket = GetSocket(channel_id);
+  CastSocketImpl* socket = GetSocket(channel_id);
   if (!socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   }
   return socket;
 }
 
-int CastChannelAsyncApiFunction::AddSocket(CastSocket* socket) {
+int CastChannelAsyncApiFunction::AddSocket(CastSocketImpl* socket) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(socket);
   DCHECK(manager_);
   const int id = manager_->Add(socket);
   socket->set_id(id);
   return id;
 }
 
 void CastChannelAsyncApiFunction::RemoveSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   manager_->Remove(extension_->id(), channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromSocket(
-    const CastSocket& socket) {
+    const CastSocketImpl& socket) {
   ChannelInfo channel_info;
   FillChannelInfo(socket, &channel_info);
   error_ = socket.error_state();
   SetResultFromChannelInfo(channel_info);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromError(int channel_id,
                                                      ChannelError error) {
   ChannelInfo channel_info;
   channel_info.channel_id = channel_id;
   channel_info.url = "";
   channel_info.ready_state = cast_channel::READY_STATE_CLOSED;
   channel_info.error_state = error;
   channel_info.connect_info.ip_address = "";
   channel_info.connect_info.port = 0;
   channel_info.connect_info.auth = cast_channel::CHANNEL_AUTH_TYPE_SSL;
   SetResultFromChannelInfo(channel_info);
   error_ = error;
 }
 
-CastSocket* CastChannelAsyncApiFunction::GetSocket(int channel_id) {
+CastSocketImpl* CastChannelAsyncApiFunction::GetSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   return manager_->Get(extension_->id(), channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromChannelInfo(
     const ChannelInfo& channel_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SetResult(channel_info.ToValue().release());
 }
@@ skipping 100 matching lines @@
     return false;
   }
   channel_auth_ = connect_info_->auth;
   ip_endpoint_.reset(ParseConnectInfo(*connect_info_));
   return true;
 }
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
-  scoped_ptr<CastSocket> socket = api_->CreateCastSocket(
+  scoped_ptr<CastSocketImpl> socket = api_->CreateCastSocketImpl(
       extension_->id(),
       *ip_endpoint_,
       channel_auth_,
       base::TimeDelta::FromMilliseconds(connect_info_->timeout.get()
                                             ? *connect_info_->timeout
                                             : kDefaultConnectTimeoutMillis));
   new_channel_id_ = AddSocket(socket.release());
-  CastSocket* new_socket = GetSocket(new_channel_id_);
+  CastSocketImpl* new_socket = GetSocket(new_channel_id_);
   api_->GetLogger()->LogNewSocketEvent(*new_socket);
   new_socket->Connect(base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
 void CastChannelOpenFunction::OnOpen(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "Connect finished, OnOpen invoked.";
-  CastSocket* socket = GetSocket(new_channel_id_);
+  CastSocketImpl* socket = GetSocket(new_channel_id_);
   if (!socket) {
     SetResultFromError(new_channel_id_,
                        cast_channel::CHANNEL_ERROR_CONNECT_ERROR);
   } else {
     SetResultFromSocket(*socket);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelSendFunction::CastChannelSendFunction() { }
@@ skipping 20 matching lines @@
     case base::Value::TYPE_BINARY:
       break;
     default:
       SetError("Invalid type of message_info.data");
       return false;
   }
   return true;
 }
 
 void CastChannelSendFunction::AsyncWorkStart() {
-  CastSocket* socket = GetSocketOrCompleteWithError(
-      params_->channel.channel_id);
+  CastSocketImpl* socket =
+      GetSocketOrCompleteWithError(params_->channel.channel_id);
   if (socket)
     socket->SendMessage(params_->message,
                         base::Bind(&CastChannelSendFunction::OnSend, this));
 }
 
 void CastChannelSendFunction::OnSend(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int channel_id = params_->channel.channel_id;
-  CastSocket* socket = GetSocket(channel_id);
+  CastSocketImpl* socket = GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelCloseFunction::CastChannelCloseFunction() { }
 
 CastChannelCloseFunction::~CastChannelCloseFunction() { }
 
 bool CastChannelCloseFunction::Prepare() {
   params_ = Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void CastChannelCloseFunction::AsyncWorkStart() {
-  CastSocket* socket = GetSocketOrCompleteWithError(
-      params_->channel.channel_id);
+  CastSocketImpl* socket =
+      GetSocketOrCompleteWithError(params_->channel.channel_id);
   if (socket)
     socket->Close(base::Bind(&CastChannelCloseFunction::OnClose, this));
 }
 
 void CastChannelCloseFunction::OnClose(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "CastChannelCloseFunction::OnClose result = " << result;
   int channel_id = params_->channel.channel_id;
-  CastSocket* socket = GetSocket(channel_id);
+  CastSocketImpl* socket = GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     RemoveSocket(channel_id);
     socket = NULL;
   }
   AsyncWorkCompleted();
@@ skipping 24 matching lines @@
   } else {
     SetError("Unable to get logs.");
   }
 
   api_->GetLogger()->Reset();
 
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions