[mDns] Move dns_sd_registry from extension/api/mdns to media/router/discovery/mdns

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>
@@ skipping 73 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 DnsSdRegistry {
+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:
-  extensions::DnsSdRegistry::DnsSdObserver* api_;
+  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) {
@@ skipping 79 matching lines @@
 
     // 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()));
     EXPECT_CALL(*dns_sd_registry(),
                 AddObserver(MDnsAPI::Get(browser_context())))
         .Times(1);
     MDnsAPI::Get(browser_context())
-        ->SetDnsSdRegistryForTesting(std::unique_ptr<DnsSdRegistry>(registry_));
+        ->SetDnsSdRegistryForTesting(
+            std::unique_ptr<media_router::DnsSdRegistry>(registry_));
 
     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;
   }
@@ skipping 128 matching lines @@
 TEST_F(MDnsAPIMaxServicesTest, OnServiceListDoesNotExceedLimit) {
   EventRouterFactory::GetInstance()->SetTestingFactory(
       browser_context(), &MockEventRouterFactoryFunction);
 
   // This check should change when the [value=2048] changes in the IDL file.
   EXPECT_EQ(2048, api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT);
 
   // Dispatch an mDNS event with more service instances than the max, and ensure
   // that the list is truncated by inspecting the argument to MockEventRouter's
   // BroadcastEvent method.
-  DnsSdRegistry::DnsSdServiceList services;
+  media_router::DnsSdRegistry::DnsSdServiceList services;
   for (int i = 0; i < api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT + 10; ++i) {
-    services.push_back(DnsSdService());
+    services.push_back(media_router::DnsSdService());
   }
   EXPECT_CALL(
       *event_router(),
       BroadcastEventPtr(testing::Pointee(EventServiceListSize(
           static_cast<size_t>(api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT)))))
       .Times(1);
   dns_sd_registry()->DispatchMDnsEvent("_testing._tcp.local", services);
 }
 
 TEST_F(MDnsAPITest, ExtensionRespectsWhitelist) {
@@ skipping 63 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