mash: Replace int ShelfIDs with AppLaunchID strings.

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 279 matching lines @@
   }
   tooltip_.Close();
   if (overflow_bubble_)
     overflow_bubble_->Hide();
   // For crbug.com/587931, because AppListButton layout logic is in OnPaint.
   AppListButton* app_list_button = GetAppListButton();
   if (app_list_button)
     app_list_button->SchedulePaint();
 }
 
-gfx::Rect ShelfView::GetIdealBoundsOfItemIcon(ShelfID id) {
+gfx::Rect ShelfView::GetIdealBoundsOfItemIcon(const ShelfID& id) {
   int index = model_->ItemIndexByID(id);
   if (index < 0 || last_visible_index_ < 0)
     return gfx::Rect();
   // Map all items from overflow area to the overflow button. Note that the
   // section between last_index_hidden_ and model_->FirstPanelIndex() is the
   // list of invisible panel items. However, these items are currently nowhere
   // represented and get dropped instead - see (crbug.com/378907). As such there
   // is no way to address them or place them. We therefore move them over the
   // overflow button.
   if (index > last_visible_index_ && index < model_->FirstPanelIndex())
     index = last_visible_index_ + 1;
   const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
   DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
   views::View* view = view_model_->view_at(index);
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   ShelfButton* button = static_cast<ShelfButton*>(view);
   gfx::Rect icon_bounds = button->GetIconBounds();
   return gfx::Rect(GetMirroredXWithWidthInView(
                        ideal_bounds.x() + icon_bounds.x(), icon_bounds.width()),
                    ideal_bounds.y() + icon_bounds.y(), icon_bounds.width(),
                    icon_bounds.height());
 }
 
-void ShelfView::UpdatePanelIconPosition(ShelfID id,
+void ShelfView::UpdatePanelIconPosition(const 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 &&
@@ skipping 187 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_ ||
+  if (!drag_and_drop_shelf_id_.IsNull() ||
       !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
   // 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_ || !model_->IsAppPinned(app_id))) {
+      (drag_and_drop_shelf_id_.IsNull() || !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_)
+    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();
   drag_and_drop_view->SetSize(gfx::Size());
 
   // First we have to center the mouse cursor over the item.
   gfx::Point pt = drag_and_drop_view->GetBoundsInScreen().CenterPoint();
   views::View::ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root =
       wm::GetRootWindowAt(location_in_screen_coordinates)
           ->ConvertPointFromScreen(location_in_screen_coordinates);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, pt, point_in_root,
                        ui::EventTimeForNow(), 0, 0);
   PointerPressedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
 
   // Drag the item where it really belongs.
   Drag(location_in_screen_coordinates);
   return true;
 }
 
 bool ShelfView::Drag(const gfx::Point& location_in_screen_coordinates) {
-  if (!drag_and_drop_shelf_id_ ||
+  if (drag_and_drop_shelf_id_.IsNull() ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   gfx::Point pt = location_in_screen_coordinates;
   views::View* drag_and_drop_view =
       view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root =
       wm::GetRootWindowAt(location_in_screen_coordinates)
           ->ConvertPointFromScreen(location_in_screen_coordinates);
   ui::MouseEvent event(ui::ET_MOUSE_DRAGGED, pt, point_in_root,
                        ui::EventTimeForNow(), 0, 0);
   PointerDraggedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
   return true;
 }
 
 void ShelfView::EndDrag(bool cancel) {
-  if (!drag_and_drop_shelf_id_)
+  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_);
   } 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_);
     }
   }
 
-  drag_and_drop_shelf_id_ = 0;
+  drag_and_drop_shelf_id_ = ShelfID();
 }
 
 bool ShelfView::ShouldEventActivateButton(View* view, const ui::Event& event) {
   if (dragging())
     return false;
 
   // Ignore if we are already in a pointer event sequence started with a repost
   // event on the same shelf item. See crbug.com/343005 for more detail.
   if (is_repost_event_on_same_item_)
     return false;
@@ skipping 331 matching lines @@
 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);
 
   // 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_ &&
+  if (drag_and_drop_shelf_id_.IsNull() &&
       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_);
   }
 
   // TODO: I don't think this works correctly with RTL.
   gfx::Point drag_point(event.location());
   ConvertPointToTarget(drag_view_, this, &drag_point);
@@ skipping 623 matching lines @@
   if (!item) {
     ShellPort::Get()->ShowContextMenu(point, source_type);
     return;
   }
 
   std::unique_ptr<ui::MenuModel> context_menu_model(
       Shell::Get()->shell_delegate()->CreateContextMenu(wm_shelf_, item));
   if (!context_menu_model)
     return;
 
-  context_menu_id_ = item ? item->id : 0;
+  context_menu_id_ = item ? item->id : ShelfID();
   ShowMenu(std::move(context_menu_model), source, point, true, source_type,
            nullptr);
 }
 
 void ShelfView::ShowMenu(std::unique_ptr<ui::MenuModel> menu_model,
                          views::View* source,
                          const gfx::Point& click_point,
                          bool context_menu,
                          ui::MenuSourceType source_type,
                          views::InkDrop* ink_drop) {
@@ skipping 42 matching lines @@
         break;
     }
   }
 
   // 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;
+  context_menu_id_ = ShelfID();
 
   // Hide the hide overflow bubble after showing a context menu for its items.
   if (owner_overflow_bubble_)
     owner_overflow_bubble_->Hide();
 
   closing_event_time_ = launcher_menu_runner_->closing_event_time();
 
   if (ink_drop)
     ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
 
@@ skipping 71 matching lines @@
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash