[cast_channel] Make CastSocketService a global leaky singleton

chrome/browser/media/router/discovery/mdns/cast_media_sink_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 "chrome/browser/media/router/discovery/mdns/cast_media_sink_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/media_router/discovery/media_sink_internal.h"
 #include "components/cast_channel/cast_socket_service.h"
-#include "components/cast_channel/cast_socket_service_factory.h"
 #include "components/net_log/chrome_net_log.h"
 #include "content/public/common/content_client.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_address.h"
 
 namespace {
 
-constexpr char kObserverId[] = "browser_observer_id";
-
 enum ErrorType {
   NONE,
   NOT_CAST_DEVICE,
   MISSING_ID,
   MISSING_FRIENDLY_NAME,
   MISSING_OR_INVALID_IP_ADDRESS,
   MISSING_OR_INVALID_PORT,
 };
 
 ErrorType CreateCastMediaSink(const media_router::DnsSdService& service,
@@ skipping 52 matching lines @@
 }  // namespace
 
 namespace media_router {
 
 // static
 const char CastMediaSinkService::kCastServiceType[] = "_googlecast._tcp.local";
 
 CastMediaSinkService::CastMediaSinkService(
     const OnSinksDiscoveredCallback& callback,
     content::BrowserContext* browser_context)
-    : MediaSinkServiceBase(callback) {
+    : MediaSinkServiceBase(callback),
+      cast_socket_service_(cast_channel::CastSocketService::GetInstance()) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  cast_socket_service_ = cast_channel::CastSocketServiceFactory::GetInstance()
-                             ->GetForBrowserContext(browser_context);
   DCHECK(cast_socket_service_);
 }
 
 CastMediaSinkService::CastMediaSinkService(
     const OnSinksDiscoveredCallback& callback,
     cast_channel::CastSocketService* cast_socket_service)
     : MediaSinkServiceBase(callback),
       cast_socket_service_(cast_socket_service) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(cast_socket_service_);
@@ skipping 55 matching lines @@
         base::Bind(&CastMediaSinkService::OpenChannelOnIOThread, this, service,
                    net::IPEndPoint(ip_address, host_port_pair.port())));
   }
 
   MediaSinkServiceBase::RestartTimer();
 }
 
 void CastMediaSinkService::OpenChannelOnIOThread(
     const DnsSdService& service,
     const net::IPEndPoint& ip_endpoint) {
-  auto* observer = cast_socket_service_->GetObserver(kObserverId);
-  if (!observer) {
-    observer = new CastSocketObserver();
-    cast_socket_service_->AddObserver(kObserverId, base::WrapUnique(observer));
-  }
+  if (!observer_)
+    observer_.reset(new CastSocketObserver());
 
   cast_socket_service_->OpenSocket(
       ip_endpoint, g_browser_process->net_log(),
       base::Bind(&CastMediaSinkService::OnChannelOpenedOnIOThread, this,
                  service),
-      observer);
+      observer_.get());
 }
 
 void CastMediaSinkService::OnChannelOpenedOnIOThread(
     const DnsSdService& service,
     int channel_id,
     cast_channel::ChannelError channel_error) {
   if (channel_error != cast_channel::ChannelError::NONE) {
     DVLOG(2) << "Fail to open channel " << service.ip_address << ": "
              << service.service_host_port
              << " [ChannelError]: " << (int)channel_error;
@@ skipping 28 matching lines @@
     DVLOG(2) << "Service data not found in current service data list...";
     return;
   }
 
   DVLOG(2) << "Ading sink to current_sinks_ [id]: " << sink.sink().id();
   current_sinks_.insert(sink);
   MediaSinkServiceBase::RestartTimer();
 }
 
 CastMediaSinkService::CastSocketObserver::CastSocketObserver() {}
-CastMediaSinkService::CastSocketObserver::~CastSocketObserver() {}
+CastMediaSinkService::CastSocketObserver::~CastSocketObserver() {
+  cast_channel::CastSocketService::GetInstance()->RemoveObserver(this);
+}
 
 void CastMediaSinkService::CastSocketObserver::OnError(
     const cast_channel::CastSocket& socket,
     cast_channel::ChannelError error_state) {
   DVLOG(1) << "OnError [ip_endpoint]: " << socket.ip_endpoint().ToString()
            << " [error_state]: "
            << cast_channel::ChannelErrorToString(error_state);
 }
 
 void CastMediaSinkService::CastSocketObserver::OnMessage(
     const cast_channel::CastSocket& socket,
     const cast_channel::CastMessage& message) {}
 
 }  // namespace media_router