clang-format all of //ash

ash/wm/window_animations.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/window_animations.h"
 
 #include <math.h>
 #include <algorithm>
 #include <utility>
 #include <vector>
@@ skipping 67 matching lines @@
   int max_area = std::max(old_area, new_area);
   // Avoid divide by zero.
   if (max_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
 
   int delta_area = std::abs(old_area - new_area);
   // If the area didn't change, the animation is instantaneous.
   if (delta_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
 
-  float factor =
-      static_cast<float>(delta_area) / static_cast<float>(max_area);
+  float factor = static_cast<float>(delta_area) / static_cast<float>(max_area);
   const float kRange = kCrossFadeDurationMaxMs - kCrossFadeDurationMinMs;
   return base::TimeDelta::FromMilliseconds(
       Round64(kCrossFadeDurationMinMs + (factor * kRange)));
 }
 
 }  // namespace
 
 const int kCrossFadeDurationMS = 200;
 
 void AddLayerAnimationsForMinimize(aura::Window* window, bool show) {
@@ skipping 11 matching lines @@
       gfx::Point3F(1, 1, 1), gfx::Point3F(scale_x, scale_y, 1)));
 
   std::unique_ptr<ui::InterpolatedTransform> translation(
       new ui::InterpolatedTranslation(
           gfx::PointF(), gfx::PointF(target_bounds.x() - bounds.x(),
                                      target_bounds.y() - bounds.y())));
 
   scale->SetChild(translation.release());
   scale->SetReversed(show);
 
-  base::TimeDelta duration = window->layer()->GetAnimator()->
-      GetTransitionDuration();
+  base::TimeDelta duration =
+      window->layer()->GetAnimator()->GetTransitionDuration();
 
   std::unique_ptr<ui::LayerAnimationElement> transition(
       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
           scale.release(), duration));
 
-  transition->set_tween_type(
-      show ? gfx::Tween::EASE_IN : gfx::Tween::EASE_IN_OUT);
+  transition->set_tween_type(show ? gfx::Tween::EASE_IN
+                                  : gfx::Tween::EASE_IN_OUT);
 
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(transition.release()));
 
   // When hiding a window, turn off blending until the animation is 3 / 4 done
   // to save bandwidth and reduce jank.
   if (!show) {
     window->layer()->GetAnimator()->SchedulePauseForProperties(
         (duration * 3) / 4, ui::LayerAnimationElement::OPACITY);
   }
 
   // Fade in and out quickly when the window is small to reduce jank.
   float opacity = show ? 1.0f : 0.0f;
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(
-          ui::LayerAnimationElement::CreateOpacityElement(
-              opacity, duration / 4)));
+          ui::LayerAnimationElement::CreateOpacityElement(opacity,
+                                                          duration / 4)));
 
   // Reset the transform to identity when the minimize animation is completed.
   window->layer()->GetAnimator()->ScheduleAnimation(
       new ui::LayerAnimationSequence(
           ui::LayerAnimationElement::CreateTransformElement(
-              gfx::Transform(),
-              base::TimeDelta())));
+              gfx::Transform(), base::TimeDelta())));
 }
 
 void AnimateShowWindow_Minimize(aura::Window* window) {
   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
-      kLayerAnimationsForMinimizeDurationMS);
+  base::TimeDelta duration =
+      base::TimeDelta::FromMilliseconds(kLayerAnimationsForMinimizeDurationMS);
   settings.SetTransitionDuration(duration);
   AddLayerAnimationsForMinimize(window, true);
 
   // Now that the window has been restored, we need to clear its animation style
   // to default so that normal animation applies.
   ::wm::SetWindowVisibilityAnimationType(
       window, ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 }
 
 void AnimateHideWindow_Minimize(aura::Window* window) {
   // Property sets within this scope will be implicitly animated.
   ::wm::ScopedHidingAnimationSettings hiding_settings(window);
-  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
-      kLayerAnimationsForMinimizeDurationMS);
+  base::TimeDelta duration =
+      base::TimeDelta::FromMilliseconds(kLayerAnimationsForMinimizeDurationMS);
   hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
   window->layer()->SetVisible(false);
 
   AddLayerAnimationsForMinimize(window, false);
 }
 
 void AnimateShowHideWindowCommon_BrightnessGrayscale(aura::Window* window,
                                                      bool show) {
   float start_value, end_value;
   if (show) {
     start_value = kWindowAnimation_HideBrightnessGrayscale;
     end_value = kWindowAnimation_ShowBrightnessGrayscale;
   } else {
     start_value = kWindowAnimation_ShowBrightnessGrayscale;
     end_value = kWindowAnimation_HideBrightnessGrayscale;
   }
 
   window->layer()->SetLayerBrightness(start_value);
   window->layer()->SetLayerGrayscale(start_value);
   if (show) {
     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
     window->layer()->SetVisible(true);
   }
 
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kBrightnessGrayscaleFadeDurationMs);
 
   if (show) {
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-    window->layer()->GetAnimator()->
-        ScheduleTogether(
-            CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
+    window->layer()->GetAnimator()->ScheduleTogether(
+        CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
   } else {
     ::wm::ScopedHidingAnimationSettings hiding_settings(window);
-    window->layer()->GetAnimator()->
-        ScheduleTogether(
-            CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
+    window->layer()->GetAnimator()->ScheduleTogether(
+        CreateBrightnessGrayscaleAnimationSequence(end_value, duration));
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
     window->layer()->SetVisible(false);
   }
 }
 
 void AnimateShowWindow_BrightnessGrayscale(aura::Window* window) {
   AnimateShowHideWindowCommon_BrightnessGrayscale(window, true);
 }
 
 void AnimateHideWindow_BrightnessGrayscale(aura::Window* window) {
   AnimateShowHideWindowCommon_BrightnessGrayscale(window, false);
 }
 
 bool AnimateShowWindow(aura::Window* window) {
-  if (!::wm::HasWindowVisibilityAnimationTransition(
-          window, ::wm::ANIMATE_SHOW)) {
+  if (!::wm::HasWindowVisibilityAnimationTransition(window,
+                                                    ::wm::ANIMATE_SHOW)) {
     return false;
   }
 
   switch (::wm::GetWindowVisibilityAnimationType(window)) {
     case wm::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateShowWindow_Minimize(window);
       return true;
     case wm::WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
       AnimateShowWindow_BrightnessGrayscale(window);
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool AnimateHideWindow(aura::Window* window) {
-  if (!::wm::HasWindowVisibilityAnimationTransition(
-          window, ::wm::ANIMATE_HIDE)) {
+  if (!::wm::HasWindowVisibilityAnimationTransition(window,
+                                                    ::wm::ANIMATE_HIDE)) {
     return false;
   }
 
   switch (::wm::GetWindowVisibilityAnimationType(window)) {
     case wm::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateHideWindow_Minimize(window);
       return true;
     case wm::WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
       AnimateHideWindow_BrightnessGrayscale(window);
       return true;
@@ skipping 66 matching lines @@
   gfx::Transform old_transform(old_layer_owner->root()->transform());
   gfx::Transform old_transform_in_root;
   old_transform_in_root.Translate(old_bounds.x(), old_bounds.y());
   old_transform_in_root.PreconcatTransform(old_transform);
   old_transform_in_root.Translate(-old_bounds.x(), -old_bounds.y());
   old_transform_in_root.TransformRect(&old_transformed_bounds);
   const gfx::Rect new_bounds(window->bounds());
   const bool old_on_top = (old_bounds.width() > new_bounds.width());
 
   // Shorten the animation if there's not much visual movement.
-  const base::TimeDelta duration = GetCrossFadeDuration(window,
-      old_transformed_bounds, new_bounds);
+  const base::TimeDelta duration =
+      GetCrossFadeDuration(window, old_transformed_bounds, new_bounds);
 
   // Scale up the old layer while translating to new position.
   {
     ui::Layer* old_layer = old_layer_owner->root();
     old_layer->GetAnimator()->StopAnimating();
     old_layer->SetTransform(old_transform);
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(
         new CrossFadeObserver(window, std::move(old_layer_owner)));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
     gfx::Transform out_transform;
     float scale_x = static_cast<float>(new_bounds.width()) /
-        static_cast<float>(old_bounds.width());
+                    static_cast<float>(old_bounds.width());
     float scale_y = static_cast<float>(new_bounds.height()) /
-        static_cast<float>(old_bounds.height());
+                    static_cast<float>(old_bounds.height());
     out_transform.Translate(new_bounds.x() - old_bounds.x(),
                             new_bounds.y() - old_bounds.y());
     out_transform.Scale(scale_x, scale_y);
     old_layer->SetTransform(out_transform);
     if (old_on_top) {
       // The old layer is on top, and should fade out.  The new layer below will
       // stay opaque to block the desktop.
       old_layer->SetOpacity(kWindowAnimation_HideOpacity);
     }
     // In tests |old_layer| is deleted here, as animations have zero duration.
     old_layer = NULL;
   }
 
   // Set the new layer's current transform, such that the user sees a scaled
   // version of the window with the original bounds at the original position.
   gfx::Transform in_transform;
-  const float scale_x = old_transformed_bounds.width() /
-      static_cast<float>(new_bounds.width());
-  const float scale_y = old_transformed_bounds.height() /
-      static_cast<float>(new_bounds.height());
+  const float scale_x =
+      old_transformed_bounds.width() / static_cast<float>(new_bounds.width());
+  const float scale_y =
+      old_transformed_bounds.height() / static_cast<float>(new_bounds.height());
   in_transform.Translate(old_transformed_bounds.x() - new_bounds.x(),
                          old_transformed_bounds.y() - new_bounds.y());
   in_transform.Scale(scale_x, scale_y);
   window->layer()->SetTransform(in_transform);
   if (!old_on_top) {
     // The new layer is on top and should fade in.  The old layer below will
     // stay opaque and block the desktop.
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   }
   {
@@ skipping 17 matching lines @@
 
   // Attempt to run CoreWm supplied animation types.
   if (::wm::AnimateOnChildWindowVisibilityChanged(window, visible))
     return true;
 
   // Otherwise try to run an Ash-specific animation.
   if (visible)
     return AnimateShowWindow(window);
   // Don't start hiding the window again if it's already being hidden.
   return window->layer()->GetTargetOpacity() != 0.0f &&
-      AnimateHideWindow(window);
+         AnimateHideWindow(window);
 }
 
 std::vector<ui::LayerAnimationSequence*>
 CreateBrightnessGrayscaleAnimationSequence(float target_value,
                                            base::TimeDelta duration) {
   gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT;
   std::unique_ptr<ui::LayerAnimationSequence> brightness_sequence(
       new ui::LayerAnimationSequence());
   std::unique_ptr<ui::LayerAnimationSequence> grayscale_sequence(
       new ui::LayerAnimationSequence());
@@ skipping 13 matching lines @@
   std::vector<ui::LayerAnimationSequence*> animations;
   animations.push_back(brightness_sequence.release());
   animations.push_back(grayscale_sequence.release());
 
   return animations;
 }
 
 // Returns scale related to the specified AshWindowScaleType.
 void SetTransformForScaleAnimation(ui::Layer* layer,
                                    LayerScaleAnimationDirection type) {
-  const float scale =
-      type == LAYER_SCALE_ANIMATION_ABOVE ? kLayerScaleAboveSize :
-          kLayerScaleBelowSize;
+  const float scale = type == LAYER_SCALE_ANIMATION_ABOVE
+                          ? kLayerScaleAboveSize
+                          : kLayerScaleBelowSize;
   gfx::Transform transform;
   transform.Translate(-layer->bounds().width() * (scale - 1.0f) / 2,
                       -layer->bounds().height() * (scale - 1.0f) / 2);
   transform.Scale(scale, scale);
   layer->SetTransform(transform);
 }
 
 gfx::Rect GetMinimizeAnimationTargetBoundsInScreen(aura::Window* window) {
   Shelf* shelf = Shelf::ForWindow(window);
   // Shelf is created lazily and can be NULL.
@@ skipping 29 matching lines @@
   gfx::Rect work_area =
       display::Screen::GetScreen()->GetDisplayNearestWindow(window).work_area();
   int ltr_adjusted_x = base::i18n::IsRTL() ? work_area.right() : work_area.x();
   return shelf->SelectValueForShelfAlignment(
       gfx::Rect(ltr_adjusted_x, work_area.bottom(), 0, 0),
       gfx::Rect(work_area.x(), work_area.y(), 0, 0),
       gfx::Rect(work_area.right(), work_area.y(), 0, 0));
 }
 
 }  // namespace ash