[cast_channel] Implement CastSocketService::OpenSocket()

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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 101 matching lines @@
 }
 
 bool IsValidConnectInfoIpAddress(const ConnectInfo& connect_info) {
   net::IPAddress ip_address;
   return ip_address.AssignFromIPLiteral(connect_info.ip_address);
 }
 
 }  // namespace
 
 CastChannelAPI::CastChannelAPI(content::BrowserContext* context)
-    : browser_context_(context), logger_(new Logger()) {
+    : browser_context_(context) {
   DCHECK(browser_context_);
 }
 
 // static
 CastChannelAPI* CastChannelAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<CastChannelAPI>::Get(context);
 }
 
-scoped_refptr<Logger> CastChannelAPI::GetLogger() {
-  return logger_;
-}
-
 void CastChannelAPI::SendEvent(const std::string& extension_id,
                                std::unique_ptr<Event> event) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EventRouter* event_router = EventRouter::Get(GetBrowserContext());
   if (event_router) {
     event_router->DispatchEventToExtension(extension_id, std::move(event));
   }
 }
 
 static base::LazyInstance<
@@ skipping 64 matching lines @@
   SetResultFromChannelInfo(channel_info);
   SetError("Channel error = " + base::IntToString(error));
 }
 
 void CastChannelAsyncApiFunction::SetResultFromChannelInfo(
     const ChannelInfo& channel_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SetResult(channel_info.ToValue());
 }
 
-CastChannelOpenFunction::CastChannelOpenFunction()
-    : new_channel_id_(0) {
-}
+CastChannelOpenFunction::CastChannelOpenFunction() {}
 
 CastChannelOpenFunction::~CastChannelOpenFunction() { }
 
 net::IPEndPoint* CastChannelOpenFunction::ParseConnectInfo(
     const ConnectInfo& connect_info) {
   net::IPAddress ip_address;
   CHECK(ip_address.AssignFromIPLiteral(connect_info.ip_address));
   return new net::IPEndPoint(ip_address,
                              static_cast<uint16_t>(connect_info.port));
 }
@@ skipping 39 matching lines @@
   }
 
   ip_endpoint_.reset(ParseConnectInfo(connect_info));
   return true;
 }
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
   const ConnectInfo& connect_info = params_->connect_info;
-  CastSocket* socket;
+
   std::unique_ptr<CastSocket> test_socket = api_->GetSocketForTest();
-  if (test_socket.get()) {
-    socket = test_socket.release();
-  } else {
-    socket = new CastSocketImpl(
-        *ip_endpoint_, ExtensionsBrowserClient::Get()->GetNetLog(),
-        base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
-                                              ? *connect_info.timeout
-                                              : kDefaultConnectTimeoutMillis),
-        liveness_timeout_, ping_interval_, api_->GetLogger(),
-        connect_info.capabilities.get() ? *connect_info.capabilities
-                                        : CastDeviceCapability::NONE);
-  }
-  new_channel_id_ = cast_socket_service_->AddSocket(base::WrapUnique(socket));
+  if (test_socket.get())
+    cast_socket_service_->SetSocketForTest(std::move(test_socket));
 
   auto* observer = cast_socket_service_->GetObserver(extension_->id());
   if (!observer) {
     observer = cast_socket_service_->AddObserver(
         extension_->id(), base::MakeUnique<CastMessageHandler>(
                               base::Bind(&CastChannelAPI::SendEvent,
                                          api_->AsWeakPtr(), extension_->id()),
-                              api_->GetLogger()));
+                              cast_socket_service_->GetLogger()));
   }
 
-  socket->AddObserver(observer);
-  // Construct read delegates.
-  socket->Connect(base::Bind(&CastChannelOpenFunction::OnOpen, this));
+  cast_socket_service_->OpenSocket(
+      *ip_endpoint_, ExtensionsBrowserClient::Get()->GetNetLog(),
+      base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
+                                            ? *connect_info.timeout
+                                            : kDefaultConnectTimeoutMillis),
+      liveness_timeout_, ping_interval_,
+      connect_info.capabilities.get() ? *connect_info.capabilities
+                                      : CastDeviceCapability::NONE,
+      base::Bind(&CastChannelOpenFunction::OnOpen, this), observer);
 }
 
-void CastChannelOpenFunction::OnOpen(ChannelError result) {
+void CastChannelOpenFunction::OnOpen(int channel_id, ChannelError result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "Connect finished, OnOpen invoked.";
   // TODO: If we failed to open the CastSocket, we may want to clean up here,
   // rather than relying on the extension to call close(). This can be done by
   // calling RemoveSocket() and api_->GetLogger()->ClearLastError(channel_id).
   if (result != ChannelError::UNKNOWN) {
-    CastSocket* socket = cast_socket_service_->GetSocket(new_channel_id_);
+    CastSocket* socket = cast_socket_service_->GetSocket(channel_id);
     CHECK(socket);
     SetResultFromSocket(*socket);
   } else {
     // The socket is being destroyed.
-    SetResultFromError(new_channel_id_,
-                       api::cast_channel::CHANNEL_ERROR_UNKNOWN);
+    SetResultFromError(channel_id, api::cast_channel::CHANNEL_ERROR_UNKNOWN);
   }
 
   AsyncWorkCompleted();
 }
 
 CastChannelSendFunction::CastChannelSendFunction() { }
 
 CastChannelSendFunction::~CastChannelSendFunction() { }
 
 bool CastChannelSendFunction::Prepare() {
@@ skipping 87 matching lines @@
   VLOG(1) << "CastChannelCloseFunction::OnClose result = " << result;
   int channel_id = params_->channel.channel_id;
   CastSocket* socket = cast_socket_service_->GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
                        api::cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     cast_socket_service_->RemoveSocket(channel_id);
-    api_->GetLogger()->ClearLastError(channel_id);
+    cast_socket_service_->GetLogger()->ClearLastError(channel_id);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelOpenFunction::CastMessageHandler::CastMessageHandler(
     const EventDispatchCallback& ui_dispatch_cb,
     scoped_refptr<Logger> logger)
     : ui_dispatch_cb_(ui_dispatch_cb), logger_(logger) {
   DCHECK(logger_);
 }
@@ skipping 38 matching lines @@
       OnMessage::Create(channel_info, message_info);
   std::unique_ptr<Event> event(new Event(events::CAST_CHANNEL_ON_MESSAGE,
                                          OnMessage::kEventName,
                                          std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
 }  // namespace extensions