Quickly close tabs/window with long-running unload handlers.

chrome/browser/ui/unload_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
 #define CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
 
 #include <set>
 
 #include "base/memory/weak_ptr.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 TabContents;
 class TabStripModel;
 
 namespace content {
 class NotificationSource;
 class NotifictaionDetails;
 class WebContents;
 }
 
 namespace chrome {
+class UnloadDetachedHandler;
 
 class UnloadController : public content::NotificationObserver,

[Ben Goodger (Google), 2012/10/26 19:35:14]

It would be good if you could codify your knowledge of how unload works
(including your changes) in a succinct but complete comment here that explains
how unload handlers are processed.

I separated out this code into this class, and reviewed the original
implementation but it's one of those topics that fits into my brain only when
actively working on it, so a crisp statement of intent here would be very
useful.

[slamm, 2012/10/26 23:16:32]

Done.

                          public TabStripModelObserver {
  public:
   explicit UnloadController(Browser* browser);
   virtual ~UnloadController();
 
   // Returns true if |contents| can be cleanly closed. When |browser_| is being
   // closed, this function will return false to indicate |contents| should not
   // be cleanly closed, since the fast shutdown path will just kill its
   // renderer.
   bool CanCloseContents(content::WebContents* contents);
@@ skipping 17 matching lines @@
 
   // 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();
 
+  // Called when detached tabs (if any) finish closing.
+  void DetachedTabsClosedCallback();
+
  private:
   typedef std::set<content::WebContents*> UnloadListenerSet;
 
   // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Overridden from TabStripModelObserver:
   virtual void TabInsertedAt(TabContents* contents,
@@ skipping 32 matching lines @@
   //
   // Typically you'll want to pass in true for |process_now|. Passing in true
   // may result in deleting |tab|. If you know that shouldn't happen (because of
   // the state of the stack), pass in false.
   void ClearUnloadState(content::WebContents* web_contents, bool process_now);
 
   Browser* browser_;
 
   content::NotificationRegistrar registrar_;
 
-  // Tracks tabs that need there beforeunload event fired before we can
+  // Tracks tabs that need their beforeunload event fired before we can
   // close the browser. Only gets populated when we try to close the browser.
   UnloadListenerSet tabs_needing_before_unload_fired_;
 
-  // Tracks tabs that need there unload event fired before we can
+  // Tracks tabs that need their unload event fired before we can
   // close the browser. Only gets populated when we try to close the browser.
   UnloadListenerSet tabs_needing_unload_fired_;
 
   // Whether we are processing the beforeunload and unload events of each tab
   // in preparation for closing the browser. UnloadController owns this 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_;
 
+  // Allow unload handlers to run without holding up the UI.
+  UnloadDetachedHandler* const unload_detached_handler_;
+
   base::WeakPtrFactory<UnloadController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UnloadController);
 };
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_