mash: Convert ShelfView to wm common types, clean up Shelf access

ash/common/shelf/shelf_view.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_view.h"
+#include "ash/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/drag_drop/drag_image_view.h"
 #include "ash/common/scoped_root_window_for_new_windows.h"
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/overflow_bubble.h"
 #include "ash/common/shelf/overflow_bubble_view.h"
 #include "ash/common/shelf/overflow_button.h"
 #include "ash/common/shelf/shelf_button.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
+#include "ash/common/shelf/shelf_icon_observer.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/wm/root_window_finder.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/shelf/shelf.h"
-#include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_strings.h"
 #include "ui/accessibility/ax_view_state.h"
-#include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/views/animation/bounds_animator.h"
@@ skipping 305 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
 // static
 const int ShelfView::kMinimumDragDistance = 8;
 
 ShelfView::ShelfView(ShelfModel* model,
                      ShelfDelegate* delegate,
                      WmShelf* wm_shelf,
-                     Shelf* shelf)
+                     ShelfWidget* shelf_widget)
     : model_(model),
       delegate_(delegate),
       wm_shelf_(wm_shelf),
-      shelf_(shelf),
+      shelf_widget_(shelf_widget),
       view_model_(new views::ViewModel),
       first_visible_index_(0),
       last_visible_index_(-1),
       overflow_button_(nullptr),
       owner_overflow_bubble_(nullptr),
       tooltip_(this),
       drag_pointer_(NONE),
       drag_view_(nullptr),
       start_drag_index_(-1),
       context_menu_id_(0),
       leading_inset_(kDefaultLeadingInset),
       cancelling_drag_model_changed_(false),
       last_hidden_index_(0),
       closing_event_time_(base::TimeTicks()),
       drag_and_drop_item_pinned_(false),
       drag_and_drop_shelf_id_(0),
       drag_replaced_view_(nullptr),
       dragged_off_shelf_(false),
       snap_back_from_rip_off_view_(nullptr),
       overflow_mode_(false),
       main_shelf_(nullptr),
       dragged_off_from_overflow_to_shelf_(false),
       is_repost_event_on_same_item_(false),
       last_pressed_index_(-1) {
   DCHECK(model_);
   DCHECK(delegate_);
   DCHECK(wm_shelf_);
+  DCHECK(shelf_widget_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
 }
 
 ShelfView::~ShelfView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
 }
@@ skipping 67 matching lines @@
 
 void ShelfView::UpdatePanelIconPosition(ShelfID id,
                                         const gfx::Point& midpoint) {
   int current_index = model_->ItemIndexByID(id);
   int first_panel_index = model_->FirstPanelIndex();
   if (current_index < first_panel_index)
     return;
 
   gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()), midpoint.y());
   int target_index = current_index;
-  while (target_index > first_panel_index &&
-         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
+  while (
+      target_index > first_panel_index &&
+      wm_shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
                                   view_model_->ideal_bounds(target_index).y()) >
-             shelf_->PrimaryAxisValue(midpoint_in_view.x(),
+          wm_shelf_->PrimaryAxisValue(midpoint_in_view.x(),
                                       midpoint_in_view.y())) {
     --target_index;
   }
   while (target_index < view_model_->view_size() - 1 &&
-         shelf_->PrimaryAxisValue(
+         wm_shelf_->PrimaryAxisValue(
              view_model_->ideal_bounds(target_index).right(),
              view_model_->ideal_bounds(target_index).bottom()) <
-             shelf_->PrimaryAxisValue(midpoint_in_view.x(),
-                                      midpoint_in_view.y())) {
+             wm_shelf_->PrimaryAxisValue(midpoint_in_view.x(),
+                                         midpoint_in_view.y())) {
     ++target_index;
   }
   if (current_index != target_index)
     model_->Move(current_index, target_index);
 }
 
 bool ShelfView::IsShowingMenu() const {
   return launcher_menu_runner_.get() && launcher_menu_runner_->IsRunning();
 }
 
@@ skipping 241 matching lines @@
 
   // Only when the repost event occurs on the same shelf item, we should ignore
   // the call in ShelfView::ButtonPressed(...).
   is_repost_event_on_same_item_ =
       IsRepostEvent(event) && (last_pressed_index_ == index);
 
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   drag_view_ = static_cast<ShelfButton*>(view);
   drag_origin_ = gfx::Point(event.x(), event.y());
   UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
-                            shelf_->SelectValueForShelfAlignment(
+                            wm_shelf_->SelectValueForShelfAlignment(
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT),
                             SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
 }
 
 void ShelfView::PointerDraggedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   // To prepare all drag types (moving an item in the shelf and dragging off),
@@ skipping 52 matching lines @@
     // should be always true regardless of its position.
     if (dragged_off_from_overflow_to_shelf_ &&
         view_model_->view_at(i) == drag_view_)
       view_model_->view_at(i)->SetVisible(true);
     else
       view_model_->view_at(i)->SetVisible(visible);
   }
 }
 
 void ShelfView::CalculateIdealBounds(IdealBounds* bounds) const {
-  int available_size = shelf_->PrimaryAxisValue(width(), height());
+  int available_size = wm_shelf_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   int x = 0;
   int y = 0;
   int button_size = GetShelfConstant(SHELF_BUTTON_SIZE);
   int button_spacing = GetShelfConstant(SHELF_BUTTON_SPACING);
 
-  int w = shelf_->PrimaryAxisValue(button_size, width());
-  int h = shelf_->PrimaryAxisValue(height(), button_size);
+  int w = wm_shelf_->PrimaryAxisValue(button_size, width());
+  int h = wm_shelf_->PrimaryAxisValue(height(), button_size);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    x = shelf_->PrimaryAxisValue(x + w + button_spacing, x);
-    y = shelf_->PrimaryAxisValue(y, y + h + button_spacing);
+    x = wm_shelf_->PrimaryAxisValue(x + w + button_spacing, x);
+    y = wm_shelf_->PrimaryAxisValue(y, y + h + button_spacing);
   }
 
   if (is_overflow_mode()) {
     const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
   // Right aligned icons.
   int end_position = available_size - button_spacing;
-  x = shelf_->PrimaryAxisValue(end_position, 0);
-  y = shelf_->PrimaryAxisValue(0, end_position);
+  x = wm_shelf_->PrimaryAxisValue(end_position, 0);
+  y = wm_shelf_->PrimaryAxisValue(0, end_position);
   for (int i = view_model_->view_size() - 1; i >= first_panel_index; --i) {
-    x = shelf_->PrimaryAxisValue(x - w - button_spacing, x);
-    y = shelf_->PrimaryAxisValue(y, y - h - button_spacing);
+    x = wm_shelf_->PrimaryAxisValue(x - w - button_spacing, x);
+    y = wm_shelf_->PrimaryAxisValue(y, y - h - button_spacing);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    end_position = shelf_->PrimaryAxisValue(x, y);
+    end_position = wm_shelf_->PrimaryAxisValue(x, y);
   }
 
   // Icons on the left / top are guaranteed up to kLeftIconProportion of
   // the available space.
   int last_icon_position =
-      shelf_->PrimaryAxisValue(
+      wm_shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_button_index).right(),
           view_model_->ideal_bounds(last_button_index).bottom()) +
       button_size;
   int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
   if (last_icon_position < reserved_icon_space)
     end_position = last_icon_position;
   else
     end_position = std::max(end_position, reserved_icon_space);
 
   bounds->overflow_bounds.set_size(
-      gfx::Size(shelf_->PrimaryAxisValue(w, width()),
-                shelf_->PrimaryAxisValue(height(), h)));
+      gfx::Size(wm_shelf_->PrimaryAxisValue(w, width()),
+                wm_shelf_->PrimaryAxisValue(height(), h)));
 
   last_visible_index_ = DetermineLastVisibleIndex(end_position - button_size);
   last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
   bool show_overflow = last_visible_index_ < last_button_index ||
                        last_hidden_index_ >= first_panel_index;
 
   // Create Space for the overflow button
   if (show_overflow) {
     // The following code makes sure that platform apps icons (aligned to left /
     // top) are favored over panel apps icons (aligned to right / bottom).
@@ skipping 26 matching lines @@
     view_model_->view_at(i)->SetVisible(visible);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
       x = 0;
       y = 0;
     } else {
-      x = shelf_->PrimaryAxisValue(
+      x = wm_shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).right(),
           view_model_->ideal_bounds(last_visible_index_).x());
-      y = shelf_->PrimaryAxisValue(
+      y = wm_shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).y(),
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
     // Set all hidden panel icon positions to be on the overflow button.
     for (int i = first_panel_index; i <= last_hidden_index_; ++i)
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
 
     // Add more space between last visible item and overflow button.
     // Without this, two buttons look too close compared with other items.
-    x = shelf_->PrimaryAxisValue(x + button_spacing, x);
-    y = shelf_->PrimaryAxisValue(y, y + button_spacing);
+    x = wm_shelf_->PrimaryAxisValue(x + button_spacing, x);
+    y = wm_shelf_->PrimaryAxisValue(y, y + button_spacing);
 
     bounds->overflow_bounds.set_x(x);
     bounds->overflow_bounds.set_y(y);
     if (overflow_bubble_.get() && overflow_bubble_->IsShowing())
       UpdateOverflowRange(overflow_bubble_->shelf_view());
   } else {
     if (overflow_bubble_)
       overflow_bubble_->Hide();
   }
 }
 
 int ShelfView::DetermineLastVisibleIndex(int max_value) const {
   int index = model_->FirstPanelIndex() - 1;
   while (index >= 0 &&
-         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).right(),
-                                  view_model_->ideal_bounds(index).bottom()) >
-             max_value) {
+         wm_shelf_->PrimaryAxisValue(
+             view_model_->ideal_bounds(index).right(),
+             view_model_->ideal_bounds(index).bottom()) > max_value) {
     index--;
   }
   return index;
 }
 
 int ShelfView::DetermineFirstVisiblePanelIndex(int min_value) const {
   int index = model_->FirstPanelIndex();
   while (index < view_model_->view_size() &&
-         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).right(),
-                                  view_model_->ideal_bounds(index).bottom()) <
-             min_value) {
+         wm_shelf_->PrimaryAxisValue(
+             view_model_->ideal_bounds(index).right(),
+             view_model_->ideal_bounds(index).bottom()) < min_value) {
     ++index;
   }
   return index;
 }
 
 void ShelfView::AddIconObserver(ShelfIconObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfView::RemoveIconObserver(ShelfIconObserver* observer) {
@@ skipping 110 matching lines @@
   // Constrain the location to the range of valid indices for the type.
   std::pair<int, int> indices(GetDragRange(current_index));
   int first_drag_index = indices.first;
   int last_drag_index = indices.second;
   // If the last index isn't valid, we're overflowing. Constrain to the app list
   // (which is the last visible item).
   if (first_drag_index < model_->FirstPanelIndex() &&
       last_drag_index > last_visible_index_)
     last_drag_index = last_visible_index_;
   int x = 0, y = 0;
-  if (shelf_->IsHorizontalAlignment()) {
+  if (wm_shelf_->IsHorizontalAlignment()) {
     x = std::max(view_model_->ideal_bounds(indices.first).x(),
                  drag_point.x() - drag_origin_.x());
     x = std::min(view_model_->ideal_bounds(last_drag_index).right() -
                      view_model_->ideal_bounds(current_index).width(),
                  x);
     if (drag_view_->x() == x)
       return;
     drag_view_->SetX(x);
   } else {
     y = std::max(view_model_->ideal_bounds(indices.first).y(),
                  drag_point.y() - drag_origin_.y());
     y = std::min(view_model_->ideal_bounds(last_drag_index).bottom() -
                      view_model_->ideal_bounds(current_index).height(),
                  y);
     if (drag_view_->y() == y)
       return;
     drag_view_->SetY(y);
   }
 
   int target_index = views::ViewModelUtils::DetermineMoveIndex(
       *view_model_, drag_view_,
-      shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
-                                      : views::ViewModelUtils::VERTICAL,
+      wm_shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
+                                         : views::ViewModelUtils::VERTICAL,
       x, y);
   target_index =
       std::min(indices.second, std::max(target_index, indices.first));
 
   int first_draggable_item = 0;
   while (first_draggable_item < static_cast<int>(model_->items().size()) &&
          !model_->GetShelfItemDelegate(model_->items()[first_draggable_item].id)
               ->IsDraggable()) {
     first_draggable_item++;
   }
 
   target_index = std::max(target_index, first_draggable_item);
 
   if (target_index == current_index)
     return;
 
   // Change the model, the ShelfItemMoved() callback will handle the
   // |view_model_| update.
   model_->Move(current_index, target_index);
   bounds_animator_->StopAnimatingView(drag_view_);
 }
 
 bool ShelfView::HandleRipOffDrag(const ui::LocatedEvent& event) {
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
   std::string dragged_app_id =
       delegate_->GetAppIDForShelfID(model_->items()[current_index].id);
 
-  gfx::Point screen_location = event.root_location();
-  ::wm::ConvertPointToScreen(GetWidget()->GetNativeWindow()->GetRootWindow(),
-                             &screen_location);
+  gfx::Point screen_location =
+      WmLookup::Get()
+          ->GetWindowForWidget(GetWidget())
+          ->GetRootWindow()
+          ->ConvertPointToScreen(event.root_location());
 
   // To avoid ugly forwards and backwards flipping we use different constants
   // for ripping off / re-inserting the items.
   if (dragged_off_shelf_) {
     // If the shelf/overflow bubble bounds contains |screen_location| we insert
     // the item back into the shelf.
     if (GetBoundsForDragInsertInScreen().Contains(screen_location)) {
       if (dragged_off_from_overflow_to_shelf_) {
         // During the dragging an item from Shelf to Overflow, it can enter here
         // directly because both are located very closly.
@@ skipping 196 matching lines @@
 void ShelfView::ToggleOverflowBubble() {
   if (IsShowingOverflowBubble()) {
     overflow_bubble_->Hide();
     return;
   }
 
   if (!overflow_bubble_)
     overflow_bubble_.reset(new OverflowBubble(wm_shelf_));
 
   ShelfView* overflow_view =
-      new ShelfView(model_, delegate_, wm_shelf_, shelf_);
+      new ShelfView(model_, delegate_, wm_shelf_, shelf_widget_);
   overflow_view->overflow_mode_ = true;
   overflow_view->Init();
   overflow_view->set_owner_overflow_bubble(overflow_bubble_.get());
   overflow_view->OnShelfAlignmentChanged();
   overflow_view->main_shelf_ = this;
   UpdateOverflowRange(overflow_view);
 
   overflow_bubble_->Show(overflow_button_, overflow_view);
 
   wm_shelf_->UpdateVisibilityState();
@@ skipping 38 matching lines @@
     const int last_button_index = view_model_->view_size() - 1;
     gfx::Rect last_button_bounds =
         view_model_->view_at(last_button_index)->bounds();
     if (overflow_button_->visible() &&
         model_->GetItemIndexForType(TYPE_APP_PANEL) == -1) {
       // When overflow button is visible and shelf has no panel items,
       // last_button_bounds should be overflow button's bounds.
       last_button_bounds = overflow_button_->bounds();
     }
 
-    if (shelf_->IsHorizontalAlignment()) {
+    if (wm_shelf_->IsHorizontalAlignment()) {
       preferred_size = gfx::Size(last_button_bounds.right() + leading_inset_,
                                  GetShelfConstant(SHELF_SIZE));
     } else {
       preferred_size = gfx::Size(GetShelfConstant(SHELF_SIZE),
                                  last_button_bounds.bottom() + leading_inset_);
     }
   }
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
 
   // In overflow mode, we should use OverflowBubbleView as a source for
@@ skipping 53 matching lines @@
   if (is_overflow_mode() && dragged_off_shelf_ &&
       !dragged_off_from_overflow_to_shelf_ &&
       RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
     last_button_index--;
 
   const gfx::Rect last_button_bounds =
       last_button_index >= first_visible_index_
           ? view_model_->ideal_bounds(last_button_index)
           : gfx::Rect(gfx::Size(shelf_size, shelf_size));
 
-  if (shelf_->IsHorizontalAlignment())
+  if (wm_shelf_->IsHorizontalAlignment())
     return gfx::Size(last_button_bounds.right() + leading_inset_, shelf_size);
 
   return gfx::Size(shelf_size, last_button_bounds.bottom() + leading_inset_);
 }
 
 void ShelfView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   // This bounds change is produced by the shelf movement and all content has
   // to follow. Using an animation at that time would produce a time lag since
   // the animation of the BoundsAnimator has itself a delay before it arrives
   // at the required location. As such we tell the animator to go there
@@ skipping 310 matching lines @@
     // It is possible to invoke the menu while it is sliding into view. To cover
     // that case, the screen coordinates are offsetted by the animation delta.
     anchor = source->GetBoundsInScreen() + (window->GetTargetBounds().origin() -
                                             window->GetBounds().origin());
 
     // Adjust the anchor location for shelf items with asymmetrical borders.
     if (source->border())
       anchor.Inset(source->border()->GetInsets());
 
     // Determine the menu alignment dependent on the shelf.
-    menu_alignment = shelf_->SelectValueForShelfAlignment(
-        views::MENU_ANCHOR_BUBBLE_ABOVE, views::MENU_ANCHOR_BUBBLE_RIGHT,
-        views::MENU_ANCHOR_BUBBLE_LEFT);
+    switch (wm_shelf_->GetAlignment()) {
+      case SHELF_ALIGNMENT_BOTTOM:
+      case SHELF_ALIGNMENT_BOTTOM_LOCKED:
+        menu_alignment = views::MENU_ANCHOR_BUBBLE_ABOVE;
+        break;
+      case SHELF_ALIGNMENT_LEFT:
+        menu_alignment = views::MENU_ANCHOR_BUBBLE_RIGHT;
+        break;
+      case SHELF_ALIGNMENT_RIGHT:
+        menu_alignment = views::MENU_ANCHOR_BUBBLE_LEFT;
+        break;
+    }
   }
 
-  shelf_->shelf_widget()->ForceUndimming(true);
+  shelf_widget_->ForceUndimming(true);
   // NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
   launcher_menu_runner_->RunMenuAt(source->GetWidget(), nullptr, anchor,
                                    menu_alignment, source_type);
 }
 
 void ShelfView::OnMenuClosed(views::InkDrop* ink_drop) {
   context_menu_id_ = 0;
-  shelf_->shelf_widget()->ForceUndimming(false);
+  shelf_widget_->ForceUndimming(false);
 
   // Hide the hide overflow bubble after showing a context menu for its items.
   if (owner_overflow_bubble_)
     owner_overflow_bubble_->HideBubbleAndRefreshButton();
 
   closing_event_time_ = launcher_menu_runner_->closing_event_time();
 
   if (ink_drop)
     ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
 
@@ skipping 42 matching lines @@
   return closing_event_time_ == event.time_stamp();
 }
 
 const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
   const int view_index = view_model_->GetIndexOfView(view);
   return (view_index < 0) ? nullptr : &(model_->items()[view_index]);
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
-  int distance = shelf_->SelectValueForShelfAlignment(
+  int distance = wm_shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash