[DIAL tests] Slightly improve DialRegistry tests.

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/default_clock.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;
@@ skipping 13 matching lines @@
 
 }  // namespace
 
 namespace media_router {
 
 DialRegistry::DialRegistry()
     : num_listeners_(0),
       registry_generation_(0),
       last_event_registry_generation_(0),
       label_count_(0),
-      refresh_interval_delta_(
-          base::TimeDelta::FromSeconds(kDialRefreshIntervalSecs)),
-      expiration_delta_(base::TimeDelta::FromSeconds(kDialExpirationSecs)),
-      max_devices_(kDialMaxDevices) {
+      refresh_interval_delta_(TimeDelta::FromSeconds(kDialRefreshIntervalSecs)),
+      expiration_delta_(TimeDelta::FromSeconds(kDialExpirationSecs)),
+      max_devices_(kDialMaxDevices),
+      clock_(new base::DefaultClock()) {
   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);
 }
 
 // This is a leaky singleton and the dtor won't be called.
 DialRegistry::~DialRegistry() = default;
 
 // static
 DialRegistry* DialRegistry::GetInstance() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   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();
 }
 
-base::Time DialRegistry::Now() const {
-  return Time::Now();
-}
-
 void DialRegistry::OnListenerAdded() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (++num_listeners_ == 1) {
     VLOG(2) << "Listener added; starting periodic discovery.";
     StartPeriodicDiscovery();
   }
   // Event listeners with the current device list.
   // TODO(crbug.com/576817): Rework the DIAL API so we don't need to have extra
   // behaviors when adding listeners.
   SendEvent();
@@ skipping 28 matching lines @@
 
 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)));
 }
 
+void DialRegistry::SetClockForTest(std::unique_ptr<base::Clock> clock) {
+  clock_ = std::move(clock);
+}
+
 bool DialRegistry::ReadyToDiscover() {
   if (num_listeners_ == 0) {
     OnDialError(DIAL_NO_LISTENERS);
     return false;
   }
   if (NetworkChangeNotifier::IsOffline()) {
     OnDialError(DIAL_NETWORK_DISCONNECTED);
     return false;
   }
   if (NetworkChangeNotifier::IsConnectionCellular(
@@ skipping 74 matching lines @@
       device_by_label_map_.erase(it++);
       pruned_device = true;
     } else {
       ++it;
     }
   }
   return pruned_device;
 }
 
 bool DialRegistry::IsDeviceExpired(const DialDeviceData& device) const {
-  Time now = Now();
+  Time now = clock_->Now();
 
   // Check against our default expiration timeout.
   Time default_expiration_time = device.response_time() + expiration_delta_;
   if (now > default_expiration_time)
     return true;
 
   // Check against the device's cache-control header, if set.
   if (device.has_max_age()) {
     Time max_age_expiration_time =
         device.response_time() + TimeDelta::FromSeconds(device.max_age());
@@ skipping 149 matching lines @@
   for (auto& observer : observers_)
     observer.OnDialDeviceEvent(devices);
 }
 
 void DialRegistry::OnDialError(DialErrorCode type) {
   for (auto& observer : observers_)
     observer.OnDialError(type);
 }
 
 }  // namespace media_router