Use the correct launcher assets for shelf alignment.

ash/wm/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/wm/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/ash_switches.h"
@@ skipping 106 matching lines @@
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
   void Detach() {
     shelf_ = NULL;
   }
 
   virtual void OnImplicitAnimationsCompleted() OVERRIDE {
     if (shelf_) {
-      shelf_->UpdateShelfBackground(
-          internal::BackgroundAnimator::CHANGE_ANIMATE);
+      shelf_->UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
     }
     delete this;
   }
 
  private:
   virtual ~UpdateShelfObserver() {
     if (shelf_)
       shelf_->update_shelf_observer_ = NULL;
   }
 
@@ skipping 163 matching lines @@
       FOR_EACH_OBSERVER(Observer, observers_, OnAutoHideStateChanged(
           CalculateAutoHideState(state_.visibility_state)));
     }
   } else {
     auto_hide_timer_.Stop();
   }
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
-  UpdateShelfBackground(internal::BackgroundAnimator::CHANGE_ANIMATE);
+  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 void ShelfLayoutManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfLayoutManager::RemoveObserver(Observer* 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(internal::BackgroundAnimator::CHANGE_ANIMATE);
+  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 ShelfLayoutManager::DragState ShelfLayoutManager::UpdateGestureDrag(
     const ui::GestureEvent& gesture) {
-  bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
+  bool horizontal = alignment_ == SHELF_ALIGNMENT_BOTTOM;
   gesture_drag_amount_ += horizontal ? gesture.details().scroll_y() :
                                        gesture.details().scroll_x();
   LayoutShelf();
 
   // Start reveling the status menu when:
   //   - dragging up on an already visible shelf
   //   - dragging up on a hidden shelf, but it is currently completely visible.
   if (horizontal && gesture.details().scroll_y() < 0) {
     int min_height = 0;
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
         launcher_widget())
       min_height = launcher_widget()->GetContentsView()->
           GetPreferredSize().height();
 
     if (min_height < launcher_widget()->GetWindowBoundsInScreen().height() &&
         gesture.root_location().x() >=
         status_area_widget_->GetWindowBoundsInScreen().x() &&
         IsDraggingTrayEnabled())
       return DRAG_TRAY;
   }
 
   return DRAG_SHELF;
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
-  bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
+  bool horizontal = alignment_ == SHELF_ALIGNMENT_BOTTOM;
   bool should_change = false;
   if (gesture.type() == ui::ET_GESTURE_SCROLL_END) {
     // The visibility of the shelf changes only if the shelf was dragged X%
     // along the correct axis. If the shelf was already visible, then the
     // direction of the drag does not matter.
     const float kDragHideThreshold = 0.4f;
     gfx::Rect bounds = GetIdealBounds();
     float drag_ratio = fabs(gesture_drag_amount_) /
                        (horizontal ?  bounds.height() : bounds.width());
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = drag_ratio > kDragHideThreshold;
     } else {
       bool correct_direction = false;
-      switch (alignment()) {
+      switch (alignment_) {
         case SHELF_ALIGNMENT_BOTTOM:
         case SHELF_ALIGNMENT_RIGHT:
           correct_direction = gesture_drag_amount_ < 0;
           break;
         case SHELF_ALIGNMENT_LEFT:
           correct_direction = gesture_drag_amount_ > 0;
           break;
       }
       should_change = correct_direction && drag_ratio > kDragHideThreshold;
     }
   } else if (gesture.type() == ui::ET_SCROLL_FLING_START) {
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = horizontal ? fabs(gesture.details().velocity_y()) > 0 :
                                    fabs(gesture.details().velocity_x()) > 0;
     } else {
       if (horizontal)
         should_change = gesture.details().velocity_y() < 0;
-      else if (alignment() == SHELF_ALIGNMENT_LEFT)
+      else if (alignment_ == SHELF_ALIGNMENT_LEFT)
         should_change = gesture.details().velocity_x() > 0;
       else
         should_change = gesture.details().velocity_x() < 0;
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
@@ skipping 21 matching lines @@
   }
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_NONE;
   ui::ScopedLayerAnimationSettings
       launcher_settings(GetLayer(launcher_widget())->GetAnimator()),
       status_settings(GetLayer(status_area_widget_)->GetAnimator());
   LayoutShelf();
   UpdateVisibilityState();
-  UpdateShelfBackground(internal::BackgroundAnimator::CHANGE_ANIMATE);
+  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, aura::LayoutManager implementation:
 
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
 }
 
 void ShelfLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
@@ skipping 23 matching lines @@
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnWindowActivated(aura::Window* active,
                                            aura::Window* old_active) {
   UpdateAutoHideStateNow();
 }
 
+bool ShelfLayoutManager::IsHorizontalAlignment() const {
+  return alignment_ == SHELF_ALIGNMENT_BOTTOM;
+}
+
+// static
+ShelfLayoutManager* ShelfLayoutManager::ForLauncher(aura::Window* window) {
+  return RootWindowController::ForLauncher(window)->shelf();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds() : opacity(0.0f) {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
@@ skipping 20 matching lines @@
     if (!event_filter_.get())
       event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     event_filter_.reset(NULL);
   }
 
   auto_hide_timer_.Stop();
 
   // Animating the background when transitioning from auto-hide & hidden to
   // visible is janky. Update the background immediately in this case.
-  internal::BackgroundAnimator::ChangeType change_type =
+  BackgroundAnimator::ChangeType change_type =
       (state_.visibility_state == SHELF_AUTO_HIDE &&
        state_.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
        state.visibility_state == SHELF_VISIBLE) ?
-      internal::BackgroundAnimator::CHANGE_IMMEDIATE :
-      internal::BackgroundAnimator::CHANGE_ANIMATE;
+      BackgroundAnimator::CHANGE_IMMEDIATE : BackgroundAnimator::CHANGE_ANIMATE;
   StopAnimating();
 
   State old_state = state_;
   state_ = state;
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   if (launcher_widget()) {
     ui::ScopedLayerAnimationSettings launcher_animation_setter(
         GetLayer(launcher_widget())->GetAnimator());
     launcher_animation_setter.SetTransitionDuration(
@@ skipping 151 matching lines @@
       (gesture_drag_status_ != GESTURE_DRAG_NONE ||
        state.visibility_state == SHELF_VISIBLE ||
        state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 }
 
 void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     TargetBounds* target_bounds) const {
   CHECK_EQ(GESTURE_DRAG_IN_PROGRESS, gesture_drag_status_);
-  bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
+  bool horizontal = alignment_ == SHELF_ALIGNMENT_BOTTOM;
   int resistance_free_region = 0;
 
   if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
       visibility_state() == SHELF_AUTO_HIDE &&
       auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
     resistance_free_region += horizontal ?
         target_bounds->launcher_bounds_in_root.height() :
         target_bounds->launcher_bounds_in_root.width();
     resistance_free_region -= kAutoHideSize;
   }
 
   bool resist = false;
   if (horizontal)
     resist = gesture_drag_amount_ < -resistance_free_region;
-  else if (alignment() == SHELF_ALIGNMENT_LEFT)
+  else if (alignment_ == SHELF_ALIGNMENT_LEFT)
     resist = gesture_drag_amount_ > resistance_free_region;
   else
     resist = gesture_drag_amount_ < -resistance_free_region;
 
   float translate = 0.f;
   if (resist) {
     float diff = fabsf(gesture_drag_amount_) - resistance_free_region;
     diff = std::min(diff, sqrtf(diff));
     if (gesture_drag_amount_ < 0)
       translate = -resistance_free_region - diff;
@@ skipping 18 matching lines @@
           target_bounds->launcher_bounds_in_root.height() + move - translate);
 
       // The statusbar should be in the center.
       gfx::Rect status_y = target_bounds->launcher_bounds_in_root;
       status_y.ClampToCenteredSize(
           target_bounds->status_bounds_in_root.size());
       target_bounds->status_bounds_in_root.set_y(status_y.y());
     }
   } else {
     // Move the launcher with the gesture.
-    if (alignment() == SHELF_ALIGNMENT_RIGHT)
+    if (alignment_ == SHELF_ALIGNMENT_RIGHT)
       target_bounds->launcher_bounds_in_root.Offset(translate, 0);
 
-    if ((translate > 0 && alignment() == SHELF_ALIGNMENT_RIGHT) ||
-        (translate < 0 && alignment() == SHELF_ALIGNMENT_LEFT)) {
+    if ((translate > 0 && alignment_ == SHELF_ALIGNMENT_RIGHT) ||
+        (translate < 0 && alignment_ == SHELF_ALIGNMENT_LEFT)) {
       // When dragging towards the edge, the statusbar should move.
       target_bounds->status_bounds_in_root.Offset(translate, 0);
     } else {
       // When dragging away from the edge, the launcher width should increase.
-      float move = alignment() == SHELF_ALIGNMENT_RIGHT ?
+      float move = alignment_ == SHELF_ALIGNMENT_RIGHT ?
           std::max(translate, -static_cast<float>(resistance_free_region)) :
           std::min(translate, static_cast<float>(resistance_free_region));
 
-      if (alignment() == SHELF_ALIGNMENT_RIGHT) {
+      if (alignment_ == SHELF_ALIGNMENT_RIGHT) {
         target_bounds->launcher_bounds_in_root.set_width(
             target_bounds->launcher_bounds_in_root.width() + move - translate);
       } else {
         target_bounds->launcher_bounds_in_root.set_width(
             target_bounds->launcher_bounds_in_root.width() - move + translate);
       }
 
       // The statusbar should be in the center.
       gfx::Rect status_x = target_bounds->launcher_bounds_in_root;
       status_x.ClampToCenteredSize(
@@ skipping 111 matching lines @@
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash