mash: Replace int ShelfIDs with AppLaunchID strings.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_browsertest.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <stddef.h>
 
-#include "ash/public/cpp/app_launch_id.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/test/shelf_view_test_api.h"
-#include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm_window.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
@@ skipping 191 matching lines @@
     // Ensure ash starts the session and creates the shelf and controller.
     SessionControllerClient::FlushForTesting();
 
     controller_ = ChromeLauncherController::instance();
     ASSERT_TRUE(controller_);
     extensions::PlatformAppBrowserTest::SetUpOnMainThread();
   }
 
   ash::ShelfModel* shelf_model() { return ash::Shell::Get()->shelf_model(); }
 
-  ash::ShelfID CreateAppShortcutLauncherItem(
-      const ash::AppLaunchId& app_launch_id) {
+  ash::ShelfID CreateAppShortcutLauncherItem(const ash::ShelfID& shelf_id) {
     return controller_->CreateAppShortcutLauncherItem(
-        app_launch_id, shelf_model()->item_count());
+        shelf_id, shelf_model()->item_count());
   }
 
   const ash::ShelfItem& GetLastLauncherItem() {
     // Unless there are any panels, the item at index [count - 1] will be
     // the desired item.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
   const ash::ShelfItem& GetLastLauncherPanelItem() {
     // Panels show up on the right side of the shelf, so the desired item
     // will be the last one.
     return shelf_model()->items()[shelf_model()->item_count() - 1];
   }
 
-  ash::ShelfItemDelegate* GetShelfItemDelegate(ash::ShelfID id) {
+  ash::ShelfItemDelegate* GetShelfItemDelegate(const ash::ShelfID& id) {
     return shelf_model()->GetShelfItemDelegate(id);
   }
 
   ChromeLauncherController* controller_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
 };
 
 enum RipOffCommand {
@@ skipping 55 matching lines @@
     LoadExtension(test_data_dir_.AppendASCII(name));
 
     // First get app_id.
     const Extension* extension =
         service->GetExtensionById(last_loaded_extension_id(), false);
     const std::string app_id = extension->id();
 
     // Then create a shortcut.
     int item_count = model_->item_count();
     ash::ShelfID shortcut_id = controller_->CreateAppShortcutLauncherItem(
-        ash::AppLaunchId(app_id), item_count);
+        ash::ShelfID(app_id), item_count);
     controller_->SyncPinPosition(shortcut_id);
     EXPECT_EQ(++item_count, model_->item_count());
     const ash::ShelfItem& item = *model_->ItemByID(shortcut_id);
     EXPECT_EQ(ash::TYPE_PINNED_APP, item.type);
     return item.id;
   }
 
   ash::ShelfID PinFakeApp(const std::string& app_id) {
-    return controller_->CreateAppShortcutLauncherItem(ash::AppLaunchId(app_id),
+    return controller_->CreateAppShortcutLauncherItem(ash::ShelfID(app_id),
                                                       model_->item_count());
   }
 
   // Get the index of an item which has the given type.
   int GetIndexOfShelfItemType(ash::ShelfItemType type) {
     return model_->GetItemIndexForType(type);
   }
 
   // Try to rip off |item_index|.
   void RipOffItemIndex(int index,
@@ skipping 87 matching lines @@
 // Test that we can launch a platform app that already has a shortcut.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPinned) {
   int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::ShelfID shortcut_id =
-      CreateAppShortcutLauncherItem(ash::AppLaunchId(app_id));
+      CreateAppShortcutLauncherItem(ash::ShelfID(app_id));
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_PINNED_APP, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Open a window. Confirm the item is now running.
   AppWindow* window = CreateAppWindow(browser()->profile(), extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
   ASSERT_EQ(item_count, shelf_model()->item_count());
@@ skipping 15 matching lines @@
   const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow* window = CreateAppWindow(browser()->profile(), extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID id = item1.id;
   EXPECT_EQ(ash::TYPE_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Create a shortcut. The app item should be after it.
-  ash::ShelfID foo_id = CreateAppShortcutLauncherItem(ash::AppLaunchId("foo"));
+  ash::ShelfID foo_id = CreateAppShortcutLauncherItem(ash::ShelfID("foo"));
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
             shelf_model()->ItemIndexByID(id));
 
   // Pin the app. The item should remain.
   controller_->PinAppWithID(extension->id());
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = *shelf_model()->ItemByID(id);
   EXPECT_EQ(ash::TYPE_PINNED_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   // New shortcuts should come after the item.
-  ash::ShelfID bar_id = CreateAppShortcutLauncherItem(ash::AppLaunchId("bar"));
+  ash::ShelfID bar_id = CreateAppShortcutLauncherItem(ash::ShelfID("bar"));
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(id),
             shelf_model()->ItemIndexByID(bar_id));
 
   // Then close it, make sure the item remains.
   CloseAppWindow(window);
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, UnpinRunning) {
   int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::ShelfID shortcut_id =
-      CreateAppShortcutLauncherItem(ash::AppLaunchId(app_id));
+      CreateAppShortcutLauncherItem(ash::ShelfID(app_id));
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_PINNED_APP, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Create a second shortcut. This will be needed to force the first one to
   // move once it gets unpinned.
-  ash::ShelfID foo_id = CreateAppShortcutLauncherItem(ash::AppLaunchId("foo"));
+  ash::ShelfID foo_id = CreateAppShortcutLauncherItem(ash::ShelfID("foo"));
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(shortcut_id),
             shelf_model()->ItemIndexByID(foo_id));
 
   // Open a window. Confirm the item is now running.
   AppWindow* window = CreateAppWindow(browser()->profile(), extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
@@ skipping 407 matching lines @@
 }
 
 // Launches an app in the background and then tries to open it. This is test for
 // a crash we had.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchInBackground) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
                          WindowOpenDisposition::NEW_BACKGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  controller_->LaunchApp(ash::AppLaunchId(last_loaded_extension_id()),
+  controller_->LaunchApp(ash::ShelfID(last_loaded_extension_id()),
                          ash::LAUNCH_FROM_UNKNOWN, 0);
 }
 
 // Confirm that clicking a icon for an app running in one of 2 maxmized windows
 // activates the right window.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchMaximized) {
   aura::Window* window1 = browser()->window()->GetNativeWindow();
   ash::wm::WindowState* window1_state = ash::wm::GetWindowState(window1);
   window1_state->Maximize();
   content::WindowedNotificationObserver open_observer(
@@ skipping 30 matching lines @@
   controller_->ActivateApp(extension->id(), ash::LAUNCH_FROM_UNKNOWN, 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   controller_->ActivateApp(extension->id(), ash::LAUNCH_FROM_UNKNOWN, 0);
   EXPECT_EQ(tab_count, tab_strip->count());
 }
 
 // Launching the same app multiple times should launch a copy for each call.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
-  ash::AppLaunchId id(LoadExtension(test_data_dir_.AppendASCII("app1"))->id());
+  ash::ShelfID id(LoadExtension(test_data_dir_.AppendASCII("app1"))->id());
   controller_->LaunchApp(id, ash::LAUNCH_FROM_UNKNOWN, 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   controller_->LaunchApp(id, ash::LAUNCH_FROM_UNKNOWN, 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
 }
 
 // Launch 2 apps and toggle which is active.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleApps) {
   int item_count = model_->item_count();
   TabStripModel* tab_strip = browser()->tab_strip_model();
@@ skipping 1109 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(tab_count + 1, tab_strip->count());
 }
 
 // Check ash::ShelfItemDelegate of Browser Shortcut functionality.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
                        BrowserShortcutLauncherItemController) {
   ash::ShelfItemDelegate* item_controller =
       controller_->GetBrowserShortcutLauncherItemController();
   const ash::ShelfID id = item_controller->shelf_id();
-  EXPECT_NE(ash::kInvalidShelfID, id);
+  EXPECT_FALSE(id.IsNull());
 
   // Get the number of browsers.
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, running_browser);
   EXPECT_FALSE(controller_->IsOpen(id));
 
   // Activate. This creates new browser
   SelectItem(item_controller, ui::ET_UNKNOWN);
   // New Window is created.
   running_browser = chrome::GetTotalBrowserCount();
@@ skipping 18 matching lines @@
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(2, model_->item_count());
 
   ash::WmWindow* window =
       ash::WmWindow::Get(browser()->window()->GetNativeWindow());
 
   int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
   ash::ShelfID browser_id = model_->items()[browser_index].id;
-  ash::ShelfID id = window->aura_window()->GetProperty(ash::kShelfIDKey);
-  EXPECT_EQ(browser_id, id);
+  ash::ShelfID* id = window->aura_window()->GetProperty(ash::kShelfIDKey);
+  ASSERT_NE(nullptr, id);
+  EXPECT_EQ(browser_id, *id);
 
   ash::ShelfID app_id = CreateShortcut("app1");
   EXPECT_EQ(3, model_->item_count());
 
   // Create and activate a new tab for "app1" and expect an application ShelfID.
   WmShelf::ActivateShelfItem(model_->ItemIndexByID(app_id));
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   id = window->aura_window()->GetProperty(ash::kShelfIDKey);
-  EXPECT_EQ(app_id, id);
+  ASSERT_NE(nullptr, id);
+  EXPECT_EQ(app_id, *id);
 
   // Activate the tab at index 0 (NTP) and expect a browser ShelfID.
   browser()->tab_strip_model()->ActivateTabAt(0, false);
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
   id = window->aura_window()->GetProperty(ash::kShelfIDKey);
-  EXPECT_EQ(browser_id, id);
+  ASSERT_NE(nullptr, id);
+  EXPECT_EQ(browser_id, *id);
 }
 
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, OverflowBubble) {
   // Make sure to have a browser window
   chrome::NewTab(browser());
 
   // No overflow yet.
   EXPECT_FALSE(shelf_->shelf_widget()->IsShowingOverflowBubble());
 
   ash::test::ShelfViewTestAPI test(shelf_->GetShelfViewForTesting());
@@ skipping 17 matching lines @@
   test.RunMessageLoopUntilAnimationsDone();
   EXPECT_FALSE(shelf_->shelf_widget()->IsShowingOverflowBubble());
 }
 
 // Check that a windowed V1 application can navigate away from its domain, but
 // still gets detected properly.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, V1AppNavigation) {
   // We assume that the web store is always there (which it apparently is).
   controller_->PinAppWithID(extensions::kWebStoreAppId);
   ash::ShelfID id = controller_->GetShelfIDForAppID(extensions::kWebStoreAppId);
-  DCHECK_NE(id, ash::kInvalidShelfID);
+  EXPECT_FALSE(id.IsNull());
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
 
   // Create a windowed application.
   AppLaunchParams params = CreateAppLaunchParamsUserContainer(
       profile(), GetExtensionForAppID(extensions::kWebStoreAppId, profile()),
       WindowOpenDisposition::NEW_FOREGROUND_TAB, extensions::SOURCE_TEST);
   params.container = extensions::LAUNCH_CONTAINER_WINDOW;
   OpenApplication(params);
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(id)->status);
 
@@ skipping 159 matching lines @@
 
   // Close all windows via the menu item.
   CloseBrowserWindow(browser(), menu1.get(), LauncherContextMenu::MENU_CLOSE);
   EXPECT_EQ(0u, BrowserList::GetInstance()->size());
 
   // Check if "Close" is removed from the context menu.
   std::unique_ptr<LauncherContextMenu> menu2 = CreateBrowserItemContextMenu();
   ASSERT_FALSE(
       IsItemPresentInMenu(menu2.get(), LauncherContextMenu::MENU_CLOSE));
 }