ash: Remove ShelfModel id conversion functions.

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"
@@ skipping 511 matching lines @@
 
 void ShelfView::DestroyDragIconProxy() {
   drag_image_.reset();
   drag_image_offset_ = gfx::Vector2d(0, 0);
 }
 
 bool ShelfView::StartDrag(const std::string& app_id,
                           const gfx::Point& location_in_screen_coordinates) {
   // Bail if an operation is already going on - or the cursor is not inside.
   // This could happen if mouse / touch operations overlap.
-  if (!drag_and_drop_shelf_id_.IsNull() ||
+  if (!drag_and_drop_shelf_id_.IsNull() || app_id.empty() ||
       !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_ = model_->GetShelfIDForAppID(drag_and_drop_app_id_);
-  // Check if the application is known and pinned - if not, we have to pin it so
+  drag_and_drop_shelf_id_ = ShelfID(app_id);
+  // Check if the application is 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_.IsNull() || !model_->IsAppPinned(app_id))) {
+  if (!IsShowingOverflowBubble() && !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_.IsNull())
-      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
   // change once a regrouping animation is performed.
   pre_drag_and_drop_size_ = drag_and_drop_view->size();
@@ skipping 35 matching lines @@
 void ShelfView::EndDrag(bool cancel) {
   if (drag_and_drop_shelf_id_.IsNull())
     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) {
-    model_->UnpinAppWithID(drag_and_drop_app_id_);
+    model_->UnpinAppWithID(drag_and_drop_shelf_id_.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 419 matching lines @@
     main_shelf_->EndDrag(cancel);
   } else {
     DCHECK(overflow_bubble_->IsShowing());
     overflow_bubble_->shelf_view()->EndDrag(cancel);
   }
 }
 
 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 =
-      model_->GetAppIDForShelfID(model_->items()[current_index].id);
+  std::string dragged_app_id = model_->items()[current_index].id.app_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 133 matching lines @@
       EndDragOnOtherShelf(false /* cancel */);
       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 =
-          model_->GetAppIDForShelfID(model_->items()[current_index].id);
-      model_->UnpinAppWithID(app_id);
+      model_->UnpinAppWithID(model_->items()[current_index].id.app_id);
     }
   }
   if (cancel || snap_back) {
     if (dragged_to_another_shelf_) {
       dragged_to_another_shelf_ = false;
       // Other shelf handles revert of dragged item.
       EndDragOnOtherShelf(false /* 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 = model_->GetAppIDForShelfID(model_->items()[index].id);
+  const std::string& app_id = model_->items()[index].id.app_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:
@@ skipping 542 matching lines @@
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash