chrome/browser/background/background_mode_manager_unittest.cc

   1 // Copyright (c) 2011 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 "base/command_line.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/background/background_mode_manager.h"
  10 #include "chrome/browser/browser_shutdown.h"
  11 #include "chrome/browser/extensions/extension_function_test_utils.h"
  12 #include "chrome/browser/extensions/extension_service.h"
  13 #include "chrome/browser/extensions/test_extension_system.h"
  14 #include "chrome/browser/lifetime/application_lifetime.h"
  15 #include "chrome/browser/profiles/profile_info_cache.h"
  16 #include "chrome/browser/status_icons/status_icon_menu_model.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/test/base/testing_browser_process.h"
  19 #include "chrome/test/base/testing_profile.h"
  20 #include "chrome/test/base/testing_profile_manager.h"
  21 #include "content/public/test/test_browser_thread_bundle.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23 #include "ui/gfx/image/image.h"
  24 #include "ui/gfx/image/image_unittest_util.h"
  25 #include "ui/message_center/message_center.h"
  26
  27 #if defined(OS_CHROMEOS)
  28 #include "chrome/browser/chromeos/login/user_manager.h"
  29 #include "chrome/browser/chromeos/settings/cros_settings.h"
  30 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  31 #endif
  32
  33 class BackgroundModeManagerTest : public testing::Test {
  34  public:
  35   BackgroundModeManagerTest() {}
  36   virtual ~BackgroundModeManagerTest() {}
  37   virtual void SetUp() {
  38     command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
  39   }
  40   scoped_ptr<CommandLine> command_line_;
  41
  42  protected:
  43   scoped_refptr<extensions::Extension> CreateExtension(
  44       extensions::Manifest::Location location,
  45       const std::string& data,
  46       const std::string& id) {
  47     scoped_ptr<base::DictionaryValue> parsed_manifest(
  48         extension_function_test_utils::ParseDictionary(data));
  49     return extension_function_test_utils::CreateExtension(
  50         location,
  51         parsed_manifest.get(),
  52         id);
  53   }
  54
  55   scoped_ptr<TestingProfileManager> CreateTestingProfileManager() {
  56     scoped_ptr<TestingProfileManager> profile_manager
  57         (new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
  58     EXPECT_TRUE(profile_manager->SetUp());
  59     return profile_manager.Pass();
  60   }
  61
  62   // From views::MenuModelAdapter::IsCommandEnabled with modification.
  63   bool IsCommandEnabled(ui::MenuModel* model, int id) const {
  64     int index = 0;
  65     if (ui::MenuModel::GetModelAndIndexForCommandId(id, &model, &index))
  66       return model->IsEnabledAt(index);
  67
  68     return false;
  69   }
  70
  71  private:
  72   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManagerTest);
  73 };
  74
  75 class TestBackgroundModeManager : public BackgroundModeManager {
  76  public:
  77   TestBackgroundModeManager(
  78       CommandLine* command_line, ProfileInfoCache* cache, bool enabled)
  79       : BackgroundModeManager(command_line, cache),
  80         enabled_(enabled),
  81         app_count_(0),
  82         profile_app_count_(0),
  83         have_status_tray_(false),
  84         launch_on_startup_(false) {
  85     ResumeBackgroundMode();
  86   }
  87   virtual void EnableLaunchOnStartup(bool launch) OVERRIDE {
  88     launch_on_startup_ = launch;
  89   }
  90   virtual void DisplayAppInstalledNotification(
  91       const extensions::Extension* extension) OVERRIDE {}
  92   virtual void CreateStatusTrayIcon() OVERRIDE { have_status_tray_ = true; }
  93   virtual void RemoveStatusTrayIcon() OVERRIDE { have_status_tray_ = false; }
  94   virtual int GetBackgroundAppCount() const OVERRIDE { return app_count_; }
  95   virtual int GetBackgroundAppCountForProfile(
  96       Profile* const profile) const OVERRIDE {
  97     return profile_app_count_;
  98   }
  99   virtual bool IsBackgroundModePrefEnabled() const OVERRIDE { return enabled_; }
 100   void SetBackgroundAppCount(int count) { app_count_ = count; }
 101   void SetBackgroundAppCountForProfile(int count) {
 102     profile_app_count_ = count;
 103   }
 104   void SetEnabled(bool enabled) {
 105     enabled_ = enabled;
 106     OnBackgroundModeEnabledPrefChanged();
 107   }
 108   bool HaveStatusTray() const { return have_status_tray_; }
 109   bool IsLaunchOnStartup() const { return launch_on_startup_; }
 110  private:
 111   bool enabled_;
 112   int app_count_;
 113   int profile_app_count_;
 114
 115   // Flags to track whether we are launching on startup/have a status tray.
 116   bool have_status_tray_;
 117   bool launch_on_startup_;
 118 };
 119
 120 class TestStatusIcon : public StatusIcon {
 121   virtual void SetImage(const gfx::ImageSkia& image) OVERRIDE {}
 122   virtual void SetPressedImage(const gfx::ImageSkia& image) OVERRIDE {}
 123   virtual void SetToolTip(const base::string16& tool_tip) OVERRIDE {}
 124   virtual void DisplayBalloon(const gfx::ImageSkia& icon,
 125                               const base::string16& title,
 126                               const base::string16& contents) OVERRIDE {}
 127   virtual void UpdatePlatformContextMenu(
 128       StatusIconMenuModel* menu) OVERRIDE {}
 129 };
 130
 131 static void AssertBackgroundModeActive(
 132     const TestBackgroundModeManager& manager) {
 133   EXPECT_TRUE(chrome::WillKeepAlive());
 134   EXPECT_TRUE(manager.HaveStatusTray());
 135   EXPECT_TRUE(manager.IsLaunchOnStartup());
 136 }
 137
 138 static void AssertBackgroundModeInactive(
 139     const TestBackgroundModeManager& manager) {
 140   EXPECT_FALSE(chrome::WillKeepAlive());
 141   EXPECT_FALSE(manager.HaveStatusTray());
 142   EXPECT_FALSE(manager.IsLaunchOnStartup());
 143 }
 144
 145 static void AssertBackgroundModeSuspended(
 146     const TestBackgroundModeManager& manager) {
 147   EXPECT_FALSE(chrome::WillKeepAlive());
 148   EXPECT_FALSE(manager.HaveStatusTray());
 149   EXPECT_TRUE(manager.IsLaunchOnStartup());
 150 }
 151
 152 TEST_F(BackgroundModeManagerTest, BackgroundAppLoadUnload) {
 153   scoped_ptr<TestingProfileManager> profile_manager =
 154       CreateTestingProfileManager();
 155   TestingProfile* profile = profile_manager->CreateTestingProfile("p1");
 156   TestBackgroundModeManager manager(
 157       command_line_.get(), profile_manager->profile_info_cache(), true);
 158   manager.RegisterProfile(profile);
 159   EXPECT_FALSE(chrome::WillKeepAlive());
 160
 161   // Mimic app load.
 162   manager.OnBackgroundAppInstalled(NULL);
 163   manager.SetBackgroundAppCount(1);
 164   manager.OnApplicationListChanged(profile);
 165   AssertBackgroundModeActive(manager);
 166
 167   manager.SuspendBackgroundMode();
 168   AssertBackgroundModeSuspended(manager);
 169   manager.ResumeBackgroundMode();
 170
 171   // Mimic app unload.
 172   manager.SetBackgroundAppCount(0);
 173   manager.OnApplicationListChanged(profile);
 174   AssertBackgroundModeInactive(manager);
 175
 176   manager.SuspendBackgroundMode();
 177   AssertBackgroundModeInactive(manager);
 178
 179   // Mimic app load while suspended, e.g. from sync. This should enable and
 180   // resume background mode.
 181   manager.OnBackgroundAppInstalled(NULL);
 182   manager.SetBackgroundAppCount(1);
 183   manager.OnApplicationListChanged(profile);
 184   AssertBackgroundModeActive(manager);
 185 }
 186
 187 // App installs while background mode is disabled should do nothing.
 188 TEST_F(BackgroundModeManagerTest, BackgroundAppInstallUninstallWhileDisabled) {
 189   scoped_ptr<TestingProfileManager> profile_manager =
 190       CreateTestingProfileManager();
 191   TestingProfile* profile = profile_manager->CreateTestingProfile("p1");
 192   TestBackgroundModeManager manager(
 193       command_line_.get(), profile_manager->profile_info_cache(), true);
 194   manager.RegisterProfile(profile);
 195   // Turn off background mode.
 196   manager.SetEnabled(false);
 197   manager.DisableBackgroundMode();
 198   AssertBackgroundModeInactive(manager);
 199
 200   // Status tray icons will not be created, launch on startup status will not
 201   // be modified.
 202   manager.OnBackgroundAppInstalled(NULL);
 203   manager.SetBackgroundAppCount(1);
 204   manager.OnApplicationListChanged(profile);
 205   AssertBackgroundModeInactive(manager);
 206
 207   manager.SetBackgroundAppCount(0);
 208   manager.OnApplicationListChanged(profile);
 209   AssertBackgroundModeInactive(manager);
 210
 211   // Re-enable background mode.
 212   manager.SetEnabled(true);
 213   manager.EnableBackgroundMode();
 214   AssertBackgroundModeInactive(manager);
 215 }
 216
 217
 218 // App installs while disabled should do nothing until background mode is
 219 // enabled..
 220 TEST_F(BackgroundModeManagerTest, EnableAfterBackgroundAppInstall) {
 221   scoped_ptr<TestingProfileManager> profile_manager =
 222       CreateTestingProfileManager();
 223   TestingProfile* profile = profile_manager->CreateTestingProfile("p1");
 224   TestBackgroundModeManager manager(
 225       command_line_.get(), profile_manager->profile_info_cache(), true);
 226   manager.RegisterProfile(profile);
 227
 228   // Install app, should show status tray icon.
 229   manager.OnBackgroundAppInstalled(NULL);
 230   // OnBackgroundAppInstalled does not actually add an app to the
 231   // BackgroundApplicationListModel which would result in another
 232   // call to CreateStatusTray.
 233   manager.SetBackgroundAppCount(1);
 234   manager.OnApplicationListChanged(profile);
 235   AssertBackgroundModeActive(manager);
 236
 237   // Turn off background mode - should hide status tray icon.
 238   manager.SetEnabled(false);
 239   manager.DisableBackgroundMode();
 240   AssertBackgroundModeInactive(manager);
 241
 242   // Turn back on background mode - again, no status tray icon
 243   // will show up since we didn't actually add anything to the list.
 244   manager.SetEnabled(true);
 245   manager.EnableBackgroundMode();
 246   AssertBackgroundModeActive(manager);
 247
 248   // Uninstall app, should hide status tray icon again.
 249   manager.SetBackgroundAppCount(0);
 250   manager.OnApplicationListChanged(profile);
 251   AssertBackgroundModeInactive(manager);
 252 }
 253
 254 TEST_F(BackgroundModeManagerTest, MultiProfile) {
 255   scoped_ptr<TestingProfileManager> profile_manager =
 256       CreateTestingProfileManager();
 257   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 258   TestingProfile* profile2 = profile_manager->CreateTestingProfile("p2");
 259   TestBackgroundModeManager manager(
 260       command_line_.get(), profile_manager->profile_info_cache(), true);
 261   manager.RegisterProfile(profile1);
 262   manager.RegisterProfile(profile2);
 263   EXPECT_FALSE(chrome::WillKeepAlive());
 264
 265   // Install app, should show status tray icon.
 266   manager.OnBackgroundAppInstalled(NULL);
 267   manager.SetBackgroundAppCount(1);
 268   manager.OnApplicationListChanged(profile1);
 269   AssertBackgroundModeActive(manager);
 270
 271   // Install app for other profile, hsould show other status tray icon.
 272   manager.OnBackgroundAppInstalled(NULL);
 273   manager.SetBackgroundAppCount(2);
 274   manager.OnApplicationListChanged(profile2);
 275   AssertBackgroundModeActive(manager);
 276
 277   // Should hide both status tray icons.
 278   manager.SetEnabled(false);
 279   manager.DisableBackgroundMode();
 280   AssertBackgroundModeInactive(manager);
 281
 282   // Turn back on background mode - should show both status tray icons.
 283   manager.SetEnabled(true);
 284   manager.EnableBackgroundMode();
 285   AssertBackgroundModeActive(manager);
 286
 287   manager.SetBackgroundAppCount(1);
 288   manager.OnApplicationListChanged(profile2);
 289   // There is still one background app alive
 290   AssertBackgroundModeActive(manager);
 291
 292   manager.SetBackgroundAppCount(0);
 293   manager.OnApplicationListChanged(profile1);
 294   AssertBackgroundModeInactive(manager);
 295 }
 296
 297 TEST_F(BackgroundModeManagerTest, ProfileInfoCacheStorage) {
 298   scoped_ptr<TestingProfileManager> profile_manager =
 299       CreateTestingProfileManager();
 300   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 301   TestingProfile* profile2 = profile_manager->CreateTestingProfile("p2");
 302   TestBackgroundModeManager manager(
 303       command_line_.get(), profile_manager->profile_info_cache(), true);
 304   manager.RegisterProfile(profile1);
 305   manager.RegisterProfile(profile2);
 306   EXPECT_FALSE(chrome::WillKeepAlive());
 307
 308   ProfileInfoCache* cache = profile_manager->profile_info_cache();
 309   EXPECT_EQ(2u, cache->GetNumberOfProfiles());
 310
 311   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(0));
 312   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(1));
 313
 314   // Install app, should show status tray icon.
 315   manager.OnBackgroundAppInstalled(NULL);
 316   manager.SetBackgroundAppCount(1);
 317   manager.SetBackgroundAppCountForProfile(1);
 318   manager.OnApplicationListChanged(profile1);
 319
 320   // Install app for other profile.
 321   manager.OnBackgroundAppInstalled(NULL);
 322   manager.SetBackgroundAppCount(1);
 323   manager.SetBackgroundAppCountForProfile(1);
 324   manager.OnApplicationListChanged(profile2);
 325
 326   EXPECT_TRUE(cache->GetBackgroundStatusOfProfileAtIndex(0));
 327   EXPECT_TRUE(cache->GetBackgroundStatusOfProfileAtIndex(1));
 328
 329   manager.SetBackgroundAppCountForProfile(0);
 330   manager.OnApplicationListChanged(profile1);
 331
 332   size_t p1_index = cache->GetIndexOfProfileWithPath(profile1->GetPath());
 333   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(p1_index));
 334
 335   manager.SetBackgroundAppCountForProfile(0);
 336   manager.OnApplicationListChanged(profile2);
 337
 338   size_t p2_index = cache->GetIndexOfProfileWithPath(profile1->GetPath());
 339   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(p2_index));
 340
 341   // Even though neither has background status on, there should still be two
 342   // profiles in the cache.
 343   EXPECT_EQ(2u, cache->GetNumberOfProfiles());
 344 }
 345
 346 TEST_F(BackgroundModeManagerTest, ProfileInfoCacheObserver) {
 347   scoped_ptr<TestingProfileManager> profile_manager =
 348       CreateTestingProfileManager();
 349   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 350   TestBackgroundModeManager manager(
 351       command_line_.get(), profile_manager->profile_info_cache(), true);
 352   manager.RegisterProfile(profile1);
 353   EXPECT_FALSE(chrome::WillKeepAlive());
 354
 355   // Install app, should show status tray icon.
 356   manager.OnBackgroundAppInstalled(NULL);
 357   manager.SetBackgroundAppCount(1);
 358   manager.SetBackgroundAppCountForProfile(1);
 359   manager.OnApplicationListChanged(profile1);
 360
 361   manager.OnProfileNameChanged(
 362       profile1->GetPath(),
 363       manager.GetBackgroundModeData(profile1)->name());
 364
 365   EXPECT_EQ(base::UTF8ToUTF16("p1"),
 366             manager.GetBackgroundModeData(profile1)->name());
 367
 368   TestingProfile* profile2 = profile_manager->CreateTestingProfile("p2");
 369   manager.RegisterProfile(profile2);
 370   EXPECT_EQ(2, manager.NumberOfBackgroundModeData());
 371
 372   manager.OnProfileAdded(profile2->GetPath());
 373   EXPECT_EQ(base::UTF8ToUTF16("p2"),
 374             manager.GetBackgroundModeData(profile2)->name());
 375
 376   manager.OnProfileWillBeRemoved(profile2->GetPath());
 377   EXPECT_EQ(1, manager.NumberOfBackgroundModeData());
 378
 379   // Check that the background mode data we think is in the map actually is.
 380   EXPECT_EQ(base::UTF8ToUTF16("p1"),
 381             manager.GetBackgroundModeData(profile1)->name());
 382 }
 383
 384 TEST_F(BackgroundModeManagerTest, DisableBackgroundModeUnderTestFlag) {
 385   scoped_ptr<TestingProfileManager> profile_manager =
 386       CreateTestingProfileManager();
 387   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 388   command_line_->AppendSwitch(switches::kKeepAliveForTest);
 389   TestBackgroundModeManager manager(
 390       command_line_.get(), profile_manager->profile_info_cache(), true);
 391   manager.RegisterProfile(profile1);
 392   EXPECT_TRUE(manager.ShouldBeInBackgroundMode());
 393   manager.SetEnabled(false);
 394   EXPECT_FALSE(manager.ShouldBeInBackgroundMode());
 395 }
 396
 397 TEST_F(BackgroundModeManagerTest,
 398        BackgroundModeDisabledPreventsKeepAliveOnStartup) {
 399   scoped_ptr<TestingProfileManager> profile_manager =
 400       CreateTestingProfileManager();
 401   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 402   command_line_->AppendSwitch(switches::kKeepAliveForTest);
 403   TestBackgroundModeManager manager(
 404       command_line_.get(), profile_manager->profile_info_cache(), false);
 405   manager.RegisterProfile(profile1);
 406   EXPECT_FALSE(manager.ShouldBeInBackgroundMode());
 407 }
 408
 409 TEST_F(BackgroundModeManagerTest, BackgroundMenuGeneration) {
 410   // Aura clears notifications from the message center at shutdown.
 411   message_center::MessageCenter::Initialize();
 412
 413   // Required for extension service.
 414   content::TestBrowserThreadBundle thread_bundle;
 415
 416   scoped_ptr<TestingProfileManager> profile_manager =
 417       CreateTestingProfileManager();
 418
 419   // BackgroundModeManager actually affects Chrome start/stop state,
 420   // tearing down our thread bundle before we've had chance to clean
 421   // everything up. Keeping Chrome alive prevents this.
 422   // We aren't interested in if the keep alive works correctly in this test.
 423   chrome::StartKeepAlive();
 424   TestingProfile* profile = profile_manager->CreateTestingProfile("p");
 425
 426 #if defined(OS_CHROMEOS)
 427   // ChromeOS needs extra services to run in the following order.
 428   chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
 429   chromeos::ScopedTestCrosSettings test_cros_settings;
 430   chromeos::ScopedTestUserManager test_user_manager;
 431
 432   // On ChromeOS shutdown, HandleAppExitingForPlatform will call
 433   // chrome::EndKeepAlive because it assumes the aura shell
 434   // called chrome::StartKeepAlive. Simulate the call here.
 435   chrome::StartKeepAlive();
 436 #endif
 437
 438   scoped_refptr<extensions::Extension> component_extension(
 439     CreateExtension(
 440         extensions::Manifest::COMPONENT,
 441         "{\"name\": \"Component Extension\","
 442         "\"version\": \"1.0\","
 443         "\"manifest_version\": 2,"
 444         "\"permissions\": [\"background\"]}",
 445         "ID-1"));
 446
 447   scoped_refptr<extensions::Extension> component_extension_with_options(
 448     CreateExtension(
 449         extensions::Manifest::COMPONENT,
 450         "{\"name\": \"Component Extension with Options\","
 451         "\"version\": \"1.0\","
 452         "\"manifest_version\": 2,"
 453         "\"permissions\": [\"background\"],"
 454         "\"options_page\": \"test.html\"}",
 455         "ID-2"));
 456
 457   scoped_refptr<extensions::Extension> regular_extension(
 458     CreateExtension(
 459         extensions::Manifest::COMMAND_LINE,
 460         "{\"name\": \"Regular Extension\", "
 461         "\"version\": \"1.0\","
 462         "\"manifest_version\": 2,"
 463         "\"permissions\": [\"background\"]}",
 464         "ID-3"));
 465
 466   scoped_refptr<extensions::Extension> regular_extension_with_options(
 467     CreateExtension(
 468         extensions::Manifest::COMMAND_LINE,
 469         "{\"name\": \"Regular Extension with Options\","
 470         "\"version\": \"1.0\","
 471         "\"manifest_version\": 2,"
 472         "\"permissions\": [\"background\"],"
 473         "\"options_page\": \"test.html\"}",
 474         "ID-4"));
 475
 476   static_cast<extensions::TestExtensionSystem*>(
 477       extensions::ExtensionSystem::Get(profile))->CreateExtensionService(
 478           CommandLine::ForCurrentProcess(),
 479           base::FilePath(),
 480           false);
 481   ExtensionService* service = profile->GetExtensionService();
 482   service->Init();
 483
 484   service->AddComponentExtension(component_extension);
 485   service->AddComponentExtension(component_extension_with_options);
 486   service->AddExtension(regular_extension);
 487   service->AddExtension(regular_extension_with_options);
 488
 489   scoped_ptr<TestBackgroundModeManager> manager(new TestBackgroundModeManager(
 490       command_line_.get(), profile_manager->profile_info_cache(), true));
 491   manager->RegisterProfile(profile);
 492
 493   scoped_ptr<StatusIconMenuModel> menu(new StatusIconMenuModel(NULL));
 494   scoped_ptr<StatusIconMenuModel> submenu(new StatusIconMenuModel(NULL));
 495   BackgroundModeManager::BackgroundModeData* bmd =
 496       manager->GetBackgroundModeData(profile);
 497   bmd->BuildProfileMenu(submenu.get(), menu.get());
 498   EXPECT_TRUE(
 499       submenu->GetLabelAt(0) ==
 500           base::UTF8ToUTF16("Component Extension"));
 501   EXPECT_FALSE(submenu->IsCommandIdEnabled(submenu->GetCommandIdAt(0)));
 502   EXPECT_TRUE(
 503       submenu->GetLabelAt(1) ==
 504           base::UTF8ToUTF16("Component Extension with Options"));
 505   EXPECT_TRUE(submenu->IsCommandIdEnabled(submenu->GetCommandIdAt(1)));
 506   EXPECT_TRUE(
 507       submenu->GetLabelAt(2) ==
 508           base::UTF8ToUTF16("Regular Extension"));
 509   EXPECT_TRUE(submenu->IsCommandIdEnabled(submenu->GetCommandIdAt(2)));
 510   EXPECT_TRUE(
 511       submenu->GetLabelAt(3) ==
 512           base::UTF8ToUTF16("Regular Extension with Options"));
 513   EXPECT_TRUE(submenu->IsCommandIdEnabled(submenu->GetCommandIdAt(3)));
 514
 515   // We have to destroy the profile now because we created it with real thread
 516   // state. This causes a lot of machinery to spin up that stops working
 517   // when we tear down our thread state at the end of the test.
 518   profile_manager->DeleteTestingProfile("p");
 519
 520   // We're getting ready to shutdown the message loop. Clear everything out!
 521   base::MessageLoop::current()->RunUntilIdle();
 522   chrome::EndKeepAlive(); // Matching the above chrome::StartKeepAlive().
 523
 524   // TestBackgroundModeManager has dependencies on the infrastructure.
 525   // It should get cleared first.
 526   manager.reset();
 527
 528   // The Profile Manager references the Browser Process.
 529   // The Browser Process references the Notification UI Manager.
 530   // The Notification UI Manager references the Message Center.
 531   // As a result, we have to clear the browser process state here
 532   // before tearing down the Message Center.
 533   profile_manager.reset();
 534
 535   // Message Center shutdown must occur after the EndKeepAlive because
 536   // EndKeepAlive will end up referencing the message center during cleanup.
 537   message_center::MessageCenter::Shutdown();
 538
 539   // Clear the shutdown flag to isolate the remaining effect of this test.
 540   browser_shutdown::SetTryingToQuit(false);
 541 }
 542
 543 TEST_F(BackgroundModeManagerTest, BackgroundMenuGenerationMultipleProfile) {
 544   // Aura clears notifications from the message center at shutdown.
 545   message_center::MessageCenter::Initialize();
 546
 547   // Required for extension service.
 548   content::TestBrowserThreadBundle thread_bundle;
 549
 550   scoped_ptr<TestingProfileManager> profile_manager =
 551       CreateTestingProfileManager();
 552
 553   // BackgroundModeManager actually affects Chrome start/stop state,
 554   // tearing down our thread bundle before we've had chance to clean
 555   // everything up. Keeping Chrome alive prevents this.
 556   // We aren't interested in if the keep alive works correctly in this test.
 557   chrome::StartKeepAlive();
 558   TestingProfile* profile1 = profile_manager->CreateTestingProfile("p1");
 559   TestingProfile* profile2 = profile_manager->CreateTestingProfile("p2");
 560
 561 #if defined(OS_CHROMEOS)
 562   // ChromeOS needs extensionsra services to run in the following order.
 563   chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
 564   chromeos::ScopedTestCrosSettings test_cros_settings;
 565   chromeos::ScopedTestUserManager test_user_manager;
 566
 567   // On ChromeOS shutdown, HandleAppExitingForPlatform will call
 568   // chrome::EndKeepAlive because it assumes the aura shell
 569   // called chrome::StartKeepAlive. Simulate the call here.
 570   chrome::StartKeepAlive();
 571 #endif
 572
 573   scoped_refptr<extensions::Extension> component_extension(
 574     CreateExtension(
 575         extensions::Manifest::COMPONENT,
 576         "{\"name\": \"Component Extension\","
 577         "\"version\": \"1.0\","
 578         "\"manifest_version\": 2,"
 579         "\"permissions\": [\"background\"]}",
 580         "ID-1"));
 581
 582   scoped_refptr<extensions::Extension> component_extension_with_options(
 583     CreateExtension(
 584         extensions::Manifest::COMPONENT,
 585         "{\"name\": \"Component Extension with Options\","
 586         "\"version\": \"1.0\","
 587         "\"manifest_version\": 2,"
 588         "\"permissions\": [\"background\"],"
 589         "\"options_page\": \"test.html\"}",
 590         "ID-2"));
 591
 592   scoped_refptr<extensions::Extension> regular_extension(
 593     CreateExtension(
 594         extensions::Manifest::COMMAND_LINE,
 595         "{\"name\": \"Regular Extension\", "
 596         "\"version\": \"1.0\","
 597         "\"manifest_version\": 2,"
 598         "\"permissions\": [\"background\"]}",
 599         "ID-3"));
 600
 601   scoped_refptr<extensions::Extension> regular_extension_with_options(
 602     CreateExtension(
 603         extensions::Manifest::COMMAND_LINE,
 604         "{\"name\": \"Regular Extension with Options\","
 605         "\"version\": \"1.0\","
 606         "\"manifest_version\": 2,"
 607         "\"permissions\": [\"background\"],"
 608         "\"options_page\": \"test.html\"}",
 609         "ID-4"));
 610
 611   static_cast<extensions::TestExtensionSystem*>(
 612       extensions::ExtensionSystem::Get(profile1))->CreateExtensionService(
 613           CommandLine::ForCurrentProcess(),
 614           base::FilePath(),
 615           false);
 616   ExtensionService* service1 = profile1->GetExtensionService();
 617   service1->Init();
 618
 619   service1->AddComponentExtension(component_extension);
 620   service1->AddComponentExtension(component_extension_with_options);
 621   service1->AddExtension(regular_extension);
 622   service1->AddExtension(regular_extension_with_options);
 623
 624   static_cast<extensions::TestExtensionSystem*>(
 625       extensions::ExtensionSystem::Get(profile2))->CreateExtensionService(
 626           CommandLine::ForCurrentProcess(),
 627           base::FilePath(),
 628           false);
 629   ExtensionService* service2 = profile2->GetExtensionService();
 630   service2->Init();
 631
 632   service2->AddComponentExtension(component_extension);
 633   service2->AddExtension(regular_extension);
 634   service2->AddExtension(regular_extension_with_options);
 635
 636   scoped_ptr<TestBackgroundModeManager> manager(new TestBackgroundModeManager(
 637       command_line_.get(), profile_manager->profile_info_cache(), true));
 638   manager->RegisterProfile(profile1);
 639   manager->RegisterProfile(profile2);
 640
 641   manager->status_icon_ = new TestStatusIcon();
 642   manager->UpdateStatusTrayIconContextMenu();
 643   StatusIconMenuModel* context_menu = manager->context_menu_;
 644   EXPECT_TRUE(context_menu != NULL);
 645
 646   // Background Profile Enable Checks
 647   EXPECT_TRUE(context_menu->GetLabelAt(3) == base::UTF8ToUTF16("p1"));
 648   EXPECT_TRUE(
 649       context_menu->IsCommandIdEnabled(context_menu->GetCommandIdAt(3)));
 650   EXPECT_TRUE(context_menu->GetCommandIdAt(3) == 4);
 651
 652   EXPECT_TRUE(context_menu->GetLabelAt(4) == base::UTF8ToUTF16("p2"));
 653   EXPECT_TRUE(
 654       context_menu->IsCommandIdEnabled(context_menu->GetCommandIdAt(4)));
 655   EXPECT_TRUE(context_menu->GetCommandIdAt(4) == 8);
 656
 657   // Profile 1 Submenu Checks
 658   StatusIconMenuModel* profile1_submenu =
 659       static_cast<StatusIconMenuModel*>(context_menu->GetSubmenuModelAt(3));
 660   EXPECT_TRUE(
 661       profile1_submenu->GetLabelAt(0) ==
 662           base::UTF8ToUTF16("Component Extension"));
 663   EXPECT_FALSE(
 664       profile1_submenu->IsCommandIdEnabled(
 665           profile1_submenu->GetCommandIdAt(0)));
 666   EXPECT_TRUE(profile1_submenu->GetCommandIdAt(0) == 0);
 667   EXPECT_TRUE(
 668       profile1_submenu->GetLabelAt(1) ==
 669           base::UTF8ToUTF16("Component Extension with Options"));
 670   EXPECT_TRUE(
 671       profile1_submenu->IsCommandIdEnabled(
 672           profile1_submenu->GetCommandIdAt(1)));
 673   EXPECT_TRUE(profile1_submenu->GetCommandIdAt(1) == 1);
 674   EXPECT_TRUE(
 675       profile1_submenu->GetLabelAt(2) ==
 676           base::UTF8ToUTF16("Regular Extension"));
 677   EXPECT_TRUE(
 678       profile1_submenu->IsCommandIdEnabled(
 679           profile1_submenu->GetCommandIdAt(2)));
 680   EXPECT_TRUE(profile1_submenu->GetCommandIdAt(2) == 2);
 681   EXPECT_TRUE(
 682       profile1_submenu->GetLabelAt(3) ==
 683           base::UTF8ToUTF16("Regular Extension with Options"));
 684   EXPECT_TRUE(
 685       profile1_submenu->IsCommandIdEnabled(
 686           profile1_submenu->GetCommandIdAt(3)));
 687   EXPECT_TRUE(profile1_submenu->GetCommandIdAt(3) == 3);
 688
 689   // Profile 2 Submenu Checks
 690   StatusIconMenuModel* profile2_submenu =
 691       static_cast<StatusIconMenuModel*>(context_menu->GetSubmenuModelAt(4));
 692   EXPECT_TRUE(
 693       profile2_submenu->GetLabelAt(0) ==
 694           base::UTF8ToUTF16("Component Extension"));
 695   EXPECT_FALSE(
 696       profile2_submenu->IsCommandIdEnabled(
 697           profile2_submenu->GetCommandIdAt(0)));
 698   EXPECT_TRUE(profile2_submenu->GetCommandIdAt(0) == 5);
 699   EXPECT_TRUE(
 700       profile2_submenu->GetLabelAt(1) ==
 701           base::UTF8ToUTF16("Regular Extension"));
 702   EXPECT_TRUE(
 703       profile2_submenu->IsCommandIdEnabled(
 704           profile2_submenu->GetCommandIdAt(1)));
 705   EXPECT_TRUE(profile2_submenu->GetCommandIdAt(1) == 6);
 706   EXPECT_TRUE(
 707       profile2_submenu->GetLabelAt(2) ==
 708           base::UTF8ToUTF16("Regular Extension with Options"));
 709   EXPECT_TRUE(
 710       profile2_submenu->IsCommandIdEnabled(
 711           profile2_submenu->GetCommandIdAt(2)));
 712   EXPECT_TRUE(profile2_submenu->GetCommandIdAt(2) == 7);
 713
 714   // Model Adapter Checks for crbug.com/315164
 715   // P1: Profile 1 Menu Item
 716   // P2: Profile 2 Menu Item
 717   // CE: Component Extension Menu Item
 718   // CEO: Component Extenison with Options Menu Item
 719   // RE: Regular Extension Menu Item
 720   // REO: Regular Extension with Options Menu Item
 721   EXPECT_FALSE(IsCommandEnabled(context_menu, 0)); // P1 - CE
 722   EXPECT_TRUE(IsCommandEnabled(context_menu, 1));  // P1 - CEO
 723   EXPECT_TRUE(IsCommandEnabled(context_menu, 2));  // P1 - RE
 724   EXPECT_TRUE(IsCommandEnabled(context_menu, 3));  // P1 - REO
 725   EXPECT_TRUE(IsCommandEnabled(context_menu, 4));  // P1
 726   EXPECT_FALSE(IsCommandEnabled(context_menu, 5)); // P2 - CE
 727   EXPECT_TRUE(IsCommandEnabled(context_menu, 6));  // P2 - RE
 728   EXPECT_TRUE(IsCommandEnabled(context_menu, 7));  // P2 - REO
 729   EXPECT_TRUE(IsCommandEnabled(context_menu, 8));  // P2
 730
 731   // Clean up the status icon. If this is not done before profile deletes,
 732   // the context menu updates will DCHECK with the now deleted profiles.
 733   StatusIcon* status_icon = manager->status_icon_;
 734   manager->status_icon_ = NULL;
 735   delete status_icon;
 736
 737   // We have to destroy the profiles now because we created them with real
 738   // thread state. This causes a lot of machinery to spin up that stops working
 739   // when we tear down our thread state at the end of the test.
 740   profile_manager->DeleteTestingProfile("p2");
 741   profile_manager->DeleteTestingProfile("p1");
 742
 743   // We're getting ready to shutdown the message loop. Clear everything out!
 744   base::MessageLoop::current()->RunUntilIdle();
 745   chrome::EndKeepAlive(); // Matching the above chrome::StartKeepAlive().
 746
 747   // TestBackgroundModeManager has dependencies on the infrastructure.
 748   // It should get cleared first.
 749   manager.reset();
 750
 751   // The Profile Manager references the Browser Process.
 752   // The Browser Process references the Notification UI Manager.
 753   // The Notification UI Manager references the Message Center.
 754   // As a result, we have to clear the browser process state here
 755   // before tearing down the Message Center.
 756   profile_manager.reset();
 757
 758   // Message Center shutdown must occur after the EndKeepAlive because
 759   // EndKeepAlive will end up referencing the message center during cleanup.
 760   message_center::MessageCenter::Shutdown();
 761
 762   // Clear the shutdown flag to isolate the remaining effect of this test.
 763   browser_shutdown::SetTryingToQuit(false);
 764 }