[cast_channel] Make CastSocketService a global leaky singleton

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 "components/cast_channel/cast_channel_enum.h"
 #include "components/cast_channel/cast_message_util.h"
 #include "components/cast_channel/cast_socket.h"
 #include "components/cast_channel/cast_socket_service.h"
-#include "components/cast_channel/cast_socket_service_factory.h"
 #include "components/cast_channel/keep_alive_delegate.h"
 #include "components/cast_channel/logger.h"
 #include "components/cast_channel/proto/cast_channel.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/cast_channel/cast_channel_enum_util.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/event_router.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
@@ skipping 94 matching lines @@
 
 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));
   }
 }
 
+cast_channel::CastSocket::Observer* CastChannelAPI::GetObserver(
+    const std::string& extension_id,
+    scoped_refptr<cast_channel::Logger> logger) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!observer_) {
+    observer_.reset(new CastMessageHandler(
+        base::Bind(&CastChannelAPI::SendEvent, this->AsWeakPtr()), logger));
+  }
+  observer_->RegisterExtensionId(extension_id);
+  return observer_.get();
+}
+
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<CastChannelAPI>>::DestructorAtExit g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CastChannelAPI>*
 CastChannelAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
@@ skipping 11 matching lines @@
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
     : cast_socket_service_(nullptr) {}
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
-  cast_socket_service_ =
-      cast_channel::CastSocketServiceFactory::GetForBrowserContext(
-          browser_context());
+  cast_socket_service_ = cast_channel::CastSocketService::GetInstance();
   DCHECK(cast_socket_service_);
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return GetError().empty();
 }
 
 void CastChannelAsyncApiFunction::SetResultFromSocket(
     const CastSocket& socket) {
@@ skipping 86 matching lines @@
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
   const ConnectInfo& connect_info = params_->connect_info;
 
   std::unique_ptr<CastSocket> test_socket = api_->GetSocketForTest();
   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()),
-                              cast_socket_service_->GetLogger()));
-  }
+  auto* observer =
+      api_->GetObserver(extension_->id(), cast_socket_service_->GetLogger());
 
   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);
@@ skipping 117 matching lines @@
                        api::cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     cast_socket_service_->RemoveSocket(channel_id);
     cast_socket_service_->GetLogger()->ClearLastError(channel_id);
   }
   AsyncWorkCompleted();
 }
 
-CastChannelOpenFunction::CastMessageHandler::CastMessageHandler(
+CastChannelAPI::CastMessageHandler::CastMessageHandler(
     const EventDispatchCallback& ui_dispatch_cb,
     scoped_refptr<Logger> logger)
     : ui_dispatch_cb_(ui_dispatch_cb), logger_(logger) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(logger_);
 }
 
-CastChannelOpenFunction::CastMessageHandler::~CastMessageHandler() {
+CastChannelAPI::CastMessageHandler::~CastMessageHandler() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  cast_channel::CastSocketService::GetInstance()->RemoveObserver(this);
 }
 
-void CastChannelOpenFunction::CastMessageHandler::OnError(
+void CastChannelAPI::CastMessageHandler::OnError(
     const cast_channel::CastSocket& socket,
     ChannelError error_state) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   ChannelInfo channel_info;
   FillChannelInfo(socket, &channel_info);
   channel_info.error_state = api::cast_channel::ToChannelError(error_state);
   ErrorInfo error_info;
   FillErrorInfo(channel_info.error_state, logger_->GetLastError(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_, base::Passed(std::move(event))));
+  for (const auto& extension_id : extension_ids_) {
+    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_, extension_id,
+                                       base::Passed(std::move(event))));
+  }
 }
 
-void CastChannelOpenFunction::CastMessageHandler::OnMessage(
+void CastChannelAPI::CastMessageHandler::OnMessage(
     const cast_channel::CastSocket& socket,
     const CastMessage& message) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   MessageInfo message_info;
   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_, base::Passed(std::move(event))));
+  for (const auto& extension_id : extension_ids_) {
+    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_, extension_id,
+                                       base::Passed(std::move(event))));
+  }
+}
+
+void CastChannelAPI::CastMessageHandler::RegisterExtensionId(

[mark a. foltz, 2017/07/10 20:43:05]

Right now there are only two extension ids that are whitelisted for the
cast.channel API [1], and basically only one can be loaded at a time based on
the --load-media-router-component-extension flag.

Unless anyone knows a case where two different extensions are using the API in
the same profile, I would be okay simplifying this to allow one extension id at
a time.

Derek, WDYT?

[1]
https://cs.chromium.org/chromium/src/extensions/common/api/_permission_featur...

[imcheng, 2017/07/11 01:31:15]

Changing to allow one extension at a time sounds fine.

[zhaobin, 2017/07/12 21:58:08]

Done.

+    const std::string& extension_id) {
+  extension_ids_.insert(extension_id);
 }
 
 }  // namespace extensions