[cast_channel] Make CastSocketService a global leaky singleton

extensions/browser/api/cast_channel/cast_channel_api.cc

Index: extensions/browser/api/cast_channel/cast_channel_api.cc
diff --git a/extensions/browser/api/cast_channel/cast_channel_api.cc b/extensions/browser/api/cast_channel/cast_channel_api.cc
index 811b681d1c26870683b2a990fc7b9f5aa08702c8..43f70152181ea8ec203bb278f78cc16f1bed6994 100644
--- a/extensions/browser/api/cast_channel/cast_channel_api.cc
+++ b/extensions/browser/api/cast_channel/cast_channel_api.cc
@@ -22,7 +22,6 @@
 #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"
@@ -137,6 +136,18 @@ void CastChannelAPI::SendEvent(const std::string& extension_id,
   }
 }
 
+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;
@@ -168,9 +179,7 @@ CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
 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;
 }
@@ -277,14 +286,8 @@ void CastChannelOpenFunction::AsyncWorkStart() {
   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(),
@@ -422,20 +425,23 @@ void CastChannelCloseFunction::OnClose(int result) {
   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);
@@ -444,19 +450,22 @@ void CastChannelOpenFunction::CastMessageHandler::OnError(
   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);
@@ -465,14 +474,21 @@ void CastChannelOpenFunction::CastMessageHandler::OnMessage(
   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