mash: Remove ShelfDelegate; move functions to 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/ash_constants.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/scoped_root_window_for_new_windows.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
 #include "ash/shelf/shelf_application_menu_model.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
-#include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_port.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/wm/root_window_finder.h"
 #include "ash/wm_window.h"
 #include "base/auto_reset.h"
@@ skipping 200 matching lines @@
   ShelfView* shelf_view_;
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
 // static
 const int ShelfView::kMinimumDragDistance = 8;
 
 ShelfView::ShelfView(ShelfModel* model,
-                     ShelfDelegate* delegate,
                      WmShelf* wm_shelf,
                      ShelfWidget* shelf_widget)
     : model_(model),
-      delegate_(delegate),
       wm_shelf_(wm_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),
       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),
       weak_factory_(this) {
   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);
@@ skipping 269 matching lines @@
   // This could happen if mouse / touch operations overlap.
   if (drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   // If the AppsGridView (which was dispatching this event) was opened by our
   // button, ShelfView dragging operations are locked and we have to unlock.
   CancelDrag(-1);
   drag_and_drop_item_pinned_ = false;
   drag_and_drop_app_id_ = app_id;
-  drag_and_drop_shelf_id_ =
-      delegate_->GetShelfIDForAppID(drag_and_drop_app_id_);
+  drag_and_drop_shelf_id_ = model_->GetShelfIDForAppID(drag_and_drop_app_id_);
   // Check if the application is known and pinned - if not, we have to pin it so
   // that we can re-arrange the shelf order accordingly. Note that items have
   // to be pinned to give them the same (order) possibilities as a shortcut.
   // When an item is dragged from overflow to shelf, IsShowingOverflowBubble()
   // returns true. At this time, we don't need to pin the item.
   if (!IsShowingOverflowBubble() &&
-      (!drag_and_drop_shelf_id_ || !delegate_->IsAppPinned(app_id))) {
-    delegate_->PinAppWithID(app_id);
-    drag_and_drop_shelf_id_ =
-        delegate_->GetShelfIDForAppID(drag_and_drop_app_id_);
+      (!drag_and_drop_shelf_id_ || !model_->IsAppPinned(app_id))) {
+    model_->PinAppWithID(app_id);
+    drag_and_drop_shelf_id_ = model_->GetShelfIDForAppID(drag_and_drop_app_id_);
     if (!drag_and_drop_shelf_id_)
       return false;
     drag_and_drop_item_pinned_ = true;
   }
   views::View* drag_and_drop_view =
       view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   DCHECK(drag_and_drop_view);
 
   // Since there is already an icon presented by the caller, we hide this item
   // for now. That has to be done by reducing the size since the visibility will
@@ skipping 37 matching lines @@
 void ShelfView::EndDrag(bool cancel) {
   if (!drag_and_drop_shelf_id_)
     return;
 
   views::View* drag_and_drop_view =
       view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   PointerReleasedOnButton(drag_and_drop_view, DRAG_AND_DROP, cancel);
 
   // Either destroy the temporarily created item - or - make the item visible.
   if (drag_and_drop_item_pinned_ && cancel) {
-    delegate_->UnpinAppWithID(drag_and_drop_app_id_);
+    model_->UnpinAppWithID(drag_and_drop_app_id_);
   } else if (drag_and_drop_view) {
     if (cancel) {
       // When a hosted drag gets canceled, the item can remain in the same slot
       // and it might have moved within the bounds. In that case the item need
       // to animate back to its correct location.
       AnimateToIdealBounds();
     } else {
       drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
     }
   }
@@ skipping 413 matching lines @@
   // 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);
+      model_->GetAppIDForShelfID(model_->items()[current_index].id);
 
   gfx::Point screen_location =
       WmWindow::Get(GetWidget()->GetNativeWindow())
           ->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
@@ skipping 102 matching lines @@
       drag_view_->layer()->SetOpacity(1.0f);
     } else if (RemovableByRipOff(current_index) != REMOVABLE) {
       // Make sure we do not try to remove un-removable items like items which
       // were not pinned or have to be always there.
       cancel = true;
       snap_back = true;
     } else {
       // Make sure the item stays invisible upon removal.
       drag_view_->SetVisible(false);
       std::string app_id =
-          delegate_->GetAppIDForShelfID(model_->items()[current_index].id);
-      delegate_->UnpinAppWithID(app_id);
+          model_->GetAppIDForShelfID(model_->items()[current_index].id);
+      model_->UnpinAppWithID(app_id);
     }
   }
   if (cancel || snap_back) {
     if (dragged_off_from_overflow_to_shelf_) {
       dragged_off_from_overflow_to_shelf_ = false;
       // Main shelf handles revert of dragged item.
       main_shelf_->EndDrag(true);
       drag_view_->layer()->SetOpacity(1.0f);
     } else if (!cancelling_drag_model_changed_) {
       // Only do something if the change did not come through a model change.
@@ skipping 21 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;
 
   if (model_->items()[index].pinned_by_policy)
     return NOT_REMOVABLE;
 
   // Note: Only pinned app shortcuts can be removed!
-  std::string app_id = delegate_->GetAppIDForShelfID(model_->items()[index].id);
-  return (type == TYPE_PINNED_APP && delegate_->IsAppPinned(app_id))
-             ? REMOVABLE
-             : DRAGGABLE;
+  std::string app_id = model_->GetAppIDForShelfID(model_->items()[index].id);
+  return (type == TYPE_PINNED_APP && model_->IsAppPinned(app_id)) ? REMOVABLE
+                                                                  : DRAGGABLE;
 }
 
 bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
   switch (typea) {
     case TYPE_PINNED_APP:
     case TYPE_BROWSER_SHORTCUT:
       return (typeb == TYPE_PINNED_APP || typeb == TYPE_BROWSER_SHORTCUT);
     case TYPE_APP_PANEL:
     case TYPE_APP_LIST:
     case TYPE_APP:
@@ skipping 28 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_widget_);
+  ShelfView* overflow_view = new ShelfView(model_, 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 235 matching lines @@
     // item is ripped out from the shelf, its |view| is already invisible.
     AnimateToIdealBounds();
   }
 
   if (view == tooltip_.GetCurrentAnchorView())
     tooltip_.Close();
 }
 
 void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
   const ShelfItem& item(model_->items()[model_index]);
+
+  // Bail if the view and shelf sizes do not match. ShelfItemChanged may be
+  // called here before ShelfItemAdded, due to ChromeLauncherController's
+  // item initialization, which calls SetItem during ShelfItemAdded.
+  if (static_cast<int>(model_->items().size()) != view_model_->view_size())

[James Cook, 2017/04/19 00:23:47]

Are you sure this is safe? Is it only for tests or in production also? It seems
like we could miss an update. Is ChromeLauncherController sending an update
twice?

[msw, 2017/04/19 20:56:06]

This is used for production and I'm reasonably confident that it's safe. This
ShelfItemChanged override just updates existing item views (and cancels any
ongoing dragging). No view exists for this item yet, so no updating is needed.
ShelfView's ShelfItemAdded override will be called imminently to add the new
view, and that pulls the latest ShelfModel/ShelfItem info (and cancels any
ongoing dragging). CLC isn't sending any updates twice, it's just updating an
item while observers are being notified of the item's addition.

+    return;
+
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     model_index = CancelDrag(model_index);
     std::unique_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     // Removing and re-inserting a view in our view model will strip the ideal
     // bounds from the item. To avoid recalculation of everything the bounds
     // get remembered and restored after the insertion to the previous value.
     gfx::Rect old_ideal_bounds = view_model_->ideal_bounds(model_index);
     view_model_->Remove(model_index);
@@ skipping 210 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = wm_shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash