Add chrome.app.window API tests for items shown in shelf

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shelf/app_list_button.h"
@@ skipping 397 matching lines @@
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item = GetLastLauncherItem();
   EXPECT_EQ(ash::TYPE_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
   CloseAppWindow(window);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
+                       LaunchUnpinnedShowInShelfWindow) {
+  int item_count = shelf_model()->item_count();
+  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
+  AppWindow::CreateParams params;
+
+  // Open a window shown in shelf.
+  params.show_in_shelf = true;
+  params.window_key = "window";
+  AppWindow* window =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item = GetLastLauncherItem();
+  EXPECT_EQ(ash::TYPE_APP, item.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
+  CloseAppWindow(window);
+  --item_count;
+  EXPECT_EQ(item_count, shelf_model()->item_count());
+}
+
 // 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 =
@@ skipping 13 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Then close it, make sure there's still an item.
   CloseAppWindow(window);
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 }
 
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
+                       LaunchPinnedShowInShelfWindow) {
+  int item_count = shelf_model()->item_count();
+
+  // First get app_id.
+  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
+  const std::string app_id = extension->id();
+  AppWindow::CreateParams params;
+
+  // Then create a shortcut.
+  ash::ShelfID shortcut_id = CreateAppShortcutLauncherItem(
+      ash::launcher::AppLauncherId(app_id, "window"));
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
+  EXPECT_EQ(ash::STATUS_CLOSED, item.status);
+
+  // Open a window shown in shelf. Confirm the item is now running.
+  params.show_in_shelf = true;
+  params.window_key = "window";
+  AppWindow* window =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ash::wm::ActivateWindow(window->GetNativeWindow());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
+
+  // Then close it, make sure there's still an item.
+  CloseAppWindow(window);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item = *shelf_model()->ItemByID(shortcut_id);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
+  EXPECT_EQ(ash::STATUS_CLOSED, item.status);
+}
+
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, PinRunning) {
   // Run.
   int item_count = shelf_model()->item_count();
   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);
@@ skipping 20 matching lines @@
   ++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,
+                       PinRunningShowInShelfWindow) {
+  // Run.
+  int item_count = shelf_model()->item_count();
+  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
+  AppWindow::CreateParams params;
+
+  AppWindow* window1 = CreateAppWindow(browser()->profile(), extension);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window1 = GetLastLauncherItem();
+  ash::ShelfID id_window1 = item_window1.id;
+  EXPECT_EQ(ash::TYPE_APP, item_window1.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window1.status);
+
+  // Open a window shown in shelf.
+  params.show_in_shelf = true;
+  params.window_key = "window2";
+  AppWindow* window2 =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window2 = GetLastLauncherItem();
+  ash::ShelfID id_window2 = item_window2.id;
+  EXPECT_EQ(ash::TYPE_APP, item_window2.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window2.status);
+
+  // Create a shortcut. The app window1 and window2 should be after it.
+  ash::ShelfID foo_id =
+      CreateAppShortcutLauncherItem(ash::launcher::AppLauncherId("foo"));
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
+            shelf_model()->ItemIndexByID(id_window1));
+  EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
+            shelf_model()->ItemIndexByID(id_window2));
+
+  // Pin the app window1. The item should remain.
+  controller_->Pin(id_window1);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window = *shelf_model()->ItemByID(id_window1);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window.type);
+  EXPECT_EQ(ash::STATUS_RUNNING, item_window.status);
+
+  // New shortcuts should come after the app window1 and before window2.
+  ash::ShelfID bar_id =
+      CreateAppShortcutLauncherItem(ash::launcher::AppLauncherId("bar"));
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(id_window1),
+            shelf_model()->ItemIndexByID(bar_id));
+  EXPECT_LT(shelf_model()->ItemIndexByID(bar_id),
+            shelf_model()->ItemIndexByID(id_window2));
+
+  // Then close the app window1, make sure the item remains.
+  CloseAppWindow(window1);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  // Then close the app window2.
+  CloseAppWindow(window2);
+  --item_count;
+  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::launcher::AppLauncherId(app_id));
@@ skipping 29 matching lines @@
   // The item should have moved after the other shortcuts.
   EXPECT_GT(shelf_model()->ItemIndexByID(shortcut_id),
             shelf_model()->ItemIndexByID(foo_id));
 
   // Then close it, make sure the item's gone.
   CloseAppWindow(window);
   --item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
+                       UnpinRunningShowInShelfWindow) {
+  int item_count = shelf_model()->item_count();
+
+  // First get app_id.
+  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
+  const std::string app_id = extension->id();
+  AppWindow::CreateParams params;
+
+  // Then create a shortcut window1.
+  ash::ShelfID shortcut_id_window1 =
+      CreateAppShortcutLauncherItem(ash::launcher::AppLauncherId(app_id));
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  ash::ShelfItem item_window1 = *shelf_model()->ItemByID(shortcut_id_window1);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window1.type);
+  EXPECT_EQ(ash::STATUS_CLOSED, item_window1.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::launcher::AppLauncherId("foo"));
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  EXPECT_LT(shelf_model()->ItemIndexByID(shortcut_id_window1),
+            shelf_model()->ItemIndexByID(foo_id));
+
+  // Open app window1. Confirm the item is now running.
+  AppWindow* window1 = CreateAppWindow(browser()->profile(), extension);
+  ash::wm::ActivateWindow(window1->GetNativeWindow());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item_window1 = *shelf_model()->ItemByID(shortcut_id_window1);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window1.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window1.status);
+
+  // Open the app window2 shown in shelf.
+  params.show_in_shelf = true;
+  params.window_key = "window2";
+  AppWindow* window2 =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window2 = GetLastLauncherItem();
+  ash::ShelfID id_window2 = item_window2.id;
+  EXPECT_EQ(ash::TYPE_APP, item_window2.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window2.status);
+  EXPECT_GT(shelf_model()->ItemIndexByID(id_window2),
+            shelf_model()->ItemIndexByID(foo_id));
+
+  // Unpin the app window1. The item should remain.
+  controller_->Unpin(shortcut_id_window1);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  item_window1 = *shelf_model()->ItemByID(shortcut_id_window1);
+  EXPECT_EQ(ash::TYPE_APP, item_window1.type);
+  EXPECT_EQ(ash::STATUS_RUNNING, item_window1.status);
+  // The app window1 should have moved after the other shortcuts.
+  EXPECT_GT(shelf_model()->ItemIndexByID(shortcut_id_window1),
+            shelf_model()->ItemIndexByID(foo_id));
+
+  // Then close app window1 and window2, make sure the item's gone.
+  CloseAppWindow(window1);
+  --item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  CloseAppWindow(window2);
+  --item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+}
+
 // Test that we can launch a platform app with more than one window.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleWindows) {
   int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
   AppWindow* window1 = CreateAppWindow(browser()->profile(), extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
@@ skipping 1867 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));
 }
+
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
+                       PinAndRestoreShowInShelfWindow) {
+  // Run.
+  int item_count = shelf_model()->item_count();
+  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
+  AppWindow::CreateParams params;
+
+  AppWindow* window1 = CreateAppWindow(browser()->profile(), extension);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window1 = GetLastLauncherItem();
+  EXPECT_EQ(ash::TYPE_APP, item_window1.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window1.status);
+
+  // Open a window shown in shelf.
+  params.show_in_shelf = true;
+  params.window_key = "window2";
+  AppWindow* window2 =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window2 = GetLastLauncherItem();
+  ash::ShelfID id_window2 = item_window2.id;
+  EXPECT_EQ(ash::TYPE_APP, item_window2.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window2.status);
+
+  // Open the second window shown in shelf.
+  params.show_in_shelf = true;
+  params.window_key = "window3";
+  AppWindow* window3 =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window3 = GetLastLauncherItem();
+  ash::ShelfID id_window3 = item_window3.id;
+  EXPECT_EQ(ash::TYPE_APP, item_window3.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window3.status);
+
+  // Pin the app window2. The item should remain.
+  controller_->Pin(id_window2);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window_p2 = *shelf_model()->ItemByID(id_window2);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window_p2.type);
+  EXPECT_EQ(ash::STATUS_RUNNING, item_window_p2.status);
+
+  // Pin the app window3. The item should remain.
+  controller_->Pin(id_window3);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window_p3 = *shelf_model()->ItemByID(id_window3);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window_p3.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window_p3.status);
+
+  // Then close the app window2, make sure the item remains.
+  CloseAppWindow(window2);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  // Then close the app window1.
+  CloseAppWindow(window1);
+  --item_count;
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  // Then close the app window3, make sure the item remains.
+  CloseAppWindow(window3);
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+
+  // Open app window2. Confirm the item is now running.
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window_p2.type);
+  EXPECT_EQ(ash::STATUS_CLOSED, item_window_p2.status);
+  params.show_in_shelf = true;
+  params.window_key = "window2";
+  AppWindow* window_p2 =
+      CreateAppWindowFromParams(browser()->profile(), extension, params);
+  ash::wm::ActivateWindow(window_p2->GetNativeWindow());
+  ASSERT_EQ(item_count, shelf_model()->item_count());
+  const ash::ShelfItem& item_window_r2 = *shelf_model()->ItemByID(id_window2);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item_window_r2.type);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item_window_r2.status);
+}