Introduce ScopedBoundsChangeAnimation to temporarily change animation type.

Refactoring CL. No functional change.

Bug: None
Change-Id: I6e6027b5994e48d3ebafb7ec09062600763b0d28
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1726665Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Commit-Queue: Xiaoqian Dai <xdai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#683641}

ash/wm/default_state.cc

@@ -584,11 +584,9 @@ void DefaultState::UpdateBoundsFromState(WindowState* window_state,
 
   if (IsMinimizedWindowStateType(previous_state_type) ||
       window_state->IsFullscreen() || window_state->IsPinned() ||
-      enter_animation_type() == IMMEDIATE) {
+      window_state->bounds_animation_type() ==
+          WindowState::BoundsChangeAnimationType::IMMEDIATE) {
     window_state->SetBoundsDirect(bounds_in_parent);
-    // Reset the |enter_animation_type_| to DEFAULT if it is IMMEDIATE, which is
-    // set for non-top windows when entering clamshell mode.
-    set_enter_animation_type(DEFAULT);
   } else if (window_state->IsMaximized() ||
              IsMaximizedOrFullscreenOrPinnedWindowStateType(
                  previous_state_type)) {

ash/wm/tablet_mode/tablet_mode_window_state.cc

@@ -195,8 +195,10 @@ TabletModeWindowState::TabletModeWindowState(aura::Window* window,
   state_type_on_attach_ =
       snap ? current_state_type_ : GetMaximizedOrCenteredWindowType(state);
   // TODO(oshima|sammiequon): consider SplitView scenario.
-  if (entering_tablet_mode)
-    set_enter_animation_type(IsTopWindow(window) ? DEFAULT : STEP_END);
+  WindowState::ScopedBoundsChangeAnimation bounds_animation(
+      window, entering_tablet_mode && !IsTopWindow(window)
+                  ? WindowState::BoundsChangeAnimationType::STEP_END
+                  : WindowState::BoundsChangeAnimationType::DEFAULT);
   old_state_.reset(
       state->SetStateObject(std::unique_ptr<State>(this)).release());
 }
@@ -211,17 +213,19 @@ void TabletModeWindowState::LeaveTabletMode(WindowState* window_state,
   // or the top window or a window showing in splitview before leaving tablet
   // mode, and the window has changed its state. Otherwise, restore its bounds
   // immediately.
-  EnterAnimationType animation_type =
+  WindowState::BoundsChangeAnimationType animation_type =
       was_in_overview || window_state->IsSnapped() ||
               IsTopWindow(window_state->window())
-          ? DEFAULT
-          : IMMEDIATE;
+          ? WindowState::BoundsChangeAnimationType::DEFAULT
+          : WindowState::BoundsChangeAnimationType::IMMEDIATE;
   if (old_state_->GetType() == window_state->GetStateType() &&
       !window_state->IsNormalStateType()) {
-    animation_type = IMMEDIATE;
+    animation_type = WindowState::BoundsChangeAnimationType::IMMEDIATE;
   }
-  old_state_->set_enter_animation_type(animation_type);
+
   // Note: When we return we will destroy ourselves with the |our_reference|.
+  WindowState::ScopedBoundsChangeAnimation bounds_animation(
+      window_state->window(), animation_type);
   std::unique_ptr<WindowState::State> our_reference =
       window_state->SetStateObject(std::move(old_state_));
 }
@@ -480,16 +484,14 @@ void TabletModeWindowState::UpdateBounds(WindowState* window_state,
     if (!window_state->window()->IsVisible() || !animated) {
       window_state->SetBoundsDirect(bounds_in_parent);
     } else {
-      if (enter_animation_type() == STEP_END) {
+      if (window_state->bounds_animation_type() ==
+          WindowState::BoundsChangeAnimationType::STEP_END) {
         // Just use the normal bounds animation with ZERO tween with long enough
         // duration for STEP_END. The animation will be stopped when the to
         // window's animation ends.
         window_state->SetBoundsDirectAnimated(bounds_in_parent,
                                               base::TimeDelta::FromSeconds(1),
                                               gfx::Tween::ZERO);
-        // Reset the |enter_animation_type_| to DEFAULT it if is STEP_END, which
-        // is set for non-top windows when entering tablet mode.
-        set_enter_animation_type(DEFAULT);
         return;
       }
       // If we animate (to) tablet mode, we want to use the cross fade to

ash/wm/window_state.cc

@@ -178,6 +178,31 @@ void CollectPipEnterExitMetrics(aura::Window* window, bool enter) {
 
 constexpr base::TimeDelta WindowState::kBoundsChangeSlideDuration;
 
+WindowState::ScopedBoundsChangeAnimation::ScopedBoundsChangeAnimation(
+    aura::Window* window,
+    BoundsChangeAnimationType bounds_animation_type)
+    : window_(window) {
+  window_->AddObserver(this);
+  previous_bounds_animation_type_ =
+      WindowState::Get(window_)->bounds_animation_type_;
+  WindowState::Get(window_)->bounds_animation_type_ = bounds_animation_type;
+}
+
+WindowState::ScopedBoundsChangeAnimation::~ScopedBoundsChangeAnimation() {
+  if (window_) {
+    WindowState::Get(window_)->bounds_animation_type_ =
+        previous_bounds_animation_type_;
+    window_->RemoveObserver(this);
+    window_ = nullptr;
+  }
+}
+
+void WindowState::ScopedBoundsChangeAnimation::OnWindowDestroying(
+    aura::Window* window) {
+  window_->RemoveObserver(this);
+  window_ = nullptr;
+}
+
 WindowState::~WindowState() {
   // WindowState is registered as an owned property of |window_|, and window
   // unregisters all of its observers in its d'tor before destroying its

ash/wm/window_state.h

@@ -58,11 +58,6 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
   // Each subclass defines its own behavior and transition for each WMEvent.
   class State {
    public:
-    // Animation type of updating window bounds for entering current state.
-    // "IMMEDIATE" means update bounds directly without animation. "STEP_END"
-    // means update bounds at the end of the animation.
-    enum EnterAnimationType { DEFAULT, IMMEDIATE, STEP_END };
-
     State() {}
     virtual ~State() {}
 
@@ -87,16 +82,7 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
     // Called when the window is being destroyed.
     virtual void OnWindowDestroying(WindowState* window_state) {}
 
-    EnterAnimationType enter_animation_type() const {
-      return enter_animation_type_;
-    }
-    void set_enter_animation_type(EnterAnimationType type) {
-      enter_animation_type_ = type;
-    }
-
    private:
-    EnterAnimationType enter_animation_type_ = DEFAULT;
-
     DISALLOW_COPY_AND_ASSIGN(State);
   };
 
@@ -359,15 +345,41 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
   friend class DefaultState;
   friend class LockWindowState;
   friend class TabletModeWindowState;
+  friend class ScopedBoundsChangeAnimation;
   FRIEND_TEST_ALL_PREFIXES(WindowAnimationsTest, CrossFadeToBounds);
   FRIEND_TEST_ALL_PREFIXES(WindowAnimationsTest,
                            CrossFadeToBoundsFromTransform);
   FRIEND_TEST_ALL_PREFIXES(WindowStateTest, PipWindowMaskRecreated);
   FRIEND_TEST_ALL_PREFIXES(WindowStateTest, PipWindowHasMaskLayer);
 
+  // Animation type of updating window bounds. "IMMEDIATE" means update bounds
+  // directly without animation. "STEP_END" means update bounds at the end of
+  // the animation.
+  enum class BoundsChangeAnimationType { DEFAULT, IMMEDIATE, STEP_END };
+
+  // A class can temporarily change the window bounds change animation type.
+  class ScopedBoundsChangeAnimation : public aura::WindowObserver {
+   public:
+    ScopedBoundsChangeAnimation(aura::Window* window,
+                                BoundsChangeAnimationType animation_type);
+    ~ScopedBoundsChangeAnimation() override;
+
+    // aura::WindowObserver:
+    void OnWindowDestroying(aura::Window* window) override;
+
+   private:
+    aura::Window* window_;
+    BoundsChangeAnimationType previous_bounds_animation_type_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedBoundsChangeAnimation);
+  };
+
   explicit WindowState(aura::Window* window);
 
   WindowStateDelegate* delegate() { return delegate_.get(); }
+  BoundsChangeAnimationType bounds_animation_type() {
+    return bounds_animation_type_;
+  }
 
   bool HasMaximumWidthOrHeight() const;
 
@@ -476,6 +488,10 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
 
   std::unique_ptr<State> current_state_;
 
+  // The animation type for the bounds change.
+  BoundsChangeAnimationType bounds_animation_type_ =
+      BoundsChangeAnimationType::DEFAULT;
+
   DISALLOW_COPY_AND_ASSIGN(WindowState);
 };