Replace base::Timer with behavior-specific timers in ash/ and chromeos/

This CL replaces base::Timer with its subclasses.
As base::Timer changes its behavior subject to its construction time
flags, that makes hard to see the actual timer behavior, especially
it's unclear when a timer is injected from other components.
Also, that OnceCallback support of base::Timer is hard to implement on
the dynamically determined invocation pattern.

Bug: 850247
Change-Id: Ic99f2456dbb1b477ebb8f320b6a472d5a0e4c6bf
Reviewed-on: https://chromium-review.googlesource.com/1128663
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Cr-Commit-Position: refs/heads/master@{#573598}

ash/autoclick/common/autoclick_controller_common.cc

@@ -105,10 +105,10 @@ void AutoclickControllerCommon::CancelAutoclick() {
 }
 
 void AutoclickControllerCommon::InitClickTimer() {
-  autoclick_timer_.reset(new base::Timer(
-      FROM_HERE, delay_, base::Bind(&AutoclickControllerCommon::DoAutoclick,
-                                    base::Unretained(this)),
-      false));
+  autoclick_timer_.reset(new base::RetainingOneShotTimer(
+      FROM_HERE, delay_,
+      base::Bind(&AutoclickControllerCommon::DoAutoclick,
+                 base::Unretained(this))));
 }
 
 void AutoclickControllerCommon::DoAutoclick() {

ash/autoclick/common/autoclick_controller_common.h

@@ -48,7 +48,7 @@ class AutoclickControllerCommon {
 
   base::TimeDelta delay_;
   int mouse_event_flags_;
-  std::unique_ptr<base::Timer> autoclick_timer_;
+  std::unique_ptr<base::RetainingOneShotTimer> autoclick_timer_;
   AutoclickControllerCommonDelegate* delegate_;
   views::Widget* widget_;
   // The position in screen coordinates used to determine

ash/components/cursor/cursor_view.cc

@@ -67,12 +67,11 @@ CursorView::CursorView(aura::Window* container,
           {base::TaskPriority::USER_BLOCKING,
            base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
       new_location_(initial_location),
-      stationary_timer_(new base::Timer(
+      stationary_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kStationaryDelayMs),
           base::BindRepeating(&CursorView::StationaryOnPaintThread,
-                              base::Unretained(this)),
-          /*is_repeating=*/false)),
+                              base::Unretained(this))),
       weak_ptr_factory_(this) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(ui_sequence_checker_);
 
@@ -159,7 +158,7 @@ void CursorView::OnTimerTick() {
 
   // Restart stationary timer if pointer location changed.
   if (location_ != old_location)
-    stationary_timer_->Reset();
+    stationary_timer_.Reset();
 
   base::TimeDelta interval = time_source_->Interval();
   // Compute velocity unless this is the first tick.
@@ -255,7 +254,7 @@ void CursorView::OnTimerTick() {
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(update_surface_callback_, cursor_rect_, damage_rect,
-                     /*auto_refresh=*/stationary_timer_->IsRunning()));
+                     /*auto_refresh=*/stationary_timer_.IsRunning()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -264,7 +263,7 @@ void CursorView::OnTimerTick() {
 void CursorView::StationaryOnPaintThread() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(paint_sequence_checker_);
 
-  stationary_timer_->Stop();
+  stationary_timer_.Stop();
   ui_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(update_surface_callback_, cursor_rect_,
                                 /*damage_rect=*/gfx::Rect(),

ash/components/cursor/cursor_view.h

@@ -7,6 +7,7 @@
 
 #include "ash/components/fast_ink/fast_ink_view.h"
 #include "base/sequence_checker.h"
+#include "base/timer/timer.h"
 #include "components/viz/common/frame_sinks/delay_based_time_source.h"
 #include "ui/events/ozone/chromeos/cursor_controller.h"
 
@@ -78,7 +79,7 @@ class CursorView : public fast_ink::FastInkView,
   SkMatrix motion_blur_matrix_;
   SkMatrix motion_blur_inverse_matrix_;
   std::unique_ptr<viz::DelayBasedTimeSource> time_source_;
-  std::unique_ptr<base::Timer> stationary_timer_;
+  base::RetainingOneShotTimer stationary_timer_;
   base::RepeatingCallback<void(const gfx::Rect&, const gfx::Rect&, bool)>
       update_surface_callback_;
   SEQUENCE_CHECKER(paint_sequence_checker_);

ash/laser/laser_pointer_view.cc

@@ -164,12 +164,10 @@ LaserPointerView::LaserPointerView(base::TimeDelta life_duration,
       laser_points_(life_duration),
       predicted_laser_points_(life_duration),
       presentation_delay_(presentation_delay),
-      stationary_timer_(
-          new base::Timer(FROM_HERE,
-                          stationary_point_delay,
-                          base::BindRepeating(&LaserPointerView::UpdateTime,
-                                              base::Unretained(this)),
-                          /*is_repeating=*/true)),
+      stationary_timer_(FROM_HERE,
+                        stationary_point_delay,
+                        base::BindRepeating(&LaserPointerView::UpdateTime,
+                                            base::Unretained(this))),
       weak_ptr_factory_(this) {}
 
 LaserPointerView::~LaserPointerView() = default;
@@ -186,7 +184,7 @@ void LaserPointerView::AddNewPoint(const gfx::PointF& new_point,
                      : 0);
   AddPoint(new_point, new_time);
   stationary_point_location_ = new_point;
-  stationary_timer_->Reset();
+  stationary_timer_.Reset();
 }
 
 void LaserPointerView::FadeOut(base::OnceClosure done) {

ash/laser/laser_pointer_view.h

@@ -7,6 +7,7 @@
 
 #include "ash/components/fast_ink/fast_ink_points.h"
 #include "ash/components/fast_ink/fast_ink_view.h"
+#include "base/timer/timer.h"
 
 namespace ash {
 
@@ -42,7 +43,7 @@ class LaserPointerView : public fast_ink::FastInkView {
   const base::TimeDelta presentation_delay_;
   // Timer which will add a new stationary point when the stylus stops moving.
   // This will remove points that are too old.
-  std::unique_ptr<base::Timer> stationary_timer_;
+  base::RepeatingTimer stationary_timer_;
   gfx::PointF stationary_point_location_;
   // A callback for when the fadeout is complete.
   base::OnceClosure fadeout_done_;

ash/login/ui/login_pin_view.cc

@@ -249,8 +249,8 @@ class LoginPinView::BackspacePinButton : public BasePinButton {
 
   ~BackspacePinButton() override = default;
 
-  void SetTimersForTesting(std::unique_ptr<base::Timer> delay_timer,
-                           std::unique_ptr<base::Timer> repeat_timer) {
+  void SetTimersForTesting(std::unique_ptr<base::OneShotTimer> delay_timer,
+                           std::unique_ptr<base::RepeatingTimer> repeat_timer) {
     delay_timer_ = std::move(delay_timer);
     repeat_timer_ = std::move(repeat_timer);
   }
@@ -341,8 +341,8 @@ class LoginPinView::BackspacePinButton : public BasePinButton {
   }
 
   bool is_held_ = false;
-  std::unique_ptr<base::Timer> delay_timer_;
-  std::unique_ptr<base::Timer> repeat_timer_;
+  std::unique_ptr<base::OneShotTimer> delay_timer_;
+  std::unique_ptr<base::RepeatingTimer> repeat_timer_;
 
   views::ImageView* image_ = nullptr;
 
@@ -362,8 +362,8 @@ views::View* LoginPinView::TestApi::GetBackspaceButton() const {
 }
 
 void LoginPinView::TestApi::SetBackspaceTimers(
-    std::unique_ptr<base::Timer> delay_timer,
-    std::unique_ptr<base::Timer> repeat_timer) {
+    std::unique_ptr<base::OneShotTimer> delay_timer,
+    std::unique_ptr<base::RepeatingTimer> repeat_timer) {
   view_->backspace_->SetTimersForTesting(std::move(delay_timer),
                                          std::move(repeat_timer));
 }

ash/login/ui/login_pin_view.h

@@ -14,7 +14,8 @@
 #include "ui/views/view.h"
 
 namespace base {
-class Timer;
+class OneShotTimer;
+class RepeatingTimer;
 }  // namespace base
 
 namespace ash {
@@ -58,8 +59,8 @@ class ASH_EXPORT LoginPinView : public NonAccessibleView {
     // Sets the timers that are used for backspace auto-submit. |delay_timer| is
     // the initial delay before an auto-submit, and |repeat_timer| fires
     // whenever a new backspace event should run after the initial delay.
-    void SetBackspaceTimers(std::unique_ptr<base::Timer> delay_timer,
-                            std::unique_ptr<base::Timer> repeat_timer);
+    void SetBackspaceTimers(std::unique_ptr<base::OneShotTimer> delay_timer,
+                            std::unique_ptr<base::RepeatingTimer> repeat_timer);
 
    private:
     LoginPinView* const view_;

ash/system/network/auto_connect_notifier.h

@@ -15,7 +15,7 @@
 #include "chromeos/network/network_state_handler_observer.h"
 
 namespace base {
-class Timer;
+class OneShotTimer;
 }
 
 namespace ash {
@@ -41,7 +41,7 @@ class ASH_EXPORT AutoConnectNotifier
   // chromeos::AutoConnectHandler::Observer:
   void OnAutoConnectedInitiated(int auto_connect_reasons) override;
 
-  void set_timer_for_testing(std::unique_ptr<base::Timer> test_timer) {
+  void set_timer_for_testing(std::unique_ptr<base::OneShotTimer> test_timer) {
     timer_ = std::move(test_timer);
   }
 
@@ -51,7 +51,7 @@ class ASH_EXPORT AutoConnectNotifier
   void DisplayNotification();
 
   bool has_user_explicitly_requested_connection_ = false;
-  std::unique_ptr<base::Timer> timer_;
+  std::unique_ptr<base::OneShotTimer> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoConnectNotifier);
 };

ash/system/session/logout_confirmation_controller.cc

@@ -119,8 +119,7 @@ class LogoutConfirmationController::LastWindowClosedObserver
 
 LogoutConfirmationController::LogoutConfirmationController()
     : clock_(base::DefaultTickClock::GetInstance()),
-      logout_closure_(base::Bind(&SignOut)),
-      logout_timer_(false, false) {
+      logout_closure_(base::Bind(&SignOut)) {
   if (Shell::HasInstance())  // Null in testing::Test.
     Shell::Get()->session_controller()->AddObserver(this);
 }

ash/system/session/logout_confirmation_controller.h

@@ -70,7 +70,7 @@ class ASH_EXPORT LogoutConfirmationController : public SessionObserver {
 
   base::TimeTicks logout_time_;
   LogoutConfirmationDialog* dialog_ = nullptr;  // Owned by the Views hierarchy.
-  base::Timer logout_timer_;
+  base::OneShotTimer logout_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(LogoutConfirmationController);
 };

chrome/browser/chromeos/arc/voice_interaction/highlighter_controller_client.cc

@@ -62,12 +62,11 @@ void HighlighterControllerClient::ConnectToHighlighterController() {
 void HighlighterControllerClient::HandleSelection(const gfx::Rect& rect) {
   // Delay the actual voice interaction service invocation for better
   // visual synchronization with the metalayer animation.
-  delay_timer_ = std::make_unique<base::Timer>(
+  delay_timer_ = std::make_unique<base::OneShotTimer>();
+  delay_timer_->Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kSelectionReportDelayMs),
       base::Bind(&HighlighterControllerClient::ReportSelection,
-                 base::Unretained(this), rect),
-      false /* is_repeating */);
-  delay_timer_->Reset();
+                 base::Unretained(this), rect));
 }
 
 void HighlighterControllerClient::HandleEnabledStateChange(bool enabled) {

chrome/browser/chromeos/arc/voice_interaction/highlighter_controller_client.h

@@ -16,7 +16,7 @@ class Rect;
 }  // namespace gfx
 
 namespace base {
-class Timer;
+class OneShotTimer;
 }  // namespace base
 
 namespace service_manager {
@@ -73,7 +73,7 @@ class HighlighterControllerClient
 
   ArcVoiceInteractionFrameworkService* service_;
 
-  std::unique_ptr<base::Timer> delay_timer_;
+  std::unique_ptr<base::OneShotTimer> delay_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(HighlighterControllerClient);
 };

chrome/browser/chromeos/attestation/platform_verification_flow.cc

@@ -262,8 +262,7 @@ void PlatformVerificationFlow::OnAttestationPrepared(
 void PlatformVerificationFlow::GetCertificate(const ChallengeContext& context,
                                               const AccountId& account_id,
                                               bool force_new_key) {
-  std::unique_ptr<base::Timer> timer(new base::Timer(false,    // Don't retain.
-                                                     false));  // Don't repeat.
+  std::unique_ptr<base::OneShotTimer> timer(new base::OneShotTimer());
   base::Closure timeout_callback = base::Bind(
       &PlatformVerificationFlow::OnCertificateTimeout,
       this,
@@ -281,7 +280,7 @@ void PlatformVerificationFlow::GetCertificate(const ChallengeContext& context,
 void PlatformVerificationFlow::OnCertificateReady(
     const ChallengeContext& context,
     const AccountId& account_id,
-    std::unique_ptr<base::Timer> timer,
+    std::unique_ptr<base::OneShotTimer> timer,
     AttestationStatus operation_status,
     const std::string& certificate_chain) {
   // Log failure before checking the timer so all failures are logged, even if

chrome/browser/chromeos/attestation/platform_verification_flow.h

@@ -199,7 +199,7 @@ class PlatformVerificationFlow
   // not invoked.
   void OnCertificateReady(const ChallengeContext& context,
                           const AccountId& account_id,
-                          std::unique_ptr<base::Timer> timer,
+                          std::unique_ptr<base::OneShotTimer> timer,
                           AttestationStatus operation_status,
                           const std::string& certificate_chain);
 

chrome/browser/chromeos/certificate_provider/certificate_requests.cc

@@ -24,12 +24,12 @@ const int kGetCertificatesTimeoutInMinutes = 5;
 
 // Holds state for a single certificate request.
 struct CertificateRequests::CertificateRequestState {
-  CertificateRequestState() : timeout(false, false) {}
+  CertificateRequestState() {}
 
   ~CertificateRequestState() {}
 
   // Extensions that are too slow are eventually dropped from a request.
-  base::Timer timeout;
+  base::OneShotTimer timeout;
 
   // Extensions that this request is still waiting for.
   std::set<std::string> pending_extensions;

chrome/browser/chromeos/login/screens/user_image_screen.cc

@@ -212,11 +212,10 @@ void UserImageScreen::Show() {
         return;
       }
       sync_observer->AddObserver(this);
-      sync_timer_.reset(new base::Timer(
+      sync_timer_.reset(new base::OneShotTimer());
+      sync_timer_->Start(
           FROM_HERE, base::TimeDelta::FromSeconds(kSyncTimeoutSeconds),
-          base::Bind(&UserImageScreen::OnSyncTimeout, base::Unretained(this)),
-          false));
-      sync_timer_->Reset();
+          base::Bind(&UserImageScreen::OnSyncTimeout, base::Unretained(this)));
     }
   }
   CameraPresenceNotifier::GetInstance()->AddObserver(this);

chrome/browser/chromeos/login/screens/user_image_screen.h

@@ -18,7 +18,7 @@
 #include "components/user_manager/user_manager.h"
 
 namespace base {
-class Timer;
+class OneShotTimer;
 class Value;
 }  // namespace base
 
@@ -148,7 +148,7 @@ class UserImageScreen : public BaseScreen,
   bool user_has_selected_image_ = false;
 
   // Timer used for waiting for user image sync.
-  std::unique_ptr<base::Timer> sync_timer_;
+  std::unique_ptr<base::OneShotTimer> sync_timer_;
 
   // The time when we started wait for user image sync.
   base::Time sync_waiting_start_time_;

chrome/browser/chromeos/resource_reporter/resource_reporter_unittest.cc

@@ -62,7 +62,7 @@ constexpr size_t kTasksSize = arraysize(kTestTasks);
 class DummyTaskManager : public task_manager::TestTaskManager {
  public:
   DummyTaskManager() {
-    set_timer_for_testing(std::make_unique<base::MockOneShotTimer>());
+    set_timer_for_testing(std::make_unique<base::MockRepeatingTimer>());
   }
   ~DummyTaskManager() override {}
 

chrome/browser/chromeos/tether/tether_service.cc

@@ -679,7 +679,7 @@ bool TetherService::HandleFeatureStateMetricIfUninitialized() {
 void TetherService::SetTestDoubles(
     std::unique_ptr<chromeos::tether::NotificationPresenter>
         notification_presenter,
-    std::unique_ptr<base::Timer> timer) {
+    std::unique_ptr<base::OneShotTimer> timer) {
   notification_presenter_ = std::move(notification_presenter);
   timer_ = std::move(timer);
 }

chrome/browser/chromeos/tether/tether_service.h

@@ -238,7 +238,7 @@ class TetherService : public KeyedService,
 
   void SetTestDoubles(std::unique_ptr<chromeos::tether::NotificationPresenter>
                           notification_presenter,
-                      std::unique_ptr<base::Timer> timer);
+                      std::unique_ptr<base::OneShotTimer> timer);
 
   // Whether the service has been shut down.
   bool shut_down_ = false;
@@ -283,7 +283,7 @@ class TetherService : public KeyedService,
 
   PrefChangeRegistrar registrar_;
   scoped_refptr<device::BluetoothAdapter> adapter_;
-  std::unique_ptr<base::Timer> timer_;
+  std::unique_ptr<base::OneShotTimer> timer_;
 
   base::WeakPtrFactory<TetherService> weak_ptr_factory_;
 

chrome/browser/ui/ash/multi_user/user_switch_animator_chromeos.cc

@@ -96,12 +96,11 @@ UserSwitchAnimatorChromeOS::UserSwitchAnimatorChromeOS(
   if (!animation_speed_ms_) {
     FinalizeAnimation();
   } else {
-    user_changed_animation_timer_.reset(new base::Timer(
+    user_changed_animation_timer_.reset(new base::RepeatingTimer());
+    user_changed_animation_timer_->Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(animation_speed_ms_),
         base::Bind(&UserSwitchAnimatorChromeOS::AdvanceUserTransitionAnimation,
-                   base::Unretained(this)),
-        true));
-    user_changed_animation_timer_->Reset();
+                   base::Unretained(this)));
   }
 }
 

chrome/browser/ui/ash/multi_user/user_switch_animator_chromeos.h

@@ -112,7 +112,7 @@ class UserSwitchAnimatorChromeOS {
 
   // A timer which watches to executes the second part of a "user changed"
   // animation. Note that this timer exists only during such an animation.
-  std::unique_ptr<base::Timer> user_changed_animation_timer_;
+  std::unique_ptr<base::RepeatingTimer> user_changed_animation_timer_;
 
   // For unit tests: Check which wallpaper was set.
   std::string wallpaper_user_id_for_test_;

chrome/browser/ui/ash/tab_scrubber.cc

@@ -85,7 +85,6 @@ TabScrubber::TabScrubber()
       swipe_y_(-1),
       swipe_direction_(LEFT),
       highlighted_tab_(-1),
-      activate_timer_(true, false),
       activation_delay_(kActivationDelayMS),
       use_default_activation_delay_(true),
       weak_ptr_factory_(this) {

chrome/browser/ui/ash/tab_scrubber.h

@@ -96,7 +96,7 @@ class TabScrubber : public ui::EventHandler,
   // The index of the tab that is currently highlighted.
   int highlighted_tab_;
   // Timer to control a delayed activation of the |highlighted_tab_|.
-  base::Timer activate_timer_;
+  base::RetainingOneShotTimer activate_timer_;
   // Time to wait in ms before newly selected tab becomes active.
   int activation_delay_;
   // Set if activation_delay had been explicitly set.