Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

chrome/browser/chromeos/policy/server_backed_state_keys_broker_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/test/test_simple_task_runner.h"
+#include "base/test/scoped_mock_time_message_loop_task_runner.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 class ServerBackedStateKeysBrokerTest : public testing::Test {
  public:
   ServerBackedStateKeysBrokerTest()
-      : task_runner_(new base::TestSimpleTaskRunner()),
-        broker_(&fake_session_manager_client_, task_runner_),
+      : broker_(&fake_session_manager_client_),
         updated_(false),
         callback_invoked_(false) {
     state_keys_.push_back("1");
     state_keys_.push_back("2");
     state_keys_.push_back("3");
     fake_session_manager_client_.set_server_backed_state_keys(state_keys_);
   }
   ~ServerBackedStateKeysBrokerTest() override {}
 
   void StateKeysUpdated() {
     updated_ = true;
   }
 
   void ExpectGood() {
     EXPECT_FALSE(broker_.pending());
     EXPECT_TRUE(broker_.available());
     EXPECT_EQ(state_keys_, broker_.state_keys());
     EXPECT_EQ(state_keys_.front(), broker_.current_state_key());
   }
 
   void HandleStateKeysCallback(const std::vector<std::string>& state_keys) {
     callback_invoked_ = true;
     callback_state_keys_ = state_keys;
   }
 
  protected:
   base::MessageLoop loop_;
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::ScopedMockTimeMessageLoopTaskRunner mocked_main_runner_;
   chromeos::FakeSessionManagerClient fake_session_manager_client_;
   ServerBackedStateKeysBroker broker_;
   std::vector<std::string> state_keys_;
   bool updated_;
   std::vector<std::string> callback_state_keys_;
   bool callback_invoked_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServerBackedStateKeysBrokerTest);
 };
 
 TEST_F(ServerBackedStateKeysBrokerTest, Load) {
   EXPECT_TRUE(broker_.pending());
   EXPECT_FALSE(broker_.available());
   EXPECT_TRUE(broker_.state_keys().empty());
   EXPECT_TRUE(broker_.current_state_key().empty());
 
   ServerBackedStateKeysBroker::Subscription subscription =
       broker_.RegisterUpdateCallback(
           base::Bind(&ServerBackedStateKeysBrokerTest::StateKeysUpdated,
                      base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();

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

nit: #include "base/test/test_mock_time_task_runner.h"?

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

We had a similar discussion @
https://bugs.chromium.org/p/chromium/issues/detail?id=618793#c6.

Conclusion was that headers that always require another one to be at all useful
should include it and not require its users to include multiple headers every
time.

i.e. jam@: "Stepping back, the purpose of IWYU is to avoid slowing down the
build by including unnecessary headers. In this case, the headers are always
necessary and will always be included by the source files anyways. So I don't
see a negative."

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

The definition of the ScopedMockTimeMessageLoopTaskRunner class uses only
pointers to TestMockTimeTaskRunner and scoped_refptr's to it. So technically,
unless I'm missing something, it's not required for
scoped_mock_time_message_loop_task_runner.h to include
test_mock_time_task_runner.h.
Therefore IWYU, in my opinion, still applies here: the header A is not required
to include header B, and not every consumer of A is required to include header B
- only if they want to dereference pointers to corresponding types.

Having said that, I don't have any intention to stand in the way of these
changes. Just trying to understand the reasoning here and the scope of the IWYU
rule.

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

In pure IWYU sense you're right, but as was concluded in discussion on
aforementioned bug. It makes sense for
scoped_mock_time_message_loop_task_runner.h to provide
test_mock_timer_task_runner.h given it's merely a proxy to it (i.e. it doesn't
make sense to use this mock if you're not going to at least use the underlying
TestMockTimeTaskRunner* once).

   EXPECT_TRUE(updated_);
   ExpectGood();
 }
 
 TEST_F(ServerBackedStateKeysBrokerTest, Retry) {
   fake_session_manager_client_.set_server_backed_state_keys(
       std::vector<std::string>());
 
   ServerBackedStateKeysBroker::Subscription subscription =
       broker_.RegisterUpdateCallback(
           base::Bind(&ServerBackedStateKeysBrokerTest::StateKeysUpdated,
                      base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();
   EXPECT_TRUE(updated_);
 
   EXPECT_FALSE(broker_.pending());
   EXPECT_FALSE(broker_.available());
   EXPECT_TRUE(broker_.state_keys().empty());
   EXPECT_TRUE(broker_.current_state_key().empty());
 
   fake_session_manager_client_.set_server_backed_state_keys(state_keys_);
   updated_ = false;
   ServerBackedStateKeysBroker::Subscription subscription2 =
       broker_.RegisterUpdateCallback(base::Bind(&base::DoNothing));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();
   EXPECT_TRUE(updated_);
   ExpectGood();
 }
 
 TEST_F(ServerBackedStateKeysBrokerTest, Refresh) {
   ServerBackedStateKeysBroker::Subscription subscription =
       broker_.RegisterUpdateCallback(
           base::Bind(&ServerBackedStateKeysBrokerTest::StateKeysUpdated,
                      base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();
   EXPECT_TRUE(updated_);
   ExpectGood();
 
   // Update callbacks get fired if the keys change.
   state_keys_.erase(state_keys_.begin());
   state_keys_.push_back("4");
   fake_session_manager_client_.set_server_backed_state_keys(state_keys_);
   updated_ = false;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->FastForwardBy(
+      ServerBackedStateKeysBroker::GetPollIntervalForTesting());
   EXPECT_TRUE(updated_);
   ExpectGood();
 
   // No update callback if the keys are unchanged.
   updated_ = false;
-  task_runner_->RunPendingTasks();
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->FastForwardBy(
+      ServerBackedStateKeysBroker::GetPollIntervalForTesting());
   EXPECT_FALSE(updated_);
   ExpectGood();
 }
 
 TEST_F(ServerBackedStateKeysBrokerTest, Request) {
   broker_.RequestStateKeys(
       base::Bind(&ServerBackedStateKeysBrokerTest::HandleStateKeysCallback,
                  base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();
   ExpectGood();
   EXPECT_TRUE(callback_invoked_);
   EXPECT_EQ(state_keys_, callback_state_keys_);
 }
 
 TEST_F(ServerBackedStateKeysBrokerTest, RequestFailure) {
   fake_session_manager_client_.set_server_backed_state_keys(
       std::vector<std::string>());
 
   broker_.RequestStateKeys(
       base::Bind(&ServerBackedStateKeysBrokerTest::HandleStateKeysCallback,
                  base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
+  mocked_main_runner_->RunUntilIdle();
   EXPECT_TRUE(callback_invoked_);
   EXPECT_TRUE(callback_state_keys_.empty());
 }
 
 }  // namespace policy