[Dial] Refactor DialRegistry and DeviceDescriptionFetcher so they can be used by MediaSinkService

chrome/browser/extensions/api/dial/dial_registry.cc

 // Copyright (c) 2012 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/dial/dial_registry.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 15 matching lines @@
 using net::NetworkChangeNotifier;
 
 namespace extensions {
 namespace api {
 namespace dial {
 
 DialRegistry::DialRegistry(Observer* dial_api,
                            const base::TimeDelta& refresh_interval,
                            const base::TimeDelta& expiration,
                            const size_t max_devices)
-  : num_listeners_(0),
-    registry_generation_(0),
-    last_event_registry_generation_(0),
-    label_count_(0),
-    refresh_interval_delta_(refresh_interval),
-    expiration_delta_(expiration),
-    max_devices_(max_devices),
-    dial_api_(dial_api) {
+    : num_listeners_(0),
+      registry_generation_(0),
+      last_event_registry_generation_(0),
+      label_count_(0),
+      refresh_interval_delta_(refresh_interval),
+      expiration_delta_(expiration),
+      max_devices_(max_devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(max_devices_, 0U);
+  RegisterObserver(dial_api);
   NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 DialRegistry::~DialRegistry() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 std::unique_ptr<DialService> DialRegistry::CreateDialService() {
   DCHECK(g_browser_process->net_log());
@@ skipping 22 matching lines @@
 
 void DialRegistry::OnListenerRemoved() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(num_listeners_, 0);
   if (--num_listeners_ == 0) {
     VLOG(2) << "Listeners removed; stopping periodic discovery.";
     StopPeriodicDiscovery();
   }
 }
 
+void DialRegistry::RegisterObserver(Observer* observer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  observers_.insert(observer);
+}
+
+void DialRegistry::UnregisterObserver(Observer* observer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  observers_.erase(observer);
+}
+
 GURL DialRegistry::GetDeviceDescriptionURL(const std::string& label) const {
   const auto device_it = device_by_label_map_.find(label);
   if (device_it != device_by_label_map_.end())
     return device_it->second->device_description_url();
 
   return GURL();
 }
 
 void DialRegistry::AddDeviceForTest(const DialDeviceData& device_data) {
   std::unique_ptr<DialDeviceData> test_data =
       base::MakeUnique<DialDeviceData>(device_data);
   device_by_label_map_.insert(
       std::make_pair(device_data.label(), test_data.get()));
   device_by_id_map_.insert(
       std::make_pair(device_data.device_id(), std::move(test_data)));
 }
 
 bool DialRegistry::ReadyToDiscover() {
   if (num_listeners_ == 0) {
-    dial_api_->OnDialError(DIAL_NO_LISTENERS);
+    OnDialError(DIAL_NO_LISTENERS);
     return false;
   }
   if (NetworkChangeNotifier::IsOffline()) {
-    dial_api_->OnDialError(DIAL_NETWORK_DISCONNECTED);
+    OnDialError(DIAL_NETWORK_DISCONNECTED);
     return false;
   }
   if (NetworkChangeNotifier::IsConnectionCellular(
           NetworkChangeNotifier::GetConnectionType())) {
-    dial_api_->OnDialError(DIAL_CELLULAR_NETWORK);
+    OnDialError(DIAL_CELLULAR_NETWORK);
     return false;
   }
   return true;
 }
 
 bool DialRegistry::DiscoverNow() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!ReadyToDiscover()) {
     return false;
   }
   if (!dial_) {
-    dial_api_->OnDialError(DIAL_UNKNOWN);
+    OnDialError(DIAL_UNKNOWN);
     return false;
   }
 
   if (!dial_->HasObserver(this))
     NOTREACHED() << "DiscoverNow() called without observing dial_";
 
   // Force increment |registry_generation_| to ensure an event is sent even if
   // the device list did not change.
   bool started = dial_->Discover();
   if (started)
@@ skipping 89 matching lines @@
   if (needs_event)
     SendEvent();
 }
 
 void DialRegistry::SendEvent() {
   DeviceList device_list;
   for (DeviceByLabelMap::const_iterator it = device_by_label_map_.begin();
        it != device_by_label_map_.end(); ++it) {
     device_list.push_back(*(it->second));
   }
-  dial_api_->OnDialDeviceEvent(device_list);
+  OnDialDeviceEvent(device_list);
 
   // Reset watermark.
   last_event_registry_generation_ = registry_generation_;
 }
 
 std::string DialRegistry::NextLabel() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return base::IntToString(++label_count_);
 }
 
@@ skipping 54 matching lines @@
   if (PruneExpiredDevices())
     registry_generation_++;
   MaybeSendEvent();
 }
 
 void DialRegistry::OnError(DialService* service,
                            const DialService::DialServiceErrorCode& code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   switch (code) {
     case DialService::DIAL_SERVICE_SOCKET_ERROR:
-      dial_api_->OnDialError(DIAL_SOCKET_ERROR);
+      OnDialError(DIAL_SOCKET_ERROR);
       break;
     case DialService::DIAL_SERVICE_NO_INTERFACES:
-      dial_api_->OnDialError(DIAL_NO_INTERFACES);
+      OnDialError(DIAL_NO_INTERFACES);
       break;
     default:
       NOTREACHED();
-      dial_api_->OnDialError(DIAL_UNKNOWN);
+      OnDialError(DIAL_UNKNOWN);
       break;
   }
 }
 
 void DialRegistry::OnNetworkChanged(
     NetworkChangeNotifier::ConnectionType type) {
   switch (type) {
     case NetworkChangeNotifier::CONNECTION_NONE:
       if (dial_) {
         VLOG(2) << "Lost connection, shutting down discovery and clearing"
                 << " list.";
-        dial_api_->OnDialError(DIAL_NETWORK_DISCONNECTED);
+        OnDialError(DIAL_NETWORK_DISCONNECTED);
 
         StopPeriodicDiscovery();
         // TODO(justinlin): As an optimization, we can probably keep our device
         // list around and restore it if we reconnected to the exact same
         // network.
         Clear();
         MaybeSendEvent();
       }
       break;
     case NetworkChangeNotifier::CONNECTION_2G:
     case NetworkChangeNotifier::CONNECTION_3G:
     case NetworkChangeNotifier::CONNECTION_4G:
     case NetworkChangeNotifier::CONNECTION_ETHERNET:
     case NetworkChangeNotifier::CONNECTION_WIFI:
     case NetworkChangeNotifier::CONNECTION_UNKNOWN:
     case NetworkChangeNotifier::CONNECTION_BLUETOOTH:
       if (!dial_) {
         VLOG(2) << "Connection detected, restarting discovery.";
         StartPeriodicDiscovery();
       }
       break;
   }
 }
 
+void DialRegistry::OnDialDeviceEvent(const DeviceList& devices) {
+  for (auto* observer : observers_)

[mark a. foltz, 2017/03/01 21:44:00]

for (auto& observer : observers_) (from base::ObserverList)

[zhaobin, 2017/03/02 07:04:35]

Done.

+    observer->OnDialDeviceEvent(devices);
+}
+
+void DialRegistry::OnDialError(DialErrorCode type) {
+  for (auto* observer : observers_)
+    observer->OnDialError(type);
+}
+
 }  // namespace dial
 }  // namespace api
 }  // namespace extensions