[mDns] Make DnsSdRegistry a leaky singleton

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

 // Copyright 2015 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 <stddef.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/browser/media/router/discovery/mdns/mock_dns_sd_registry.h"
 #include "chrome/common/extensions/api/mdns.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using media_router::MockDnsSdRegistry;
 using testing::_;
 using testing::Return;
 using testing::ReturnRef;
 
 namespace extensions {
 namespace {
 
 const char kExtId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
 const char kService1[] = "service1";
 const char kService2[] = "service2";
@@ skipping 45 matching lines @@
   return base::MakeUnique<extensions::EventRouter>(
       context, ExtensionPrefs::Get(context));
 }
 
 // For ExtensionService interface when it requires a path that is not used.
 base::FilePath bogus_file_pathname(const std::string& name) {
   return base::FilePath(FILE_PATH_LITERAL("//foobar_nonexistent"))
       .AppendASCII(name);
 }
 
-class MockDnsSdRegistry : public media_router::DnsSdRegistry {
- public:
-  explicit MockDnsSdRegistry(extensions::MDnsAPI* api) : api_(api) {}
-  virtual ~MockDnsSdRegistry() {}
-
-  MOCK_METHOD1(AddObserver, void(DnsSdObserver* observer));
-  MOCK_METHOD1(RemoveObserver, void(DnsSdObserver* observer));
-  MOCK_METHOD1(RegisterDnsSdListener, void(const std::string& service_type));
-  MOCK_METHOD1(UnregisterDnsSdListener, void(const std::string& service_type));
-  MOCK_METHOD1(Publish, void(const std::string&));
-  MOCK_METHOD0(ForceDiscovery, void(void));
-
-  void DispatchMDnsEvent(const std::string& service_type,
-                         const DnsSdServiceList& services) {
-    api_->OnDnsSdEvent(service_type, services);
-  }
-
- private:
-  media_router::DnsSdRegistry::DnsSdObserver* api_;
-};
-
 class MockEventRouter : public EventRouter {
  public:
   explicit MockEventRouter(content::BrowserContext* browser_context,
                            ExtensionPrefs* extension_prefs)
       : EventRouter(browser_context, extension_prefs) {}
   virtual ~MockEventRouter() {}
 
   virtual void BroadcastEvent(std::unique_ptr<Event> event) {
     BroadcastEventPtr(event.get());
   }
@@ skipping 72 matching lines @@
     MDnsAPI::GetFactoryInstance()->SetTestingFactory(browser_context(),
                                                      GetMDnsFactory());
 
     EventRouterFactory::GetInstance()->SetTestingFactory(browser_context(),
                                                          &BuildEventRouter);
 
     // Do some sanity checking
     ASSERT_TRUE(MDnsAPI::Get(browser_context()));      // constructs MDnsAPI
     ASSERT_TRUE(EventRouter::Get(browser_context()));  // constructs EventRouter
 
-    registry_ = new MockDnsSdRegistry(MDnsAPI::Get(browser_context()));
+    registry_ =
+        base::MakeUnique<MockDnsSdRegistry>(MDnsAPI::Get(browser_context()));
     EXPECT_CALL(*dns_sd_registry(),
                 AddObserver(MDnsAPI::Get(browser_context())))
         .Times(1);
     MDnsAPI::Get(browser_context())
-        ->SetDnsSdRegistryForTesting(
-            std::unique_ptr<media_router::DnsSdRegistry>(registry_));
+        ->SetDnsSdRegistryForTesting(registry_.get());
 
     render_process_host_.reset(
         new content::MockRenderProcessHost(browser_context()));
   }
 
   // Returns the mDNS API factory function (mock vs. real) to use for the test.
   virtual BrowserContextKeyedServiceFactory::TestingFactoryFunction
   GetMDnsFactory() {
     return MDnsAPITestingFactoryFunction;
   }
 
   void TearDown() override {
-    EXPECT_CALL(*dns_sd_registry(),
-                RemoveObserver(MDnsAPI::Get(browser_context())))
-        .Times(1);
+    MDnsAPI::Get(browser_context())->SetDnsSdRegistryForTesting(nullptr);
     render_process_host_.reset();
     extensions::ExtensionServiceTestBase::TearDown();
   }
 
-  virtual MockDnsSdRegistry* dns_sd_registry() {
-    return registry_;
-  }
+  virtual MockDnsSdRegistry* dns_sd_registry() { return registry_.get(); }
 
   // Constructs an extension according to the parameters that matter most to
   // MDnsAPI the local unit tests.
   const scoped_refptr<extensions::Extension> CreateExtension(
       std::string name,
       bool is_platform_app,
       std::string extension_id) {
     base::DictionaryValue manifest;
     manifest.SetString(extensions::manifest_keys::kVersion, "1.0.0.0");
     manifest.SetString(extensions::manifest_keys::kName, name);
@@ skipping 12 matching lines @@
         Extension::NO_FLAGS,
         extension_id,
         &error);
   }
 
   content::RenderProcessHost* render_process_host() const {
     return render_process_host_.get();
   }
 
  private:
-  // The registry is owned by MDnsAPI, but MDnsAPI does not have an accessor
-  // for it, so use a private member.
-  MockDnsSdRegistry* registry_;
+  std::unique_ptr<MockDnsSdRegistry> registry_;
 
   std::unique_ptr<content::RenderProcessHost> render_process_host_;
 };
 
 class MDnsAPIMaxServicesTest : public MDnsAPITest {
  public:
   MockEventRouter* event_router() {
     return static_cast<MockEventRouter*>(EventRouter::Get(browser_context()));
   }
 };
@@ skipping 157 matching lines @@
                                  render_process_host(), kExtId, filter, false);
 
   EXPECT_CALL(*dns_sd_registry(), UnregisterDnsSdListener("_trex._tcp.local"));
   EventRouter::Get(browser_context())
       ->RemoveFilteredEventListener(api::mdns::OnServiceList::kEventName,
                                     render_process_host(), kExtId, filter,
                                     false);
 }
 
 }  // namespace extensions