[Device Discovery] Make DialRegistry a Singleton

chrome/browser/media/router/discovery/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_MEDIA_ROUTER_DISCOVERY_DIAL_DIAL_REGISTRY_H_
 #define CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_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/media/router/discovery/dial/dial_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "components/keyed_service/core/refcounted_keyed_service.h"
 #include "net/base/network_change_notifier.h"
 
 namespace media_router {
 
 // Keeps track of devices that have responded to discovery requests and notifies
 // the observer with an updated, complete set of active devices.  The registry's
 // observer (i.e., the Dial API) owns the registry instance.
 // DialRegistry lives on the IO thread.
-class DialRegistry : public DialService::Observer,
+class DialRegistry : public RefcountedKeyedService,

[mark a. foltz, 2017/03/18 18:04:58]

I don't think the DialRegistry needs to be a keyed service - it should have the
same set of devices across profiles, so only one needs to be created per browser
process.   Maybe just make it base::RefCounted<>?

[zhaobin, 2017/03/22 02:48:45]

Code removed.

+                     public DialService::Observer,
                      public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   using DeviceList = std::vector<DialDeviceData>;
 
   enum DialErrorCode {
     DIAL_NO_LISTENERS = 0,
     DIAL_NO_INTERFACES,
     DIAL_NETWORK_DISCONNECTED,
     DIAL_CELLULAR_NETWORK,
     DIAL_SOCKET_ERROR,
@@ skipping 10 matching lines @@
    protected:
     virtual ~Observer() {}
   };
 
   // Create the DIAL registry and pass a reference to allow it to notify on
   // DIAL device events.
   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
   // removed by PruneExpiredDevices().
   void AddDeviceForTest(const DialDeviceData& device_data);
 
  protected:
+  ~DialRegistry() override;
+
   // Returns a new instance of the DIAL service.  Overridden by tests.
   virtual std::unique_ptr<DialService> CreateDialService();
   virtual void ClearDialService();
 
   // Returns the current time.  Overridden by tests.
   virtual base::Time Now() const;
 
   // The DIAL service. Periodic discovery is active when this is not NULL.
   std::unique_ptr<DialService> dial_;
 
  private:
   using DeviceByIdMap =
       base::hash_map<std::string, std::unique_ptr<DialDeviceData>>;
   using DeviceByLabelMap = std::map<std::string, DialDeviceData*>;
 
+  // RefcountedKeyedService:
+  void ShutdownOnUIThread() override;
+
   // DialService::Observer:
   void OnDiscoveryRequest(DialService* service) override;
   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(
@@ skipping 83 matching lines @@
                            TestRemovingListenerDoesNotClearList);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest, TestNetworkEventConnectionLost);
   FRIEND_TEST_ALL_PREFIXES(DialRegistryTest,
                            TestNetworkEventConnectionRestored);
   DISALLOW_COPY_AND_ASSIGN(DialRegistry);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_DIAL_REGISTRY_H_