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

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 18 matching lines @@
 const char kTestServiceType[] = "_testing._tcp.local";
 
 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) {
   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()) {
     dns_sd_registry_->RemoveObserver(this);
@@ skipping 23 matching lines @@
 
 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 extensions::DnsSdRegistry());
+    dns_sd_registry_.reset(new media_router::DnsSdRegistry());
     dns_sd_registry_->AddObserver(this);
   }
   return dns_sd_registry_.get();
 }
 
 void MDnsAPI::OnListenerAdded(const EventListenerInfo& details) {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateMDnsListeners();
 }
 
@@ skipping 46 matching lines @@
     }
   }
   prev_service_counts_.swap(current_service_counts);
 }
 
 void MDnsAPI::OnDnsSdEvent(const std::string& service_type,
                            const DnsSdRegistry::DnsSdServiceList& services) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<mdns::MDnsService> args;
-  for (const DnsSdService& service : services) {
+  for (const auto& service : services) {
     if (static_cast<int>(args.size()) ==
         api::mdns::MAX_SERVICE_INSTANCES_PER_EVENT) {
       // TODO(reddaly): This is not the most meaningful way of notifying the
       // application that something bad happened.  It will go to the user's
       // console (which most users don't look at)and the developer will be none
       // the wiser.  Instead, changing the event to pass the number of
       // discovered instances would allow the caller to know when the list is
       // truncated and tell the user something meaningful in the extension/app.
       WriteToConsole(service_type,
                      content::CONSOLE_MESSAGE_LEVEL_WARNING,
@@ skipping 107 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