Home | History | Annotate | Download | only in ui 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
      6 #define CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
      7 
      8 #include <set>
      9 
     10 #include "base/callback.h"
     11 #include "base/memory/weak_ptr.h"
     12 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
     13 #include "content/public/browser/notification_observer.h"
     14 #include "content/public/browser/notification_registrar.h"
     15 
     16 class Browser;
     17 class TabStripModel;
     18 
     19 namespace content {
     20 class NotificationSource;
     21 class NotificationDetails;
     22 class WebContents;
     23 }
     24 
     25 namespace chrome {
     26 
     27 class UnloadController : public content::NotificationObserver,
     28                          public TabStripModelObserver {
     29  public:
     30   explicit UnloadController(Browser* browser);
     31   virtual ~UnloadController();
     32 
     33   // Returns true if |contents| can be cleanly closed. When |browser_| is being
     34   // closed, this function will return false to indicate |contents| should not
     35   // be cleanly closed, since the fast shutdown path will just kill its
     36   // renderer.
     37   bool CanCloseContents(content::WebContents* contents);
     38 
     39   // Returns true if we need to run unload events for the |contents|.
     40   static bool ShouldRunUnloadEventsHelper(content::WebContents* contents);
     41 
     42   // Helper function to run beforeunload listeners on a WebContents.
     43   // Returns true if |contents| beforeunload listeners were invoked.
     44   static bool RunUnloadEventsHelper(content::WebContents* contents);
     45 
     46   // Called when a BeforeUnload handler is fired for |contents|. |proceed|
     47   // indicates the user's response to the Y/N BeforeUnload handler dialog. If
     48   // this parameter is false, any pending attempt to close the whole browser
     49   // will be canceled. Returns true if Unload handlers should be fired. When the
     50   // |browser_| is being closed, Unload handlers for any particular WebContents
     51   // will not be run until every WebContents being closed has a chance to run
     52   // its BeforeUnloadHandler.
     53   bool BeforeUnloadFired(content::WebContents* contents, bool proceed);
     54 
     55   bool is_attempting_to_close_browser() const {
     56     return is_attempting_to_close_browser_;
     57   }
     58 
     59   // Called in response to a request to close |browser_|'s window. Returns true
     60   // when there are no remaining beforeunload handlers to be run.
     61   bool ShouldCloseWindow();
     62 
     63   // Begins the process of confirming whether the associated browser can be
     64   // closed.
     65   bool CallBeforeUnloadHandlers(
     66       const base::Callback<void(bool)>& on_close_confirmed);
     67 
     68   // Clears the results of any beforeunload confirmation dialogs triggered by a
     69   // CallBeforeUnloadHandlers call.
     70   void ResetBeforeUnloadHandlers();
     71 
     72   // Returns true if |browser_| has any tabs that have BeforeUnload handlers
     73   // that have not been fired. This method is non-const because it builds a list
     74   // of tabs that need their BeforeUnloadHandlers fired.
     75   // TODO(beng): This seems like it could be private but it is used by
     76   //             AreAllBrowsersCloseable() in application_lifetime.cc. It seems
     77   //             very similar to ShouldCloseWindow() and some consolidation
     78   //             could be pursued.
     79   bool TabsNeedBeforeUnloadFired();
     80 
     81   // Clears all the state associated with processing tabs' beforeunload/unload
     82   // events since the user cancelled closing the window.
     83   void CancelWindowClose();
     84 
     85  private:
     86   typedef std::set<content::WebContents*> UnloadListenerSet;
     87 
     88   // Overridden from content::NotificationObserver:
     89   virtual void Observe(int type,
     90                        const content::NotificationSource& source,
     91                        const content::NotificationDetails& details) OVERRIDE;
     92 
     93   // Overridden from TabStripModelObserver:
     94   virtual void TabInsertedAt(content::WebContents* contents,
     95                              int index,
     96                              bool foreground) OVERRIDE;
     97   virtual void TabDetachedAt(content::WebContents* contents,
     98                              int index) OVERRIDE;
     99   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
    100                              content::WebContents* old_contents,
    101                              content::WebContents* new_contents,
    102                              int index) OVERRIDE;
    103   virtual void TabStripEmpty() OVERRIDE;
    104 
    105   void TabAttachedImpl(content::WebContents* contents);
    106   void TabDetachedImpl(content::WebContents* contents);
    107 
    108   // Processes the next tab that needs it's beforeunload/unload event fired.
    109   void ProcessPendingTabs();
    110 
    111   // Whether we've completed firing all the tabs' beforeunload/unload events.
    112   bool HasCompletedUnloadProcessing() const;
    113 
    114   // Removes |web_contents| from the passed |set|.
    115   // Returns whether the tab was in the set in the first place.
    116   bool RemoveFromSet(UnloadListenerSet* set,
    117                      content::WebContents* web_contents);
    118 
    119   // Cleans up state appropriately when we are trying to close the browser and
    120   // the tab has finished firing its unload handler. We also use this in the
    121   // cases where a tab crashes or hangs even if the beforeunload/unload haven't
    122   // successfully fired. If |process_now| is true |ProcessPendingTabs| is
    123   // invoked immediately, otherwise it is invoked after a delay (PostTask).
    124   //
    125   // Typically you'll want to pass in true for |process_now|. Passing in true
    126   // may result in deleting |tab|. If you know that shouldn't happen (because of
    127   // the state of the stack), pass in false.
    128   void ClearUnloadState(content::WebContents* web_contents, bool process_now);
    129 
    130   bool is_calling_before_unload_handlers() {
    131     return !on_close_confirmed_.is_null();
    132   }
    133 
    134   Browser* browser_;
    135 
    136   content::NotificationRegistrar registrar_;
    137 
    138   // Tracks tabs that need there beforeunload event fired before we can
    139   // close the browser. Only gets populated when we try to close the browser.
    140   UnloadListenerSet tabs_needing_before_unload_fired_;
    141 
    142   // Tracks tabs that need there unload event fired before we can
    143   // close the browser. Only gets populated when we try to close the browser.
    144   UnloadListenerSet tabs_needing_unload_fired_;
    145 
    146   // Whether we are processing the beforeunload and unload events of each tab
    147   // in preparation for closing the browser. UnloadController owns this state
    148   // rather than Browser because unload handlers are the only reason that a
    149   // Browser window isn't just immediately closed.
    150   bool is_attempting_to_close_browser_;
    151 
    152   // A callback to call to report whether the user chose to close all tabs of
    153   // |browser_| that have beforeunload event handlers. This is set only if we
    154   // are currently confirming that the browser is closable.
    155   base::Callback<void(bool)> on_close_confirmed_;
    156 
    157   base::WeakPtrFactory<UnloadController> weak_factory_;
    158 
    159   DISALLOW_COPY_AND_ASSIGN(UnloadController);
    160 };
    161 
    162 }  // namespace chrome
    163 
    164 #endif  // CHROME_BROWSER_UI_UNLOAD_CONTROLLER_H_
    165