Tweaks workspace animation code per latest from Nicholas. Additionally

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 <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
+#include "ash/wm/workspace/workspace_animations.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
@@ skipping 15 matching lines @@
 
 using aura::Window;
 using base::TimeDelta;
 using ui::Layer;
 
 namespace ash {
 namespace internal {
 namespace {
 const float kWindowAnimation_Vertical_TranslateY = 15.f;
 
-}
+}  // namespace
 
 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationType,
                            kWindowVisibilityAnimationTypeKey,
                            WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 DEFINE_WINDOW_PROPERTY_KEY(int, kWindowVisibilityAnimationDurationKey, 0);
 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationTransition,
                            kWindowVisibilityAnimationTransitionKey,
                            ANIMATE_BOTH);
 DEFINE_WINDOW_PROPERTY_KEY(float,
                            kWindowVisibilityAnimationVerticalPositionKey,
                            kWindowAnimation_Vertical_TranslateY);
 
 namespace {
 
 const int kDefaultAnimationDurationForMenuMS = 150;
 const int kLayerAnimationsForMinimizeDurationMS = 200;
 
 // Durations for the cross-fade animation, in milliseconds.
-const float kCrossFadeDurationMinMs = 100.f;
+const float kCrossFadeDurationMinMs = 200.f;
 const float kCrossFadeDurationMaxMs = 400.f;
 
 // Durations for the brightness/grayscale fade animation, in milliseconds.
 const int kBrightnessGrayscaleFadeDurationMs = 1000;
 
 // Brightness/grayscale values for hide/show window animations.
 const float kWindowAnimation_HideBrightnessGrayscale = 1.f;
 const float kWindowAnimation_ShowBrightnessGrayscale = 0.f;
 
 const float kWindowAnimation_HideOpacity = 0.f;
 const float kWindowAnimation_ShowOpacity = 1.f;
 const float kWindowAnimation_TranslateFactor = 0.025f;
 const float kWindowAnimation_ScaleFactor = .95f;
 // TODO(sky): if we end up sticking with 0, nuke the code doing the rotation.
 const float kWindowAnimation_MinimizeRotate = 0.f;
 
 // Amount windows are scaled during workspace animations.
 const float kWorkspaceScale = .95f;
 
+// Tween type when cross fading a workspace window.
+const ui::Tween::Type kCrossFadeTweenType = ui::Tween::EASE_IN_OUT;
+
 int64 Round64(float f) {
   return static_cast<int64>(f + 0.5f);
 }
 
 base::TimeDelta GetWindowVisibilityAnimationDuration(aura::Window* window) {
   int duration =
       window->GetProperty(kWindowVisibilityAnimationDurationKey);
   if (duration == 0 && window->type() == aura::client::WINDOW_TYPE_MENU) {
     return base::TimeDelta::FromMilliseconds(
         kDefaultAnimationDurationForMenuMS);
@@ skipping 476 matching lines @@
     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
       AnimateShowWindow_Fade(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_WORKSPACE_SHOW:
       AnimateShowWindow_Workspace(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE:
       AnimateShowWindow_Minimize(window);
       return true;
     case WINDOW_VISIBILITY_ANIMATION_TYPE_BRIGHTNESS_GRAYSCALE:
-        AnimateShowWindow_BrightnessGrayscale(window);
-        return true;
+      AnimateShowWindow_BrightnessGrayscale(window);
+      return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool AnimateHideWindow(aura::Window* window) {
   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE))
     return false;
 
@@ skipping 75 matching lines @@
   Layer* layer_;  // owned
 
   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 };
 
 }  // namespace
 }  // namespace internal
 
 namespace {
 
-// Scales for workspaces above/below current workspace.
-const float kWorkspaceScaleAbove = 1.1f;
-const float kWorkspaceScaleBelow = .9f;
-
-// Amount of time to pause before animating anything. Only used during initial
-// animation (when logging in).
-const int kWorkspaceInitialPauseTimeMS = 750;
-
-// TODO: leaving in for now since Nicholas wants to play with this, remove if we
-// leave it at 0.
-const int kPauseTimeMS = 0;
-
-}  // namespace
-
-// Amount of time for animating a workspace in or out.
-const int kWorkspaceSwitchTimeMS = 200 + kPauseTimeMS;
-
-namespace {
-
-// Brightness for the non-active workspace.
-// TODO(sky): ideally this would be -.33f, but it slows down animations by a
-// factor of 2. Figure out why.
-const float kWorkspaceBrightness = 0.0f;
-
-enum WorkspaceScaleType {
-  WORKSPACE_SCALE_ABOVE,
-  WORKSPACE_SCALE_BELOW,
-};
-
-// Used to identify what should animate in AnimateWorkspaceIn/Out.
-enum WorkspaceAnimateTypes {
-  WORKSPACE_ANIMATE_OPACITY =    1 << 0,
-  WORKSPACE_ANIMATE_BRIGHTNESS = 1 << 1,
-};
-
-void ApplyWorkspaceScale(ui::Layer* layer, WorkspaceScaleType type) {
-  const float scale = type == WORKSPACE_SCALE_ABOVE ? kWorkspaceScaleAbove :
-      kWorkspaceScaleBelow;
-  ui::Transform transform;
-  transform.ConcatScale(scale, scale);
-  transform.ConcatTranslate(
-      -layer->bounds().width() * (scale - 1.0f) / 2,
-      -layer->bounds().height() * (scale - 1.0f) / 2);
-  layer->SetTransform(transform);
-}
-
 // Implementation of cross fading. Window is the window being cross faded. It
 // should be at the target bounds. |old_layer| the previous layer from |window|.
 // This takes ownership of |old_layer| and deletes when the animation is done.
 // |pause_duration| is the duration to pause at the current bounds before
 // animating. Returns the duration of the fade.
 TimeDelta CrossFadeImpl(aura::Window* window,
                         ui::Layer* old_layer,
-                        ui::Tween::Type tween_type,
-                        base::TimeDelta pause_duration) {
+                        ui::Tween::Type tween_type) {
   const gfx::Rect old_bounds(old_layer->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 TimeDelta duration = GetCrossFadeDuration(old_bounds, new_bounds);
 
   // Scale up the old layer while translating to new position.
   {
     old_layer->GetAnimator()->StopAnimating();
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
-    settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
-    old_layer->GetAnimator()->SchedulePauseForProperties(
-        pause_duration, ui::LayerAnimationElement::TRANSFORM,
-        ui::LayerAnimationElement::OPACITY, -1);
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(new internal::CrossFadeObserver(window, old_layer));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
     ui::Transform out_transform;
     float scale_x = static_cast<float>(new_bounds.width()) /
         static_cast<float>(old_bounds.width());
     float scale_y = static_cast<float>(new_bounds.height()) /
         static_cast<float>(old_bounds.height());
@@ skipping 23 matching lines @@
   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(0.f);
   }
   {
     // Animate the new layer to the identity transform, so the window goes to
     // its newly set bounds.
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-    settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
-    window->layer()->GetAnimator()->SchedulePauseForProperties(
-        pause_duration, ui::LayerAnimationElement::TRANSFORM,
-        ui::LayerAnimationElement::OPACITY, -1);
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
     window->layer()->SetTransform(ui::Transform());
     if (!old_on_top) {
       // New layer is on top, fade it in.
       window->layer()->SetOpacity(1.f);
     }
   }
   return duration;
 }
 
-// Returns a TimeDelta from |time_ms|. If animations are disabled this returns
-// a TimeDelta of 0 (so the animation completes immediately).
-base::TimeDelta AdjustAnimationTime(int time_ms) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          ash::switches::kAshWindowAnimationsDisabled))
-    time_ms = 0;
-  return base::TimeDelta::FromMilliseconds(time_ms);
-}
-
-// Returns a TimeDelta adjusted for animations. If animations are disabled this
-// returns 0. If animations are not disabled and |time_delta| is non-empty, it
-// is returned. Otherwise |delta_time_ms| is returned.
-base::TimeDelta AdjustAnimationTimeDelta(base::TimeDelta time_delta,
-                                         int delta_time_ms) {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          ash::switches::kAshWindowAnimationsDisabled))
-    return base::TimeDelta();
-  return time_delta == base::TimeDelta() ?
-      base::TimeDelta::FromMilliseconds(delta_time_ms) : time_delta;
-}
-
-void AnimateWorkspaceInImpl(aura::Window* window,
-                            WorkspaceAnimationDirection direction,
-                            uint32 animate_types,
-                            int pause_time_ms,
-                            ui::Tween::Type tween_type,
-                            base::TimeDelta duration) {
-  window->layer()->SetOpacity(
-      (animate_types & WORKSPACE_ANIMATE_OPACITY) ? 0.0f : 1.0f);
-  window->layer()->SetLayerBrightness(
-      (animate_types & WORKSPACE_ANIMATE_BRIGHTNESS) ?
-      kWorkspaceBrightness : 0.0f);
-  window->Show();
-  ApplyWorkspaceScale(window->layer(),
-                      direction == WORKSPACE_ANIMATE_UP ?
-                          WORKSPACE_SCALE_BELOW : WORKSPACE_SCALE_ABOVE);
-  window->layer()->GetAnimator()->StopAnimating();
-
-  {
-    ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-
-    if (pause_time_ms > 0) {
-      settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
-      window->layer()->GetAnimator()->SchedulePauseForProperties(
-          AdjustAnimationTime(pause_time_ms),
-          ui::LayerAnimationElement::TRANSFORM,
-          ui::LayerAnimationElement::OPACITY,
-          ui::LayerAnimationElement::BRIGHTNESS,
-          ui::LayerAnimationElement::VISIBILITY,
-          -1);
-    }
-
-    settings.SetTweenType(tween_type);
-    settings.SetTransitionDuration(duration);
-    window->layer()->SetTransform(ui::Transform());
-    window->layer()->SetOpacity(1.0f);
-    window->layer()->SetLayerBrightness(0.0f);
-  }
-}
-
-void AnimateWorkspaceOutImpl(aura::Window* window,
-                             WorkspaceAnimationDirection direction,
-                             uint32 animate_types,
-                             int pause_time_ms,
-                             ui::Tween::Type tween_type,
-                             TimeDelta duration) {
-  window->Show();
-  window->layer()->SetTransform(ui::Transform());
-  window->layer()->SetLayerBrightness(0.0f);
-  window->layer()->SetOpacity(1.0f);
-  window->layer()->GetAnimator()->StopAnimating();
-
-  {
-    ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-
-    if (pause_time_ms > 0) {
-      settings.SetPreemptionStrategy(ui::LayerAnimator::ENQUEUE_NEW_ANIMATION);
-      window->layer()->GetAnimator()->SchedulePauseForProperties(
-          AdjustAnimationTime(pause_time_ms),
-          ui::LayerAnimationElement::TRANSFORM,
-          ui::LayerAnimationElement::OPACITY,
-          ui::LayerAnimationElement::BRIGHTNESS,
-          ui::LayerAnimationElement::VISIBILITY,
-          -1);
-    }
-
-    settings.SetTransitionDuration(duration);
-    settings.SetTweenType(tween_type);
-    ApplyWorkspaceScale(window->layer(),
-                        direction == WORKSPACE_ANIMATE_UP ?
-                            WORKSPACE_SCALE_ABOVE : WORKSPACE_SCALE_BELOW);
-    // NOTE: Hide() must be before SetOpacity(), else
-    // VisibilityController::UpdateLayerVisibility doesn't pass the false to the
-    // layer so that the layer and window end up out of sync and confused.
-    window->Hide();
-    if (animate_types & WORKSPACE_ANIMATE_OPACITY)
-      window->layer()->SetOpacity(0.0f);
-    if (animate_types & WORKSPACE_ANIMATE_BRIGHTNESS)
-      window->layer()->SetLayerBrightness(kWorkspaceBrightness);
-
-    // 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());
-    window->layer()->SetTransform(ui::Transform());
-  }
-}
-
-ui::Tween::Type TweenTypeForWorskpaceOut(WorkspaceType type) {
-  return WORKSPACE_DESKTOP ? ui::Tween::LINEAR : ui::Tween::EASE_OUT;
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // External interface
 
 void SetWindowVisibilityAnimationType(aura::Window* window,
                                       WindowVisibilityAnimationType type) {
   window->SetProperty(internal::kWindowVisibilityAnimationTypeKey, type);
 }
 
@@ skipping 39 matching lines @@
   // Resize the window to the new size, which will force a layout and paint.
   window->SetBounds(new_bounds);
 
   // Ensure the higher-resolution layer is on top.
   bool old_on_top = (old_bounds.width() > new_bounds.width());
   if (old_on_top)
     old_layer->parent()->StackBelow(new_layer, old_layer);
   else
     old_layer->parent()->StackAbove(new_layer, old_layer);
 
-  CrossFadeImpl(window, old_layer, ui::Tween::EASE_OUT, base::TimeDelta());
+  CrossFadeImpl(window, old_layer, ui::Tween::EASE_OUT);
 }
 
-void CrossFadeWindowBetweenWorkspaces(aura::Window* old_workspace,
-                                      aura::Window* new_workspace,
+void CrossFadeWindowBetweenWorkspaces(aura::Window* new_workspace,
                                       aura::Window* window,
                                       ui::Layer* old_layer) {
   ui::Layer* layer_parent = new_workspace->layer()->parent();
   layer_parent->Add(old_layer);
   const bool restoring = old_layer->bounds().width() > window->bounds().width();
-  ui::Tween::Type tween_type, workspace_tween_type;
-  if (restoring) {
+  if (restoring)
     layer_parent->StackAbove(old_layer, new_workspace->layer());
-    tween_type = ui::Tween::EASE_OUT;
-    workspace_tween_type = ui::Tween::EASE_OUT;
-  } else {
+  else
     layer_parent->StackBelow(old_layer, new_workspace->layer());
-    tween_type = ui::Tween::EASE_IN_2;
-    workspace_tween_type = ui::Tween::LINEAR;
-  }
 
-  const TimeDelta duration =
-      CrossFadeImpl(window, old_layer, tween_type,
-                    AdjustAnimationTime(restoring ? 0 : kPauseTimeMS));
-
-  if (restoring) {
-    typedef aura::Window::Windows Windows;
-    if (old_workspace)
-      AnimateWorkspaceOutImpl(old_workspace, WORKSPACE_ANIMATE_UP,
-                              WORKSPACE_ANIMATE_BRIGHTNESS,
-                              0, workspace_tween_type, duration);
-
-    // Ideally we would use AnimateWorkspaceIn() for |new_workspace|, but that
-    // results in |window| animating with the workspace scale. We don't want
-    // that, so we explicitly animate each of the children to give the effect of
-    // the workspace scaling.
-    new_workspace->Show();
-    new_workspace->SetTransform(ui::Transform());
-    new_workspace->layer()->SetOpacity(1.0f);
-    new_workspace->layer()->SetLayerBrightness(0.0f);
-    const Windows& children(new_workspace->children());
-    for (Windows::const_iterator i = children.begin(); i != children.end();
-         ++i) {
-      aura::Window* child = *i;
-      if (child == window)
-        continue;
-      child->SetTransform(ash::internal::BuildWorkspaceSwitchTransform(
-                              child, kWorkspaceScaleBelow));
-      child->layer()->SetLayerBrightness(kWorkspaceBrightness);
-      ui::ScopedLayerAnimationSettings settings(child->layer()->GetAnimator());
-      settings.SetTweenType(ui::Tween::EASE_OUT);
-      settings.SetTransitionDuration(duration);
-      child->SetTransform(ui::Transform());
-      child->layer()->SetLayerBrightness(0.0f);
-    }
-  } else {
-    if (old_workspace) {
-      AnimateWorkspaceOutImpl(old_workspace, WORKSPACE_ANIMATE_DOWN,
-                              WORKSPACE_ANIMATE_BRIGHTNESS,
-                              0, workspace_tween_type, duration);
-    }
-
-    new_workspace->Show();
-    new_workspace->layer()->SetOpacity(1.f);
-    new_workspace->layer()->SetTransform(ui::Transform());
-    new_workspace->layer()->SetLayerBrightness(0.0f);
-  }
-}
-
-void AnimateBetweenWorkspaces(aura::Window* old_window,
-                              WorkspaceType old_type,
-                              bool animate_old,
-                              aura::Window* new_window,
-                              WorkspaceType new_type,
-                              bool is_restoring_maximized_window) {
-  uint32 common_animate_types = 0;
-  if (animate_old) {
-    // When switching to the desktop the old window lifts off.
-    uint32 animate_types = 0;
-    if (!(new_type == WORKSPACE_MAXIMIZED && old_type == WORKSPACE_MAXIMIZED))
-      animate_types |= WORKSPACE_ANIMATE_BRIGHTNESS;
-    if ((new_type == WORKSPACE_DESKTOP || old_type == WORKSPACE_MAXIMIZED) &&
-        !is_restoring_maximized_window)
-      animate_types |= WORKSPACE_ANIMATE_OPACITY;
-    AnimateWorkspaceOutImpl(
-        old_window,
-        new_type == WORKSPACE_DESKTOP ? WORKSPACE_ANIMATE_UP :
-            WORKSPACE_ANIMATE_DOWN,
-        animate_types,
-        0,
-        TweenTypeForWorskpaceOut(old_type),
-        AdjustAnimationTime(kWorkspaceSwitchTimeMS));
-  }
-
-  // Switching from the desktop to a maximized animates down.
-  uint32 animate_types = common_animate_types;
-  if (!(new_type == WORKSPACE_MAXIMIZED && old_type == WORKSPACE_MAXIMIZED) &&
-      !is_restoring_maximized_window)
-    animate_types |= WORKSPACE_ANIMATE_BRIGHTNESS;
-  if (old_type == WORKSPACE_DESKTOP)
-    animate_types |= WORKSPACE_ANIMATE_OPACITY;
-  AnimateWorkspaceInImpl(
-      new_window,
-      old_type == WORKSPACE_DESKTOP ?
-          WORKSPACE_ANIMATE_DOWN : WORKSPACE_ANIMATE_UP,
-      animate_types,
-      0,
-      ui::Tween::EASE_OUT,
-      AdjustAnimationTime(kWorkspaceSwitchTimeMS));
-}
-
-void AnimateWorkspaceIn(aura::Window* window,
-                        WorkspaceAnimationDirection direction,
-                        bool initial_animate,
-                        base::TimeDelta delta) {
-  AnimateWorkspaceInImpl(
-      window, direction,
-      WORKSPACE_ANIMATE_BRIGHTNESS |
-          (initial_animate ? WORKSPACE_ANIMATE_OPACITY : 0),
-      initial_animate ? kWorkspaceInitialPauseTimeMS : 0,
-      ui::Tween::EASE_OUT,
-      AdjustAnimationTimeDelta(delta, kWorkspaceSwitchTimeMS));
-}
-
-void AnimateWorkspaceOut(aura::Window* window,
-                         WorkspaceAnimationDirection direction,
-                         WorkspaceType type,
-                         bool initial_animate,
-                         base::TimeDelta delta) {
-  AnimateWorkspaceOutImpl(window, direction, WORKSPACE_ANIMATE_BRIGHTNESS,
-                          initial_animate ? kWorkspaceInitialPauseTimeMS : 0,
-                          TweenTypeForWorskpaceOut(type),
-                          AdjustAnimationTimeDelta(delta,
-                                                   kWorkspaceSwitchTimeMS));
-}
-
-base::TimeDelta GetSystemBackgroundDestroyDuration() {
-  return base::TimeDelta::FromMilliseconds(
-      std::max(static_cast<int>(internal::kCrossFadeDurationMaxMs),
-               kWorkspaceSwitchTimeMS));
+  CrossFadeImpl(window, old_layer, internal::kCrossFadeTweenType);
 }
 
 TimeDelta GetCrossFadeDuration(const gfx::Rect& old_bounds,
                                const gfx::Rect& new_bounds) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           ash::switches::kAshWindowAnimationsDisabled))
     return base::TimeDelta();
 
   const int min_time_ms = internal::WorkspaceController::IsWorkspace2Enabled() ?
-      kWorkspaceSwitchTimeMS : 0;
+      internal::kWorkspaceSwitchTimeMS : 0;
   int old_area = old_bounds.width() * old_bounds.height();
   int new_area = new_bounds.width() * new_bounds.height();
   int max_area = std::max(old_area, new_area);
   // Avoid divide by zero.
   if (max_area == 0)
     return TimeDelta::FromMilliseconds(min_time_ms);
 
   int delta_area = std::abs(old_area - new_area);
   // If the area didn't change, the animation is instantaneous.
   if (delta_area == 0)
@@ skipping 19 matching lines @@
     return AnimateShowWindow(window);
   } else {
     // Don't start hiding the window again if it's already being hidden.
     return window->layer()->GetTargetOpacity() != 0.0f &&
         AnimateHideWindow(window);
   }
 }
 
 }  // namespace internal
 }  // namespace ash