1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
|
// 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 <set>
#include "base/callback.h"
#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 NotificationDetails;
class WebContents;
}
namespace chrome {
// 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, 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 FastUnloadController : public content::NotificationObserver,
public TabStripModelObserver {
public:
explicit FastUnloadController(Browser* browser);
~FastUnloadController() override;
// 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);
// Returns true if we need to run unload events for the |contents|.
static bool ShouldRunUnloadEventsHelper(content::WebContents* contents);
// Helper function to run beforeunload listeners on a WebContents.
// Returns true if |contents| beforeunload listeners were invoked.
static bool RunUnloadEventsHelper(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
// will be canceled. Returns true if Unload handlers should be fired. When the
// |browser_| is being closed, Unload handlers for any particular WebContents
// will not be run until every WebContents being closed has a chance to run
// its BeforeUnloadHandler.
bool BeforeUnloadFired(content::WebContents* contents, bool proceed);
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);
// Clears the results of any beforeunload confirmation dialogs triggered by a
// CallBeforeUnloadHandlers call.
void ResetBeforeUnloadHandlers();
// 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();
// Returns true if all tabs' beforeunload/unload events have fired.
bool HasCompletedUnloadProcessing() const;
// Clears all the state associated with processing tabs' beforeunload/unload
// events since the user cancelled closing the window.
void CancelWindowClose();
private:
// Overridden from content::NotificationObserver:
void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) override;
// Overridden from TabStripModelObserver:
void TabInsertedAt(content::WebContents* contents,
int index,
bool foreground) override;
void TabDetachedAt(content::WebContents* contents, int index) override;
void TabReplacedAt(TabStripModel* tab_strip_model,
content::WebContents* old_contents,
content::WebContents* new_contents,
int index) override;
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();
// 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;
bool is_calling_before_unload_handlers() {
return !on_close_confirmed_.is_null();
}
Browser* browser_;
content::NotificationRegistrar registrar_;
typedef std::set<content::WebContents*> WebContentsSet;
// Tracks tabs that need their beforeunload event started.
// Only gets populated when we try to close the browser.
WebContentsSet tabs_needing_before_unload_;
// Tracks the tab that needs its beforeunload event result.
// Only gets populated when we try to close the browser.
content::WebContents* tab_needing_before_unload_ack_;
// 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. 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_;
// 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;
scoped_ptr<DetachedWebContentsDelegate> detached_delegate_;
base::WeakPtrFactory<FastUnloadController> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(FastUnloadController);
};
} // namespace chrome
#endif // CHROME_BROWSER_UI_FAST_UNLOAD_CONTROLLER_H_
|