chrome/browser/lifetime/browser_close_manager_browsertest.cc

   1 // Copyright 2013 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 #include <vector>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "chrome/browser/background/background_mode_manager.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/browser_shutdown.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/defaults.h"
  14 #include "chrome/browser/download/chrome_download_manager_delegate.h"
  15 #include "chrome/browser/download/download_prefs.h"
  16 #include "chrome/browser/download/download_service.h"
  17 #include "chrome/browser/download/download_service_factory.h"
  18 #include "chrome/browser/lifetime/application_lifetime.h"
  19 #include "chrome/browser/lifetime/browser_close_manager.h"
  20 #include "chrome/browser/net/url_request_mock_util.h"
  21 #include "chrome/browser/prefs/session_startup_pref.h"
  22 #include "chrome/browser/profiles/profile.h"
  23 #include "chrome/browser/profiles/profile_manager.h"
  24 #include "chrome/browser/ui/app_modal_dialogs/javascript_app_modal_dialog.h"
  25 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h"
  26 #include "chrome/browser/ui/browser.h"
  27 #include "chrome/browser/ui/browser_commands.h"
  28 #include "chrome/browser/ui/browser_iterator.h"
  29 #include "chrome/browser/ui/browser_window.h"
  30 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  31 #include "chrome/common/chrome_switches.h"
  32 #include "chrome/common/url_constants.h"
  33 #include "chrome/test/base/in_process_browser_test.h"
  34 #include "chrome/test/base/ui_test_utils.h"
  35 #include "content/public/browser/browser_context.h"
  36 #include "content/public/browser/download_item.h"
  37 #include "content/public/browser/download_manager.h"
  38 #include "content/public/browser/notification_service.h"
  39 #include "content/public/browser/web_contents.h"
  40 #include "content/public/test/download_test_observer.h"
  41 #include "content/public/test/test_navigation_observer.h"
  42 #include "content/test/net/url_request_slow_download_job.h"
  43 #include "net/test/embedded_test_server/embedded_test_server.h"
  44 #include "net/test/url_request/url_request_mock_http_job.h"
  45
  46 #if defined(OS_CHROMEOS)
  47 #include "chromeos/chromeos_switches.h"
  48 #endif
  49
  50 namespace {
  51
  52 class AppModalDialogObserver {
  53  public:
  54   AppModalDialogObserver() {}
  55
  56   void Start() {
  57     observer_.reset(new content::WindowedNotificationObserver(
  58         chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
  59         content::NotificationService::AllSources()));
  60   }
  61
  62   void AcceptClose() {
  63     NativeAppModalDialog* dialog = GetNextDialog();
  64     ASSERT_TRUE(dialog);
  65     dialog->AcceptAppModalDialog();
  66   }
  67
  68   void CancelClose() {
  69     NativeAppModalDialog* dialog = GetNextDialog();
  70     ASSERT_TRUE(dialog);
  71     dialog->CancelAppModalDialog();
  72   }
  73
  74  private:
  75   NativeAppModalDialog* GetNextDialog() {
  76     DCHECK(observer_);
  77     observer_->Wait();
  78     if (observer_->source() == content::NotificationService::AllSources())
  79       return NULL;
  80
  81     AppModalDialog* dialog =
  82         content::Source<AppModalDialog>(observer_->source()).ptr();
  83     EXPECT_TRUE(dialog->IsJavaScriptModalDialog());
  84     JavaScriptAppModalDialog* js_dialog =
  85         static_cast<JavaScriptAppModalDialog*>(dialog);
  86     observer_.reset(new content::WindowedNotificationObserver(
  87         chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
  88         content::NotificationService::AllSources()));
  89     return js_dialog->native_dialog();
  90   }
  91
  92   scoped_ptr<content::WindowedNotificationObserver> observer_;
  93
  94   DISALLOW_COPY_AND_ASSIGN(AppModalDialogObserver);
  95 };
  96
  97 class RepeatedNotificationObserver : public content::NotificationObserver {
  98  public:
  99   explicit RepeatedNotificationObserver(int type, int count)
 100       : num_outstanding_(count), running_(false) {
 101     registrar_.Add(this, type, content::NotificationService::AllSources());
 102   }
 103
 104   virtual void Observe(int type,
 105                        const content::NotificationSource& source,
 106                        const content::NotificationDetails& details) override {
 107     ASSERT_GT(num_outstanding_, 0);
 108     if (!--num_outstanding_ && running_) {
 109       content::BrowserThread::PostTask(
 110           content::BrowserThread::UI, FROM_HERE, run_loop_.QuitClosure());
 111     }
 112   }
 113
 114   void Wait() {
 115     if (num_outstanding_ <= 0)
 116       return;
 117
 118     running_ = true;
 119     run_loop_.Run();
 120     running_ = false;
 121   }
 122
 123  private:
 124   int num_outstanding_;
 125   content::NotificationRegistrar registrar_;
 126   bool running_;
 127   base::RunLoop run_loop_;
 128
 129   DISALLOW_COPY_AND_ASSIGN(RepeatedNotificationObserver);
 130 };
 131
 132 class TestBrowserCloseManager : public BrowserCloseManager {
 133  public:
 134   enum UserChoice {
 135     USER_CHOICE_USER_CANCELS_CLOSE,
 136     USER_CHOICE_USER_ALLOWS_CLOSE,
 137     NO_USER_CHOICE
 138   };
 139
 140   static void AttemptClose(UserChoice user_choice) {
 141     scoped_refptr<BrowserCloseManager> browser_close_manager =
 142         new TestBrowserCloseManager(user_choice);
 143     browser_shutdown::SetTryingToQuit(true);
 144     browser_close_manager->StartClosingBrowsers();
 145   }
 146
 147  protected:
 148   virtual ~TestBrowserCloseManager() {}
 149
 150   virtual void ConfirmCloseWithPendingDownloads(
 151       int download_count,
 152       const base::Callback<void(bool)>& callback) override {
 153     EXPECT_NE(NO_USER_CHOICE, user_choice_);
 154     switch (user_choice_) {
 155       case NO_USER_CHOICE:
 156       case USER_CHOICE_USER_CANCELS_CLOSE: {
 157         callback.Run(false);
 158         break;
 159       }
 160       case USER_CHOICE_USER_ALLOWS_CLOSE: {
 161         callback.Run(true);
 162         break;
 163       }
 164     }
 165   }
 166
 167  private:
 168   explicit TestBrowserCloseManager(UserChoice user_choice)
 169       : user_choice_(user_choice) {}
 170
 171   UserChoice user_choice_;
 172
 173   DISALLOW_COPY_AND_ASSIGN(TestBrowserCloseManager);
 174 };
 175
 176 class TestDownloadManagerDelegate : public ChromeDownloadManagerDelegate {
 177  public:
 178   explicit TestDownloadManagerDelegate(Profile* profile)
 179       : ChromeDownloadManagerDelegate(profile) {
 180     GetDownloadIdReceiverCallback().Run(content::DownloadItem::kInvalidId + 1);
 181   }
 182   virtual ~TestDownloadManagerDelegate() {}
 183
 184   virtual bool DetermineDownloadTarget(
 185       content::DownloadItem* item,
 186       const content::DownloadTargetCallback& callback) override {
 187     content::DownloadTargetCallback dangerous_callback =
 188         base::Bind(&TestDownloadManagerDelegate::SetDangerous, callback);
 189     return ChromeDownloadManagerDelegate::DetermineDownloadTarget(
 190         item, dangerous_callback);
 191   }
 192
 193   static void SetDangerous(
 194       const content::DownloadTargetCallback& callback,
 195       const base::FilePath& target_path,
 196       content::DownloadItem::TargetDisposition disp,
 197       content::DownloadDangerType danger_type,
 198       const base::FilePath& intermediate_path) {
 199     callback.Run(target_path,
 200                  disp,
 201                  content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
 202                  intermediate_path);
 203   }
 204 };
 205
 206 class FakeBackgroundModeManager : public BackgroundModeManager {
 207  public:
 208   FakeBackgroundModeManager()
 209       : BackgroundModeManager(
 210             CommandLine::ForCurrentProcess(),
 211             &g_browser_process->profile_manager()->GetProfileInfoCache()),
 212         suspended_(false) {}
 213
 214   virtual void SuspendBackgroundMode() override {
 215     BackgroundModeManager::SuspendBackgroundMode();
 216     suspended_ = true;
 217   }
 218
 219   virtual void ResumeBackgroundMode() override {
 220     BackgroundModeManager::ResumeBackgroundMode();
 221     suspended_ = false;
 222   }
 223
 224   bool IsBackgroundModeSuspended() {
 225     return suspended_;
 226   }
 227
 228  private:
 229   bool suspended_;
 230
 231   DISALLOW_COPY_AND_ASSIGN(FakeBackgroundModeManager);
 232 };
 233
 234 }  // namespace
 235
 236 class BrowserCloseManagerBrowserTest
 237     : public InProcessBrowserTest,
 238       public testing::WithParamInterface<bool> {
 239  protected:
 240   virtual void SetUpOnMainThread() override {
 241     InProcessBrowserTest::SetUpOnMainThread();
 242     SessionStartupPref::SetStartupPref(
 243         browser()->profile(), SessionStartupPref(SessionStartupPref::LAST));
 244     browsers_.push_back(browser());
 245     dialogs_.Start();
 246     content::BrowserThread::PostTask(
 247         content::BrowserThread::IO,
 248         FROM_HERE,
 249         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
 250   }
 251
 252   virtual void SetUpCommandLine(CommandLine* command_line) override {
 253     if (GetParam())
 254       command_line->AppendSwitch(switches::kEnableFastUnload);
 255 #if defined(OS_CHROMEOS)
 256     command_line->AppendSwitch(
 257         chromeos::switches::kIgnoreUserProfileMappingForTests);
 258 #endif
 259   }
 260
 261   void CreateStalledDownload(Browser* browser) {
 262     content::DownloadTestObserverInProgress observer(
 263         content::BrowserContext::GetDownloadManager(browser->profile()), 1);
 264     ui_test_utils::NavigateToURLWithDisposition(
 265         browser,
 266         GURL(content::URLRequestSlowDownloadJob::kKnownSizeUrl),
 267         NEW_BACKGROUND_TAB,
 268         ui_test_utils::BROWSER_TEST_NONE);
 269     observer.WaitForFinished();
 270     EXPECT_EQ(
 271         1UL,
 272         observer.NumDownloadsSeenInState(content::DownloadItem::IN_PROGRESS));
 273   }
 274
 275   std::vector<Browser*> browsers_;
 276   AppModalDialogObserver dialogs_;
 277 };
 278
 279 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest, TestSingleTabShutdown) {
 280   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 281   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 282       browser(), embedded_test_server()->GetURL("/beforeunload.html")));
 283   RepeatedNotificationObserver cancel_observer(
 284       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 285   chrome::CloseAllBrowsersAndQuit();
 286   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 287   cancel_observer.Wait();
 288   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 289   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 290
 291   RepeatedNotificationObserver close_observer(
 292       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 293   chrome::CloseAllBrowsersAndQuit();
 294   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 295   close_observer.Wait();
 296   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 297   EXPECT_TRUE(chrome::BrowserIterator().done());
 298 }
 299
 300 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 301                        TestShutdownMoreThanOnce) {
 302   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 303   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 304       browser(), embedded_test_server()->GetURL("/beforeunload.html")));
 305   RepeatedNotificationObserver cancel_observer(
 306       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 307   chrome::CloseAllBrowsersAndQuit();
 308   chrome::CloseAllBrowsersAndQuit();
 309   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 310   cancel_observer.Wait();
 311   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 312   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 313
 314   RepeatedNotificationObserver close_observer(
 315       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 316   chrome::CloseAllBrowsersAndQuit();
 317   chrome::CloseAllBrowsersAndQuit();
 318   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 319   close_observer.Wait();
 320   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 321   EXPECT_TRUE(chrome::BrowserIterator().done());
 322 }
 323
 324 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest, PRE_TestSessionRestore) {
 325   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 326   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 327       browser(), embedded_test_server()->GetURL("/beforeunload.html")));
 328   AddBlankTabAndShow(browser());
 329   ASSERT_NO_FATAL_FAILURE(
 330       ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIAboutURL)));
 331   RepeatedNotificationObserver cancel_observer(
 332       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 333   chrome::CloseAllBrowsersAndQuit();
 334   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 335   cancel_observer.Wait();
 336   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 337
 338   browser()->tab_strip_model()
 339       ->CloseWebContentsAt(1, TabStripModel::CLOSE_USER_GESTURE);
 340   content::TestNavigationObserver navigation_observer(
 341       browser()->tab_strip_model()->GetActiveWebContents(), 1);
 342   ASSERT_NO_FATAL_FAILURE(
 343       NavigateToURLWithDisposition(browser(),
 344                                    GURL(chrome::kChromeUIVersionURL),
 345                                    CURRENT_TAB,
 346                                    ui_test_utils::BROWSER_TEST_NONE));
 347   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 348   navigation_observer.Wait();
 349
 350   RepeatedNotificationObserver close_observer(
 351       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 352   chrome::CloseAllBrowsersAndQuit();
 353   close_observer.Wait();
 354   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 355   EXPECT_TRUE(chrome::BrowserIterator().done());
 356 }
 357
 358 // Test that the tab closed after the aborted shutdown attempt is not re-opened
 359 // when restoring the session.
 360 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest, TestSessionRestore) {
 361   // The testing framework launches Chrome with about:blank as args.
 362   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 363   EXPECT_EQ(GURL(chrome::kChromeUIVersionURL),
 364             browser()->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 365   EXPECT_EQ(GURL("about:blank"),
 366             browser()->tab_strip_model()->GetWebContentsAt(1)->GetURL());
 367 }
 368
 369 // Test that browser windows are only closed if all browsers are ready to close
 370 // and that all beforeunload dialogs are shown again after a cancel.
 371 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest, TestMultipleWindows) {
 372   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 373   browsers_.push_back(CreateBrowser(browser()->profile()));
 374   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 375       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 376   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 377       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 378
 379   // Cancel shutdown on the first beforeunload event.
 380   {
 381     RepeatedNotificationObserver cancel_observer(
 382         chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 383     chrome::CloseAllBrowsersAndQuit();
 384     ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 385     cancel_observer.Wait();
 386   }
 387   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 388   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 389   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 390
 391   // Cancel shutdown on the second beforeunload event.
 392   {
 393     RepeatedNotificationObserver cancel_observer(
 394         chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 2);
 395     chrome::CloseAllBrowsersAndQuit();
 396     ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 397     ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 398     cancel_observer.Wait();
 399   }
 400   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 401   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 402   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 403
 404   // Allow shutdown for both beforeunload events.
 405   RepeatedNotificationObserver close_observer(
 406       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 407   chrome::CloseAllBrowsersAndQuit();
 408   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 409   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 410   close_observer.Wait();
 411   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 412   EXPECT_TRUE(chrome::BrowserIterator().done());
 413 }
 414
 415 // Test that tabs in the same window with a beforeunload event that hangs are
 416 // treated the same as the user accepting the close, but do not close the tab
 417 // early.
 418 // Test is flaky on windows, disabled. See http://crbug.com/276366
 419 #if defined(OS_WIN)
 420 #define MAYBE_TestHangInBeforeUnloadMultipleTabs \
 421     DISABLED_TestHangInBeforeUnloadMultipleTabs
 422 #else
 423 #define MAYBE_TestHangInBeforeUnloadMultipleTabs \
 424     TestHangInBeforeUnloadMultipleTabs
 425 #endif
 426 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 427                        MAYBE_TestHangInBeforeUnloadMultipleTabs) {
 428   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 429   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 430       browsers_[0], embedded_test_server()->GetURL("/beforeunload_hang.html")));
 431   AddBlankTabAndShow(browsers_[0]);
 432   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 433       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 434   AddBlankTabAndShow(browsers_[0]);
 435   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 436       browsers_[0], embedded_test_server()->GetURL("/beforeunload_hang.html")));
 437
 438   RepeatedNotificationObserver cancel_observer(
 439       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 440   chrome::CloseAllBrowsersAndQuit();
 441   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 442   cancel_observer.Wait();
 443   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 444   // All tabs should still be open.
 445   EXPECT_EQ(3, browsers_[0]->tab_strip_model()->count());
 446
 447   RepeatedNotificationObserver close_observer(
 448       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 449   chrome::CloseAllBrowsersAndQuit();
 450   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 451   close_observer.Wait();
 452   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 453   EXPECT_TRUE(chrome::BrowserIterator().done());
 454 }
 455
 456 // Test that tabs in different windows with a beforeunload event that hangs are
 457 // treated the same as the user accepting the close, but do not close the tab
 458 // early.
 459 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 460                        TestHangInBeforeUnloadMultipleWindows) {
 461   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 462   browsers_.push_back(CreateBrowser(browser()->profile()));
 463   browsers_.push_back(CreateBrowser(browser()->profile()));
 464   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 465       browsers_[0], embedded_test_server()->GetURL("/beforeunload_hang.html")));
 466   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 467       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 468   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 469       browsers_[2], embedded_test_server()->GetURL("/beforeunload_hang.html")));
 470
 471   RepeatedNotificationObserver cancel_observer(
 472       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 2);
 473   chrome::CloseAllBrowsersAndQuit();
 474   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 475   cancel_observer.Wait();
 476   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 477   // All windows should still be open.
 478   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 479   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 480   EXPECT_EQ(1, browsers_[2]->tab_strip_model()->count());
 481
 482   RepeatedNotificationObserver close_observer(
 483       chrome::NOTIFICATION_BROWSER_CLOSED, 3);
 484   chrome::CloseAllBrowsersAndQuit();
 485   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 486   close_observer.Wait();
 487   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 488   EXPECT_TRUE(chrome::BrowserIterator().done());
 489 }
 490
 491 // Test that a window created during shutdown is closed.
 492 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 493                        TestAddWindowDuringShutdown) {
 494   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 495   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 496       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 497
 498   RepeatedNotificationObserver close_observer(
 499       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 500   chrome::CloseAllBrowsersAndQuit();
 501   browsers_.push_back(CreateBrowser(browser()->profile()));
 502   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 503   close_observer.Wait();
 504   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 505   EXPECT_TRUE(chrome::BrowserIterator().done());
 506 }
 507
 508 // Test that a window created during shutdown with a beforeunload handler can
 509 // cancel the shutdown.
 510 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 511                        TestAddWindowWithBeforeUnloadDuringShutdown) {
 512   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 513   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 514       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 515
 516   RepeatedNotificationObserver cancel_observer(
 517       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 2);
 518   chrome::CloseAllBrowsersAndQuit();
 519   browsers_.push_back(CreateBrowser(browser()->profile()));
 520   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 521       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 522   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 523   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 524   cancel_observer.Wait();
 525   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 526   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 527   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 528
 529   // Allow shutdown for both beforeunload dialogs.
 530   RepeatedNotificationObserver close_observer(
 531       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 532   chrome::CloseAllBrowsersAndQuit();
 533   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 534   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 535   close_observer.Wait();
 536   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 537   EXPECT_TRUE(chrome::BrowserIterator().done());
 538 }
 539
 540 // Test that tabs added during shutdown are closed.
 541 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 542                        TestAddTabDuringShutdown) {
 543   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 544   browsers_.push_back(CreateBrowser(browser()->profile()));
 545   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 546       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 547   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 548       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 549
 550   RepeatedNotificationObserver close_observer(
 551       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 552   chrome::CloseAllBrowsersAndQuit();
 553   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 554   AddBlankTabAndShow(browsers_[0]);
 555   AddBlankTabAndShow(browsers_[1]);
 556   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 557   close_observer.Wait();
 558   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 559   EXPECT_TRUE(chrome::BrowserIterator().done());
 560 }
 561
 562 // Test that tabs created during shutdown with beforeunload handlers can cancel
 563 // the shutdown.
 564 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 565                        TestAddTabWithBeforeUnloadDuringShutdown) {
 566   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 567   browsers_.push_back(CreateBrowser(browser()->profile()));
 568   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 569       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 570   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 571       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 572   RepeatedNotificationObserver cancel_observer(
 573       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 2);
 574   chrome::CloseAllBrowsersAndQuit();
 575   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 576   AddBlankTabAndShow(browsers_[0]);
 577   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 578       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 579   AddBlankTabAndShow(browsers_[1]);
 580   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 581       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 582   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 583   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 584   cancel_observer.Wait();
 585   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 586   EXPECT_EQ(2, browsers_[0]->tab_strip_model()->count());
 587   EXPECT_EQ(2, browsers_[1]->tab_strip_model()->count());
 588
 589   RepeatedNotificationObserver close_observer(
 590       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 591   chrome::CloseAllBrowsersAndQuit();
 592   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 593   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 594   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 595   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 596
 597   close_observer.Wait();
 598   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 599   EXPECT_TRUE(chrome::BrowserIterator().done());
 600 }
 601
 602 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 603                        TestCloseTabDuringShutdown) {
 604   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 605   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 606       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 607   RepeatedNotificationObserver cancel_observer(
 608       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 609   chrome::CloseAllBrowsersAndQuit();
 610
 611   browsers_.push_back(CreateBrowser(browser()->profile()));
 612   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 613       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 614   browsers_[1]->tab_strip_model()->CloseAllTabs();
 615   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 616   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 617   cancel_observer.Wait();
 618   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 619   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 620   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 621
 622   RepeatedNotificationObserver close_observer(
 623       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 624   chrome::CloseAllBrowsersAndQuit();
 625   browsers_[1]->tab_strip_model()->CloseAllTabs();
 626   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 627   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 628
 629   close_observer.Wait();
 630   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 631   EXPECT_TRUE(chrome::BrowserIterator().done());
 632 }
 633
 634 // Test is flaky on windows, disabled. See http://crbug.com/276366
 635 #if defined(OS_WIN)
 636 #define MAYBE_TestOpenAndCloseWindowDuringShutdown \
 637     DISABLED_TestOpenAndCloseWindowDuringShutdown
 638 #else
 639 #define MAYBE_TestOpenAndCloseWindowDuringShutdown \
 640     TestOpenAndCloseWindowDuringShutdown
 641 #endif
 642 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 643                        MAYBE_TestOpenAndCloseWindowDuringShutdown) {
 644   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 645   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 646       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 647   RepeatedNotificationObserver cancel_observer(
 648       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 2);
 649   chrome::CloseAllBrowsersAndQuit();
 650
 651   browsers_.push_back(CreateBrowser(browser()->profile()));
 652   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 653       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 654   ASSERT_FALSE(browsers_[1]->ShouldCloseWindow());
 655   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 656   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 657   cancel_observer.Wait();
 658   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 659   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 660   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 661
 662   RepeatedNotificationObserver close_observer(
 663       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 664   chrome::CloseAllBrowsersAndQuit();
 665   ASSERT_FALSE(browsers_[1]->ShouldCloseWindow());
 666   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 667   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 668
 669   close_observer.Wait();
 670   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 671   EXPECT_TRUE(chrome::BrowserIterator().done());
 672 }
 673
 674 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerBrowserTest,
 675                        TestCloseWindowDuringShutdown) {
 676   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 677   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 678       browsers_[0], embedded_test_server()->GetURL("/beforeunload.html")));
 679   browsers_.push_back(CreateBrowser(browser()->profile()));
 680   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 681       browsers_[1], embedded_test_server()->GetURL("/beforeunload.html")));
 682   RepeatedNotificationObserver cancel_observer(
 683       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED, 1);
 684   chrome::CloseAllBrowsersAndQuit();
 685
 686   ASSERT_FALSE(browsers_[0]->ShouldCloseWindow());
 687   ASSERT_NO_FATAL_FAILURE(dialogs_.CancelClose());
 688   cancel_observer.Wait();
 689   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 690   EXPECT_EQ(1, browsers_[0]->tab_strip_model()->count());
 691   EXPECT_EQ(1, browsers_[1]->tab_strip_model()->count());
 692
 693   RepeatedNotificationObserver close_observer(
 694       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 695   chrome::CloseAllBrowsersAndQuit();
 696   ASSERT_FALSE(browsers_[0]->ShouldCloseWindow());
 697   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 698   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 699
 700   close_observer.Wait();
 701   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 702   EXPECT_TRUE(chrome::BrowserIterator().done());
 703 }
 704
 705 INSTANTIATE_TEST_CASE_P(BrowserCloseManagerBrowserTest,
 706                         BrowserCloseManagerBrowserTest,
 707                         testing::Bool());
 708
 709 class BrowserCloseManagerWithDownloadsBrowserTest :
 710   public BrowserCloseManagerBrowserTest {
 711  public:
 712   BrowserCloseManagerWithDownloadsBrowserTest() {}
 713   virtual ~BrowserCloseManagerWithDownloadsBrowserTest() {}
 714
 715   virtual void SetUpOnMainThread() override {
 716     BrowserCloseManagerBrowserTest::SetUpOnMainThread();
 717     ASSERT_TRUE(scoped_download_directory_.CreateUniqueTempDir());
 718   }
 719
 720   void SetDownloadPathForProfile(Profile* profile) {
 721     DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(profile);
 722     download_prefs->SetDownloadPath(download_path());
 723   }
 724
 725   const base::FilePath& download_path() const {
 726     return scoped_download_directory_.path();
 727   }
 728
 729  private:
 730   base::ScopedTempDir scoped_download_directory_;
 731 };
 732
 733 // Test shutdown with a DANGEROUS_URL download undecided.
 734 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithDownloadsBrowserTest,
 735     TestWithDangerousUrlDownload) {
 736   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 737   SetDownloadPathForProfile(browser()->profile());
 738
 739   // Set up the fake delegate that forces the download to be malicious.
 740   scoped_ptr<TestDownloadManagerDelegate> test_delegate(
 741       new TestDownloadManagerDelegate(browser()->profile()));
 742   DownloadServiceFactory::GetForBrowserContext(browser()->profile())
 743       ->SetDownloadManagerDelegateForTesting(test_delegate.Pass());
 744
 745   // Run a dangerous download, but the user doesn't make a decision.
 746   // This .swf normally would be categorized as DANGEROUS_FILE, but
 747   // TestDownloadManagerDelegate turns it into DANGEROUS_URL.
 748   base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
 749   GURL download_url(net::URLRequestMockHTTPJob::GetMockUrl(file));
 750   content::DownloadTestObserverInterrupted observer(
 751       content::BrowserContext::GetDownloadManager(browser()->profile()),
 752       1,
 753       content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT);
 754   ui_test_utils::NavigateToURLWithDisposition(
 755       browser(),
 756       GURL(download_url),
 757       NEW_BACKGROUND_TAB,
 758       ui_test_utils::BROWSER_TEST_NONE);
 759   observer.WaitForFinished();
 760
 761   // Check that the download manager has the expected state.
 762   EXPECT_EQ(1, content::BrowserContext::GetDownloadManager(
 763       browser()->profile())->InProgressCount());
 764   EXPECT_EQ(0, content::BrowserContext::GetDownloadManager(
 765       browser()->profile())->NonMaliciousInProgressCount());
 766
 767   // Close the browser with no user action.
 768   RepeatedNotificationObserver close_observer(
 769       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 770   TestBrowserCloseManager::AttemptClose(
 771       TestBrowserCloseManager::NO_USER_CHOICE);
 772   close_observer.Wait();
 773   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 774   EXPECT_TRUE(chrome::BrowserIterator().done());
 775 }
 776
 777 // Test shutdown with a download in progress.
 778 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithDownloadsBrowserTest,
 779                        TestWithDownloads) {
 780   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 781   SetDownloadPathForProfile(browser()->profile());
 782   ASSERT_NO_FATAL_FAILURE(CreateStalledDownload(browser()));
 783   content::TestNavigationObserver navigation_observer(
 784       browser()->tab_strip_model()->GetActiveWebContents(), 1);
 785   TestBrowserCloseManager::AttemptClose(
 786       TestBrowserCloseManager::USER_CHOICE_USER_CANCELS_CLOSE);
 787   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 788   navigation_observer.Wait();
 789   EXPECT_EQ(GURL(chrome::kChromeUIDownloadsURL),
 790             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 791
 792   RepeatedNotificationObserver close_observer(
 793       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 794
 795   TestBrowserCloseManager::AttemptClose(
 796       TestBrowserCloseManager::USER_CHOICE_USER_ALLOWS_CLOSE);
 797   close_observer.Wait();
 798   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 799   EXPECT_TRUE(chrome::BrowserIterator().done());
 800   if (browser_defaults::kBrowserAliveWithNoWindows)
 801     EXPECT_EQ(1, DownloadService::NonMaliciousDownloadCountAllProfiles());
 802   else
 803     EXPECT_EQ(0, DownloadService::NonMaliciousDownloadCountAllProfiles());
 804 }
 805
 806 // Test shutdown with a download in progress from one profile, where the only
 807 // open windows are for another profile.
 808 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithDownloadsBrowserTest,
 809                        TestWithDownloadsFromDifferentProfiles) {
 810   ProfileManager* profile_manager = g_browser_process->profile_manager();
 811   base::FilePath path =
 812       profile_manager->user_data_dir().AppendASCII("test_profile");
 813   if (!base::PathExists(path))
 814     ASSERT_TRUE(base::CreateDirectory(path));
 815   Profile* other_profile =
 816       Profile::CreateProfile(path, NULL, Profile::CREATE_MODE_SYNCHRONOUS);
 817   profile_manager->RegisterTestingProfile(other_profile, true, false);
 818   Browser* other_profile_browser = CreateBrowser(other_profile);
 819
 820   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 821   SetDownloadPathForProfile(browser()->profile());
 822   SetDownloadPathForProfile(other_profile);
 823   ASSERT_NO_FATAL_FAILURE(CreateStalledDownload(browser()));
 824   {
 825     RepeatedNotificationObserver close_observer(
 826         chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 827     browser()->window()->Close();
 828     close_observer.Wait();
 829   }
 830
 831   // When the shutdown is cancelled, the downloads page should be opened in a
 832   // browser for that profile. Because there are no browsers for that profile, a
 833   // new browser should be opened.
 834   ui_test_utils::BrowserAddedObserver new_browser_observer;
 835   TestBrowserCloseManager::AttemptClose(
 836       TestBrowserCloseManager::USER_CHOICE_USER_CANCELS_CLOSE);
 837   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 838   Browser* opened_browser = new_browser_observer.WaitForSingleNewBrowser();
 839   EXPECT_EQ(
 840       GURL(chrome::kChromeUIDownloadsURL),
 841       opened_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 842   EXPECT_EQ(GURL("about:blank"),
 843             other_profile_browser->tab_strip_model()->GetActiveWebContents()
 844                 ->GetURL());
 845
 846   RepeatedNotificationObserver close_observer(
 847       chrome::NOTIFICATION_BROWSER_CLOSED, 2);
 848   TestBrowserCloseManager::AttemptClose(
 849       TestBrowserCloseManager::USER_CHOICE_USER_ALLOWS_CLOSE);
 850   close_observer.Wait();
 851   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 852   EXPECT_TRUE(chrome::BrowserIterator().done());
 853   if (browser_defaults::kBrowserAliveWithNoWindows)
 854     EXPECT_EQ(1, DownloadService::NonMaliciousDownloadCountAllProfiles());
 855   else
 856     EXPECT_EQ(0, DownloadService::NonMaliciousDownloadCountAllProfiles());
 857 }
 858
 859 // Test shutdown with downloads in progress and beforeunload handlers.
 860 // Disabled, see http://crbug.com/315754.
 861 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithDownloadsBrowserTest,
 862                        DISABLED_TestBeforeUnloadAndDownloads) {
 863   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 864   SetDownloadPathForProfile(browser()->profile());
 865   ASSERT_NO_FATAL_FAILURE(CreateStalledDownload(browser()));
 866   ASSERT_NO_FATAL_FAILURE(ui_test_utils::NavigateToURL(
 867       browser(), embedded_test_server()->GetURL("/beforeunload.html")));
 868
 869   content::WindowedNotificationObserver cancel_observer(
 870       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
 871       content::NotificationService::AllSources());
 872   TestBrowserCloseManager::AttemptClose(
 873       TestBrowserCloseManager::USER_CHOICE_USER_CANCELS_CLOSE);
 874   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 875   cancel_observer.Wait();
 876   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 877
 878   RepeatedNotificationObserver close_observer(
 879       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 880   TestBrowserCloseManager::AttemptClose(
 881       TestBrowserCloseManager::USER_CHOICE_USER_ALLOWS_CLOSE);
 882   ASSERT_NO_FATAL_FAILURE(dialogs_.AcceptClose());
 883   close_observer.Wait();
 884   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 885   EXPECT_TRUE(chrome::BrowserIterator().done());
 886 }
 887
 888 INSTANTIATE_TEST_CASE_P(BrowserCloseManagerWithDownloadsBrowserTest,
 889                         BrowserCloseManagerWithDownloadsBrowserTest,
 890                         testing::Bool());
 891
 892 class BrowserCloseManagerWithBackgroundModeBrowserTest
 893     : public BrowserCloseManagerBrowserTest {
 894  public:
 895   BrowserCloseManagerWithBackgroundModeBrowserTest() {}
 896
 897   virtual void SetUpOnMainThread() override {
 898     BrowserCloseManagerBrowserTest::SetUpOnMainThread();
 899     g_browser_process->set_background_mode_manager_for_test(
 900         scoped_ptr<BackgroundModeManager>(new FakeBackgroundModeManager));
 901   }
 902
 903   bool IsBackgroundModeSuspended() {
 904     return static_cast<FakeBackgroundModeManager*>(
 905         g_browser_process->background_mode_manager())
 906         ->IsBackgroundModeSuspended();
 907   }
 908
 909  private:
 910   DISALLOW_COPY_AND_ASSIGN(BrowserCloseManagerWithBackgroundModeBrowserTest);
 911 };
 912
 913 // Check that background mode is suspended when closing all browsers unless we
 914 // are quitting and that background mode is resumed when a new browser window is
 915 // opened.
 916 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithBackgroundModeBrowserTest,
 917                        CloseAllBrowsersWithBackgroundMode) {
 918   EXPECT_FALSE(IsBackgroundModeSuspended());
 919   Profile* profile = browser()->profile();
 920   {
 921     RepeatedNotificationObserver close_observer(
 922         chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 923     chrome::IncrementKeepAliveCount();
 924     chrome::CloseAllBrowsers();
 925     close_observer.Wait();
 926   }
 927   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 928   EXPECT_TRUE(chrome::BrowserIterator().done());
 929   EXPECT_TRUE(IsBackgroundModeSuspended());
 930
 931   // Background mode should be resumed when a new browser window is opened.
 932   ui_test_utils::BrowserAddedObserver new_browser_observer;
 933   chrome::NewEmptyWindow(profile, chrome::HOST_DESKTOP_TYPE_NATIVE);
 934   new_browser_observer.WaitForSingleNewBrowser();
 935   chrome::DecrementKeepAliveCount();
 936   EXPECT_FALSE(IsBackgroundModeSuspended());
 937   RepeatedNotificationObserver close_observer(
 938       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 939
 940   // Background mode should not be suspended when quitting.
 941   chrome::CloseAllBrowsersAndQuit();
 942   close_observer.Wait();
 943   EXPECT_TRUE(browser_shutdown::IsTryingToQuit());
 944   EXPECT_TRUE(chrome::BrowserIterator().done());
 945   EXPECT_FALSE(IsBackgroundModeSuspended());
 946
 947 }
 948
 949 // Check that closing the last browser window individually does not affect
 950 // background mode.
 951 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithBackgroundModeBrowserTest,
 952                        CloseSingleBrowserWithBackgroundMode) {
 953   RepeatedNotificationObserver close_observer(
 954       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 955   EXPECT_FALSE(IsBackgroundModeSuspended());
 956   browser()->window()->Close();
 957   close_observer.Wait();
 958   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 959   EXPECT_TRUE(chrome::BrowserIterator().done());
 960   EXPECT_FALSE(IsBackgroundModeSuspended());
 961 }
 962
 963 // Check that closing all browsers with no browser windows open suspends
 964 // background mode but does not cause Chrome to quit.
 965 IN_PROC_BROWSER_TEST_P(BrowserCloseManagerWithBackgroundModeBrowserTest,
 966                        CloseAllBrowsersWithNoOpenBrowsersWithBackgroundMode) {
 967   RepeatedNotificationObserver close_observer(
 968       chrome::NOTIFICATION_BROWSER_CLOSED, 1);
 969   EXPECT_FALSE(IsBackgroundModeSuspended());
 970   chrome::IncrementKeepAliveCount();
 971   browser()->window()->Close();
 972   close_observer.Wait();
 973   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 974   EXPECT_TRUE(chrome::BrowserIterator().done());
 975   EXPECT_FALSE(IsBackgroundModeSuspended());
 976
 977   chrome::CloseAllBrowsers();
 978   EXPECT_FALSE(browser_shutdown::IsTryingToQuit());
 979   EXPECT_TRUE(chrome::BrowserIterator().done());
 980   EXPECT_TRUE(IsBackgroundModeSuspended());
 981 }
 982
 983 INSTANTIATE_TEST_CASE_P(BrowserCloseManagerWithBackgroundModeBrowserTest,
 984                         BrowserCloseManagerWithBackgroundModeBrowserTest,
 985                         testing::Bool());