Convert base::Bind and base::Callback in ash/display to Once/Repeating

Bug: 1007633
Change-Id: I91945e13761da0dcd237ce0667d5a72054f2e498
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1934524
Auto-Submit: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720346}

ash/display/display_animator.cc

@@ -30,8 +30,10 @@ const int kFadingTimeoutDurationInSeconds = 10;
 // runs the specified |callback| when all of the animations have finished.
 class CallbackRunningObserver {
  public:
-  CallbackRunningObserver(base::Closure callback)
-      : completed_counter_(0), animation_aborted_(false), callback_(callback) {}
+  CallbackRunningObserver(base::OnceClosure callback)
+      : completed_counter_(0),
+        animation_aborted_(false),
+        callback_(std::move(callback)) {}
 
   void AddNewAnimator(ui::LayerAnimator* animator) {
     auto observer = std::make_unique<Observer>(animator, this);
@@ -45,7 +47,8 @@ class CallbackRunningObserver {
     if (completed_counter_ >= observer_list_.size()) {
       base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
       if (!animation_aborted_)
-        base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback_);
+        base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                      std::move(callback_));
     }
   }
 
@@ -87,7 +90,7 @@ class CallbackRunningObserver {
   size_t completed_counter_;
   bool animation_aborted_;
   std::vector<std::unique_ptr<Observer>> observer_list_;
-  base::Closure callback_;
+  base::OnceClosure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackRunningObserver);
 };
@@ -103,8 +106,9 @@ DisplayAnimator::~DisplayAnimator() {
   ClearHidingLayers();
 }
 
-void DisplayAnimator::StartFadeOutAnimation(base::Closure callback) {
-  CallbackRunningObserver* observer = new CallbackRunningObserver(callback);
+void DisplayAnimator::StartFadeOutAnimation(base::OnceClosure callback) {
+  CallbackRunningObserver* observer =
+      new CallbackRunningObserver(std::move(callback));
   ClearHidingLayers();
 
   // Make the fade-out animation for all root windows.  Instead of actually
@@ -146,8 +150,9 @@ void DisplayAnimator::StartFadeInAnimation() {
   // finished.  Note that this callback can be canceled, but the cancel only
   // happens when the next animation is scheduled.  Thus the hiding layers
   // should be deleted eventually.
-  CallbackRunningObserver* observer = new CallbackRunningObserver(base::Bind(
-      &DisplayAnimator::ClearHidingLayers, weak_ptr_factory_.GetWeakPtr()));
+  CallbackRunningObserver* observer =
+      new CallbackRunningObserver(base::BindOnce(
+          &DisplayAnimator::ClearHidingLayers, weak_ptr_factory_.GetWeakPtr()));
 
   // Ensure that layers are not animating.
   for (auto& e : hiding_layers_) {

ash/display/display_animator.h

@@ -35,7 +35,7 @@ class ASH_EXPORT DisplayAnimator
   DisplayAnimator();
   ~DisplayAnimator() override;
 
-  void StartFadeOutAnimation(base::Closure callback);
+  void StartFadeOutAnimation(base::OnceClosure callback);
   void StartFadeInAnimation();
 
  protected:

ash/display/display_color_manager.cc

@@ -333,10 +333,10 @@ bool DisplayColorManager::LoadCalibrationForDisplay(
 
   quirks::QuirksManager::Get()->RequestIccProfilePath(
       display->product_code(), display->display_name(),
-      base::Bind(&DisplayColorManager::FinishLoadCalibrationForDisplay,
-                 weak_ptr_factory_.GetWeakPtr(), display->display_id(),
-                 display->product_code(),
-                 display->has_color_correction_matrix(), display->type()));
+      base::BindOnce(&DisplayColorManager::FinishLoadCalibrationForDisplay,
+                     weak_ptr_factory_.GetWeakPtr(), display->display_id(),
+                     display->product_code(),
+                     display->has_color_correction_matrix(), display->type()));
   return true;
 }
 
@@ -373,9 +373,9 @@ void DisplayColorManager::FinishLoadCalibrationForDisplay(
 
   base::PostTaskAndReplyWithResult(
       sequenced_task_runner_.get(), FROM_HERE,
-      base::Bind(&ParseDisplayProfile, path, has_color_correction_matrix),
-      base::Bind(&DisplayColorManager::UpdateCalibrationData,
-                 weak_ptr_factory_.GetWeakPtr(), display_id, product_code));
+      base::BindOnce(&ParseDisplayProfile, path, has_color_correction_matrix),
+      base::BindOnce(&DisplayColorManager::UpdateCalibrationData,
+                     weak_ptr_factory_.GetWeakPtr(), display_id, product_code));
 }
 
 void DisplayColorManager::UpdateCalibrationData(

ash/display/display_color_manager_unittest.cc

@@ -39,8 +39,8 @@ class DisplayColorManagerForTest : public DisplayColorManager {
       display::DisplayConfigurator* configurator)
       : DisplayColorManager(configurator, nullptr /* display_to_observe */) {}
 
-  void SetOnFinishedForTest(base::Closure on_finished_for_test) {
-    on_finished_for_test_ = on_finished_for_test;
+  void SetOnFinishedForTest(base::OnceClosure on_finished_for_test) {
+    on_finished_for_test_ = std::move(on_finished_for_test);
   }
 
  private:
@@ -54,8 +54,8 @@ class DisplayColorManagerForTest : public DisplayColorManager {
         display_id, product_id, has_color_correction_matrix, type, path,
         file_downloaded);
     // If path is empty, there is no icc file, and the DCM's work is done.
-    if (path.empty() && !on_finished_for_test_.is_null()) {
-      on_finished_for_test_.Run();
+    if (path.empty() && on_finished_for_test_) {
+      std::move(on_finished_for_test_).Run();
       on_finished_for_test_.Reset();
     }
   }
@@ -66,13 +66,13 @@ class DisplayColorManagerForTest : public DisplayColorManager {
       std::unique_ptr<ColorCalibrationData> data) override {
     DisplayColorManager::UpdateCalibrationData(display_id, product_id,
                                                std::move(data));
-    if (!on_finished_for_test_.is_null()) {
-      on_finished_for_test_.Run();
+    if (on_finished_for_test_) {
+      std::move(on_finished_for_test_).Run();
       on_finished_for_test_.Reset();
     }
   }
 
-  base::Closure on_finished_for_test_;
+  base::OnceClosure on_finished_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayColorManagerForTest);
 };

ash/display/display_configuration_controller.cc

@@ -99,8 +99,8 @@ void DisplayConfigurationController::SetDisplayLayout(
     std::unique_ptr<display::DisplayLayout> layout) {
   if (display_animator_) {
     display_animator_->StartFadeOutAnimation(
-        base::Bind(&DisplayConfigurationController::SetDisplayLayoutImpl,
-                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&layout)));
+        base::BindOnce(&DisplayConfigurationController::SetDisplayLayoutImpl,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(layout)));
   } else {
     SetDisplayLayoutImpl(std::move(layout));
   }
@@ -111,7 +111,7 @@ void DisplayConfigurationController::SetUnifiedDesktopLayoutMatrix(
   DCHECK(display_manager_->IsInUnifiedMode());
 
   if (display_animator_) {
-    display_animator_->StartFadeOutAnimation(base::Bind(
+    display_animator_->StartFadeOutAnimation(base::BindOnce(
         &DisplayConfigurationController::SetUnifiedDesktopLayoutMatrixImpl,
         weak_ptr_factory_.GetWeakPtr(), matrix));
   } else {
@@ -128,8 +128,8 @@ void DisplayConfigurationController::SetMirrorMode(bool mirror, bool throttle) {
   SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
   if (display_animator_) {
     display_animator_->StartFadeOutAnimation(
-        base::Bind(&DisplayConfigurationController::SetMirrorModeImpl,
-                   weak_ptr_factory_.GetWeakPtr(), mirror));
+        base::BindOnce(&DisplayConfigurationController::SetMirrorModeImpl,
+                       weak_ptr_factory_.GetWeakPtr(), mirror));
   } else {
     SetMirrorModeImpl(mirror);
   }
@@ -176,8 +176,8 @@ void DisplayConfigurationController::SetPrimaryDisplayId(int64_t display_id,
   SetThrottleTimeout(kSetPrimaryDisplayThrottleTimeoutMs);
   if (display_animator_) {
     display_animator_->StartFadeOutAnimation(
-        base::Bind(&DisplayConfigurationController::SetPrimaryDisplayIdImpl,
-                   weak_ptr_factory_.GetWeakPtr(), display_id));
+        base::BindOnce(&DisplayConfigurationController::SetPrimaryDisplayIdImpl,
+                       weak_ptr_factory_.GetWeakPtr(), display_id));
   } else {
     SetPrimaryDisplayIdImpl(display_id);
   }