mash: Replace int ShelfIDs with AppLaunchID strings.

ash/shelf/shelf_view_unittest.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 <utility>
 #include <vector>
@@ skipping 122 matching lines @@
  private:
   std::unique_ptr<TestWmShelfObserver> observer_;
   std::unique_ptr<ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(WmShelfObserverIconTest);
 };
 
 // A ShelfItemDelegate that tracks selections and reports a custom action.
 class ShelfItemSelectionTracker : public ShelfItemDelegate {
  public:
-  ShelfItemSelectionTracker() : ShelfItemDelegate(AppLaunchId()) {}
+  ShelfItemSelectionTracker() : ShelfItemDelegate(ShelfID()) {}
   ~ShelfItemSelectionTracker() override {}
 
   size_t item_selected_count() const { return item_selected_count_; }
   void set_item_selected_action(ShelfAction item_selected_action) {
     item_selected_action_ = item_selected_action;
   }
 
   // ShelfItemDelegate:
   void ItemSelected(std::unique_ptr<ui::Event> event,
                     int64_t display_id,
                     ShelfLaunchSource source,
                     const ItemSelectedCallback& callback) override {
     item_selected_count_++;
     callback.Run(item_selected_action_, base::nullopt);
   }
   void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
   size_t item_selected_count_ = 0;
   ShelfAction item_selected_action_ = SHELF_ACTION_NONE;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
 };
 
 TEST_F(WmShelfObserverIconTest, AddRemove) {
   ShelfItem item;
+  item.id = ShelfID("foo");
   item.type = TYPE_APP;
   EXPECT_FALSE(observer()->icon_positions_changed());
   const int shelf_item_index = Shell::Get()->shelf_model()->Add(item);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   observer()->Reset();
 
   EXPECT_FALSE(observer()->icon_positions_changed());
   Shell::Get()->shelf_model()->RemoveItemAt(shelf_item_index);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   observer()->Reset();
 }
 
 // Make sure creating/deleting an window on one displays notifies a
 // shelf on external display as well as one on primary.
 TEST_F(WmShelfObserverIconTest, AddRemoveWithMultipleDisplays) {
   // TODO: investigate failure in mash, http://crbug.com/695751.
   if (Shell::GetAshConfig() == Config::MASH)
     return;
 
   UpdateDisplay("400x400,400x400");
   observer()->Reset();
 
   WmWindow* second_root = ShellPort::Get()->GetAllRootWindows()[1];
   WmShelf* second_shelf = second_root->GetRootWindowController()->GetShelf();
   TestWmShelfObserver second_observer(second_shelf);
 
   ShelfItem item;
+  item.id = ShelfID("foo");
   item.type = TYPE_APP;
   EXPECT_FALSE(observer()->icon_positions_changed());
   EXPECT_FALSE(second_observer.icon_positions_changed());
   const int shelf_item_index = Shell::Get()->shelf_model()->Add(item);
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->icon_positions_changed());
   EXPECT_TRUE(second_observer.icon_positions_changed());
   observer()->Reset();
   second_observer.Reset();
 
@@ skipping 55 matching lines @@
   }
 
  protected:
   // Add shelf items of various types, and optionally wait for animations.
   ShelfID AddItem(ShelfItemType type, bool wait_for_animations) {
     ShelfItem item;
     item.type = type;
     if (type == TYPE_APP || type == TYPE_APP_PANEL)
       item.status = STATUS_RUNNING;
 
-    ShelfID id = model_->next_id();
-    item.app_launch_id = AppLaunchId(base::IntToString(id));
+    static int id = 0;
+    item.id = ShelfID(base::IntToString(id++));
     model_->Add(item);
     // Set a delegate; some tests require one to select the item.
-    model_->SetShelfItemDelegate(id,
+    model_->SetShelfItemDelegate(item.id,
                                  base::MakeUnique<ShelfItemSelectionTracker>());
     if (wait_for_animations)
       test_api_->RunMessageLoopUntilAnimationsDone();
-    return id;
+    return item.id;
   }
   ShelfID AddAppShortcut() { return AddItem(TYPE_PINNED_APP, true); }
   ShelfID AddPanel() { return AddItem(TYPE_APP_PANEL, true); }
   ShelfID AddAppNoWait() { return AddItem(TYPE_APP, false); }
   ShelfID AddApp() { return AddItem(TYPE_APP, true); }
 
-  void SetShelfItemTypeToAppShortcut(ShelfID id) {
+  void SetShelfItemTypeToAppShortcut(const ShelfID& id) {
     int index = model_->ItemIndexByID(id);
     DCHECK_GE(index, 0);
 
     ShelfItem item = model_->items()[index];
 
     if (item.type == TYPE_APP) {
       item.type = TYPE_PINNED_APP;
       model_->Set(index, item);
     }
     test_api_->RunMessageLoopUntilAnimationsDone();
   }
 
-  void RemoveByID(ShelfID id) {
+  void RemoveByID(const ShelfID& id) {
     model_->RemoveItemAt(model_->ItemIndexByID(id));
     test_api_->RunMessageLoopUntilAnimationsDone();
   }
 
-  ShelfButton* GetButtonByID(ShelfID id) {
+  ShelfButton* GetButtonByID(const ShelfID& id) {
     int index = model_->ItemIndexByID(id);
     return test_api_->GetButton(index);
   }
 
-  ShelfItem GetItemByID(ShelfID id) {
+  ShelfItem GetItemByID(const ShelfID& id) {
     ShelfItems::const_iterator items = model_->ItemByID(id);
     return *items;
   }
 
   void CheckModelIDs(
       const std::vector<std::pair<ShelfID, views::View*>>& id_map) {
     size_t map_index = 0;
     for (size_t model_index = 0; model_index < model_->items().size();
          ++model_index) {
       ShelfItem item = model_->items()[model_index];
@@ skipping 253 matching lines @@
   }
 
   // Returns the item's ShelfID at |index|.
   ShelfID GetItemId(int index) {
     DCHECK_GE(index, 0);
     return model_->items()[index].id;
   }
 
   // Returns the center coordinates for a button. Helper function for an event
   // generator.
-  gfx::Point GetButtonCenter(ShelfID button_id) {
+  gfx::Point GetButtonCenter(const ShelfID& button_id) {
     return GetButtonCenter(
         test_api_->GetButton(model_->ItemIndexByID(button_id)));
   }
 
   gfx::Point GetButtonCenter(ShelfButton* button) {
     return button->GetBoundsInScreen().CenterPoint();
   }
 
   ShelfModel* model_ = nullptr;
   ShelfView* shelf_view_ = nullptr;
@@ skipping 1334 matching lines @@
   std::unique_ptr<views::InkDrop> ink_drop_;
   std::vector<views::InkDropState> requested_states_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InkDropSpy);
 };
 
 // A ShelfItemDelegate that returns a menu for the shelf item.
 class ListMenuShelfItemDelegate : public ShelfItemDelegate {
  public:
-  ListMenuShelfItemDelegate() : ShelfItemDelegate(AppLaunchId()) {}
+  ListMenuShelfItemDelegate() : ShelfItemDelegate(ShelfID()) {}
   ~ListMenuShelfItemDelegate() override {}
 
  private:
   // ShelfItemDelegate:
   void ItemSelected(std::unique_ptr<ui::Event> event,
                     int64_t display_id,
                     ShelfLaunchSource source,
                     const ItemSelectedCallback& callback) override {
     // Two items are needed to show a menu; the data in the items is not tested.
     std::vector<mojom::MenuItemPtr> items;
@@ skipping 1104 matching lines @@
   EXPECT_EQ(views::InkDropState::ACTIVATED,
             overflow_button_ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(overflow_button_ink_drop_->GetAndResetRequestedStates(),
               IsEmpty());
 
   ASSERT_TRUE(test_api_->IsShowingOverflowBubble());
 }
 
 }  // namespace test
 }  // namespace ash