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 29 matching lines @@
 
 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_delegate_(pref_delegate),
       setting_prefs_(false),
       is_initialized_(false),
       network_task_runner_(network_task_runner) {
   DCHECK(pref_delegate_);

[xunjieli, 2017/02/16 02:49:18]

nit: could you add a 
DCHECK(pref_task_runner->RunsTasksOnCurrentThread()) here?

[gab, 2017/02/16 16:50:15]

Done (though then I guess you might as well store
base::ThreadTaskRunnerHandle::Get() instead of tasking it as a parameter then).
I leave that up to you if you want to improve it further as a follow-up.

[xunjieli, 2017/02/16 17:08:29]

Acknowledged. It used to be base::ThreadTaskRunnerHandle::Get() but was changed
in
https://chromium.googlesource.com/chromium/src/+/894658381ab6a524afa5ab08c780...
to facilitate testing. 

[gab, 2017/02/16 21:03:36]

Ah well, that's no longer necessary with my addition of the
ScopedMockTimeMessageLoopTaskRunner on the main thread :).

And you could also get rid of the Timer::SetTaskRunner() calls I think because
Start() binds to the task runner it's started from which in your case is always
the right one (as DCHECK'ed and ensured by the ScopedContexts in this CL :)).

   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 264 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