[mDns] Make DnsSdRegistry a leaky singleton

chrome/browser/extensions/api/mdns/mdns_api.cc

 // Copyright 2013 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/extensions/api/mdns/mdns_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
@@ skipping 20 matching lines @@
 bool IsServiceTypeWhitelisted(const std::string& service_type) {
   return service_type == kCastServiceType ||
          service_type == kPrivetServiceType ||
          service_type == kTestServiceType;
 }
 
 }  // namespace
 
 using DnsSdRegistry = media_router::DnsSdRegistry;
 
-MDnsAPI::MDnsAPI(content::BrowserContext* context) : browser_context_(context) {
+MDnsAPI::MDnsAPI(content::BrowserContext* context)
+    : browser_context_(context), dns_sd_registry_(nullptr) {
   DCHECK(browser_context_);
   extensions::EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
   event_router->RegisterObserver(this, mdns::OnServiceList::kEventName);
 }
 
 MDnsAPI::~MDnsAPI() {
-  if (dns_sd_registry_.get()) {
+  if (dns_sd_registry_) {
     dns_sd_registry_->RemoveObserver(this);
   }
 }
 
 // static
 MDnsAPI* MDnsAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<MDnsAPI>::Get(context);
 }
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<MDnsAPI>>::DestructorAtExit g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MDnsAPI>* MDnsAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
-void MDnsAPI::SetDnsSdRegistryForTesting(
-    std::unique_ptr<DnsSdRegistry> dns_sd_registry) {
-  dns_sd_registry_ = std::move(dns_sd_registry);
-  if (dns_sd_registry_.get())
+void MDnsAPI::SetDnsSdRegistryForTesting(DnsSdRegistry* dns_sd_registry) {
+  dns_sd_registry_ = dns_sd_registry;
+  if (dns_sd_registry_)
     dns_sd_registry_->AddObserver(this);
 }
 
 void MDnsAPI::ForceDiscovery() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DnsSdRegistry* registry = dns_sd_registry();
   return registry->ForceDiscovery();
 }
 
 DnsSdRegistry* MDnsAPI::dns_sd_registry() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!dns_sd_registry_.get()) {
-    dns_sd_registry_.reset(new media_router::DnsSdRegistry());
+  if (!dns_sd_registry_) {
+    dns_sd_registry_ = media_router::DnsSdRegistry::GetInstance();
     dns_sd_registry_->AddObserver(this);
   }
-  return dns_sd_registry_.get();
+  return dns_sd_registry_;
 }
 
 void MDnsAPI::OnListenerAdded(const EventListenerInfo& details) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateMDnsListeners();
 }
 
 void MDnsAPI::OnListenerRemoved(const EventListenerInfo& details) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateMDnsListeners();
@@ skipping 171 matching lines @@
 AsyncApiFunction::ResponseAction MdnsForceDiscoveryFunction::Run() {
   MDnsAPI* api = MDnsAPI::Get(browser_context());
   if (!api) {
     return RespondNow(Error("Unknown error."));
   }
   api->ForceDiscovery();
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions