Animating docked background in sync with shelf

ash/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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
@@ skipping 157 matching lines @@
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
   void Detach() {
     shelf_ = NULL;
   }
 
   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
-    if (shelf_) {
-      shelf_->UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
-    }
+    if (shelf_)
+      shelf_->UpdateShelfBackground(CHANGE_ANIMATE);
     delete this;
   }
 
  private:
   virtual ~UpdateShelfObserver() {
     if (shelf_)
       shelf_->update_shelf_observer_ = NULL;
   }
 
   // Shelf we're in. NULL if deleted before we're deleted.
@@ skipping 168 matching lines @@
           base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
           this, &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
-  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
+  UpdateShelfBackground(CHANGE_ANIMATE);
 }
 
 void ShelfLayoutManager::AddObserver(ShelfLayoutManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfLayoutManager::RemoveObserver(ShelfLayoutManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture dragging:
 
 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;
-  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
+  UpdateShelfBackground(CHANGE_ANIMATE);
 }
 
 ShelfLayoutManager::DragState ShelfLayoutManager::UpdateGestureDrag(
     const ui::GestureEvent& gesture) {
   bool horizontal = IsHorizontalAlignment();
   gesture_drag_amount_ += horizontal ? gesture.details().scroll_y() :
                                        gesture.details().scroll_x();
   LayoutShelf();
 
   // Start reveling the status menu when:
@@ skipping 192 matching lines @@
       auto_hide_event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     auto_hide_event_filter_.reset(NULL);
   }
 
   StopAutoHideTimer();
 
   State old_state = state_;
   state_ = state;
 
-  BackgroundAnimator::ChangeType change_type =
-      BackgroundAnimator::CHANGE_ANIMATE;
+  BackgroundAnimatorChangeType change_type = CHANGE_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 == WORKSPACE_WINDOW_STATE_MAXIMIZED &&
       old_state.visibility_state != SHELF_VISIBLE) {
-    change_type = BackgroundAnimator::CHANGE_IMMEDIATE;
+    change_type = CHANGE_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 299 matching lines @@
       gfx::Rect status_x = target_bounds->shelf_bounds_in_root;
       status_x.set_x(0);
       status_x.ClampToCenteredSize(
           target_bounds->status_bounds_in_shelf.size());
       target_bounds->status_bounds_in_shelf.set_x(status_x.x());
     }
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
-    BackgroundAnimator::ChangeType type) {
-  shelf_->SetPaintsBackground(GetShelfBackgroundType(), type);
+    BackgroundAnimatorChangeType type) {
+  const ShelfBackgroundType background_type(GetShelfBackgroundType());
+  shelf_->SetPaintsBackground(background_type, type);
+  FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
+                    OnBackgroundUpdated(background_type, type));
 }
 
 ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
   if (state_.visibility_state != SHELF_AUTO_HIDE &&
       state_.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED) {
     return SHELF_BACKGROUND_MAXIMIZED;
   }
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
       (!state_.is_screen_locked && window_overlaps_shelf_) ||
@@ skipping 182 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();
+    UpdateShelfBackground(CHANGE_ANIMATE);
   }
 }
 
 void ShelfLayoutManager::OnLockStateEvent(LockStateObserver::EventType event) {
   if (event == EVENT_LOCK_ANIMATION_STARTED) {
     // Hide the status area widget (using auto hide animation).
     base::AutoReset<ShelfVisibilityState> state(&state_.visibility_state,
                                                 SHELF_HIDDEN);
     TargetBounds target_bounds;
     CalculateTargetBounds(state_, &target_bounds);
@@ skipping 11 matching lines @@
       return gfx::Insets(0, distance, 0, 0);
     case SHELF_ALIGNMENT_TOP:
       return gfx::Insets(0, 0, distance, 0);
   }
   NOTREACHED();
   return gfx::Insets();
 }
 
 }  // namespace internal
 }  // namespace ash