Add ScopedKeepAlive to c/b/lifetime

chrome/browser/background/background_mode_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/background/background_mode_manager.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 11 matching lines @@
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background/background_application_list_model.h"
 #include "chrome/browser/background/background_trigger.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/lifetime/keep_alive_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 229 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 //  BackgroundModeManager, public
 BackgroundModeManager::BackgroundModeManager(
     const base::CommandLine& command_line,
     ProfileAttributesStorage* profile_storage)
     : profile_storage_(profile_storage),
       status_tray_(NULL),
       status_icon_(NULL),
       context_menu_(NULL),
       in_background_mode_(false),
-      keep_alive_for_startup_(false),
       keep_alive_for_test_(false),
       background_mode_suspended_(false),
-      keeping_alive_(false),
       weak_factory_(this) {
   // We should never start up if there is no browser process or if we are
   // currently quitting.
   CHECK(g_browser_process != NULL);
   CHECK(!browser_shutdown::IsTryingToQuit());
 
   // Add self as an observer for the ProfileAttributesStorage so we know when
   // profiles are deleted and their names change.
   profile_storage_->AddObserver(this);
 
   UMA_HISTOGRAM_BOOLEAN("BackgroundMode.OnStartup.AutoLaunchState",
                         command_line.HasSwitch(switches::kNoStartupWindow));
   UMA_HISTOGRAM_BOOLEAN("BackgroundMode.OnStartup.IsBackgroundModePrefEnabled",
                         IsBackgroundModePrefEnabled());
 
   // Listen for the background mode preference changing.
   if (g_browser_process->local_state()) {  // Skip for unit tests
     pref_registrar_.Init(g_browser_process->local_state());
     pref_registrar_.Add(
         prefs::kBackgroundModeEnabled,
         base::Bind(&BackgroundModeManager::OnBackgroundModeEnabledPrefChanged,
                    base::Unretained(this)));
   }
 
   // Keep the browser alive until extensions are done loading - this is needed
   // by the --no-startup-window flag. We want to stay alive until we load
   // extensions, at which point we should either run in background mode (if
   // there are background apps) or exit if there are none.
   if (command_line.HasSwitch(switches::kNoStartupWindow)) {
-    keep_alive_for_startup_ = true;
-    chrome::IncrementKeepAliveCount();
+    keep_alive_for_startup_.reset(
+        new ScopedKeepAlive(KeepAliveOrigin::BACKGROUND_MODE_MANAGER));
   } else {
     // Otherwise, start with background mode suspended in case we're launching
     // in a mode that doesn't open a browser window. It will be resumed when the
     // first browser window is opened.
     SuspendBackgroundMode();
   }
 
   // If the -keep-alive-for-test flag is passed, then always keep chrome running
   // in the background until the user explicitly terminates it.
   if (command_line.HasSwitch(switches::kKeepAliveForTest))
     keep_alive_for_test_ = true;
 
   if (ShouldBeInBackgroundMode())
     StartBackgroundMode();
 
-  // Listen for the application shutting down so we can decrement our KeepAlive
-  // count.
+  // Listen for the application shutting down so we can release our KeepAlive.
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
   BrowserList::AddObserver(this);
 }
 
 BackgroundModeManager::~BackgroundModeManager() {
   // Remove ourselves from the application observer list (only needed by unit
   // tests since APP_TERMINATING is what does this in a real running system).
   for (const auto& it : background_mode_data_)
     it.second->applications_->RemoveObserver(this);
@@ skipping 118 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 //  BackgroundModeManager, content::NotificationObserver overrides
 void BackgroundModeManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_APP_TERMINATING:
       // Make sure we aren't still keeping the app alive (only happens if we
       // don't receive an EXTENSIONS_READY notification for some reason).
-      DecrementKeepAliveCountForStartup();
+      ReleaseStartupKeepAlive();
       // Performing an explicit shutdown, so exit background mode (does nothing
       // if we aren't in background mode currently).
       EndBackgroundMode();
       // Shutting down, so don't listen for any more notifications so we don't
       // try to re-enter/exit background mode again.
       registrar_.RemoveAll();
       for (const auto& it : background_mode_data_)
         it.second->applications_->RemoveObserver(this);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void BackgroundModeManager::OnExtensionsReady(Profile* profile) {
   BackgroundModeManager::BackgroundModeData* bmd =
       GetBackgroundModeData(profile);
   if (bmd) {
     UMA_HISTOGRAM_COUNTS_100("BackgroundMode.BackgroundApplicationsCount",
         bmd->applications_->size());
   }
   // Extensions are loaded, so we don't need to manually keep the browser
   // process alive any more when running in no-startup-window mode.
-  DecrementKeepAliveCountForStartup();
+  ReleaseStartupKeepAlive();
 }
 
 void BackgroundModeManager::OnBackgroundModeEnabledPrefChanged() {
   bool enabled = IsBackgroundModePrefEnabled();
   UMA_HISTOGRAM_BOOLEAN("BackgroundMode.BackgroundModeEnabledPrefChanged",
                         enabled);
   if (enabled)
     EnableBackgroundMode();
   else
     DisableBackgroundMode();
@@ skipping 161 matching lines @@
                           profiles::USER_MANAGER_NO_TUTORIAL,
                           profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
       }
       break;
   }
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 //  BackgroundModeManager, private
-void BackgroundModeManager::DecrementKeepAliveCountForStartup() {
+void BackgroundModeManager::ReleaseStartupKeepAliveCallback() {
+  keep_alive_for_startup_.reset();
+}
+
+void BackgroundModeManager::ReleaseStartupKeepAlive() {
   if (keep_alive_for_startup_) {
-    keep_alive_for_startup_ = false;
     // We call this via the message queue to make sure we don't try to end
     // keep-alive (which can shutdown Chrome) before the message loop has
-    // started.
+    // started. This object reference is safe because it's going to be kept
+    // alive by the browser process until after the callback is called.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&chrome::DecrementKeepAliveCount));
+        FROM_HERE,
+        base::Bind(&BackgroundModeManager::ReleaseStartupKeepAliveCallback,
+                   base::Unretained(this)));
   }
 }
 
 void BackgroundModeManager::StartBackgroundMode() {
   DCHECK(ShouldBeInBackgroundMode());
   // Don't bother putting ourselves in background mode if we're already there
   // or if background mode is disabled.
   if (in_background_mode_)
     return;
 
@@ skipping 58 matching lines @@
   UpdateKeepAliveAndTrayIcon();
 }
 
 void BackgroundModeManager::ResumeBackgroundMode() {
   background_mode_suspended_ = false;
   UpdateKeepAliveAndTrayIcon();
 }
 
 void BackgroundModeManager::UpdateKeepAliveAndTrayIcon() {
   if (in_background_mode_ && !background_mode_suspended_) {
-    if (!keeping_alive_) {
-      keeping_alive_ = true;
-      chrome::IncrementKeepAliveCount();
+    if (!keep_alive_) {
+      keep_alive_.reset(
+          new ScopedKeepAlive(KeepAliveOrigin::BACKGROUND_MODE_MANAGER));
     }
     CreateStatusTrayIcon();
     return;
   }
 
   RemoveStatusTrayIcon();
-  if (keeping_alive_) {
-    keeping_alive_ = false;
-    chrome::DecrementKeepAliveCount();
-  }
+  keep_alive_.reset();
 }
 
 void BackgroundModeManager::OnBrowserAdded(Browser* browser) {
   ResumeBackgroundMode();
 }
 
 void BackgroundModeManager::OnClientsChanged(
     Profile* profile,
     const std::vector<base::string16>& new_client_names) {
   DCHECK(IsBackgroundModePrefEnabled());
@@ skipping 239 matching lines @@
     }
   }
   return profile_it;
 }
 
 bool BackgroundModeManager::IsBackgroundModePrefEnabled() const {
   PrefService* service = g_browser_process->local_state();
   DCHECK(service);
   return service->GetBoolean(prefs::kBackgroundModeEnabled);
 }