Use OnceCallback on Mojo interfaces in //ash

ash/wm/session_state_animator_impl.cc

 // Copyright (c) 2012 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/wm/session_state_animator_impl.h"
 
+#include <utility>
 #include <vector>
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/shell.h"
 #include "ash/wm/wm_window_animations.h"
 #include "base/barrier_closure.h"
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer_animation_observer.h"
@@ skipping 418 matching lines @@
 // equal, observer will delete itself, calling callback passed to constructor if
 // there were no aborted animations.
 // This way it can be either used to wait for some animation to be finished in
 // multiple layers, to wait once a sequence of animations is finished in one
 // layer or the mixture of both.
 class SessionStateAnimatorImpl::AnimationSequence
     : public SessionStateAnimator::AnimationSequence,
       public ui::LayerAnimationObserver {
  public:
   explicit AnimationSequence(SessionStateAnimatorImpl* animator,
-                             base::Closure callback)
-      : SessionStateAnimator::AnimationSequence(callback),
+                             base::OnceClosure callback)
+      : SessionStateAnimator::AnimationSequence(std::move(callback)),
         animator_(animator),
         sequences_attached_(0),
         sequences_completed_(0) {}
 
   // SessionStateAnimator::AnimationSequence:
   void StartAnimation(int container_mask,
                       SessionStateAnimator::AnimationType type,
                       SessionStateAnimator::AnimationSpeed speed) override {
     animator_->StartAnimationInSequence(container_mask, type, speed, this);
   }
@@ skipping 82 matching lines @@
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     RunAnimationForWindow(*it, type, speed, NULL);
   }
 }
 
 void SessionStateAnimatorImpl::StartAnimationWithCallback(
     int container_mask,
     AnimationType type,
     AnimationSpeed speed,
-    base::Closure callback) {
+    base::OnceClosure callback) {
   aura::Window::Windows containers;
   GetContainers(container_mask, &containers);
   base::Closure animation_done_closure =
-      base::BarrierClosure(containers.size(), callback);
+      base::BarrierClosure(containers.size(), std::move(callback));
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     ui::LayerAnimationObserver* observer =
         new CallbackAnimationObserver(animation_done_closure);
     RunAnimationForWindow(*it, type, speed, observer);
   }
 }
 
 SessionStateAnimator::AnimationSequence*
-SessionStateAnimatorImpl::BeginAnimationSequence(base::Closure callback) {
-  return new AnimationSequence(this, callback);
+SessionStateAnimatorImpl::BeginAnimationSequence(base::OnceClosure callback) {
+  return new AnimationSequence(this, std::move(callback));
 }
 
 bool SessionStateAnimatorImpl::IsWallpaperHidden() const {
   return !GetWallpaper()->IsVisible();
 }
 
 void SessionStateAnimatorImpl::ShowWallpaper() {
   ui::ScopedLayerAnimationSettings settings(
       GetWallpaper()->layer()->GetAnimator());
   settings.SetTransitionDuration(base::TimeDelta());
@@ skipping 80 matching lines @@
                                                  gfx::Tween::EASE_IN, observer);
       break;
     case ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS:
       StartGrayscaleBrightnessAnimationForWindow(
           window, 0.0, duration, gfx::Tween::EASE_IN_OUT, observer);
       break;
   }
 }
 
 }  // namespace ash