[cast_channel] Make CastSocketService a global leaky singleton

components/cast_channel/cast_socket_service.cc

 // Copyright 2017 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 "components/cast_channel/cast_socket_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "components/cast_channel/cast_socket.h"
 #include "components/cast_channel/logger.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 10 matching lines @@
 // Liveness timeout for connect calls, in milliseconds. If no message is
 // received from the receiver during kConnectLivenessTimeoutSecs, it is
 // considered gone.
 const int kConnectLivenessTimeoutSecs = kPingIntervalInSecs * 2;
 }  // namespace
 
 namespace cast_channel {
 
 int CastSocketService::last_channel_id_ = 0;
 
-CastSocketService::CastSocketService()
-    : RefcountedKeyedService(
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)),
-      logger_(new Logger()) {
+CastSocketService::CastSocketService() : logger_(new Logger()) {
   DETACH_FROM_THREAD(thread_checker_);
 }
 
-CastSocketService::~CastSocketService() {
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+// This is a leaky singleton and the dtor won't be called.
+CastSocketService::~CastSocketService() = default;
+
+// static
+CastSocketService* CastSocketService::GetInstance() {
+  return base::Singleton<CastSocketService,
+                         base::LeakySingletonTraits<CastSocketService>>::get();
 }
 
 scoped_refptr<Logger> CastSocketService::GetLogger() {
   return logger_;
 }
 
 CastSocket* CastSocketService::AddSocket(std::unique_ptr<CastSocket> socket) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(socket);
   int id = ++last_channel_id_;
@@ skipping 71 matching lines @@
                                   CastSocket::Observer* observer) {
   auto connect_timeout = base::TimeDelta::FromSeconds(kConnectTimeoutSecs);
   auto ping_interval = base::TimeDelta::FromSeconds(kPingIntervalInSecs);
   auto liveness_timeout =
       base::TimeDelta::FromSeconds(kConnectLivenessTimeoutSecs);
   return OpenSocket(ip_endpoint, net_log, connect_timeout, liveness_timeout,
                     ping_interval, CastDeviceCapability::NONE, open_cb,
                     observer);
 }
 
-CastSocket::Observer* CastSocketService::GetObserver(const std::string& id) {
-  auto it = socket_observer_map_.find(id);
-  return it == socket_observer_map_.end() ? nullptr : it->second.get();
-}
-
-CastSocket::Observer* CastSocketService::AddObserver(
-    const std::string& id,
-    std::unique_ptr<CastSocket::Observer> observer) {
-  CastSocket::Observer* observer_ptr = observer.get();
-  socket_observer_map_.insert(std::make_pair(id, std::move(observer)));
-  return observer_ptr;
+void CastSocketService::RemoveObserver(CastSocket::Observer* observer) {
+  for (auto& socket_it : sockets_)
+    socket_it.second->RemoveObserver(observer);
 }
 
 void CastSocketService::SetSocketForTest(
     std::unique_ptr<cast_channel::CastSocket> socket_for_test) {
   socket_for_test_ = std::move(socket_for_test);
 }
 
-void CastSocketService::ShutdownOnUIThread() {}
-
 }  // namespace cast_channel