Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

net/http/http_server_properties_manager.cc

 // Copyright 2014 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 "net/http/http_server_properties_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address.h"
 #include "net/base/port_util.h"
 #include "net/quic/platform/api/quic_url_utils.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 // Time to wait before starting an update the http_server_properties_impl_ cache
 // from preferences. Scheduling another update during this period will be a
 // no-op.
-const int64_t kUpdateCacheDelayMs = 1000;
+constexpr base::TimeDelta kUpdateCacheDelay = base::TimeDelta::FromSeconds(1);
 
 // Time to wait before starting an update the preferences from the
 // http_server_properties_impl_ cache. Scheduling another update during this
 // period will be a no-op.
-const int64_t kUpdatePrefsDelayMs = 60000;
+constexpr base::TimeDelta kUpdatePrefsDelay = base::TimeDelta::FromSeconds(60);
 
 // "version" 0 indicates, http_server_properties doesn't have "version"
 // property.
 const int kMissingVersion = 0;
 
 // The version number of persisted http_server_properties.
 const int kVersionNumber = 5;
 
 // Persist 200 MRU AlternateProtocolHostPortPairs.
 const int kMaxAlternateProtocolHostsToPersist = 200;
@@ skipping 24 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //  HttpServerPropertiesManager
 
 HttpServerPropertiesManager::PrefDelegate::~PrefDelegate() {}
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefDelegate* pref_delegate,
     scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
-    : pref_task_runner_(pref_task_runner),
+    : pref_task_runner_(std::move(pref_task_runner)),
       pref_delegate_(pref_delegate),
       setting_prefs_(false),
       is_initialized_(false),
-      network_task_runner_(network_task_runner) {
+      network_task_runner_(std::move(network_task_runner)) {
+  DCHECK(pref_task_runner->RunsTasksOnCurrentThread());
   DCHECK(pref_delegate_);
   pref_weak_ptr_factory_.reset(
       new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   pref_weak_ptr_ = pref_weak_ptr_factory_->GetWeakPtr();
   pref_cache_update_timer_.reset(new base::OneShotTimer);
   pref_cache_update_timer_->SetTaskRunner(pref_task_runner_);
   pref_delegate_->StartListeningForUpdates(
       base::Bind(&HttpServerPropertiesManager::OnHttpServerPropertiesChanged,
                  base::Unretained(this)));
 }
@@ skipping 265 matching lines @@
   return http_server_properties_impl_->SetMaxServerConfigsStoredInProperties(
       max_server_configs_stored_in_properties);
 }
 
 bool HttpServerPropertiesManager::IsInitialized() const {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
 
   return is_initialized_;
 }
 
+// static
+base::TimeDelta HttpServerPropertiesManager::GetUpdateCacheDelayForTesting() {
+  return kUpdateCacheDelay;
+}
+
+// static
+base::TimeDelta HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting() {
+  return kUpdatePrefsDelay;
+}
+
 //
 // Update the HttpServerPropertiesImpl's cache with data from preferences.
 //
 void HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   // Do not schedule a new update if there is already one scheduled.
   if (pref_cache_update_timer_->IsRunning())
     return;
 
   pref_cache_update_timer_->Start(
-      FROM_HERE, base::TimeDelta::FromMilliseconds(kUpdateCacheDelayMs), this,
+      FROM_HERE, kUpdateCacheDelay, this,
       &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread);
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread() {
   // The preferences can only be read on the pref thread.
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
 
   if (!pref_delegate_->HasServerProperties())
     return;
 
@@ skipping 395 matching lines @@
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(
     Location location) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   // Do not schedule a new update if there is already one scheduled.
   if (network_prefs_update_timer_->IsRunning())
     return;
 
   network_prefs_update_timer_->Start(
-      FROM_HERE, base::TimeDelta::FromMilliseconds(kUpdatePrefsDelayMs), this,
+      FROM_HERE, kUpdatePrefsDelay, this,
       &HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread);
 
   // TODO(rtenneti): Delete the following histogram after collecting some data.
   UMA_HISTOGRAM_ENUMERATION("Net.HttpServerProperties.UpdatePrefs", location,
                             HttpServerPropertiesManager::NUM_LOCATIONS);
 }
 
 // This is required so we can set this as the callback for a timer.
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread() {
   UpdatePrefsFromCacheOnNetworkThread(base::Closure());
@@ skipping 315 matching lines @@
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   is_initialized_ = true;
 }
 
 }  // namespace net