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

chrome/browser/media/router/discovery/mdns/dns_sd_registry.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/dns_sd_registry.h"
+#include "chrome/browser/media/router/discovery/mdns/dns_sd_registry.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
-#include "chrome/browser/extensions/api/mdns/dns_sd_device_lister.h"
 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
+#include "chrome/browser/media/router/discovery/mdns/dns_sd_device_lister.h"
 #include "chrome/common/features.h"
 
 using local_discovery::ServiceDiscoveryClient;
 using local_discovery::ServiceDiscoverySharedClient;
 
-namespace extensions {
+namespace media_router {
 
 namespace {
 // Predicate to test if two discovered services have the same service_name.
 class IsSameServiceName {
  public:
   explicit IsSameServiceName(const DnsSdService& service) : service_(service) {}
   bool operator()(const DnsSdService& other) const {
     return service_.service_name == other.service_name;
   }
 
@@ skipping 14 matching lines @@
 
 bool DnsSdRegistry::ServiceTypeData::ListenerRemoved() {
   return --ref_count == 0;
 }
 
 int DnsSdRegistry::ServiceTypeData::GetListenerCount() {
   return ref_count;
 }
 
 bool DnsSdRegistry::ServiceTypeData::UpdateService(
-      bool added, const DnsSdService& service) {
-  DnsSdRegistry::DnsSdServiceList::iterator it =
-      std::find_if(service_list_.begin(),
-                   service_list_.end(),
-                   IsSameServiceName(service));
+    bool added,
+    const DnsSdService& service) {
+  DnsSdRegistry::DnsSdServiceList::iterator it = std::find_if(
+      service_list_.begin(), service_list_.end(), IsSameServiceName(service));
   // Set to true when a service is updated in or added to the registry.
   bool updated_or_added = added;
   bool known = (it != service_list_.end());
   if (known) {
     // If added == true, but we still found the service in our cache, then just
     // update the existing entry, but this should not happen!
     DCHECK(!added);
     if (*it != service) {
       *it = service;
       updated_or_added = true;
     }
   } else if (added) {
     service_list_.push_back(service);
   }
 
-  VLOG(1) << "UpdateService: " << service.service_name
-          << ", added: " << added
-          << ", known: " << known
-          << ", updated or added: " << updated_or_added;
+  VLOG(1) << "UpdateService: " << service.service_name << ", added: " << added
+          << ", known: " << known << ", updated or added: " << updated_or_added;
   return updated_or_added;
 }
 
 bool DnsSdRegistry::ServiceTypeData::RemoveService(
     const std::string& service_name) {
   for (DnsSdRegistry::DnsSdServiceList::iterator it = service_list_.begin();
        it != service_list_.end(); ++it) {
     if ((*it).service_name == service_name) {
       service_list_.erase(it);
       return true;
@@ skipping 87 matching lines @@
 
   if (service_data_map_[service_type]->ListenerRemoved())
     service_data_map_.erase(it);
 }
 
 void DnsSdRegistry::ServiceChanged(const std::string& service_type,
                                    bool added,
                                    const DnsSdService& service) {
   VLOG(1) << "ServiceChanged: service_type: " << service_type
           << ", known: " << IsRegistered(service_type)
-          << ", service: " << service.service_name
-          << ", added: " << added;
+          << ", service: " << service.service_name << ", added: " << added;
   if (!IsRegistered(service_type)) {
     return;
   }
 
   bool is_updated =
       service_data_map_[service_type]->UpdateService(added, service);
   VLOG(1) << "ServiceChanged: is_updated: " << is_updated;
 
   if (is_updated) {
     DispatchApiEvent(service_type);
@@ skipping 36 matching lines @@
   for (auto& observer : observers_) {
     observer.OnDnsSdEvent(service_type,
                           service_data_map_[service_type]->GetServiceList());
   }
 }
 
 bool DnsSdRegistry::IsRegistered(const std::string& service_type) {
   return service_data_map_.find(service_type) != service_data_map_.end();
 }
 
-}  // namespace extensions
+}  // namespace media_router