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

chrome/browser/ui/fast_unload_controller.h

 // Copyright 2013 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.
 
 #ifndef CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_
 #define CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_
 
 #include <memory>
 #include <set>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_piece.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class Browser;
 class TabStripModel;
+class UnloadControllerWebContentsDelegate;
 
 namespace content {
 class NotificationSource;
 class NotificationDetails;
 class WebContents;
 }
 
 namespace chrome {
 // FastUnloadController manages closing tabs and windows -- especially in
 // regards to beforeunload handlers (have proceed/cancel dialogs) and
@@ skipping 52 matching lines @@
 
   bool is_attempting_to_close_browser() const {
     return is_attempting_to_close_browser_;
   }
 
   // Called in response to a request to close |browser_|'s window. Returns true
   // when there are no remaining beforeunload handlers to be run.
   bool ShouldCloseWindow();
 
   // Begins the process of confirming whether the associated browser can be
-  // closed.
-  bool CallBeforeUnloadHandlers(
-      const base::Callback<void(bool)>& on_close_confirmed);
+  // closed. Beforeunload events won't be fired if |skip_beforeunload|
+  // true.
+  bool TryToCloseWindow(bool skip_beforeunload,
+                        const base::Callback<void(bool)>& on_close_confirmed);
 
   // Clears the results of any beforeunload confirmation dialogs triggered by a
-  // CallBeforeUnloadHandlers call.
-  void ResetBeforeUnloadHandlers();
+  // TryToCloseWindow call.
+  void ResetTryToCloseWindow();
 
   // Returns true if |browser_| has any tabs that have BeforeUnload handlers
   // that have not been fired. This method is non-const because it builds a list
   // of tabs that need their BeforeUnloadHandlers fired.
   // TODO(beng): This seems like it could be private but it is used by
   //             AreAllBrowsersCloseable() in application_lifetime.cc. It seems
   //             very similar to ShouldCloseWindow() and some consolidation
   //             could be pursued.
   bool TabsNeedBeforeUnloadFired();
 
@@ skipping 23 matching lines @@
   void TabStripEmpty() override;
 
   void TabAttachedImpl(content::WebContents* contents);
   void TabDetachedImpl(content::WebContents* contents);
 
   // Detach |contents| and wait for it to finish closing.
   // The close must be inititiated outside of this method.
   // Returns true if it succeeds.
   bool DetachWebContents(content::WebContents* contents);
 
-  // Processes the next tab that needs it's beforeunload/unload event fired.
-  void ProcessPendingTabs();
+  // Processes the next tab that needs its beforeunload/unload event fired.
+  void ProcessPendingTabs(bool skip_beforeunload);
 
   // Cleans up state appropriately when we are trying to close the
   // browser or close a tab in the background. We also use this in the
   // cases where a tab crashes or hangs even if the
   // beforeunload/unload haven't successfully fired.
   void ClearUnloadState(content::WebContents* contents);
 
   // Helper for |ClearUnloadState| to unwind stack before proceeding.
   void PostTaskForProcessPendingTabs();
 
   // Log a step of the unload processing.
   void LogUnloadStep(const base::StringPiece& step_name,
                      content::WebContents* contents) const;
 
+  void CancelTabNeedingBeforeUnloadAck();
+
   bool is_calling_before_unload_handlers() {
     return !on_close_confirmed_.is_null();
   }
 
   Browser* browser_;
 
   content::NotificationRegistrar registrar_;
 
   typedef std::set<content::WebContents*> WebContentsSet;
 
@@ skipping 18 matching lines @@
   // state rather than Browser because unload handlers are the only reason that
   // a Browser window isn't just immediately closed.
   bool is_attempting_to_close_browser_;
 
   // A callback to call to report whether the user chose to close all tabs of
   // |browser_| that have beforeunload event handlers. This is set only if we
   // are currently confirming that the browser is closable.
   base::Callback<void(bool)> on_close_confirmed_;
 
   // Manage tabs with beforeunload/unload handlers that close detached.
-  class DetachedWebContentsDelegate;
-  std::unique_ptr<DetachedWebContentsDelegate> detached_delegate_;
+  std::unique_ptr<UnloadControllerWebContentsDelegate> detached_delegate_;
 
   base::WeakPtrFactory<FastUnloadController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FastUnloadController);
 };
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_