ash: Clean up shelf GetAlignment() and IsHorizontalAlignment() calls

ash/common/shelf/overflow_bubble_view.cc

 // Copyright 2013 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/overflow_bubble_view.h"
 
 #include <algorithm>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
-#include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Max bubble size to screen size ratio.
 const float kMaxBubbleSizeToScreenRatio = 0.5f;
 
 // Inner padding in pixels for shelf view inside bubble.
 const int kPadding = 2;
 
 // Padding space in pixels between ShelfView's left/top edge to its contents.
 const int kShelfViewLeadingInset = 8;
 
 }  // namespace
 
 OverflowBubbleView::OverflowBubbleView(WmShelf* wm_shelf)
-    : wm_shelf_(wm_shelf), shelf_view_(nullptr) {}
+    : wm_shelf_(wm_shelf), shelf_view_(nullptr) {
+  DCHECK(wm_shelf_);
+}
 
 OverflowBubbleView::~OverflowBubbleView() {}
 
 void OverflowBubbleView::InitOverflowBubble(views::View* anchor,
                                             views::View* shelf_view) {
   shelf_view_ = shelf_view;
 
   SetAnchorView(anchor);
   set_arrow(GetBubbleArrow());
   set_mirror_arrow_in_rtl(false);
@@ skipping 11 matching lines @@
   // Makes bubble view has a layer and clip its children layers.
   SetPaintToLayer();
   layer()->SetFillsBoundsOpaquely(false);
   layer()->SetMasksToBounds(true);
 
   // Calls into OnBeforeBubbleWidgetInit to set the window parent container.
   views::BubbleDialogDelegateView::CreateBubble(this);
   AddChildView(shelf_view_);
 }
 
-bool OverflowBubbleView::IsHorizontalAlignment() const {
-  return ::ash::IsHorizontalAlignment(wm_shelf_->GetAlignment());
-}
-
 const gfx::Size OverflowBubbleView::GetContentsSize() const {
   return shelf_view_->GetPreferredSize();
 }
 
 // Gets arrow location based on shelf alignment.
 views::BubbleBorder::Arrow OverflowBubbleView::GetBubbleArrow() const {
   switch (wm_shelf_->GetAlignment()) {
     case SHELF_ALIGNMENT_BOTTOM:
     case SHELF_ALIGNMENT_BOTTOM_LOCKED:
       return views::BubbleBorder::BOTTOM_LEFT;
@@ skipping 27 matching lines @@
 }
 
 gfx::Size OverflowBubbleView::GetPreferredSize() const {
   gfx::Size preferred_size = GetContentsSize();
 
   const gfx::Rect monitor_rect =
       display::Screen::GetScreen()
           ->GetDisplayNearestPoint(GetAnchorRect().CenterPoint())
           .work_area();
   if (!monitor_rect.IsEmpty()) {
-    if (IsHorizontalAlignment()) {
+    if (wm_shelf_->IsHorizontalAlignment()) {
       preferred_size.set_width(
           std::min(preferred_size.width(),
                    static_cast<int>(monitor_rect.width() *
                                     kMaxBubbleSizeToScreenRatio)));
     } else {
       preferred_size.set_height(
           std::min(preferred_size.height(),
                    static_cast<int>(monitor_rect.height() *
                                     kMaxBubbleSizeToScreenRatio)));
     }
   }
 
   return preferred_size;
 }
 
 void OverflowBubbleView::Layout() {
   shelf_view_->SetBoundsRect(gfx::Rect(
       gfx::PointAtOffsetFromOrigin(-scroll_offset_), GetContentsSize()));
 }
 
 void OverflowBubbleView::ChildPreferredSizeChanged(views::View* child) {
   // When contents size is changed, ContentsBounds should be updated before
   // calculating scroll offset.
   SizeToContents();
 
   // Ensures |shelf_view_| is still visible.
-  if (IsHorizontalAlignment())
+  if (wm_shelf_->IsHorizontalAlignment())
     ScrollByXOffset(0);
   else
     ScrollByYOffset(0);
   Layout();
 }
 
 bool OverflowBubbleView::OnMouseWheel(const ui::MouseWheelEvent& event) {
   // The MouseWheelEvent was changed to support both X and Y offsets
   // recently, but the behavior of this function was retained to continue
   // using Y offsets only. Might be good to simply scroll in both
   // directions as in OverflowBubbleView::OnScrollEvent.
-  if (IsHorizontalAlignment())
+  if (wm_shelf_->IsHorizontalAlignment())
     ScrollByXOffset(-event.y_offset());
   else
     ScrollByYOffset(-event.y_offset());
   Layout();
 
   return true;
 }
 
 void OverflowBubbleView::OnScrollEvent(ui::ScrollEvent* event) {
   ScrollByXOffset(-event->x_offset());
@@ skipping 56 matching lines @@
 
     bubble_rect.Offset(0, offset);
     border->set_arrow_offset(anchor_rect.CenterPoint().y() - bubble_rect.y());
   }
 
   GetBubbleFrameView()->SchedulePaint();
   return bubble_rect;
 }
 
 }  // namespace ash