Refactor shutdown code to allow win/linux to run after last browser closes.

chrome/browser/browser_list.cc

 // Copyright (c) 2010 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/browser_list.h"
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
@@ skipping 154 matching lines @@
 }
 
 // static
 void BrowserList::RemoveBrowser(Browser* browser) {
   RemoveBrowserFrom(browser, &last_active_browsers_);
 
   // Closing all windows does not indicate quitting the application on the Mac,
   // however, many UI tests rely on this behavior so leave it be for now and
   // simply ignore the behavior on the Mac outside of unit tests.
   // TODO(andybons): Fix the UI tests to Do The Right Thing.
-  bool close_app_non_mac = (browsers_.size() == 1);
+  bool closing_last_browser = (browsers_.size() == 1);
   NotificationService::current()->Notify(
       NotificationType::BROWSER_CLOSED,
-      Source<Browser>(browser), Details<bool>(&close_app_non_mac));
+      Source<Browser>(browser), Details<bool>(&closing_last_browser));
 
   // Send out notifications before anything changes. Do some basic checking to
   // try to catch evil observers that change the list from under us.
   size_t original_count = observers_.size();
   FOR_EACH_OBSERVER(Observer, observers_, OnBrowserRemoving(browser));
   DCHECK_EQ(original_count, observers_.size())
       << "observer list modified during notification";
 
   RemoveBrowserFrom(browser, &browsers_);
 
   // If the last Browser object was destroyed, make sure we try to close any
   // remaining dependent windows too.
   if (browsers_.empty()) {
-    AllBrowsersClosed();
-
     delete activity_observer;
     activity_observer = NULL;
   }
 
   g_browser_process->ReleaseModule();
+
+  // If we're exiting, send out the APP_TERMINATING notification to allow other
+  // modules to shut themselves down.
+  if (browsers_.empty() &&
+      (browser_shutdown::IsTryingToQuit() ||
+       g_browser_process->IsShuttingDown())) {
+    // Last browser has just closed, and this is a user-initiated quit or there
+    // is no module keeping the app alive, so send out our notification.
+    NotificationService::current()->Notify(NotificationType::APP_TERMINATING,
+                                           NotificationService::AllSources(),
+                                           NotificationService::NoDetails());
+    AllBrowsersClosedAndAppExiting();
+  }
 }
 
 // static
 void BrowserList::AddObserver(BrowserList::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 // static
 void BrowserList::RemoveObserver(BrowserList::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // static
 void BrowserList::CloseAllBrowsers(bool use_post) {
+  // Tell everyone that we are shutting down.
+  browser_shutdown::SetTryingToQuit(true);
+
   // Before we close the browsers shutdown all session services. That way an
   // exit can restore all browsers open before exiting.
   ProfileManager::ShutdownSessionServices();
 
+  // If there are no browsers, send the APP_TERMINATING action here. Otherwise,
+  // it will be sent by RemoveBrowser() when the last browser has closed.
+  if (browsers_.empty()) {
+    NotificationService::current()->Notify(NotificationType::APP_TERMINATING,
+                                           NotificationService::AllSources(),
+                                           NotificationService::NoDetails());
+    AllBrowsersClosedAndAppExiting();
+    return;
+  }
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end();) {
     if (use_post) {
       (*i)->window()->Close();
       ++i;
     } else {
       // This path is hit during logoff/power-down. In this case we won't get
       // a final message and so we force the browser to be deleted.
       Browser* browser = *i;
       browser->window()->Close();
@@ skipping 75 matching lines @@
 // static
 bool BrowserList::HasBrowserWithProfile(Profile* profile) {
   return FindBrowserMatching(BrowserList::begin(),
                              BrowserList::end(),
                              profile, Browser::TYPE_ANY,
                              Browser::FEATURE_NONE,
                              kMatchNothing) != NULL;
 }
 
 // static
-bool BrowserList::IsInPersistentMode() {
-  // TODO(atwilson): check the boolean state variable that you will set for
-  // persisent instances.
-  return false;
+int BrowserList::keep_alive_count_ = 0;
+
+// static
+void BrowserList::StartKeepAlive() {
+  // Increment the browser process refcount as long as we're keeping the
+  // application alive.
+  if (!WillKeepAlive())
+    g_browser_process->AddRefModule();
+  keep_alive_count_++;
 }
 
 // static
+void BrowserList::EndKeepAlive() {
+  DCHECK(keep_alive_count_ > 0);
+  keep_alive_count_--;
+  // Allow the app to shutdown again.
+  if (!WillKeepAlive()) {
+    g_browser_process->ReleaseModule();
+    // If there are no browsers open and we aren't already shutting down,
+    // initiate a shutdown. Also skips shutdown if this is a unit test
+    // (MessageLoop::current() == null).
+    if (browsers_.empty() && !browser_shutdown::IsTryingToQuit() &&
+        MessageLoop::current())
+      CloseAllBrowsers(true);
+  }
+}
+
+// static
+bool BrowserList::WillKeepAlive() {
+  return keep_alive_count_ > 0;
+}
+
+// static
 BrowserList::BrowserVector BrowserList::last_active_browsers_;
 
 // static
 void BrowserList::SetLastActive(Browser* browser) {
   RemoveBrowserFrom(browser, &last_active_browsers_);
   last_active_browsers_.push_back(browser);
 
   FOR_EACH_OBSERVER(Observer, observers_, OnBrowserSetLastActive(browser));
 }
 
@@ skipping 126 matching lines @@
     }
 
     TabContents* next_tab =
         (*browser_iterator_)->GetTabContentsAt(web_view_index_);
     if (next_tab) {
       cur_ = next_tab;
       return;
     }
   }
 }