Remove ShelfItemDelegate::IsDraggable; check for app list button.

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/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "ash/common/ash_constants.h"
@@ skipping 780 matching lines @@
 void ShelfView::PointerPressedOnButton(views::View* view,
                                        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 =
-      model_->GetShelfItemDelegate(model_->items()[index].id);
-  if (!item_delegate->IsDraggable())
+  if (view == GetAppListButton())
     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);
   drag_origin_ = gfx::Point(event.x(), event.y());
@@ skipping 283 matching lines @@
   DCHECK(!dragging());
   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 =
-      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) {
+  DCHECK(dragging());
+  DCHECK(drag_view_);
   // 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 =
-      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))
       return;
     // The rip off handler could have changed the location of the item.
     current_index = view_model_->GetIndexOfView(drag_view_);
   }
 
@@ skipping 32 matching lines @@
   }
 
   int target_index = views::ViewModelUtils::DetermineMoveIndex(
       *view_model_, drag_view_,
       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++;
-  }
-
+  int first_draggable_item = model_->GetItemIndexForType(TYPE_APP_LIST) + 1;

[James Cook, 2016/12/14 17:41:54]

Maybe comment or DCHECK that if the shelf only has the app list item then it's
impossible to drag, so first_draggable_item / target_index is always a valid
item?

[msw, 2016/12/14 19:46:50]

Added a comment and a couple DCHECKs. The top of this function also DCHECKs
dragging() and drag_view_, which is never set as the app list button itself
(drag_view_ is a ShelfButton and the app list button oddly isn't), and so if
drag_view_ is set, it must be some other valid draggable button (which comes
after the app list button, which is always first), so this index must be 1 and
must be valid. Really, I could just set this to 1, and DCHECK my assumptions,
but I'll leave the variable assignment as-is for now.

   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_);
 }
@@ skipping 695 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