1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
6
7#include "ash/ash_switches.h"
8#include "ash/display/display_controller.h"
9#include "ash/shelf/shelf.h"
10#include "ash/shelf/shelf_button.h"
11#include "ash/shelf/shelf_constants.h"
12#include "ash/shelf/shelf_model.h"
13#include "ash/shelf/shelf_util.h"
14#include "ash/shelf/shelf_view.h"
15#include "ash/shell.h"
16#include "ash/test/app_list_controller_test_api.h"
17#include "ash/test/shelf_test_api.h"
18#include "ash/test/shelf_view_test_api.h"
19#include "ash/test/shell_test_api.h"
20#include "ash/wm/window_state.h"
21#include "ash/wm/window_util.h"
22#include "base/strings/stringprintf.h"
23#include "base/strings/utf_string_conversions.h"
24#include "chrome/browser/apps/app_browsertest_util.h"
25#include "chrome/browser/chrome_notification_types.h"
26#include "chrome/browser/extensions/extension_apitest.h"
27#include "chrome/browser/extensions/extension_browsertest.h"
28#include "chrome/browser/extensions/extension_function_test_utils.h"
29#include "chrome/browser/extensions/extension_service.h"
30#include "chrome/browser/profiles/profile.h"
31#include "chrome/browser/ui/app_list/app_list_service.h"
32#include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
33#include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h"
34#include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
35#include "chrome/browser/ui/browser.h"
36#include "chrome/browser/ui/browser_commands.h"
37#include "chrome/browser/ui/browser_finder.h"
38#include "chrome/browser/ui/browser_list.h"
39#include "chrome/browser/ui/browser_window.h"
40#include "chrome/browser/ui/chrome_pages.h"
41#include "chrome/browser/ui/extensions/application_launch.h"
42#include "chrome/browser/ui/host_desktop.h"
43#include "chrome/browser/ui/settings_window_manager.h"
44#include "chrome/browser/ui/tabs/tab_strip_model.h"
45#include "chrome/common/chrome_switches.h"
46#include "chrome/test/base/ui_test_utils.h"
47#include "content/public/browser/notification_service.h"
48#include "content/public/browser/notification_source.h"
49#include "content/public/browser/web_contents.h"
50#include "content/public/test/browser_test_utils.h"
51#include "extensions/browser/app_window/app_window.h"
52#include "extensions/browser/app_window/app_window_registry.h"
53#include "extensions/browser/app_window/native_app_window.h"
54#include "extensions/browser/extension_system.h"
55#include "extensions/common/constants.h"
56#include "extensions/common/switches.h"
57#include "extensions/test/extension_test_message_listener.h"
58#include "testing/gtest/include/gtest/gtest.h"
59#include "ui/app_list/views/apps_grid_view.h"
60#include "ui/aura/client/aura_constants.h"
61#include "ui/aura/window.h"
62#include "ui/events/event.h"
63#include "ui/events/test/event_generator.h"
64
65using extensions::AppWindow;
66using extensions::Extension;
67using content::WebContents;
68
69namespace {
70
71class TestEvent : public ui::Event {
72 public:
73  explicit TestEvent(ui::EventType type)
74      : ui::Event(type, base::TimeDelta(), 0) {
75  }
76  virtual ~TestEvent() {
77  }
78
79 private:
80  DISALLOW_COPY_AND_ASSIGN(TestEvent);
81};
82
83class TestAppWindowRegistryObserver
84    : public extensions::AppWindowRegistry::Observer {
85 public:
86  explicit TestAppWindowRegistryObserver(Profile* profile)
87      : profile_(profile), icon_updates_(0) {
88    extensions::AppWindowRegistry::Get(profile_)->AddObserver(this);
89  }
90
91  virtual ~TestAppWindowRegistryObserver() {
92    extensions::AppWindowRegistry::Get(profile_)->RemoveObserver(this);
93  }
94
95  // Overridden from AppWindowRegistry::Observer:
96  virtual void OnAppWindowIconChanged(AppWindow* app_window) OVERRIDE {
97    ++icon_updates_;
98  }
99
100  int icon_updates() { return icon_updates_; }
101
102 private:
103  Profile* profile_;
104  int icon_updates_;
105
106  DISALLOW_COPY_AND_ASSIGN(TestAppWindowRegistryObserver);
107};
108
109}  // namespace
110
111class LauncherPlatformAppBrowserTest
112    : public extensions::PlatformAppBrowserTest {
113 protected:
114  LauncherPlatformAppBrowserTest() : shelf_(NULL), controller_(NULL) {
115  }
116
117  virtual ~LauncherPlatformAppBrowserTest() {}
118
119  virtual void RunTestOnMainThreadLoop() OVERRIDE {
120    shelf_ = ash::Shelf::ForPrimaryDisplay();
121    controller_ = ChromeLauncherController::instance();
122    return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
123  }
124
125  ash::ShelfModel* shelf_model() {
126    return ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
127  }
128
129  ash::ShelfID CreateAppShortcutLauncherItem(const std::string& name) {
130    return controller_->CreateAppShortcutLauncherItem(
131        name, controller_->model()->item_count());
132  }
133
134  const ash::ShelfItem& GetLastLauncherItem() {
135    // Unless there are any panels, the item at index [count - 1] will be
136    // the desired item.
137    return shelf_model()->items()[shelf_model()->item_count() - 1];
138  }
139
140  const ash::ShelfItem& GetLastLauncherPanelItem() {
141    // Panels show up on the right side of the shelf, so the desired item
142    // will be the last one.
143    return shelf_model()->items()[shelf_model()->item_count() - 1];
144  }
145
146  LauncherItemController* GetItemController(ash::ShelfID id) {
147    return controller_->id_to_item_controller_map_[id];
148  }
149
150  // Returns the number of menu items, ignoring separators.
151  int GetNumApplicationMenuItems(const ash::ShelfItem& item) {
152    const int event_flags = 0;
153    scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
154        controller_->GetApplicationList(item, event_flags)));
155    int num_items = 0;
156    for (int i = 0; i < menu->GetItemCount(); ++i) {
157      if (menu->GetTypeAt(i) != ui::MenuModel::TYPE_SEPARATOR)
158        ++num_items;
159    }
160    return num_items;
161  }
162
163  // Activate the shelf item with the given |id|.
164  void ActivateShelfItem(int id) {
165    shelf_->ActivateShelfItem(id);
166  }
167
168  ash::Shelf* shelf_;
169  ChromeLauncherController* controller_;
170
171 private:
172
173  DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
174};
175
176enum RipOffCommand {
177  // Drag the item off the shelf and let the mouse go.
178  RIP_OFF_ITEM,
179  // Drag the item off the shelf, move the mouse back and then let go.
180  RIP_OFF_ITEM_AND_RETURN,
181  // Drag the item off the shelf and then issue a cancel command.
182  RIP_OFF_ITEM_AND_CANCEL,
183  // Drag the item off the shelf and do not release the mouse.
184  RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE,
185};
186
187class ShelfAppBrowserTest : public ExtensionBrowserTest {
188 protected:
189  ShelfAppBrowserTest() : shelf_(NULL), model_(NULL), controller_(NULL) {
190  }
191
192  virtual ~ShelfAppBrowserTest() {}
193
194  virtual void RunTestOnMainThreadLoop() OVERRIDE {
195    shelf_ = ash::Shelf::ForPrimaryDisplay();
196    model_ = ash::test::ShellTestApi(ash::Shell::GetInstance()).shelf_model();
197    controller_ = ChromeLauncherController::instance();
198    return ExtensionBrowserTest::RunTestOnMainThreadLoop();
199  }
200
201  size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
202    LauncherItemController* item_controller =
203      controller_->GetBrowserShortcutLauncherItemController();
204    int items = item_controller->GetApplicationList(
205        show_all_tabs ? ui::EF_SHIFT_DOWN : 0).size();
206    // If we have at least one item, we have also a title which we remove here.
207    return items ? (items - 1) : 0;
208  }
209
210  const Extension* LoadAndLaunchExtension(
211      const char* name,
212      extensions::LaunchContainer container,
213      WindowOpenDisposition disposition) {
214    EXPECT_TRUE(LoadExtension(test_data_dir_.AppendASCII(name)));
215
216    ExtensionService* service = extensions::ExtensionSystem::Get(
217        profile())->extension_service();
218    const Extension* extension =
219        service->GetExtensionById(last_loaded_extension_id(), false);
220    EXPECT_TRUE(extension);
221
222    OpenApplication(AppLaunchParams(profile(),
223                                    extension,
224                                    container,
225                                    disposition));
226    return extension;
227  }
228
229  ash::ShelfID CreateShortcut(const char* name) {
230    ExtensionService* service = extensions::ExtensionSystem::Get(
231        profile())->extension_service();
232    LoadExtension(test_data_dir_.AppendASCII(name));
233
234    // First get app_id.
235    const Extension* extension =
236        service->GetExtensionById(last_loaded_extension_id(), false);
237    const std::string app_id = extension->id();
238
239    // Then create a shortcut.
240    int item_count = model_->item_count();
241    ash::ShelfID shortcut_id = controller_->CreateAppShortcutLauncherItem(
242        app_id,
243        item_count);
244    controller_->PersistPinnedState();
245    EXPECT_EQ(++item_count, model_->item_count());
246    const ash::ShelfItem& item = *model_->ItemByID(shortcut_id);
247    EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
248    return item.id;
249  }
250
251  void RemoveShortcut(ash::ShelfID id) {
252    controller_->Unpin(id);
253  }
254
255  // Activate the shelf item with the given |id|.
256  void ActivateShelfItem(int id) {
257    shelf_->ActivateShelfItem(id);
258  }
259
260  ash::ShelfID PinFakeApp(const std::string& name) {
261    return controller_->CreateAppShortcutLauncherItem(
262        name, model_->item_count());
263  }
264
265  // Get the index of an item which has the given type.
266  int GetIndexOfShelfItemType(ash::ShelfItemType type) {
267    return model_->GetItemIndexForType(type);
268  }
269
270  // Try to rip off |item_index|.
271  void RipOffItemIndex(int index,
272                       ui::test::EventGenerator* generator,
273                       ash::test::ShelfViewTestAPI* test,
274                       RipOffCommand command) {
275    ash::ShelfButton* button = test->GetButton(index);
276    gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
277    gfx::Point rip_off_point(start_point.x(), 0);
278    generator->MoveMouseTo(start_point.x(), start_point.y());
279    base::MessageLoop::current()->RunUntilIdle();
280    generator->PressLeftButton();
281    base::MessageLoop::current()->RunUntilIdle();
282    generator->MoveMouseTo(rip_off_point.x(), rip_off_point.y());
283    base::MessageLoop::current()->RunUntilIdle();
284    test->RunMessageLoopUntilAnimationsDone();
285    if (command == RIP_OFF_ITEM_AND_RETURN) {
286      generator->MoveMouseTo(start_point.x(), start_point.y());
287      base::MessageLoop::current()->RunUntilIdle();
288      test->RunMessageLoopUntilAnimationsDone();
289    } else if (command == RIP_OFF_ITEM_AND_CANCEL) {
290      // This triggers an internal cancel. Using VKEY_ESCAPE was too unreliable.
291      button->OnMouseCaptureLost();
292    }
293    if (command != RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE) {
294      generator->ReleaseLeftButton();
295      base::MessageLoop::current()->RunUntilIdle();
296      test->RunMessageLoopUntilAnimationsDone();
297    }
298  }
299
300  ash::Shelf* shelf_;
301  ash::ShelfModel* model_;
302  ChromeLauncherController* controller_;
303
304 private:
305
306  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTest);
307};
308
309class ShelfAppBrowserTestNoDefaultBrowser : public ShelfAppBrowserTest {
310 protected:
311  ShelfAppBrowserTestNoDefaultBrowser() {}
312  virtual ~ShelfAppBrowserTestNoDefaultBrowser() {}
313
314  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
315    ShelfAppBrowserTest::SetUpCommandLine(command_line);
316    command_line->AppendSwitch(switches::kNoStartupWindow);
317  }
318
319 private:
320
321  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTestNoDefaultBrowser);
322};
323
324// Since the default for minimizing on click might change, I added both classes
325// to either get the minimize on click or not.
326class ShelfAppBrowserNoMinimizeOnClick : public LauncherPlatformAppBrowserTest {
327 protected:
328  ShelfAppBrowserNoMinimizeOnClick() {}
329  virtual ~ShelfAppBrowserNoMinimizeOnClick() {}
330
331  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
332    LauncherPlatformAppBrowserTest::SetUpCommandLine(command_line);
333    command_line->AppendSwitch(
334        switches::kDisableMinimizeOnSecondLauncherItemClick);
335  }
336
337 private:
338
339  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserNoMinimizeOnClick);
340};
341
342typedef LauncherPlatformAppBrowserTest ShelfAppBrowserMinimizeOnClick;
343
344// Test that we can launch a platform app and get a running item.
345IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
346  int item_count = shelf_model()->item_count();
347  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
348  AppWindow* window = CreateAppWindow(extension);
349  ++item_count;
350  ASSERT_EQ(item_count, shelf_model()->item_count());
351  const ash::ShelfItem& item = GetLastLauncherItem();
352  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
353  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
354  CloseAppWindow(window);
355  --item_count;
356  EXPECT_EQ(item_count, shelf_model()->item_count());
357}
358
359// Test that we can launch a platform app that already has a shortcut.
360IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPinned) {
361  int item_count = shelf_model()->item_count();
362
363  // First get app_id.
364  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
365  const std::string app_id = extension->id();
366
367  // Then create a shortcut.
368  ash::ShelfID shortcut_id = CreateAppShortcutLauncherItem(app_id);
369  ++item_count;
370  ASSERT_EQ(item_count, shelf_model()->item_count());
371  ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
372  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
373  EXPECT_EQ(ash::STATUS_CLOSED, item.status);
374
375  // Open a window. Confirm the item is now running.
376  AppWindow* window = CreateAppWindow(extension);
377  ash::wm::ActivateWindow(window->GetNativeWindow());
378  ASSERT_EQ(item_count, shelf_model()->item_count());
379  item = *shelf_model()->ItemByID(shortcut_id);
380  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
381  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
382
383  // Then close it, make sure there's still an item.
384  CloseAppWindow(window);
385  ASSERT_EQ(item_count, shelf_model()->item_count());
386  item = *shelf_model()->ItemByID(shortcut_id);
387  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
388  EXPECT_EQ(ash::STATUS_CLOSED, item.status);
389}
390
391IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, PinRunning) {
392  // Run.
393  int item_count = shelf_model()->item_count();
394  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
395  AppWindow* window = CreateAppWindow(extension);
396  ++item_count;
397  ASSERT_EQ(item_count, shelf_model()->item_count());
398  const ash::ShelfItem& item1 = GetLastLauncherItem();
399  ash::ShelfID id = item1.id;
400  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
401  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
402
403  // Create a shortcut. The app item should be after it.
404  ash::ShelfID foo_id = CreateAppShortcutLauncherItem("foo");
405  ++item_count;
406  ASSERT_EQ(item_count, shelf_model()->item_count());
407  EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
408            shelf_model()->ItemIndexByID(id));
409
410  // Pin the app. The item should remain.
411  controller_->Pin(id);
412  ASSERT_EQ(item_count, shelf_model()->item_count());
413  const ash::ShelfItem& item2 = *shelf_model()->ItemByID(id);
414  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item2.type);
415  EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
416
417  // New shortcuts should come after the item.
418  ash::ShelfID bar_id = CreateAppShortcutLauncherItem("bar");
419  ++item_count;
420  ASSERT_EQ(item_count, shelf_model()->item_count());
421  EXPECT_LT(shelf_model()->ItemIndexByID(id),
422            shelf_model()->ItemIndexByID(bar_id));
423
424  // Then close it, make sure the item remains.
425  CloseAppWindow(window);
426  ASSERT_EQ(item_count, shelf_model()->item_count());
427}
428
429IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, UnpinRunning) {
430  int item_count = shelf_model()->item_count();
431
432  // First get app_id.
433  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
434  const std::string app_id = extension->id();
435
436  // Then create a shortcut.
437  ash::ShelfID shortcut_id = CreateAppShortcutLauncherItem(app_id);
438  ++item_count;
439  ASSERT_EQ(item_count, shelf_model()->item_count());
440  ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
441  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
442  EXPECT_EQ(ash::STATUS_CLOSED, item.status);
443
444  // Create a second shortcut. This will be needed to force the first one to
445  // move once it gets unpinned.
446  ash::ShelfID foo_id = CreateAppShortcutLauncherItem("foo");
447  ++item_count;
448  ASSERT_EQ(item_count, shelf_model()->item_count());
449  EXPECT_LT(shelf_model()->ItemIndexByID(shortcut_id),
450            shelf_model()->ItemIndexByID(foo_id));
451
452  // Open a window. Confirm the item is now running.
453  AppWindow* window = CreateAppWindow(extension);
454  ash::wm::ActivateWindow(window->GetNativeWindow());
455  ASSERT_EQ(item_count, shelf_model()->item_count());
456  item = *shelf_model()->ItemByID(shortcut_id);
457  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
458  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
459
460  // Unpin the app. The item should remain.
461  controller_->Unpin(shortcut_id);
462  ASSERT_EQ(item_count, shelf_model()->item_count());
463  item = *shelf_model()->ItemByID(shortcut_id);
464  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
465  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
466  // The item should have moved after the other shortcuts.
467  EXPECT_GT(shelf_model()->ItemIndexByID(shortcut_id),
468            shelf_model()->ItemIndexByID(foo_id));
469
470  // Then close it, make sure the item's gone.
471  CloseAppWindow(window);
472  --item_count;
473  ASSERT_EQ(item_count, shelf_model()->item_count());
474}
475
476// Test that we can launch a platform app with more than one window.
477IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleWindows) {
478  int item_count = shelf_model()->item_count();
479
480  // First run app.
481  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
482  AppWindow* window1 = CreateAppWindow(extension);
483  ++item_count;
484  ASSERT_EQ(item_count, shelf_model()->item_count());
485  const ash::ShelfItem& item1 = GetLastLauncherItem();
486  ash::ShelfID item_id = item1.id;
487  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
488  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
489  EXPECT_EQ(2, GetNumApplicationMenuItems(item1));  // Title + 1 window
490
491  // Add second window.
492  AppWindow* window2 = CreateAppWindow(extension);
493  // Confirm item stays.
494  ASSERT_EQ(item_count, shelf_model()->item_count());
495  const ash::ShelfItem& item2 = *shelf_model()->ItemByID(item_id);
496  EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
497  EXPECT_EQ(3, GetNumApplicationMenuItems(item2));  // Title + 2 windows
498
499  // Close second window.
500  CloseAppWindow(window2);
501  // Confirm item stays.
502  ASSERT_EQ(item_count, shelf_model()->item_count());
503  const ash::ShelfItem& item3 = *shelf_model()->ItemByID(item_id);
504  EXPECT_EQ(ash::STATUS_ACTIVE, item3.status);
505  EXPECT_EQ(2, GetNumApplicationMenuItems(item3));  // Title + 1 window
506
507  // Close first window.
508  CloseAppWindow(window1);
509  // Confirm item is removed.
510  --item_count;
511  ASSERT_EQ(item_count, shelf_model()->item_count());
512}
513
514IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleApps) {
515  int item_count = shelf_model()->item_count();
516
517  // First run app.
518  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
519  AppWindow* window1 = CreateAppWindow(extension1);
520  ++item_count;
521  ASSERT_EQ(item_count, shelf_model()->item_count());
522  const ash::ShelfItem& item1 = GetLastLauncherItem();
523  ash::ShelfID item_id1 = item1.id;
524  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
525  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
526
527  // Then run second app.
528  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
529                                                         "Launched");
530  AppWindow* window2 = CreateAppWindow(extension2);
531  ++item_count;
532  ASSERT_EQ(item_count, shelf_model()->item_count());
533  const ash::ShelfItem& item2 = GetLastLauncherItem();
534  ash::ShelfID item_id2 = item2.id;
535  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item2.type);
536  EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
537
538  EXPECT_NE(item_id1, item_id2);
539  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
540
541  // Close second app.
542  CloseAppWindow(window2);
543  --item_count;
544  ASSERT_EQ(item_count, shelf_model()->item_count());
545  // First app should be active again.
546  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
547
548  // Close first app.
549  CloseAppWindow(window1);
550  --item_count;
551  ASSERT_EQ(item_count, shelf_model()->item_count());
552}
553
554// Confirm that app windows can be reactivated by clicking their icons and that
555// the correct activation order is maintained.
556IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowActivation) {
557  int item_count = shelf_model()->item_count();
558
559  // First run app.
560  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
561  AppWindow* window1 = CreateAppWindow(extension1);
562  ++item_count;
563  ASSERT_EQ(item_count, shelf_model()->item_count());
564  const ash::ShelfItem& item1 = GetLastLauncherItem();
565  ash::ShelfID item_id1 = item1.id;
566  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
567  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
568
569  // Then run second app.
570  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
571                                                         "Launched");
572  AppWindow* window2 = CreateAppWindow(extension2);
573  ++item_count;
574  ASSERT_EQ(item_count, shelf_model()->item_count());
575  const ash::ShelfItem& item2 = GetLastLauncherItem();
576  ash::ShelfID item_id2 = item2.id;
577  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item2.type);
578  EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
579
580  EXPECT_NE(item_id1, item_id2);
581  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
582
583  // Activate first one.
584  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
585  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
586  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id2)->status);
587  EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
588  EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
589
590  // Activate second one.
591  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
592  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
593  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id2)->status);
594  EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
595  EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
596
597  // Add window for app1. This will activate it.
598  AppWindow* window1b = CreateAppWindow(extension1);
599  ash::wm::ActivateWindow(window1b->GetNativeWindow());
600  EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
601  EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
602  EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
603
604  // Activate launcher item for app1, this will activate the first app window.
605  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
606  EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
607  EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
608  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
609  EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
610
611  // Activate the second app again
612  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
613  EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
614  EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
615  EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
616
617  // Activate the first app again
618  ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
619  EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
620  EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
621  EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
622
623  // Close second app.
624  CloseAppWindow(window2);
625  --item_count;
626  EXPECT_EQ(item_count, shelf_model()->item_count());
627  // First app should be active again.
628  EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
629
630  // Close first app.
631  CloseAppWindow(window1b);
632  CloseAppWindow(window1);
633  --item_count;
634  EXPECT_EQ(item_count, shelf_model()->item_count());
635}
636
637// Verify that ChromeLauncherController::CanInstall() returns true for ephemeral
638// apps and false when the app is promoted to a regular installed app.
639IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, InstallEphemeralApp) {
640  int item_count = shelf_model()->item_count();
641
642  // Sanity check to verify that ChromeLauncherController::CanInstall() returns
643  // false for apps that are fully installed.
644  const Extension* app = LoadAndLaunchPlatformApp("launch", "Launched");
645  ASSERT_TRUE(app);
646  CreateAppWindow(app);
647  ++item_count;
648  ASSERT_EQ(item_count, shelf_model()->item_count());
649  const ash::ShelfItem& app_item = GetLastLauncherItem();
650  ash::ShelfID app_id = app_item.id;
651  EXPECT_FALSE(controller_->CanInstall(app_id));
652
653  // Add an ephemeral app.
654  const Extension* ephemeral_app = InstallEphemeralAppWithSourceAndFlags(
655      test_data_dir_.AppendASCII("platform_apps").AppendASCII("launch_2"),
656      1,
657      extensions::Manifest::INTERNAL,
658      Extension::NO_FLAGS);
659  ASSERT_TRUE(ephemeral_app);
660  CreateAppWindow(ephemeral_app);
661  ++item_count;
662  ASSERT_EQ(item_count, shelf_model()->item_count());
663  const ash::ShelfItem& ephemeral_item = GetLastLauncherItem();
664  ash::ShelfID ephemeral_id = ephemeral_item.id;
665
666  // Verify that the shelf item for the ephemeral app can be installed.
667  EXPECT_TRUE(controller_->CanInstall(ephemeral_id));
668
669  // Promote the ephemeral app to a regular installed app.
670  ExtensionService* service =
671      extensions::ExtensionSystem::Get(profile())->extension_service();
672  service->PromoteEphemeralApp(ephemeral_app, false);
673
674  // Verify that the shelf item for the app can no longer be installed.
675  EXPECT_FALSE(controller_->CanInstall(ephemeral_id));
676}
677
678// Confirm that Click behavior for app windows is correnct.
679IN_PROC_BROWSER_TEST_F(ShelfAppBrowserNoMinimizeOnClick, AppClickBehavior) {
680  // Launch a platform app and create a window for it.
681  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
682  AppWindow* window1 = CreateAppWindow(extension1);
683  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
684  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
685  // Confirm that a controller item was created and is the correct state.
686  const ash::ShelfItem& item1 = GetLastLauncherItem();
687  LauncherItemController* item1_controller = GetItemController(item1.id);
688  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
689  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
690  EXPECT_EQ(LauncherItemController::TYPE_APP, item1_controller->type());
691  // Clicking the item should have no effect.
692  TestEvent click_event(ui::ET_MOUSE_PRESSED);
693  item1_controller->ItemSelected(click_event);
694  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
695  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
696  // Minimize the window and confirm that the controller item is updated.
697  window1->GetBaseWindow()->Minimize();
698  EXPECT_FALSE(window1->GetNativeWindow()->IsVisible());
699  EXPECT_FALSE(window1->GetBaseWindow()->IsActive());
700  EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
701  // Clicking the item should activate the window.
702  item1_controller->ItemSelected(click_event);
703  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
704  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
705  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
706  // Maximizing a window should preserve state after minimize + click.
707  window1->GetBaseWindow()->Maximize();
708  window1->GetBaseWindow()->Minimize();
709  item1_controller->ItemSelected(click_event);
710  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
711  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
712  EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
713}
714
715// Confirm the minimizing click behavior for apps.
716IN_PROC_BROWSER_TEST_F(ShelfAppBrowserMinimizeOnClick,
717                       PackagedAppClickBehaviorInMinimizeMode) {
718  // Launch one platform app and create a window for it.
719  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
720  AppWindow* window1 = CreateAppWindow(extension1);
721  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
722  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
723
724  // Confirm that a controller item was created and is the correct state.
725  const ash::ShelfItem& item1 = GetLastLauncherItem();
726  LauncherItemController* item1_controller = GetItemController(item1.id);
727  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
728  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
729  EXPECT_EQ(LauncherItemController::TYPE_APP, item1_controller->type());
730  // Since it is already active, clicking it should minimize.
731  TestEvent click_event(ui::ET_MOUSE_PRESSED);
732  item1_controller->ItemSelected(click_event);
733  EXPECT_FALSE(window1->GetNativeWindow()->IsVisible());
734  EXPECT_FALSE(window1->GetBaseWindow()->IsActive());
735  EXPECT_TRUE(window1->GetBaseWindow()->IsMinimized());
736  EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
737  // Clicking the item again should activate the window again.
738  item1_controller->ItemSelected(click_event);
739  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
740  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
741  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
742  // Maximizing a window should preserve state after minimize + click.
743  window1->GetBaseWindow()->Maximize();
744  window1->GetBaseWindow()->Minimize();
745  item1_controller->ItemSelected(click_event);
746  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
747  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
748  EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
749  window1->GetBaseWindow()->Restore();
750  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
751  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
752  EXPECT_FALSE(window1->GetBaseWindow()->IsMaximized());
753
754  // Creating a second window of the same type should change the behavior so
755  // that a click does not change the activation state.
756  AppWindow* window1a = CreateAppWindow(extension1);
757  EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
758  EXPECT_TRUE(window1a->GetBaseWindow()->IsActive());
759  // The first click does nothing.
760  item1_controller->ItemSelected(click_event);
761  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
762  EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
763  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
764  EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
765  // The second neither.
766  item1_controller->ItemSelected(click_event);
767  EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
768  EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
769  EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
770  EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
771}
772
773// Confirm that click behavior for app panels is correct.
774IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, AppPanelClickBehavior) {
775  // Enable experimental APIs to allow panel creation.
776  CommandLine::ForCurrentProcess()->AppendSwitch(
777      extensions::switches::kEnableExperimentalExtensionApis);
778  // Launch a platform app and create a panel window for it.
779  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
780  AppWindow::CreateParams params;
781  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
782  params.focused = false;
783  AppWindow* panel = CreateAppWindowFromParams(extension1, params);
784  EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
785  // Panels should not be active by default.
786  EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
787  // Confirm that a controller item was created and is the correct state.
788  const ash::ShelfItem& item1 = GetLastLauncherPanelItem();
789  LauncherItemController* item1_controller = GetItemController(item1.id);
790  EXPECT_EQ(ash::TYPE_APP_PANEL, item1.type);
791  EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
792  EXPECT_EQ(LauncherItemController::TYPE_APP_PANEL, item1_controller->type());
793  // Click the item and confirm that the panel is activated.
794  TestEvent click_event(ui::ET_MOUSE_PRESSED);
795  item1_controller->ItemSelected(click_event);
796  EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
797  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
798  // Click the item again and confirm that the panel is minimized.
799  item1_controller->ItemSelected(click_event);
800  EXPECT_TRUE(panel->GetBaseWindow()->IsMinimized());
801  EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
802  // Click the item again and confirm that the panel is activated.
803  item1_controller->ItemSelected(click_event);
804  EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
805  EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
806  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
807}
808
809IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, BrowserActivation) {
810  int item_count = shelf_model()->item_count();
811
812  // First run app.
813  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
814  CreateAppWindow(extension1);
815  ++item_count;
816  ASSERT_EQ(item_count, shelf_model()->item_count());
817  const ash::ShelfItem& item1 = GetLastLauncherItem();
818  ash::ShelfID item_id1 = item1.id;
819  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
820  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
821
822  ash::wm::ActivateWindow(browser()->window()->GetNativeWindow());
823  EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
824}
825
826// Test that opening an app sets the correct icon
827IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, SetIcon) {
828  TestAppWindowRegistryObserver test_observer(browser()->profile());
829
830  // Enable experimental APIs to allow panel creation.
831  CommandLine::ForCurrentProcess()->AppendSwitch(
832      extensions::switches::kEnableExperimentalExtensionApis);
833
834  int base_shelf_item_count = shelf_model()->item_count();
835  ExtensionTestMessageListener completed_listener("Completed", false);
836  LoadAndLaunchPlatformApp("app_icon", "Launched");
837  ASSERT_TRUE(completed_listener.WaitUntilSatisfied());
838
839  // Now wait until the WebContent has decoded the icons and chrome has
840  // processed it. This needs to be in a loop since the renderer runs in a
841  // different process.
842  while (test_observer.icon_updates() < 3) {
843    base::RunLoop run_loop;
844    run_loop.RunUntilIdle();
845  }
846
847  // This test creates one app window and one panel window.
848  int shelf_item_count = shelf_model()->item_count();
849  ASSERT_EQ(base_shelf_item_count + 2, shelf_item_count);
850  // The Panel will be the last item, the app second-to-last.
851  const ash::ShelfItem& app_item =
852      shelf_model()->items()[shelf_item_count - 2];
853  const ash::ShelfItem& panel_item =
854      shelf_model()->items()[shelf_item_count - 1];
855  const LauncherItemController* app_item_controller =
856      GetItemController(app_item.id);
857  const LauncherItemController* panel_item_controller =
858      GetItemController(panel_item.id);
859  // Icons for Apps are set by the AppWindowLauncherController, so
860  // image_set_by_controller() should be set.
861  EXPECT_TRUE(app_item_controller->image_set_by_controller());
862  EXPECT_TRUE(panel_item_controller->image_set_by_controller());
863  // Ensure icon heights are correct (see test.js in app_icon/ test directory)
864  EXPECT_EQ(ash::kShelfSize, app_item.image.height());
865  EXPECT_EQ(64, panel_item.image.height());
866}
867
868// Test that we can launch an app with a shortcut.
869IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchPinned) {
870  TabStripModel* tab_strip = browser()->tab_strip_model();
871  int tab_count = tab_strip->count();
872  ash::ShelfID shortcut_id = CreateShortcut("app1");
873  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
874  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
875  EXPECT_EQ(++tab_count, tab_strip->count());
876  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
877  WebContents* tab = tab_strip->GetActiveWebContents();
878  content::WebContentsDestroyedWatcher destroyed_watcher(tab);
879  browser()->tab_strip_model()->CloseSelectedTabs();
880  destroyed_watcher.Wait();
881  EXPECT_EQ(--tab_count, tab_strip->count());
882  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
883}
884
885// Launch the app first and then create the shortcut.
886IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchUnpinned) {
887  TabStripModel* tab_strip = browser()->tab_strip_model();
888  int tab_count = tab_strip->count();
889  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
890                         NEW_FOREGROUND_TAB);
891  EXPECT_EQ(++tab_count, tab_strip->count());
892  ash::ShelfID shortcut_id = CreateShortcut("app1");
893  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
894  WebContents* tab = tab_strip->GetActiveWebContents();
895  content::WebContentsDestroyedWatcher destroyed_watcher(tab);
896  browser()->tab_strip_model()->CloseSelectedTabs();
897  destroyed_watcher.Wait();
898  EXPECT_EQ(--tab_count, tab_strip->count());
899  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
900}
901
902// Launches an app in the background and then tries to open it. This is test for
903// a crash we had.
904IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchInBackground) {
905  TabStripModel* tab_strip = browser()->tab_strip_model();
906  int tab_count = tab_strip->count();
907  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
908                         NEW_BACKGROUND_TAB);
909  EXPECT_EQ(++tab_count, tab_strip->count());
910  ChromeLauncherController::instance()->LaunchApp(last_loaded_extension_id(),
911                                                  ash::LAUNCH_FROM_UNKNOWN,
912                                                  0);
913}
914
915// Confirm that clicking a icon for an app running in one of 2 maxmized windows
916// activates the right window.
917IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchMaximized) {
918  aura::Window* window1 = browser()->window()->GetNativeWindow();
919  ash::wm::WindowState* window1_state = ash::wm::GetWindowState(window1);
920  window1_state->Maximize();
921  content::WindowedNotificationObserver open_observer(
922      chrome::NOTIFICATION_BROWSER_WINDOW_READY,
923      content::NotificationService::AllSources());
924  chrome::NewEmptyWindow(browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH);
925  open_observer.Wait();
926  Browser* browser2 = content::Source<Browser>(open_observer.source()).ptr();
927  aura::Window* window2 = browser2->window()->GetNativeWindow();
928  TabStripModel* tab_strip = browser2->tab_strip_model();
929  int tab_count = tab_strip->count();
930  ash::wm::GetWindowState(window2)->Maximize();
931
932  ash::ShelfID shortcut_id = CreateShortcut("app1");
933  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
934  EXPECT_EQ(++tab_count, tab_strip->count());
935  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
936
937  window1->Show();
938  window1_state->Activate();
939  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
940
941  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
942  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
943}
944
945// Activating the same app multiple times should launch only a single copy.
946IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivateApp) {
947  TabStripModel* tab_strip = browser()->tab_strip_model();
948  int tab_count = tab_strip->count();
949  const Extension* extension =
950      LoadExtension(test_data_dir_.AppendASCII("app1"));
951
952  ChromeLauncherController::instance()->ActivateApp(extension->id(),
953                                                    ash::LAUNCH_FROM_UNKNOWN,
954                                                    0);
955  EXPECT_EQ(++tab_count, tab_strip->count());
956  ChromeLauncherController::instance()->ActivateApp(extension->id(),
957                                                    ash::LAUNCH_FROM_UNKNOWN,
958                                                    0);
959  EXPECT_EQ(tab_count, tab_strip->count());
960}
961
962// Launching the same app multiple times should launch a copy for each call.
963IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, LaunchApp) {
964  TabStripModel* tab_strip = browser()->tab_strip_model();
965  int tab_count = tab_strip->count();
966  const Extension* extension =
967      LoadExtension(test_data_dir_.AppendASCII("app1"));
968
969  ChromeLauncherController::instance()->LaunchApp(extension->id(),
970                                                  ash::LAUNCH_FROM_UNKNOWN,
971                                                  0);
972  EXPECT_EQ(++tab_count, tab_strip->count());
973  ChromeLauncherController::instance()->LaunchApp(extension->id(),
974                                                  ash::LAUNCH_FROM_UNKNOWN,
975                                                  0);
976  EXPECT_EQ(++tab_count, tab_strip->count());
977}
978
979// Launch 2 apps and toggle which is active.
980IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleApps) {
981  int item_count = model_->item_count();
982  TabStripModel* tab_strip = browser()->tab_strip_model();
983  int tab_count = tab_strip->count();
984  ash::ShelfID shortcut1 = CreateShortcut("app1");
985  EXPECT_EQ(++item_count, model_->item_count());
986  ash::ShelfID shortcut2 = CreateShortcut("app2");
987  EXPECT_EQ(++item_count, model_->item_count());
988
989  // Launch first app.
990  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
991  EXPECT_EQ(++tab_count, tab_strip->count());
992  WebContents* tab1 = tab_strip->GetActiveWebContents();
993  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
994
995  // Launch second app.
996  ActivateShelfItem(model_->ItemIndexByID(shortcut2));
997  EXPECT_EQ(++tab_count, tab_strip->count());
998  WebContents* tab2 = tab_strip->GetActiveWebContents();
999  ASSERT_NE(tab1, tab2);
1000  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
1001  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
1002
1003  // Reactivate first app.
1004  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
1005  EXPECT_EQ(tab_count, tab_strip->count());
1006  EXPECT_EQ(tab_strip->GetActiveWebContents(), tab1);
1007  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
1008  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
1009
1010  // Open second tab for second app. This should activate it.
1011  ui_test_utils::NavigateToURLWithDisposition(
1012      browser(),
1013      GURL("http://www.example.com/path3/foo.html"),
1014      NEW_FOREGROUND_TAB,
1015      0);
1016  EXPECT_EQ(++tab_count, tab_strip->count());
1017  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
1018  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
1019
1020  // Reactivate first app.
1021  ActivateShelfItem(model_->ItemIndexByID(shortcut1));
1022  EXPECT_EQ(tab_count, tab_strip->count());
1023  EXPECT_EQ(tab_strip->GetActiveWebContents(), tab1);
1024  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
1025  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
1026
1027  // And second again. This time the second tab should become active.
1028  ActivateShelfItem(model_->ItemIndexByID(shortcut2));
1029  EXPECT_EQ(tab_count, tab_strip->count());
1030  EXPECT_EQ(tab_strip->GetActiveWebContents(), tab2);
1031  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
1032  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
1033}
1034
1035// Confirm that a page can be navigated from and to while maintaining the
1036// correct running state.
1037IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, Navigation) {
1038  ash::ShelfID shortcut_id = CreateShortcut("app1");
1039  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
1040  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1041  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
1042
1043  // Navigate away.
1044  ui_test_utils::NavigateToURL(
1045      browser(), GURL("http://www.example.com/path0/bar.html"));
1046  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
1047
1048  // Navigate back.
1049  ui_test_utils::NavigateToURL(
1050      browser(), GURL("http://www.example.com/path1/foo.html"));
1051  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
1052}
1053
1054// Confirm that a tab can be moved between browsers while maintaining the
1055// correct running state.
1056IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, TabDragAndDrop) {
1057  TabStripModel* tab_strip_model1 = browser()->tab_strip_model();
1058  EXPECT_EQ(1, tab_strip_model1->count());
1059  int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
1060  EXPECT_TRUE(browser_index >= 0);
1061  EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1062
1063  // Create a shortcut for app1.
1064  ash::ShelfID shortcut_id = CreateShortcut("app1");
1065  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1066  EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
1067
1068  // Activate app1 and check its item status.
1069  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1070  EXPECT_EQ(2, tab_strip_model1->count());
1071  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
1072  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
1073
1074  // Create a new browser with blank tab.
1075  Browser* browser2 = CreateBrowser(profile());
1076  EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
1077  TabStripModel* tab_strip_model2 = browser2->tab_strip_model();
1078  EXPECT_EQ(1, tab_strip_model2->count());
1079  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1080  EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
1081
1082  // Detach a tab at index 1 (app1) from |tab_strip_model1| and insert it as an
1083  // active tab at index 1 to |tab_strip_model2|.
1084  content::WebContents* detached_tab = tab_strip_model1->DetachWebContentsAt(1);
1085  tab_strip_model2->InsertWebContentsAt(1,
1086                                        detached_tab,
1087                                        TabStripModel::ADD_ACTIVE);
1088  EXPECT_EQ(1, tab_strip_model1->count());
1089  EXPECT_EQ(2, tab_strip_model2->count());
1090  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
1091  EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
1092
1093  tab_strip_model1->CloseAllTabs();
1094  tab_strip_model2->CloseAllTabs();
1095}
1096
1097IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MultipleOwnedTabs) {
1098  TabStripModel* tab_strip = browser()->tab_strip_model();
1099  int tab_count = tab_strip->count();
1100  ash::ShelfID shortcut_id = CreateShortcut("app1");
1101  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1102  EXPECT_EQ(++tab_count, tab_strip->count());
1103  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1104  WebContents* first_tab = tab_strip->GetActiveWebContents();
1105
1106  // Create new tab owned by app.
1107  ui_test_utils::NavigateToURLWithDisposition(
1108      browser(),
1109      GURL("http://www.example.com/path2/bar.html"),
1110      NEW_FOREGROUND_TAB,
1111      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1112  EXPECT_EQ(++tab_count, tab_strip->count());
1113  // Confirm app is still active.
1114  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1115
1116  // Create new tab not owned by app.
1117  ui_test_utils::NavigateToURLWithDisposition(
1118      browser(),
1119      GURL("http://www.example.com/path3/foo.html"),
1120      NEW_FOREGROUND_TAB,
1121      0);
1122  EXPECT_EQ(++tab_count, tab_strip->count());
1123  // No longer active.
1124  EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
1125
1126  // Activating app makes first tab active again.
1127  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1128  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1129  EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
1130}
1131
1132IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, RefocusFilter) {
1133  TabStripModel* tab_strip = browser()->tab_strip_model();
1134  int tab_count = tab_strip->count();
1135  ash::ShelfID shortcut_id = CreateShortcut("app1");
1136  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1137  EXPECT_EQ(++tab_count, tab_strip->count());
1138  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1139  WebContents* first_tab = tab_strip->GetActiveWebContents();
1140
1141  controller_->SetRefocusURLPatternForTest(
1142      shortcut_id, GURL("http://www.example.com/path1/*"));
1143  // Create new tab owned by app.
1144  ui_test_utils::NavigateToURLWithDisposition(
1145      browser(),
1146      GURL("http://www.example.com/path2/bar.html"),
1147      NEW_FOREGROUND_TAB,
1148      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1149  EXPECT_EQ(++tab_count, tab_strip->count());
1150  // Confirm app is still active.
1151  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1152
1153  // Create new tab not owned by app.
1154  ui_test_utils::NavigateToURLWithDisposition(
1155      browser(),
1156      GURL("http://www.example.com/path3/foo.html"),
1157      NEW_FOREGROUND_TAB,
1158      0);
1159  EXPECT_EQ(++tab_count, tab_strip->count());
1160  // No longer active.
1161  EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
1162
1163  // Activating app makes first tab active again, because second tab isn't
1164  // in its refocus url path.
1165  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1166  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1167  EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
1168}
1169
1170IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, RefocusFilterLaunch) {
1171  TabStripModel* tab_strip = browser()->tab_strip_model();
1172  int tab_count = tab_strip->count();
1173  ash::ShelfID shortcut_id = CreateShortcut("app1");
1174  controller_->SetRefocusURLPatternForTest(
1175      shortcut_id, GURL("http://www.example.com/path1/*"));
1176
1177  // Create new tab.
1178  ui_test_utils::NavigateToURLWithDisposition(
1179      browser(),
1180      GURL("http://www.example2.com/path2/bar.html"),
1181      NEW_FOREGROUND_TAB,
1182      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1183  EXPECT_EQ(++tab_count, tab_strip->count());
1184  WebContents* first_tab = tab_strip->GetActiveWebContents();
1185  // Confirm app is not active.
1186  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1187
1188  // Activating app should launch new tab, because second tab isn't
1189  // in its refocus url path.
1190  ActivateShelfItem(model_->ItemIndexByID(shortcut_id));
1191  EXPECT_EQ(++tab_count, tab_strip->count());
1192  WebContents* second_tab = tab_strip->GetActiveWebContents();
1193  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1194  EXPECT_NE(first_tab, second_tab);
1195  EXPECT_EQ(tab_strip->GetActiveWebContents(), second_tab);
1196}
1197
1198// Check the launcher activation state for applications and browser.
1199IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivationStateCheck) {
1200  TabStripModel* tab_strip = browser()->tab_strip_model();
1201  // Get the browser item index
1202  int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
1203  EXPECT_TRUE(browser_index >= 0);
1204
1205  // Even though we are just comming up, the browser should be active.
1206  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1207
1208  ash::ShelfID shortcut_id = CreateShortcut("app1");
1209  controller_->SetRefocusURLPatternForTest(
1210      shortcut_id, GURL("http://www.example.com/path1/*"));
1211
1212  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1213  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1214
1215  // Create new tab which would be the running app.
1216  ui_test_utils::NavigateToURLWithDisposition(
1217      browser(),
1218      GURL("http://www.example.com/path1/bar.html"),
1219      NEW_FOREGROUND_TAB,
1220      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1221
1222  // There should never be two items active at the same time.
1223  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1224  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
1225
1226  tab_strip->ActivateTabAt(0, false);
1227  EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
1228  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1229
1230  tab_strip->CloseWebContentsAt(1, TabStripModel::CLOSE_NONE);
1231  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1232  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
1233
1234  ash::wm::DeactivateWindow(browser()->window()->GetNativeWindow());
1235  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1236  EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
1237}
1238
1239// Check that the launcher activation state for a V1 application stays closed
1240// even after an asynchronous browser event comes in after the tab got
1241// destroyed.
1242IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, AsyncActivationStateCheck) {
1243  TabStripModel* tab_strip = browser()->tab_strip_model();
1244
1245  ash::ShelfID shortcut_id = CreateShortcut("app1");
1246  controller_->SetRefocusURLPatternForTest(
1247      shortcut_id, GURL("http://www.example.com/path1/*"));
1248
1249  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1250
1251  // Create new tab which would be the running app.
1252  ui_test_utils::NavigateToURLWithDisposition(
1253      browser(),
1254      GURL("http://www.example.com/path1/bar.html"),
1255      NEW_FOREGROUND_TAB,
1256      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1257
1258  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
1259  // To address the issue of crbug.com/174050, the tab we are about to close
1260  // has to be active.
1261  tab_strip->ActivateTabAt(1, false);
1262  EXPECT_EQ(1, tab_strip->active_index());
1263
1264  // Close the web contents.
1265  tab_strip->CloseWebContentsAt(1, TabStripModel::CLOSE_NONE);
1266  // The status should now be set to closed.
1267  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
1268}
1269
1270// Checks that a windowed application does not add an item to the browser list.
1271IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
1272    WindowedAppDoesNotAddToBrowser) {
1273  // Get the number of items in the browser menu.
1274  size_t items = NumberOfDetectedLauncherBrowsers(false);
1275  size_t running_browser = chrome::GetTotalBrowserCount();
1276  EXPECT_EQ(0u, items);
1277  EXPECT_EQ(0u, running_browser);
1278
1279  LoadAndLaunchExtension(
1280      "app1", extensions::LAUNCH_CONTAINER_WINDOW, NEW_WINDOW);
1281
1282  // No new browser should get detected, even though one more is running.
1283  EXPECT_EQ(0u, NumberOfDetectedLauncherBrowsers(false));
1284  EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
1285
1286  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
1287
1288  // A new browser should get detected and one more should be running.
1289  EXPECT_EQ(NumberOfDetectedLauncherBrowsers(false), 1u);
1290  EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
1291}
1292
1293// Checks the functionality to enumerate all browsers vs. all tabs.
1294IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
1295                       EnumerateALlBrowsersAndTabs) {
1296  // Create at least one browser.
1297  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
1298  size_t browsers = NumberOfDetectedLauncherBrowsers(false);
1299  size_t tabs = NumberOfDetectedLauncherBrowsers(true);
1300
1301  // Create a second browser.
1302  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
1303
1304  EXPECT_EQ(++browsers, NumberOfDetectedLauncherBrowsers(false));
1305  EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
1306
1307  // Create only a tab.
1308  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB,
1309                         NEW_FOREGROUND_TAB);
1310
1311  EXPECT_EQ(browsers, NumberOfDetectedLauncherBrowsers(false));
1312  EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
1313}
1314
1315// Check that the keyboard activation of a launcher item tabs properly through
1316// the items at hand.
1317IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, AltNumberTabsTabbing) {
1318  TabStripModel* tab_strip = browser()->tab_strip_model();
1319
1320  ash::ShelfID shortcut_id = CreateShortcut("app");
1321  controller_->SetRefocusURLPatternForTest(
1322      shortcut_id, GURL("http://www.example.com/path/*"));
1323  std::string url = "http://www.example.com/path/bla";
1324
1325  int shortcut_index = model_->ItemIndexByID(shortcut_id);
1326
1327  // Create an application handled browser tab.
1328  ui_test_utils::NavigateToURLWithDisposition(
1329      browser(),
1330      GURL(url),
1331      NEW_FOREGROUND_TAB,
1332      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1333
1334  content::WebContents* content1 = tab_strip->GetActiveWebContents();
1335
1336  // Create some other browser tab.
1337  ui_test_utils::NavigateToURLWithDisposition(
1338      browser(),
1339      GURL("http://www.test.com"),
1340      NEW_FOREGROUND_TAB,
1341      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1342  content::WebContents* content1a = tab_strip->GetActiveWebContents();
1343
1344  // Make sure that the active tab is now our handled tab.
1345  EXPECT_NE(content1a, content1);
1346
1347  // The active tab should still be the unnamed tab. Then we switch and reach
1348  // the first app and stay there.
1349  EXPECT_EQ(content1a, tab_strip->GetActiveWebContents());
1350  ActivateShelfItem(shortcut_index);
1351  EXPECT_EQ(content1, tab_strip->GetActiveWebContents());
1352  ActivateShelfItem(shortcut_index);
1353  EXPECT_EQ(content1, tab_strip->GetActiveWebContents());
1354
1355  ui_test_utils::NavigateToURLWithDisposition(
1356      browser(),
1357      GURL(url),
1358      NEW_FOREGROUND_TAB,
1359      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1360  content::WebContents* content2 = tab_strip->GetActiveWebContents();
1361
1362  EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
1363  ActivateShelfItem(shortcut_index);
1364  EXPECT_EQ(content1, browser()->tab_strip_model()->GetActiveWebContents());
1365  ActivateShelfItem(shortcut_index);
1366  EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
1367}
1368
1369// Check that the keyboard activation of a launcher item tabs properly through
1370// the items at hand.
1371IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
1372                       AltNumberAppsTabbing) {
1373  // First run app.
1374  const Extension* extension1 = LoadAndLaunchPlatformApp("launch", "Launched");
1375  ui::BaseWindow* window1 = CreateAppWindow(extension1)->GetBaseWindow();
1376  const ash::ShelfItem& item1 = GetLastLauncherItem();
1377  ash::ShelfID app_id = item1.id;
1378  int app_index = shelf_model()->ItemIndexByID(app_id);
1379
1380  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
1381  EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
1382
1383  const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2",
1384                                                         "Launched");
1385  ui::BaseWindow* window2 = CreateAppWindow(extension2)->GetBaseWindow();
1386
1387  // By now the browser should be active. Issue Alt keystrokes several times to
1388  // see that we stay on that application.
1389  EXPECT_TRUE(window2->IsActive());
1390  ActivateShelfItem(app_index);
1391  EXPECT_TRUE(window1->IsActive());
1392  ActivateShelfItem(app_index);
1393  EXPECT_TRUE(window1->IsActive());
1394
1395  ui::BaseWindow* window1a = CreateAppWindow(extension1)->GetBaseWindow();
1396
1397  EXPECT_TRUE(window1a->IsActive());
1398  EXPECT_FALSE(window1->IsActive());
1399  ActivateShelfItem(app_index);
1400  EXPECT_TRUE(window1->IsActive());
1401  ActivateShelfItem(app_index);
1402  EXPECT_TRUE(window1a->IsActive());
1403}
1404
1405// Test that we can launch a platform app panel and get a running item.
1406IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPanelWindow) {
1407  int item_count = shelf_model()->item_count();
1408  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
1409  AppWindow::CreateParams params;
1410  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
1411  params.focused = false;
1412  AppWindow* window = CreateAppWindowFromParams(extension, params);
1413  ++item_count;
1414  ASSERT_EQ(item_count, shelf_model()->item_count());
1415  const ash::ShelfItem& item = GetLastLauncherPanelItem();
1416  EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
1417  // Opening a panel does not activate it.
1418  EXPECT_EQ(ash::STATUS_RUNNING, item.status);
1419  CloseAppWindow(window);
1420  --item_count;
1421  EXPECT_EQ(item_count, shelf_model()->item_count());
1422}
1423
1424// Test that we get correct shelf presence with hidden app windows.
1425IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, HiddenAppWindows) {
1426  int item_count = shelf_model()->item_count();
1427  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
1428  AppWindow::CreateParams params;
1429
1430  // Create a hidden window.
1431  params.hidden = true;
1432  AppWindow* window_1 = CreateAppWindowFromParams(extension, params);
1433  EXPECT_EQ(item_count, shelf_model()->item_count());
1434
1435  // Create a visible window.
1436  params.hidden = false;
1437  AppWindow* window_2 = CreateAppWindowFromParams(extension, params);
1438  ++item_count;
1439  EXPECT_EQ(item_count, shelf_model()->item_count());
1440
1441  // Minimize the visible window.
1442  window_2->Minimize();
1443  EXPECT_EQ(item_count, shelf_model()->item_count());
1444
1445  // Hide the visible window.
1446  window_2->Hide();
1447  --item_count;
1448  EXPECT_EQ(item_count, shelf_model()->item_count());
1449
1450  // Show the originally hidden window.
1451  window_1->Show(AppWindow::SHOW_ACTIVE);
1452  ++item_count;
1453  EXPECT_EQ(item_count, shelf_model()->item_count());
1454
1455  // Close the originally hidden window.
1456  CloseAppWindow(window_1);
1457  --item_count;
1458  EXPECT_EQ(item_count, shelf_model()->item_count());
1459}
1460
1461// Test attention states of windows.
1462IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowAttentionStatus) {
1463  const Extension* extension = LoadAndLaunchPlatformApp("launch", "Launched");
1464  AppWindow::CreateParams params;
1465  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
1466  params.focused = false;
1467  AppWindow* panel = CreateAppWindowFromParams(extension, params);
1468  EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
1469  // Panels should not be active by default.
1470  EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
1471  // Confirm that a controller item was created and is the correct state.
1472  const ash::ShelfItem& item = GetLastLauncherPanelItem();
1473  LauncherItemController* item_controller = GetItemController(item.id);
1474  EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
1475  EXPECT_EQ(ash::STATUS_RUNNING, item.status);
1476  EXPECT_EQ(LauncherItemController::TYPE_APP_PANEL, item_controller->type());
1477
1478  // App windows should go to attention state.
1479  panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
1480  EXPECT_EQ(ash::STATUS_ATTENTION, item.status);
1481
1482  // Click the item and confirm that the panel is activated.
1483  TestEvent click_event(ui::ET_MOUSE_PRESSED);
1484  item_controller->ItemSelected(click_event);
1485  EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
1486  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
1487
1488  // Active windows don't show attention.
1489  panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
1490  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
1491}
1492
1493// Checks that the browser Alt "tabbing" is properly done.
1494IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
1495                       AltNumberBrowserTabbing) {
1496  // Get the number of items in the browser menu.
1497  EXPECT_EQ(0u, chrome::GetTotalBrowserCount());
1498  // The first activation should create a browser at index 1 (App List @ 0).
1499  shelf_->ActivateShelfItem(1);
1500  EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1501  // A second activation should not create a new instance.
1502  shelf_->ActivateShelfItem(1);
1503  Browser* browser1 = chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());
1504  EXPECT_TRUE(browser1);
1505  aura::Window* window1 = browser1->window()->GetNativeWindow();
1506  Browser* browser2 = CreateBrowser(profile());
1507  aura::Window* window2 = browser2->window()->GetNativeWindow();
1508
1509  EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
1510  EXPECT_NE(window1, window2);
1511  EXPECT_EQ(window2, ash::wm::GetActiveWindow());
1512
1513  // Activate multiple times the switcher to see that the windows get activated.
1514  shelf_->ActivateShelfItem(1);
1515  EXPECT_EQ(window1, ash::wm::GetActiveWindow());
1516  shelf_->ActivateShelfItem(1);
1517  EXPECT_EQ(window2, ash::wm::GetActiveWindow());
1518
1519  // Create a third browser - make sure that we do not toggle simply between
1520  // two windows.
1521  Browser* browser3 = CreateBrowser(profile());
1522  aura::Window* window3 = browser3->window()->GetNativeWindow();
1523
1524  EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
1525  EXPECT_NE(window1, window3);
1526  EXPECT_NE(window2, window3);
1527  EXPECT_EQ(window3, ash::wm::GetActiveWindow());
1528
1529  shelf_->ActivateShelfItem(1);
1530  EXPECT_EQ(window1, ash::wm::GetActiveWindow());
1531  shelf_->ActivateShelfItem(1);
1532  EXPECT_EQ(window2, ash::wm::GetActiveWindow());
1533  shelf_->ActivateShelfItem(1);
1534  EXPECT_EQ(window3, ash::wm::GetActiveWindow());
1535  shelf_->ActivateShelfItem(1);
1536  EXPECT_EQ(window1, ash::wm::GetActiveWindow());
1537
1538  // Create anther app and make sure that none of our browsers is active.
1539  LoadAndLaunchExtension("app1", extensions::LAUNCH_CONTAINER_TAB, NEW_WINDOW);
1540  EXPECT_NE(window1, ash::wm::GetActiveWindow());
1541  EXPECT_NE(window2, ash::wm::GetActiveWindow());
1542
1543  // After activation our browser should be active again.
1544  shelf_->ActivateShelfItem(1);
1545  EXPECT_EQ(window1, ash::wm::GetActiveWindow());
1546}
1547
1548// Checks that after a session restore, we do not start applications on an
1549// activation.
1550IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ActivateAfterSessionRestore) {
1551  EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1552
1553  // Create a known application.
1554  ash::ShelfID shortcut_id = CreateShortcut("app1");
1555
1556  // Create a new browser - without activating it - and load an "app" into it.
1557  Browser::CreateParams params =
1558      Browser::CreateParams(profile(), chrome::GetActiveDesktop());
1559  params.initial_show_state = ui::SHOW_STATE_INACTIVE;
1560  Browser* browser2 = new Browser(params);
1561  controller_->SetRefocusURLPatternForTest(
1562      shortcut_id, GURL("http://www.example.com/path/*"));
1563  std::string url = "http://www.example.com/path/bla";
1564  ui_test_utils::NavigateToURLWithDisposition(
1565      browser2,
1566      GURL(url),
1567      NEW_FOREGROUND_TAB,
1568      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1569
1570  // Remember the number of tabs for each browser.
1571  TabStripModel* tab_strip = browser()->tab_strip_model();
1572  int tab_count1 = tab_strip->count();
1573  TabStripModel* tab_strip2 = browser2->tab_strip_model();
1574  int tab_count2 = tab_strip2->count();
1575
1576  // Check that we have two browsers and the inactive browser remained inactive.
1577  EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
1578  EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
1579            browser());
1580  // Check that the LRU browser list does only contain the original browser.
1581  BrowserList* ash_browser_list =
1582      BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
1583  BrowserList::const_reverse_iterator it =
1584      ash_browser_list->begin_last_active();
1585  EXPECT_EQ(*it, browser());
1586  ++it;
1587  EXPECT_EQ(it, ash_browser_list->end_last_active());
1588
1589  // Now request to either activate an existing app or create a new one.
1590  LauncherItemController* item_controller =
1591      controller_->GetLauncherItemController(shortcut_id);
1592  item_controller->ItemSelected(ui::KeyEvent(ui::ET_KEY_RELEASED,
1593                                        ui::VKEY_RETURN,
1594                                        ui::EF_NONE));
1595
1596  // Check that we have set focus on the existing application and nothing new
1597  // was created.
1598  EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
1599  EXPECT_EQ(tab_count1, tab_strip->count());
1600  EXPECT_EQ(tab_count2, tab_strip2->count());
1601  EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
1602            browser2);
1603}
1604
1605// Do various drag and drop interaction tests between the application list and
1606// the launcher.
1607// TODO(skuhne): Test is flaky with a real compositor: crbug.com/331924
1608IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, DISABLED_DragAndDrop) {
1609  // Get a number of interfaces we need.
1610  ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
1611                                     gfx::Point());
1612  ash::test::ShelfViewTestAPI test(
1613      ash::test::ShelfTestAPI(shelf_).shelf_view());
1614  AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
1615
1616  // There should be two items in our launcher by this time.
1617  EXPECT_EQ(2, model_->item_count());
1618  EXPECT_FALSE(service->IsAppListVisible());
1619
1620  // Open the app list menu and check that the drag and drop host was set.
1621  gfx::Rect app_list_bounds =
1622      test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
1623  generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
1624                        app_list_bounds.CenterPoint().y());
1625  base::MessageLoop::current()->RunUntilIdle();
1626  generator.ClickLeftButton();
1627
1628  EXPECT_TRUE(service->IsAppListVisible());
1629  app_list::AppsGridView* grid_view =
1630      ash::test::AppListControllerTestApi(ash::Shell::GetInstance()).
1631          GetRootGridView();
1632  ASSERT_TRUE(grid_view);
1633  ASSERT_TRUE(grid_view->has_drag_and_drop_host_for_test());
1634
1635  // There should be 2 items in our application list.
1636  const views::ViewModel* vm_grid = grid_view->view_model_for_test();
1637  EXPECT_EQ(2, vm_grid->view_size());
1638
1639  // Test #1: Drag an app list which does not exist yet item into the
1640  // launcher. Keeping it dragged, see that a new item gets created. Continuing
1641  // to drag it out should remove it again.
1642
1643  // Get over item #1 of the application list and press the mouse button.
1644  views::View* item1 = vm_grid->view_at(1);
1645  gfx::Rect bounds_grid_1 = item1->GetBoundsInScreen();
1646  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1647                        bounds_grid_1.CenterPoint().y());
1648  base::MessageLoop::current()->RunUntilIdle();
1649  generator.PressLeftButton();
1650
1651  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1652
1653  // Drag the item into the shelf and check that a new item gets created.
1654  const views::ViewModel* vm_shelf = test.shelf_view()->view_model_for_test();
1655  views::View* shelf1 = vm_shelf->view_at(1);
1656  gfx::Rect bounds_shelf_1 = shelf1->GetBoundsInScreen();
1657  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
1658                        bounds_shelf_1.CenterPoint().y());
1659  base::MessageLoop::current()->RunUntilIdle();
1660
1661  // Check that a new item got created.
1662  EXPECT_EQ(3, model_->item_count());
1663  EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1664
1665  // Move it where the item originally was and check that it disappears again.
1666  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1667                        bounds_grid_1.CenterPoint().y());
1668  base::MessageLoop::current()->RunUntilIdle();
1669  EXPECT_EQ(2, model_->item_count());
1670  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1671
1672  // Dropping it should keep the launcher as it originally was.
1673  generator.ReleaseLeftButton();
1674  base::MessageLoop::current()->RunUntilIdle();
1675  EXPECT_EQ(2, model_->item_count());
1676  // There are a few animations which need finishing before we can continue.
1677  test.RunMessageLoopUntilAnimationsDone();
1678  // Move the mouse outside of the launcher.
1679  generator.MoveMouseTo(0, 0);
1680
1681  // Test #2: Check that the unknown item dropped into the launcher will
1682  // create a new item.
1683  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1684                        bounds_grid_1.CenterPoint().y());
1685  generator.PressLeftButton();
1686  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
1687                        bounds_shelf_1.CenterPoint().y());
1688  base::MessageLoop::current()->RunUntilIdle();
1689  EXPECT_EQ(3, model_->item_count());
1690  EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1691  generator.ReleaseLeftButton();
1692  base::MessageLoop::current()->RunUntilIdle();
1693  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1694  EXPECT_EQ(3, model_->item_count());  // It should be still there.
1695  test.RunMessageLoopUntilAnimationsDone();
1696
1697  // Test #3: Check that the now known item dropped into the launcher will
1698  // not create a new item.
1699  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1700                        bounds_grid_1.CenterPoint().y());
1701  generator.PressLeftButton();
1702  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
1703                        bounds_shelf_1.CenterPoint().y());
1704  base::MessageLoop::current()->RunUntilIdle();
1705  EXPECT_EQ(3, model_->item_count());  // No new item got added.
1706  EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1707  generator.ReleaseLeftButton();
1708  base::MessageLoop::current()->RunUntilIdle();
1709  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1710  EXPECT_EQ(3, model_->item_count());  // And it remains that way.
1711
1712  // Test #4: Check that by pressing ESC the operation gets cancelled.
1713  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1714                        bounds_grid_1.CenterPoint().y());
1715  generator.PressLeftButton();
1716  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
1717                        bounds_shelf_1.CenterPoint().y());
1718  base::MessageLoop::current()->RunUntilIdle();
1719  // Issue an ESC and see that the operation gets cancelled.
1720  generator.PressKey(ui::VKEY_ESCAPE, 0);
1721  generator.ReleaseKey(ui::VKEY_ESCAPE, 0);
1722  EXPECT_FALSE(grid_view->dragging());
1723  EXPECT_FALSE(grid_view->has_dragged_view());
1724  generator.ReleaseLeftButton();
1725}
1726
1727#if !defined(OS_WIN)
1728// Used to test drag & drop an item between app list and shelf with multi
1729// display environment.
1730class ShelfAppBrowserTestWithMultiMonitor
1731    : public ShelfAppBrowserTestNoDefaultBrowser {
1732 protected:
1733  ShelfAppBrowserTestWithMultiMonitor() {}
1734  virtual ~ShelfAppBrowserTestWithMultiMonitor() {}
1735
1736  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
1737    ShelfAppBrowserTestNoDefaultBrowser::SetUpCommandLine(command_line);
1738    command_line->AppendSwitchASCII("ash-host-window-bounds",
1739                                    "800x600,801+0-800x600");
1740  }
1741
1742 private:
1743
1744  DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserTestWithMultiMonitor);
1745};
1746
1747// Do basic drag and drop interaction tests between the application list and
1748// the launcher in the secondary monitor.
1749IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestWithMultiMonitor,
1750    BasicDragAndDrop) {
1751  // Get a number of interfaces we need.
1752  DCHECK_EQ(ash::Shell::GetAllRootWindows().size(), 2U);
1753  aura::Window* secondary_root_window = ash::Shell::GetAllRootWindows()[1];
1754  ash::Shelf* secondary_shelf = ash::Shelf::ForWindow(secondary_root_window);
1755
1756  ui::test::EventGenerator generator(secondary_root_window, gfx::Point());
1757  ash::test::ShelfViewTestAPI test(
1758      ash::test::ShelfTestAPI(secondary_shelf).shelf_view());
1759  AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
1760
1761  // There should be two items in our shelf by this time.
1762  EXPECT_EQ(2, model_->item_count());
1763  EXPECT_FALSE(service->IsAppListVisible());
1764
1765  // Open the app list menu and check that the drag and drop host was set.
1766  gfx::Rect app_list_bounds =
1767      test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
1768  gfx::Display display =
1769      ash::Shell::GetScreen()->GetDisplayNearestWindow(secondary_root_window);
1770  const gfx::Point& origin = display.bounds().origin();
1771  app_list_bounds.Offset(-origin.x(), -origin.y());
1772
1773  generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
1774                        app_list_bounds.CenterPoint().y());
1775  base::MessageLoop::current()->RunUntilIdle();
1776  generator.ClickLeftButton();
1777
1778  EXPECT_TRUE(service->IsAppListVisible());
1779  app_list::AppsGridView* grid_view =
1780      ash::test::AppListControllerTestApi(ash::Shell::GetInstance()).
1781          GetRootGridView();
1782  ASSERT_TRUE(grid_view);
1783  ASSERT_TRUE(grid_view->has_drag_and_drop_host_for_test());
1784
1785  // There should be 2 items in our application list.
1786  const views::ViewModel* vm_grid = grid_view->view_model_for_test();
1787  EXPECT_EQ(2, vm_grid->view_size());
1788
1789  // Drag an app list item which does not exist yet in the shelf.
1790  // Keeping it dragged, see that a new item gets created.
1791  // Continuing to drag it out should remove it again.
1792
1793  // Get over item #1 of the application list and press the mouse button.
1794  views::View* item1 = vm_grid->view_at(1);
1795  gfx::Rect bounds_grid_1 = item1->GetBoundsInScreen();
1796  bounds_grid_1.Offset(-origin.x(), -origin.y());
1797  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1798                        bounds_grid_1.CenterPoint().y());
1799  base::MessageLoop::current()->RunUntilIdle();
1800  generator.PressLeftButton();
1801
1802  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1803
1804  // Drag the item into the shelf and check that a new item gets created.
1805  const views::ViewModel* vm_shelf = test.shelf_view()->view_model_for_test();
1806  views::View* shelf1 = vm_shelf->view_at(1);
1807  gfx::Rect bounds_shelf_1 = shelf1->GetBoundsInScreen();
1808  bounds_shelf_1.Offset(-origin.x(), -origin.y());
1809  generator.MoveMouseTo(bounds_shelf_1.CenterPoint().x(),
1810                        bounds_shelf_1.CenterPoint().y());
1811  base::MessageLoop::current()->RunUntilIdle();
1812
1813  // Check that a new item got created.
1814  EXPECT_EQ(3, model_->item_count());
1815  EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1816
1817  // Move it to an empty slot on grid_view.
1818  gfx::Rect empty_slot_rect = bounds_grid_1;
1819  empty_slot_rect.Offset(0, bounds_grid_1.height());
1820  generator.MoveMouseTo(empty_slot_rect.CenterPoint().x(),
1821                        empty_slot_rect.CenterPoint().y());
1822  base::MessageLoop::current()->RunUntilIdle();
1823  EXPECT_EQ(2, model_->item_count());
1824  EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
1825
1826  // Dropping it should keep the shelf as it originally was.
1827  generator.ReleaseLeftButton();
1828  base::MessageLoop::current()->RunUntilIdle();
1829  EXPECT_EQ(2, model_->item_count());
1830}
1831#endif
1832
1833// Do tests for removal of items from the shelf by dragging.
1834IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, DragOffShelf) {
1835  ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
1836                                     gfx::Point());
1837  ash::test::ShelfViewTestAPI test(
1838      ash::test::ShelfTestAPI(shelf_).shelf_view());
1839  test.SetAnimationDuration(1);  // Speed up animations for test.
1840  // Create a known application and check that we have 3 items in the shelf.
1841  CreateShortcut("app1");
1842  test.RunMessageLoopUntilAnimationsDone();
1843  EXPECT_EQ(3, model_->item_count());
1844
1845  // Test #1: Ripping out the browser item should not change anything.
1846  int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
1847  EXPECT_LE(0, browser_index);
1848  RipOffItemIndex(browser_index, &generator, &test, RIP_OFF_ITEM);
1849  // => It should not have been removed and the location should be unchanged.
1850  EXPECT_EQ(3, model_->item_count());
1851  EXPECT_EQ(browser_index,
1852            GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT));
1853  // Make sure that the hide state has been unset after the snap back animation
1854  // finished.
1855  ash::ShelfButton* button = test.GetButton(browser_index);
1856  EXPECT_FALSE(button->state() & ash::ShelfButton::STATE_HIDDEN);
1857
1858  // Test #2: Ripping out the application and canceling the operation should
1859  // not change anything.
1860  int app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
1861  EXPECT_LE(0, app_index);
1862  RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM_AND_CANCEL);
1863  // => It should not have been removed and the location should be unchanged.
1864  ASSERT_EQ(3, model_->item_count());
1865  EXPECT_EQ(app_index, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
1866
1867  // Test #3: Ripping out the application and moving it back in should not
1868  // change anything.
1869  RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM_AND_RETURN);
1870  // => It should not have been removed and the location should be unchanged.
1871  ASSERT_EQ(3, model_->item_count());
1872  // Through the operation the index might have changed.
1873  app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
1874
1875  // Test #4: Ripping out the application should remove the item.
1876  RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
1877  // => It should not have been removed and the location should be unchanged.
1878  EXPECT_EQ(2, model_->item_count());
1879  EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
1880
1881  // Test #5: Uninstalling an application while it is being ripped off should
1882  // not crash.
1883  ash::ShelfID app_id = CreateShortcut("app2");
1884  test.RunMessageLoopUntilAnimationsDone();
1885  int app2_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
1886  EXPECT_EQ(3, model_->item_count());  // And it remains that way.
1887  RipOffItemIndex(app2_index,
1888                  &generator,
1889                  &test,
1890                  RIP_OFF_ITEM_AND_DONT_RELEASE_MOUSE);
1891  RemoveShortcut(app_id);
1892  test.RunMessageLoopUntilAnimationsDone();
1893  EXPECT_EQ(2, model_->item_count());  // The item should now be gone.
1894  generator.ReleaseLeftButton();
1895  base::MessageLoop::current()->RunUntilIdle();
1896  EXPECT_EQ(2, model_->item_count());  // And it remains that way.
1897  EXPECT_EQ(-1, GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT));
1898
1899  // Test #6: Ripping out the application when the overflow button exists.
1900  // After ripping out, overflow button should be removed.
1901  int items_added = 0;
1902  EXPECT_FALSE(test.IsOverflowButtonVisible());
1903
1904  // Create fake app shortcuts until overflow button is created.
1905  while (!test.IsOverflowButtonVisible()) {
1906    std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
1907    PinFakeApp(fake_app_id);
1908    test.RunMessageLoopUntilAnimationsDone();
1909
1910    ++items_added;
1911    ASSERT_LT(items_added, 10000);
1912  }
1913  // Make one more item after creating a overflow button.
1914  std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
1915  PinFakeApp(fake_app_id);
1916  test.RunMessageLoopUntilAnimationsDone();
1917
1918  int total_count = model_->item_count();
1919  app_index = GetIndexOfShelfItemType(ash::TYPE_APP_SHORTCUT);
1920  RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
1921  // When an item is ripped off from the shelf that has overflow button
1922  // (see crbug.com/3050787), it was hidden accidentally and was then
1923  // suppressing any further events. If handled correctly the operation will
1924  // however correctly done and the item will get removed (as well as the
1925  // overflow button).
1926  EXPECT_EQ(total_count - 1, model_->item_count());
1927  EXPECT_TRUE(test.IsOverflowButtonVisible());
1928
1929  // Rip off again and the overflow button should has disappeared.
1930  RipOffItemIndex(app_index, &generator, &test, RIP_OFF_ITEM);
1931  EXPECT_EQ(total_count - 2, model_->item_count());
1932  EXPECT_FALSE(test.IsOverflowButtonVisible());
1933}
1934
1935// Check that clicking on an app shelf item launches a new browser.
1936IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, ClickItem) {
1937  // Get a number of interfaces we need.
1938  ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
1939                                     gfx::Point());
1940  ash::test::ShelfViewTestAPI test(
1941      ash::test::ShelfTestAPI(shelf_).shelf_view());
1942  AppListService* service = AppListService::Get(chrome::GetActiveDesktop());
1943  // There should be two items in our shelf by this time.
1944  EXPECT_EQ(2, model_->item_count());
1945  EXPECT_FALSE(service->IsAppListVisible());
1946
1947  // Open the app list menu and check that the drag and drop host was set.
1948  gfx::Rect app_list_bounds =
1949      test.shelf_view()->GetAppListButtonView()->GetBoundsInScreen();
1950  generator.MoveMouseTo(app_list_bounds.CenterPoint().x(),
1951                        app_list_bounds.CenterPoint().y());
1952  generator.ClickLeftButton();
1953  base::MessageLoop::current()->RunUntilIdle();
1954
1955  EXPECT_TRUE(service->IsAppListVisible());
1956  app_list::AppsGridView* grid_view =
1957      ash::test::AppListControllerTestApi(ash::Shell::GetInstance()).
1958          GetRootGridView();
1959  ASSERT_TRUE(grid_view);
1960  const views::ViewModel* vm_grid = grid_view->view_model_for_test();
1961  EXPECT_EQ(2, vm_grid->view_size());
1962  gfx::Rect bounds_grid_1 = vm_grid->view_at(1)->GetBoundsInScreen();
1963  // Test now that a click does create a new application tab.
1964  TabStripModel* tab_strip = browser()->tab_strip_model();
1965  int tab_count = tab_strip->count();
1966  generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
1967                        bounds_grid_1.CenterPoint().y());
1968  generator.ClickLeftButton();
1969  base::MessageLoop::current()->RunUntilIdle();
1970  EXPECT_EQ(tab_count + 1, tab_strip->count());
1971}
1972
1973// Check LauncherItemController of Browser Shortcut functionality.
1974IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTestNoDefaultBrowser,
1975                       BrowserShortcutLauncherItemController) {
1976  LauncherItemController* item_controller =
1977      controller_->GetBrowserShortcutLauncherItemController();
1978
1979  // Get the number of browsers.
1980  size_t running_browser = chrome::GetTotalBrowserCount();
1981  EXPECT_EQ(0u, running_browser);
1982  EXPECT_FALSE(item_controller->IsOpen());
1983
1984  // Activate. This creates new browser
1985  item_controller->Activate(ash::LAUNCH_FROM_UNKNOWN);
1986  // New Window is created.
1987  running_browser = chrome::GetTotalBrowserCount();
1988  EXPECT_EQ(1u, running_browser);
1989  EXPECT_TRUE(item_controller->IsOpen());
1990
1991  // Minimize Window.
1992  ash::wm::WindowState* window_state = ash::wm::GetActiveWindowState();
1993  window_state->Minimize();
1994  EXPECT_TRUE(window_state->IsMinimized());
1995
1996  // Activate again. This doesn't create new browser.
1997  // It activates window.
1998  item_controller->Activate(ash::LAUNCH_FROM_UNKNOWN);
1999  running_browser = chrome::GetTotalBrowserCount();
2000  EXPECT_EQ(1u, running_browser);
2001  EXPECT_TRUE(item_controller->IsOpen());
2002  EXPECT_FALSE(window_state->IsMinimized());
2003}
2004
2005// Check that GetShelfIDForWindow() returns |ShelfID| of the active tab.
2006IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, MatchingShelfIDandActiveTab) {
2007  EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
2008  EXPECT_EQ(1, browser()->tab_strip_model()->count());
2009  EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
2010  EXPECT_EQ(2, model_->item_count());
2011
2012  aura::Window* window = browser()->window()->GetNativeWindow();
2013
2014  int browser_index = GetIndexOfShelfItemType(ash::TYPE_BROWSER_SHORTCUT);
2015  ash::ShelfID browser_id = model_->items()[browser_index].id;
2016  EXPECT_EQ(browser_id, ash::GetShelfIDForWindow(window));
2017
2018  ash::ShelfID app_id = CreateShortcut("app1");
2019  EXPECT_EQ(3, model_->item_count());
2020
2021  // Creates a new tab for "app1" and checks that GetShelfIDForWindow()
2022  // returns |ShelfID| of "app1".
2023  ActivateShelfItem(model_->ItemIndexByID(app_id));
2024  EXPECT_EQ(2, browser()->tab_strip_model()->count());
2025  EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
2026  EXPECT_EQ(app_id, ash::GetShelfIDForWindow(window));
2027
2028  // Makes tab at index 0(NTP) as an active tab and checks that
2029  // GetShelfIDForWindow() returns |ShelfID| of browser shortcut.
2030  browser()->tab_strip_model()->ActivateTabAt(0, false);
2031  EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
2032  EXPECT_EQ(browser_id, ash::GetShelfIDForWindow(window));
2033}
2034
2035IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, OverflowBubble) {
2036  // Make sure to have a browser window
2037  chrome::NewTab(browser());
2038
2039  // No overflow yet.
2040  EXPECT_FALSE(shelf_->IsShowingOverflowBubble());
2041
2042  ash::test::ShelfViewTestAPI test(
2043      ash::test::ShelfTestAPI(shelf_).shelf_view());
2044
2045  int items_added = 0;
2046  while (!test.IsOverflowButtonVisible()) {
2047    std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
2048    PinFakeApp(fake_app_id);
2049
2050    ++items_added;
2051    ASSERT_LT(items_added, 10000);
2052  }
2053
2054  // Now show overflow bubble.
2055  test.ShowOverflowBubble();
2056  EXPECT_TRUE(shelf_->IsShowingOverflowBubble());
2057
2058  // Unpin first pinned app and there should be no crash.
2059  controller_->UnpinAppWithID(std::string("fake_app_0"));
2060
2061  test.RunMessageLoopUntilAnimationsDone();
2062  EXPECT_FALSE(shelf_->IsShowingOverflowBubble());
2063}
2064
2065// Check that a windowed V1 application can navigate away from its domain, but
2066// still gets detected properly.
2067IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, V1AppNavigation) {
2068  // We assume that the web store is always there (which it apparently is).
2069  controller_->PinAppWithID(extensions::kWebStoreAppId);
2070  ash::ShelfID id = controller_->GetShelfIDForAppID(
2071      extensions::kWebStoreAppId);
2072  ASSERT_NE(0, id);
2073  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
2074
2075  // Create a windowed application.
2076  AppLaunchParams params(
2077      profile(),
2078      controller_->GetExtensionForAppID(extensions::kWebStoreAppId),
2079      0,
2080      chrome::HOST_DESKTOP_TYPE_ASH);
2081  params.container = extensions::LAUNCH_CONTAINER_WINDOW;
2082  OpenApplication(params);
2083  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(id)->status);
2084
2085  // Find the browser which holds our app.
2086  Browser* app_browser = NULL;
2087  const BrowserList* ash_browser_list =
2088      BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
2089  for (BrowserList::const_reverse_iterator it =
2090           ash_browser_list->begin_last_active();
2091       it != ash_browser_list->end_last_active() && !app_browser; ++it) {
2092    if ((*it)->is_app()) {
2093      app_browser = *it;
2094      break;
2095    }
2096  }
2097  ASSERT_TRUE(app_browser);
2098
2099  // After navigating away in the app, we should still be active.
2100  ui_test_utils::NavigateToURL(app_browser,
2101                               GURL("http://www.foo.com/bar.html"));
2102  // Make sure the navigation was entirely performed.
2103  base::MessageLoop::current()->RunUntilIdle();
2104  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(id)->status);
2105  app_browser->tab_strip_model()->CloseWebContentsAt(0,
2106                                                     TabStripModel::CLOSE_NONE);
2107  // Make sure that the app is really gone.
2108  base::MessageLoop::current()->RunUntilIdle();
2109  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
2110}
2111
2112// Checks that a opening a settings window creates a new launcher item.
2113IN_PROC_BROWSER_TEST_F(ShelfAppBrowserTest, SettingsWindow) {
2114  chrome::SettingsWindowManager* settings_manager =
2115      chrome::SettingsWindowManager::GetInstance();
2116  ash::ShelfModel* shelf_model = ash::Shell::GetInstance()->shelf_model();
2117
2118  // Get the number of items in the shelf and browser menu.
2119  int item_count = shelf_model->item_count();
2120  size_t browser_count = NumberOfDetectedLauncherBrowsers(false);
2121
2122  // Open a settings window. Number of browser items should remain unchanged,
2123  // number of shelf items should increase.
2124  settings_manager->ShowChromePageForProfile(
2125      browser()->profile(),
2126      chrome::GetSettingsUrl(std::string()));
2127  Browser* settings_browser =
2128      settings_manager->FindBrowserForProfile(browser()->profile());
2129  ASSERT_TRUE(settings_browser);
2130  EXPECT_EQ(browser_count, NumberOfDetectedLauncherBrowsers(false));
2131  EXPECT_EQ(item_count + 1, shelf_model->item_count());
2132
2133  // TODO(stevenjb): Test multiprofile on Chrome OS when test support is addded.
2134  // crbug.com/230464.
2135}
2136