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

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

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_
 #define CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/extensions/api/dial/dial_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "net/base/network_change_notifier.h"
 
 namespace extensions {
 namespace api {
 namespace dial {
 
@@ skipping 21 matching lines @@
     // update is triggered by dial.discoverNow or an error occured.
     virtual void OnDialDeviceEvent(const DeviceList& devices) = 0;
     virtual void OnDialError(DialErrorCode type) = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   // Create the DIAL registry and pass a reference to allow it to notify on
   // DIAL device events.
-  DialRegistry(Observer* dial_api,
-               const base::TimeDelta& refresh_interval,
-               const base::TimeDelta& expiration,
+  DialRegistry(base::TimeDelta refresh_interval,
+               base::TimeDelta expiration,
                const size_t max_devices);
 
   ~DialRegistry() override;
 
   // Called by the DIAL API when event listeners are added or removed. The dial
   // service is started after the first listener is added and stopped after the
   // last listener is removed.
   void OnListenerAdded();
   void OnListenerRemoved();
 
+  // This class does not take ownership of observer.
+  void RegisterObserver(Observer* observer);
+  void UnregisterObserver(Observer* observer);
+
   // Called by the DIAL API to try to kickoff a discovery if there is not one
   // already active.
   bool DiscoverNow();
 
   // Returns the URL of the device description for the device identified by
   // |label|, or an empty GURL if no such device exists.
   GURL GetDeviceDescriptionURL(const std::string& label) const;
 
   // Adds a device directly to the registry as if it was discovered.  For tests
   // only.  Note that if discovery is actually started, this device will be
@@ skipping 21 matching lines @@
   void OnDeviceDiscovered(DialService* service,
                           const DialDeviceData& device) override;
   void OnDiscoveryFinished(DialService* service) override;
   void OnError(DialService* service,
                const DialService::DialServiceErrorCode& code) override;
 
   // net::NetworkChangeObserver:
   void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
+  // Notify all observers about DialDeviceEvent or DialError.
+  void OnDialDeviceEvent(const DeviceList& devices);
+  void OnDialError(DialErrorCode type);
+
   // Starts and stops periodic discovery.  Periodic discovery is done when there
   // are registered event listeners.
   void StartPeriodicDiscovery();
   void StopPeriodicDiscovery();
 
   // Check whether we are in a state ready to discover and dispatch error
   // notifications if not.
   bool ReadyToDiscover();
 
   // Purge our whole registry. We may need to do this occasionally, e.g. when
@@ skipping 47 matching lines @@
 
   // A map used to track known devices sorted by label.  We iterate over this to
   // construct the device list sent to API clients.
   DeviceByLabelMap device_by_label_map_;
 
   // Timer used to manage periodic discovery requests.
   base::RepeatingTimer repeating_timer_;
 
   // Interface from which the DIAL API is notified of DIAL device events. the
   // DIAL API owns this DIAL registry.
-  Observer* const dial_api_;
+  base::ObserverList<Observer> observers_;
 
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestAddRemoveListeners);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestNoDevicesDiscovered);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestDevicesDiscovered);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest,
                            TestDevicesDiscoveredWithTwoListeners);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestDeviceExpires);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestExpiredDeviceIsRediscovered);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest,
                            TestRemovingListenerDoesNotClearList);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestNetworkEventConnectionLost);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest,
                            TestNetworkEventConnectionRestored);
   DISALLOW_COPY_AND_ASSIGN(DialRegistry);
 };
 
 }  // namespace dial
 }  // namespace api
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DIAL_DIAL_REGISTRY_H_