[Device Discovery] Make DialRegistry a Singleton

chrome/browser/media/router/discovery/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/media/router/discovery/dial/dial_registry.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
 #include "chrome/browser/media/router/discovery/dial/dial_service.h"
 #include "components/net_log/chrome_net_log.h"
 #include "content/public/browser/browser_thread.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 using net::NetworkChangeNotifier;
 
+namespace {
+
+// How often to poll for devices.
+const int kDialRefreshIntervalSecs = 120;
+
+// We prune a device if it does not respond after this time.
+const int kDialExpirationSecs = 240;
+
+// The maximum number of devices retained at once in the registry.
+const size_t kDialMaxDevices = 256;
+
+}  // namespace
+
 namespace media_router {
 
-DialRegistry::DialRegistry(base::TimeDelta refresh_interval,
-                           base::TimeDelta expiration,
-                           const size_t max_devices)
+DialRegistry::DialRegistry()
     : 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) {
+      refresh_interval_delta_(
+          base::TimeDelta::FromSeconds(kDialRefreshIntervalSecs)),
+      expiration_delta_(base::TimeDelta::FromSeconds(kDialExpirationSecs)),
+      max_devices_(kDialMaxDevices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(max_devices_, 0U);
+  // This is a leaky singleton, so there's no code to remove |this| as an
+  // observer.
   NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
-DialRegistry::~DialRegistry() {
+// This is a leaky singleton and the dtor won't be called.
+DialRegistry::~DialRegistry() = default;
+
+// static
+DialRegistry* DialRegistry::GetInstance() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
+  return base::Singleton<DialRegistry,
+                         base::LeakySingletonTraits<DialRegistry>>::get();
 }
 
 std::unique_ptr<DialService> DialRegistry::CreateDialService() {
   DCHECK(g_browser_process->net_log());
   return base::MakeUnique<DialServiceImpl>(g_browser_process->net_log());
 }
 
 void DialRegistry::ClearDialService() {
   dial_.reset();
 }
@@ skipping 90 matching lines @@
 }
 
 void DialRegistry::StartPeriodicDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!ReadyToDiscover() || dial_)
     return;
 
   dial_ = CreateDialService();
   dial_->AddObserver(this);
   DoDiscovery();
-  repeating_timer_.Start(FROM_HERE, refresh_interval_delta_, this,
-                         &DialRegistry::DoDiscovery);
+  repeating_timer_.reset(new base::RepeatingTimer());
+  repeating_timer_->Start(FROM_HERE, refresh_interval_delta_, this,
+                          &DialRegistry::DoDiscovery);
 }
 
 void DialRegistry::DoDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(dial_);
   VLOG(2) << "About to discover!";
   dial_->Discover();
 }
 
 void DialRegistry::StopPeriodicDiscovery() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!dial_)
     return;
 
-  repeating_timer_.Stop();
+  repeating_timer_->Stop();
+  repeating_timer_.reset();
   dial_->RemoveObserver(this);
   ClearDialService();
 }
 
 bool DialRegistry::PruneExpiredDevices() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   bool pruned_device = false;
   DeviceByLabelMap::iterator it = device_by_label_map_.begin();
   while (it != device_by_label_map_.end()) {
     auto* device = it->second;
@@ skipping 178 matching lines @@
   for (auto& observer : observers_)
     observer.OnDialDeviceEvent(devices);
 }
 
 void DialRegistry::OnDialError(DialErrorCode type) {
   for (auto& observer : observers_)
     observer.OnDialError(type);
 }
 
 }  // namespace media_router