mash: Fold ShelfItemDelegateManager into ShelfModel

ash/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 <algorithm>
 #include <memory>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_constants.h"
 #include "ash/common/ash_switches.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_constants.h"
-#include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/wm/root_window_finder.h"
 #include "ash/common/wm_shell.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/scoped_target_root_window.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_delegate.h"
@@ skipping 349 matching lines @@
       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),
-      item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       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(wm_shelf_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
@@ skipping 132 matching lines @@
 }
 
 bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
   if (view == GetAppListButton() &&
       WmShell::Get()->GetAppListTargetVisibility()) {
     return false;
   }
   const ShelfItem* item = ShelfItemForView(view);
   if (!item)
     return false;
-  return item_manager_->GetShelfItemDelegate(item->id)->ShouldShowTooltip();
+  return model_->GetShelfItemDelegate(item->id)->ShouldShowTooltip();
 }
 
 base::string16 ShelfView::GetTitleForView(const views::View* view) const {
   const ShelfItem* item = ShelfItemForView(view);
-  if (!item || !item_manager_->GetShelfItemDelegate(item->id))
+  if (!item || !model_->GetShelfItemDelegate(item->id))
     return base::string16();
-  return item_manager_->GetShelfItemDelegate(item->id)->GetTitle();
+  return model_->GetShelfItemDelegate(item->id)->GetTitle();
 }
 
 gfx::Rect ShelfView::GetVisibleItemsBoundsInScreen() {
   gfx::Size preferred_size = GetPreferredSize();
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
   ConvertPointToScreen(this, &origin);
   return gfx::Rect(origin, preferred_size);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 176 matching lines @@
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   if (drag_view_)
     return;
 
   int index = view_model_->GetIndexOfView(view);
   if (index == -1 || view_model_->view_size() <= 1)
     return;  // View is being deleted, ignore request.
 
   ShelfItemDelegate* item_delegate =
-      item_manager_->GetShelfItemDelegate(model_->items()[index].id);
+      model_->GetShelfItemDelegate(model_->items()[index].id);
   if (!item_delegate->IsDraggable())
     return;  // View is not draggable, ignore request.
 
   // 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);
@@ skipping 286 matching lines @@
   DCHECK(drag_view_);
   drag_pointer_ = pointer;
   start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
 
   if (start_drag_index_ == -1) {
     CancelDrag(-1);
     return;
   }
 
   // If the item is no longer draggable, bail out.
-  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
-      model_->items()[start_drag_index_].id);
+  ShelfItemDelegate* item_delegate =
+      model_->GetShelfItemDelegate(model_->items()[start_drag_index_].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // Move the view to the front so that it appears on top of other views.
   ReorderChildView(drag_view_, -1);
   bounds_animator_->StopAnimatingView(drag_view_);
 
   drag_view_->OnDragStarted(&event);
 }
 
 void ShelfView::ContinueDrag(const ui::LocatedEvent& event) {
   // Due to a syncing operation the application might have been removed.
   // Bail if it is gone.
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
 
   ShelfItemDelegate* item_delegate =
-      item_manager_->GetShelfItemDelegate(model_->items()[current_index].id);
+      model_->GetShelfItemDelegate(model_->items()[current_index].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // If this is not a drag and drop host operation and not the app list item,
   // check if the item got ripped off the shelf - if it did we are done.
   if (!drag_and_drop_shelf_id_ &&
       RemovableByRipOff(current_index) != NOT_REMOVABLE) {
     if (HandleRipOffDrag(event))
@@ skipping 39 matching lines @@
   int target_index = views::ViewModelUtils::DetermineMoveIndex(
       *view_model_, drag_view_,
       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()) &&
-         !item_manager_
-              ->GetShelfItemDelegate(model_->items()[first_draggable_item].id)
+         !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
@@ skipping 162 matching lines @@
 }
 
 ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) const {
   DCHECK(index >= 0 && index < model_->item_count());
   ShelfItemType type = model_->items()[index].type;
   if (type == TYPE_APP_LIST || type == TYPE_DIALOG)
     return NOT_REMOVABLE;
 
   std::string app_id = delegate_->GetAppIDForShelfID(model_->items()[index].id);
   ShelfItemDelegate* item_delegate =
-      item_manager_->GetShelfItemDelegate(model_->items()[index].id);
+      model_->GetShelfItemDelegate(model_->items()[index].id);
   if (!item_delegate->CanPin())
     return NOT_REMOVABLE;
   // Note: Only pinned app shortcuts can be removed!
   return (type == TYPE_APP_SHORTCUT && delegate_->IsAppPinned(app_id))
              ? REMOVABLE
              : DRAGGABLE;
 }
 
 bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
   switch (typea) {
@@ skipping 346 matching lines @@
 void ShelfView::ShelfItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
   // When cancelling a drag due to a shelf item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
+void ShelfView::OnSetShelfItemDelegate(ShelfID id,
+                                       ShelfItemDelegate* item_delegate) {}
+
 void ShelfView::ButtonPressed(views::Button* sender,
                               const ui::Event& event,
                               views::InkDrop* ink_drop) {
   if (sender == overflow_button_) {
     ToggleOverflowBubble();
     shelf_button_pressed_metric_tracker_.ButtonPressed(
         event, sender, ShelfItemDelegate::kNoAction);
     return;
   }
 
@@ skipping 33 matching lines @@
     case TYPE_DIALOG:
     case TYPE_IME_MENU:
       break;
 
     case TYPE_UNDEFINED:
       NOTREACHED() << "ShelfItemType must be set.";
       break;
   }
 
   ShelfItemDelegate::PerformedAction performed_action =
-      item_manager_
-          ->GetShelfItemDelegate(model_->items()[last_pressed_index_].id)
+      model_->GetShelfItemDelegate(model_->items()[last_pressed_index_].id)
           ->ItemSelected(event);
 
   shelf_button_pressed_metric_tracker_.ButtonPressed(event, sender,
                                                      performed_action);
 
   // For the app list menu no TRIGGERED ink drop effect is needed and it
   // handles its own ACTIVATED/DEACTIVATED states.
   if (performed_action == ShelfItemDelegate::kNewWindowCreated ||
       (performed_action != ShelfItemDelegate::kAppListMenuShown &&
        !ShowListMenuForView(model_->items()[last_pressed_index_], sender, event,
                             ink_drop))) {
     ink_drop->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
   }
   // Allow the menu to clear |scoped_target_root_window_| during OnMenuClosed.
   if (!IsShowingMenu())
     scoped_target_root_window_.reset();
 }
 
 bool ShelfView::ShowListMenuForView(const ShelfItem& item,
                                     views::View* source,
                                     const ui::Event& event,
                                     views::InkDrop* ink_drop) {
-  ShelfItemDelegate* item_delegate =
-      item_manager_->GetShelfItemDelegate(item.id);
+  ShelfItemDelegate* item_delegate = model_->GetShelfItemDelegate(item.id);
   std::unique_ptr<ui::MenuModel> list_menu_model(
       item_delegate->CreateApplicationMenu(event.flags()));
 
   // Make sure we have a menu and it has at least two items in addition to the
   // application title and the 3 spacing separators.
   if (!list_menu_model.get() || list_menu_model->GetItemCount() <= 5)
     return false;
 
   ink_drop->AnimateToState(views::InkDropState::ACTIVATED);
   context_menu_id_ = item.id;
@@ skipping 135 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash