chromeos: Remove wm_shelf_util.h

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>
 
 #include "ash/keyboard/keyboard_observer_register.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/wm_shelf.h"
-#include "ash/shelf/wm_shelf_util.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/window_animation_types.h"
 #include "ash/wm/window_parenting_utils.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm_window.h"
@@ skipping 154 matching lines @@
 }
 
 }  // namespace
 
 class PanelCalloutWidget : public views::Widget {
  public:
   explicit PanelCalloutWidget(WmWindow* container) : background_(nullptr) {
     InitWidget(container);
   }
 
-  void SetAlignment(ShelfAlignment alignment) {
+  // Updates the bounds based on the shelf alignment.
+  void UpdateBounds(WmShelf* shelf) {
     WmWindow* window = WmWindow::Get(this->GetNativeWindow());
     gfx::Rect callout_bounds = window->GetBounds();
-    if (IsHorizontalAlignment(alignment)) {
+    if (shelf->IsHorizontalAlignment()) {
       callout_bounds.set_width(kArrowWidth);
       callout_bounds.set_height(kArrowHeight);
     } else {
       callout_bounds.set_width(kArrowHeight);
       callout_bounds.set_height(kArrowWidth);
     }
     WmWindow* parent = window->GetParent();
     // It's important this go through WmWindow and not Widget. Going through
     // Widget means it may move do a different screen, we don't want that.
     window->SetBounds(callout_bounds);
     // Setting the bounds should not trigger changing the parent.
     DCHECK_EQ(parent, window->GetParent());
-    if (background_->alignment() != alignment) {
-      background_->set_alignment(alignment);
+    if (background_->alignment() != shelf->alignment()) {
+      background_->set_alignment(shelf->alignment());
       SchedulePaintInRect(gfx::Rect(callout_bounds.size()));
     }
   }
 
  private:
   void InitWidget(WmWindow* parent) {
     views::Widget::InitParams params;
     params.type = views::Widget::InitParams::TYPE_POPUP;
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
     params.keep_on_top = true;
@@ skipping 397 matching lines @@
   WindowSelectorController* window_selector_controller =
       Shell::Get()->window_selector_controller();
   if (in_layout_ ||
       (window_selector_controller->IsSelecting() &&
        !window_selector_controller->IsRestoringMinimizedWindows())) {
     return;
   }
 
   base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
 
-  const ShelfAlignment alignment = shelf_->GetAlignment();
   const bool horizontal = shelf_->IsHorizontalAlignment();
   gfx::Rect shelf_bounds = panel_container_->ConvertRectFromScreen(
       shelf_->GetWindow()->GetBoundsInScreen());
   int panel_start_bounds = kPanelIdealSpacing;
   int panel_end_bounds =
       horizontal ? panel_container_->GetBounds().width() - kPanelIdealSpacing
                  : panel_container_->GetBounds().height() - kPanelIdealSpacing;
   WmWindow* active_panel = nullptr;
   std::vector<VisiblePanelPositionInfo> visible_panels;
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end(); ++iter) {
     WmWindow* panel = iter->window;
-    iter->callout_widget->SetAlignment(alignment);
+    iter->callout_widget->UpdateBounds(shelf_);
 
     // Consider the dragged panel as part of the layout as long as it is
     // touching the shelf.
     if ((!panel->IsVisible() && !iter->slide_in) ||
         (panel == dragged_panel_ &&
          !BoundsAdjacent(panel->GetBounds(), shelf_bounds))) {
       continue;
     }
 
     // If the shelf is currently hidden (full-screen mode), minimize panel until
@@ skipping 58 matching lines @@
     }
   }
   FanOutPanels(visible_panels.begin() + first_overlapping_panel,
                visible_panels.end());
 
   for (size_t i = 0; i < visible_panels.size(); ++i) {
     if (visible_panels[i].window == dragged_panel_)
       continue;
     bool slide_in = visible_panels[i].slide_in;
     gfx::Rect bounds = visible_panels[i].window->GetTargetBounds();
-    if (alignment == SHELF_ALIGNMENT_LEFT)
+    if (shelf_->alignment() == SHELF_ALIGNMENT_LEFT)
       bounds.set_x(shelf_bounds.right());
-    else if (alignment == SHELF_ALIGNMENT_RIGHT)
+    else if (shelf_->alignment() == SHELF_ALIGNMENT_RIGHT)
       bounds.set_x(shelf_bounds.x() - bounds.width());
     else
       bounds.set_y(shelf_bounds.y() - bounds.height());
     bool on_shelf = visible_panels[i].window->GetTargetBounds() == bounds;
 
     if (horizontal) {
       bounds.set_x(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     } else {
       bounds.set_y(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     }
 
     ui::Layer* layer = visible_panels[i].window->GetLayer();
     if (slide_in) {
       // New windows shift up from the shelf into position and fade in.
       layer->SetOpacity(0);
       gfx::Rect initial_bounds(bounds);
-      initial_bounds.Offset(GetSlideInAnimationOffset(alignment));
+      initial_bounds.Offset(GetSlideInAnimationOffset(shelf_->alignment()));
       visible_panels[i].window->SetBoundsDirect(initial_bounds);
       // Set on shelf so that the panel animates into its target position.
       on_shelf = true;
     }
 
     if (on_shelf) {
       ui::ScopedLayerAnimationSettings panel_slide_settings(
           layer->GetAnimator());
       panel_slide_settings.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 191 matching lines @@
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 void PanelLayoutManager::OnKeyboardClosed() {
   keyboard_observer_.RemoveAll();
 }
 
 }  // namespace ash