Reland fast tab closure behind a flag

chrome/browser/ui/fast_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_
+#ifndef CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_
+#define CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_
 
 #include <set>
 
 #include "base/memory/scoped_ptr.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;
 
 namespace content {
 class NotificationSource;
 class NotifictaionDetails;
 class WebContents;
 }
 
 namespace chrome {
-// UnloadController manages closing tabs and windows -- especially in
+// FastUnloadController manages closing tabs and windows -- especially in
 // regards to beforeunload handlers (have proceed/cancel dialogs) and
 // unload handlers (have no user interaction).
 //
 // Typical flow of closing a tab:
 //  1. Browser calls CanCloseContents().
 //     If true, browser calls contents::CloseWebContents().
 //  2. WebContents notifies us via its delegate and BeforeUnloadFired()
 //     that the beforeunload handler was run. If the user allowed the
 //     close to continue, we detached the tab and hold onto it while the
 //     close finishes.
 //
 // Typical flow of closing a window:
 //  1. BrowserView::CanClose() calls TabsNeedBeforeUnloadFired().
-//     If beforeunload/unload handlers need to run, UnloadController returns
+//     If beforeunload/unload handlers need to run, FastUnloadController returns
 //     true and calls ProcessPendingTabs() (private method).
 //  2. For each tab with a beforeunload/unload handler, ProcessPendingTabs()
 //        calls |CoreTabHelper::OnCloseStarted()|
 //        and   |web_contents->GetRenderViewHost()->FirePageBeforeUnload()|.
 //  3. If the user allowed the close to continue, we detach all the tabs with
 //     unload handlers, remove them from the tab strip, and finish closing
 //     the tabs in the background.
 //  4. The browser gets notified that the tab strip is empty and calls
 //     CloseFrame where the empty tab strip causes the window to hide.
 //     Once the detached tabs finish, the browser calls CloseFrame again and
 //     the window is finally closed.
 //
-class UnloadController : public content::NotificationObserver,
+class FastUnloadController : public content::NotificationObserver,
                              public TabStripModelObserver {
  public:
-  explicit UnloadController(Browser* browser);
-  virtual ~UnloadController();
+  explicit FastUnloadController(Browser* browser);
+  virtual ~FastUnloadController();
 
   // 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);
 
   // Called when a BeforeUnload handler is fired for |contents|. |proceed|
   // indicates the user's response to the Y/N BeforeUnload handler dialog. If
   // this parameter is false, any pending attempt to close the whole browser
@@ skipping 85 matching lines @@
 
   // Tracks tabs that need their unload event started.
   // Only gets populated when we try to close the browser.
   WebContentsSet tabs_needing_unload_;
 
   // Tracks tabs that need to finish running their unload event.
   // Populated both when closing individual tabs and when closing the browser.
   WebContentsSet tabs_needing_unload_ack_;
 
   // Whether we are processing the beforeunload and unload events of each tab
-  // in preparation for closing the browser. UnloadController owns this
+  // in preparation for closing the browser. FastUnloadController 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_;
 
   // Manage tabs with beforeunload/unload handlers that close detached.
   class DetachedWebContentsDelegate;
   scoped_ptr<DetachedWebContentsDelegate> detached_delegate_;
 
-  base::WeakPtrFactory<UnloadController> weak_factory_;
+  base::WeakPtrFactory<FastUnloadController> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(UnloadController);
+  DISALLOW_COPY_AND_ASSIGN(FastUnloadController);
 };
 
 }  // namespace chrome
 
-#endif  // CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
+#endif  // CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_