Cleanup ash shelf accessor functions.

ash/wm/panels/panel_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/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 293 matching lines @@
 void PanelLayoutManager::FinishDragging() {
   dragged_panel_ = NULL;
   Relayout();
 }
 
 void PanelLayoutManager::SetShelf(Shelf* shelf) {
   DCHECK(!shelf_);
   DCHECK(!shelf_layout_manager_);
   shelf_ = shelf;
   shelf_->AddIconObserver(this);
-  if (shelf_->shelf_widget()) {
-    shelf_layout_manager_ = shelf_->shelf_widget()->shelf_layout_manager();
+  if (shelf_->shelf_layout_manager()) {
+    shelf_layout_manager_ = shelf_->shelf_layout_manager();
     WillChangeVisibilityState(shelf_layout_manager_->visibility_state());
     shelf_layout_manager_->AddObserver(this);
   }
 }
 
 void PanelLayoutManager::ToggleMinimize(aura::Window* panel) {
   DCHECK(panel->parent() == panel_container_);
   wm::WindowState* window_state = wm::GetWindowState(panel);
   if (window_state->IsMinimized())
     window_state->Restore();
@@ skipping 251 matching lines @@
 void PanelLayoutManager::MinimizePanel(aura::Window* panel) {
   ::wm::SetWindowVisibilityAnimationType(
       panel, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
   ui::Layer* layer = panel->layer();
   ui::ScopedLayerAnimationSettings panel_slide_settings(layer->GetAnimator());
   panel_slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   panel_slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
   gfx::Rect bounds(panel->bounds());
-  bounds.Offset(GetSlideInAnimationOffset(
-      shelf_->shelf_widget()->GetAlignment()));
+  bounds.Offset(GetSlideInAnimationOffset(shelf_->alignment()));
   SetChildBoundsDirect(panel, bounds);
   panel->Hide();
   layer->SetOpacity(0);
   if (wm::IsActiveWindow(panel))
     wm::DeactivateWindow(panel);
   Relayout();
 }
 
 void PanelLayoutManager::RestorePanel(aura::Window* panel) {
   PanelList::iterator found =
@@ skipping 12 matching lines @@
   // when the WindowSelectorController is restoring minimized windows so that
   // they actually become visible.
   WindowSelectorController* window_selector_controller =
       Shell::GetInstance()->window_selector_controller();
   if (in_layout_ || !window_selector_controller ||
       (window_selector_controller->IsSelecting() &&
           !window_selector_controller->IsRestoringMinimizedWindows()))
     return;
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
-  ShelfAlignment alignment = shelf_->shelf_widget()->GetAlignment();
-  bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
-                    alignment == SHELF_ALIGNMENT_BOTTOM;
+  const ShelfAlignment alignment = shelf_->alignment();
+  const bool horizontal = shelf_->IsHorizontalAlignment();
   gfx::Rect shelf_bounds = ash::ScreenUtil::ConvertRectFromScreen(
       panel_container_, shelf_->shelf_widget()->GetWindowBoundsInScreen());
   int panel_start_bounds = kPanelIdealSpacing;
   int panel_end_bounds = horizontal ?
       panel_container_->bounds().width() - kPanelIdealSpacing :
       panel_container_->bounds().height() - kPanelIdealSpacing;
   aura::Window* active_panel = NULL;
   std::vector<VisiblePanelPositionInfo> visible_panels;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
@@ skipping 137 matching lines @@
   UpdateCallouts();
 }
 
 void PanelLayoutManager::UpdateStacking(aura::Window* active_panel) {
   if (!active_panel) {
     if (!last_active_panel_)
       return;
     active_panel = last_active_panel_;
   }
 
-  ShelfAlignment alignment = shelf_->alignment();
-  bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
-                    alignment == SHELF_ALIGNMENT_BOTTOM;
-
   // We want to to stack the panels like a deck of cards:
   // ,--,--,--,-------.--.--.
   // |  |  |  |       |  |  |
   // |  |  |  |       |  |  |
   //
   // We use the middle of each panel to figure out how to stack the panels. This
   // allows us to update the stacking when a panel is being dragged around by
   // the titlebar--even though it doesn't update the shelf icon positions, we
   // still want the visual effect.
   std::map<int, aura::Window*> window_ordering;
+  const bool horizontal = shelf_->IsHorizontalAlignment();
   for (PanelList::const_iterator it = panel_windows_.begin();
        it != panel_windows_.end(); ++it) {
     gfx::Rect bounds = it->window->bounds();
     window_ordering.insert(std::make_pair(horizontal ?
                                               bounds.x() + bounds.width() / 2 :
                                               bounds.y() + bounds.height() / 2,
                                           it->window));
   }
 
   aura::Window* previous_panel = NULL;
@@ skipping 14 matching lines @@
     previous_panel = it->second;
   }
 
   panel_container_->StackChildAtTop(active_panel);
   if (dragged_panel_ && dragged_panel_->parent() == panel_container_)
     panel_container_->StackChildAtTop(dragged_panel_);
   last_active_panel_ = active_panel;
 }
 
 void PanelLayoutManager::UpdateCallouts() {
-  ShelfAlignment alignment = shelf_->alignment();
-  bool horizontal = alignment == SHELF_ALIGNMENT_TOP ||
-                    alignment == SHELF_ALIGNMENT_BOTTOM;
-
+  const bool horizontal = shelf_->IsHorizontalAlignment();
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     aura::Window* panel = iter->window;
     views::Widget* callout_widget = iter->callout_widget;
 
     gfx::Rect current_bounds = panel->GetBoundsInScreen();
     gfx::Rect bounds = ScreenUtil::ConvertRectToScreen(
         panel->parent(),
         panel->GetTargetBounds());
     gfx::Rect icon_bounds = shelf_->GetScreenBoundsOfItemIconForWindow(panel);
@@ skipping 15 matching lines @@
           current_bounds.x() - callout_bounds.x(),
           callout_bounds.right() - current_bounds.right());
     } else {
       callout_bounds.set_y(
           icon_bounds.y() + (icon_bounds.height() -
                              callout_bounds.height()) / 2);
       distance_until_over_panel = std::max(
           current_bounds.y() - callout_bounds.y(),
           callout_bounds.bottom() - current_bounds.bottom());
     }
-    switch (alignment) {
+    switch (shelf_->alignment()) {
       case SHELF_ALIGNMENT_BOTTOM:
         callout_bounds.set_y(bounds.bottom());
         break;
       case SHELF_ALIGNMENT_LEFT:
         callout_bounds.set_x(bounds.x() - callout_bounds.width());
         break;
       case SHELF_ALIGNMENT_RIGHT:
         callout_bounds.set_x(bounds.right());
         break;
       case SHELF_ALIGNMENT_TOP:
@@ skipping 72 matching lines @@
       // Keyboard hidden, restore original bounds if they exist.
       SetChildBounds(panel, panel_state->GetRestoreBoundsInScreen());
     }
   }
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 }  // namespace ash