chrome/browser/ui/browser_close_browsertest.cc

   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 #include "base/command_line.h"
   6 #include "base/logging.h"
   7 #include "base/path_service.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/download/download_service.h"
  12 #include "chrome/browser/download/download_service_factory.h"
  13 #include "chrome/browser/download/download_test_file_activity_observer.h"
  14 #include "chrome/browser/net/url_request_mock_util.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/profiles/profile_manager.h"
  17 #include "chrome/browser/ui/browser.h"
  18 #include "chrome/browser/ui/browser_iterator.h"
  19 #include "chrome/browser/ui/browser_tabstrip.h"
  20 #include "chrome/browser/ui/browser_window.h"
  21 #include "chrome/browser/ui/host_desktop.h"
  22 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  23 #include "chrome/common/chrome_paths.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/common/url_constants.h"
  26 #include "chrome/test/base/in_process_browser_test.h"
  27 #include "chrome/test/base/ui_test_utils.h"
  28 #include "content/public/browser/download_item.h"
  29 #include "content/public/common/page_transition_types.h"
  30 #include "content/public/test/browser_test_utils.h"
  31 #include "content/public/test/download_test_observer.h"
  32 #include "content/test/net/url_request_slow_download_job.h"
  33
  34 using content::BrowserContext;
  35 using content::BrowserThread;
  36 using content::DownloadItem;
  37 using content::DownloadManager;
  38 using content::URLRequestSlowDownloadJob;
  39
  40 class BrowserCloseTest : public InProcessBrowserTest {
  41  public:
  42   // Structure defining test cases for DownloadsCloseCheck.
  43   struct DownloadsCloseCheckCase {
  44     std::string DebugString() const;
  45
  46     // Input
  47     struct {
  48       struct {
  49         int windows;
  50         int downloads;
  51       } regular;
  52       struct {
  53         int windows;
  54         int downloads;
  55       } incognito;
  56     } profile_a;
  57
  58     struct {
  59       struct {
  60         int windows;
  61         int downloads;
  62       } regular;
  63       struct {
  64         int windows;
  65         int downloads;
  66       } incognito;
  67     } profile_b;
  68
  69     // We always probe a window in profile A.
  70     enum { REGULAR = 0, INCOGNITO = 1 } window_to_probe;
  71
  72     // Output
  73     Browser::DownloadClosePreventionType type;
  74
  75     // Unchecked if type == DOWNLOAD_CLOSE_OK.
  76     int num_blocking;
  77   };
  78
  79  protected:
  80   virtual void SetUpOnMainThread() OVERRIDE {
  81     BrowserThread::PostTask(
  82         BrowserThread::IO, FROM_HERE,
  83         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
  84   }
  85
  86   // Create a second profile to work within multi-profile.
  87   Profile* CreateSecondProfile() {
  88     base::FilePath user_data_dir;
  89     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
  90
  91     if (!second_profile_data_dir_.CreateUniqueTempDirUnderPath(user_data_dir))
  92       return NULL;
  93
  94     Profile* second_profile =
  95         g_browser_process->profile_manager()->GetProfile(
  96             second_profile_data_dir_.path());
  97     if (!second_profile)
  98       return NULL;
  99
 100     bool result = second_profile_downloads_dir_.CreateUniqueTempDir();
 101     if (!result)
 102       return NULL;
 103     second_profile->GetPrefs()->SetFilePath(
 104         prefs::kDownloadDefaultDirectory,
 105         second_profile_downloads_dir_.path());
 106
 107     return second_profile;
 108   }
 109
 110   // Create |num_downloads| number of downloads that are stalled
 111   // (will quickly get to a place where the server won't
 112   // provide any more data) so that we can test closing the
 113   // browser with active downloads.
 114   void CreateStalledDownloads(Browser* browser, int num_downloads) {
 115     GURL url(URLRequestSlowDownloadJob::kKnownSizeUrl);
 116
 117     if (num_downloads == 0)
 118       return;
 119
 120     // Setup an observer waiting for the given number of downloads
 121     // to get to IN_PROGRESS.
 122     DownloadManager* download_manager =
 123         BrowserContext::GetDownloadManager(browser->profile());
 124     scoped_ptr<content::DownloadTestObserver> observer(
 125         new content::DownloadTestObserverInProgress(download_manager,
 126                                                     num_downloads));
 127
 128     // Set of that number of downloads.
 129     size_t count_downloads = num_downloads;
 130     while (num_downloads--)
 131       ui_test_utils::NavigateToURLWithDisposition(
 132           browser, url, NEW_BACKGROUND_TAB,
 133           ui_test_utils::BROWSER_TEST_NONE);
 134
 135     // Wait for them.
 136     observer->WaitForFinished();
 137     EXPECT_EQ(count_downloads,
 138               observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
 139   }
 140
 141   // All all downloads created in CreateStalledDownloads() to
 142   // complete, and block in this routine until they do complete.
 143   void CompleteAllDownloads(Browser* browser) {
 144     GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
 145     ui_test_utils::NavigateToURL(browser, finish_url);
 146
 147     // Go through and, for every single profile, wait until there are
 148     // no active downloads on that download manager.
 149     std::vector<Profile*> profiles(
 150         g_browser_process->profile_manager()->GetLoadedProfiles());
 151     for (std::vector<Profile*>::const_iterator pit = profiles.begin();
 152          pit != profiles.end(); ++pit) {
 153       DownloadService* download_service =
 154           DownloadServiceFactory::GetForBrowserContext(*pit);
 155       if (download_service->HasCreatedDownloadManager()) {
 156         DownloadManager *mgr = BrowserContext::GetDownloadManager(*pit);
 157         scoped_refptr<content::DownloadTestFlushObserver> observer(
 158             new content::DownloadTestFlushObserver(mgr));
 159         observer->WaitForFlush();
 160       }
 161       if ((*pit)->HasOffTheRecordProfile()) {
 162         DownloadService* incognito_download_service =
 163           DownloadServiceFactory::GetForBrowserContext(
 164               (*pit)->GetOffTheRecordProfile());
 165         if (incognito_download_service->HasCreatedDownloadManager()) {
 166           DownloadManager *mgr = BrowserContext::GetDownloadManager(
 167               (*pit)->GetOffTheRecordProfile());
 168           scoped_refptr<content::DownloadTestFlushObserver> observer(
 169               new content::DownloadTestFlushObserver(mgr));
 170           observer->WaitForFlush();
 171         }
 172       }
 173     }
 174   }
 175
 176   // Create a Browser (with associated window) on the specified profile.
 177   Browser* CreateBrowserOnProfile(Profile* profile,
 178                                   chrome::HostDesktopType host_desktop_type) {
 179     Browser* new_browser =
 180         new Browser(Browser::CreateParams(profile, host_desktop_type));
 181     chrome::AddSelectedTabWithURL(new_browser, GURL(content::kAboutBlankURL),
 182                                   content::PAGE_TRANSITION_AUTO_TOPLEVEL);
 183     content::WaitForLoadStop(
 184         new_browser->tab_strip_model()->GetActiveWebContents());
 185     new_browser->window()->Show();
 186     return new_browser;
 187   }
 188
 189   // Adjust the number of browsers and associated windows up or down
 190   // to |num_windows|.  This routine assumes that there is only a single
 191   // browser associated with the profile on entry.  |*base_browser| contains
 192   // this browser, and the profile is derived from that browser.  On output,
 193   // if |*base_browser| was destroyed (because |num_windows == 0|), NULL
 194   // is assigned to that memory location.
 195   bool AdjustBrowsersOnProfile(Browser** base_browser, int num_windows) {
 196     int num_downloads_blocking;
 197     if (num_windows == 0) {
 198       if (Browser::DOWNLOAD_CLOSE_OK !=
 199           (*base_browser)->OkToCloseWithInProgressDownloads(
 200               &num_downloads_blocking))
 201         return false;
 202       (*base_browser)->window()->Close();
 203       *base_browser = 0;
 204       return true;
 205     }
 206
 207     // num_windows > 0
 208     Profile* profile((*base_browser)->profile());
 209     chrome::HostDesktopType host_desktop_type =
 210         (*base_browser)->host_desktop_type();
 211     for (int w = 1; w < num_windows; ++w) {
 212       CreateBrowserOnProfile(profile, host_desktop_type);
 213     }
 214     return true;
 215   }
 216
 217   int TotalUnclosedBrowsers() {
 218     int count = 0;
 219     for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 220       if (!it->IsAttemptingToCloseBrowser())
 221         count++;
 222     }
 223     return count;
 224   }
 225
 226   // Note that this is invalid to call if TotalUnclosedBrowsers() == 0.
 227   Browser* FirstUnclosedBrowser() {
 228     for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 229       if (!it->IsAttemptingToCloseBrowser())
 230         return *it;
 231     }
 232     return NULL;
 233   }
 234
 235   bool SetupForDownloadCloseCheck() {
 236     first_profile_ = browser()->profile();
 237
 238     bool result = first_profile_downloads_dir_.CreateUniqueTempDir();
 239     EXPECT_TRUE(result);
 240     if (!result) return false;
 241     first_profile_->GetPrefs()->SetFilePath(
 242         prefs::kDownloadDefaultDirectory,
 243         first_profile_downloads_dir_.path());
 244
 245     second_profile_ = CreateSecondProfile();
 246     EXPECT_TRUE(second_profile_);
 247     if (!second_profile_) return false;
 248
 249     DownloadTestFileActivityObserver(first_profile_) .EnableFileChooser(false);
 250     DownloadTestFileActivityObserver(second_profile_).EnableFileChooser(false);
 251     return true;
 252   }
 253
 254   // Test a specific DownloadsCloseCheckCase.  Returns false if
 255   // an assertion has failed and the test should be aborted.
 256   bool ExecuteDownloadCloseCheckCase(size_t i) {
 257     const DownloadsCloseCheckCase& check_case(download_close_check_cases[i]);
 258
 259     // Test invariant: so that we don't actually try and close the browser,
 260     // we always enter the function with a single browser window open on the
 261     // main profile.  That means we need to exit the function the same way.
 262     // So we setup everything except for the |first_profile_| regular, and then
 263     // flip the bit on the main window.
 264     // Note that this means that browser() is unreliable in the context
 265     // of this function or its callers; we'll be killing that main window
 266     // and recreating it fairly frequently.
 267     int unclosed_browsers = TotalUnclosedBrowsers();
 268     EXPECT_EQ(1, unclosed_browsers);
 269     if (1 != unclosed_browsers)
 270       return false;
 271
 272     Browser* entry_browser = FirstUnclosedBrowser();
 273     EXPECT_EQ(first_profile_, entry_browser->profile())
 274         << "Case" << i
 275         << ": " << check_case.DebugString();
 276     if (first_profile_ != entry_browser->profile())
 277       return false;
 278     int total_download_count = DownloadService::DownloadCountAllProfiles();
 279     EXPECT_EQ(0, total_download_count)
 280         << "Case " << i
 281         << ": " << check_case.DebugString();
 282     if (0 != total_download_count)
 283       return false;
 284
 285     Profile* first_profile_incognito = first_profile_->GetOffTheRecordProfile();
 286     Profile* second_profile_incognito =
 287         second_profile_->GetOffTheRecordProfile();
 288     DownloadTestFileActivityObserver(first_profile_incognito)
 289         .EnableFileChooser(false);
 290     DownloadTestFileActivityObserver(second_profile_incognito)
 291         .EnableFileChooser(false);
 292
 293     // For simplicty of coding, we create a window on each profile so that
 294     // we can easily create downloads, then we destroy or create windows
 295     // as necessary.
 296     chrome::HostDesktopType host_desktop_type =
 297         entry_browser->host_desktop_type();
 298     Browser* browser_a_regular(CreateBrowserOnProfile(first_profile_,
 299                                                       host_desktop_type));
 300     Browser* browser_a_incognito(
 301         CreateBrowserOnProfile(first_profile_incognito, host_desktop_type));
 302     Browser* browser_b_regular(CreateBrowserOnProfile(second_profile_,
 303                                                       host_desktop_type));
 304     Browser* browser_b_incognito(
 305         CreateBrowserOnProfile(second_profile_incognito, host_desktop_type));
 306
 307     // Kill our entry browser.
 308     entry_browser->window()->Close();
 309     entry_browser = NULL;
 310
 311     // Create all downloads needed.
 312     CreateStalledDownloads(
 313         browser_a_regular, check_case.profile_a.regular.downloads);
 314     CreateStalledDownloads(
 315         browser_a_incognito, check_case.profile_a.incognito.downloads);
 316     CreateStalledDownloads(
 317         browser_b_regular, check_case.profile_b.regular.downloads);
 318     CreateStalledDownloads(
 319         browser_b_incognito, check_case.profile_b.incognito.downloads);
 320
 321     // Adjust the windows
 322     Browser** browsers[] = {
 323       &browser_a_regular, &browser_a_incognito,
 324       &browser_b_regular, &browser_b_incognito
 325     };
 326     int window_counts[] = {
 327       check_case.profile_a.regular.windows,
 328       check_case.profile_a.incognito.windows,
 329       check_case.profile_b.regular.windows,
 330       check_case.profile_b.incognito.windows,
 331     };
 332     for (size_t j = 0; j < arraysize(browsers); ++j) {
 333       bool result = AdjustBrowsersOnProfile(browsers[j], window_counts[j]);
 334       EXPECT_TRUE(result);
 335       if (!result)
 336         return false;
 337     }
 338     content::RunAllPendingInMessageLoop();
 339
 340     // All that work, for this one little test.
 341     EXPECT_TRUE((check_case.window_to_probe ==
 342                  DownloadsCloseCheckCase::REGULAR) ||
 343                 (check_case.window_to_probe ==
 344                  DownloadsCloseCheckCase::INCOGNITO));
 345     if (!((check_case.window_to_probe ==
 346            DownloadsCloseCheckCase::REGULAR) ||
 347           (check_case.window_to_probe ==
 348            DownloadsCloseCheckCase::INCOGNITO)))
 349       return false;
 350
 351     int num_downloads_blocking;
 352     Browser* browser_to_probe =
 353         (check_case.window_to_probe == DownloadsCloseCheckCase::REGULAR ?
 354          browser_a_regular :
 355          browser_a_incognito);
 356     Browser::DownloadClosePreventionType type =
 357         browser_to_probe->OkToCloseWithInProgressDownloads(
 358             &num_downloads_blocking);
 359     EXPECT_EQ(check_case.type, type) << "Case " << i
 360                                      << ": " << check_case.DebugString();
 361     if (type != Browser::DOWNLOAD_CLOSE_OK)
 362       EXPECT_EQ(check_case.num_blocking, num_downloads_blocking)
 363           << "Case " << i
 364           << ": " << check_case.DebugString();
 365
 366     // Release all the downloads.
 367     CompleteAllDownloads(browser_to_probe);
 368
 369     // Create a new main window and kill everything else.
 370     entry_browser = CreateBrowserOnProfile(first_profile_, host_desktop_type);
 371     for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 372       if ((*it) != entry_browser) {
 373         if (!it->window()) {
 374           ADD_FAILURE();
 375           return false;
 376         }
 377         it->window()->Close();
 378       }
 379     }
 380     content::RunAllPendingInMessageLoop();
 381
 382     return true;
 383   }
 384
 385   static const DownloadsCloseCheckCase download_close_check_cases[];
 386
 387   // DownloadCloseCheck variables.
 388   Profile* first_profile_;
 389   Profile* second_profile_;
 390
 391   base::ScopedTempDir first_profile_downloads_dir_;
 392   base::ScopedTempDir second_profile_data_dir_;
 393   base::ScopedTempDir second_profile_downloads_dir_;
 394 };
 395
 396 const BrowserCloseTest::DownloadsCloseCheckCase
 397 BrowserCloseTest::download_close_check_cases[] = {
 398   // Top level nesting is {profile_a, profile_b}
 399   // Second level nesting is {regular, incognito
 400   // Third level (inner) nesting is {windows, downloads}
 401
 402   // Last window (incognito) triggers browser close warning.
 403   {{{0, 0}, {1, 1}}, {{0, 0}, {0, 0}},
 404    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 405    Browser::DOWNLOAD_CLOSE_BROWSER_SHUTDOWN, 1},
 406
 407   // Last incognito window triggers incognito close warning.
 408   {{{1, 0}, {1, 1}}, {{0, 0}, {0, 0}},
 409    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 410    Browser::DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE, 1},
 411
 412   // Last incognito window with no downloads triggers no warning.
 413   {{{0, 0}, {1, 0}}, {{0, 0}, {0, 0}},
 414    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 415    Browser::DOWNLOAD_CLOSE_OK},
 416
 417   // Last incognito window with window+download on another incognito profile
 418   // triggers no warning.
 419   {{{0, 0}, {1, 0}}, {{0, 0}, {1, 1}},
 420    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 421    Browser::DOWNLOAD_CLOSE_OK},
 422
 423   // Non-last incognito window triggers no warning.
 424   {{{0, 0}, {2, 1}}, {{0, 0}, {0, 0}},
 425    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 426    Browser::DOWNLOAD_CLOSE_OK},
 427
 428   // Non-last regular window triggers no warning.
 429   {{{2, 1}, {0, 0}}, {{0, 0}, {0, 0}},
 430    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 431    Browser::DOWNLOAD_CLOSE_OK},
 432
 433   // Last regular window triggers browser close.
 434   {{{1, 1}, {0, 0}}, {{0, 0}, {0, 0}},
 435    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 436    Browser::DOWNLOAD_CLOSE_BROWSER_SHUTDOWN, 1},
 437
 438   // Last regular window triggers browser close for download on different
 439   // profile.
 440   {{{1, 0}, {0, 0}}, {{0, 1}, {0, 0}},
 441    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 442    Browser::DOWNLOAD_CLOSE_BROWSER_SHUTDOWN, 1},
 443
 444   // Last regular window triggers no warning if incognito
 445   // active (http://crbug.com/61257).
 446   {{{1, 0}, {1, 1}}, {{0, 0}, {0, 0}},
 447    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 448    Browser::DOWNLOAD_CLOSE_OK},
 449
 450   // Last regular window triggers no warning if other profile window active.
 451   {{{1, 1}, {0, 0}}, {{1, 0}, {0, 0}},
 452    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 453    Browser::DOWNLOAD_CLOSE_OK},
 454
 455   // Last regular window triggers no warning if other incognito window
 456   // active.
 457   {{{1, 0}, {0, 0}}, {{0, 0}, {1, 1}},
 458    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 459    Browser::DOWNLOAD_CLOSE_OK},
 460
 461   // Last regular window triggers no warning if incognito active.
 462   {{{1, 1}, {1, 0}}, {{0, 0}, {0, 0}},
 463    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 464    Browser::DOWNLOAD_CLOSE_OK},
 465
 466   // Test plural for regular.
 467   {{{1, 2}, {0, 0}}, {{0, 0}, {0, 0}},
 468    BrowserCloseTest::DownloadsCloseCheckCase::REGULAR,
 469    Browser::DOWNLOAD_CLOSE_BROWSER_SHUTDOWN, 2},
 470
 471   // Test plural for incognito.
 472   {{{1, 0}, {1, 2}}, {{0, 0}, {0, 0}},
 473    BrowserCloseTest::DownloadsCloseCheckCase::INCOGNITO,
 474    Browser::DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE, 2},
 475 };
 476
 477 std::string BrowserCloseTest::DownloadsCloseCheckCase::DebugString() const {
 478   std::string result;
 479   result += "{";
 480   if (profile_a.regular.windows || profile_a.regular.downloads)
 481     result += base::StringPrintf("Regular profile A: (%d w, %d d), ",
 482                                  profile_a.regular.windows,
 483                                  profile_a.regular.downloads);
 484   if (profile_a.incognito.windows || profile_a.incognito.downloads)
 485     result += base::StringPrintf("Incognito profile A: (%d w, %d d), ",
 486                                  profile_a.incognito.windows,
 487                                  profile_a.incognito.downloads);
 488   if (profile_b.regular.windows || profile_b.regular.downloads)
 489     result += base::StringPrintf("Regular profile B: (%d w, %d d), ",
 490                                  profile_b.regular.windows,
 491                                  profile_b.regular.downloads);
 492   if (profile_b.incognito.windows || profile_b.incognito.downloads)
 493     result += base::StringPrintf("Incognito profile B: (%d w, %d d), ",
 494                                  profile_b.incognito.windows,
 495                                  profile_b.incognito.downloads);
 496   result += (window_to_probe == REGULAR ? "Probe regular" :
 497              window_to_probe == INCOGNITO ? "Probe incognito" :
 498              "Probe unknown");
 499   result += "} -> ";
 500   if (type == Browser::DOWNLOAD_CLOSE_OK) {
 501     result += "No warning";
 502   } else {
 503     result += base::StringPrintf(
 504         "%s (%d downloads) warning",
 505         (type == Browser::DOWNLOAD_CLOSE_BROWSER_SHUTDOWN ? "Browser shutdown" :
 506          type == Browser::DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE ?
 507          "Incognito close" : "Unknown"),
 508         num_blocking);
 509   }
 510   return result;
 511 }
 512
 513 // The following test is split into six chunks to reduce the chance
 514 // of hitting the 25s timeout.
 515
 516 // This test is timing out very often under AddressSanitizer.
 517 // http://crbug.com/111914 and http://crbug.com/103371.
 518 // Crashing on Linux. http://crbug.com/100566
 519 // Timing out on XP debug. http://crbug.com/111914
 520 // Timing out, http://crbug.com/159449 .
 521
 522 #define MAYBE_DownloadsCloseCheck_0 DISABLED_DownloadsCloseCheck_0
 523 #define MAYBE_DownloadsCloseCheck_1 DISABLED_DownloadsCloseCheck_1
 524 #define MAYBE_DownloadsCloseCheck_2 DISABLED_DownloadsCloseCheck_2
 525 #define MAYBE_DownloadsCloseCheck_3 DISABLED_DownloadsCloseCheck_3
 526 #define MAYBE_DownloadsCloseCheck_4 DISABLED_DownloadsCloseCheck_4
 527 #define MAYBE_DownloadsCloseCheck_5 DISABLED_DownloadsCloseCheck_5
 528
 529 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_0) {
 530   ASSERT_TRUE(SetupForDownloadCloseCheck());
 531   for (size_t i = 0; i < arraysize(download_close_check_cases) / 6; ++i) {
 532     ExecuteDownloadCloseCheckCase(i);
 533   }
 534 }
 535
 536 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_1) {
 537   ASSERT_TRUE(SetupForDownloadCloseCheck());
 538   for (size_t i = arraysize(download_close_check_cases) / 6;
 539        i < 2 * arraysize(download_close_check_cases) / 6; ++i) {
 540     ExecuteDownloadCloseCheckCase(i);
 541   }
 542 }
 543
 544 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_2) {
 545   ASSERT_TRUE(SetupForDownloadCloseCheck());
 546   for (size_t i = 2 * arraysize(download_close_check_cases) / 6;
 547        i < 3 * arraysize(download_close_check_cases) / 6; ++i) {
 548     ExecuteDownloadCloseCheckCase(i);
 549   }
 550 }
 551
 552 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_3) {
 553   ASSERT_TRUE(SetupForDownloadCloseCheck());
 554   for (size_t i = 3 * arraysize(download_close_check_cases) / 6;
 555        i < 4 * arraysize(download_close_check_cases) / 6; ++i) {
 556     ExecuteDownloadCloseCheckCase(i);
 557   }
 558 }
 559
 560 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_4) {
 561   ASSERT_TRUE(SetupForDownloadCloseCheck());
 562   for (size_t i = 4 * arraysize(download_close_check_cases) / 6;
 563        i < 5 * arraysize(download_close_check_cases) / 6; ++i) {
 564     ExecuteDownloadCloseCheckCase(i);
 565   }
 566 }
 567
 568 IN_PROC_BROWSER_TEST_F(BrowserCloseTest, MAYBE_DownloadsCloseCheck_5) {
 569   ASSERT_TRUE(SetupForDownloadCloseCheck());
 570   for (size_t i = 5 * arraysize(download_close_check_cases) / 6;
 571        i < 6 * arraysize(download_close_check_cases) / 6; ++i) {
 572     ExecuteDownloadCloseCheckCase(i);
 573   }
 574 }