Animate window control changes in TouchView

ash/frame/caption_buttons/frame_caption_button_container_view.cc

Index: ash/frame/caption_buttons/frame_caption_button_container_view.cc
diff --git a/ash/frame/caption_buttons/frame_caption_button_container_view.cc b/ash/frame/caption_buttons/frame_caption_button_container_view.cc
index f533f14a8119b6f39ed57c5bdb777ce7c71ad084..1f278d666f737893a38bc1c16cea01fa87650a3c 100644
--- a/ash/frame/caption_buttons/frame_caption_button_container_view.cc
+++ b/ash/frame/caption_buttons/frame_caption_button_container_view.cc
@@ -5,6 +5,7 @@
 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
 
 #include <cmath>
+#include <map>
 
 #include "ash/ash_switches.h"
 #include "ash/frame/caption_buttons/alternate_frame_size_button.h"
@@ -15,7 +16,10 @@
 #include "grit/ui_strings.h"  // Accessibility names
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
@@ -26,6 +30,14 @@ namespace ash {
 
 namespace {
 
+// Visual design parameters for animating the transition to maximize mode.
+// When the size button hides we delay sliding the minimize button into its
+// location. Also used to delay showing the size button so that the minimize
+// button slides out of that position.
+const int kAnimationDelayMs = 100;
+const int kMinimizeSlideDurationMs = 500;
+const int kSizeFadeDurationMs = 250;
+
 // Converts |point| from |src| to |dst| and hittests against |dst|.
 bool ConvertPointToViewAndHitTest(const views::View* src,
                                   const views::View* dst,
@@ -50,6 +62,9 @@ FrameCaptionButtonContainerView::FrameCaptionButtonContainerView(
       close_button_(NULL) {
   bool alternate_style = switches::UseAlternateFrameCaptionButtonStyle();
 
+  SetPaintToLayer(true);
+  SetFillsBoundsOpaquely(false);
+
   // Insert the buttons left to right.
   minimize_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_MINIMIZE);
   minimize_button_->SetAccessibleName(
@@ -59,6 +74,8 @@ FrameCaptionButtonContainerView::FrameCaptionButtonContainerView(
   minimize_button_->SetVisible(
       minimize_allowed == MINIMIZE_ALLOWED &&
       (alternate_style || !frame_->widget_delegate()->CanMaximize()));
+  minimize_button_->SetPaintToLayer(true);
+  minimize_button_->SetFillsBoundsOpaquely(false);
   AddChildView(minimize_button_);
 
   if (alternate_style)
@@ -67,12 +84,16 @@ FrameCaptionButtonContainerView::FrameCaptionButtonContainerView(
     size_button_ = new FrameMaximizeButton(this, frame);
   size_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MAXIMIZE));
+  size_button_->SetPaintToLayer(true);
+  size_button_->SetFillsBoundsOpaquely(false);
   UpdateSizeButtonVisibility(false);
   AddChildView(size_button_);
 
   close_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_CLOSE);
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE));
+  close_button_->SetPaintToLayer(true);
+  close_button_->SetFillsBoundsOpaquely(false);
   AddChildView(close_button_);
 }
 
@@ -143,8 +164,41 @@ void FrameCaptionButtonContainerView::UpdateSizeButtonVisibility(
   // time when ShellObserver::OnMaximizeModeStarted is called. This prevents
   // this method from performing that check, and instead relies on the calling
   // code to tell it to force being hidden.
-  size_button_->SetVisible(
-      !force_hidden && frame_->widget_delegate()->CanMaximize());
+
+  bool visible = !force_hidden && frame_->widget_delegate()->CanMaximize();
+
+  // Turning visibility off prevents animations from rendering. Setting the
+  // size button visibility to false will occur after the animation.
+  if (visible)
+    size_button_->SetVisible(visible);
+
+  ui::ScopedLayerAnimationSettings settings(
+      size_button_->layer()->GetAnimator());
+  settings.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kSizeFadeDurationMs));
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
+  if (visible) {
+    settings.SetTweenType(gfx::Tween::EASE_OUT);
+    // Delay fade in so that the minimize button has begun its sliding
+    // animation.
+    size_button_->layer()->GetAnimator()->SchedulePauseForProperties(
+        base::TimeDelta::FromMilliseconds(kAnimationDelayMs),
+        ui::LayerAnimationElement::OPACITY);
+    size_button_->layer()->SetOpacity(1.0f);
+  } else {
+    settings.SetTweenType(gfx::Tween::EASE_IN);
+    // Observer will call size_button_->SetVisible(false) upon completion of
+    // the animation.
+    // TODO(jonross): avoid the delayed SetVisible(false) call by acquring
+    // the size_button's layer before making it invisible. That layer can then
+    // be animated and deleted upon completion of the animation. See
+    // LayerOwner::RecreateLayer
+    settings.AddObserver(this);
+    size_button_->layer()->SetOpacity(0.0f);
+    size_button_->layer()->SetVisible(false);
+  }
 }
 
 gfx::Size FrameCaptionButtonContainerView::GetPreferredSize() {
@@ -158,15 +212,57 @@ gfx::Size FrameCaptionButtonContainerView::GetPreferredSize() {
 }
 
 void FrameCaptionButtonContainerView::Layout() {

[jonross, 2014/05/09 18:41:10]

Redone to not care which button is changing visibility.

I had one thought though. This might be cleaner if we just tracked when a
visibility animation was triggered. And enable animations for each child's
layout during that time.

-  int x = 0;
-  for (int i = 0; i < child_count(); ++i) {
+  scoped_ptr<ui::ScopedLayerAnimationSettings> animation;

[flackr, 2014/05/09 18:57:58]

nit: Scope this to it's use, i.e. in the loop body.

[jonross, 2014/05/15 20:24:13]

Done.

+  bool previous_child_animating_visibility = false;
+  bool previous_child_target_visibility = false;
+  int x = width();
+  for (int i = child_count() - 1; i >= 0; --i) {
     views::View* child = child_at(i);
-    if (!child->visible())
+    ui::LayerAnimator* child_animator = child->layer()->GetAnimator();
+    bool child_animating = child_animator->is_animating();
+    // The actual property visibility is not being animated, otherwise the
+    // view does not render.
+    bool child_animating_visibility = child_animator->
+        IsAnimatingProperty(ui::LayerAnimationElement::OPACITY);

[flackr, 2014/05/09 18:57:58]

Instead of checking if it's animating opacity, checking current opacity > 0.0f
might work as long as this is called immediately after
UpdateSizeButtonVisibility right? This would also prevent a double animation if
it was called again and won't require digging into all of the animators.

[jonross, 2014/05/09 19:03:34]

Issue with that is that layout is called 7+ times after
UpdateSizeButtonVisibility, while transitioning to maximize mode. Depending on
when it is called we could have non-zero opacity for both animations.

+    bool child_target_visibility = child->layer()->GetTargetVisibility();
+
+
+    if (!child->visible() ||
+        (child_animating_visibility && !child_target_visibility)) {
+      previous_child_animating_visibility = child_animating_visibility;
+      previous_child_target_visibility = child_target_visibility;

[flackr, 2014/05/09 18:57:58]

This really needs to be an offset width. The buttons aren't necessarily the same
size, and in theory there can be multiple hiding. I think both of these bools
can be captured by a single value for the x offset to start animating all
subsequent buttons from.

Then the animation should pause if that offset is negative (i.e. wait for things
which are hiding).

[jonross, 2014/05/15 20:24:13]

Done.

       continue;
+    }
 
     gfx::Size size = child->GetPreferredSize();
+    // Animate the button if the previous button is currently animating
+    // its visibility.
+    if (previous_child_animating_visibility) {
+      if (previous_child_target_visibility) {
+        if (!child_animating)
+          child->SetBounds(x, 0, size.width(), size.height());
+      } else {
+        // Delay sliding to where the previous button was located.
+        child_animator->SchedulePauseForProperties(
+             base::TimeDelta::FromMilliseconds(kAnimationDelayMs),
+             ui::LayerAnimationElement::BOUNDS);
+      }
+      ui::ScopedLayerAnimationSettings* settings =
+          new ui::ScopedLayerAnimationSettings(child_animator);
+      settings->SetTransitionDuration(
+          base::TimeDelta::FromMilliseconds(kMinimizeSlideDurationMs));
+      settings->SetPreemptionStrategy(
+          ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+      settings->SetTweenType(gfx::Tween::EASE_OUT);
+      animation.reset(settings);
+    }
+    x -= size.width();
     child->SetBounds(x, 0, size.width(), size.height());
-    x += size.width();
+
+    if (child_animating_visibility) {
+      previous_child_animating_visibility = child_animating_visibility;
+      previous_child_target_visibility = child_target_visibility;
+    }
   }
 }
 
@@ -218,7 +314,7 @@ void FrameCaptionButtonContainerView::ButtonPressed(views::Button* sender,
   if (sender == minimize_button_) {
     frame_->Minimize();
   } else if (sender == size_button_) {
-    if (frame_->IsFullscreen()) { // Can be clicked in immersive fullscreen.
+    if (frame_->IsFullscreen()) {  // Can be clicked in immersive fullscreen.
       frame_->SetFullscreen(false);
       action = ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_EXIT_FULLSCREEN;
     } else if (frame_->IsMaximized()) {
@@ -228,7 +324,7 @@ void FrameCaptionButtonContainerView::ButtonPressed(views::Button* sender,
       frame_->Maximize();
       action = ash::UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_MAXIMIZE;
     }
-  } else if(sender == close_button_) {
+  } else if (sender == close_button_) {
     frame_->Close();
     action = ash::UMA_WINDOW_CLOSE_BUTTON_CLICK;
   } else {
@@ -305,6 +401,19 @@ void FrameCaptionButtonContainerView::SetHoveredAndPressedButtons(
   }
 }
 
+void FrameCaptionButtonContainerView::OnImplicitAnimationsCompleted() {
+  DCHECK(!size_button_->layer()->GetTargetVisibility());
+  size_button_->SetVisible(false);
+  // TODO(jonross): currently we need to delay telling the parent about the
+  // size change from visibility. When the size changes this forces a relayout
+  // and we want to animate both the bounds of FrameCaptionButtonContainerView
+  // along with that of its children. However when the parent is currently
+  // having its bounds changed this leads to strange animations where this view
+  // renders outside of its parents. Create a more specific animation where
+  // height and y are immediately fixed, and where we only animate width and x.
+  PreferredSizeChanged();
+}
+
 FrameCaptionButtonContainerView::ButtonIconIds::ButtonIconIds()
     : icon_image_id(-1),
       inactive_icon_image_id(-1),