Cleanup: Pull some browser keep alive functions into its own file.

chrome/browser/background/background_mode_manager_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/background/background_trigger.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/lifetime/browser_keep_alive.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/status_icons/status_icon_menu_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/api_test_utils.h"
 #include "extensions/browser/extension_prefs.h"
@@ skipping 94 matching lines @@
   void DisplayBalloon(const gfx::ImageSkia& icon,
                       const base::string16& title,
                       const base::string16& contents) override {}
   void UpdatePlatformContextMenu(StatusIconMenuModel* menu) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestStatusIcon);
 };
 
 void AssertBackgroundModeActive(const TestBackgroundModeManager& manager) {
-  EXPECT_TRUE(chrome::WillKeepAlive());
+  EXPECT_TRUE(browser_lifetime::WillKeepAlive());
   EXPECT_TRUE(manager.HaveStatusTray());
 }
 
 void AssertBackgroundModeInactive(const TestBackgroundModeManager& manager) {
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
   EXPECT_FALSE(manager.HaveStatusTray());
 }
 
 }  // namespace
 
 // More complex test helper that exposes APIs for fine grained control of
 // things like the number of background applications. This allows writing
 // smaller tests that don't have to install/uninstall extensions.
 class AdvancedTestBackgroundModeManager : public TestBackgroundModeManager {
  public:
@@ skipping 35 matching lines @@
 
 class BackgroundModeManagerTest : public testing::Test {
  public:
   BackgroundModeManagerTest() {}
   ~BackgroundModeManagerTest() override {}
 
   void SetUp() override {
     command_line_.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
     profile_manager_ = CreateTestingProfileManager();
     profile_ = profile_manager_->CreateTestingProfile("p1");
-    chrome::DisableShutdownForTesting(true);
+    browser_lifetime::DisableShutdownForTesting(true);
   }
 
   void TearDown() override {
     // Don't allow the browser to be closed because the shutdown procedure will
     // attempt to access objects that we haven't created (e.g., MessageCenter).
     browser_shutdown::SetTryingToQuit(true);
-    chrome::DisableShutdownForTesting(false);
+    browser_lifetime::DisableShutdownForTesting(false);
     browser_shutdown::SetTryingToQuit(false);
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<base::CommandLine> command_line_;
 
   scoped_ptr<TestingProfileManager> profile_manager_;
   // Test profile used by all tests - this is owned by profile_manager_.
   TestingProfile* profile_;
@@ skipping 12 matching lines @@
     profile_manager_ = CreateTestingProfileManager();
     profile_ = profile_manager_->CreateTestingProfile("p1");
 
     // Aura clears notifications from the message center at shutdown.
     message_center::MessageCenter::Initialize();
 
     // BackgroundModeManager actually affects Chrome start/stop state,
     // tearing down our thread bundle before we've had chance to clean
     // everything up. Keeping Chrome alive prevents this.
     // We aren't interested in if the keep alive works correctly in this test.
-    chrome::IncrementKeepAliveCount();
+    keep_alive_.reset(new browser_lifetime::ScopedKeepAlive);
 
 #if defined(OS_CHROMEOS)
-    // On ChromeOS shutdown, HandleAppExitingForPlatform will call
-    // chrome::DecrementKeepAliveCount because it assumes the aura shell
-    // called chrome::IncrementKeepAliveCount. Simulate the call here.
-    chrome::IncrementKeepAliveCount();
+    // On ChromeOS shutdown, HandleAppExitingForPlatform() will call
+    // browser_lifetime::DecrementKeepAliveCount() because it assumes the aura
+    // shell called browser_lifetime::IncrementKeepAliveCount(). Simulate the
+    // call here.
+    browser_lifetime::IncrementKeepAliveCount();
 #endif
 
     // Create our test BackgroundModeManager.
     manager_.reset(new TestBackgroundModeManager(
         *command_line_, profile_manager_->profile_info_cache()));
     manager_->RegisterProfile(profile_);
   }
 
   void TearDown() override {
     // Clean up the status icon. If this is not done before profile deletes,
     // the context menu updates will DCHECK with the now deleted profiles.
     StatusIcon* status_icon = manager_->status_icon_;
     manager_->status_icon_ = NULL;
     delete status_icon;
 
     // We have to destroy the profiles now because we created them with real
     // thread state. This causes a lot of machinery to spin up that stops
     // working when we tear down our thread state at the end of the test.
     // Deleting our testing profile may have the side-effect of disabling
     // background mode if it was enabled for that profile (explicitly note that
     // here to satisfy StrictMock requirements.
     EXPECT_CALL(*manager_, EnableLaunchOnStartup(false)).Times(AtMost(1));
     profile_manager_->DeleteAllTestingProfiles();
     Mock::VerifyAndClearExpectations(manager_.get());
 
     // We're getting ready to shutdown the message loop. Clear everything out!
     base::MessageLoop::current()->RunUntilIdle();
-    // Matching the call to IncrementKeepAliveCount in SetUp().
-    chrome::DecrementKeepAliveCount();
+    // Matching the keep_alive_.reset(...) in SetUp().
+    keep_alive_.reset();
 
     // TestBackgroundModeManager has dependencies on the infrastructure.
     // It should get cleared first.
     manager_.reset();
 
     // The Profile Manager references the Browser Process.
     // The Browser Process references the Notification UI Manager.
     // The Notification UI Manager references the Message Center.
     // As a result, we have to clear the browser process state here
     // before tearing down the Message Center.
@@ skipping 54 matching lines @@
   // Required for extension service.
   content::TestBrowserThreadBundle thread_bundle_;
 
 #if defined(OS_CHROMEOS)
   // ChromeOS needs extra services to run in the following order.
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 
+  scoped_ptr<browser_lifetime::ScopedKeepAlive> keep_alive_;
+
   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManagerWithExtensionsTest);
 };
 
 
 TEST_F(BackgroundModeManagerTest, BackgroundAppLoadUnload) {
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 
   // Mimic app load.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true)).Times(Exactly(1));
   manager.OnBackgroundClientInstalled(base::UTF8ToUTF16("name"));
   manager.SetBackgroundClientCountForProfile(profile_, 1);
   manager.OnApplicationListChanged(profile_);
   Mock::VerifyAndClearExpectations(&manager);
   AssertBackgroundModeActive(manager);
 
   manager.SuspendBackgroundMode();
@@ skipping 112 matching lines @@
   Mock::VerifyAndClearExpectations(&manager);
   AssertBackgroundModeInactive(manager);
 }
 
 TEST_F(BackgroundModeManagerTest, MultiProfile) {
   TestingProfile* profile2 = profile_manager_->CreateTestingProfile("p2");
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
   manager.RegisterProfile(profile2);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 
   // Install app, should show status tray icon.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true)).Times(Exactly(1));
   manager.OnBackgroundClientInstalled(base::UTF8ToUTF16("name"));
   manager.SetBackgroundClientCountForProfile(profile_, 1);
   manager.OnApplicationListChanged(profile_);
   Mock::VerifyAndClearExpectations(&manager);
   AssertBackgroundModeActive(manager);
 
   // Install app for other profile, should show other status tray icon.
@@ skipping 29 matching lines @@
   Mock::VerifyAndClearExpectations(&manager);
   AssertBackgroundModeInactive(manager);
 }
 
 TEST_F(BackgroundModeManagerTest, ProfileInfoCacheStorage) {
   TestingProfile* profile2 = profile_manager_->CreateTestingProfile("p2");
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
   manager.RegisterProfile(profile2);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 
   ProfileInfoCache* cache = profile_manager_->profile_info_cache();
   EXPECT_EQ(2u, cache->GetNumberOfProfiles());
 
   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(0));
   EXPECT_FALSE(cache->GetBackgroundStatusOfProfileAtIndex(1));
 
   // Install app, should show status tray icon.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true)).Times(Exactly(1));
   manager.OnBackgroundClientInstalled(base::UTF8ToUTF16("name"));
@@ skipping 25 matching lines @@
 
   // Even though neither has background status on, there should still be two
   // profiles in the cache.
   EXPECT_EQ(2u, cache->GetNumberOfProfiles());
 }
 
 TEST_F(BackgroundModeManagerTest, ProfileInfoCacheObserver) {
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 
   // Install app, should show status tray icon.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true)).Times(Exactly(1));
   manager.OnBackgroundClientInstalled(base::UTF8ToUTF16("name"));
   manager.SetBackgroundClientCountForProfile(profile_, 1);
   manager.OnApplicationListChanged(profile_);
   Mock::VerifyAndClearExpectations(&manager);
 
   // Background mode should remain active for the remainder of this test.
 
   manager.OnProfileNameChanged(
       profile_->GetPath(),
       manager.GetBackgroundModeData(profile_)->name());
 
   EXPECT_EQ(base::UTF8ToUTF16("p1"),
             manager.GetBackgroundModeData(profile_)->name());
 
-  EXPECT_TRUE(chrome::WillKeepAlive());
+  EXPECT_TRUE(browser_lifetime::WillKeepAlive());
   TestingProfile* profile2 = profile_manager_->CreateTestingProfile("p2");
   manager.RegisterProfile(profile2);
   EXPECT_EQ(2, manager.NumberOfBackgroundModeData());
 
   manager.OnProfileAdded(profile2->GetPath());
   EXPECT_EQ(base::UTF8ToUTF16("p2"),
             manager.GetBackgroundModeData(profile2)->name());
 
   manager.OnProfileWillBeRemoved(profile2->GetPath());
   // Should still be in background mode after deleting profile.
-  EXPECT_TRUE(chrome::WillKeepAlive());
+  EXPECT_TRUE(browser_lifetime::WillKeepAlive());
   EXPECT_EQ(1, manager.NumberOfBackgroundModeData());
 
   // Check that the background mode data we think is in the map actually is.
   EXPECT_EQ(base::UTF8ToUTF16("p1"),
             manager.GetBackgroundModeData(profile_)->name());
 }
 
 TEST_F(BackgroundModeManagerTest, DeleteBackgroundProfile) {
   // Tests whether deleting the only profile when it is a BG profile works
   // or not (http://crbug.com/346214).
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 
   // Install app, should show status tray icon.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true)).Times(Exactly(1));
   manager.OnBackgroundClientInstalled(base::UTF8ToUTF16("name"));
   manager.SetBackgroundClientCountForProfile(profile_, 1);
   manager.OnApplicationListChanged(profile_);
   Mock::VerifyAndClearExpectations(&manager);
 
   manager.OnProfileNameChanged(
       profile_->GetPath(),
       manager.GetBackgroundModeData(profile_)->name());
 
   EXPECT_CALL(manager, EnableLaunchOnStartup(false)).Times(Exactly(1));
-  EXPECT_TRUE(chrome::WillKeepAlive());
+  EXPECT_TRUE(browser_lifetime::WillKeepAlive());
   manager.SetBackgroundClientCountForProfile(profile_, 0);
   manager.OnProfileWillBeRemoved(profile_->GetPath());
   Mock::VerifyAndClearExpectations(&manager);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(browser_lifetime::WillKeepAlive());
 }
 
 TEST_F(BackgroundModeManagerTest, DisableBackgroundModeUnderTestFlag) {
   command_line_->AppendSwitch(switches::kKeepAliveForTest);
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_info_cache(), true);
   manager.RegisterProfile(profile_);
   EXPECT_TRUE(manager.ShouldBeInBackgroundMode());
 
   // No enable-launch-on-startup calls expected yet.
@@ skipping 158 matching lines @@
   service2->AddExtension(regular_extension_with_options.get());
 
   manager_->RegisterProfile(profile2);
 
   manager_->status_icon_ = new TestStatusIcon();
   manager_->UpdateStatusTrayIconContextMenu();
   StatusIconMenuModel* context_menu = manager_->context_menu_;
   EXPECT_TRUE(context_menu != NULL);
 
   // Background Profile Enable Checks
-  EXPECT_TRUE(context_menu->GetLabelAt(3) == base::UTF8ToUTF16("p1"));
+  EXPECT_EQ(base::UTF8ToUTF16("p1"),
+            context_menu->GetLabelAt(3));
   EXPECT_TRUE(
       context_menu->IsCommandIdEnabled(context_menu->GetCommandIdAt(3)));
-  EXPECT_TRUE(context_menu->GetCommandIdAt(3) == 4);
+  EXPECT_EQ(4, context_menu->GetCommandIdAt(3));
 
-  EXPECT_TRUE(context_menu->GetLabelAt(4) == base::UTF8ToUTF16("p2"));
+  EXPECT_EQ(base::UTF8ToUTF16("p2"), context_menu->GetLabelAt(4));
   EXPECT_TRUE(
       context_menu->IsCommandIdEnabled(context_menu->GetCommandIdAt(4)));
-  EXPECT_TRUE(context_menu->GetCommandIdAt(4) == 8);
+  EXPECT_EQ(8, context_menu->GetCommandIdAt(4));
 
   // Profile 1 Submenu Checks
   StatusIconMenuModel* profile1_submenu =
       static_cast<StatusIconMenuModel*>(context_menu->GetSubmenuModelAt(3));
-  EXPECT_TRUE(
-      profile1_submenu->GetLabelAt(0) ==
-          base::UTF8ToUTF16("Component Extension"));
+  EXPECT_EQ(base::UTF8ToUTF16("Component Extension"),
+            profile1_submenu->GetLabelAt(0));
   EXPECT_FALSE(
       profile1_submenu->IsCommandIdEnabled(
           profile1_submenu->GetCommandIdAt(0)));
-  EXPECT_TRUE(profile1_submenu->GetCommandIdAt(0) == 0);
-  EXPECT_TRUE(
-      profile1_submenu->GetLabelAt(1) ==
-          base::UTF8ToUTF16("Component Extension with Options"));
+  EXPECT_EQ(0, profile1_submenu->GetCommandIdAt(0));
+  EXPECT_EQ(base::UTF8ToUTF16("Component Extension with Options"),
+            profile1_submenu->GetLabelAt(1));
   EXPECT_TRUE(
       profile1_submenu->IsCommandIdEnabled(
           profile1_submenu->GetCommandIdAt(1)));
-  EXPECT_TRUE(profile1_submenu->GetCommandIdAt(1) == 1);
-  EXPECT_TRUE(
-      profile1_submenu->GetLabelAt(2) ==
-          base::UTF8ToUTF16("Regular Extension"));
+  EXPECT_EQ(1, profile1_submenu->GetCommandIdAt(1));
+  EXPECT_EQ(base::UTF8ToUTF16("Regular Extension"),
+            profile1_submenu->GetLabelAt(2));
   EXPECT_TRUE(
       profile1_submenu->IsCommandIdEnabled(
           profile1_submenu->GetCommandIdAt(2)));
-  EXPECT_TRUE(profile1_submenu->GetCommandIdAt(2) == 2);
-  EXPECT_TRUE(
-      profile1_submenu->GetLabelAt(3) ==
-          base::UTF8ToUTF16("Regular Extension with Options"));
+  EXPECT_EQ(2, profile1_submenu->GetCommandIdAt(2));
+  EXPECT_EQ(base::UTF8ToUTF16("Regular Extension with Options"),
+            profile1_submenu->GetLabelAt(3));
   EXPECT_TRUE(
       profile1_submenu->IsCommandIdEnabled(
           profile1_submenu->GetCommandIdAt(3)));
-  EXPECT_TRUE(profile1_submenu->GetCommandIdAt(3) == 3);
+  EXPECT_EQ(3, profile1_submenu->GetCommandIdAt(3));
 
   // Profile 2 Submenu Checks
   StatusIconMenuModel* profile2_submenu =
       static_cast<StatusIconMenuModel*>(context_menu->GetSubmenuModelAt(4));
-  EXPECT_TRUE(
-      profile2_submenu->GetLabelAt(0) ==
-          base::UTF8ToUTF16("Component Extension"));
+  EXPECT_EQ(base::UTF8ToUTF16("Component Extension"),
+            profile2_submenu->GetLabelAt(0));
   EXPECT_FALSE(
       profile2_submenu->IsCommandIdEnabled(
           profile2_submenu->GetCommandIdAt(0)));
-  EXPECT_TRUE(profile2_submenu->GetCommandIdAt(0) == 5);
-  EXPECT_TRUE(
-      profile2_submenu->GetLabelAt(1) ==
-          base::UTF8ToUTF16("Regular Extension"));
+  EXPECT_EQ(5, profile2_submenu->GetCommandIdAt(0));
+  EXPECT_EQ(base::UTF8ToUTF16("Regular Extension"),
+            profile2_submenu->GetLabelAt(1));
   EXPECT_TRUE(
       profile2_submenu->IsCommandIdEnabled(
           profile2_submenu->GetCommandIdAt(1)));
-  EXPECT_TRUE(profile2_submenu->GetCommandIdAt(1) == 6);
-  EXPECT_TRUE(
-      profile2_submenu->GetLabelAt(2) ==
-          base::UTF8ToUTF16("Regular Extension with Options"));
+  EXPECT_EQ(6, profile2_submenu->GetCommandIdAt(1));
+  EXPECT_EQ(base::UTF8ToUTF16("Regular Extension with Options"),
+            profile2_submenu->GetLabelAt(2));
   EXPECT_TRUE(
       profile2_submenu->IsCommandIdEnabled(
           profile2_submenu->GetCommandIdAt(2)));
-  EXPECT_TRUE(profile2_submenu->GetCommandIdAt(2) == 7);
+  EXPECT_EQ(7, profile2_submenu->GetCommandIdAt(2));
 
   // Model Adapter Checks for crbug.com/315164
   // P1: Profile 1 Menu Item
   // P2: Profile 2 Menu Item
   // CE: Component Extension Menu Item
   // CEO: Component Extenison with Options Menu Item
   // RE: Regular Extension Menu Item
   // REO: Regular Extension with Options Menu Item
   EXPECT_FALSE(IsCommandEnabled(context_menu, 0)); // P1 - CE
   EXPECT_TRUE(IsCommandEnabled(context_menu, 1));  // P1 - CEO
@@ skipping 132 matching lines @@
   // When the background mode pref is enabled and there are pending triggers
   // they will be registered and the user will be notified.
   EXPECT_CALL(manager, EnableLaunchOnStartup(true));
   g_browser_process->local_state()->SetBoolean(prefs::kBackgroundModeEnabled,
                                                true);
   Mock::VerifyAndClearExpectations(&manager);
   ASSERT_EQ(1, manager.GetBackgroundClientCountForProfile(profile_));
   AssertBackgroundModeActive(manager);
   ASSERT_TRUE(manager.HasShownBalloon());
 }