Move unload handling off Browser onto its own class, UnloadController.

chrome/browser/ui/browser.cc

 // 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.
 
 #include "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 117 matching lines @@
 #include "chrome/browser/ui/search/search_model.h"
 #include "chrome/browser/ui/search_engines/search_engine_tab_helper.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/sync/browser_synced_window_delegate.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/dock_info.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/unload_controller.h"
 #include "chrome/browser/ui/web_applications/web_app_ui.h"
 #include "chrome/browser/ui/webui/feedback_ui.h"
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 147 matching lines @@
 // Browser, Constructors, Creation, Showing:
 
 Browser::Browser(Type type, Profile* profile)
     : type_(type),
       profile_(profile),
       window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_strip_model_(new TabStripModel(this, profile))),
       app_type_(APP_TYPE_HOST),
       chrome_updater_factory_(this),
-      is_attempting_to_close_browser_(false),
       cancel_download_confirmation_state_(NOT_PROMPTED),
       initial_show_state_(ui::SHOW_STATE_DEFAULT),
       is_session_restore_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          unload_controller_(new chrome::UnloadController(this))),
       weak_factory_(this),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           content_setting_bubble_model_delegate_(
               new BrowserContentSettingBubbleModelDelegate(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           toolbar_model_delegate_(
               new BrowserToolbarModelDelegate(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_restore_service_delegate_(
               new BrowserTabRestoreServiceDelegate(this))),
@@ skipping 249 matching lines @@
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, OnBeforeUnload handling:
 
 bool Browser::ShouldCloseWindow() {
   if (!CanCloseWithInProgressDownloads())
     return false;
 
-  if (HasCompletedUnloadProcessing())
-    return true;
+  return unload_controller_->ShouldCloseWindow();
+}
 
-  is_attempting_to_close_browser_ = true;
-
-  if (!TabsNeedBeforeUnloadFired())
-    return true;
-
-  ProcessPendingTabs();
-  return false;
+bool Browser::IsAttemptingToCloseBrowser() const {
+  return unload_controller_->is_attempting_to_close_browser();
 }
 
 void Browser::OnWindowClosing() {
   if (!ShouldCloseWindow())
     return;
 
   bool exiting = false;
 
   // Application should shutdown on last window close if the user is explicitly
   // trying to quit, or if there is nothing keeping the browser alive (such as
@@ skipping 64 matching lines @@
   // Show the download page so the user can figure-out what downloads are still
   // in-progress.
   chrome::ShowDownloads(this);
 }
 
 Browser::DownloadClosePreventionType Browser::OkToCloseWithInProgressDownloads(
     int* num_downloads_blocking) const {
   DCHECK(num_downloads_blocking);
   *num_downloads_blocking = 0;
 
-  if (is_attempting_to_close_browser_)
+  if (IsAttemptingToCloseBrowser())
     return DOWNLOAD_CLOSE_OK;
 
   // If we're not running a full browser process with a profile manager
   // (testing), it's ok to close the browser.
   if (!g_browser_process->profile_manager())
     return DOWNLOAD_CLOSE_OK;
 
   int total_download_count = DownloadService::DownloadCountAllProfiles();
   if (total_download_count == 0)
     return DOWNLOAD_CLOSE_OK;   // No downloads; can definitely close.
 
   // Figure out how many windows are open total, and associated with this
   // profile, that are relevant for the ok-to-close decision.
   int profile_window_count = 0;
   int total_window_count = 0;
   for (BrowserList::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end(); ++iter) {
     // Don't count this browser window or any other in the process of closing.
     Browser* const browser = *iter;
-    // Check is_attempting_to_close_browser_ as window closing may be
-    // delayed, and windows that are in the process of closing don't
-    // count against our totals.
-    if (browser == this || browser->is_attempting_to_close_browser_)
+    // Window closing may be delayed, and windows that are in the process of
+    // closing don't count against our totals.
+    if (browser == this || browser->IsAttemptingToCloseBrowser())
       continue;
 
     if ((*iter)->profile() == profile())
       profile_window_count++;
     total_window_count++;
   }
 
   // If there aren't any other windows, we're at browser shutdown,
   // which would cancel all current downloads.
   if (total_window_count == 0) {
@@ skipping 464 matching lines @@
                             bool foreground) {
   SetAsDelegate(contents, this);
   contents->restore_tab_helper()->SetWindowID(session_id());
 
   SyncHistoryWithTabs(index);
 
   // Make sure the loading state is updated correctly, otherwise the throbber
   // won't start if the page is loading.
   LoadingStateChanged(contents->web_contents());
 
-  // If the tab crashes in the beforeunload or unload handler, it won't be
-  // able to ack. But we know we can close it.
-  registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                 content::Source<WebContents>(contents->web_contents()));
-
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                  content::Source<WebContents>(contents->web_contents()));
 
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_DETACHED,
                  content::Source<WebContents>(contents->web_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContents* contents,
                            int index) {
@@ skipping 148 matching lines @@
 
 void Browser::TabStripEmpty() {
   // Close the frame after we return to the message loop (not immediately,
   // otherwise it will destroy this object before the stack has a chance to
   // cleanly unwind.)
   // Note: This will be called several times if TabStripEmpty is called several
   //       times. This is because it does not close the window if tabs are
   //       still present.
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&Browser::CloseFrame, weak_factory_.GetWeakPtr()));
-  // Set is_attempting_to_close_browser_ here, so that extensions, etc, do not
-  // attempt to add tabs to the browser before it closes.
-  is_attempting_to_close_browser_ = true;
 }
 
 bool Browser::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                      bool* is_keyboard_shortcut) {
   // Escape exits tabbed fullscreen mode.
   // TODO(koz): Write a test for this http://crbug.com/100441.
   if (event.windowsKeyCode == 27 &&
       fullscreen_controller_->HandleUserPressedEscape()) {
     return true;
   }
   return window()->PreHandleKeyboardEvent(event, is_keyboard_shortcut);
 }
 
 void Browser::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
   window()->HandleKeyboardEvent(event);
 }
 
 void Browser::OnAcceptFullscreenPermission(
     const GURL& url,
     FullscreenExitBubbleType bubble_type) {
   fullscreen_controller_->OnAcceptFullscreenPermission(url, bubble_type);
 }
 
 void Browser::OnDenyFullscreenPermission(FullscreenExitBubbleType bubble_type) {
   fullscreen_controller_->OnDenyFullscreenPermission(bubble_type);
 }
 
 bool Browser::TabsNeedBeforeUnloadFired() {
-  if (tabs_needing_before_unload_fired_.empty()) {
-    for (int i = 0; i < tab_count(); ++i) {
-      WebContents* contents = chrome::GetTabContentsAt(this, i)->web_contents();
-      if (contents->NeedToFireBeforeUnload())
-        tabs_needing_before_unload_fired_.insert(contents);
-    }
-  }
-  return !tabs_needing_before_unload_fired_.empty();
+  return unload_controller_->TabsNeedBeforeUnloadFired();
 }
 
 bool Browser::IsFullscreenForTabOrPending() const {
   return fullscreen_controller_->IsFullscreenForTabOrPending();
 }
 
 bool Browser::IsMouseLocked() const {
   return fullscreen_controller_->IsMouseLocked();
 }
 
@@ skipping 103 matching lines @@
     command_controller_->LoadingStateChanged(is_loading, false);
     if (GetStatusBubble()) {
       GetStatusBubble()->SetStatus(
           chrome::GetActiveTabContents(this)->core_tab_helper()->
               GetStatusText());
     }
   }
 }
 
 void Browser::CloseContents(WebContents* source) {
-  if (is_attempting_to_close_browser_) {
-    // If we're trying to close the browser, just clear the state related to
-    // waiting for unload to fire. Don't actually try to close the tab as it
-    // will go down the slow shutdown path instead of the fast path of killing
-    // all the renderer processes.
-    ClearUnloadState(source, true);
-    return;
-  }
-
-  chrome::CloseWebContents(this, source);
+  if (unload_controller_->CanCloseContents(source))
+    chrome::CloseWebContents(this, source);
 }
 
 void Browser::MoveContents(WebContents* source, const gfx::Rect& pos) {
   if (!IsPopupOrPanel(source)) {
     NOTREACHED() << "moving invalid browser type";
     return;
   }
   window_->SetBounds(pos);
 }
 
@@ skipping 45 matching lines @@
   return is_app();
 }
 
 gfx::Rect Browser::GetRootWindowResizerRect() const {
   return window_->GetRootWindowResizerRect();
 }
 
 void Browser::BeforeUnloadFired(WebContents* web_contents,
                                 bool proceed,
                                 bool* proceed_to_fire_unload) {
-  if (!is_attempting_to_close_browser_) {
-    *proceed_to_fire_unload = proceed;
-    if (!proceed)
-      web_contents->SetClosedByUserGesture(false);
-    return;
-  }
-
-  if (!proceed) {
-    CancelWindowClose();
-    *proceed_to_fire_unload = false;
-    web_contents->SetClosedByUserGesture(false);
-    return;
-  }
-
-  if (RemoveFromSet(&tabs_needing_before_unload_fired_, web_contents)) {
-    // Now that beforeunload has fired, put the tab on the queue to fire
-    // unload.
-    tabs_needing_unload_fired_.insert(web_contents);
-    ProcessPendingTabs();
-    // We want to handle firing the unload event ourselves since we want to
-    // fire all the beforeunload events before attempting to fire the unload
-    // events should the user cancel closing the browser.
-    *proceed_to_fire_unload = false;
-    return;
-  }
-
-  *proceed_to_fire_unload = true;
+  *proceed_to_fire_unload =
+      unload_controller_->BeforeUnloadFired(web_contents, proceed);
 }
 
 void Browser::SetFocusToLocationBar(bool select_all) {
   // Two differences between this and FocusLocationBar():
   // (1) This doesn't get recorded in user metrics, since it's called
   //     internally.
   // (2) This checks whether the location bar can be focused, and if not, clears
   //     the focus.  FocusLocationBar() is only reached when the location bar is
   //     focusable, but this may be reached at other times, e.g. while in
   //     fullscreen mode, where we need to leave focus in a consistent state.
@@ skipping 407 matching lines @@
       false));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, content::NotificationObserver implementation:
 
 void Browser::Observe(int type,
                       const content::NotificationSource& source,
                       const content::NotificationDetails& details) {
   switch (type) {
-    case content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED:
-      if (is_attempting_to_close_browser_) {
-        // Pass in false so that we delay processing. We need to delay the
-        // processing as it may close the tab, which is currently on the call
-        // stack above us.
-        ClearUnloadState(content::Source<WebContents>(source).ptr(), false);
-      }
-      break;
-
     case content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED:
       // When the current tab's SSL state changes, we need to update the URL
       // bar to reflect the new state. Note that it's possible for the selected
       // tab contents to be NULL. This is because we listen for all sources
       // (NavigationControllers) for convenience, so the notification could
       // actually be for a different window while we're doing asynchronous
       // closing of this one.
       if (chrome::GetActiveWebContents(this) &&
           &chrome::GetActiveWebContents(this)->GetController() ==
           content::Source<NavigationController>(source).ptr())
@@ skipping 326 matching lines @@
         session_service->SetPinnedState(
             session_id(),
             tab->restore_tab_helper()->session_id(),
             tab_strip_model_->IsTabPinned(i));
       }
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// Browser, OnBeforeUnload handling (private):
-
-void Browser::ProcessPendingTabs() {
-  if (!is_attempting_to_close_browser_) {
-    // Because we might invoke this after a delay it's possible for the value of
-    // is_attempting_to_close_browser_ to have changed since we scheduled the
-    // task.
-    return;
-  }
-
-  if (HasCompletedUnloadProcessing()) {
-    // We've finished all the unload events and can proceed to close the
-    // browser.
-    OnWindowClosing();
-    return;
-  }
-
-  // Process beforeunload tabs first. When that queue is empty, process
-  // unload tabs.
-  if (!tabs_needing_before_unload_fired_.empty()) {
-    WebContents* web_contents = *(tabs_needing_before_unload_fired_.begin());
-    // Null check render_view_host here as this gets called on a PostTask and
-    // the tab's render_view_host may have been nulled out.
-    if (web_contents->GetRenderViewHost()) {
-      web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
-    } else {
-      ClearUnloadState(web_contents, true);
-    }
-  } else if (!tabs_needing_unload_fired_.empty()) {
-    // We've finished firing all beforeunload events and can proceed with unload
-    // events.
-    // TODO(ojan): We should add a call to browser_shutdown::OnShutdownStarting
-    // somewhere around here so that we have accurate measurements of shutdown
-    // time.
-    // TODO(ojan): We can probably fire all the unload events in parallel and
-    // get a perf benefit from that in the cases where the tab hangs in it's
-    // unload handler or takes a long time to page in.
-    WebContents* web_contents = *(tabs_needing_unload_fired_.begin());
-    // Null check render_view_host here as this gets called on a PostTask and
-    // the tab's render_view_host may have been nulled out.
-    if (web_contents->GetRenderViewHost()) {
-      web_contents->GetRenderViewHost()->ClosePage();
-    } else {
-      ClearUnloadState(web_contents, true);
-    }
-  } else {
-    NOTREACHED();
-  }
-}
-
-bool Browser::HasCompletedUnloadProcessing() const {
-  return is_attempting_to_close_browser_ &&
-      tabs_needing_before_unload_fired_.empty() &&
-      tabs_needing_unload_fired_.empty();
-}
-
-void Browser::CancelWindowClose() {
-  // Closing of window can be canceled from a beforeunload handler.
-  DCHECK(is_attempting_to_close_browser_);
-  tabs_needing_before_unload_fired_.clear();
-  tabs_needing_unload_fired_.clear();
-  is_attempting_to_close_browser_ = false;
-
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
-      content::Source<Browser>(this),
-      content::NotificationService::NoDetails());
-}
-
-bool Browser::RemoveFromSet(UnloadListenerSet* set, WebContents* web_contents) {
-  DCHECK(is_attempting_to_close_browser_);
-
-  UnloadListenerSet::iterator iter =
-      std::find(set->begin(), set->end(), web_contents);
-  if (iter != set->end()) {
-    set->erase(iter);
-    return true;
-  }
-  return false;
-}
-
-void Browser::ClearUnloadState(WebContents* web_contents, bool process_now) {
-  if (is_attempting_to_close_browser_) {
-    RemoveFromSet(&tabs_needing_before_unload_fired_, web_contents);
-    RemoveFromSet(&tabs_needing_unload_fired_, web_contents);
-    if (process_now) {
-      ProcessPendingTabs();
-    } else {
-      MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&Browser::ProcessPendingTabs, weak_factory_.GetWeakPtr()));
-    }
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // Browser, In-progress download termination handling (private):
 
 bool Browser::CanCloseWithInProgressDownloads() {
   // If we've prompted, we need to hear from the user before we
   // can close.
   if (cancel_download_confirmation_state_ != NOT_PROMPTED)
     return cancel_download_confirmation_state_ != WAITING_FOR_RESPONSE;
 
   int num_downloads_blocking;
   if (DOWNLOAD_CLOSE_OK ==
@@ skipping 47 matching lines @@
       SyncHistoryWithTabs(0);
   }
 
   SetAsDelegate(contents, NULL);
   RemoveScheduledUpdatesFor(contents->web_contents());
 
   if (find_bar_controller_.get() && index == active_index()) {
     find_bar_controller_->ChangeTabContents(NULL);
   }
 
-  if (is_attempting_to_close_browser_) {
-    // If this is the last tab with unload handlers, then ProcessPendingTabs
-    // would call back into the TabStripModel (which is invoking this method on
-    // us). Avoid that by passing in false so that the call to
-    // ProcessPendingTabs is delayed.
-    ClearUnloadState(contents->web_contents(), false);
-  }
-
   // Stop observing search model changes for this tab.
   search_delegate_->OnTabDetached(contents);
 
   registrar_.Remove(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                     content::Source<WebContents>(contents->web_contents()));
   registrar_.Remove(this, content::NOTIFICATION_INTERSTITIAL_DETACHED,
                     content::Source<WebContents>(contents->web_contents()));
-  registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                    content::Source<WebContents>(contents->web_contents()));
 }
 
 bool Browser::SupportsWindowFeatureImpl(WindowFeature feature,
                                         bool check_fullscreen) const {
   // On Mac, fullscreen mode has most normal things (in a slide-down panel). On
   // other platforms, we hide some controls when in fullscreen mode.
   bool hide_ui_for_fullscreen = false;
 #if !defined(OS_MACOSX)
   hide_ui_for_fullscreen = check_fullscreen && window_ &&
       window_->IsFullscreen();
@@ skipping 142 matching lines @@
   if (contents && !allow_js_access) {
     contents->web_contents()->GetController().LoadURL(
         target_url,
         content::Referrer(),
         content::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }