ui/wm/core/window_animations.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/wm/core/window_animations.h"
   6
   7 #include <math.h>
   8
   9 #include <algorithm>
  10 #include <vector>
  11
  12 #include "base/command_line.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/stl_util.h"
  17 #include "base/time/time.h"
  18 #include "ui/aura/client/aura_constants.h"
  19 #include "ui/aura/window.h"
  20 #include "ui/aura/window_delegate.h"
  21 #include "ui/aura/window_observer.h"
  22 #include "ui/aura/window_property.h"
  23 #include "ui/compositor/compositor_observer.h"
  24 #include "ui/compositor/layer.h"
  25 #include "ui/compositor/layer_animation_observer.h"
  26 #include "ui/compositor/layer_animation_sequence.h"
  27 #include "ui/compositor/layer_animator.h"
  28 #include "ui/compositor/layer_tree_owner.h"
  29 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  30 #include "ui/compositor/scoped_layer_animation_settings.h"
  31 #include "ui/gfx/animation/animation.h"
  32 #include "ui/gfx/interpolated_transform.h"
  33 #include "ui/gfx/rect_conversions.h"
  34 #include "ui/gfx/screen.h"
  35 #include "ui/gfx/vector2d.h"
  36 #include "ui/gfx/vector3d_f.h"
  37 #include "ui/wm/core/window_util.h"
  38 #include "ui/wm/core/wm_core_switches.h"
  39 #include "ui/wm/public/animation_host.h"
  40
  41 DECLARE_WINDOW_PROPERTY_TYPE(int)
  42 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationType)
  43 DECLARE_WINDOW_PROPERTY_TYPE(wm::WindowVisibilityAnimationTransition)
  44 DECLARE_WINDOW_PROPERTY_TYPE(float)
  45 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(WM_EXPORT, bool)
  46
  47 namespace wm {
  48 namespace {
  49 const float kWindowAnimation_Vertical_TranslateY = 15.f;
  50
  51 // A base class for hiding animation observer which has two roles:
  52 // 1) Notifies AnimationHost at the end of hiding animation.
  53 // 2) Detaches the window's layers for hiding animation and deletes
  54 // them upon completion of the animation. This is necessary to a)
  55 // ensure that the animation continues in the event of the window being
  56 // deleted, and b) to ensure that the animation is visible even if the
  57 // window gets restacked below other windows when focus or activation
  58 // changes.
  59 // The subclass will determine when the animation is completed.
  60 class HidingWindowAnimationObserverBase : public aura::WindowObserver {
  61  public:
  62   explicit HidingWindowAnimationObserverBase(aura::Window* window)
  63       : window_(window) {
  64     window_->AddObserver(this);
  65   }
  66   virtual ~HidingWindowAnimationObserverBase() {
  67     if (window_)
  68       window_->RemoveObserver(this);
  69   }
  70
  71   // aura::WindowObserver:
  72   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
  73     DCHECK_EQ(window, window_);
  74     WindowInvalid();
  75   }
  76
  77   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
  78     DCHECK_EQ(window, window_);
  79     WindowInvalid();
  80   }
  81
  82   // Detach the current layers and create new layers for |window_|.
  83   // Stack the original layers above |window_| and its transient
  84   // children.  If the window has transient children, the original
  85   // layers will be moved above the top most transient child so that
  86   // activation change does not put the window above the animating
  87   // layer.
  88   void DetachAndRecreateLayers() {
  89     layer_owner_ = RecreateLayers(window_);
  90     if (window_->parent()) {
  91       const aura::Window::Windows& transient_children =
  92           GetTransientChildren(window_);
  93       aura::Window::Windows::const_iterator iter =
  94           std::find(window_->parent()->children().begin(),
  95                     window_->parent()->children().end(),
  96                     window_);
  97       DCHECK(iter != window_->parent()->children().end());
  98       aura::Window* topmost_transient_child = NULL;
  99       for (++iter; iter != window_->parent()->children().end(); ++iter) {
 100         if (std::find(transient_children.begin(),
 101                       transient_children.end(),
 102                       *iter) != transient_children.end()) {
 103           topmost_transient_child = *iter;
 104         }
 105       }
 106       if (topmost_transient_child) {
 107         window_->parent()->layer()->StackAbove(
 108             layer_owner_->root(), topmost_transient_child->layer());
 109       }
 110     }
 111   }
 112
 113  protected:
 114   // Invoked when the hiding animation is completed.  It will delete
 115   // 'this', and no operation should be made on this object after this
 116   // point.
 117   void OnAnimationCompleted() {
 118     // Window may have been destroyed by this point.
 119     if (window_) {
 120       aura::client::AnimationHost* animation_host =
 121           aura::client::GetAnimationHost(window_);
 122       if (animation_host)
 123         animation_host->OnWindowHidingAnimationCompleted();
 124       window_->RemoveObserver(this);
 125     }
 126     delete this;
 127   }
 128
 129  private:
 130   // Invoked when the window is destroyed (or destroying).
 131   void WindowInvalid() {
 132     layer_owner_->root()->SuppressPaint();
 133
 134     window_->RemoveObserver(this);
 135     window_ = NULL;
 136   }
 137
 138   aura::Window* window_;
 139
 140   // The owner of detached layers.
 141   scoped_ptr<ui::LayerTreeOwner> layer_owner_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(HidingWindowAnimationObserverBase);
 144 };
 145
 146 }  // namespace
 147
 148 DEFINE_WINDOW_PROPERTY_KEY(int,
 149                            kWindowVisibilityAnimationTypeKey,
 150                            WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
 151 DEFINE_WINDOW_PROPERTY_KEY(int, kWindowVisibilityAnimationDurationKey, 0);
 152 DEFINE_WINDOW_PROPERTY_KEY(WindowVisibilityAnimationTransition,
 153                            kWindowVisibilityAnimationTransitionKey,
 154                            ANIMATE_BOTH);
 155 DEFINE_WINDOW_PROPERTY_KEY(float,
 156                            kWindowVisibilityAnimationVerticalPositionKey,
 157                            kWindowAnimation_Vertical_TranslateY);
 158
 159 // A HidingWindowAnimationObserver that deletes observer and detached
 160 // layers upon the completion of the implicit animation.
 161 class ImplicitHidingWindowAnimationObserver
 162     : public HidingWindowAnimationObserverBase,
 163       public ui::ImplicitAnimationObserver {
 164  public:
 165   ImplicitHidingWindowAnimationObserver(
 166       aura::Window* window,
 167       ui::ScopedLayerAnimationSettings* settings);
 168   virtual ~ImplicitHidingWindowAnimationObserver() {}
 169
 170   // ui::ImplicitAnimationObserver:
 171   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 172
 173  private:
 174   DISALLOW_COPY_AND_ASSIGN(ImplicitHidingWindowAnimationObserver);
 175 };
 176
 177 namespace {
 178
 179 const int kDefaultAnimationDurationForMenuMS = 150;
 180
 181 const float kWindowAnimation_HideOpacity = 0.f;
 182 const float kWindowAnimation_ShowOpacity = 1.f;
 183 const float kWindowAnimation_TranslateFactor = 0.5f;
 184 const float kWindowAnimation_ScaleFactor = .95f;
 185
 186 const int kWindowAnimation_Rotate_DurationMS = 180;
 187 const int kWindowAnimation_Rotate_OpacityDurationPercent = 90;
 188 const float kWindowAnimation_Rotate_TranslateY = -20.f;
 189 const float kWindowAnimation_Rotate_PerspectiveDepth = 500.f;
 190 const float kWindowAnimation_Rotate_DegreesX = 5.f;
 191 const float kWindowAnimation_Rotate_ScaleFactor = .99f;
 192
 193 const float kWindowAnimation_Bounce_Scale = 1.02f;
 194 const int kWindowAnimation_Bounce_DurationMS = 180;
 195 const int kWindowAnimation_Bounce_GrowShrinkDurationPercent = 40;
 196
 197 base::TimeDelta GetWindowVisibilityAnimationDuration(
 198     const aura::Window& window) {
 199   int duration =
 200       window.GetProperty(kWindowVisibilityAnimationDurationKey);
 201   if (duration == 0 && window.type() == ui::wm::WINDOW_TYPE_MENU) {
 202     return base::TimeDelta::FromMilliseconds(
 203         kDefaultAnimationDurationForMenuMS);
 204   }
 205   return base::TimeDelta::FromInternalValue(duration);
 206 }
 207
 208 // Gets/sets the WindowVisibilityAnimationType associated with a window.
 209 // TODO(beng): redundant/fold into method on public api?
 210 int GetWindowVisibilityAnimationType(aura::Window* window) {
 211   int type = window->GetProperty(kWindowVisibilityAnimationTypeKey);
 212   if (type == WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT) {
 213     return (window->type() == ui::wm::WINDOW_TYPE_MENU ||
 214             window->type() == ui::wm::WINDOW_TYPE_TOOLTIP)
 215                ? WINDOW_VISIBILITY_ANIMATION_TYPE_FADE
 216                : WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
 217   }
 218   return type;
 219 }
 220
 221 void GetTransformRelativeToRoot(ui::Layer* layer, gfx::Transform* transform) {
 222   const ui::Layer* root = layer;
 223   while (root->parent())
 224     root = root->parent();
 225   layer->GetTargetTransformRelativeTo(root, transform);
 226 }
 227
 228 gfx::Rect GetLayerWorldBoundsAfterTransform(ui::Layer* layer,
 229                                             const gfx::Transform& transform) {
 230   gfx::Transform in_world = transform;
 231   GetTransformRelativeToRoot(layer, &in_world);
 232
 233   gfx::RectF transformed = layer->bounds();
 234   in_world.TransformRect(&transformed);
 235
 236   return gfx::ToEnclosingRect(transformed);
 237 }
 238
 239 // Augment the host window so that the enclosing bounds of the full
 240 // animation will fit inside of it.
 241 void AugmentWindowSize(aura::Window* window,
 242                        const gfx::Transform& end_transform) {
 243   aura::client::AnimationHost* animation_host =
 244       aura::client::GetAnimationHost(window);
 245   if (!animation_host)
 246     return;
 247
 248   const gfx::Rect& world_at_start = window->bounds();
 249   gfx::Rect world_at_end =
 250       GetLayerWorldBoundsAfterTransform(window->layer(), end_transform);
 251   gfx::Rect union_in_window_space =
 252       gfx::UnionRects(world_at_start, world_at_end);
 253
 254   // Calculate the top left and bottom right deltas to be added to the window
 255   // bounds.
 256   gfx::Vector2d top_left_delta(world_at_start.x() - union_in_window_space.x(),
 257                                world_at_start.y() - union_in_window_space.y());
 258
 259   gfx::Vector2d bottom_right_delta(
 260       union_in_window_space.x() + union_in_window_space.width() -
 261           (world_at_start.x() + world_at_start.width()),
 262       union_in_window_space.y() + union_in_window_space.height() -
 263           (world_at_start.y() + world_at_start.height()));
 264
 265   DCHECK(top_left_delta.x() >= 0 && top_left_delta.y() >= 0 &&
 266          bottom_right_delta.x() >= 0 && bottom_right_delta.y() >= 0);
 267
 268   animation_host->SetHostTransitionOffsets(top_left_delta, bottom_right_delta);
 269 }
 270
 271 // Shows a window using an animation, animating its opacity from 0.f to 1.f,
 272 // its visibility to true, and its transform from |start_transform| to
 273 // |end_transform|.
 274 void AnimateShowWindowCommon(aura::Window* window,
 275                              const gfx::Transform& start_transform,
 276                              const gfx::Transform& end_transform) {
 277   AugmentWindowSize(window, end_transform);
 278
 279   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 280   window->layer()->SetTransform(start_transform);
 281   window->layer()->SetVisible(true);
 282
 283   {
 284     // Property sets within this scope will be implicitly animated.
 285     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
 286     base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
 287     if (duration.ToInternalValue() > 0)
 288       settings.SetTransitionDuration(duration);
 289
 290     window->layer()->SetTransform(end_transform);
 291     window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 292   }
 293 }
 294
 295 // Hides a window using an animation, animating its opacity from 1.f to 0.f,
 296 // its visibility to false, and its transform to |end_transform|.
 297 void AnimateHideWindowCommon(aura::Window* window,
 298                              const gfx::Transform& end_transform) {
 299   AugmentWindowSize(window, end_transform);
 300
 301   // Property sets within this scope will be implicitly animated.
 302   ScopedHidingAnimationSettings hiding_settings(window);
 303   base::TimeDelta duration = GetWindowVisibilityAnimationDuration(*window);
 304   if (duration.ToInternalValue() > 0)
 305     hiding_settings.layer_animation_settings()->SetTransitionDuration(duration);
 306
 307   window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 308   window->layer()->SetTransform(end_transform);
 309   window->layer()->SetVisible(false);
 310 }
 311
 312 static gfx::Transform GetScaleForWindow(aura::Window* window) {
 313   gfx::Rect bounds = window->bounds();
 314   gfx::Transform scale = gfx::GetScaleTransform(
 315       gfx::Point(kWindowAnimation_TranslateFactor * bounds.width(),
 316                  kWindowAnimation_TranslateFactor * bounds.height()),
 317       kWindowAnimation_ScaleFactor);
 318   return scale;
 319 }
 320
 321 // Show/Hide windows using a shrink animation.
 322 void AnimateShowWindow_Drop(aura::Window* window) {
 323   AnimateShowWindowCommon(window, GetScaleForWindow(window), gfx::Transform());
 324 }
 325
 326 void AnimateHideWindow_Drop(aura::Window* window) {
 327   AnimateHideWindowCommon(window, GetScaleForWindow(window));
 328 }
 329
 330 // Show/Hide windows using a vertical Glenimation.
 331 void AnimateShowWindow_Vertical(aura::Window* window) {
 332   gfx::Transform transform;
 333   transform.Translate(0, window->GetProperty(
 334       kWindowVisibilityAnimationVerticalPositionKey));
 335   AnimateShowWindowCommon(window, transform, gfx::Transform());
 336 }
 337
 338 void AnimateHideWindow_Vertical(aura::Window* window) {
 339   gfx::Transform transform;
 340   transform.Translate(0, window->GetProperty(
 341       kWindowVisibilityAnimationVerticalPositionKey));
 342   AnimateHideWindowCommon(window, transform);
 343 }
 344
 345 // Show/Hide windows using a fade.
 346 void AnimateShowWindow_Fade(aura::Window* window) {
 347   AnimateShowWindowCommon(window, gfx::Transform(), gfx::Transform());
 348 }
 349
 350 void AnimateHideWindow_Fade(aura::Window* window) {
 351   AnimateHideWindowCommon(window, gfx::Transform());
 352 }
 353
 354 ui::LayerAnimationElement* CreateGrowShrinkElement(
 355     aura::Window* window, bool grow) {
 356   scoped_ptr<ui::InterpolatedTransform> scale(new ui::InterpolatedScale(
 357       gfx::Point3F(kWindowAnimation_Bounce_Scale,
 358                    kWindowAnimation_Bounce_Scale,
 359                    1),
 360       gfx::Point3F(1, 1, 1)));
 361   scoped_ptr<ui::InterpolatedTransform> scale_about_pivot(
 362       new ui::InterpolatedTransformAboutPivot(
 363           gfx::Point(window->bounds().width() * 0.5,
 364                      window->bounds().height() * 0.5),
 365           scale.release()));
 366   scale_about_pivot->SetReversed(grow);
 367   scoped_ptr<ui::LayerAnimationElement> transition(
 368       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
 369           scale_about_pivot.release(),
 370           base::TimeDelta::FromMilliseconds(
 371               kWindowAnimation_Bounce_DurationMS *
 372                   kWindowAnimation_Bounce_GrowShrinkDurationPercent / 100)));
 373   transition->set_tween_type(grow ? gfx::Tween::EASE_OUT : gfx::Tween::EASE_IN);
 374   return transition.release();
 375 }
 376
 377 void AnimateBounce(aura::Window* window) {
 378   ui::ScopedLayerAnimationSettings scoped_settings(
 379       window->layer()->GetAnimator());
 380   scoped_settings.SetPreemptionStrategy(
 381       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 382   scoped_ptr<ui::LayerAnimationSequence> sequence(
 383       new ui::LayerAnimationSequence);
 384   sequence->AddElement(CreateGrowShrinkElement(window, true));
 385   sequence->AddElement(ui::LayerAnimationElement::CreatePauseElement(
 386       ui::LayerAnimationElement::BOUNDS,
 387       base::TimeDelta::FromMilliseconds(
 388         kWindowAnimation_Bounce_DurationMS *
 389             (100 - 2 * kWindowAnimation_Bounce_GrowShrinkDurationPercent) /
 390             100)));
 391   sequence->AddElement(CreateGrowShrinkElement(window, false));
 392   window->layer()->GetAnimator()->StartAnimation(sequence.release());
 393 }
 394
 395 // A HidingWindowAnimationObserver that deletes observer and detached
 396 // layers when the last_sequence has been completed or aborted.
 397 class RotateHidingWindowAnimationObserver
 398     : public HidingWindowAnimationObserverBase,
 399       public ui::LayerAnimationObserver {
 400  public:
 401   explicit RotateHidingWindowAnimationObserver(aura::Window* window)
 402       : HidingWindowAnimationObserverBase(window) {}
 403   virtual ~RotateHidingWindowAnimationObserver() {}
 404
 405   // Destroys itself after |last_sequence| ends or is aborted. Does not take
 406   // ownership of |last_sequence|, which should not be NULL.
 407   void SetLastSequence(ui::LayerAnimationSequence* last_sequence) {
 408     last_sequence->AddObserver(this);
 409   }
 410
 411   // ui::LayerAnimationObserver:
 412   virtual void OnLayerAnimationEnded(
 413       ui::LayerAnimationSequence* sequence) OVERRIDE {
 414     OnAnimationCompleted();
 415   }
 416   virtual void OnLayerAnimationAborted(
 417       ui::LayerAnimationSequence* sequence) OVERRIDE {
 418     OnAnimationCompleted();
 419   }
 420   virtual void OnLayerAnimationScheduled(
 421       ui::LayerAnimationSequence* sequence) OVERRIDE {}
 422
 423  private:
 424   DISALLOW_COPY_AND_ASSIGN(RotateHidingWindowAnimationObserver);
 425 };
 426
 427 void AddLayerAnimationsForRotate(aura::Window* window, bool show) {
 428   if (show)
 429     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 430
 431   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(
 432       kWindowAnimation_Rotate_DurationMS);
 433
 434   RotateHidingWindowAnimationObserver* observer = NULL;
 435
 436   if (!show) {
 437     observer = new RotateHidingWindowAnimationObserver(window);
 438     window->layer()->GetAnimator()->SchedulePauseForProperties(
 439         duration * (100 - kWindowAnimation_Rotate_OpacityDurationPercent) / 100,
 440         ui::LayerAnimationElement::OPACITY);
 441   }
 442   scoped_ptr<ui::LayerAnimationElement> opacity(
 443       ui::LayerAnimationElement::CreateOpacityElement(
 444           show ? kWindowAnimation_ShowOpacity : kWindowAnimation_HideOpacity,
 445           duration * kWindowAnimation_Rotate_OpacityDurationPercent / 100));
 446   opacity->set_tween_type(gfx::Tween::EASE_IN_OUT);
 447   window->layer()->GetAnimator()->ScheduleAnimation(
 448       new ui::LayerAnimationSequence(opacity.release()));
 449
 450   float xcenter = window->bounds().width() * 0.5;
 451
 452   gfx::Transform transform;
 453   transform.Translate(xcenter, 0);
 454   transform.ApplyPerspectiveDepth(kWindowAnimation_Rotate_PerspectiveDepth);
 455   transform.Translate(-xcenter, 0);
 456   scoped_ptr<ui::InterpolatedTransform> perspective(
 457       new ui::InterpolatedConstantTransform(transform));
 458
 459   scoped_ptr<ui::InterpolatedTransform> scale(
 460       new ui::InterpolatedScale(1, kWindowAnimation_Rotate_ScaleFactor));
 461   scoped_ptr<ui::InterpolatedTransform> scale_about_pivot(
 462       new ui::InterpolatedTransformAboutPivot(
 463           gfx::Point(xcenter, kWindowAnimation_Rotate_TranslateY),
 464           scale.release()));
 465
 466   scoped_ptr<ui::InterpolatedTransform> translation(
 467       new ui::InterpolatedTranslation(gfx::Point(), gfx::Point(
 468           0, kWindowAnimation_Rotate_TranslateY)));
 469
 470   scoped_ptr<ui::InterpolatedTransform> rotation(
 471       new ui::InterpolatedAxisAngleRotation(
 472           gfx::Vector3dF(1, 0, 0), 0, kWindowAnimation_Rotate_DegreesX));
 473
 474   scale_about_pivot->SetChild(perspective.release());
 475   translation->SetChild(scale_about_pivot.release());
 476   rotation->SetChild(translation.release());
 477   rotation->SetReversed(show);
 478
 479   scoped_ptr<ui::LayerAnimationElement> transition(
 480       ui::LayerAnimationElement::CreateInterpolatedTransformElement(
 481           rotation.release(), duration));
 482   ui::LayerAnimationSequence* last_sequence =
 483       new ui::LayerAnimationSequence(transition.release());
 484   window->layer()->GetAnimator()->ScheduleAnimation(last_sequence);
 485
 486   if (observer) {
 487     observer->SetLastSequence(last_sequence);
 488     observer->DetachAndRecreateLayers();
 489   }
 490 }
 491
 492 void AnimateShowWindow_Rotate(aura::Window* window) {
 493   AddLayerAnimationsForRotate(window, true);
 494 }
 495
 496 void AnimateHideWindow_Rotate(aura::Window* window) {
 497   AddLayerAnimationsForRotate(window, false);
 498 }
 499
 500 bool AnimateShowWindow(aura::Window* window) {
 501   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
 502     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
 503       // Since hide animation may have changed opacity and transform,
 504       // reset them to show the window.
 505       window->layer()->SetOpacity(kWindowAnimation_ShowOpacity);
 506       window->layer()->SetTransform(gfx::Transform());
 507     }
 508     return false;
 509   }
 510
 511   switch (GetWindowVisibilityAnimationType(window)) {
 512     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
 513       AnimateShowWindow_Drop(window);
 514       return true;
 515     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
 516       AnimateShowWindow_Vertical(window);
 517       return true;
 518     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
 519       AnimateShowWindow_Fade(window);
 520       return true;
 521     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
 522       AnimateShowWindow_Rotate(window);
 523       return true;
 524     default:
 525       return false;
 526   }
 527 }
 528
 529 bool AnimateHideWindow(aura::Window* window) {
 530   if (!HasWindowVisibilityAnimationTransition(window, ANIMATE_HIDE)) {
 531     if (HasWindowVisibilityAnimationTransition(window, ANIMATE_SHOW)) {
 532       // Since show animation may have changed opacity and transform,
 533       // reset them, though the change should be hidden.
 534       window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
 535       window->layer()->SetTransform(gfx::Transform());
 536     }
 537     return false;
 538   }
 539
 540   switch (GetWindowVisibilityAnimationType(window)) {
 541     case WINDOW_VISIBILITY_ANIMATION_TYPE_DROP:
 542       AnimateHideWindow_Drop(window);
 543       return true;
 544     case WINDOW_VISIBILITY_ANIMATION_TYPE_VERTICAL:
 545       AnimateHideWindow_Vertical(window);
 546       return true;
 547     case WINDOW_VISIBILITY_ANIMATION_TYPE_FADE:
 548       AnimateHideWindow_Fade(window);
 549       return true;
 550     case WINDOW_VISIBILITY_ANIMATION_TYPE_ROTATE:
 551       AnimateHideWindow_Rotate(window);
 552       return true;
 553     default:
 554       return false;
 555   }
 556 }
 557
 558 }  // namespace
 559
 560 ////////////////////////////////////////////////////////////////////////////////
 561 // ImplicitHidingWindowAnimationObserver
 562
 563 ImplicitHidingWindowAnimationObserver::ImplicitHidingWindowAnimationObserver(
 564     aura::Window* window,
 565     ui::ScopedLayerAnimationSettings* settings)
 566     : HidingWindowAnimationObserverBase(window) {
 567   settings->AddObserver(this);
 568 }
 569
 570 void ImplicitHidingWindowAnimationObserver::OnImplicitAnimationsCompleted() {
 571   OnAnimationCompleted();
 572 }
 573
 574 ////////////////////////////////////////////////////////////////////////////////
 575 // ScopedHidingAnimationSettings
 576
 577 ScopedHidingAnimationSettings::ScopedHidingAnimationSettings(
 578     aura::Window* window)
 579     : layer_animation_settings_(window->layer()->GetAnimator()),
 580       observer_(new ImplicitHidingWindowAnimationObserver(
 581           window,
 582           &layer_animation_settings_)) {
 583 }
 584
 585 ScopedHidingAnimationSettings::~ScopedHidingAnimationSettings() {
 586   observer_->DetachAndRecreateLayers();
 587 }
 588
 589 ////////////////////////////////////////////////////////////////////////////////
 590 // External interface
 591
 592 void SetWindowVisibilityAnimationType(aura::Window* window, int type) {
 593   window->SetProperty(kWindowVisibilityAnimationTypeKey, type);
 594 }
 595
 596 int GetWindowVisibilityAnimationType(aura::Window* window) {
 597   return window->GetProperty(kWindowVisibilityAnimationTypeKey);
 598 }
 599
 600 void SetWindowVisibilityAnimationTransition(
 601     aura::Window* window,
 602     WindowVisibilityAnimationTransition transition) {
 603   window->SetProperty(kWindowVisibilityAnimationTransitionKey, transition);
 604 }
 605
 606 bool HasWindowVisibilityAnimationTransition(
 607     aura::Window* window,
 608     WindowVisibilityAnimationTransition transition) {
 609   WindowVisibilityAnimationTransition prop = window->GetProperty(
 610       kWindowVisibilityAnimationTransitionKey);
 611   return (prop & transition) != 0;
 612 }
 613
 614 void SetWindowVisibilityAnimationDuration(aura::Window* window,
 615                                           const base::TimeDelta& duration) {
 616   window->SetProperty(kWindowVisibilityAnimationDurationKey,
 617                       static_cast<int>(duration.ToInternalValue()));
 618 }
 619
 620 base::TimeDelta GetWindowVisibilityAnimationDuration(
 621     const aura::Window& window) {
 622   return base::TimeDelta::FromInternalValue(
 623       window.GetProperty(kWindowVisibilityAnimationDurationKey));
 624 }
 625
 626 void SetWindowVisibilityAnimationVerticalPosition(aura::Window* window,
 627                                                   float position) {
 628   window->SetProperty(kWindowVisibilityAnimationVerticalPositionKey, position);
 629 }
 630
 631 bool AnimateOnChildWindowVisibilityChanged(aura::Window* window, bool visible) {
 632   if (WindowAnimationsDisabled(window))
 633     return false;
 634   if (visible)
 635     return AnimateShowWindow(window);
 636   // Don't start hiding the window again if it's already being hidden.
 637   return window->layer()->GetTargetOpacity() != 0.0f &&
 638       AnimateHideWindow(window);
 639 }
 640
 641 bool AnimateWindow(aura::Window* window, WindowAnimationType type) {
 642   switch (type) {
 643   case WINDOW_ANIMATION_TYPE_BOUNCE:
 644     AnimateBounce(window);
 645     return true;
 646   default:
 647     NOTREACHED();
 648     return false;
 649   }
 650 }
 651
 652 bool WindowAnimationsDisabled(aura::Window* window) {
 653   // Individual windows can choose to skip animations.
 654   if (window && window->GetProperty(aura::client::kAnimationsDisabledKey))
 655     return true;
 656
 657   // Animations can be disabled globally for testing.
 658   if (CommandLine::ForCurrentProcess()->HasSwitch(
 659           switches::kWindowAnimationsDisabled))
 660     return true;
 661
 662   // Tests of animations themselves should still run even if the machine is
 663   // being accessed via Remote Desktop.
 664   if (ui::ScopedAnimationDurationScaleMode::duration_scale_mode() ==
 665       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION)
 666     return false;
 667
 668   // Let the user decide whether or not to play the animation.
 669   return !gfx::Animation::ShouldRenderRichAnimation();
 670 }
 671
 672 }  // namespace wm