Add support in TestMockTimeTaskRunner for vending out mock Time and mock Clocks.

ash/system/chromeos/session/logout_confirmation_controller_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 "ash/system/chromeos/session/logout_confirmation_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/time/tick_clock.h"

[bartfab (slow), 2015/02/12 09:50:55]

Nit: No need for this include. The type is never dereferenced.

[engedy, 2015/02/12 11:27:03]

It is needed for passing the scoped_ptr returned by the task runner into
SetClockForTesting().

[bartfab (slow), 2015/02/12 12:36:07]

You do not need to define the types you pass around via a pointer.

[engedy, 2015/02/13 11:08:04]

Note that this is not a raw pointer, but a scoped_ptr.

I have not looked into the implementation of scoped_ptr<T> too deeply, but I
believe the definition of T is needed so that the code for ~scoped_ptr<T>(),
necessitated by the destruction of the temporary on line 41, and containing an
invocation to ~T(), can be generated.

(I tried, just to be sure, and it won't compile without the include.)

[bartfab (slow), 2015/02/16 13:40:34]

Aye, your analysis is correct. I had missed the fact that this is a scoped_ptr.

 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ash {
 
 class LogoutConfirmationControllerTest : public testing::Test {
  protected:
   LogoutConfirmationControllerTest();
   ~LogoutConfirmationControllerTest() override;
 
   void LogOut();
@@ skipping 21 matching lines @@
 LogoutConfirmationControllerTest::~LogoutConfirmationControllerTest() {
 }
 
 void LogoutConfirmationControllerTest::LogOut() {
   log_out_called_ = true;
 }
 
 // Verifies that the user is logged out immediately if logout confirmation with
 // a zero-length countdown is requested.
 TEST_F(LogoutConfirmationControllerTest, ZeroDuration) {
-  controller_.ConfirmLogout(runner_->GetCurrentMockTime());
+  controller_.ConfirmLogout(runner_->NowTicks());
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta());
   EXPECT_TRUE(log_out_called_);
 }
 
 // Verifies that the user is logged out when the countdown expires.
 TEST_F(LogoutConfirmationControllerTest, DurationExpired) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(9));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
   EXPECT_TRUE(log_out_called_);
 }
 
 // Verifies that when a second request to confirm logout is made and the second
 // request's countdown ends before the original request's, the user is logged
 // out when the new countdown expires.
 TEST_F(LogoutConfirmationControllerTest, DurationShortened) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(30));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(30));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(9));
   EXPECT_FALSE(log_out_called_);
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(9));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
   EXPECT_TRUE(log_out_called_);
 }
 
 // Verifies that when a second request to confirm logout is made and the second
 // request's countdown ends after the original request's, the user is logged
 // out when the original countdown expires.
 TEST_F(LogoutConfirmationControllerTest, DurationExtended) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(9));
   EXPECT_FALSE(log_out_called_);
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
   EXPECT_TRUE(log_out_called_);
 }
 
 // Verifies that when the screen is locked while the countdown is running, the
 // user is not logged out, even when the original countdown expires.
 TEST_F(LogoutConfirmationControllerTest, Lock) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   controller_.OnLockStateChanged(true);
   runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(log_out_called_);
 }
 
 // Verifies that when the user confirms the logout request, the user is logged
 // out immediately.
 TEST_F(LogoutConfirmationControllerTest, UserAccepted) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   controller_.OnLogoutConfirmed();
   EXPECT_TRUE(log_out_called_);
 }
 
 // Verifies that when the user denies the logout request, the user is not logged
 // out, even when the original countdown expires.
 TEST_F(LogoutConfirmationControllerTest, UserDenied) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   controller_.OnDialogClosed();
   runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(log_out_called_);
 }
 
 // Verifies that after the user has denied a logout request, a subsequent logout
 // request is handled correctly and the user is logged out when the countdown
 // expires.
 TEST_F(LogoutConfirmationControllerTest, DurationExpiredAfterDeniedRequest) {
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   controller_.OnDialogClosed();
   runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(log_out_called_);
 
-  controller_.ConfirmLogout(
-      runner_->GetCurrentMockTime() + base::TimeDelta::FromSeconds(10));
+  controller_.ConfirmLogout(runner_->NowTicks() +
+                            base::TimeDelta::FromSeconds(10));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(9));
   EXPECT_FALSE(log_out_called_);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
   EXPECT_TRUE(log_out_called_);
 }
 
 }  // namespace ash