Use OnceCallback on Mojo interfaces in //ash

ash/test/test_session_state_animator.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/test/test_session_state_animator.h"
 
+#include <utility>
 #include <vector>
 
+#include "base/barrier_closure.h"
 #include "base/bind.h"
 
 namespace ash {
 namespace test {
 
 namespace {
 // A no-op callback that can be used when managing an animation that didn't
 // actually have a callback given.
 void DummyCallback() {}
 }
 
 const SessionStateAnimator::Container
     TestSessionStateAnimator::kAllContainers[] = {
         SessionStateAnimator::WALLPAPER,
         SessionStateAnimator::LAUNCHER,
         SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
         SessionStateAnimator::LOCK_SCREEN_WALLPAPER,
         SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
         SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS,
         SessionStateAnimator::ROOT_CONTAINER};
 
 // A simple SessionStateAnimator::AnimationSequence that tracks the number of
 // attached sequences.  The callback will be invoked if all animations complete
 // successfully.
 class TestSessionStateAnimator::AnimationSequence
     : public SessionStateAnimator::AnimationSequence {
  public:
-  AnimationSequence(base::Closure callback, TestSessionStateAnimator* animator)
-      : SessionStateAnimator::AnimationSequence(callback),
+  AnimationSequence(base::OnceClosure callback,
+                    TestSessionStateAnimator* animator)
+      : SessionStateAnimator::AnimationSequence(std::move(callback)),
         sequence_count_(0),
         sequence_aborted_(false),
         animator_(animator) {}
 
   ~AnimationSequence() override {}
 
   virtual void SequenceAttached() { ++sequence_count_; }
 
   // Notify the sequence that is has completed.
   virtual void SequenceFinished(bool successfully) {
@@ skipping 155 matching lines @@
       base::Closure callback = base::Bind(&DummyCallback);
       AddAnimation(kAllContainers[i], type, speed, callback, callback);
     }
   }
 }
 
 void TestSessionStateAnimator::StartAnimationWithCallback(
     int container_mask,
     AnimationType type,
     AnimationSpeed speed,
-    base::Closure callback) {
+    base::OnceClosure callback) {
   ++last_animation_epoch_;
-  for (size_t i = 0; i < arraysize(kAllContainers); ++i)
+
+  int container_count = 0;
+  for (size_t i = 0; i < arraysize(kAllContainers); ++i) {
+    if (container_mask & kAllContainers[i])
+      ++container_count;
+  }
+
+  base::RepeatingClosure completion_callback =
+      base::BarrierClosure(container_count, std::move(callback));
+  for (size_t i = 0; i < arraysize(kAllContainers); ++i) {
     if (container_mask & kAllContainers[i]) {
       // ash::SessionStateAnimatorImpl invokes the callback whether or not the
       // animation was completed successfully or not.
-      AddAnimation(kAllContainers[i], type, speed, callback, callback);
+      AddAnimation(kAllContainers[i], type, speed, completion_callback,
+                   completion_callback);
     }
+  }
 }
 
 ash::SessionStateAnimator::AnimationSequence*
-TestSessionStateAnimator::BeginAnimationSequence(base::Closure callback) {
-  return new AnimationSequence(callback, this);
+TestSessionStateAnimator::BeginAnimationSequence(base::OnceClosure callback) {
+  return new AnimationSequence(std::move(callback), this);
 }
 
 bool TestSessionStateAnimator::IsWallpaperHidden() const {
   return is_wallpaper_hidden_;
 }
 
 void TestSessionStateAnimator::ShowWallpaper() {
   is_wallpaper_hidden_ = false;
 }
 
@@ skipping 47 matching lines @@
     while (animation_iter != (*container_iter).second.end()) {
       ActiveAnimation active_animation = *animation_iter;
       active_animation.failed_callback.Run();
       animation_iter = (*container_iter).second.erase(animation_iter);
     }
   }
 }
 
 }  // namespace test
 }  // namespace ash