Add Browser::SkipCallBeforeUnload so that the browser windows can be closed regardless of beforeunl…

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/auto_reset.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
-#include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 
 using base::UserMetricsAction;
 using content::WebContents;
 
+namespace {
+
+BrowserList::BrowserVector GetBrowserToClose(Profile* profile) {
+  BrowserList::BrowserVector browsers_to_close;
+  for (auto* browser : *BrowserList::GetInstance()) {
+    if (browser->profile()->GetOriginalProfile() ==
+        profile->GetOriginalProfile())
+      browsers_to_close.push_back(browser);
+  }
+  return browsers_to_close;
+}
+
+}  // namespace
+
 // static
 base::LazyInstance<base::ObserverList<chrome::BrowserListObserver>>::Leaky
     BrowserList::observers_ = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserList* BrowserList::instance_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserList, public:
 
@@ skipping 80 matching lines @@
       browsers_to_close.push_back(browser);
   }
 
   for (BrowserVector::const_iterator it = browsers_to_close.begin();
        it != browsers_to_close.end(); ++it) {
     (*it)->window()->Close();
   }
 }
 
 // static
-void BrowserList::CloseAllBrowsersWithProfile(Profile* profile,
+void BrowserList::CloseAllBrowsersWithProfile(
+    Profile* profile,
     const CloseCallback& on_close_success,
-    const CloseCallback& on_close_aborted) {
-  BrowserVector browsers_to_close;
-  for (auto* browser : *BrowserList::GetInstance()) {
-    if (browser->profile()->GetOriginalProfile() ==
-        profile->GetOriginalProfile())
-      browsers_to_close.push_back(browser);
-  }
-
-  TryToCloseBrowserList(browsers_to_close, on_close_success, on_close_aborted,
-                        profile->GetPath());
+    const CloseCallback& on_close_aborted,
+    bool is_force) {
+  TryToCloseBrowserList(GetBrowserToClose(profile), on_close_success,
+                        on_close_aborted, profile->GetPath(), is_force);
 }
 
 // static
 void BrowserList::TryToCloseBrowserList(const BrowserVector& browsers_to_close,
-    const CloseCallback& on_close_success,
-    const CloseCallback& on_close_aborted,
-    const base::FilePath& profile_path) {
+                                        const CloseCallback& on_close_success,
+                                        const CloseCallback& on_close_aborted,
+                                        const base::FilePath& profile_path,
+                                        const bool is_force) {
   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,
-                       on_close_aborted,
-                       profile_path))) {
+    if ((*it)->TryToCloseWindow(
+            is_force, base::Bind(&BrowserList::PostTryToCloseBrowserWindow,
+                                 browsers_to_close, on_close_success,
+                                 on_close_aborted, profile_path, is_force))) {
       return;
     }
   }
 
   on_close_success.Run(profile_path);
 
   for (Browser* b : browsers_to_close) {
     // BeforeUnload handlers may close browser windows, so we need to explicitly
     // check whether they still exist.
     if (b->window())
       b->window()->Close();
   }
 }
 
 // static
-void BrowserList::PostBeforeUnloadHandlers(
+void BrowserList::PostTryToCloseBrowserWindow(
     const BrowserVector& browsers_to_close,
     const CloseCallback& on_close_success,
     const CloseCallback& on_close_aborted,
     const base::FilePath& profile_path,
+    const bool is_force,
     bool tab_close_confirmed) {
   // 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) {
     TryToCloseBrowserList(browsers_to_close, on_close_success, on_close_aborted,
-                          profile_path);
+                          profile_path, is_force);
   } else if (!resetting_handlers) {
     base::AutoReset<bool> resetting_handlers_scoper(&resetting_handlers, true);
     for (BrowserVector::const_iterator it = browsers_to_close.begin();
          it != browsers_to_close.end(); ++it) {
-      (*it)->ResetBeforeUnloadHandlers();
+      (*it)->ResetCloseWindow();
     }
     on_close_aborted.Run(profile_path);
   }
 }
 
 // static
 void BrowserList::MoveBrowsersInWorkspaceToFront(
     const std::string& new_workspace) {
   DCHECK(!new_workspace.empty());
 
@@ skipping 70 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);
 }