clang-format all of //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 <vector>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/shell.h"
@@ skipping 50 matching lines @@
 }
 
 // Slowly shrinks |window| to a slightly-smaller size.
 void StartSlowCloseAnimationForWindow(aura::Window* window,
                                       base::TimeDelta duration,
                                       ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
-      ui::LayerAnimationElement::CreateTransformElement(
-          GetSlowCloseTransform(),
-          duration));
+      ui::LayerAnimationElement::CreateTransformElement(GetSlowCloseTransform(),
+                                                        duration));
   if (observer)
     sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
 // Quickly undoes the effects of the slow-close animation on |window|.
 void StartUndoSlowCloseAnimationForWindow(
     aura::Window* window,
     base::TimeDelta duration,
     ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
-      ui::LayerAnimationElement::CreateTransformElement(
-          gfx::Transform(),
-          duration));
+      ui::LayerAnimationElement::CreateTransformElement(gfx::Transform(),
+                                                        duration));
   if (observer)
     sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
 // Quickly shrinks |window| down to a point in the center of the screen and
 // fades it out to 0 opacity.
 void StartFastCloseAnimationForWindow(aura::Window* window,
                                       base::TimeDelta duration,
                                       ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  animator->StartAnimation(
-      new ui::LayerAnimationSequence(
-          ui::LayerAnimationElement::CreateTransformElement(
-              GetFastCloseTransform(), duration)));
+  animator->StartAnimation(new ui::LayerAnimationSequence(
+      ui::LayerAnimationElement::CreateTransformElement(GetFastCloseTransform(),
+                                                        duration)));
   ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
       ui::LayerAnimationElement::CreateOpacityElement(0.0, duration));
   if (observer)
     sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
 // Fades |window| to |target_opacity| over |duration|.
 void StartPartialFadeAnimation(aura::Window* window,
                                float target_opacity,
                                base::TimeDelta duration,
                                ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
-      ui::LayerAnimationElement::CreateOpacityElement(
-          target_opacity, duration));
+      ui::LayerAnimationElement::CreateOpacityElement(target_opacity,
+                                                      duration));
   if (observer)
     sequence->AddObserver(observer);
   animator->StartAnimation(sequence);
 }
 
 // Fades |window| to |opacity| over |duration|.
 void StartOpacityAnimationForWindow(aura::Window* window,
                                     float opacity,
                                     base::TimeDelta duration,
                                     ui::LayerAnimationObserver* observer) {
@@ skipping 29 matching lines @@
                 bool above,
                 ui::LayerAnimationObserver* observer) {
   ui::Layer* layer = window->layer();
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
 
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(duration);
 
   settings.SetTweenType(gfx::Tween::EASE_OUT);
-  SetTransformForScaleAnimation(layer,
-      above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
+  SetTransformForScaleAnimation(
+      layer, above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
 
   settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
   layer->SetOpacity(0.0f);
 
   // After the animation completes snap the transform back to the identity,
   // otherwise any one that asks for screen bounds gets a slightly scaled
   // version.
   settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
   settings.SetTransitionDuration(base::TimeDelta());
   layer->SetTransform(gfx::Transform());
 
   // A bit of a dirty trick: we need to catch the end of the animation we don't
   // control. So we use two facts we know: which animator will be used and the
   // target opacity to add "Do nothing" animation sequence.
   // Unfortunately, we can not just use empty LayerAnimationSequence, because
   // it does not call NotifyEnded().
   if (observer) {
     ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
-        ui::LayerAnimationElement::CreateOpacityElement(
-            0.0, base::TimeDelta()));
-      sequence->AddObserver(observer);
+        ui::LayerAnimationElement::CreateOpacityElement(0.0,
+                                                        base::TimeDelta()));
+    sequence->AddObserver(observer);
     layer->GetAnimator()->ScheduleAnimation(sequence);
   }
 }
 
 // Animates |window| to identity transform and full opacity over |duration|.
 void TransformWindowToBaseState(aura::Window* window,
                                 base::TimeDelta duration,
                                 ui::LayerAnimationObserver* observer) {
   ui::Layer* layer = window->layer();
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
 
   // Animate to target values.
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(duration);
 
   settings.SetTweenType(gfx::Tween::EASE_OUT);
   layer->SetTransform(gfx::Transform());
 
   settings.SetTweenType(gfx::Tween::EASE_IN_OUT);
   layer->SetOpacity(1.0f);
 
   // A bit of a dirty trick: we need to catch the end of the animation we don't
   // control. So we use two facts we know: which animator will be used and the
   // target opacity to add "Do nothing" animation sequence.
   // Unfortunately, we can not just use empty LayerAnimationSequence, because
   // it does not call NotifyEnded().
   if (observer) {
     ui::LayerAnimationSequence* sequence = new ui::LayerAnimationSequence(
-        ui::LayerAnimationElement::CreateOpacityElement(
-            1.0, base::TimeDelta()));
+        ui::LayerAnimationElement::CreateOpacityElement(1.0,
+                                                        base::TimeDelta()));
     sequence->AddObserver(observer);
     layer->GetAnimator()->ScheduleAnimation(sequence);
   }
 }
 
 void ShowWindow(aura::Window* window,
                 base::TimeDelta duration,
                 bool above,
                 ui::LayerAnimationObserver* observer) {
   ui::Layer* layer = window->layer();
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
 
   // Set initial state of animation
   settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta());
-  SetTransformForScaleAnimation(layer,
-      above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
+  SetTransformForScaleAnimation(
+      layer, above ? LAYER_SCALE_ANIMATION_ABOVE : LAYER_SCALE_ANIMATION_BELOW);
 
   TransformWindowToBaseState(window, duration, observer);
 }
 
 // Starts grayscale/brightness animation for |window| over |duration|. Target
 // value for both grayscale and brightness are specified by |target|.
 void StartGrayscaleBrightnessAnimationForWindow(
     aura::Window* window,
     float target,
     base::TimeDelta duration,
@@ skipping 27 matching lines @@
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartTogether(animations);
 }
 
 // Animation observer that will drop animated foreground once animation is
 // finished. It is used in when undoing shutdown animation.
 class CallbackAnimationObserver : public ui::LayerAnimationObserver {
  public:
   explicit CallbackAnimationObserver(base::Closure callback)
-      : callback_(callback) {
-  }
+      : callback_(callback) {}
   ~CallbackAnimationObserver() override {}
 
  private:
   // Overridden from ui::LayerAnimationObserver:
   void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override {
     // Drop foreground once animation is over.
     callback_.Run();
     delete this;
   }
 
   void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq) override {
     // Drop foreground once animation is over.
     callback_.Run();
     delete this;
   }
 
   void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq) override {}
 
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
 };
 
-
 bool IsLayerAnimated(ui::Layer* layer,
                      SessionStateAnimator::AnimationType type) {
   switch (type) {
     case SessionStateAnimator::ANIMATION_PARTIAL_CLOSE:
       if (layer->GetTargetTransform() != GetSlowCloseTransform())
         return false;
       break;
     case SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE:
       if (layer->GetTargetTransform() != gfx::Transform())
         return false;
@@ skipping 24 matching lines @@
           (layer->GetTargetGrayscale() < 0.9999))
         return false;
       break;
     case SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS:
       if ((layer->GetTargetBrightness() > 0.0001) ||
           (layer->GetTargetGrayscale() > 0.0001))
         return false;
       break;
     case SessionStateAnimator::ANIMATION_DROP:
     case SessionStateAnimator::ANIMATION_UNDO_LIFT:
-      //ToDo(antim) : check other effects
+      // ToDo(antim) : check other effects
       if (layer->GetTargetOpacity() < 0.9999)
         return false;
       break;
-      //ToDo(antim) : check other effects
+    // ToDo(antim) : check other effects
     case SessionStateAnimator::ANIMATION_LIFT:
       if (layer->GetTargetOpacity() > 0.0001)
         return false;
       break;
     case SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN:
-      //ToDo(antim) : check other effects
+      // ToDo(antim) : check other effects
       if (layer->GetTargetOpacity() < 0.9999)
         return false;
       break;
-      //ToDo(antim) : check other effects
+    // ToDo(antim) : check other effects
     case SessionStateAnimator::ANIMATION_LOWER_BELOW_SCREEN:
       if (layer->GetTargetOpacity() > 0.0001)
         return false;
       break;
     default:
       NOTREACHED() << "Unhandled animation type " << type;
       return false;
   }
   return true;
 }
@@ skipping 46 matching lines @@
 // This observer is intended to use in cases when some action has to be taken
 // once some animation successfully completes (i.e. it was not aborted).
 // Observer will count a number of sequences it is attached to, and a number of
 // finished sequences (either Ended or Aborted). Once these two numbers are
 // 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 SessionStateAnimator::AnimationSequence,
+      public ui::LayerAnimationObserver {
  public:
-  explicit AnimationSequence(
-      SessionStateAnimatorImpl* animator,
-      base::Closure callback)
+  explicit AnimationSequence(SessionStateAnimatorImpl* animator,
+                             base::Closure callback)
       : SessionStateAnimator::AnimationSequence(callback),
         animator_(animator),
         sequences_attached_(0),
-        sequences_completed_(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);
   }
 
  private:
   ~AnimationSequence() override {}
@@ skipping 24 matching lines @@
   // Number of sequences this observer was attached to.
   int sequences_attached_;
 
   // Number of sequences either ended or aborted.
   int sequences_completed_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimationSequence);
 };
 
 bool SessionStateAnimatorImpl::TestApi::ContainersAreAnimated(
-    int container_mask, AnimationType type) const {
+    int container_mask,
+    AnimationType type) const {
   aura::Window::Windows containers;
   animator_->GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
     ui::Layer* layer = window->layer();
     if (!IsLayerAnimated(layer, type))
       return false;
   }
   return true;
 }
 
-bool SessionStateAnimatorImpl::TestApi::RootWindowIsAnimated(AnimationType type)
-    const {
+bool SessionStateAnimatorImpl::TestApi::RootWindowIsAnimated(
+    AnimationType type) const {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   ui::Layer* layer = root_window->layer();
   return IsLayerAnimated(layer, type);
 }
 
-SessionStateAnimatorImpl::SessionStateAnimatorImpl() {
-}
+SessionStateAnimatorImpl::SessionStateAnimatorImpl() {}
 
-SessionStateAnimatorImpl::~SessionStateAnimatorImpl() {
-}
+SessionStateAnimatorImpl::~SessionStateAnimatorImpl() {}
 
 // Fills |containers| with the containers described by |container_mask|.
 void SessionStateAnimatorImpl::GetContainers(
     int container_mask,
     aura::Window::Windows* containers) {
   containers->clear();
 
   for (aura::Window* root_window : Shell::GetAllRootWindows())
     GetContainersInRootWindow(container_mask, root_window, containers);
 
@@ skipping 23 matching lines @@
   GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     ui::LayerAnimationObserver* observer =
         new CallbackAnimationObserver(callback);
     RunAnimationForWindow(*it, type, speed, observer);
   }
 }
 
 SessionStateAnimator::AnimationSequence*
-    SessionStateAnimatorImpl::BeginAnimationSequence(base::Closure callback) {
+SessionStateAnimatorImpl::BeginAnimationSequence(base::Closure callback) {
   return new AnimationSequence(this, callback);
 }
 
 bool SessionStateAnimatorImpl::IsBackgroundHidden() const {
   return !GetBackground()->IsVisible();
 }
 
 void SessionStateAnimatorImpl::ShowBackground() {
   ui::ScopedLayerAnimationSettings settings(
       GetBackground()->layer()->GetAnimator());
@@ skipping 61 matching lines @@
     case ANIMATION_UNDO_LIFT:
       TransformWindowToBaseState(window, duration, observer);
       break;
     case ANIMATION_RAISE_TO_SCREEN:
       ShowWindow(window, duration, false, observer);
       break;
     case ANIMATION_LOWER_BELOW_SCREEN:
       HideWindow(window, duration, false, observer);
       break;
     case ANIMATION_PARTIAL_FADE_IN:
-      StartPartialFadeAnimation(
-          window, kPartialFadeRatio, duration, observer);
+      StartPartialFadeAnimation(window, kPartialFadeRatio, duration, observer);
       break;
     case ANIMATION_UNDO_PARTIAL_FADE_IN:
       StartPartialFadeAnimation(window, 0.0, duration, observer);
       break;
     case ANIMATION_FULL_FADE_IN:
       StartPartialFadeAnimation(window, 1.0, duration, observer);
       break;
     case ANIMATION_GRAYSCALE_BRIGHTNESS:
-      StartGrayscaleBrightnessAnimationForWindow(
-          window, 1.0, duration, gfx::Tween::EASE_IN, observer);
+      StartGrayscaleBrightnessAnimationForWindow(window, 1.0, duration,
+                                                 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