[ash-md] Remove the number of animators used for the Shelf animations.

ash/common/shelf/shelf_layout_manager.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/common/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "base/i18n/rtl.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
+#include "ui/gfx/animation/animation_change_type.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/border.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
@@ skipping 39 matching lines @@
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
   void Detach() { shelf_ = NULL; }
 
   void OnImplicitAnimationsCompleted() override {
     if (shelf_)
-      shelf_->MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+      shelf_->MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
     delete this;
   }
 
  private:
   ~UpdateShelfObserver() override {
     if (shelf_)
       shelf_->update_shelf_observer_ = NULL;
   }
 
   // Shelf we're in. NULL if deleted before we're deleted.
@@ skipping 208 matching lines @@
                                                        WmWindow* target) {
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
     return;
 
   if (IsShelfWindow(target) && ProcessGestureEvent(*event))
     event->StopPropagation();
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
-  MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+  MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
 }
 
 void ShelfLayoutManager::AddObserver(ShelfLayoutManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfLayoutManager::RemoveObserver(ShelfLayoutManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 154 matching lines @@
     return;  // Nothing changed.
 
   for (auto& observer : observers_)
     observer.WillChangeVisibilityState(visibility_state);
 
   StopAutoHideTimer();
 
   State old_state = state_;
   state_ = state;
 
-  BackgroundAnimatorChangeType change_type = BACKGROUND_CHANGE_ANIMATE;
+  gfx::AnimationChangeType change_type = gfx::AnimationChangeType::ANIMATE;
   bool delay_background_change = false;
 
   // Do not animate the background when:
   // - Going from a hidden / auto hidden shelf in fullscreen to a visible shelf
   //   in maximized mode.
   // - Going from an auto hidden shelf in maximized mode to a visible shelf in
   //   maximized mode.
   if (state.visibility_state == SHELF_VISIBLE &&
       state.window_state == wm::WORKSPACE_WINDOW_STATE_MAXIMIZED &&
       old_state.visibility_state != SHELF_VISIBLE) {
-    change_type = BACKGROUND_CHANGE_IMMEDIATE;
+    change_type = gfx::AnimationChangeType::IMMEDIATE;
   } else {
     // Delay the animation when the shelf was hidden, and has just been made
     // visible (e.g. using a gesture-drag).
     if (state.visibility_state == SHELF_VISIBLE &&
         old_state.visibility_state == SHELF_AUTO_HIDE &&
         old_state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
       delay_background_change = true;
     }
   }
 
@@ skipping 283 matching lines @@
       target_bounds->status_bounds_in_shelf.set_x(0);
     } else {
       target_bounds->status_bounds_in_shelf.set_x(
           target_bounds->shelf_bounds_in_root.width() -
           GetShelfConstant(SHELF_SIZE));
     }
   }
 }
 
 void ShelfLayoutManager::MaybeUpdateShelfBackground(
-    BackgroundAnimatorChangeType type) {
+    gfx::AnimationChangeType type) {
   const ShelfBackgroundType new_background_type(GetShelfBackgroundType());
 
   if (new_background_type == shelf_background_type_)
     return;
 
   shelf_background_type_ = new_background_type;
   for (auto& observer : observers_)
     observer.OnBackgroundUpdated(shelf_background_type_, type);
 }
 
@@ skipping 145 matching lines @@
 void ShelfLayoutManager::OnDockBoundsChanging(
     const gfx::Rect& dock_bounds,
     DockedWindowLayoutManagerObserver::Reason reason) {
   // Skip shelf layout in case docked notification originates from this class.
   if (reason == DISPLAY_INSETS_CHANGED)
     return;
   if (dock_bounds_ != dock_bounds) {
     dock_bounds_ = dock_bounds;
     OnWindowResized();
     UpdateVisibilityState();
-    MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+    MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
   }
 }
 
 void ShelfLayoutManager::OnLockStateEvent(LockStateObserver::EventType event) {
   if (event == EVENT_LOCK_ANIMATION_STARTED) {
     // Enter the screen locked state and update the visibility to avoid an odd
     // animation when transitioning the orientation from L/R to bottom.
     state_.pre_lock_screen_animation_active = true;
     UpdateShelfVisibilityAfterLoginUIChange();
   } else {
     state_.pre_lock_screen_animation_active = false;
   }
-  MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+  MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
 }
 
 void ShelfLayoutManager::SessionStateChanged(
     session_manager::SessionState state) {
   // Check transition changes to/from the add user to session and change the
   // shelf alignment accordingly
   const bool was_adding_user = state_.IsAddingSecondaryUser();
   const bool was_locked = state_.IsScreenLocked();
   state_.session_state = state;
-  MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+  MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
   if (was_adding_user != state_.IsAddingSecondaryUser()) {
     UpdateShelfVisibilityAfterLoginUIChange();
     return;
   }
 
   // Force the shelf to layout for alignment (bottom if locked, restore the
   // previous alignment otherwise).
   if (was_locked != state_.IsScreenLocked())
     UpdateShelfVisibilityAfterLoginUIChange();
 
@@ skipping 35 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture functions:
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
   gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE
                                       ? auto_hide_state()
                                       : SHELF_AUTO_HIDE_SHOWN;
-  MaybeUpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
+  MaybeUpdateShelfBackground(gfx::AnimationChangeType::ANIMATE);
 }
 
 void ShelfLayoutManager::UpdateGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_amount_ += PrimaryAxisValue(gesture.details().scroll_y(),
                                            gesture.details().scroll_x());
   LayoutShelf();
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
   bool horizontal = wm_shelf_->IsHorizontalAlignment();
@@ skipping 65 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash