[cast_channel] Make CastSocket not inherit from ApiResource

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>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/cast_socket.h"
+#include "extensions/browser/api/cast_channel/cast_socket_service.h"
+#include "extensions/browser/api/cast_channel/cast_socket_service_factory.h"
 #include "extensions/browser/api/cast_channel/keep_alive_delegate.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "extensions/common/api/cast_channel/logging.pb.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 
 // Default timeout interval for connection setup.
@@ skipping 124 matching lines @@
     std::unique_ptr<base::Timer> timer) {
   injected_timeout_timer_ = std::move(timer);
 }
 
 std::unique_ptr<base::Timer> CastChannelAPI::GetInjectedTimeoutTimerForTest() {
   return std::move(injected_timeout_timer_);
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
-CastChannelAsyncApiFunction::CastChannelAsyncApiFunction() {
-}
+CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
+    : cast_socket_service_(nullptr) {}
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
-  DCHECK(ApiResourceManager<CastSocket>::Get(browser_context()));
-  sockets_ = ApiResourceManager<CastSocket>::Get(browser_context())->data_;
-  DCHECK(sockets_);
+  cast_socket_service_ =
+      api::cast_channel::CastSocketServiceFactory::GetInstance()
+          ->GetForBrowserContext(browser_context());
+  DCHECK(cast_socket_service_);
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return GetError().empty();
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
     int channel_id) {
   CastSocket* socket = GetSocket(channel_id);
   if (!socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   }
   return socket;
 }
 
-int CastChannelAsyncApiFunction::AddSocket(CastSocket* socket) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(socket);
-  const int id = sockets_->Add(socket);
-  socket->set_id(id);
-  return id;
+int CastChannelAsyncApiFunction::AddSocket(std::unique_ptr<CastSocket> socket) {
+  auto* sockets = cast_socket_service_->GetOrCreateSocketRegistry();
+  return sockets->AddSocket(std::move(socket));
 }
 
 void CastChannelAsyncApiFunction::RemoveSocket(int channel_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  sockets_->Remove(extension_->id(), channel_id);
+  auto* sockets = cast_socket_service_->GetOrCreateSocketRegistry();
+  sockets->RemoveSocket(channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromSocket(
     const CastSocket& socket) {
   ChannelInfo channel_info;
   FillChannelInfo(socket, &channel_info);
   ChannelError error = socket.error_state();
   if (error != cast_channel::CHANNEL_ERROR_NONE) {
     SetError("Channel socket error = " + base::IntToString(error));
   }
   SetResultFromChannelInfo(channel_info);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromError(int channel_id,
                                                      ChannelError error) {
   ChannelInfo channel_info;
   channel_info.channel_id = channel_id;
   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_VERIFIED;
   SetResultFromChannelInfo(channel_info);
   SetError("Channel error = " + base::IntToString(error));
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocket(int channel_id) const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return sockets_->Get(extension_->id(), channel_id);
+  auto* sockets = cast_socket_service_->GetOrCreateSocketRegistry();
+  return sockets->GetSocket(channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromChannelInfo(
     const ChannelInfo& channel_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SetResult(channel_info.ToValue());
 }
 
 CastChannelOpenFunction::CastChannelOpenFunction()
     : new_channel_id_(0) {
@@ skipping 66 matching lines @@
     socket = new cast_channel::CastSocketImpl(
         extension_->id(), *ip_endpoint_, channel_auth_,
         ExtensionsBrowserClient::Get()->GetNetLog(),
         base::TimeDelta::FromMilliseconds(connect_info.timeout.get()
                                               ? *connect_info.timeout
                                               : kDefaultConnectTimeoutMillis),
         liveness_timeout_ > base::TimeDelta(), api_->GetLogger(),
         connect_info.capabilities.get() ? *connect_info.capabilities
                                         : CastDeviceCapability::NONE);
   }
-  new_channel_id_ = AddSocket(socket);
+  new_channel_id_ = AddSocket(base::WrapUnique(socket));
 
   // Construct read delegates.
   std::unique_ptr<api::cast_channel::CastTransport::Delegate> delegate(
       base::MakeUnique<CastMessageHandler>(
-          base::Bind(&CastChannelAPI::SendEvent, api_->AsWeakPtr()), socket,
-          api_->GetLogger()));
+          base::Bind(&CastChannelAPI::SendEvent, api_->AsWeakPtr(),
+                     extension_->id()),
+          socket, api_->GetLogger()));
   if (socket->keep_alive()) {
     // Wrap read delegate in a KeepAliveDelegate for timeout handling.
     api::cast_channel::KeepAliveDelegate* keep_alive =
         new api::cast_channel::KeepAliveDelegate(
             socket, api_->GetLogger(), std::move(delegate), ping_interval_,
             liveness_timeout_);
     std::unique_ptr<base::Timer> injected_timer =
         api_->GetInjectedTimeoutTimerForTest();
     if (injected_timer) {
       keep_alive->SetTimersForTest(base::MakeUnique<base::Timer>(false, false),
@@ skipping 151 matching lines @@
   ErrorInfo error_info;
   FillErrorInfo(error_state, logger_->GetLastErrors(socket_->id()),
                 &error_info);
 
   std::unique_ptr<base::ListValue> results =
       OnError::Create(channel_info, error_info);
   std::unique_ptr<Event> event(new Event(
       events::CAST_CHANNEL_ON_ERROR, OnError::kEventName, std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(ui_dispatch_cb_, socket_->owner_extension_id(),
-                 base::Passed(std::move(event))));
+      base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::OnMessage(
     const CastMessage& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   MessageInfo message_info;
   cast_channel::CastMessageToMessageInfo(message, &message_info);
   ChannelInfo channel_info;
   FillChannelInfo(*socket_, &channel_info);
   VLOG(1) << "Received message " << ParamToString(message_info)
           << " on channel " << ParamToString(channel_info);
 
   std::unique_ptr<base::ListValue> results =
       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_, socket_->owner_extension_id(),
-                 base::Passed(std::move(event))));
+      base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::Start() {
 }
 
 }  // namespace extensions