Nicely handle OnBeforeUnloads with guest and lock mode.

chrome/browser/ui/browser_list.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/ui/browser_list.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 14 matching lines @@
 using content::WebContents;
 
 // static
 base::LazyInstance<ObserverList<chrome::BrowserListObserver> >::Leaky
     BrowserList::observers_ = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserList* BrowserList::native_instance_ = NULL;
 BrowserList* BrowserList::ash_instance_ = NULL;
 
+// static
+// Whether the BrowserList is currently processing OnBeforeUnload events.
+bool before_unload_callback_expected_;
+
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserList, public:
 
 Browser* BrowserList::GetLastActive() const {
   if (!last_active_browsers_.empty())
     return *(last_active_browsers_.rbegin());
   return NULL;
 }
 
 // static
@@ skipping 64 matching lines @@
 // static
 void BrowserList::AddObserver(chrome::BrowserListObserver* observer) {
   observers_.Get().AddObserver(observer);
 }
 
 // static
 void BrowserList::RemoveObserver(chrome::BrowserListObserver* observer) {
   observers_.Get().RemoveObserver(observer);
 }
 
+// static
 void BrowserList::CloseAllBrowsersWithProfile(Profile* profile) {
   BrowserVector browsers_to_close;
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if (it->profile()->GetOriginalProfile() == profile->GetOriginalProfile())
       browsers_to_close.push_back(*it);
   }
 
   for (BrowserVector::const_iterator it = browsers_to_close.begin();
        it != browsers_to_close.end(); ++it) {
     (*it)->window()->Close();
   }
 }
 
 // static
+void BrowserList::CloseAllBrowsersWithProfile(Profile* profile,
+    const base::Callback<void(const base::FilePath&)>& on_close_success) {
+  before_unload_callback_expected_ = false;
+  BrowserVector browsers_to_close;
+  for (chrome::BrowserIterator it; !it.done(); it.Next()) {
+    if (it->profile()->GetOriginalProfile() == profile->GetOriginalProfile())
+      browsers_to_close.push_back(*it);
+  }
+
+  TryToCloseBrowserList(browsers_to_close,
+                        on_close_success,
+                        profile->GetPath());
+}
+
+// static
+void BrowserList::TryToCloseBrowserList(const BrowserVector& browsers_to_close,
+    const base::Callback<void(const base::FilePath&)>& on_close_success,
+    const base::FilePath& profile_path) {
+  for (BrowserVector::const_iterator it = browsers_to_close.begin();
+       it != browsers_to_close.end(); ++it) {
+    if ((*it)->CallBeforeUnloadHandlers(
+            base::Bind(&BrowserList::PostBeforeUnloadHandlers,
+                       browsers_to_close,
+                       on_close_success,
+                       profile_path))) {
+      // Note that the UnloadController has been called to fire and handle one
+      // OnBeforeUnload event. We expect the callback to be called once.
+      before_unload_callback_expected_ = true;
+      return;
+    }
+  }
+
+  for (BrowserVector::const_iterator it = browsers_to_close.begin();
+       it != browsers_to_close.end(); ++it)
+    (*it)->window()->Close();
+
+  on_close_success.Run(profile_path);
+}
+
+// static
+void BrowserList::PostBeforeUnloadHandlers(
+    const BrowserVector& browsers_to_close,
+    const base::Callback<void(const base::FilePath&)>& on_close_success,
+    const base::FilePath& profile_path,
+    bool tab_close_confirmed) {
+  // If multiple windows' OnBeforeUnload events have been handled when the user
+  // clicks "Stay on this page", then resetting the handlers will call each
+  // window's UnloadController's CancelWindowClose method, triggering the
+  // UnloadController's callback (this method). The following check ensures this
+  // callback only executes once.

[Peter Kasting, 2014/08/29 21:30:25]

It seems like we can simplify this to avoid the member variable by using a local
static:

void PostBeforeUnloadHandlers() {
  // We need this bool to avoid infinite recursion when resetting the
  // BeforeUnload handlers, since doing that will trigger calls back to this
  // method for each affected window.
  static bool resetting_handlers = false;
  if (tab_close_confirmed) {
    ...
  } else if (!resetting_handlers) {
    base::AutoReset<bool> resetting_handlers_scoper(&resetting_handlers, true);
    for ()
      ResetBeforeUnloadHandlers();
  }
}

[Mike Lerman, 2014/09/02 15:15:40]

I like that AutoReset class! And done.

+  if (!before_unload_callback_expected_)
+    return;
+
+  // The UnloadController has called back for the processing of a
+  // particular OnBeforeUnload event. We expect no more callbacks.
+  before_unload_callback_expected_ = false;
+
+  if (tab_close_confirmed) {
+    TryToCloseBrowserList(browsers_to_close, on_close_success, profile_path);
+  } else {
+    for (BrowserVector::const_iterator it = browsers_to_close.begin();
+        it != browsers_to_close.end(); ++it) {
+      (*it)->ResetBeforeUnloadHandlers();
+    }
+  }
+}
+
+// static
 void BrowserList::SetLastActive(Browser* browser) {
   content::RecordAction(UserMetricsAction("ActiveBrowserChanged"));
   BrowserList* browser_list = GetInstance(browser->host_desktop_type());
 
   RemoveBrowserFrom(browser, &browser_list->last_active_browsers_);
   browser_list->last_active_browsers_.push_back(browser);
 
   FOR_EACH_OBSERVER(chrome::BrowserListObserver, observers_.Get(),
                     OnBrowserSetLastActive(browser));
 }
@@ skipping 30 matching lines @@
 }
 
 // static
 void BrowserList::RemoveBrowserFrom(Browser* browser,
                                     BrowserVector* browser_list) {
   BrowserVector::iterator remove_browser =
       std::find(browser_list->begin(), browser_list->end(), browser);
   if (remove_browser != browser_list->end())
     browser_list->erase(remove_browser);
 }