src/chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.cc

   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 <algorithm>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "ash/ash_switches.h"
  12 #include "ash/shelf/shelf_item_delegate_manager.h"
  13 #include "ash/shelf/shelf_model.h"
  14 #include "ash/shelf/shelf_model_observer.h"
  15 #include "ash/shell.h"
  16 #include "ash/test/shelf_item_delegate_manager_test_api.h"
  17 #include "base/command_line.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/files/file_path.h"
  20 #include "base/memory/scoped_ptr.h"
  21 #include "base/message_loop/message_loop.h"
  22 #include "base/strings/utf_string_conversions.h"
  23 #include "base/values.h"
  24 #include "chrome/browser/extensions/extension_service.h"
  25 #include "chrome/browser/extensions/test_extension_system.h"
  26 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
  27 #include "chrome/browser/ui/ash/launcher/app_window_launcher_item_controller.h"
  28 #include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h"
  29 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
  30 #include "chrome/browser/ui/browser.h"
  31 #include "chrome/browser/ui/browser_commands.h"
  32 #include "chrome/browser/ui/browser_finder.h"
  33 #include "chrome/browser/ui/browser_list.h"
  34 #include "chrome/browser/ui/browser_tabstrip.h"
  35 #include "chrome/browser/ui/host_desktop.h"
  36 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  37 #include "chrome/common/extensions/extension_constants.h"
  38 #include "chrome/common/pref_names.h"
  39 #include "chrome/test/base/browser_with_test_window_test.h"
  40 #include "chrome/test/base/testing_pref_service_syncable.h"
  41 #include "chrome/test/base/testing_profile.h"
  42 #include "content/public/browser/web_contents.h"
  43 #include "extensions/common/extension.h"
  44 #include "extensions/common/manifest_constants.h"
  45 #include "testing/gtest/include/gtest/gtest.h"
  46 #include "ui/aura/client/window_tree_client.h"
  47 #include "ui/base/models/menu_model.h"
  48
  49 #if defined(OS_CHROMEOS)
  50 #include "ash/test/test_session_state_delegate.h"
  51 #include "ash/test/test_shell_delegate.h"
  52 #include "chrome/browser/apps/scoped_keep_alive.h"
  53 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
  54 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
  55 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
  56 #include "chrome/browser/ui/ash/launcher/app_window_launcher_controller.h"
  57 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
  58 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
  59 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
  60 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.h"
  61 #include "chrome/common/chrome_constants.h"
  62 #include "chrome/common/chrome_switches.h"
  63 #include "chrome/test/base/testing_browser_process.h"
  64 #include "chrome/test/base/testing_profile_manager.h"
  65 #include "content/public/browser/web_contents_observer.h"
  66 #include "content/public/test/test_utils.h"
  67 #include "extensions/browser/app_window/app_window_contents.h"
  68 #include "extensions/browser/app_window/app_window_registry.h"
  69 #include "extensions/browser/app_window/native_app_window.h"
  70 #include "ui/aura/window.h"
  71 #endif
  72
  73 using base::ASCIIToUTF16;
  74 using extensions::Extension;
  75 using extensions::Manifest;
  76 using extensions::UnloadedExtensionInfo;
  77
  78 namespace {
  79 const char* offline_gmail_url = "https://mail.google.com/mail/mu/u";
  80 const char* gmail_url = "https://mail.google.com/mail/u";
  81 const char* kGmailLaunchURL = "https://mail.google.com/mail/ca";
  82
  83 #if defined(OS_CHROMEOS)
  84 // An extension prefix.
  85 const char kCrxAppPrefix[] = "_crx_";
  86 #endif
  87
  88 // ShelfModelObserver implementation that tracks what messages are invoked.
  89 class TestShelfModelObserver : public ash::ShelfModelObserver {
  90  public:
  91   TestShelfModelObserver()
  92     : added_(0),
  93       removed_(0),
  94       changed_(0) {
  95   }
  96
  97   virtual ~TestShelfModelObserver() {
  98   }
  99
 100   // Overridden from ash::ShelfModelObserver:
 101   virtual void ShelfItemAdded(int index) OVERRIDE {
 102     ++added_;
 103     last_index_ = index;
 104   }
 105
 106   virtual void ShelfItemRemoved(int index, ash::ShelfID id) OVERRIDE {
 107     ++removed_;
 108     last_index_ = index;
 109   }
 110
 111   virtual void ShelfItemChanged(int index,
 112                                 const ash::ShelfItem& old_item) OVERRIDE {
 113     ++changed_;
 114     last_index_ = index;
 115   }
 116
 117   virtual void ShelfItemMoved(int start_index, int target_index) OVERRIDE {
 118     last_index_ = target_index;
 119   }
 120
 121   virtual void ShelfStatusChanged() OVERRIDE {
 122   }
 123
 124   void clear_counts() {
 125     added_ = 0;
 126     removed_ = 0;
 127     changed_ = 0;
 128     last_index_ = 0;
 129   }
 130
 131   int added() const { return added_; }
 132   int removed() const { return removed_; }
 133   int changed() const { return changed_; }
 134   int last_index() const { return last_index_; }
 135
 136  private:
 137   int added_;
 138   int removed_;
 139   int changed_;
 140   int last_index_;
 141
 142   DISALLOW_COPY_AND_ASSIGN(TestShelfModelObserver);
 143 };
 144
 145 // Test implementation of AppIconLoader.
 146 class TestAppIconLoaderImpl : public extensions::AppIconLoader {
 147  public:
 148   TestAppIconLoaderImpl() : fetch_count_(0) {
 149   }
 150
 151   virtual ~TestAppIconLoaderImpl() {
 152   }
 153
 154   // AppIconLoader implementation:
 155   virtual void FetchImage(const std::string& id) OVERRIDE {
 156     ++fetch_count_;
 157   }
 158
 159   virtual void ClearImage(const std::string& id) OVERRIDE {
 160   }
 161
 162   virtual void UpdateImage(const std::string& id) OVERRIDE {
 163   }
 164
 165   int fetch_count() const { return fetch_count_; }
 166
 167  private:
 168   int fetch_count_;
 169
 170   DISALLOW_COPY_AND_ASSIGN(TestAppIconLoaderImpl);
 171 };
 172
 173 // Test implementation of AppTabHelper.
 174 class TestAppTabHelperImpl : public ChromeLauncherController::AppTabHelper {
 175  public:
 176   TestAppTabHelperImpl() {}
 177   virtual ~TestAppTabHelperImpl() {}
 178
 179   // Sets the id for the specified tab. The id is removed if Remove() is
 180   // invoked.
 181   void SetAppID(content::WebContents* tab, const std::string& id) {
 182     tab_id_map_[tab] = id;
 183   }
 184
 185   // Returns true if there is an id registered for |tab|.
 186   bool HasAppID(content::WebContents* tab) const {
 187     return tab_id_map_.find(tab) != tab_id_map_.end();
 188   }
 189
 190   // AppTabHelper implementation:
 191   virtual std::string GetAppID(content::WebContents* tab) OVERRIDE {
 192     return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
 193         std::string();
 194   }
 195
 196   virtual bool IsValidIDForCurrentUser(const std::string& id) OVERRIDE {
 197     for (TabToStringMap::const_iterator i = tab_id_map_.begin();
 198          i != tab_id_map_.end(); ++i) {
 199       if (i->second == id)
 200         return true;
 201     }
 202     return false;
 203   }
 204
 205   virtual void SetCurrentUser(Profile* profile) OVERRIDE {
 206     // We can ignore this for now.
 207   }
 208
 209  private:
 210   typedef std::map<content::WebContents*, std::string> TabToStringMap;
 211
 212   TabToStringMap tab_id_map_;
 213
 214   DISALLOW_COPY_AND_ASSIGN(TestAppTabHelperImpl);
 215 };
 216
 217 // Test implementation of a V2 app launcher item controller.
 218 class TestV2AppLauncherItemController : public LauncherItemController {
 219  public:
 220   TestV2AppLauncherItemController(const std::string& app_id,
 221                                   ChromeLauncherController* controller)
 222       : LauncherItemController(LauncherItemController::TYPE_APP,
 223                                app_id,
 224                                controller) {
 225   }
 226
 227   virtual ~TestV2AppLauncherItemController() {}
 228
 229   // Override for LauncherItemController:
 230   virtual bool IsOpen() const OVERRIDE { return true; }
 231   virtual bool IsVisible() const OVERRIDE { return true; }
 232   virtual void Launch(ash::LaunchSource source, int event_flags) OVERRIDE {}
 233   virtual bool Activate(ash::LaunchSource source) OVERRIDE { return false; }
 234   virtual void Close() OVERRIDE {}
 235   virtual bool ItemSelected(const ui::Event& event) OVERRIDE { return false; }
 236   virtual base::string16 GetTitle() OVERRIDE { return base::string16(); }
 237   virtual ChromeLauncherAppMenuItems GetApplicationList(
 238       int event_flags) OVERRIDE {
 239     ChromeLauncherAppMenuItems items;
 240     items.push_back(
 241         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
 242     items.push_back(
 243         new ChromeLauncherAppMenuItem(base::string16(), NULL, false));
 244     return items.Pass();
 245   }
 246   virtual ui::MenuModel* CreateContextMenu(aura::Window* root_window) OVERRIDE {
 247     return NULL;
 248   }
 249   virtual ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) OVERRIDE {
 250     return NULL;
 251   }
 252   virtual bool IsDraggable() OVERRIDE { return false; }
 253   virtual bool ShouldShowTooltip() OVERRIDE { return false; }
 254
 255  private:
 256   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 257 };
 258
 259 }  // namespace
 260
 261 class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
 262  protected:
 263   ChromeLauncherControllerTest()
 264       : BrowserWithTestWindowTest(
 265             Browser::TYPE_TABBED,
 266             chrome::HOST_DESKTOP_TYPE_ASH,
 267             false),
 268         test_controller_(NULL),
 269         extension_service_(NULL) {
 270   }
 271
 272   virtual ~ChromeLauncherControllerTest() {
 273   }
 274
 275   virtual void SetUp() OVERRIDE {
 276     BrowserWithTestWindowTest::SetUp();
 277
 278     model_.reset(new ash::ShelfModel);
 279     model_observer_.reset(new TestShelfModelObserver);
 280     model_->AddObserver(model_observer_.get());
 281
 282     if (ash::Shell::HasInstance()) {
 283       item_delegate_manager_ =
 284           ash::Shell::GetInstance()->shelf_item_delegate_manager();
 285     } else {
 286       item_delegate_manager_ =
 287           new ash::ShelfItemDelegateManager(model_.get());
 288     }
 289
 290     base::DictionaryValue manifest;
 291     manifest.SetString(extensions::manifest_keys::kName,
 292                        "launcher controller test extension");
 293     manifest.SetString(extensions::manifest_keys::kVersion, "1");
 294     manifest.SetString(extensions::manifest_keys::kDescription,
 295                        "for testing pinned apps");
 296
 297     extensions::TestExtensionSystem* extension_system(
 298         static_cast<extensions::TestExtensionSystem*>(
 299             extensions::ExtensionSystem::Get(profile())));
 300     extension_service_ = extension_system->CreateExtensionService(
 301         CommandLine::ForCurrentProcess(), base::FilePath(), false);
 302
 303     std::string error;
 304     extension1_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 305                                     manifest,
 306                                     Extension::NO_FLAGS,
 307                                     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
 308                                     &error);
 309     extension2_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 310                                     manifest,
 311                                     Extension::NO_FLAGS,
 312                                     "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
 313                                     &error);
 314     // Fake gmail extension.
 315     base::DictionaryValue manifest_gmail;
 316     manifest_gmail.SetString(extensions::manifest_keys::kName,
 317                              "Gmail launcher controller test extension");
 318     manifest_gmail.SetString(extensions::manifest_keys::kVersion, "1");
 319     manifest_gmail.SetString(extensions::manifest_keys::kDescription,
 320                              "for testing pinned Gmail");
 321     manifest_gmail.SetString(extensions::manifest_keys::kLaunchWebURL,
 322                              kGmailLaunchURL);
 323     base::ListValue* list = new base::ListValue();
 324     list->Append(new base::StringValue("*://mail.google.com/mail/ca"));
 325     manifest_gmail.Set(extensions::manifest_keys::kWebURLs, list);
 326
 327     extension3_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 328                                     manifest_gmail,
 329                                     Extension::NO_FLAGS,
 330                                     extension_misc::kGmailAppId,
 331                                     &error);
 332
 333     // Fake search extension.
 334     extension4_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 335                                     manifest,
 336                                     Extension::NO_FLAGS,
 337                                     extension_misc::kGoogleSearchAppId,
 338                                     &error);
 339     extension5_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 340                                     manifest,
 341                                     Extension::NO_FLAGS,
 342                                     "cccccccccccccccccccccccccccccccc",
 343                                     &error);
 344     extension6_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 345                                     manifest,
 346                                     Extension::NO_FLAGS,
 347                                     "dddddddddddddddddddddddddddddddd",
 348                                     &error);
 349     extension7_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 350                                     manifest,
 351                                     Extension::NO_FLAGS,
 352                                     "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
 353                                     &error);
 354     extension8_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
 355                                     manifest,
 356                                     Extension::NO_FLAGS,
 357                                     "ffffffffffffffffffffffffffffffff",
 358                                     &error);
 359   }
 360
 361   // Creates a running V2 app (not pinned) of type |app_id|.
 362   virtual void CreateRunningV2App(const std::string& app_id) {
 363     DCHECK(!test_controller_);
 364     ash::ShelfID id =
 365         launcher_controller_->CreateAppShortcutLauncherItemWithType(
 366             app_id,
 367             model_->item_count(),
 368             ash::TYPE_PLATFORM_APP);
 369     DCHECK(id);
 370     // Change the created launcher controller into a V2 app controller.
 371     test_controller_ = new TestV2AppLauncherItemController(app_id,
 372         launcher_controller_.get());
 373     launcher_controller_->SetItemController(id, test_controller_);
 374   }
 375
 376   // Sets the stage for a multi user test.
 377   virtual void SetUpMultiUserScenario(base::ListValue* user_a,
 378                                       base::ListValue* user_b) {
 379     InitLauncherController();
 380     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 381
 382     // Set an empty pinned pref to begin with.
 383     base::ListValue no_user;
 384     SetShelfChromeIconIndex(0);
 385     profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
 386                                                     no_user.DeepCopy());
 387     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 388
 389     // Assume all applications have been added already.
 390     extension_service_->AddExtension(extension1_.get());
 391     extension_service_->AddExtension(extension2_.get());
 392     extension_service_->AddExtension(extension3_.get());
 393     extension_service_->AddExtension(extension4_.get());
 394     extension_service_->AddExtension(extension5_.get());
 395     extension_service_->AddExtension(extension6_.get());
 396     extension_service_->AddExtension(extension7_.get());
 397     extension_service_->AddExtension(extension8_.get());
 398     // There should be nothing in the list by now.
 399     EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 400
 401     // Set user a preferences.
 402     InsertPrefValue(user_a, 0, extension1_->id());
 403     InsertPrefValue(user_a, 1, extension2_->id());
 404     InsertPrefValue(user_a, 2, extension3_->id());
 405     InsertPrefValue(user_a, 3, extension4_->id());
 406     InsertPrefValue(user_a, 4, extension5_->id());
 407     InsertPrefValue(user_a, 5, extension6_->id());
 408
 409     // Set user b preferences.
 410     InsertPrefValue(user_b, 0, extension7_->id());
 411     InsertPrefValue(user_b, 1, extension8_->id());
 412   }
 413
 414   virtual void TearDown() OVERRIDE {
 415     if (!ash::Shell::HasInstance())
 416       delete item_delegate_manager_;
 417     model_->RemoveObserver(model_observer_.get());
 418     model_observer_.reset();
 419     launcher_controller_.reset();
 420     model_.reset();
 421
 422     BrowserWithTestWindowTest::TearDown();
 423   }
 424
 425   void AddAppListLauncherItem() {
 426     ash::ShelfItem app_list;
 427     app_list.type = ash::TYPE_APP_LIST;
 428     model_->Add(app_list);
 429   }
 430
 431   void InitLauncherController() {
 432     AddAppListLauncherItem();
 433     launcher_controller_.reset(
 434         new ChromeLauncherController(profile(), model_.get()));
 435     if (!ash::Shell::HasInstance())
 436       SetShelfItemDelegateManager(item_delegate_manager_);
 437     launcher_controller_->Init();
 438   }
 439
 440   void InitLauncherControllerWithBrowser() {
 441     chrome::NewTab(browser());
 442     BrowserList::SetLastActive(browser());
 443     InitLauncherController();
 444   }
 445
 446   void SetAppIconLoader(extensions::AppIconLoader* loader) {
 447     launcher_controller_->SetAppIconLoaderForTest(loader);
 448   }
 449
 450   void SetAppTabHelper(ChromeLauncherController::AppTabHelper* helper) {
 451     launcher_controller_->SetAppTabHelperForTest(helper);
 452   }
 453
 454   void SetShelfItemDelegateManager(ash::ShelfItemDelegateManager* manager) {
 455     launcher_controller_->SetShelfItemDelegateManagerForTest(manager);
 456   }
 457
 458   void InsertPrefValue(base::ListValue* pref_value,
 459                        int index,
 460                        const std::string& extension_id) {
 461     base::DictionaryValue* entry = new base::DictionaryValue();
 462     entry->SetString(ash::kPinnedAppsPrefAppIDPath, extension_id);
 463     pref_value->Insert(index, entry);
 464   }
 465
 466   // Gets the currently configured app launchers from the controller.
 467   void GetAppLaunchers(ChromeLauncherController* controller,
 468                        std::vector<std::string>* launchers) {
 469     launchers->clear();
 470     for (ash::ShelfItems::const_iterator iter(model_->items().begin());
 471          iter != model_->items().end(); ++iter) {
 472       ChromeLauncherController::IDToItemControllerMap::const_iterator
 473           entry(controller->id_to_item_controller_map_.find(iter->id));
 474       if (iter->type == ash::TYPE_APP_SHORTCUT &&
 475           entry != controller->id_to_item_controller_map_.end()) {
 476         launchers->push_back(entry->second->app_id());
 477       }
 478     }
 479   }
 480
 481   // Get the setup of the currently shown launcher items in one string.
 482   // Each pinned element will start with a big letter, each running but not
 483   // pinned V1 app will start with a small letter and each running but not
 484   // pinned V2 app will start with a '*' + small letter.
 485   std::string GetPinnedAppStatus() {
 486     std::string result;
 487     for (int i = 0; i < model_->item_count(); i++) {
 488       if (!result.empty())
 489         result.append(", ");
 490       switch (model_->items()[i].type) {
 491         case ash::TYPE_PLATFORM_APP:
 492             result+= "*";
 493             // FALLTHROUGH
 494         case ash::TYPE_WINDOWED_APP: {
 495           const std::string& app =
 496               launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
 497             if (app == extension1_->id()) {
 498               result += "app1";
 499               EXPECT_FALSE(
 500                   launcher_controller_->IsAppPinned(extension1_->id()));
 501             } else if (app == extension2_->id()) {
 502               result += "app2";
 503               EXPECT_FALSE(
 504                   launcher_controller_->IsAppPinned(extension2_->id()));
 505             } else if (app == extension3_->id()) {
 506               result += "app3";
 507               EXPECT_FALSE(
 508                   launcher_controller_->IsAppPinned(extension3_->id()));
 509             } else if (app == extension4_->id()) {
 510               result += "app4";
 511               EXPECT_FALSE(
 512                   launcher_controller_->IsAppPinned(extension4_->id()));
 513             } else if (app == extension5_->id()) {
 514               result += "app5";
 515               EXPECT_FALSE(
 516                   launcher_controller_->IsAppPinned(extension5_->id()));
 517             } else if (app == extension6_->id()) {
 518               result += "app6";
 519               EXPECT_FALSE(
 520                   launcher_controller_->IsAppPinned(extension6_->id()));
 521             } else if (app == extension7_->id()) {
 522               result += "app7";
 523               EXPECT_FALSE(
 524                   launcher_controller_->IsAppPinned(extension7_->id()));
 525             } else if (app == extension8_->id()) {
 526               result += "app8";
 527               EXPECT_FALSE(
 528                   launcher_controller_->IsAppPinned(extension8_->id()));
 529             } else {
 530               result += "unknown";
 531             }
 532             break;
 533           }
 534         case ash::TYPE_APP_SHORTCUT: {
 535           const std::string& app =
 536               launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
 537             if (app == extension1_->id()) {
 538               result += "App1";
 539               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
 540             } else if (app == extension2_->id()) {
 541               result += "App2";
 542               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
 543             } else if (app == extension3_->id()) {
 544               result += "App3";
 545               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
 546             } else if (app == extension4_->id()) {
 547               result += "App4";
 548               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
 549             } else if (app == extension5_->id()) {
 550               result += "App5";
 551               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension5_->id()));
 552             } else if (app == extension6_->id()) {
 553               result += "App6";
 554               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension6_->id()));
 555             } else if (app == extension7_->id()) {
 556               result += "App7";
 557               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension7_->id()));
 558             } else if (app == extension8_->id()) {
 559               result += "App8";
 560               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension8_->id()));
 561             } else {
 562               result += "unknown";
 563             }
 564             break;
 565           }
 566         case ash::TYPE_BROWSER_SHORTCUT:
 567           result += "Chrome";
 568           break;
 569         case ash::TYPE_APP_LIST:
 570           result += "AppList";
 571           break;
 572         default:
 573           result += "Unknown";
 574           break;
 575       }
 576     }
 577     return result;
 578   }
 579
 580   // Set the index at which the chrome icon should be.
 581   void SetShelfChromeIconIndex(int index) {
 582     profile()->GetTestingPrefService()->SetInteger(prefs::kShelfChromeIconIndex,
 583                                                    index);
 584   }
 585
 586   // Remember the order of unpinned but running applications for the current
 587   // user.
 588   void RememberUnpinnedRunningApplicationOrder() {
 589     launcher_controller_->RememberUnpinnedRunningApplicationOrder();
 590   }
 591
 592   // Restore the order of running but unpinned applications for a given user.
 593   void RestoreUnpinnedRunningApplicationOrder(const std::string& user_id) {
 594     launcher_controller_->RestoreUnpinnedRunningApplicationOrder(user_id);
 595   }
 596
 597   // Needed for extension service & friends to work.
 598   scoped_refptr<Extension> extension1_;
 599   scoped_refptr<Extension> extension2_;
 600   scoped_refptr<Extension> extension3_;
 601   scoped_refptr<Extension> extension4_;
 602   scoped_refptr<Extension> extension5_;
 603   scoped_refptr<Extension> extension6_;
 604   scoped_refptr<Extension> extension7_;
 605   scoped_refptr<Extension> extension8_;
 606   scoped_ptr<ChromeLauncherController> launcher_controller_;
 607   scoped_ptr<TestShelfModelObserver> model_observer_;
 608   scoped_ptr<ash::ShelfModel> model_;
 609
 610   // |item_delegate_manager_| owns |test_controller_|.
 611   LauncherItemController* test_controller_;
 612
 613   ExtensionService* extension_service_;
 614
 615   ash::ShelfItemDelegateManager* item_delegate_manager_;
 616
 617  private:
 618   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
 619 };
 620
 621 #if defined(OS_CHROMEOS)
 622 // A browser window proxy which is able to associate an aura native window with
 623 // it.
 624 class TestBrowserWindowAura : public TestBrowserWindow {
 625  public:
 626   // |native_window| will still be owned by the caller after the constructor
 627   // was called.
 628   explicit TestBrowserWindowAura(aura::Window* native_window)
 629       : native_window_(native_window) {
 630   }
 631   virtual ~TestBrowserWindowAura() {}
 632
 633   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE {
 634     return native_window_.get();
 635   }
 636
 637   Browser* browser() { return browser_.get(); }
 638
 639   void CreateBrowser(const Browser::CreateParams& params) {
 640     Browser::CreateParams create_params = params;
 641     create_params.window = this;
 642     browser_.reset(new Browser(create_params));
 643   }
 644
 645  private:
 646   scoped_ptr<Browser> browser_;
 647   scoped_ptr<aura::Window> native_window_;
 648
 649   DISALLOW_COPY_AND_ASSIGN(TestBrowserWindowAura);
 650 };
 651
 652 // Creates a test browser window which has a native window.
 653 scoped_ptr<TestBrowserWindowAura> CreateTestBrowserWindow(
 654     const Browser::CreateParams& params) {
 655   // Create a window.
 656   aura::Window* window = new aura::Window(NULL);
 657   window->set_id(0);
 658   window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
 659   window->Init(aura::WINDOW_LAYER_TEXTURED);
 660   window->Show();
 661
 662   scoped_ptr<TestBrowserWindowAura> browser_window(
 663       new TestBrowserWindowAura(window));
 664   browser_window->CreateBrowser(params);
 665   return browser_window.Pass();
 666 }
 667
 668 // Watches WebContents and blocks until it is destroyed. This is needed for
 669 // the destruction of a V2 application.
 670 class WebContentsDestroyedWatcher : public content::WebContentsObserver {
 671  public:
 672   explicit WebContentsDestroyedWatcher(content::WebContents* web_contents)
 673       : content::WebContentsObserver(web_contents),
 674         message_loop_runner_(new content::MessageLoopRunner) {
 675     EXPECT_TRUE(web_contents != NULL);
 676   }
 677   virtual ~WebContentsDestroyedWatcher() {}
 678
 679   // Waits until the WebContents is destroyed.
 680   void Wait() {
 681     message_loop_runner_->Run();
 682   }
 683
 684  private:
 685   // Overridden WebContentsObserver methods.
 686   virtual void WebContentsDestroyed() OVERRIDE {
 687     message_loop_runner_->Quit();
 688   }
 689
 690   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 691
 692   DISALLOW_COPY_AND_ASSIGN(WebContentsDestroyedWatcher);
 693 };
 694
 695 // A V1 windowed application.
 696 class V1App : public TestBrowserWindow {
 697  public:
 698   V1App(Profile* profile, const std::string& app_name) {
 699     // Create a window.
 700     native_window_.reset(new aura::Window(NULL));
 701     native_window_->set_id(0);
 702     native_window_->SetType(ui::wm::WINDOW_TYPE_POPUP);
 703     native_window_->Init(aura::WINDOW_LAYER_TEXTURED);
 704     native_window_->Show();
 705     aura::client::ParentWindowWithContext(native_window_.get(),
 706                                           ash::Shell::GetPrimaryRootWindow(),
 707                                           gfx::Rect(10, 10, 20, 30));
 708     Browser::CreateParams params =
 709         Browser::CreateParams::CreateForApp(kCrxAppPrefix + app_name,
 710                                             true /* trusted_source */,
 711                                             gfx::Rect(),
 712                                             profile,
 713                                             chrome::HOST_DESKTOP_TYPE_ASH);
 714     params.window = this;
 715     browser_.reset(new Browser(params));
 716     chrome::AddTabAt(browser_.get(), GURL(), 0, true);
 717   }
 718
 719   virtual ~V1App() {
 720     // close all tabs. Note that we do not need to destroy the browser itself.
 721     browser_->tab_strip_model()->CloseAllTabs();
 722   }
 723
 724   Browser* browser() { return browser_.get(); }
 725
 726   // TestBrowserWindow override:
 727   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE {
 728     return native_window_.get();
 729   }
 730
 731  private:
 732   // The associated browser with this app.
 733   scoped_ptr<Browser> browser_;
 734
 735   // The native window we use.
 736   scoped_ptr<aura::Window> native_window_;
 737
 738   DISALLOW_COPY_AND_ASSIGN(V1App);
 739 };
 740
 741 // A V2 application which gets created with an |extension| and for a |profile|.
 742 // Upon destruction it will properly close the application.
 743 class V2App {
 744  public:
 745   V2App(Profile* profile, const extensions::Extension* extension) {
 746     window_ = new extensions::AppWindow(
 747         profile,
 748         new ChromeAppDelegate(make_scoped_ptr(new ScopedKeepAlive)),
 749         extension);
 750     extensions::AppWindow::CreateParams params =
 751         extensions::AppWindow::CreateParams();
 752     window_->Init(GURL(std::string()),
 753                   new extensions::AppWindowContentsImpl(window_), params);
 754   }
 755
 756   virtual ~V2App() {
 757     WebContentsDestroyedWatcher destroyed_watcher(window_->web_contents());
 758     window_->GetBaseWindow()->Close();
 759     destroyed_watcher.Wait();
 760   }
 761
 762   extensions::AppWindow* window() { return window_; }
 763
 764  private:
 765   // The app window which represents the application. Note that the window
 766   // deletes itself asynchronously after window_->GetBaseWindow()->Close() gets
 767   // called.
 768   extensions::AppWindow* window_;
 769
 770   DISALLOW_COPY_AND_ASSIGN(V2App);
 771 };
 772
 773 // The testing framework to test multi profile scenarios.
 774 class MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest
 775     : public ChromeLauncherControllerTest {
 776  protected:
 777   MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
 778   }
 779
 780   virtual ~MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest() {
 781   }
 782
 783   // Overwrite the Setup function to enable multi profile and needed objects.
 784   virtual void SetUp() OVERRIDE {
 785     profile_manager_.reset(
 786         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
 787
 788     ASSERT_TRUE(profile_manager_->SetUp());
 789
 790     // AvatarMenu and multiple profiles works after user logged in.
 791     profile_manager_->SetLoggedIn(true);
 792
 793     // Initialize the UserManager singleton to a fresh FakeUserManager instance.
 794     user_manager_enabler_.reset(
 795         new chromeos::ScopedUserManagerEnabler(new chromeos::FakeUserManager));
 796
 797     // Initialize the rest.
 798     ChromeLauncherControllerTest::SetUp();
 799
 800     // Get some base objects.
 801     session_delegate()->set_logged_in_users(2);
 802     shell_delegate_ = static_cast<ash::test::TestShellDelegate*>(
 803         ash::Shell::GetInstance()->delegate());
 804     shell_delegate_->set_multi_profiles_enabled(true);
 805   }
 806
 807   virtual void TearDown() {
 808     ChromeLauncherControllerTest::TearDown();
 809     user_manager_enabler_.reset();
 810     for (ProfileToNameMap::iterator it = created_profiles_.begin();
 811          it != created_profiles_.end(); ++it)
 812       profile_manager_->DeleteTestingProfile(it->second);
 813
 814     // A Task is leaked if we don't destroy everything, then run the message
 815     // loop.
 816     base::MessageLoop::current()->PostTask(FROM_HERE,
 817                                            base::MessageLoop::QuitClosure());
 818     base::MessageLoop::current()->Run();
 819   }
 820
 821   // Creates a profile for a given |user_name|. Note that this class will keep
 822   // the ownership of the created object.
 823   TestingProfile* CreateMultiUserProfile(const std::string& user_name) {
 824     std::string email_string = user_name + "@example.com";
 825     static_cast<ash::test::TestSessionStateDelegate*>(
 826         ash::Shell::GetInstance()->session_state_delegate())
 827         ->AddUser(email_string);
 828     // Add a user to the fake user manager.
 829     session_delegate()->AddUser(email_string);
 830     GetFakeUserManager()->AddUser(email_string);
 831
 832     GetFakeUserManager()->LoginUser(email_string);
 833
 834     TestingProfile* profile =
 835         profile_manager()->CreateTestingProfile(email_string);
 836     EXPECT_TRUE(profile);
 837
 838     // Remember the profile name so that we can destroy it upon destruction.
 839     created_profiles_[profile] = email_string;
 840     if (chrome::MultiUserWindowManager::GetInstance())
 841       chrome::MultiUserWindowManager::GetInstance()->AddUser(profile);
 842     if (launcher_controller_)
 843       launcher_controller_->AdditionalUserAddedToSession(profile);
 844     return profile;
 845   }
 846
 847   // Switch to another user.
 848   void SwitchActiveUser(const std::string& name) {
 849     session_delegate()->SwitchActiveUser(name);
 850     GetFakeUserManager()->SwitchActiveUser(name);
 851     chrome::MultiUserWindowManagerChromeOS* manager =
 852         static_cast<chrome::MultiUserWindowManagerChromeOS*>(
 853             chrome::MultiUserWindowManager::GetInstance());
 854     manager->SetAnimationSpeedForTest(
 855         chrome::MultiUserWindowManagerChromeOS::ANIMATION_SPEED_DISABLED);
 856     manager->ActiveUserChanged(name);
 857     launcher_controller_->browser_status_monitor_for_test()->
 858         ActiveUserChanged(name);
 859     launcher_controller_->app_window_controller_for_test()->
 860         ActiveUserChanged(name);
 861   }
 862
 863   // Creates a browser with a |profile| and load a tab with a |title| and |url|.
 864   Browser* CreateBrowserAndTabWithProfile(Profile* profile,
 865                                           const std::string& title,
 866                                           const std::string& url) {
 867     Browser::CreateParams params(profile, chrome::HOST_DESKTOP_TYPE_ASH);
 868     Browser* browser = chrome::CreateBrowserWithTestWindowForParams(&params);
 869     chrome::NewTab(browser);
 870
 871     BrowserList::SetLastActive(browser);
 872     NavigateAndCommitActiveTabWithTitle(
 873         browser, GURL(url), ASCIIToUTF16(title));
 874     return browser;
 875   }
 876
 877   // Creates a running V1 application.
 878   // Note that with the use of the app_tab_helper as done below, this is only
 879   // usable with a single v1 application.
 880   V1App* CreateRunningV1App(Profile* profile,
 881                             const std::string& app_name,
 882                             const std::string& url) {
 883     V1App* v1_app = new V1App(profile, app_name);
 884     // Create a new app tab helper and assign it to the launcher so that this
 885     // app gets properly detected.
 886     // TODO(skuhne): Create a more intelligent app tab helper which is able to
 887     // detect all running apps properly.
 888     TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
 889     app_tab_helper->SetAppID(
 890         v1_app->browser()->tab_strip_model()->GetWebContentsAt(0),
 891         app_name);
 892     SetAppTabHelper(app_tab_helper);
 893
 894     NavigateAndCommitActiveTabWithTitle(
 895         v1_app->browser(), GURL(url), ASCIIToUTF16(""));
 896     return v1_app;
 897   }
 898
 899   ash::test::TestSessionStateDelegate* session_delegate() {
 900     return static_cast<ash::test::TestSessionStateDelegate*>(
 901         ash::Shell::GetInstance()->session_state_delegate());
 902   }
 903   ash::test::TestShellDelegate* shell_delegate() { return shell_delegate_; }
 904
 905   // Override BrowserWithTestWindowTest:
 906   virtual TestingProfile* CreateProfile() OVERRIDE {
 907     return CreateMultiUserProfile("user1");
 908   }
 909   virtual void DestroyProfile(TestingProfile* profile) OVERRIDE {
 910     // Delete the profile through our profile manager.
 911     ProfileToNameMap::iterator it = created_profiles_.find(profile);
 912     DCHECK(it != created_profiles_.end());
 913     profile_manager_->DeleteTestingProfile(it->second);
 914     created_profiles_.erase(it);
 915   }
 916
 917  private:
 918   typedef std::map<Profile*, std::string> ProfileToNameMap;
 919   TestingProfileManager* profile_manager() { return profile_manager_.get(); }
 920
 921   chromeos::FakeUserManager* GetFakeUserManager() {
 922     return static_cast<chromeos::FakeUserManager*>(
 923         user_manager::UserManager::Get());
 924   }
 925
 926   scoped_ptr<TestingProfileManager> profile_manager_;
 927   scoped_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 928
 929   ash::test::TestShellDelegate* shell_delegate_;
 930
 931   ProfileToNameMap created_profiles_;
 932
 933   DISALLOW_COPY_AND_ASSIGN(
 934       MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest);
 935 };
 936 #endif  // defined(OS_CHROMEOS)
 937
 938
 939 TEST_F(ChromeLauncherControllerTest, DefaultApps) {
 940   InitLauncherController();
 941   // Model should only contain the browser shortcut and app list items.
 942   EXPECT_EQ(2, model_->item_count());
 943   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
 944   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 945   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 946
 947   // Installing |extension3_| should add it to the launcher - behind the
 948   // chrome icon.
 949   extension_service_->AddExtension(extension3_.get());
 950   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 951   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
 952   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 953 }
 954
 955 // Check that the restauration of launcher items is happening in the same order
 956 // as the user has pinned them (on another system) when they are synced reverse
 957 // order.
 958 TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsReverseOrder) {
 959   InitLauncherController();
 960
 961   base::ListValue policy_value;
 962   InsertPrefValue(&policy_value, 0, extension1_->id());
 963   InsertPrefValue(&policy_value, 1, extension2_->id());
 964   InsertPrefValue(&policy_value, 2, extension3_->id());
 965   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
 966                                                   policy_value.DeepCopy());
 967   SetShelfChromeIconIndex(0);
 968   // Model should only contain the browser shortcut and app list items.
 969   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
 970   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 971   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 972   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 973
 974   // Installing |extension3_| should add it to the shelf - behind the
 975   // chrome icon.
 976   ash::ShelfItem item;
 977   extension_service_->AddExtension(extension3_.get());
 978   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
 979   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 980   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 981
 982   // Installing |extension2_| should add it to the launcher - behind the
 983   // chrome icon, but in first location.
 984   extension_service_->AddExtension(extension2_.get());
 985   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
 986   EXPECT_EQ("AppList, Chrome, App2, App3", GetPinnedAppStatus());
 987
 988   // Installing |extension1_| should add it to the launcher - behind the
 989   // chrome icon, but in first location.
 990   extension_service_->AddExtension(extension1_.get());
 991   EXPECT_EQ("AppList, Chrome, App1, App2, App3", GetPinnedAppStatus());
 992 }
 993
 994 // Check that the restauration of launcher items is happening in the same order
 995 // as the user has pinned them (on another system) when they are synced random
 996 // order.
 997 TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrder) {
 998   InitLauncherController();
 999
1000   base::ListValue policy_value;
1001   InsertPrefValue(&policy_value, 0, extension1_->id());
1002   InsertPrefValue(&policy_value, 1, extension2_->id());
1003   InsertPrefValue(&policy_value, 2, extension3_->id());
1004   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1005                                                   policy_value.DeepCopy());
1006   SetShelfChromeIconIndex(0);
1007   // Model should only contain the browser shortcut and app list items.
1008   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1009   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1010   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1011   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
1012
1013   // Installing |extension2_| should add it to the launcher - behind the
1014   // chrome icon.
1015   extension_service_->AddExtension(extension2_.get());
1016   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1017   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1018   EXPECT_EQ("AppList, Chrome, App2", GetPinnedAppStatus());
1019
1020   // Installing |extension1_| should add it to the launcher - behind the
1021   // chrome icon, but in first location.
1022   extension_service_->AddExtension(extension1_.get());
1023   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1024   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
1025
1026   // Installing |extension3_| should add it to the launcher - behind the
1027   // chrome icon, but in first location.
1028   extension_service_->AddExtension(extension3_.get());
1029   EXPECT_EQ("AppList, Chrome, App1, App2, App3", GetPinnedAppStatus());
1030 }
1031
1032 // Check that the restauration of launcher items is happening in the same order
1033 // as the user has pinned / moved them (on another system) when they are synced
1034 // random order - including the chrome icon.
1035 TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrderChromeMoved) {
1036   InitLauncherController();
1037
1038   base::ListValue policy_value;
1039   InsertPrefValue(&policy_value, 0, extension1_->id());
1040   InsertPrefValue(&policy_value, 1, extension2_->id());
1041   InsertPrefValue(&policy_value, 2, extension3_->id());
1042   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1043                                                   policy_value.DeepCopy());
1044   SetShelfChromeIconIndex(1);
1045   // Model should only contain the browser shortcut and app list items.
1046   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1047   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1048   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1049   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
1050
1051   // Installing |extension2_| should add it to the shelf - behind the
1052   // chrome icon.
1053   ash::ShelfItem item;
1054   extension_service_->AddExtension(extension2_.get());
1055   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1056   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1057   EXPECT_EQ("AppList, Chrome, App2", GetPinnedAppStatus());
1058
1059   // Installing |extension1_| should add it to the launcher - behind the
1060   // chrome icon, but in first location.
1061   extension_service_->AddExtension(extension1_.get());
1062   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1063   EXPECT_EQ("AppList, App1, Chrome, App2", GetPinnedAppStatus());
1064
1065   // Installing |extension3_| should add it to the launcher - behind the
1066   // chrome icon, but in first location.
1067   extension_service_->AddExtension(extension3_.get());
1068   EXPECT_EQ("AppList, App1, Chrome, App2, App3", GetPinnedAppStatus());
1069 }
1070
1071 // Check that syncing to a different state does the correct thing.
1072 TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsResyncOrder) {
1073   InitLauncherController();
1074   base::ListValue policy_value;
1075   InsertPrefValue(&policy_value, 0, extension1_->id());
1076   InsertPrefValue(&policy_value, 1, extension2_->id());
1077   InsertPrefValue(&policy_value, 2, extension3_->id());
1078   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1079                                                   policy_value.DeepCopy());
1080   // The shelf layout has always one static item at the beginning (App List).
1081   SetShelfChromeIconIndex(0);
1082   extension_service_->AddExtension(extension2_.get());
1083   EXPECT_EQ("AppList, Chrome, App2", GetPinnedAppStatus());
1084   extension_service_->AddExtension(extension1_.get());
1085   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
1086   extension_service_->AddExtension(extension3_.get());
1087   EXPECT_EQ("AppList, Chrome, App1, App2, App3", GetPinnedAppStatus());
1088
1089   // Change the order with increasing chrome position and decreasing position.
1090   base::ListValue policy_value1;
1091   InsertPrefValue(&policy_value1, 0, extension3_->id());
1092   InsertPrefValue(&policy_value1, 1, extension1_->id());
1093   InsertPrefValue(&policy_value1, 2, extension2_->id());
1094   SetShelfChromeIconIndex(3);
1095   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1096                                                   policy_value1.DeepCopy());
1097   EXPECT_EQ("AppList, App3, App1, App2, Chrome", GetPinnedAppStatus());
1098   base::ListValue policy_value2;
1099   InsertPrefValue(&policy_value2, 0, extension2_->id());
1100   InsertPrefValue(&policy_value2, 1, extension3_->id());
1101   InsertPrefValue(&policy_value2, 2, extension1_->id());
1102   SetShelfChromeIconIndex(2);
1103   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1104                                                   policy_value2.DeepCopy());
1105   EXPECT_EQ("AppList, App2, App3, Chrome, App1", GetPinnedAppStatus());
1106
1107   // Check that the chrome icon can also be at the first possible location.
1108   SetShelfChromeIconIndex(0);
1109   base::ListValue policy_value3;
1110   InsertPrefValue(&policy_value3, 0, extension3_->id());
1111   InsertPrefValue(&policy_value3, 1, extension2_->id());
1112   InsertPrefValue(&policy_value3, 2, extension1_->id());
1113   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1114                                                   policy_value3.DeepCopy());
1115   EXPECT_EQ("AppList, Chrome, App3, App2, App1", GetPinnedAppStatus());
1116
1117   // Check that unloading of extensions works as expected.
1118   extension_service_->UnloadExtension(extension1_->id(),
1119                                       UnloadedExtensionInfo::REASON_UNINSTALL);
1120   EXPECT_EQ("AppList, Chrome, App3, App2", GetPinnedAppStatus());
1121
1122   extension_service_->UnloadExtension(extension2_->id(),
1123                                       UnloadedExtensionInfo::REASON_UNINSTALL);
1124   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
1125
1126   // Check that an update of an extension does not crash the system.
1127   extension_service_->UnloadExtension(extension3_->id(),
1128                                       UnloadedExtensionInfo::REASON_UPDATE);
1129   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
1130 }
1131
1132 // Check that simple locking of an application will 'create' a launcher item.
1133 TEST_F(ChromeLauncherControllerTest, CheckLockApps) {
1134   InitLauncherController();
1135   // Model should only contain the browser shortcut and app list items.
1136   EXPECT_EQ(2, model_->item_count());
1137   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1138   EXPECT_FALSE(
1139       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1140   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1141   EXPECT_FALSE(
1142       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
1143
1144   launcher_controller_->LockV1AppWithID(extension1_->id());
1145
1146   EXPECT_EQ(3, model_->item_count());
1147   EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
1148   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1149   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1150   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1151   EXPECT_FALSE(
1152       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
1153
1154   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1155
1156   EXPECT_EQ(2, model_->item_count());
1157   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1158   EXPECT_FALSE(
1159       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1160   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1161   EXPECT_FALSE(
1162       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
1163 }
1164
1165 // Check that multiple locks of an application will be properly handled.
1166 TEST_F(ChromeLauncherControllerTest, CheckMultiLockApps) {
1167   InitLauncherController();
1168   // Model should only contain the browser shortcut and app list items.
1169   EXPECT_EQ(2, model_->item_count());
1170   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1171   EXPECT_FALSE(
1172       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1173
1174   for (int i = 0; i < 2; i++) {
1175     launcher_controller_->LockV1AppWithID(extension1_->id());
1176
1177     EXPECT_EQ(3, model_->item_count());
1178     EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
1179     EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1180     EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(
1181         extension1_->id()));
1182   }
1183
1184   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1185
1186   EXPECT_EQ(3, model_->item_count());
1187   EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
1188   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1189   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1190
1191   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1192
1193   EXPECT_EQ(2, model_->item_count());
1194   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1195   EXPECT_FALSE(
1196       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1197   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1198   EXPECT_FALSE(
1199       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1200 }
1201
1202 // Check that already pinned items are not effected by locks.
1203 TEST_F(ChromeLauncherControllerTest, CheckAlreadyPinnedLockApps) {
1204   InitLauncherController();
1205   // Model should only contain the browser shortcut and app list items.
1206   EXPECT_EQ(2, model_->item_count());
1207   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1208   EXPECT_FALSE(
1209       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1210
1211   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1212   launcher_controller_->PinAppWithID(extension1_->id());
1213   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1214
1215   EXPECT_EQ(3, model_->item_count());
1216   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1217   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1218   EXPECT_FALSE(
1219       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1220
1221   launcher_controller_->LockV1AppWithID(extension1_->id());
1222
1223   EXPECT_EQ(3, model_->item_count());
1224   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1225   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1226   EXPECT_FALSE(
1227       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1228
1229   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1230
1231   EXPECT_EQ(3, model_->item_count());
1232   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1233   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1234   EXPECT_FALSE(
1235       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1236
1237   launcher_controller_->UnpinAppWithID(extension1_->id());
1238
1239   EXPECT_EQ(2, model_->item_count());
1240 }
1241
1242 // Check that already pinned items which get locked stay after unpinning.
1243 TEST_F(ChromeLauncherControllerTest, CheckPinnedAppsStayAfterUnlock) {
1244   InitLauncherController();
1245   // Model should only contain the browser shortcut and app list items.
1246   EXPECT_EQ(2, model_->item_count());
1247   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1248   EXPECT_FALSE(
1249       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1250
1251   launcher_controller_->PinAppWithID(extension1_->id());
1252
1253   EXPECT_EQ(3, model_->item_count());
1254   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1255   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1256   EXPECT_FALSE(
1257       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1258
1259   launcher_controller_->LockV1AppWithID(extension1_->id());
1260
1261   EXPECT_EQ(3, model_->item_count());
1262   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1263   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1264   EXPECT_FALSE(
1265       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1266
1267   launcher_controller_->UnpinAppWithID(extension1_->id());
1268
1269   EXPECT_EQ(3, model_->item_count());
1270   EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
1271   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1272   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1273
1274   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1275
1276   EXPECT_EQ(2, model_->item_count());
1277 }
1278
1279 #if defined(OS_CHROMEOS)
1280 // Check that running applications wich are not pinned get properly restored
1281 // upon user change.
1282 TEST_F(ChromeLauncherControllerTest, CheckRunningAppOrder) {
1283   InitLauncherController();
1284   // Model should only contain the browser shortcut and app list items.
1285   EXPECT_EQ(2, model_->item_count());
1286
1287   // Add a few running applications.
1288   launcher_controller_->LockV1AppWithID(extension1_->id());
1289   launcher_controller_->LockV1AppWithID(extension2_->id());
1290   launcher_controller_->LockV1AppWithID(extension3_->id());
1291   EXPECT_EQ(5, model_->item_count());
1292   // Note that this not only checks the order of applications but also the
1293   // running type.
1294   EXPECT_EQ("AppList, Chrome, app1, app2, app3", GetPinnedAppStatus());
1295
1296   // Remember the current order of applications for the current user.
1297   const std::string& current_user_id =
1298       multi_user_util::GetUserIDFromProfile(profile());
1299   RememberUnpinnedRunningApplicationOrder();
1300
1301   // Switch some items and check that restoring a user which was not yet
1302   // remembered changes nothing.
1303   model_->Move(2, 3);
1304   EXPECT_EQ("AppList, Chrome, app2, app1, app3", GetPinnedAppStatus());
1305   RestoreUnpinnedRunningApplicationOrder("second-fake-user@fake.com");
1306   EXPECT_EQ("AppList, Chrome, app2, app1, app3", GetPinnedAppStatus());
1307
1308   // Restoring the stored user should however do the right thing.
1309   RestoreUnpinnedRunningApplicationOrder(current_user_id);
1310   EXPECT_EQ("AppList, Chrome, app1, app2, app3", GetPinnedAppStatus());
1311
1312   // Switch again some items and even delete one - making sure that the missing
1313   // item gets properly handled.
1314   model_->Move(3, 4);
1315   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1316   EXPECT_EQ("AppList, Chrome, app3, app2", GetPinnedAppStatus());
1317   RestoreUnpinnedRunningApplicationOrder(current_user_id);
1318   EXPECT_EQ("AppList, Chrome, app2, app3", GetPinnedAppStatus());
1319
1320   // Check that removing more items does not crash and changes nothing.
1321   launcher_controller_->UnlockV1AppWithID(extension2_->id());
1322   RestoreUnpinnedRunningApplicationOrder(current_user_id);
1323   EXPECT_EQ("AppList, Chrome, app3", GetPinnedAppStatus());
1324   launcher_controller_->UnlockV1AppWithID(extension3_->id());
1325   RestoreUnpinnedRunningApplicationOrder(current_user_id);
1326   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
1327 }
1328
1329 // Check that with multi profile V1 apps are properly added / removed from the
1330 // shelf.
1331 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1332        V1AppUpdateOnUserSwitch) {
1333   // Create a browser item in the LauncherController.
1334   InitLauncherController();
1335   EXPECT_EQ(2, model_->item_count());
1336   {
1337     // Create a "windowed gmail app".
1338     scoped_ptr<V1App> v1_app(CreateRunningV1App(
1339         profile(), extension_misc::kGmailAppId, gmail_url));
1340     EXPECT_EQ(3, model_->item_count());
1341
1342     // After switching to a second user the item should be gone.
1343     std::string user2 = "user2";
1344     TestingProfile* profile2 = CreateMultiUserProfile(user2);
1345     SwitchActiveUser(profile2->GetProfileName());
1346     EXPECT_EQ(2, model_->item_count());
1347
1348     // After switching back the item should be back.
1349     SwitchActiveUser(profile()->GetProfileName());
1350     EXPECT_EQ(3, model_->item_count());
1351     // Note we destroy now the gmail app with the closure end.
1352   }
1353   EXPECT_EQ(2, model_->item_count());
1354 }
1355
1356 // Check edge cases with multi profile V1 apps in the shelf.
1357 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1358        V1AppUpdateOnUserSwitchEdgecases) {
1359   // Create a browser item in the LauncherController.
1360   InitLauncherController();
1361
1362   // First test: Create an app when the user is not active.
1363   std::string user2 = "user2";
1364   TestingProfile* profile2 = CreateMultiUserProfile(user2);
1365   {
1366     // Create a "windowed gmail app".
1367     scoped_ptr<V1App> v1_app(CreateRunningV1App(
1368         profile2, extension_misc::kGmailAppId, gmail_url));
1369     EXPECT_EQ(2, model_->item_count());
1370
1371     // However - switching to the user should show it.
1372     SwitchActiveUser(profile2->GetProfileName());
1373     EXPECT_EQ(3, model_->item_count());
1374
1375     // Second test: Remove the app when the user is not active and see that it
1376     // works.
1377     SwitchActiveUser(profile()->GetProfileName());
1378     EXPECT_EQ(2, model_->item_count());
1379     // Note: the closure ends and the browser will go away.
1380   }
1381   EXPECT_EQ(2, model_->item_count());
1382   SwitchActiveUser(profile2->GetProfileName());
1383   EXPECT_EQ(2, model_->item_count());
1384   SwitchActiveUser(profile()->GetProfileName());
1385   EXPECT_EQ(2, model_->item_count());
1386 }
1387
1388 // Check edge case where a visiting V1 app gets closed (crbug.com/321374).
1389 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1390        V1CloseOnVisitingDesktop) {
1391   // Create a browser item in the LauncherController.
1392   InitLauncherController();
1393
1394   chrome::MultiUserWindowManager* manager =
1395       chrome::MultiUserWindowManager::GetInstance();
1396
1397   // First create an app when the user is active.
1398   std::string user2 = "user2";
1399   TestingProfile* profile2 = CreateMultiUserProfile(user2);
1400   {
1401     // Create a "windowed gmail app".
1402     scoped_ptr<V1App> v1_app(CreateRunningV1App(
1403         profile(),
1404         extension_misc::kGmailAppId,
1405         kGmailLaunchURL));
1406     EXPECT_EQ(3, model_->item_count());
1407
1408     // Transfer the app to the other screen and switch users.
1409     manager->ShowWindowForUser(v1_app->browser()->window()->GetNativeWindow(),
1410                                user2);
1411     EXPECT_EQ(3, model_->item_count());
1412     SwitchActiveUser(profile2->GetProfileName());
1413     EXPECT_EQ(2, model_->item_count());
1414   }
1415   // After the app was destroyed, switch back. (which caused already a crash).
1416   SwitchActiveUser(profile()->GetProfileName());
1417
1418   // Create the same app again - which was also causing the crash.
1419   EXPECT_EQ(2, model_->item_count());
1420   {
1421     // Create a "windowed gmail app".
1422     scoped_ptr<V1App> v1_app(CreateRunningV1App(
1423         profile(),
1424         extension_misc::kGmailAppId,
1425         kGmailLaunchURL));
1426     EXPECT_EQ(3, model_->item_count());
1427   }
1428   SwitchActiveUser(profile2->GetProfileName());
1429   EXPECT_EQ(2, model_->item_count());
1430 }
1431
1432 // Check edge cases with multi profile V1 apps in the shelf.
1433 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1434        V1AppUpdateOnUserSwitchEdgecases2) {
1435   // Create a browser item in the LauncherController.
1436   InitLauncherController();
1437   TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
1438   SetAppTabHelper(app_tab_helper);
1439
1440   // First test: Create an app when the user is not active.
1441   std::string user2 = "user2";
1442   TestingProfile* profile2 = CreateMultiUserProfile(user2);
1443   SwitchActiveUser(profile2->GetProfileName());
1444   {
1445     // Create a "windowed gmail app".
1446     scoped_ptr<V1App> v1_app(CreateRunningV1App(
1447         profile(), extension_misc::kGmailAppId, gmail_url));
1448     EXPECT_EQ(2, model_->item_count());
1449
1450     // However - switching to the user should show it.
1451     SwitchActiveUser(profile()->GetProfileName());
1452     EXPECT_EQ(3, model_->item_count());
1453
1454     // Second test: Remove the app when the user is not active and see that it
1455     // works.
1456     SwitchActiveUser(profile2->GetProfileName());
1457     EXPECT_EQ(2, model_->item_count());
1458     v1_app.reset();
1459   }
1460   EXPECT_EQ(2, model_->item_count());
1461   SwitchActiveUser(profile()->GetProfileName());
1462   EXPECT_EQ(2, model_->item_count());
1463   SwitchActiveUser(profile2->GetProfileName());
1464   EXPECT_EQ(2, model_->item_count());
1465 }
1466
1467 // Check that activating an item which is on another user's desktop, will bring
1468 // it back.
1469 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1470        TestLauncherActivationPullsBackWindow) {
1471   // Create a browser item in the LauncherController.
1472   InitLauncherController();
1473   chrome::MultiUserWindowManager* manager =
1474       chrome::MultiUserWindowManager::GetInstance();
1475
1476   // Add two users to the window manager.
1477   std::string user2 = "user2";
1478   TestingProfile* profile2 = CreateMultiUserProfile(user2);
1479   manager->AddUser(profile());
1480   manager->AddUser(profile2);
1481   const std::string& current_user =
1482       multi_user_util::GetUserIDFromProfile(profile());
1483
1484   // Create a browser window with a native window for the current user.
1485   scoped_ptr<BrowserWindow> browser_window(CreateTestBrowserWindow(
1486       Browser::CreateParams(profile(), chrome::HOST_DESKTOP_TYPE_ASH)));
1487   aura::Window* window = browser_window->GetNativeWindow();
1488   manager->SetWindowOwner(window, current_user);
1489
1490   // Check that an activation of the window on its owner's desktop does not
1491   // change the visibility to another user.
1492   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window.get(),
1493                                                          false);
1494   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
1495
1496   // Transfer the window to another user's desktop and check that activating it
1497   // does pull it back to that user.
1498   manager->ShowWindowForUser(window, user2);
1499   EXPECT_FALSE(manager->IsWindowOnDesktopOfUser(window, current_user));
1500   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window.get(),
1501                                                          false);
1502   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
1503 }
1504 #endif
1505
1506 // Check that lock -> pin -> unlock -> unpin does properly transition.
1507 TEST_F(ChromeLauncherControllerTest, CheckLockPinUnlockUnpin) {
1508   InitLauncherController();
1509   // Model should only contain the browser shortcut and app list items.
1510   EXPECT_EQ(2, model_->item_count());
1511   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1512   EXPECT_FALSE(
1513       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1514
1515   launcher_controller_->LockV1AppWithID(extension1_->id());
1516
1517   EXPECT_EQ(3, model_->item_count());
1518   EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[2].type);
1519   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1520   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1521
1522   launcher_controller_->PinAppWithID(extension1_->id());
1523
1524   EXPECT_EQ(3, model_->item_count());
1525   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1526   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1527   EXPECT_FALSE(
1528       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1529
1530   launcher_controller_->UnlockV1AppWithID(extension1_->id());
1531
1532   EXPECT_EQ(3, model_->item_count());
1533   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1534   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1535   EXPECT_FALSE(
1536       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
1537
1538   launcher_controller_->UnpinAppWithID(extension1_->id());
1539
1540   EXPECT_EQ(2, model_->item_count());
1541 }
1542
1543 // Check that a locked (windowed V1 application) will be properly converted
1544 // between locked and pinned when the order gets changed through a profile /
1545 // policy change.
1546 TEST_F(ChromeLauncherControllerTest, RestoreDefaultAndLockedAppsResyncOrder) {
1547   InitLauncherController();
1548   base::ListValue policy_value0;
1549   InsertPrefValue(&policy_value0, 0, extension1_->id());
1550   InsertPrefValue(&policy_value0, 1, extension3_->id());
1551   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1552                                                   policy_value0.DeepCopy());
1553   // The shelf layout has always one static item at the beginning (App List).
1554   SetShelfChromeIconIndex(0);
1555   extension_service_->AddExtension(extension1_.get());
1556   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
1557   extension_service_->AddExtension(extension2_.get());
1558   // No new app icon will be generated.
1559   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
1560   // Add the app as locked app which will add it (un-pinned).
1561   launcher_controller_->LockV1AppWithID(extension2_->id());
1562   EXPECT_EQ("AppList, Chrome, App1, app2", GetPinnedAppStatus());
1563   extension_service_->AddExtension(extension3_.get());
1564   EXPECT_EQ("AppList, Chrome, App1, App3, app2", GetPinnedAppStatus());
1565
1566   // Now request to pin all items which should convert the locked item into a
1567   // pinned item.
1568   base::ListValue policy_value1;
1569   InsertPrefValue(&policy_value1, 0, extension3_->id());
1570   InsertPrefValue(&policy_value1, 1, extension2_->id());
1571   InsertPrefValue(&policy_value1, 2, extension1_->id());
1572   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1573                                                   policy_value1.DeepCopy());
1574   EXPECT_EQ("AppList, Chrome, App3, App2, App1", GetPinnedAppStatus());
1575
1576   // Going back to a status where there is no requirement for app 2 to be pinned
1577   // should convert it back to locked but not pinned and state. The position
1578   // is determined by the |ShelfModel|'s weight system and since running
1579   // applications are not allowed to be mixed with shortcuts, it should show up
1580   // at the end of the list.
1581   base::ListValue policy_value2;
1582   InsertPrefValue(&policy_value2, 0, extension3_->id());
1583   InsertPrefValue(&policy_value2, 1, extension1_->id());
1584   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1585                                                   policy_value2.DeepCopy());
1586   EXPECT_EQ("AppList, Chrome, App3, App1, app2", GetPinnedAppStatus());
1587
1588   // Removing an item should simply close it and everything should shift.
1589   base::ListValue policy_value3;
1590   InsertPrefValue(&policy_value3, 0, extension3_->id());
1591   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1592                                                   policy_value3.DeepCopy());
1593   EXPECT_EQ("AppList, Chrome, App3, app2", GetPinnedAppStatus());
1594 }
1595
1596 // Check that a running and not pinned V2 application will be properly converted
1597 // between locked and pinned when the order gets changed through a profile /
1598 // policy change.
1599 TEST_F(ChromeLauncherControllerTest,
1600        RestoreDefaultAndRunningV2AppsResyncOrder) {
1601   InitLauncherController();
1602   base::ListValue policy_value0;
1603   InsertPrefValue(&policy_value0, 0, extension1_->id());
1604   InsertPrefValue(&policy_value0, 1, extension3_->id());
1605   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1606                                                   policy_value0.DeepCopy());
1607   // The shelf layout has always one static item at the beginning (app List).
1608   SetShelfChromeIconIndex(0);
1609   extension_service_->AddExtension(extension1_.get());
1610   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
1611   extension_service_->AddExtension(extension2_.get());
1612   // No new app icon will be generated.
1613   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
1614   // Add the app as an unpinned but running V2 app.
1615   CreateRunningV2App(extension2_->id());
1616   EXPECT_EQ("AppList, Chrome, App1, *app2", GetPinnedAppStatus());
1617   extension_service_->AddExtension(extension3_.get());
1618   EXPECT_EQ("AppList, Chrome, App1, App3, *app2", GetPinnedAppStatus());
1619
1620   // Now request to pin all items which should convert the locked item into a
1621   // pinned item.
1622   base::ListValue policy_value1;
1623   InsertPrefValue(&policy_value1, 0, extension3_->id());
1624   InsertPrefValue(&policy_value1, 1, extension2_->id());
1625   InsertPrefValue(&policy_value1, 2, extension1_->id());
1626   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1627                                                   policy_value1.DeepCopy());
1628   EXPECT_EQ("AppList, Chrome, App3, App2, App1", GetPinnedAppStatus());
1629
1630   // Going back to a status where there is no requirement for app 2 to be pinned
1631   // should convert it back to running V2 app. Since the position is determined
1632   // by the |ShelfModel|'s weight system, it will be after last pinned item.
1633   base::ListValue policy_value2;
1634   InsertPrefValue(&policy_value2, 0, extension3_->id());
1635   InsertPrefValue(&policy_value2, 1, extension1_->id());
1636   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1637                                                   policy_value2.DeepCopy());
1638   EXPECT_EQ("AppList, Chrome, App3, App1, *app2", GetPinnedAppStatus());
1639
1640   // Removing an item should simply close it and everything should shift.
1641   base::ListValue policy_value3;
1642   InsertPrefValue(&policy_value3, 0, extension3_->id());
1643   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1644                                                   policy_value3.DeepCopy());
1645   EXPECT_EQ("AppList, Chrome, App3, *app2", GetPinnedAppStatus());
1646 }
1647
1648 // Each user has a different set of applications pinned. Check that when
1649 // switching between the two users, the state gets properly set.
1650 TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestore) {
1651   base::ListValue user_a;
1652   base::ListValue user_b;
1653   SetUpMultiUserScenario(&user_a, &user_b);
1654   // Show user 1.
1655   SetShelfChromeIconIndex(6);
1656   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1657                                                   user_a.DeepCopy());
1658   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
1659             GetPinnedAppStatus());
1660
1661   // Show user 2.
1662   SetShelfChromeIconIndex(4);
1663   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1664                                                   user_b.DeepCopy());
1665
1666   EXPECT_EQ("AppList, App7, App8, Chrome", GetPinnedAppStatus());
1667
1668   // Switch back to 1.
1669   SetShelfChromeIconIndex(8);
1670   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1671                                                   user_a.DeepCopy());
1672   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
1673             GetPinnedAppStatus());
1674
1675   // Switch back to 2.
1676   SetShelfChromeIconIndex(4);
1677   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1678                                                   user_b.DeepCopy());
1679   EXPECT_EQ("AppList, App7, App8, Chrome", GetPinnedAppStatus());
1680 }
1681
1682 // Each user has a different set of applications pinned, and one user has an
1683 // application running. Check that when switching between the two users, the
1684 // state gets properly set.
1685 TEST_F(ChromeLauncherControllerTest, UserSwitchIconRestoreWithRunningV2App) {
1686   base::ListValue user_a;
1687   base::ListValue user_b;
1688   SetUpMultiUserScenario(&user_a, &user_b);
1689
1690   // Run App1 and assume that it is a V2 app.
1691   CreateRunningV2App(extension1_->id());
1692
1693   // Show user 1.
1694   SetShelfChromeIconIndex(6);
1695   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1696                                                   user_a.DeepCopy());
1697   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
1698             GetPinnedAppStatus());
1699
1700   // Show user 2.
1701   SetShelfChromeIconIndex(4);
1702   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1703                                                   user_b.DeepCopy());
1704
1705   EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
1706
1707   // Switch back to 1.
1708   SetShelfChromeIconIndex(8);
1709   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1710                                                   user_a.DeepCopy());
1711   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, App6, Chrome",
1712             GetPinnedAppStatus());
1713
1714   // Switch back to 2.
1715   SetShelfChromeIconIndex(4);
1716   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1717                                                   user_b.DeepCopy());
1718   EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
1719 }
1720
1721 // Each user has a different set of applications pinned, and one user has an
1722 // application running. The chrome icon is not the last item in the list.
1723 // Check that when switching between the two users, the state gets properly set.
1724 // There was once a bug associated with this.
1725 TEST_F(ChromeLauncherControllerTest,
1726        UserSwitchIconRestoreWithRunningV2AppChromeInMiddle) {
1727   base::ListValue user_a;
1728   base::ListValue user_b;
1729   SetUpMultiUserScenario(&user_a, &user_b);
1730
1731   // Run App1 and assume that it is a V2 app.
1732   CreateRunningV2App(extension1_->id());
1733
1734   // Show user 1.
1735   SetShelfChromeIconIndex(5);
1736   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1737                                                   user_a.DeepCopy());
1738   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, Chrome, App6",
1739             GetPinnedAppStatus());
1740
1741   // Show user 2.
1742   SetShelfChromeIconIndex(4);
1743   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1744                                                   user_b.DeepCopy());
1745
1746   EXPECT_EQ("AppList, App7, App8, Chrome, *app1", GetPinnedAppStatus());
1747
1748   // Switch back to 1.
1749   SetShelfChromeIconIndex(5);
1750   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1751                                                   user_a.DeepCopy());
1752   EXPECT_EQ("AppList, App1, App2, App3, App4, App5, Chrome, App6",
1753             GetPinnedAppStatus());
1754 }
1755
1756 TEST_F(ChromeLauncherControllerTest, Policy) {
1757   extension_service_->AddExtension(extension1_.get());
1758   extension_service_->AddExtension(extension3_.get());
1759
1760   base::ListValue policy_value;
1761   InsertPrefValue(&policy_value, 0, extension1_->id());
1762   InsertPrefValue(&policy_value, 1, extension2_->id());
1763   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
1764                                                      policy_value.DeepCopy());
1765
1766   // Only |extension1_| should get pinned. |extension2_| is specified but not
1767   // installed, and |extension3_| is part of the default set, but that shouldn't
1768   // take effect when the policy override is in place.
1769   InitLauncherController();
1770   EXPECT_EQ(3, model_->item_count());
1771   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1772   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1773   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
1774   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1775
1776   // Installing |extension2_| should add it to the launcher.
1777   extension_service_->AddExtension(extension2_.get());
1778   EXPECT_EQ(4, model_->item_count());
1779   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1780   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[3].type);
1781   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
1782   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
1783   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1784
1785   // Removing |extension1_| from the policy should be reflected in the launcher.
1786   policy_value.Remove(0, NULL);
1787   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
1788                                                      policy_value.DeepCopy());
1789   EXPECT_EQ(3, model_->item_count());
1790   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
1791   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
1792   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
1793   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1794 }
1795
1796 TEST_F(ChromeLauncherControllerTest, UnpinWithUninstall) {
1797   extension_service_->AddExtension(extension3_.get());
1798   extension_service_->AddExtension(extension4_.get());
1799
1800   InitLauncherController();
1801
1802   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
1803   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
1804
1805   extension_service_->UnloadExtension(extension3_->id(),
1806                                       UnloadedExtensionInfo::REASON_UNINSTALL);
1807
1808   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
1809   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
1810 }
1811
1812 TEST_F(ChromeLauncherControllerTest, PrefUpdates) {
1813   extension_service_->AddExtension(extension2_.get());
1814   extension_service_->AddExtension(extension3_.get());
1815   extension_service_->AddExtension(extension4_.get());
1816
1817   InitLauncherController();
1818
1819   std::vector<std::string> expected_launchers;
1820   std::vector<std::string> actual_launchers;
1821   base::ListValue pref_value;
1822   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1823                                                  pref_value.DeepCopy());
1824   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1825   EXPECT_EQ(expected_launchers, actual_launchers);
1826
1827   // Unavailable extensions don't create launcher items.
1828   InsertPrefValue(&pref_value, 0, extension1_->id());
1829   InsertPrefValue(&pref_value, 1, extension2_->id());
1830   InsertPrefValue(&pref_value, 2, extension4_->id());
1831   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1832                                                  pref_value.DeepCopy());
1833   expected_launchers.push_back(extension2_->id());
1834   expected_launchers.push_back(extension4_->id());
1835   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1836   EXPECT_EQ(expected_launchers, actual_launchers);
1837
1838   // Redundant pref entries show up only once.
1839   InsertPrefValue(&pref_value, 2, extension3_->id());
1840   InsertPrefValue(&pref_value, 2, extension3_->id());
1841   InsertPrefValue(&pref_value, 5, extension3_->id());
1842   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1843                                                  pref_value.DeepCopy());
1844   expected_launchers.insert(expected_launchers.begin() + 1, extension3_->id());
1845   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1846   EXPECT_EQ(expected_launchers, actual_launchers);
1847
1848   // Order changes are reflected correctly.
1849   pref_value.Clear();
1850   InsertPrefValue(&pref_value, 0, extension4_->id());
1851   InsertPrefValue(&pref_value, 1, extension3_->id());
1852   InsertPrefValue(&pref_value, 2, extension2_->id());
1853   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1854                                                  pref_value.DeepCopy());
1855   std::reverse(expected_launchers.begin(), expected_launchers.end());
1856   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1857   EXPECT_EQ(expected_launchers, actual_launchers);
1858
1859   // Clearing works.
1860   pref_value.Clear();
1861   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1862                                                  pref_value.DeepCopy());
1863   expected_launchers.clear();
1864   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1865   EXPECT_EQ(expected_launchers, actual_launchers);
1866 }
1867
1868 TEST_F(ChromeLauncherControllerTest, PendingInsertionOrder) {
1869   extension_service_->AddExtension(extension1_.get());
1870   extension_service_->AddExtension(extension3_.get());
1871
1872   InitLauncherController();
1873
1874   base::ListValue pref_value;
1875   InsertPrefValue(&pref_value, 0, extension1_->id());
1876   InsertPrefValue(&pref_value, 1, extension2_->id());
1877   InsertPrefValue(&pref_value, 2, extension3_->id());
1878   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
1879                                                  pref_value.DeepCopy());
1880
1881   std::vector<std::string> expected_launchers;
1882   expected_launchers.push_back(extension1_->id());
1883   expected_launchers.push_back(extension3_->id());
1884   std::vector<std::string> actual_launchers;
1885
1886   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1887   EXPECT_EQ(expected_launchers, actual_launchers);
1888
1889   // Install |extension2| and verify it shows up between the other two.
1890   extension_service_->AddExtension(extension2_.get());
1891   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
1892   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
1893   EXPECT_EQ(expected_launchers, actual_launchers);
1894 }
1895
1896 // Checks the created menus and menu lists for correctness. It uses the given
1897 // |controller| to create the objects for the given |item| and checks the
1898 // found item count against the |expected_items|. The |title| list contains the
1899 // menu titles in the order of their appearance in the menu (not including the
1900 // application name).
1901 bool CheckMenuCreation(ChromeLauncherController* controller,
1902                        const ash::ShelfItem& item,
1903                        size_t expected_items,
1904                        base::string16 title[],
1905                        bool is_browser) {
1906   ChromeLauncherAppMenuItems items = controller->GetApplicationList(item, 0);
1907   // A new behavior has been added: Only show menus if there is at least one
1908   // item available.
1909   if (expected_items < 1 && is_browser) {
1910     EXPECT_EQ(0u, items.size());
1911     return items.size() == 0;
1912   }
1913   // There should be one item in there: The title.
1914   EXPECT_EQ(expected_items + 1, items.size());
1915   EXPECT_FALSE(items[0]->IsEnabled());
1916   for (size_t i = 0; i < expected_items; i++) {
1917     EXPECT_EQ(title[i], items[1 + i]->title());
1918     // Check that the first real item has a leading separator.
1919     if (i == 1)
1920       EXPECT_TRUE(items[i]->HasLeadingSeparator());
1921     else
1922       EXPECT_FALSE(items[i]->HasLeadingSeparator());
1923   }
1924
1925   scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
1926       controller->GetApplicationList(item, 0)));
1927   // The first element in the menu is a spacing separator. On some systems
1928   // (e.g. Windows) such things do not exist. As such we check the existence
1929   // and adjust dynamically.
1930   int first_item = menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR ? 1 : 0;
1931   int expected_menu_items = first_item +
1932                             (expected_items ? (expected_items + 3) : 2);
1933   EXPECT_EQ(expected_menu_items, menu->GetItemCount());
1934   EXPECT_FALSE(menu->IsEnabledAt(first_item));
1935   if (expected_items) {
1936     EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
1937               menu->GetTypeAt(first_item + 1));
1938   }
1939   return items.size() == expected_items + 1;
1940 }
1941
1942 // Check that browsers get reflected correctly in the launcher menu.
1943 TEST_F(ChromeLauncherControllerTest, BrowserMenuGeneration) {
1944   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
1945   chrome::NewTab(browser());
1946
1947   InitLauncherController();
1948
1949   // Check that the browser list is empty at this time.
1950   ash::ShelfItem item_browser;
1951   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
1952   item_browser.id =
1953       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
1954   EXPECT_TRUE(CheckMenuCreation(
1955       launcher_controller_.get(), item_browser, 0, NULL, true));
1956
1957   // Now make the created browser() visible by adding it to the active browser
1958   // list.
1959   BrowserList::SetLastActive(browser());
1960   base::string16 title1 = ASCIIToUTF16("Test1");
1961   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
1962   base::string16 one_menu_item[] = { title1 };
1963
1964   EXPECT_TRUE(CheckMenuCreation(
1965       launcher_controller_.get(), item_browser, 1, one_menu_item, true));
1966
1967   // Create one more browser/window and check that one more was added.
1968   Browser::CreateParams ash_params(profile(), chrome::HOST_DESKTOP_TYPE_ASH);
1969   scoped_ptr<Browser> browser2(
1970       chrome::CreateBrowserWithTestWindowForParams(&ash_params));
1971   chrome::NewTab(browser2.get());
1972   BrowserList::SetLastActive(browser2.get());
1973   base::string16 title2 = ASCIIToUTF16("Test2");
1974   NavigateAndCommitActiveTabWithTitle(browser2.get(), GURL("http://test2"),
1975                                       title2);
1976
1977   // Check that the list contains now two entries - make furthermore sure that
1978   // the active item is the first entry.
1979   base::string16 two_menu_items[] = {title1, title2};
1980   EXPECT_TRUE(CheckMenuCreation(
1981       launcher_controller_.get(), item_browser, 2, two_menu_items, true));
1982
1983   // Apparently we have to close all tabs we have.
1984   chrome::CloseTab(browser2.get());
1985 }
1986
1987 #if defined(OS_CHROMEOS)
1988 // Check the multi profile case where only user related browsers should show
1989 // up.
1990 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
1991        BrowserMenuGenerationTwoUsers) {
1992   // Create a browser item in the LauncherController.
1993   InitLauncherController();
1994
1995   ash::ShelfItem item_browser;
1996   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
1997   item_browser.id =
1998       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
1999
2000   // Check that the menu is empty.
2001   chrome::NewTab(browser());
2002   EXPECT_TRUE(CheckMenuCreation(
2003       launcher_controller_.get(), item_browser, 0, NULL, true));
2004
2005   // Show the created |browser()| by adding it to the active browser list.
2006   BrowserList::SetLastActive(browser());
2007   base::string16 title1 = ASCIIToUTF16("Test1");
2008   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
2009   base::string16 one_menu_item1[] = { title1 };
2010   EXPECT_TRUE(CheckMenuCreation(
2011       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
2012
2013   // Create a browser for another user and check that it is not included in the
2014   // users running browser list.
2015   std::string user2 = "user2";
2016   TestingProfile* profile2 = CreateMultiUserProfile(user2);
2017   scoped_ptr<Browser> browser2(
2018       CreateBrowserAndTabWithProfile(profile2, user2, "http://test2"));
2019   base::string16 one_menu_item2[] = { ASCIIToUTF16(user2) };
2020   EXPECT_TRUE(CheckMenuCreation(
2021       launcher_controller_.get(), item_browser, 1, one_menu_item1, true));
2022
2023   // Switch to the other user and make sure that only that browser window gets
2024   // shown.
2025   SwitchActiveUser(profile2->GetProfileName());
2026   EXPECT_TRUE(CheckMenuCreation(
2027       launcher_controller_.get(), item_browser, 1, one_menu_item2, true));
2028
2029   // Transferred browsers of other users should not show up in the list.
2030   chrome::MultiUserWindowManager::GetInstance()->ShowWindowForUser(
2031       browser()->window()->GetNativeWindow(),
2032       user2);
2033   EXPECT_TRUE(CheckMenuCreation(
2034       launcher_controller_.get(), item_browser, 1, one_menu_item2, true));
2035
2036   chrome::CloseTab(browser2.get());
2037 }
2038 #endif  // defined(OS_CHROMEOS)
2039
2040 // Check that V1 apps are correctly reflected in the launcher menu using the
2041 // refocus logic.
2042 // Note that the extension matching logic is tested by the extension system
2043 // and does not need a separate test here.
2044 TEST_F(ChromeLauncherControllerTest, V1AppMenuGeneration) {
2045   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
2046   EXPECT_EQ(0, browser()->tab_strip_model()->count());
2047
2048   InitLauncherControllerWithBrowser();
2049
2050   // Model should only contain the browser shortcut and app list items.
2051   EXPECT_EQ(2, model_->item_count());
2052   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
2053
2054   // Installing |extension3_| adds it to the launcher.
2055   ash::ShelfID gmail_id = model_->next_id();
2056   extension_service_->AddExtension(extension3_.get());
2057   EXPECT_EQ(3, model_->item_count());
2058   int gmail_index = model_->ItemIndexByID(gmail_id);
2059   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[gmail_index].type);
2060   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
2061   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
2062
2063   // Check the menu content.
2064   ash::ShelfItem item_browser;
2065   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
2066   item_browser.id =
2067       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
2068
2069   ash::ShelfItem item_gmail;
2070   item_gmail.type = ash::TYPE_APP_SHORTCUT;
2071   item_gmail.id = gmail_id;
2072   EXPECT_TRUE(CheckMenuCreation(
2073       launcher_controller_.get(), item_gmail, 0, NULL, false));
2074
2075   // Set the gmail URL to a new tab.
2076   base::string16 title1 = ASCIIToUTF16("Test1");
2077   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
2078
2079   base::string16 one_menu_item[] = { title1 };
2080   EXPECT_TRUE(CheckMenuCreation(
2081       launcher_controller_.get(), item_gmail, 1, one_menu_item, false));
2082
2083   // Create one empty tab.
2084   chrome::NewTab(browser());
2085   base::string16 title2 = ASCIIToUTF16("Test2");
2086   NavigateAndCommitActiveTabWithTitle(
2087       browser(),
2088       GURL("https://bla"),
2089       title2);
2090
2091   // and another one with another gmail instance.
2092   chrome::NewTab(browser());
2093   base::string16 title3 = ASCIIToUTF16("Test3");
2094   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title3);
2095   base::string16 two_menu_items[] = {title1, title3};
2096   EXPECT_TRUE(CheckMenuCreation(
2097       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
2098
2099   // Even though the item is in the V1 app list, it should also be in the
2100   // browser list.
2101   base::string16 browser_menu_item[] = {title3};
2102   EXPECT_TRUE(CheckMenuCreation(
2103       launcher_controller_.get(), item_browser, 1, browser_menu_item, false));
2104
2105   // Test that closing of (all) the item(s) does work (and all menus get
2106   // updated properly).
2107   launcher_controller_->Close(item_gmail.id);
2108
2109   EXPECT_TRUE(CheckMenuCreation(
2110       launcher_controller_.get(), item_gmail, 0, NULL, false));
2111   base::string16 browser_menu_item2[] = { title2 };
2112   EXPECT_TRUE(CheckMenuCreation(
2113       launcher_controller_.get(), item_browser, 1, browser_menu_item2, false));
2114 }
2115
2116 #if defined(OS_CHROMEOS)
2117 // Check the multi profile case where only user related apps should show up.
2118 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
2119        V1AppMenuGenerationTwoUsers) {
2120   // Create a browser item in the LauncherController.
2121   InitLauncherController();
2122   chrome::NewTab(browser());
2123
2124   // Installing |extension3_| adds it to the launcher.
2125   ash::ShelfID gmail_id = model_->next_id();
2126   extension_service_->AddExtension(extension3_.get());
2127   EXPECT_EQ(3, model_->item_count());
2128   int gmail_index = model_->ItemIndexByID(gmail_id);
2129   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[gmail_index].type);
2130   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
2131   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
2132
2133   // Check the menu content.
2134   ash::ShelfItem item_browser;
2135   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
2136   item_browser.id =
2137       launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
2138
2139   ash::ShelfItem item_gmail;
2140   item_gmail.type = ash::TYPE_APP_SHORTCUT;
2141   item_gmail.id = gmail_id;
2142   EXPECT_TRUE(CheckMenuCreation(
2143       launcher_controller_.get(), item_gmail, 0, NULL, false));
2144
2145   // Set the gmail URL to a new tab.
2146   base::string16 title1 = ASCIIToUTF16("Test1");
2147   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
2148
2149   base::string16 one_menu_item[] = { title1 };
2150   EXPECT_TRUE(CheckMenuCreation(
2151       launcher_controller_.get(), item_gmail, 1, one_menu_item, false));
2152
2153   // Create a second profile and switch to that user.
2154   std::string user2 = "user2";
2155   TestingProfile* profile2 = CreateMultiUserProfile(user2);
2156   SwitchActiveUser(profile2->GetProfileName());
2157
2158   // No item should have content yet.
2159   EXPECT_TRUE(CheckMenuCreation(
2160       launcher_controller_.get(), item_browser, 0, NULL, true));
2161   EXPECT_TRUE(CheckMenuCreation(
2162       launcher_controller_.get(), item_gmail, 0, NULL, false));
2163
2164   // Transfer the browser of the first user - it should still not show up.
2165   chrome::MultiUserWindowManager::GetInstance()->ShowWindowForUser(
2166       browser()->window()->GetNativeWindow(),
2167       user2);
2168
2169   EXPECT_TRUE(CheckMenuCreation(
2170       launcher_controller_.get(), item_browser, 0, NULL, true));
2171   EXPECT_TRUE(CheckMenuCreation(
2172       launcher_controller_.get(), item_gmail, 0, NULL, false));
2173 }
2174
2175 // Check that V2 applications are creating items properly in the launcher when
2176 // instantiated by the current user.
2177 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
2178        V2AppHandlingTwoUsers) {
2179   InitLauncherController();
2180   // Create a profile for our second user (will be destroyed by the framework).
2181   TestingProfile* profile2 = CreateMultiUserProfile("user2");
2182   // Check that there is a browser and a app launcher.
2183   EXPECT_EQ(2, model_->item_count());
2184
2185   // Add a v2 app.
2186   V2App v2_app(profile(), extension1_.get());
2187   EXPECT_EQ(3, model_->item_count());
2188
2189   // After switching users the item should go away.
2190   SwitchActiveUser(profile2->GetProfileName());
2191   EXPECT_EQ(2, model_->item_count());
2192
2193   // And it should come back when switching back.
2194   SwitchActiveUser(profile()->GetProfileName());
2195   EXPECT_EQ(3, model_->item_count());
2196 }
2197
2198 // Check that V2 applications are creating items properly in edge cases:
2199 // a background user creates a V2 app, gets active and inactive again and then
2200 // deletes the app.
2201 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
2202        V2AppHandlingTwoUsersEdgeCases) {
2203   InitLauncherController();
2204   // Create a profile for our second user (will be destroyed by the framework).
2205   TestingProfile* profile2 = CreateMultiUserProfile("user2");
2206   // Check that there is a browser and a app launcher.
2207   EXPECT_EQ(2, model_->item_count());
2208
2209   // Switch to an inactive user.
2210   SwitchActiveUser(profile2->GetProfileName());
2211   EXPECT_EQ(2, model_->item_count());
2212
2213   // Add the v2 app to the inactive user and check that no item was added to
2214   // the launcher.
2215   {
2216     V2App v2_app(profile(), extension1_.get());
2217     EXPECT_EQ(2, model_->item_count());
2218
2219     // Switch to the primary user and check that the item is shown.
2220     SwitchActiveUser(profile()->GetProfileName());
2221     EXPECT_EQ(3, model_->item_count());
2222
2223     // Switch to the second user and check that the item goes away - even if the
2224     // item gets closed.
2225     SwitchActiveUser(profile2->GetProfileName());
2226     EXPECT_EQ(2, model_->item_count());
2227   }
2228
2229   // After the application was killed there should be still 2 items.
2230   EXPECT_EQ(2, model_->item_count());
2231
2232   // Switching then back to the default user should not show the additional item
2233   // anymore.
2234   SwitchActiveUser(profile()->GetProfileName());
2235   EXPECT_EQ(2, model_->item_count());
2236 }
2237
2238 // Check that V2 applications will be made visible on the target desktop if
2239 // another window of the same type got previously teleported there.
2240 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
2241        V2AppFollowsTeleportedWindow) {
2242   InitLauncherController();
2243   chrome::MultiUserWindowManager* manager =
2244       chrome::MultiUserWindowManager::GetInstance();
2245
2246   // Create and add three users / profiles, and go to #1's desktop.
2247   TestingProfile* profile1 = CreateMultiUserProfile("user-1");
2248   TestingProfile* profile2 = CreateMultiUserProfile("user-2");
2249   TestingProfile* profile3 = CreateMultiUserProfile("user-3");
2250   SwitchActiveUser(profile1->GetProfileName());
2251
2252   // A v2 app for user #1 should be shown first and get hidden when switching to
2253   // desktop #2.
2254   V2App v2_app_1(profile1, extension1_.get());
2255   EXPECT_TRUE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2256   SwitchActiveUser(profile2->GetProfileName());
2257   EXPECT_FALSE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2258
2259   // Add a v2 app for user #1 while on desktop #2 should not be shown.
2260   V2App v2_app_2(profile1, extension1_.get());
2261   EXPECT_FALSE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2262   EXPECT_FALSE(v2_app_2.window()->GetNativeWindow()->IsVisible());
2263
2264   // Teleport the app from user #1 to the desktop #2 should show it.
2265   manager->ShowWindowForUser(v2_app_1.window()->GetNativeWindow(),
2266                              profile2->GetProfileName());
2267   EXPECT_TRUE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2268   EXPECT_FALSE(v2_app_2.window()->GetNativeWindow()->IsVisible());
2269
2270   // Creating a new application for user #1 on desktop #2 should teleport it
2271   // there automatically.
2272   V2App v2_app_3(profile1, extension1_.get());
2273   EXPECT_TRUE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2274   EXPECT_FALSE(v2_app_2.window()->GetNativeWindow()->IsVisible());
2275   EXPECT_TRUE(v2_app_3.window()->GetNativeWindow()->IsVisible());
2276
2277   // Switching back to desktop#1 and creating an app for user #1 should move
2278   // the app on desktop #1.
2279   SwitchActiveUser(profile1->GetProfileName());
2280   V2App v2_app_4(profile1, extension1_.get());
2281   EXPECT_FALSE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2282   EXPECT_TRUE(v2_app_2.window()->GetNativeWindow()->IsVisible());
2283   EXPECT_FALSE(v2_app_3.window()->GetNativeWindow()->IsVisible());
2284   EXPECT_TRUE(v2_app_4.window()->GetNativeWindow()->IsVisible());
2285
2286   // Switching to desktop #3 and create an app for user #1 there should land on
2287   // his own desktop (#1).
2288   SwitchActiveUser(profile3->GetProfileName());
2289   V2App v2_app_5(profile1, extension1_.get());
2290   EXPECT_FALSE(v2_app_5.window()->GetNativeWindow()->IsVisible());
2291   SwitchActiveUser(profile1->GetProfileName());
2292   EXPECT_TRUE(v2_app_5.window()->GetNativeWindow()->IsVisible());
2293
2294   // Switching to desktop #2, hiding the app window and creating an app should
2295   // teleport there automatically.
2296   SwitchActiveUser(profile2->GetProfileName());
2297   v2_app_1.window()->Hide();
2298   V2App v2_app_6(profile1, extension1_.get());
2299   EXPECT_FALSE(v2_app_1.window()->GetNativeWindow()->IsVisible());
2300   EXPECT_FALSE(v2_app_2.window()->GetNativeWindow()->IsVisible());
2301   EXPECT_TRUE(v2_app_6.window()->GetNativeWindow()->IsVisible());
2302 }
2303
2304 // Check that V2 applications hide correctly on the shelf when the app window
2305 // is hidden.
2306 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
2307        V2AppHiddenWindows) {
2308   InitLauncherController();
2309
2310   TestingProfile* profile2 = CreateMultiUserProfile("user-2");
2311   SwitchActiveUser(profile()->GetProfileName());
2312   EXPECT_EQ(2, model_->item_count());
2313
2314   V2App v2_app_1(profile(), extension1_.get());
2315   EXPECT_EQ(3, model_->item_count());
2316   {
2317     // Hide and show the app.
2318     v2_app_1.window()->Hide();
2319     EXPECT_EQ(2, model_->item_count());
2320
2321     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
2322     EXPECT_EQ(3, model_->item_count());
2323   }
2324   {
2325     // Switch user, hide and show the app and switch back.
2326     SwitchActiveUser(profile2->GetProfileName());
2327     EXPECT_EQ(2, model_->item_count());
2328
2329     v2_app_1.window()->Hide();
2330     EXPECT_EQ(2, model_->item_count());
2331
2332     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
2333     EXPECT_EQ(2, model_->item_count());
2334
2335     SwitchActiveUser(profile()->GetProfileName());
2336     EXPECT_EQ(3, model_->item_count());
2337   }
2338   {
2339     // Switch user, hide the app, switch back and then show it again.
2340     SwitchActiveUser(profile2->GetProfileName());
2341     EXPECT_EQ(2, model_->item_count());
2342
2343     v2_app_1.window()->Hide();
2344     EXPECT_EQ(2, model_->item_count());
2345
2346     SwitchActiveUser(profile()->GetProfileName());
2347     EXPECT_EQ(2, model_->item_count());
2348
2349     v2_app_1.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
2350     EXPECT_EQ(3, model_->item_count());
2351   }
2352   {
2353     // Create a second app, hide and show it and then hide both apps.
2354     V2App v2_app_2(profile(), extension1_.get());
2355     EXPECT_EQ(3, model_->item_count());
2356
2357     v2_app_2.window()->Hide();
2358     EXPECT_EQ(3, model_->item_count());
2359
2360     v2_app_2.window()->Show(extensions::AppWindow::SHOW_ACTIVE);
2361     EXPECT_EQ(3, model_->item_count());
2362
2363     v2_app_1.window()->Hide();
2364     v2_app_2.window()->Hide();
2365     EXPECT_EQ(2, model_->item_count());
2366   }
2367 }
2368 #endif  // defined(OS_CHROMEOS)
2369
2370 // Checks that the generated menu list properly activates items.
2371 TEST_F(ChromeLauncherControllerTest, V1AppMenuExecution) {
2372   InitLauncherControllerWithBrowser();
2373
2374   // Add |extension3_| to the launcher and add two items.
2375   GURL gmail = GURL("https://mail.google.com/mail/u");
2376   ash::ShelfID gmail_id = model_->next_id();
2377   extension_service_->AddExtension(extension3_.get());
2378   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
2379   base::string16 title1 = ASCIIToUTF16("Test1");
2380   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
2381   chrome::NewTab(browser());
2382   base::string16 title2 = ASCIIToUTF16("Test2");
2383   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
2384
2385   // Check that the menu is properly set.
2386   ash::ShelfItem item_gmail;
2387   item_gmail.type = ash::TYPE_APP_SHORTCUT;
2388   item_gmail.id = gmail_id;
2389   base::string16 two_menu_items[] = {title1, title2};
2390   EXPECT_TRUE(CheckMenuCreation(
2391       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
2392   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
2393   // Execute the second item in the list (which shouldn't do anything since that
2394   // item is per definition already the active tab).
2395   {
2396     scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
2397         launcher_controller_->GetApplicationList(item_gmail, 0)));
2398     // The first element in the menu is a spacing separator. On some systems
2399     // (e.g. Windows) such things do not exist. As such we check the existence
2400     // and adjust dynamically.
2401     int first_item =
2402         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
2403     menu->ActivatedAt(first_item + 3);
2404   }
2405   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
2406
2407   // Execute the first item.
2408   {
2409     scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
2410         launcher_controller_->GetApplicationList(item_gmail, 0)));
2411     int first_item =
2412         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
2413     menu->ActivatedAt(first_item + 2);
2414   }
2415   // Now the active tab should be the second item.
2416   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
2417 }
2418
2419 // Checks that the generated menu list properly deletes items.
2420 TEST_F(ChromeLauncherControllerTest, V1AppMenuDeletionExecution) {
2421   InitLauncherControllerWithBrowser();
2422
2423   // Add |extension3_| to the launcher and add two items.
2424   GURL gmail = GURL("https://mail.google.com/mail/u");
2425   ash::ShelfID gmail_id = model_->next_id();
2426   extension_service_->AddExtension(extension3_.get());
2427   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
2428   base::string16 title1 = ASCIIToUTF16("Test1");
2429   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
2430   chrome::NewTab(browser());
2431   base::string16 title2 = ASCIIToUTF16("Test2");
2432   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
2433
2434   // Check that the menu is properly set.
2435   ash::ShelfItem item_gmail;
2436   item_gmail.type = ash::TYPE_APP_SHORTCUT;
2437   item_gmail.id = gmail_id;
2438   base::string16 two_menu_items[] = {title1, title2};
2439   EXPECT_TRUE(CheckMenuCreation(
2440       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
2441
2442   int tabs = browser()->tab_strip_model()->count();
2443   // Activate the proper tab through the menu item.
2444   {
2445     ChromeLauncherAppMenuItems items =
2446         launcher_controller_->GetApplicationList(item_gmail, 0);
2447     items[1]->Execute(0);
2448     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
2449   }
2450
2451   // Delete one tab through the menu item.
2452   {
2453     ChromeLauncherAppMenuItems items =
2454         launcher_controller_->GetApplicationList(item_gmail, 0);
2455     items[1]->Execute(ui::EF_SHIFT_DOWN);
2456     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
2457   }
2458 }
2459
2460 // Tests that panels create launcher items correctly
2461 TEST_F(ChromeLauncherControllerTest, AppPanels) {
2462   InitLauncherControllerWithBrowser();
2463   // App list and Browser shortcut ShelfItems are added.
2464   EXPECT_EQ(2, model_observer_->added());
2465
2466   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
2467   SetAppIconLoader(app_icon_loader);
2468
2469   // Test adding an app panel
2470   std::string app_id = extension1_->id();
2471   AppWindowLauncherItemController* app_panel_controller =
2472       new AppWindowLauncherItemController(
2473           LauncherItemController::TYPE_APP_PANEL,
2474           "id",
2475           app_id,
2476           launcher_controller_.get());
2477   ash::ShelfID shelf_id1 = launcher_controller_->CreateAppLauncherItem(
2478       app_panel_controller, app_id, ash::STATUS_RUNNING);
2479   int panel_index = model_observer_->last_index();
2480   EXPECT_EQ(3, model_observer_->added());
2481   EXPECT_EQ(0, model_observer_->changed());
2482   EXPECT_EQ(1, app_icon_loader->fetch_count());
2483   model_observer_->clear_counts();
2484
2485   // App panels should have a separate identifier than the app id
2486   EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
2487
2488   // Setting the app image image should not change the panel if it set its icon
2489   app_panel_controller->set_image_set_by_controller(true);
2490   gfx::ImageSkia image;
2491   launcher_controller_->SetAppImage(app_id, image);
2492   EXPECT_EQ(0, model_observer_->changed());
2493   model_observer_->clear_counts();
2494
2495   // Add a second app panel and verify that it get the same index as the first
2496   // one had, being added to the left of the existing panel.
2497   AppWindowLauncherItemController* app_panel_controller2 =
2498       new AppWindowLauncherItemController(
2499           LauncherItemController::TYPE_APP_PANEL,
2500           "id",
2501           app_id,
2502           launcher_controller_.get());
2503
2504   ash::ShelfID shelf_id2 = launcher_controller_->CreateAppLauncherItem(
2505       app_panel_controller2, app_id, ash::STATUS_RUNNING);
2506   EXPECT_EQ(panel_index, model_observer_->last_index());
2507   EXPECT_EQ(1, model_observer_->added());
2508   model_observer_->clear_counts();
2509
2510   launcher_controller_->CloseLauncherItem(shelf_id2);
2511   launcher_controller_->CloseLauncherItem(shelf_id1);
2512   EXPECT_EQ(2, model_observer_->removed());
2513 }
2514
2515 // Tests that the Gmail extension matches more then the app itself claims with
2516 // the manifest file.
2517 TEST_F(ChromeLauncherControllerTest, GmailMatching) {
2518   InitLauncherControllerWithBrowser();
2519
2520   // Create a Gmail browser tab.
2521   chrome::NewTab(browser());
2522   base::string16 title = ASCIIToUTF16("Test");
2523   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title);
2524   content::WebContents* content =
2525       browser()->tab_strip_model()->GetActiveWebContents();
2526
2527   // Check that the launcher controller does not recognize the running app.
2528   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
2529
2530   // Installing |extension3_| adds it to the launcher.
2531   ash::ShelfID gmail_id = model_->next_id();
2532   extension_service_->AddExtension(extension3_.get());
2533   EXPECT_EQ(3, model_->item_count());
2534   int gmail_index = model_->ItemIndexByID(gmail_id);
2535   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[gmail_index].type);
2536   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
2537
2538   // Check that it is now handled.
2539   EXPECT_TRUE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
2540
2541   // Check also that the app has detected that properly.
2542   ash::ShelfItem item_gmail;
2543   item_gmail.type = ash::TYPE_APP_SHORTCUT;
2544   item_gmail.id = gmail_id;
2545   EXPECT_EQ(2U, launcher_controller_->GetApplicationList(item_gmail, 0).size());
2546 }
2547
2548 // Tests that the Gmail extension does not match the offline verison.
2549 TEST_F(ChromeLauncherControllerTest, GmailOfflineMatching) {
2550   InitLauncherControllerWithBrowser();
2551
2552   // Create a Gmail browser tab.
2553   chrome::NewTab(browser());
2554   base::string16 title = ASCIIToUTF16("Test");
2555   NavigateAndCommitActiveTabWithTitle(browser(),
2556                                       GURL(offline_gmail_url),
2557                                       title);
2558   content::WebContents* content =
2559       browser()->tab_strip_model()->GetActiveWebContents();
2560
2561   // Installing |extension3_| adds it to the launcher.
2562   ash::ShelfID gmail_id = model_->next_id();
2563   extension_service_->AddExtension(extension3_.get());
2564   EXPECT_EQ(3, model_->item_count());
2565   int gmail_index = model_->ItemIndexByID(gmail_id);
2566   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[gmail_index].type);
2567   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
2568
2569   // The content should not be able to be handled by the app.
2570   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
2571 }
2572
2573 // Verify that the launcher item positions are persisted and restored.
2574 TEST_F(ChromeLauncherControllerTest, PersistLauncherItemPositions) {
2575   InitLauncherController();
2576
2577   TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
2578   SetAppTabHelper(app_tab_helper);
2579
2580   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
2581   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
2582
2583   TabStripModel* tab_strip_model = browser()->tab_strip_model();
2584   EXPECT_EQ(0, tab_strip_model->count());
2585   chrome::NewTab(browser());
2586   chrome::NewTab(browser());
2587   EXPECT_EQ(2, tab_strip_model->count());
2588   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
2589   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
2590
2591   EXPECT_FALSE(launcher_controller_->IsAppPinned("1"));
2592   launcher_controller_->PinAppWithID("1");
2593   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
2594   launcher_controller_->PinAppWithID("2");
2595
2596   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
2597   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
2598   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
2599   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[3].type);
2600
2601   // Move browser shortcut item from index 1 to index 3.
2602   model_->Move(1, 3);
2603   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
2604   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
2605   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
2606   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
2607
2608   launcher_controller_.reset();
2609   if (!ash::Shell::HasInstance()) {
2610     delete item_delegate_manager_;
2611   } else {
2612     // Clear already registered ShelfItemDelegate.
2613     ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
2614     test.RemoveAllShelfItemDelegateForTest();
2615   }
2616   model_.reset(new ash::ShelfModel);
2617
2618   AddAppListLauncherItem();
2619   launcher_controller_.reset(
2620       ChromeLauncherController::CreateInstance(profile(), model_.get()));
2621   app_tab_helper = new TestAppTabHelperImpl;
2622   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
2623   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
2624   SetAppTabHelper(app_tab_helper);
2625   if (!ash::Shell::HasInstance()) {
2626     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
2627     SetShelfItemDelegateManager(item_delegate_manager_);
2628   }
2629   launcher_controller_->Init();
2630
2631   // Check ShelfItems are restored after resetting ChromeLauncherController.
2632   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
2633   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
2634   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
2635   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[3].type);
2636 }
2637
2638 // Verifies pinned apps are persisted and restored.
2639 TEST_F(ChromeLauncherControllerTest, PersistPinned) {
2640   InitLauncherControllerWithBrowser();
2641   size_t initial_size = model_->items().size();
2642
2643   TabStripModel* tab_strip_model = browser()->tab_strip_model();
2644   EXPECT_EQ(1, tab_strip_model->count());
2645
2646   TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
2647   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
2648   SetAppTabHelper(app_tab_helper);
2649
2650   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
2651   SetAppIconLoader(app_icon_loader);
2652   EXPECT_EQ(0, app_icon_loader->fetch_count());
2653
2654   launcher_controller_->PinAppWithID("1");
2655   ash::ShelfID id = launcher_controller_->GetShelfIDForAppID("1");
2656   int app_index = model_->ItemIndexByID(id);
2657   EXPECT_EQ(1, app_icon_loader->fetch_count());
2658   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
2659   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
2660   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
2661   EXPECT_EQ(initial_size + 1, model_->items().size());
2662
2663   launcher_controller_.reset();
2664   if (!ash::Shell::HasInstance()) {
2665     delete item_delegate_manager_;
2666   } else {
2667     // Clear already registered ShelfItemDelegate.
2668     ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
2669     test.RemoveAllShelfItemDelegateForTest();
2670   }
2671   model_.reset(new ash::ShelfModel);
2672
2673   AddAppListLauncherItem();
2674   launcher_controller_.reset(
2675       ChromeLauncherController::CreateInstance(profile(), model_.get()));
2676   app_tab_helper = new TestAppTabHelperImpl;
2677   app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
2678   SetAppTabHelper(app_tab_helper);
2679   app_icon_loader = new TestAppIconLoaderImpl;
2680   SetAppIconLoader(app_icon_loader);
2681   if (!ash::Shell::HasInstance()) {
2682     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
2683     SetShelfItemDelegateManager(item_delegate_manager_);
2684   }
2685   launcher_controller_->Init();
2686
2687   EXPECT_EQ(1, app_icon_loader->fetch_count());
2688   ASSERT_EQ(initial_size + 1, model_->items().size());
2689   EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
2690   EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
2691   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
2692
2693   launcher_controller_->UnpinAppWithID("1");
2694   ASSERT_EQ(initial_size, model_->items().size());
2695 }