Replace Increment/DecrementKeepAliveCount by ScopedKeepAlives

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 <stddef.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.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 "build/build_config.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/keep_alive_registry.h"
+#include "chrome/browser/lifetime/keep_alive_types.h"
+#include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_attributes_storage.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"
@@ skipping 97 matching lines @@
                       const base::string16& title,
                       const base::string16& contents,
                       const message_center::NotifierId& notifier_id) override {}
   void UpdatePlatformContextMenu(StatusIconMenuModel* menu) override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestStatusIcon);
 };
 
 void AssertBackgroundModeActive(const TestBackgroundModeManager& manager) {
-  EXPECT_TRUE(chrome::WillKeepAlive());
+  EXPECT_TRUE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   EXPECT_TRUE(manager.HaveStatusTray());
 }
 
 void AssertBackgroundModeInactive(const TestBackgroundModeManager& manager) {
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   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 71 matching lines @@
   ~BackgroundModeManagerWithExtensionsTest() override {}
 
   void SetUp() override {
     command_line_.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
     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();
+    test_keep_alive_.reset(
+        new ScopedKeepAlive(KeepAliveOrigin::BACKGROUND_MODE_MANAGER,
+                            KeepAliveRestartOption::DISABLED));
 
 #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();

[dgn, 2016/03/09 23:49:23]

This is not needed anymore because the reset() call is specific to a given
keep_alive, so it would not decrement the global count.

+// TODO(dgn): reset() on the empty keep alive would do nothing, is it
+// ok to just skip?
 #endif
 
     // Create our test BackgroundModeManager.
     manager_.reset(new TestBackgroundModeManager(
         *command_line_, profile_manager_->profile_attributes_storage()));
     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();
+
+    test_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.
     profile_manager_.reset();
 
-    // Message Center shutdown must occur after the DecrementKeepAliveCount
-    // because DecrementKeepAliveCount will end up referencing the message
-    // center during cleanup.
+    // Message Center shutdown must occur after the KeepAlive is released
+    // because clearing them will end up referencing the message center.
     message_center::MessageCenter::Shutdown();
 
     // Clear the shutdown flag to isolate the remaining effect of this test.
     browser_shutdown::SetTryingToQuit(false);
   }
 
  protected:
   scoped_refptr<extensions::Extension> CreateExtension(
       extensions::Manifest::Location location,
       const std::string& data,
@@ skipping 18 matching lines @@
   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_;
 
  private:
   // Required for extension service.
   content::TestBrowserThreadBundle thread_bundle_;
 
+  // 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.
+  scoped_ptr<ScopedKeepAlive> test_keep_alive_;
+
 #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
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundModeManagerWithExtensionsTest);
 };
 
 
 TEST_F(BackgroundModeManagerTest, BackgroundAppLoadUnload) {
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_attributes_storage(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
 
   // 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_attributes_storage(), true);
   manager.RegisterProfile(profile_);
   manager.RegisterProfile(profile2);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
 
   // 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 30 matching lines @@
   AssertBackgroundModeInactive(manager);
 }
 
 TEST_F(BackgroundModeManagerTest, ProfileAttributesStorage) {
   TestingProfile* profile2 = profile_manager_->CreateTestingProfile("p2");
   ProfileAttributesStorage* storage =
       profile_manager_->profile_attributes_storage();
   AdvancedTestBackgroundModeManager manager(*command_line_, storage, true);
   manager.RegisterProfile(profile_);
   manager.RegisterProfile(profile2);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   EXPECT_EQ(2u, storage->GetNumberOfProfiles());
 
   ProfileAttributesEntry* entry1;
   ProfileAttributesEntry* entry2;
   ASSERT_TRUE(storage->GetProfileAttributesWithPath(profile_->GetPath(),
                                                     &entry1));
   ASSERT_TRUE(storage->GetProfileAttributesWithPath(profile2->GetPath(),
                                                     &entry2));
 
   EXPECT_FALSE(entry1->GetBackgroundStatus());
@@ skipping 28 matching lines @@
 
   // Even though neither has background status on, there should still be two
   // profiles in the ProfileAttributesStorage.
   EXPECT_EQ(2u, storage->GetNumberOfProfiles());
 }
 
 TEST_F(BackgroundModeManagerTest, ProfileAttributesStorageObserver) {
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_attributes_storage(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
 
   // 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(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   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(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   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_attributes_storage(), true);
   manager.RegisterProfile(profile_);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
 
   // 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(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
   manager.SetBackgroundClientCountForProfile(profile_, 0);
   manager.OnProfileWillBeRemoved(profile_->GetPath());
   Mock::VerifyAndClearExpectations(&manager);
-  EXPECT_FALSE(chrome::WillKeepAlive());
+  EXPECT_FALSE(KeepAliveRegistry::GetInstance()->IsKeepingAlive());
 }
 
 TEST_F(BackgroundModeManagerTest, DisableBackgroundModeUnderTestFlag) {
   command_line_->AppendSwitch(switches::kKeepAliveForTest);
   AdvancedTestBackgroundModeManager manager(
       *command_line_, profile_manager_->profile_attributes_storage(), true);
   manager.RegisterProfile(profile_);
   EXPECT_TRUE(manager.ShouldBeInBackgroundMode());
 
   // No enable-launch-on-startup calls expected yet.
@@ skipping 376 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());
 }