Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

chrome/browser/chromeos/policy/server_backed_state_keys_broker.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 "chrome/browser/chromeos/policy/server_backed_state_keys_broker.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/dbus/session_manager_client.h"
 
 namespace policy {
 
 namespace {
 
 // Refresh interval for state keys. There's a quantized time component in
 // state key generation, so they rotate over time. The quantum size is pretty
 // coarse though (currently 2^23 seconds), so simply polling for a new state
 // keys once a day is good enough.
-const int kPollIntervalSeconds = 60 * 60 * 24;
+constexpr base::TimeDelta kPollInterval = base::TimeDelta::FromDays(1);
 
 }  // namespace
 
 ServerBackedStateKeysBroker::ServerBackedStateKeysBroker(
-    chromeos::SessionManagerClient* session_manager_client,
-    scoped_refptr<base::TaskRunner> delayed_task_runner)
+    chromeos::SessionManagerClient* session_manager_client)
     : session_manager_client_(session_manager_client),
-      delayed_task_runner_(delayed_task_runner),
       requested_(false),
       initial_retrieval_completed_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 ServerBackedStateKeysBroker::~ServerBackedStateKeysBroker() {
 }
 
 ServerBackedStateKeysBroker::Subscription
 ServerBackedStateKeysBroker::RegisterUpdateCallback(
     const base::Closure& callback) {
   if (!available())
     FetchStateKeys();
   return update_callbacks_.Add(callback);
 }
 
 void ServerBackedStateKeysBroker::RequestStateKeys(
     const StateKeysCallback& callback) {
   if (pending()) {
     request_callbacks_.push_back(callback);
     FetchStateKeys();
     return;
   }
 
   if (!callback.is_null())
     callback.Run(state_keys_);
   return;
 }
 
+// static
+base::TimeDelta ServerBackedStateKeysBroker::GetPollIntervalForTesting() {
+  return kPollInterval;
+}
+
 void ServerBackedStateKeysBroker::FetchStateKeys() {
   if (!requested_) {
     requested_ = true;
     session_manager_client_->GetServerBackedStateKeys(
         base::Bind(&ServerBackedStateKeysBroker::StoreStateKeys,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServerBackedStateKeysBroker::StoreStateKeys(
@@ skipping 18 matching lines @@
   std::vector<StateKeysCallback> callbacks;
   request_callbacks_.swap(callbacks);
   for (std::vector<StateKeysCallback>::const_iterator callback(
            callbacks.begin());
        callback != callbacks.end();
        ++callback) {
     if (!callback->is_null())
       callback->Run(state_keys_);
   }
 
-  delayed_task_runner_->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(

[emaxx, 2017/03/01 14:43:53]

nit: #include "base/single_thread_task_runner.h"?
I don't think we can rely here on base/threading/thread_task_runner_handle.h
including it.

[gab, 2017/03/02 00:33:31]

By IWYU (include-what-you-use), thread_task_runner_handle.h has to include
single_thread_task_runner.h per returning it by value.

[emaxx, 2017/03/02 02:39:39]

I'm not entirely following this argument. ThreadTaskRunnerHandle is returning
SingleThreadTaskRunner not by a value, but inside a smart pointer. Incomplete
types may be used in declarations with STL's smart pointers std::unique_ptr and
std::shared_ptr, and so do is with scoped_refptr - as documented here:
https://cs.chromium.org/chromium/src/base/memory/ref_counted.h?l=392

[gab, 2017/03/02 03:24:44]

https://groups.google.com/a/chromium.org/d/topic/chromium-dev/0khIRhxDq6E/dis...

(can't fwd-decl the pointer type of a scoped_refptr passed by value -- and the
documented/tested paradigm should be remove because it requires an advanced
fwd-template-decl which is literally never used outside of that test)

       FROM_HERE,
       base::Bind(&ServerBackedStateKeysBroker::FetchStateKeys,
                  weak_factory_.GetWeakPtr()),
-      base::TimeDelta::FromSeconds(kPollIntervalSeconds));
+      kPollInterval);
 }
 
 }  // namespace policy