chrome/browser/download/download_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 <sstream>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/files/file.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/file_util.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/path_service.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/strings/string_split.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/stringprintf.h"
  22 #include "base/strings/utf_string_conversions.h"
  23 #include "base/sys_info.h"
  24 #include "base/test/test_file_util.h"
  25 #include "chrome/app/chrome_command_ids.h"
  26 #include "chrome/browser/browser_process.h"
  27 #include "chrome/browser/chrome_notification_types.h"
  28 #include "chrome/browser/download/chrome_download_manager_delegate.h"
  29 #include "chrome/browser/download/download_browsertest.h"
  30 #include "chrome/browser/download/download_crx_util.h"
  31 #include "chrome/browser/download/download_history.h"
  32 #include "chrome/browser/download/download_item_model.h"
  33 #include "chrome/browser/download/download_prefs.h"
  34 #include "chrome/browser/download/download_request_limiter.h"
  35 #include "chrome/browser/download/download_service.h"
  36 #include "chrome/browser/download/download_service_factory.h"
  37 #include "chrome/browser/download/download_shelf.h"
  38 #include "chrome/browser/download/download_target_determiner.h"
  39 #include "chrome/browser/download/download_test_file_activity_observer.h"
  40 #include "chrome/browser/download/notification/download_notification_manager.h"
  41 #include "chrome/browser/extensions/extension_install_prompt.h"
  42 #include "chrome/browser/extensions/extension_install_prompt_show_params.h"
  43 #include "chrome/browser/extensions/extension_service.h"
  44 #include "chrome/browser/history/history_service_factory.h"
  45 #include "chrome/browser/infobars/infobar_service.h"
  46 #include "chrome/browser/net/url_request_mock_util.h"
  47 #include "chrome/browser/profiles/profile.h"
  48 #include "chrome/browser/renderer_context_menu/render_view_context_menu_browsertest_util.h"
  49 #include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
  50 #include "chrome/browser/ui/browser.h"
  51 #include "chrome/browser/ui/browser_commands.h"
  52 #include "chrome/browser/ui/browser_finder.h"
  53 #include "chrome/browser/ui/browser_list.h"
  54 #include "chrome/browser/ui/browser_tabstrip.h"
  55 #include "chrome/browser/ui/browser_window.h"
  56 #include "chrome/browser/ui/chrome_pages.h"
  57 #include "chrome/browser/ui/host_desktop.h"
  58 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  59 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  60 #include "chrome/common/chrome_paths.h"
  61 #include "chrome/common/chrome_switches.h"
  62 #include "chrome/common/pref_names.h"
  63 #include "chrome/common/safe_browsing/csd.pb.h"
  64 #include "chrome/common/url_constants.h"
  65 #include "chrome/grit/generated_resources.h"
  66 #include "chrome/test/base/in_process_browser_test.h"
  67 #include "chrome/test/base/test_switches.h"
  68 #include "chrome/test/base/ui_test_utils.h"
  69 #include "components/history/content/browser/download_constants_utils.h"
  70 #include "components/history/core/browser/download_constants.h"
  71 #include "components/history/core/browser/download_row.h"
  72 #include "components/history/core/browser/history_service.h"
  73 #include "components/infobars/core/confirm_infobar_delegate.h"
  74 #include "components/infobars/core/infobar.h"
  75 #include "content/public/browser/download_interrupt_reasons.h"
  76 #include "content/public/browser/download_item.h"
  77 #include "content/public/browser/download_manager.h"
  78 #include "content/public/browser/download_save_info.h"
  79 #include "content/public/browser/download_url_parameters.h"
  80 #include "content/public/browser/notification_source.h"
  81 #include "content/public/browser/render_frame_host.h"
  82 #include "content/public/browser/render_view_host.h"
  83 #include "content/public/browser/resource_context.h"
  84 #include "content/public/browser/web_contents.h"
  85 #include "content/public/common/content_switches.h"
  86 #include "content/public/common/context_menu_params.h"
  87 #include "content/public/test/browser_test_utils.h"
  88 #include "content/public/test/download_test_observer.h"
  89 #include "content/public/test/test_file_error_injector.h"
  90 #include "content/public/test/test_navigation_observer.h"
  91 #include "extensions/browser/extension_system.h"
  92 #include "extensions/common/feature_switch.h"
  93 #include "net/base/filename_util.h"
  94 #include "net/test/embedded_test_server/embedded_test_server.h"
  95 #include "net/test/embedded_test_server/http_request.h"
  96 #include "net/test/embedded_test_server/http_response.h"
  97 #include "net/test/url_request/url_request_mock_http_job.h"
  98 #include "net/test/url_request/url_request_slow_download_job.h"
  99 #include "testing/gtest/include/gtest/gtest.h"
 100 #include "ui/base/l10n/l10n_util.h"
 101 #include "ui/base/page_transition_types.h"
 102
 103 #if defined(FULL_SAFE_BROWSING)
 104 #include "chrome/browser/safe_browsing/download_feedback_service.h"
 105 #include "chrome/browser/safe_browsing/download_protection_service.h"
 106 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 107 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 108 #endif
 109
 110 using content::BrowserContext;
 111 using content::BrowserThread;
 112 using content::DownloadItem;
 113 using content::DownloadManager;
 114 using content::DownloadUrlParameters;
 115 using content::WebContents;
 116 using extensions::Extension;
 117 using extensions::FeatureSwitch;
 118 using net::URLRequestMockHTTPJob;
 119
 120 namespace {
 121
 122 class CreatedObserver : public content::DownloadManager::Observer {
 123  public:
 124   explicit CreatedObserver(content::DownloadManager* manager)
 125       : manager_(manager),
 126         waiting_(false) {
 127     manager->AddObserver(this);
 128   }
 129   ~CreatedObserver() override {
 130     if (manager_)
 131       manager_->RemoveObserver(this);
 132   }
 133
 134   void Wait() {
 135     std::vector<DownloadItem*> downloads;
 136     manager_->GetAllDownloads(&downloads);
 137     if (!downloads.empty())
 138       return;
 139     waiting_ = true;
 140     content::RunMessageLoop();
 141     waiting_ = false;
 142   }
 143
 144  private:
 145   void OnDownloadCreated(content::DownloadManager* manager,
 146                          content::DownloadItem* item) override {
 147     DCHECK_EQ(manager_, manager);
 148     if (waiting_)
 149       base::MessageLoopForUI::current()->Quit();
 150   }
 151
 152   content::DownloadManager* manager_;
 153   bool waiting_;
 154
 155   DISALLOW_COPY_AND_ASSIGN(CreatedObserver);
 156 };
 157
 158 class PercentWaiter : public content::DownloadItem::Observer {
 159  public:
 160   explicit PercentWaiter(DownloadItem* item)
 161     : item_(item),
 162       waiting_(false),
 163       error_(false),
 164       prev_percent_(0) {
 165     item_->AddObserver(this);
 166   }
 167   ~PercentWaiter() override {
 168     if (item_)
 169       item_->RemoveObserver(this);
 170   }
 171
 172   bool WaitForFinished() {
 173     if (item_->GetState() == DownloadItem::COMPLETE) {
 174       return item_->PercentComplete() == 100;
 175     }
 176     waiting_ = true;
 177     content::RunMessageLoop();
 178     waiting_ = false;
 179     return !error_;
 180   }
 181
 182  private:
 183   void OnDownloadUpdated(content::DownloadItem* item) override {
 184     DCHECK_EQ(item_, item);
 185     if (!error_ &&
 186         ((prev_percent_ > item_->PercentComplete()) ||
 187          (item_->GetState() == DownloadItem::COMPLETE &&
 188           (item_->PercentComplete() != 100)))) {
 189       error_ = true;
 190       if (waiting_)
 191         base::MessageLoopForUI::current()->Quit();
 192     }
 193     if (item_->GetState() == DownloadItem::COMPLETE && waiting_)
 194       base::MessageLoopForUI::current()->Quit();
 195   }
 196
 197   void OnDownloadDestroyed(content::DownloadItem* item) override {
 198     DCHECK_EQ(item_, item);
 199     item_->RemoveObserver(this);
 200     item_ = NULL;
 201   }
 202
 203   content::DownloadItem* item_;
 204   bool waiting_;
 205   bool error_;
 206   int prev_percent_;
 207
 208   DISALLOW_COPY_AND_ASSIGN(PercentWaiter);
 209 };
 210
 211 // DownloadTestObserver subclass that observes one download until it transitions
 212 // from a non-resumable state to a resumable state a specified number of
 213 // times. Note that this observer can only observe a single download.
 214 class DownloadTestObserverResumable : public content::DownloadTestObserver {
 215  public:
 216   // Construct a new observer. |transition_count| is the number of times the
 217   // download should transition from a non-resumable state to a resumable state.
 218   DownloadTestObserverResumable(DownloadManager* download_manager,
 219                                 size_t transition_count)
 220       : DownloadTestObserver(download_manager, 1,
 221                              ON_DANGEROUS_DOWNLOAD_FAIL),
 222         was_previously_resumable_(false),
 223         transitions_left_(transition_count) {
 224     Init();
 225   }
 226   ~DownloadTestObserverResumable() override {}
 227
 228  private:
 229   bool IsDownloadInFinalState(DownloadItem* download) override {
 230     bool is_resumable_now = download->CanResume();
 231     if (!was_previously_resumable_ && is_resumable_now)
 232       --transitions_left_;
 233     was_previously_resumable_ = is_resumable_now;
 234     return transitions_left_ == 0;
 235   }
 236
 237   bool was_previously_resumable_;
 238   size_t transitions_left_;
 239
 240   DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverResumable);
 241 };
 242
 243 // IDs and paths of CRX files used in tests.
 244 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 245 const base::FilePath kGoodCrxPath(FILE_PATH_LITERAL("extensions/good.crx"));
 246
 247 const char kLargeThemeCrxId[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 248 const base::FilePath kLargeThemePath(
 249     FILE_PATH_LITERAL("extensions/theme2.crx"));
 250
 251 // Get History Information.
 252 class DownloadsHistoryDataCollector {
 253  public:
 254   explicit DownloadsHistoryDataCollector(Profile* profile)
 255       : profile_(profile), result_valid_(false) {}
 256
 257   bool WaitForDownloadInfo(
 258       scoped_ptr<std::vector<history::DownloadRow> >* results) {
 259     history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
 260         profile_, ServiceAccessType::EXPLICIT_ACCESS);
 261     DCHECK(hs);
 262     hs->QueryDownloads(
 263         base::Bind(&DownloadsHistoryDataCollector::OnQueryDownloadsComplete,
 264                    base::Unretained(this)));
 265
 266     content::RunMessageLoop();
 267     if (result_valid_) {
 268       *results = results_.Pass();
 269     }
 270     return result_valid_;
 271   }
 272
 273  private:
 274   void OnQueryDownloadsComplete(
 275       scoped_ptr<std::vector<history::DownloadRow> > entries) {
 276     result_valid_ = true;
 277     results_ = entries.Pass();
 278     base::MessageLoopForUI::current()->Quit();
 279   }
 280
 281   Profile* profile_;
 282   scoped_ptr<std::vector<history::DownloadRow> > results_;
 283   bool result_valid_;
 284
 285   DISALLOW_COPY_AND_ASSIGN(DownloadsHistoryDataCollector);
 286 };
 287
 288 // Mock that simulates a permissions dialog where the user denies
 289 // permission to install.  TODO(skerner): This could be shared with
 290 // extensions tests.  Find a common place for this class.
 291 class MockAbortExtensionInstallPrompt : public ExtensionInstallPrompt {
 292  public:
 293   MockAbortExtensionInstallPrompt() :
 294       ExtensionInstallPrompt(NULL) {
 295   }
 296
 297   // Simulate a user abort on an extension installation.
 298   void ConfirmInstall(Delegate* delegate,
 299                       const Extension* extension,
 300                       const ShowDialogCallback& show_dialog_callback) override {
 301     delegate->InstallUIAbort(true);
 302     base::MessageLoopForUI::current()->Quit();
 303   }
 304
 305   void OnInstallSuccess(const Extension* extension, SkBitmap* icon) override {}
 306   void OnInstallFailure(const extensions::CrxInstallError& error) override {}
 307 };
 308
 309 // Mock that simulates a permissions dialog where the user allows
 310 // installation.
 311 class MockAutoConfirmExtensionInstallPrompt : public ExtensionInstallPrompt {
 312  public:
 313   explicit MockAutoConfirmExtensionInstallPrompt(
 314       content::WebContents* web_contents)
 315       : ExtensionInstallPrompt(web_contents) {}
 316
 317   // Proceed without confirmation prompt.
 318   void ConfirmInstall(Delegate* delegate,
 319                       const Extension* extension,
 320                       const ShowDialogCallback& show_dialog_callback) override {
 321     delegate->InstallUIProceed();
 322   }
 323
 324   void OnInstallSuccess(const Extension* extension, SkBitmap* icon) override {}
 325   void OnInstallFailure(const extensions::CrxInstallError& error) override {}
 326 };
 327
 328 static DownloadManager* DownloadManagerForBrowser(Browser* browser) {
 329   return BrowserContext::GetDownloadManager(browser->profile());
 330 }
 331
 332 bool WasAutoOpened(DownloadItem* item) {
 333   return item->GetAutoOpened();
 334 }
 335
 336 // Called when a download starts. Marks the download as hidden.
 337 void SetHiddenDownloadCallback(DownloadItem* item,
 338                                content::DownloadInterruptReason reason) {
 339   DownloadItemModel(item).SetShouldShowInShelf(false);
 340 }
 341
 342 // Callback for HistoryObserver; used in DownloadHistoryCheck
 343 bool HasDataAndName(const history::DownloadRow& row) {
 344   return row.received_bytes > 0 && !row.target_path.empty();
 345 }
 346
 347 }  // namespace
 348
 349 DownloadTestObserverNotInProgress::DownloadTestObserverNotInProgress(
 350     DownloadManager* download_manager,
 351     size_t count)
 352     : DownloadTestObserver(download_manager, count, ON_DANGEROUS_DOWNLOAD_FAIL),
 353       started_observing_(false) {
 354   Init();
 355 }
 356
 357 DownloadTestObserverNotInProgress::~DownloadTestObserverNotInProgress() {}
 358
 359 void DownloadTestObserverNotInProgress::StartObserving() {
 360   started_observing_ = true;
 361 }
 362
 363 bool DownloadTestObserverNotInProgress::IsDownloadInFinalState(
 364     DownloadItem* download) {
 365   return started_observing_ &&
 366          download->GetState() != DownloadItem::IN_PROGRESS;
 367 }
 368
 369 class HistoryObserver : public DownloadHistory::Observer {
 370  public:
 371   typedef base::Callback<bool(const history::DownloadRow&)> FilterCallback;
 372
 373   explicit HistoryObserver(Profile* profile)
 374       : profile_(profile),
 375         waiting_(false),
 376         seen_stored_(false) {
 377     DownloadServiceFactory::GetForBrowserContext(profile_)->
 378       GetDownloadHistory()->AddObserver(this);
 379   }
 380
 381   ~HistoryObserver() override {
 382     DownloadService* service = DownloadServiceFactory::GetForBrowserContext(
 383         profile_);
 384     if (service && service->GetDownloadHistory())
 385       service->GetDownloadHistory()->RemoveObserver(this);
 386   }
 387
 388   void SetFilterCallback(const FilterCallback& callback) {
 389     callback_ = callback;
 390   }
 391
 392   void OnDownloadStored(content::DownloadItem* item,
 393                         const history::DownloadRow& info) override {
 394     if (!callback_.is_null() && (!callback_.Run(info)))
 395         return;
 396
 397     seen_stored_ = true;
 398     if (waiting_)
 399       base::MessageLoopForUI::current()->Quit();
 400   }
 401
 402   void OnDownloadHistoryDestroyed() override {
 403     DownloadServiceFactory::GetForBrowserContext(profile_)->
 404       GetDownloadHistory()->RemoveObserver(this);
 405   }
 406
 407   void WaitForStored() {
 408     if (seen_stored_)
 409       return;
 410     waiting_ = true;
 411     content::RunMessageLoop();
 412     waiting_ = false;
 413   }
 414
 415  private:
 416   Profile* profile_;
 417   bool waiting_;
 418   bool seen_stored_;
 419   FilterCallback callback_;
 420
 421   DISALLOW_COPY_AND_ASSIGN(HistoryObserver);
 422 };
 423
 424 class DownloadTest : public InProcessBrowserTest {
 425  public:
 426   // Choice of navigation or direct fetch.  Used by |DownloadFileCheckErrors()|.
 427   enum DownloadMethod {
 428     DOWNLOAD_NAVIGATE,
 429     DOWNLOAD_DIRECT
 430   };
 431
 432   // Information passed in to |DownloadFileCheckErrors()|.
 433   struct DownloadInfo {
 434     const char* url_name;  // URL for the download.
 435     DownloadMethod download_method;  // Navigation or Direct.
 436     // Download interrupt reason (NONE is OK).
 437     content::DownloadInterruptReason reason;
 438     bool show_download_item;  // True if the download item appears on the shelf.
 439     bool should_redirect_to_documents;  // True if we save it in "My Documents".
 440   };
 441
 442   struct FileErrorInjectInfo {
 443     DownloadInfo download_info;
 444     content::TestFileErrorInjector::FileErrorInfo error_info;
 445   };
 446
 447   DownloadTest() {}
 448
 449   void SetUpOnMainThread() override {
 450     BrowserThread::PostTask(
 451         BrowserThread::IO, FROM_HERE,
 452         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
 453     ASSERT_TRUE(InitialSetup());
 454   }
 455
 456   void TearDownOnMainThread() override {
 457     // Needs to be torn down on the main thread. file_activity_observer_ holds a
 458     // reference to the ChromeDownloadManagerDelegate which should be destroyed
 459     // on the UI thread.
 460     file_activity_observer_.reset();
 461   }
 462
 463   void SetUpCommandLine(base::CommandLine* command_line) override {
 464     command_line->AppendSwitch(switches::kDisablePluginsDiscovery);
 465   }
 466
 467   // Returning false indicates a failure of the setup, and should be asserted
 468   // in the caller.
 469   virtual bool InitialSetup() {
 470     bool have_test_dir = PathService::Get(chrome::DIR_TEST_DATA, &test_dir_);
 471     EXPECT_TRUE(have_test_dir);
 472     if (!have_test_dir)
 473       return false;
 474
 475     // Sanity check default values for window and tab count.
 476     int window_count = chrome::GetTotalBrowserCount();
 477     EXPECT_EQ(1, window_count);
 478     EXPECT_EQ(1, browser()->tab_strip_model()->count());
 479
 480     // Set up the temporary download folder.
 481     bool created_downloads_dir = CreateAndSetDownloadsDirectory(browser());
 482     EXPECT_TRUE(created_downloads_dir);
 483     if (!created_downloads_dir)
 484       return false;
 485     browser()->profile()->GetPrefs()->SetBoolean(
 486         prefs::kPromptForDownload, false);
 487
 488     DownloadManager* manager = DownloadManagerForBrowser(browser());
 489     DownloadPrefs::FromDownloadManager(manager)->ResetAutoOpen();
 490     manager->RemoveAllDownloads();
 491
 492     file_activity_observer_.reset(
 493         new DownloadTestFileActivityObserver(browser()->profile()));
 494
 495     return true;
 496   }
 497
 498  protected:
 499   enum SizeTestType {
 500     SIZE_TEST_TYPE_KNOWN,
 501     SIZE_TEST_TYPE_UNKNOWN,
 502   };
 503
 504   base::FilePath GetTestDataDirectory() {
 505     base::FilePath test_file_directory;
 506     PathService::Get(chrome::DIR_TEST_DATA, &test_file_directory);
 507     return test_file_directory;
 508   }
 509
 510   base::FilePath GetDownloadsDirectory() {
 511     return downloads_directory_.path();
 512   }
 513
 514   // Location of the file source (the place from which it is downloaded).
 515   base::FilePath OriginFile(base::FilePath file) {
 516     return test_dir_.Append(file);
 517   }
 518
 519   // Location of the file destination (place to which it is downloaded).
 520   base::FilePath DestinationFile(Browser* browser, base::FilePath file) {
 521     return GetDownloadDirectory(browser).Append(file.BaseName());
 522   }
 523
 524   // Must be called after browser creation.  Creates a temporary
 525   // directory for downloads that is auto-deleted on destruction.
 526   // Returning false indicates a failure of the function, and should be asserted
 527   // in the caller.
 528   bool CreateAndSetDownloadsDirectory(Browser* browser) {
 529     if (!browser)
 530       return false;
 531
 532     if (!downloads_directory_.CreateUniqueTempDir())
 533       return false;
 534
 535     browser->profile()->GetPrefs()->SetFilePath(
 536         prefs::kDownloadDefaultDirectory,
 537         downloads_directory_.path());
 538     browser->profile()->GetPrefs()->SetFilePath(
 539         prefs::kSaveFileDefaultDirectory,
 540         downloads_directory_.path());
 541
 542     return true;
 543   }
 544
 545   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
 546     return DownloadPrefs::FromDownloadManager(
 547         DownloadManagerForBrowser(browser));
 548   }
 549
 550   base::FilePath GetDownloadDirectory(Browser* browser) {
 551     return GetDownloadPrefs(browser)->DownloadPath();
 552   }
 553
 554   // Create a DownloadTestObserverTerminal that will wait for the
 555   // specified number of downloads to finish.
 556   content::DownloadTestObserver* CreateWaiter(
 557       Browser* browser, int num_downloads) {
 558     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
 559     return new content::DownloadTestObserverTerminal(
 560         download_manager, num_downloads,
 561         content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
 562   }
 563
 564   // Create a DownloadTestObserverInProgress that will wait for the
 565   // specified number of downloads to start.
 566   content::DownloadTestObserver* CreateInProgressWaiter(
 567       Browser* browser, int num_downloads) {
 568     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
 569     return new content::DownloadTestObserverInProgress(
 570         download_manager, num_downloads);
 571   }
 572
 573   // Create a DownloadTestObserverTerminal that will wait for the
 574   // specified number of downloads to finish, or for
 575   // a dangerous download warning to be shown.
 576   content::DownloadTestObserver* DangerousDownloadWaiter(
 577       Browser* browser,
 578       int num_downloads,
 579       content::DownloadTestObserver::DangerousDownloadAction
 580           dangerous_download_action) {
 581     DownloadManager* download_manager = DownloadManagerForBrowser(browser);
 582     return new content::DownloadTestObserverTerminal(
 583         download_manager, num_downloads, dangerous_download_action);
 584   }
 585
 586   void CheckDownloadStatesForBrowser(Browser* browser,
 587                                      size_t num,
 588                                      DownloadItem::DownloadState state) {
 589     std::vector<DownloadItem*> download_items;
 590     GetDownloads(browser, &download_items);
 591
 592     EXPECT_EQ(num, download_items.size());
 593
 594     for (size_t i = 0; i < download_items.size(); ++i) {
 595       EXPECT_EQ(state, download_items[i]->GetState()) << " Item " << i;
 596     }
 597   }
 598
 599   void CheckDownloadStates(size_t num, DownloadItem::DownloadState state) {
 600     CheckDownloadStatesForBrowser(browser(), num, state);
 601   }
 602
 603   bool VerifyNoDownloads() const {
 604     DownloadManager::DownloadVector items;
 605     GetDownloads(browser(), &items);
 606     return items.empty();
 607   }
 608
 609   // Download |url|, then wait for the download to finish.
 610   // |disposition| indicates where the navigation occurs (current tab, new
 611   // foreground tab, etc).
 612   // |browser_test_flags| indicate what to wait for, and is an OR of 0 or more
 613   // values in the ui_test_utils::BrowserTestWaitFlags enum.
 614   void DownloadAndWaitWithDisposition(Browser* browser,
 615                                       const GURL& url,
 616                                       WindowOpenDisposition disposition,
 617                                       int browser_test_flags) {
 618     // Setup notification, navigate, and block.
 619     scoped_ptr<content::DownloadTestObserver> observer(
 620         CreateWaiter(browser, 1));
 621     // This call will block until the condition specified by
 622     // |browser_test_flags|, but will not wait for the download to finish.
 623     ui_test_utils::NavigateToURLWithDisposition(browser,
 624                                                 url,
 625                                                 disposition,
 626                                                 browser_test_flags);
 627     // Waits for the download to complete.
 628     observer->WaitForFinished();
 629     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 630     // We don't expect a file chooser to be shown.
 631     EXPECT_FALSE(DidShowFileChooser());
 632   }
 633
 634   // Download a file in the current tab, then wait for the download to finish.
 635   void DownloadAndWait(Browser* browser,
 636                        const GURL& url) {
 637     DownloadAndWaitWithDisposition(
 638         browser,
 639         url,
 640         CURRENT_TAB,
 641         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 642   }
 643
 644   // Should only be called when the download is known to have finished
 645   // (in error or not).
 646   // Returning false indicates a failure of the function, and should be asserted
 647   // in the caller.
 648   bool CheckDownload(Browser* browser,
 649                      const base::FilePath& downloaded_filename,
 650                      const base::FilePath& origin_filename) {
 651     // Find the path to which the data will be downloaded.
 652     base::FilePath downloaded_file(
 653         DestinationFile(browser, downloaded_filename));
 654
 655     // Find the origin path (from which the data comes).
 656     base::FilePath origin_file(OriginFile(origin_filename));
 657     return CheckDownloadFullPaths(browser, downloaded_file, origin_file);
 658   }
 659
 660   // A version of CheckDownload that allows complete path specification.
 661   bool CheckDownloadFullPaths(Browser* browser,
 662                               const base::FilePath& downloaded_file,
 663                               const base::FilePath& origin_file) {
 664     bool origin_file_exists = base::PathExists(origin_file);
 665     EXPECT_TRUE(origin_file_exists) << origin_file.value();
 666     if (!origin_file_exists)
 667       return false;
 668
 669     // Confirm the downloaded data file exists.
 670     bool downloaded_file_exists = base::PathExists(downloaded_file);
 671     EXPECT_TRUE(downloaded_file_exists) << downloaded_file.value();
 672     if (!downloaded_file_exists)
 673       return false;
 674
 675     int64 origin_file_size = 0;
 676     EXPECT_TRUE(base::GetFileSize(origin_file, &origin_file_size));
 677     std::string original_file_contents;
 678     EXPECT_TRUE(base::ReadFileToString(origin_file, &original_file_contents));
 679     EXPECT_TRUE(
 680         VerifyFile(downloaded_file, original_file_contents, origin_file_size));
 681
 682     // Delete the downloaded copy of the file.
 683     bool downloaded_file_deleted = base::DieFileDie(downloaded_file, false);
 684     EXPECT_TRUE(downloaded_file_deleted);
 685     return downloaded_file_deleted;
 686   }
 687
 688   content::DownloadTestObserver* CreateInProgressDownloadObserver(
 689       size_t download_count) {
 690     DownloadManager* manager = DownloadManagerForBrowser(browser());
 691     return new content::DownloadTestObserverInProgress(
 692         manager, download_count);
 693   }
 694
 695   DownloadItem* CreateSlowTestDownload() {
 696     scoped_ptr<content::DownloadTestObserver> observer(
 697         CreateInProgressDownloadObserver(1));
 698     GURL slow_download_url(net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
 699     DownloadManager* manager = DownloadManagerForBrowser(browser());
 700
 701     EXPECT_EQ(0, manager->NonMaliciousInProgressCount());
 702     EXPECT_EQ(0, manager->InProgressCount());
 703     if (manager->InProgressCount() != 0)
 704       return NULL;
 705
 706     ui_test_utils::NavigateToURL(browser(), slow_download_url);
 707
 708     observer->WaitForFinished();
 709     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
 710
 711     DownloadManager::DownloadVector items;
 712     manager->GetAllDownloads(&items);
 713
 714     DownloadItem* new_item = NULL;
 715     for (DownloadManager::DownloadVector::iterator iter = items.begin();
 716          iter != items.end(); ++iter) {
 717       if ((*iter)->GetState() == DownloadItem::IN_PROGRESS) {
 718         // There should be only one IN_PROGRESS item.
 719         EXPECT_EQ(NULL, new_item);
 720         new_item = *iter;
 721       }
 722     }
 723     return new_item;
 724   }
 725
 726   bool RunSizeTest(Browser* browser,
 727                    SizeTestType type,
 728                    const std::string& partial_indication,
 729                    const std::string& total_indication) {
 730     EXPECT_TRUE(type == SIZE_TEST_TYPE_UNKNOWN || type == SIZE_TEST_TYPE_KNOWN);
 731     if (type != SIZE_TEST_TYPE_KNOWN && type != SIZE_TEST_TYPE_UNKNOWN)
 732       return false;
 733     GURL url(type == SIZE_TEST_TYPE_KNOWN ?
 734              net::URLRequestSlowDownloadJob::kKnownSizeUrl :
 735              net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
 736
 737     // TODO(ahendrickson) -- |expected_title_in_progress| and
 738     // |expected_title_finished| need to be checked.
 739     base::FilePath filename;
 740     net::FileURLToFilePath(url, &filename);
 741     base::string16 expected_title_in_progress(
 742         base::ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
 743     base::string16 expected_title_finished(
 744         base::ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
 745
 746     // Download a partial web page in a background tab and wait.
 747     // The mock system will not complete until it gets a special URL.
 748     scoped_ptr<content::DownloadTestObserver> observer(
 749         CreateWaiter(browser, 1));
 750     ui_test_utils::NavigateToURL(browser, url);
 751
 752     // TODO(ahendrickson): check download status text before downloading.
 753     // Need to:
 754     //  - Add a member function to the |DownloadShelf| interface class, that
 755     //    indicates how many members it has.
 756     //  - Add a member function to |DownloadShelf| to get the status text
 757     //    of a given member (for example, via the name in |DownloadItemView|'s
 758     //    GetAccessibleState() member function), by index.
 759     //  - Iterate over browser->window()->GetDownloadShelf()'s members
 760     //    to see if any match the status text we want.  Start with the last one.
 761
 762     // Allow the request to finish.  We do this by loading a second URL in a
 763     // separate tab.
 764     GURL finish_url(net::URLRequestSlowDownloadJob::kFinishDownloadUrl);
 765     ui_test_utils::NavigateToURLWithDisposition(
 766         browser,
 767         finish_url,
 768         NEW_FOREGROUND_TAB,
 769         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 770     observer->WaitForFinished();
 771     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 772     CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);
 773
 774     EXPECT_EQ(2, browser->tab_strip_model()->count());
 775
 776     // TODO(ahendrickson): check download status text after downloading.
 777
 778     base::FilePath basefilename(filename.BaseName());
 779     net::FileURLToFilePath(url, &filename);
 780     base::FilePath download_path =
 781         downloads_directory_.path().Append(basefilename);
 782
 783     bool downloaded_path_exists = base::PathExists(download_path);
 784     EXPECT_TRUE(downloaded_path_exists);
 785     if (!downloaded_path_exists)
 786       return false;
 787
 788     // Check the file contents.
 789     size_t file_size = net::URLRequestSlowDownloadJob::kFirstDownloadSize +
 790                        net::URLRequestSlowDownloadJob::kSecondDownloadSize;
 791     std::string expected_contents(file_size, '*');
 792     EXPECT_TRUE(VerifyFile(download_path, expected_contents, file_size));
 793
 794     // Delete the file we just downloaded.
 795     EXPECT_TRUE(base::DieFileDie(download_path, true));
 796     EXPECT_FALSE(base::PathExists(download_path));
 797
 798     return true;
 799   }
 800
 801   void GetDownloads(Browser* browser,
 802                     std::vector<DownloadItem*>* downloads) const {
 803     DCHECK(downloads);
 804     DownloadManager* manager = DownloadManagerForBrowser(browser);
 805     manager->GetAllDownloads(downloads);
 806   }
 807
 808   static void ExpectWindowCountAfterDownload(size_t expected) {
 809     EXPECT_EQ(expected, chrome::GetTotalBrowserCount());
 810   }
 811
 812   void EnableFileChooser(bool enable) {
 813     file_activity_observer_->EnableFileChooser(enable);
 814   }
 815
 816   bool DidShowFileChooser() {
 817     return file_activity_observer_->TestAndResetDidShowFileChooser();
 818   }
 819
 820   // Checks that |path| is has |file_size| bytes, and matches the |value|
 821   // string.
 822   bool VerifyFile(const base::FilePath& path,
 823                   const std::string& value,
 824                   const int64 file_size) {
 825     std::string file_contents;
 826
 827     bool read = base::ReadFileToString(path, &file_contents);
 828     EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
 829     if (!read)
 830       return false;  // Couldn't read the file.
 831
 832     // Note: we don't handle really large files (more than size_t can hold)
 833     // so we will fail in that case.
 834     size_t expected_size = static_cast<size_t>(file_size);
 835
 836     // Check the size.
 837     EXPECT_EQ(expected_size, file_contents.size());
 838     if (expected_size != file_contents.size())
 839       return false;
 840
 841     // Check the contents.
 842     EXPECT_EQ(value, file_contents);
 843     if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
 844       return false;
 845
 846     return true;
 847   }
 848
 849   // Attempts to download a file, based on information in |download_info|.
 850   // If a Select File dialog opens, will automatically choose the default.
 851   void DownloadFilesCheckErrorsSetup() {
 852     embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
 853     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 854     std::vector<DownloadItem*> download_items;
 855     GetDownloads(browser(), &download_items);
 856     ASSERT_TRUE(download_items.empty());
 857
 858     EnableFileChooser(true);
 859   }
 860
 861   void DownloadFilesCheckErrorsLoopBody(const DownloadInfo& download_info,
 862                                         size_t i) {
 863     SCOPED_TRACE(
 864         ::testing::Message()
 865         << " " << __FUNCTION__ << "()"
 866         << " index = " << i << " url = '" << download_info.url_name << "'"
 867         << " method = " << ((download_info.download_method == DOWNLOAD_DIRECT)
 868                                 ? "DOWNLOAD_DIRECT"
 869                                 : "DOWNLOAD_NAVIGATE")
 870         << " show_item = " << download_info.show_download_item << " reason = "
 871         << DownloadInterruptReasonToString(download_info.reason));
 872
 873     std::vector<DownloadItem*> download_items;
 874     GetDownloads(browser(), &download_items);
 875     size_t downloads_expected = download_items.size();
 876
 877     std::string server_path = "/downloads/";
 878     server_path += download_info.url_name;
 879     GURL url = embedded_test_server()->GetURL(server_path);
 880     ASSERT_TRUE(url.is_valid());
 881
 882     DownloadManager* download_manager = DownloadManagerForBrowser(browser());
 883     WebContents* web_contents =
 884         browser()->tab_strip_model()->GetActiveWebContents();
 885     ASSERT_TRUE(web_contents);
 886
 887     scoped_ptr<content::DownloadTestObserver> observer(
 888         new content::DownloadTestObserverTerminal(
 889             download_manager,
 890             1,
 891             content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
 892
 893     if (download_info.download_method == DOWNLOAD_DIRECT) {
 894       // Go directly to download.  Don't wait for navigation.
 895       scoped_refptr<content::DownloadTestItemCreationObserver>
 896           creation_observer(new content::DownloadTestItemCreationObserver);
 897
 898       scoped_ptr<DownloadUrlParameters> params(
 899           DownloadUrlParameters::FromWebContents(web_contents, url));
 900       params->set_callback(creation_observer->callback());
 901       DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
 902
 903       // Wait until the item is created, or we have determined that it
 904       // won't be.
 905       creation_observer->WaitForDownloadItemCreation();
 906
 907       ASSERT_EQ(download_info.show_download_item,
 908                 creation_observer->succeeded());
 909       if (download_info.show_download_item) {
 910         EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE,
 911                   creation_observer->interrupt_reason());
 912         EXPECT_NE(content::DownloadItem::kInvalidId,
 913                   creation_observer->download_id());
 914       } else {
 915         EXPECT_NE(content::DOWNLOAD_INTERRUPT_REASON_NONE,
 916                   creation_observer->interrupt_reason());
 917         EXPECT_EQ(content::DownloadItem::kInvalidId,
 918                   creation_observer->download_id());
 919       }
 920     } else {
 921       // Navigate to URL normally, wait until done.
 922       ui_test_utils::NavigateToURL(browser(), url);
 923     }
 924
 925     if (download_info.show_download_item) {
 926       downloads_expected++;
 927       observer->WaitForFinished();
 928       DownloadItem::DownloadState final_state =
 929           (download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
 930               DownloadItem::COMPLETE :
 931               DownloadItem::INTERRUPTED;
 932       EXPECT_EQ(1u, observer->NumDownloadsSeenInState(final_state));
 933     }
 934
 935     // Wait till the |DownloadFile|s are destroyed.
 936     content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
 937     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 938
 939     // Validate that the correct files were downloaded.
 940     download_items.clear();
 941     GetDownloads(browser(), &download_items);
 942     ASSERT_EQ(downloads_expected, download_items.size());
 943
 944     if (download_info.show_download_item) {
 945       // Find the last download item.
 946       DownloadItem* item = download_items[0];
 947       for (size_t d = 1; d < downloads_expected; ++d) {
 948         if (download_items[d]->GetStartTime() > item->GetStartTime())
 949           item = download_items[d];
 950       }
 951
 952       ASSERT_EQ(url, item->GetOriginalUrl());
 953       ASSERT_EQ(download_info.reason, item->GetLastReason());
 954
 955       if (item->GetState() == content::DownloadItem::COMPLETE) {
 956         // Clean up the file, in case it ended up in the My Documents folder.
 957         base::FilePath destination_folder = GetDownloadDirectory(browser());
 958         base::FilePath my_downloaded_file = item->GetTargetFilePath();
 959         EXPECT_TRUE(base::PathExists(my_downloaded_file));
 960         EXPECT_TRUE(base::DeleteFile(my_downloaded_file, false));
 961
 962         EXPECT_EQ(download_info.should_redirect_to_documents ?
 963                       std::string::npos :
 964                       0u,
 965                   my_downloaded_file.value().find(destination_folder.value()));
 966         if (download_info.should_redirect_to_documents) {
 967           // If it's not where we asked it to be, it should be in the
 968           // My Documents folder.
 969           base::FilePath my_docs_folder;
 970           EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DOCUMENTS,
 971                                        &my_docs_folder));
 972           EXPECT_EQ(0u,
 973                     my_downloaded_file.value().find(my_docs_folder.value()));
 974         }
 975       }
 976     }
 977   }
 978
 979   // Attempts to download a set of files, based on information in the
 980   // |download_info| array.  |count| is the number of files.
 981   // If a Select File dialog appears, it will choose the default and return
 982   // immediately.
 983   void DownloadFilesCheckErrors(size_t count, DownloadInfo* download_info) {
 984     DownloadFilesCheckErrorsSetup();
 985
 986     for (size_t i = 0; i < count; ++i) {
 987       DownloadFilesCheckErrorsLoopBody(download_info[i], i);
 988     }
 989   }
 990
 991   void DownloadInsertFilesErrorCheckErrorsLoopBody(
 992       scoped_refptr<content::TestFileErrorInjector> injector,
 993       const FileErrorInjectInfo& info,
 994       size_t i) {
 995     std::stringstream s;
 996     s << " " << __FUNCTION__ << "()"
 997       << " index = " << i
 998       << " url = " << info.error_info.url
 999       << " operation code = "
1000       << content::TestFileErrorInjector::DebugString(info.error_info.code)
1001       << " instance = " << info.error_info.operation_instance
1002       << " error = "
1003       << content::DownloadInterruptReasonToString(info.error_info.error);
1004
1005     injector->ClearErrors();
1006     injector->AddError(info.error_info);
1007
1008     injector->InjectErrors();
1009
1010     DownloadFilesCheckErrorsLoopBody(info.download_info, i);
1011
1012     size_t expected_successes = info.download_info.show_download_item ? 1u : 0u;
1013     EXPECT_EQ(expected_successes, injector->TotalFileCount()) << s.str();
1014     EXPECT_EQ(0u, injector->CurrentFileCount()) << s.str();
1015
1016     if (info.download_info.show_download_item)
1017       EXPECT_TRUE(injector->HadFile(GURL(info.error_info.url))) << s.str();
1018   }
1019
1020   void DownloadInsertFilesErrorCheckErrors(size_t count,
1021                                            FileErrorInjectInfo* info) {
1022     DownloadFilesCheckErrorsSetup();
1023
1024     // Set up file failures.
1025     scoped_refptr<content::TestFileErrorInjector> injector(
1026         content::TestFileErrorInjector::Create(
1027             DownloadManagerForBrowser(browser())));
1028
1029     for (size_t i = 0; i < count; ++i) {
1030       // Set up the full URL, for download file tracking.
1031       std::string server_path = "/downloads/";
1032       server_path += info[i].download_info.url_name;
1033       GURL url = embedded_test_server()->GetURL(server_path);
1034       info[i].error_info.url = url.spec();
1035
1036       DownloadInsertFilesErrorCheckErrorsLoopBody(injector, info[i], i);
1037     }
1038   }
1039
1040   // Attempts to download a file to a read-only folder, based on information
1041   // in |download_info|.
1042   void DownloadFilesToReadonlyFolder(size_t count,
1043                                      DownloadInfo* download_info) {
1044     DownloadFilesCheckErrorsSetup();
1045
1046     // Make the test folder unwritable.
1047     base::FilePath destination_folder = GetDownloadDirectory(browser());
1048     DVLOG(1) << " " << __FUNCTION__ << "()"
1049              << " folder = '" << destination_folder.value() << "'";
1050     base::FilePermissionRestorer permission_restorer(destination_folder);
1051     EXPECT_TRUE(base::MakeFileUnwritable(destination_folder));
1052
1053     for (size_t i = 0; i < count; ++i) {
1054       DownloadFilesCheckErrorsLoopBody(download_info[i], i);
1055     }
1056   }
1057
1058   // A mock install prompt that simulates the user allowing an install request.
1059   void SetAllowMockInstallPrompt() {
1060     download_crx_util::SetMockInstallPromptForTesting(
1061         scoped_ptr<ExtensionInstallPrompt>(
1062             new MockAutoConfirmExtensionInstallPrompt(
1063                 browser()->tab_strip_model()->GetActiveWebContents())));
1064   }
1065
1066   // This method:
1067   // * Starts a mock download by navigating browser() to a URLRequestMockHTTPJob
1068   //   mock URL.
1069   // * Injects |error| on the first write using |error_injector|.
1070   // * Waits for the download to be interrupted.
1071   // * Clears the errors on |error_injector|.
1072   // * Returns the resulting interrupted download.
1073   DownloadItem* StartMockDownloadAndInjectError(
1074       content::TestFileErrorInjector* error_injector,
1075       content::DownloadInterruptReason error) {
1076     base::FilePath file_path(FILE_PATH_LITERAL("download-test1.lib"));
1077     GURL url = URLRequestMockHTTPJob::GetMockUrl(file_path);
1078
1079     content::TestFileErrorInjector::FileErrorInfo error_info;
1080     error_info.url = url.spec();
1081     error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
1082     error_info.operation_instance = 0;
1083     error_info.error = error;
1084     error_injector->ClearErrors();
1085     error_injector->AddError(error_info);
1086     error_injector->InjectErrors();
1087
1088     scoped_ptr<content::DownloadTestObserver> observer(
1089         new DownloadTestObserverResumable(
1090             DownloadManagerForBrowser(browser()), 1));
1091     ui_test_utils::NavigateToURL(browser(), url);
1092     observer->WaitForFinished();
1093
1094     content::DownloadManager::DownloadVector downloads;
1095     DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
1096     EXPECT_EQ(1u, downloads.size());
1097
1098     if (downloads.size() != 1)
1099       return NULL;
1100
1101     error_injector->ClearErrors();
1102     error_injector->InjectErrors();
1103     DownloadItem* download = downloads[0];
1104     EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
1105     EXPECT_EQ(error, download->GetLastReason());
1106     return download;
1107   }
1108
1109  private:
1110   static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
1111     if (net::URLRequestSlowDownloadJob::NumberOutstandingRequests())
1112       *result = false;
1113     BrowserThread::PostTask(
1114         BrowserThread::UI, FROM_HERE, base::MessageLoop::QuitClosure());
1115   }
1116
1117   // Location of the test data.
1118   base::FilePath test_dir_;
1119
1120   // Location of the downloads directory for these tests
1121   base::ScopedTempDir downloads_directory_;
1122
1123   scoped_ptr<DownloadTestFileActivityObserver> file_activity_observer_;
1124 };
1125
1126 // NOTES:
1127 //
1128 // Files for these tests are found in DIR_TEST_DATA (currently
1129 // "chrome\test\data\", see chrome_paths.cc).
1130 // Mock responses have extension .mock-http-headers appended to the file name.
1131
1132 // Download a file due to the associated MIME type.
1133 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeType) {
1134   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1135   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1136
1137   // Download the file and wait.  We do not expect the Select File dialog.
1138   DownloadAndWait(browser(), url);
1139
1140   // Check state.
1141   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1142   CheckDownload(browser(), file, file);
1143 }
1144
1145 #if defined(OS_WIN)
1146 // Download a file and confirm that the zone identifier (on windows)
1147 // is set to internet.
1148 IN_PROC_BROWSER_TEST_F(DownloadTest, CheckInternetZone) {
1149   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1150   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1151
1152   // Download the file and wait.  We do not expect the Select File dialog.
1153   DownloadAndWait(browser(), url);
1154
1155   // Check state.  Special file state must be checked before CheckDownload,
1156   // as CheckDownload will delete the output file.
1157   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1158   base::FilePath downloaded_file(DestinationFile(browser(), file));
1159   if (base::VolumeSupportsADS(downloaded_file))
1160     EXPECT_TRUE(base::HasInternetZoneIdentifier(downloaded_file));
1161   CheckDownload(browser(), file, file);
1162 }
1163 #endif
1164
1165 // Put up a Select File dialog when the file is downloaded, due to
1166 // downloads preferences settings.
1167 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeTypeSelect) {
1168   // Re-enable prompting.
1169   browser()->profile()->GetPrefs()->SetBoolean(
1170       prefs::kPromptForDownload, true);
1171   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1172   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1173
1174   EnableFileChooser(true);
1175
1176   // Download the file and wait.  We expect the Select File dialog to appear
1177   // due to the MIME type, but we still wait until the download completes.
1178   scoped_ptr<content::DownloadTestObserver> observer(
1179       new content::DownloadTestObserverTerminal(
1180           DownloadManagerForBrowser(browser()),
1181           1,
1182           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
1183   ui_test_utils::NavigateToURL(browser(), url);
1184   observer->WaitForFinished();
1185   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
1186   CheckDownloadStates(1, DownloadItem::COMPLETE);
1187   EXPECT_TRUE(DidShowFileChooser());
1188
1189   // Check state.
1190   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1191   CheckDownload(browser(), file, file);
1192 }
1193
1194 // Access a file with a viewable mime-type, verify that a download
1195 // did not initiate.
1196 IN_PROC_BROWSER_TEST_F(DownloadTest, NoDownload) {
1197   base::FilePath file(FILE_PATH_LITERAL("download-test2.html"));
1198   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1199   base::FilePath file_path(DestinationFile(browser(), file));
1200
1201   // Open a web page and wait.
1202   ui_test_utils::NavigateToURL(browser(), url);
1203
1204   // Check that we did not download the web page.
1205   EXPECT_FALSE(base::PathExists(file_path));
1206
1207   // Check state.
1208   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1209   EXPECT_TRUE(VerifyNoDownloads());
1210 }
1211
1212 // EmbeddedTestServer::HandleRequestCallback function that returns the relative
1213 // URL as the MIME type.
1214 // E.g.:
1215 //   C -> S: GET /foo/bar =>
1216 //   S -> C: HTTP/1.1 200 OK
1217 //           Content-Type: foo/bar
1218 //           ...
1219 static scoped_ptr<net::test_server::HttpResponse> RespondWithContentTypeHandler(
1220     const net::test_server::HttpRequest& request) {
1221   scoped_ptr<net::test_server::BasicHttpResponse> response(
1222       new net::test_server::BasicHttpResponse());
1223   response->set_content_type(request.relative_url.substr(1));
1224   response->set_code(net::HTTP_OK);
1225   response->set_content("ooogaboogaboogabooga");
1226   return response.Pass();
1227 }
1228
1229 IN_PROC_BROWSER_TEST_F(DownloadTest, MimeTypesToShowNotDownload) {
1230   embedded_test_server()->RegisterRequestHandler(
1231       base::Bind(&RespondWithContentTypeHandler));
1232   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
1233
1234   // These files should all be displayed in the browser.
1235   const char* mime_types[] = {
1236     // It is unclear whether to display text/css or download it.
1237     //   Firefox 3: Display
1238     //   Internet Explorer 7: Download
1239     //   Safari 3.2: Download
1240     // We choose to match Firefox due to the lot of complains
1241     // from the users if css files are downloaded:
1242     // http://code.google.com/p/chromium/issues/detail?id=7192
1243     "text/css",
1244     "text/javascript",
1245     "text/plain",
1246     "application/x-javascript",
1247     "text/html",
1248     "text/xml",
1249     "text/xsl",
1250     "application/xhtml+xml",
1251     "image/png",
1252     "image/gif",
1253     "image/jpeg",
1254     "image/bmp",
1255   };
1256   for (size_t i = 0; i < arraysize(mime_types); ++i) {
1257     const char* mime_type = mime_types[i];
1258     GURL url(
1259         embedded_test_server()->GetURL(std::string("/").append(mime_type)));
1260     ui_test_utils::NavigateToURL(browser(), url);
1261
1262     // Check state.
1263     EXPECT_EQ(1, browser()->tab_strip_model()->count());
1264     EXPECT_TRUE(VerifyNoDownloads());
1265   }
1266 }
1267
1268 // Verify that when the DownloadResourceThrottle cancels a download, the
1269 // download never makes it to the downloads system.
1270 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadResourceThrottleCancels) {
1271   // Navigate to a page with the same domain as the file to download.  We can't
1272   // navigate directly to the file we don't want to download because cross-site
1273   // navigations reset the TabDownloadState.
1274   base::FilePath same_site_path(FILE_PATH_LITERAL("download_script.html"));
1275   GURL same_site_url(URLRequestMockHTTPJob::GetMockUrl(same_site_path));
1276   ui_test_utils::NavigateToURL(browser(), same_site_url);
1277
1278   // Make sure the initial navigation didn't trigger a download.
1279   EXPECT_TRUE(VerifyNoDownloads());
1280
1281   // Disable downloads for the tab.
1282   WebContents* web_contents =
1283       browser()->tab_strip_model()->GetActiveWebContents();
1284   DownloadRequestLimiter::TabDownloadState* tab_download_state =
1285       g_browser_process->download_request_limiter()->GetDownloadState(
1286           web_contents, web_contents, true);
1287   ASSERT_TRUE(tab_download_state);
1288   tab_download_state->set_download_status(
1289       DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED);
1290
1291   // Try to start the download via Javascript and wait for the corresponding
1292   // load stop event.
1293   content::TestNavigationObserver observer(web_contents);
1294   bool download_assempted;
1295   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
1296       browser()->tab_strip_model()->GetActiveWebContents(),
1297       "window.domAutomationController.send(startDownload());",
1298       &download_assempted));
1299   ASSERT_TRUE(download_assempted);
1300   observer.Wait();
1301
1302   // Check that we did not download the file.
1303   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1304   base::FilePath file_path(DestinationFile(browser(), file));
1305   EXPECT_FALSE(base::PathExists(file_path));
1306
1307   // Check state.
1308   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1309
1310   // Verify that there's no pending download.  The resource throttle
1311   // should have deleted it before it created a download item, so it
1312   // shouldn't be available as a cancelled download either.
1313   EXPECT_TRUE(VerifyNoDownloads());
1314 }
1315
1316 // Download a 0-size file with a content-disposition header, verify that the
1317 // download tab opened and the file exists as the filename specified in the
1318 // header.  This also ensures we properly handle empty file downloads.
1319 IN_PROC_BROWSER_TEST_F(DownloadTest, ContentDisposition) {
1320   base::FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
1321   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1322   base::FilePath download_file(
1323       FILE_PATH_LITERAL("download-test3-attachment.gif"));
1324
1325   // Download a file and wait.
1326   DownloadAndWait(browser(), url);
1327
1328   CheckDownload(browser(), download_file, file);
1329
1330   // Check state.
1331   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1332 }
1333
1334 // UnknownSize and KnownSize are tests which depend on
1335 // URLRequestSlowDownloadJob to serve content in a certain way. Data will be
1336 // sent in two chunks where the first chunk is 35K and the second chunk is 10K.
1337 // The test will first attempt to download a file; but the server will "pause"
1338 // in the middle until the server receives a second request for
1339 // "download-finish".  At that time, the download will finish.
1340 // These tests don't currently test much due to holes in |RunSizeTest()|.  See
1341 // comments in that routine for details.
1342 IN_PROC_BROWSER_TEST_F(DownloadTest, UnknownSize) {
1343   ASSERT_TRUE(RunSizeTest(browser(), SIZE_TEST_TYPE_UNKNOWN,
1344                           "32.0 KB - ", "100% - "));
1345 }
1346
1347 IN_PROC_BROWSER_TEST_F(DownloadTest, KnownSize) {
1348   ASSERT_TRUE(RunSizeTest(browser(), SIZE_TEST_TYPE_KNOWN,
1349                           "71% - ", "100% - "));
1350 }
1351
1352 // Test that when downloading an item in Incognito mode, we don't crash when
1353 // closing the last Incognito window (http://crbug.com/13983).
1354 IN_PROC_BROWSER_TEST_F(DownloadTest, IncognitoDownload) {
1355   Browser* incognito = CreateIncognitoBrowser();
1356   ASSERT_TRUE(incognito);
1357   int window_count = chrome::GetTotalBrowserCount();
1358   EXPECT_EQ(2, window_count);
1359
1360   // Download a file in the Incognito window and wait.
1361   CreateAndSetDownloadsDirectory(incognito);
1362   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1363   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1364   // Since |incognito| is a separate browser, we have to set it up explicitly.
1365   incognito->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
1366                                                false);
1367   DownloadAndWait(incognito, url);
1368
1369   // We should still have 2 windows.
1370   ExpectWindowCountAfterDownload(2);
1371
1372 #if !defined(OS_MACOSX)
1373   // On Mac OS X, the UI window close is delayed until the outermost
1374   // message loop runs.  So it isn't possible to get a BROWSER_CLOSED
1375   // notification inside of a test.
1376   content::WindowedNotificationObserver signal(
1377       chrome::NOTIFICATION_BROWSER_CLOSED,
1378       content::Source<Browser>(incognito));
1379 #endif
1380
1381   // Close the Incognito window and don't crash.
1382   chrome::CloseWindow(incognito);
1383
1384 #if !defined(OS_MACOSX)
1385   signal.Wait();
1386   ExpectWindowCountAfterDownload(1);
1387 #endif
1388
1389   CheckDownload(browser(), file, file);
1390 }
1391
1392 // Download one file on-record, then download the same file off-record, and test
1393 // that the filename is deduplicated.  The previous test tests for a specific
1394 // bug; this next test tests that filename deduplication happens independently
1395 // of DownloadManager/CDMD.
1396 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_IncognitoRegular) {
1397   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
1398
1399   // Read the origin file now so that we can compare the downloaded files to it
1400   // later.
1401   base::FilePath origin(OriginFile(base::FilePath(FILE_PATH_LITERAL(
1402       "downloads/a_zip_file.zip"))));
1403   ASSERT_TRUE(base::PathExists(origin));
1404   int64 origin_file_size = 0;
1405   EXPECT_TRUE(base::GetFileSize(origin, &origin_file_size));
1406   std::string original_contents;
1407   EXPECT_TRUE(base::ReadFileToString(origin, &original_contents));
1408
1409   std::vector<DownloadItem*> download_items;
1410   GetDownloads(browser(), &download_items);
1411   ASSERT_TRUE(download_items.empty());
1412
1413   // Download a file in the on-record browser and check that it was downloaded
1414   // correctly.
1415   DownloadAndWaitWithDisposition(browser(),
1416                                  url,
1417                                  CURRENT_TAB,
1418                                  ui_test_utils::BROWSER_TEST_NONE);
1419   GetDownloads(browser(), &download_items);
1420   ASSERT_EQ(1UL, download_items.size());
1421   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file.zip")),
1422             download_items[0]->GetTargetFilePath().BaseName());
1423   ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
1424   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
1425                          original_contents, origin_file_size));
1426
1427   // Setup an incognito window.
1428   Browser* incognito = CreateIncognitoBrowser();
1429   ASSERT_TRUE(incognito);
1430   int window_count = BrowserList::GetInstance(
1431       browser()->host_desktop_type())->size();
1432   EXPECT_EQ(2, window_count);
1433   incognito->profile()->GetPrefs()->SetFilePath(
1434       prefs::kDownloadDefaultDirectory,
1435       GetDownloadsDirectory());
1436   incognito->profile()->GetPrefs()->SetFilePath(
1437       prefs::kSaveFileDefaultDirectory,
1438       GetDownloadsDirectory());
1439
1440   download_items.clear();
1441   GetDownloads(incognito, &download_items);
1442   ASSERT_TRUE(download_items.empty());
1443
1444   // Download a file in the incognito browser and check that it was downloaded
1445   // correctly.
1446   DownloadAndWaitWithDisposition(incognito,
1447                                  url,
1448                                  CURRENT_TAB,
1449                                  ui_test_utils::BROWSER_TEST_NONE);
1450   GetDownloads(incognito, &download_items);
1451   ASSERT_EQ(1UL, download_items.size());
1452   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file (1).zip")),
1453             download_items[0]->GetTargetFilePath().BaseName());
1454   ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
1455   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
1456                          original_contents, origin_file_size));
1457 }
1458
1459 // Navigate to a new background page, but don't download.
1460 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
1461   // Because it's an HTML link, it should open a web page rather than
1462   // downloading.
1463   base::FilePath file1(FILE_PATH_LITERAL("download-test2.html"));
1464   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
1465
1466   // Open a web page and wait.
1467   ui_test_utils::NavigateToURLWithDisposition(
1468       browser(),
1469       url,
1470       NEW_BACKGROUND_TAB,
1471       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1472
1473   // We should have two tabs now.
1474   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1475   EXPECT_TRUE(VerifyNoDownloads());
1476 }
1477
1478 // Download a file in a background tab. Verify that the tab is closed
1479 // automatically.
1480 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab1) {
1481   // Download a file in a new background tab and wait.  The tab is automatically
1482   // closed when the download begins.
1483   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1484   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1485   DownloadAndWaitWithDisposition(
1486       browser(),
1487       url,
1488       NEW_BACKGROUND_TAB,
1489       0);
1490
1491   // When the download finishes, we should still have one tab.
1492   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1493
1494   CheckDownload(browser(), file, file);
1495 }
1496
1497 // Open a web page in the current tab, then download a file in another tab via
1498 // a Javascript call.
1499 // Verify that we have 2 tabs.
1500 //
1501 // The download_page1.html page contains an openNew() function that opens a
1502 // tab and then downloads download-test1.lib.
1503 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab2) {
1504   // Because it's an HTML link, it should open a web page rather than
1505   // downloading.
1506   base::FilePath file1(FILE_PATH_LITERAL("download_page1.html"));
1507   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
1508
1509   // Open a web page and wait.
1510   ui_test_utils::NavigateToURL(browser(), url);
1511
1512   // Download a file in a new tab and wait (via Javascript).
1513   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1514   DownloadAndWaitWithDisposition(browser(),
1515                                  GURL("javascript:openNew()"),
1516                                  CURRENT_TAB,
1517                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
1518
1519   // When the download finishes, we should have two tabs.
1520   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1521
1522   CheckDownload(browser(), file, file);
1523 }
1524
1525 // Open a web page in the current tab, open another tab via a Javascript call,
1526 // then download a file in the new tab.
1527 // Verify that we have 2 tabs.
1528 //
1529 // The download_page2.html page contains an openNew() function that opens a
1530 // tab.
1531 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab3) {
1532   // Because it's an HTML link, it should open a web page rather than
1533   // downloading.
1534   base::FilePath file1(FILE_PATH_LITERAL("download_page2.html"));
1535   GURL url1(URLRequestMockHTTPJob::GetMockUrl(file1));
1536
1537   // Open a web page and wait.
1538   ui_test_utils::NavigateToURL(browser(), url1);
1539
1540   // Open a new tab and wait.
1541   ui_test_utils::NavigateToURLWithDisposition(
1542       browser(),
1543       GURL("javascript:openNew()"),
1544       CURRENT_TAB,
1545       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
1546
1547   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1548
1549   // Download a file and wait.
1550   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1551   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1552   DownloadAndWaitWithDisposition(browser(),
1553                                  url,
1554                                  CURRENT_TAB,
1555                                  ui_test_utils::BROWSER_TEST_NONE);
1556
1557   // When the download finishes, we should have two tabs.
1558   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1559
1560   CheckDownload(browser(), file, file);
1561 }
1562
1563 // Open a web page in the current tab, then download a file via Javascript,
1564 // which will do so in a temporary tab. Verify that we have 1 tab.
1565 //
1566 // The download_page3.html page contains an openNew() function that opens a
1567 // tab with download-test1.lib in the URL.  When the URL is determined to be
1568 // a download, the tab is closed automatically.
1569 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab2) {
1570   // Because it's an HTML link, it should open a web page rather than
1571   // downloading.
1572   base::FilePath file1(FILE_PATH_LITERAL("download_page3.html"));
1573   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
1574
1575   // Open a web page and wait.
1576   ui_test_utils::NavigateToURL(browser(), url);
1577
1578   // Download a file and wait.
1579   // The file to download is "download-test1.lib".
1580   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1581   DownloadAndWaitWithDisposition(browser(),
1582                                  GURL("javascript:openNew()"),
1583                                  CURRENT_TAB,
1584                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
1585
1586   // When the download finishes, we should still have one tab.
1587   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1588
1589   CheckDownload(browser(), file, file);
1590 }
1591
1592 // Open a web page in the current tab, then call Javascript via a button to
1593 // download a file in a new tab, which is closed automatically when the
1594 // download begins.
1595 // Verify that we have 1 tab.
1596 //
1597 // The download_page4.html page contains a form with download-test1.lib as the
1598 // action.
1599 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab3) {
1600   // Because it's an HTML link, it should open a web page rather than
1601   // downloading.
1602   base::FilePath file1(FILE_PATH_LITERAL("download_page4.html"));
1603   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
1604
1605   // Open a web page and wait.
1606   ui_test_utils::NavigateToURL(browser(), url);
1607
1608   // Download a file in a new tab and wait.  The tab will automatically close
1609   // when the download begins.
1610   // The file to download is "download-test1.lib".
1611   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1612   DownloadAndWaitWithDisposition(
1613       browser(),
1614       GURL("javascript:document.getElementById('form').submit()"),
1615       CURRENT_TAB,
1616       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
1617
1618   // When the download finishes, we should still have one tab.
1619   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1620
1621   CheckDownload(browser(), file, file);
1622 }
1623
1624 // EmbeddedTestServer::HandleRequestCallback function that responds with a
1625 // redirect to the URL specified via a query string.
1626 // E.g.:
1627 //   C -> S: GET /dummy?http://example.com
1628 //   S -> C: HTTP/1.1 301 Moved Permanently
1629 //           Location: http://example.com
1630 //           ...
1631 static scoped_ptr<net::test_server::HttpResponse> ServerRedirectRequestHandler(
1632     const net::test_server::HttpRequest& request) {
1633   scoped_ptr<net::test_server::BasicHttpResponse> response(
1634       new net::test_server::BasicHttpResponse());
1635   size_t query_position = request.relative_url.find('?');
1636
1637   if (query_position == std::string::npos) {
1638     response->set_code(net::HTTP_PERMANENT_REDIRECT);
1639     response->AddCustomHeader("Location",
1640                               "https://request-had-no-query-string");
1641     response->set_content_type("text/plain");
1642     response->set_content("Error");
1643     return response.Pass();
1644   }
1645
1646   response->set_code(net::HTTP_PERMANENT_REDIRECT);
1647   response->AddCustomHeader("Location",
1648                             request.relative_url.substr(query_position + 1));
1649   response->set_content_type("text/plain");
1650   response->set_content("It's gone!");
1651   return response.Pass();
1652 }
1653
1654 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
1655   GURL download_url(net::URLRequestSlowDownloadJob::kKnownSizeUrl);
1656   base::FilePath file(net::GenerateFileName(download_url,
1657                                             std::string(),
1658                                             std::string(),
1659                                             std::string(),
1660                                             std::string(),
1661                                             std::string()));
1662
1663   // We use the server so that we can get a redirect and test url_chain
1664   // persistence.
1665   embedded_test_server()->RegisterRequestHandler(
1666       base::Bind(&ServerRedirectRequestHandler));
1667   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
1668   GURL redirect_url =
1669       embedded_test_server()->GetURL("/a?" + download_url.spec());
1670
1671   // Download the url and wait until the object has been stored.
1672   base::Time start(base::Time::Now());
1673   HistoryObserver observer(browser()->profile());
1674   observer.SetFilterCallback(base::Bind(&HasDataAndName));
1675   ui_test_utils::NavigateToURL(browser(), redirect_url);
1676   observer.WaitForStored();
1677
1678   // Get the details on what was stored into the history.
1679   scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
1680   ASSERT_TRUE(DownloadsHistoryDataCollector(
1681       browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
1682   ASSERT_EQ(1u, downloads_in_database->size());
1683
1684   // Confirm history storage is what you expect for a partially completed
1685   // slow download job.
1686   history::DownloadRow& row(downloads_in_database->at(0));
1687   EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
1688   EXPECT_EQ(DownloadTargetDeterminer::GetCrDownloadPath(
1689                 DestinationFile(browser(), file)),
1690             row.current_path);
1691   ASSERT_EQ(2u, row.url_chain.size());
1692   EXPECT_EQ(redirect_url.spec(), row.url_chain[0].spec());
1693   EXPECT_EQ(download_url.spec(), row.url_chain[1].spec());
1694   EXPECT_EQ(history::DownloadDangerType::NOT_DANGEROUS, row.danger_type);
1695   EXPECT_LE(start, row.start_time);
1696   EXPECT_EQ(net::URLRequestSlowDownloadJob::kFirstDownloadSize,
1697             row.received_bytes);
1698   EXPECT_EQ(net::URLRequestSlowDownloadJob::kFirstDownloadSize
1699             + net::URLRequestSlowDownloadJob::kSecondDownloadSize,
1700             row.total_bytes);
1701   EXPECT_EQ(history::DownloadState::IN_PROGRESS, row.state);
1702   EXPECT_FALSE(row.opened);
1703
1704   // Finish the download.  We're ok relying on the history to be flushed
1705   // at this point as our queries will be behind the history updates
1706   // invoked by completion.
1707   scoped_ptr<content::DownloadTestObserver> download_observer(
1708       CreateWaiter(browser(), 1));
1709   ui_test_utils::NavigateToURL(browser(),
1710       GURL(net::URLRequestSlowDownloadJob::kErrorDownloadUrl));
1711   download_observer->WaitForFinished();
1712   EXPECT_EQ(1u, download_observer->NumDownloadsSeenInState(
1713       DownloadItem::INTERRUPTED));
1714   base::Time end(base::Time::Now());
1715
1716   // Get what was stored in the history.
1717   ASSERT_TRUE(DownloadsHistoryDataCollector(
1718       browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
1719   ASSERT_EQ(1u, downloads_in_database->size());
1720
1721   // Confirm history storage is what you expect for an interrupted slow download
1722   // job. The download isn't continuable, so there's no intermediate file.
1723   history::DownloadRow& row1(downloads_in_database->at(0));
1724   EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
1725   EXPECT_TRUE(row1.current_path.empty());
1726   ASSERT_EQ(2u, row1.url_chain.size());
1727   EXPECT_EQ(redirect_url.spec(), row1.url_chain[0].spec());
1728   EXPECT_EQ(download_url.spec(), row1.url_chain[1].spec());
1729   EXPECT_EQ(history::DownloadDangerType::NOT_DANGEROUS, row1.danger_type);
1730   EXPECT_LE(start, row1.start_time);
1731   EXPECT_GE(end, row1.end_time);
1732   EXPECT_EQ(net::URLRequestSlowDownloadJob::kFirstDownloadSize,
1733             row1.received_bytes);
1734   EXPECT_EQ(net::URLRequestSlowDownloadJob::kFirstDownloadSize
1735             + net::URLRequestSlowDownloadJob::kSecondDownloadSize,
1736             row1.total_bytes);
1737   EXPECT_EQ(history::DownloadState::INTERRUPTED, row1.state);
1738   EXPECT_EQ(history::ToHistoryDownloadInterruptReason(
1739                 content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED),
1740             row1.interrupt_reason);
1741   EXPECT_FALSE(row1.opened);
1742 }
1743
1744 // Make sure a dangerous file shows up properly in the history.
1745 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryDangerCheck) {
1746 #if defined(OS_WIN) && defined(USE_ASH)
1747   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
1748   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
1749           switches::kAshBrowserTests))
1750     return;
1751 #endif
1752   // Disable SafeBrowsing so that danger will be determined by downloads system.
1753   browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
1754                                                false);
1755
1756   // .swf file so that it's dangerous on all platforms (including CrOS).
1757   base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
1758   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
1759
1760   // Download the url and wait until the object has been stored.
1761   scoped_ptr<content::DownloadTestObserver> download_observer(
1762       new content::DownloadTestObserverTerminal(
1763           DownloadManagerForBrowser(browser()), 1,
1764           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_IGNORE));
1765   base::Time start(base::Time::Now());
1766   HistoryObserver observer(browser()->profile());
1767   observer.SetFilterCallback(base::Bind(&HasDataAndName));
1768   ui_test_utils::NavigateToURL(browser(), download_url);
1769   observer.WaitForStored();
1770
1771   // Get the details on what was stored into the history.
1772   scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
1773   ASSERT_TRUE(DownloadsHistoryDataCollector(
1774       browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
1775   ASSERT_EQ(1u, downloads_in_database->size());
1776
1777   // Confirm history storage is what you expect for an unvalidated
1778   // dangerous file.
1779   history::DownloadRow& row(downloads_in_database->at(0));
1780   EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
1781   EXPECT_NE(DownloadTargetDeterminer::GetCrDownloadPath(
1782                 DestinationFile(browser(), file)),
1783             row.current_path);
1784   EXPECT_EQ(history::DownloadDangerType::DANGEROUS_FILE, row.danger_type);
1785   EXPECT_LE(start, row.start_time);
1786   EXPECT_EQ(history::DownloadState::IN_PROGRESS, row.state);
1787   EXPECT_FALSE(row.opened);
1788
1789   // Validate the download and wait for it to finish.
1790   std::vector<DownloadItem*> downloads;
1791   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
1792   ASSERT_EQ(1u, downloads.size());
1793   downloads[0]->ValidateDangerousDownload();
1794   download_observer->WaitForFinished();
1795
1796   // Get history details and confirm it's what you expect.
1797   downloads_in_database->clear();
1798   ASSERT_TRUE(DownloadsHistoryDataCollector(
1799       browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
1800   ASSERT_EQ(1u, downloads_in_database->size());
1801   history::DownloadRow& row1(downloads_in_database->at(0));
1802   EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
1803   EXPECT_EQ(DestinationFile(browser(), file), row1.current_path);
1804   EXPECT_EQ(history::DownloadDangerType::USER_VALIDATED, row1.danger_type);
1805   EXPECT_LE(start, row1.start_time);
1806   EXPECT_EQ(history::DownloadState::COMPLETE, row1.state);
1807   EXPECT_FALSE(row1.opened);
1808   // Not checking file size--not relevant to the point of the test, and
1809   // the file size is actually different on Windows and other platforms,
1810   // because for source control simplicity it's actually a text file, and
1811   // there are CRLF transformations for those files.
1812 }
1813
1814 // Test for crbug.com/14505. This tests that chrome:// urls are still functional
1815 // after download of a file while viewing another chrome://.
1816 IN_PROC_BROWSER_TEST_F(DownloadTest, ChromeURLAfterDownload) {
1817   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1818   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
1819   GURL flags_url(chrome::kChromeUIFlagsURL);
1820   GURL extensions_url(chrome::kChromeUIExtensionsFrameURL);
1821
1822   ui_test_utils::NavigateToURL(browser(), flags_url);
1823   DownloadAndWait(browser(), download_url);
1824   ui_test_utils::NavigateToURL(browser(), extensions_url);
1825   WebContents* contents =
1826       browser()->tab_strip_model()->GetActiveWebContents();
1827   ASSERT_TRUE(contents);
1828   bool webui_responded = false;
1829   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
1830       contents,
1831       "window.domAutomationController.send(window.webuiResponded);",
1832       &webui_responded));
1833   EXPECT_TRUE(webui_responded);
1834 }
1835
1836 // Test for crbug.com/12745. This tests that if a download is initiated from
1837 // a chrome:// page that has registered and onunload handler, the browser
1838 // will be able to close.
1839 IN_PROC_BROWSER_TEST_F(DownloadTest, BrowserCloseAfterDownload) {
1840   GURL downloads_url(chrome::kChromeUIFlagsURL);
1841   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
1842   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
1843
1844   ui_test_utils::NavigateToURL(browser(), downloads_url);
1845   WebContents* contents = browser()->tab_strip_model()->GetActiveWebContents();
1846   ASSERT_TRUE(contents);
1847   bool result = false;
1848   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
1849       contents,
1850       "window.onunload = function() { var do_nothing = 0; }; "
1851       "window.domAutomationController.send(true);",
1852       &result));
1853   EXPECT_TRUE(result);
1854
1855   DownloadAndWait(browser(), download_url);
1856
1857   content::WindowedNotificationObserver signal(
1858       chrome::NOTIFICATION_BROWSER_CLOSED,
1859       content::Source<Browser>(browser()));
1860   chrome::CloseWindow(browser());
1861   signal.Wait();
1862 }
1863
1864 // Test to make sure the 'download' attribute in anchor tag is respected.
1865 IN_PROC_BROWSER_TEST_F(DownloadTest, AnchorDownloadTag) {
1866   base::FilePath file(FILE_PATH_LITERAL("download-anchor-attrib.html"));
1867   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1868
1869   // Create a download, wait until it's complete, and confirm
1870   // we're in the expected state.
1871   scoped_ptr<content::DownloadTestObserver> observer(
1872       CreateWaiter(browser(), 1));
1873   ui_test_utils::NavigateToURL(browser(), url);
1874   observer->WaitForFinished();
1875   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
1876   CheckDownloadStates(1, DownloadItem::COMPLETE);
1877
1878   // Confirm the downloaded data exists.
1879   base::FilePath downloaded_file = GetDownloadDirectory(browser());
1880   downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
1881   EXPECT_TRUE(base::PathExists(downloaded_file));
1882 }
1883
1884 // Test to make sure auto-open works.
1885 IN_PROC_BROWSER_TEST_F(DownloadTest, AutoOpen) {
1886   base::FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
1887   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
1888
1889   ASSERT_TRUE(
1890       GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
1891
1892   DownloadAndWait(browser(), url);
1893
1894   // Find the download and confirm it was opened.
1895   std::vector<DownloadItem*> downloads;
1896   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
1897   ASSERT_EQ(1u, downloads.size());
1898   EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
1899
1900   // Unfortunately, this will block forever, causing a timeout, if
1901   // the download is never opened.
1902   content::DownloadUpdatedObserver(
1903       downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
1904   EXPECT_TRUE(downloads[0]->GetOpened());  // Confirm it anyway.
1905
1906   // As long as we're here, confirmed everything else is good.
1907   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1908   CheckDownload(browser(), file, file);
1909 }
1910
1911 // Download an extension.  Expect a dangerous download warning.
1912 // Deny the download.
1913 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxDenyInstall) {
1914   FeatureSwitch::ScopedOverride enable_easy_off_store_install(
1915       FeatureSwitch::easy_off_store_install(), true);
1916
1917   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
1918
1919   scoped_ptr<content::DownloadTestObserver> observer(
1920       DangerousDownloadWaiter(
1921           browser(), 1,
1922           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
1923   ui_test_utils::NavigateToURL(browser(), extension_url);
1924
1925   observer->WaitForFinished();
1926   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::CANCELLED));
1927   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
1928   EXPECT_TRUE(VerifyNoDownloads());
1929
1930   // Check that the CRX is not installed.
1931   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
1932       browser()->profile())->extension_service();
1933   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
1934 }
1935
1936 // Download an extension.  Expect a dangerous download warning.
1937 // Allow the download, deny the install.
1938 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallDenysPermissions) {
1939   FeatureSwitch::ScopedOverride enable_easy_off_store_install(
1940       FeatureSwitch::easy_off_store_install(), true);
1941
1942   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
1943
1944   // Install a mock install UI that simulates a user denying permission to
1945   // finish the install.
1946   download_crx_util::SetMockInstallPromptForTesting(
1947       scoped_ptr<ExtensionInstallPrompt>(
1948           new MockAbortExtensionInstallPrompt()));
1949
1950   scoped_ptr<content::DownloadTestObserver> observer(
1951       DangerousDownloadWaiter(
1952           browser(), 1,
1953           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
1954   ui_test_utils::NavigateToURL(browser(), extension_url);
1955
1956   observer->WaitForFinished();
1957   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
1958   CheckDownloadStates(1, DownloadItem::COMPLETE);
1959   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
1960
1961   content::DownloadManager::DownloadVector downloads;
1962   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
1963   ASSERT_EQ(1u, downloads.size());
1964   content::DownloadUpdatedObserver(
1965       downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
1966
1967   // Check that the extension was not installed.
1968   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
1969       browser()->profile())->extension_service();
1970   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
1971 }
1972
1973 // Download an extension.  Expect a dangerous download warning.
1974 // Allow the download, and the install.
1975 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallAcceptPermissions) {
1976   FeatureSwitch::ScopedOverride enable_easy_off_store_install(
1977       FeatureSwitch::easy_off_store_install(), true);
1978
1979   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
1980
1981   // Install a mock install UI that simulates a user allowing permission to
1982   // finish the install.
1983   SetAllowMockInstallPrompt();
1984
1985   scoped_ptr<content::DownloadTestObserver> observer(
1986       DangerousDownloadWaiter(
1987           browser(), 1,
1988           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
1989   ui_test_utils::NavigateToURL(browser(), extension_url);
1990
1991   observer->WaitForFinished();
1992   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
1993   CheckDownloadStates(1, DownloadItem::COMPLETE);
1994   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
1995
1996   // Download shelf should close from auto-open.
1997   content::DownloadManager::DownloadVector downloads;
1998   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
1999   ASSERT_EQ(1u, downloads.size());
2000   content::DownloadUpdatedObserver(
2001       downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
2002
2003   // Check that the extension was installed.
2004   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
2005       browser()->profile())->extension_service();
2006   ASSERT_TRUE(extension_service->GetExtensionById(kGoodCrxId, false));
2007 }
2008
2009 // Test installing a CRX that fails integrity checks.
2010 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInvalid) {
2011   base::FilePath file(FILE_PATH_LITERAL("extensions/bad_signature.crx"));
2012   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(file));
2013
2014   // Install a mock install UI that simulates a user allowing permission to
2015   // finish the install, and dismisses any error message.  We check that the
2016   // install failed below.
2017   SetAllowMockInstallPrompt();
2018
2019   scoped_ptr<content::DownloadTestObserver> observer(
2020       DangerousDownloadWaiter(
2021           browser(), 1,
2022           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
2023   ui_test_utils::NavigateToURL(browser(), extension_url);
2024
2025   observer->WaitForFinished();
2026   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2027   CheckDownloadStates(1, DownloadItem::COMPLETE);
2028
2029   // Check that the extension was not installed.
2030   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
2031       browser()->profile())->extension_service();
2032   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
2033 }
2034
2035 // Install a large (100kb) theme.
2036 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxLargeTheme) {
2037   FeatureSwitch::ScopedOverride enable_easy_off_store_install(
2038       FeatureSwitch::easy_off_store_install(), true);
2039
2040   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kLargeThemePath));
2041
2042   // Install a mock install UI that simulates a user allowing permission to
2043   // finish the install.
2044   SetAllowMockInstallPrompt();
2045
2046   scoped_ptr<content::DownloadTestObserver> observer(
2047       DangerousDownloadWaiter(
2048           browser(), 1,
2049           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
2050   ui_test_utils::NavigateToURL(browser(), extension_url);
2051
2052   observer->WaitForFinished();
2053   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2054   CheckDownloadStates(1, DownloadItem::COMPLETE);
2055   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
2056
2057   // Download shelf should close from auto-open.
2058   content::DownloadManager::DownloadVector downloads;
2059   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
2060   ASSERT_EQ(1u, downloads.size());
2061   content::DownloadUpdatedObserver(
2062       downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
2063
2064   // Check that the extension was installed.
2065   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
2066       browser()->profile())->extension_service();
2067   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
2068 }
2069
2070 // Tests for download initiation functions.
2071 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrl) {
2072   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
2073   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
2074
2075   // DownloadUrl always prompts; return acceptance of whatever it prompts.
2076   EnableFileChooser(true);
2077
2078   WebContents* web_contents =
2079       browser()->tab_strip_model()->GetActiveWebContents();
2080   ASSERT_TRUE(web_contents);
2081
2082   content::DownloadTestObserver* observer(
2083       new content::DownloadTestObserverTerminal(
2084           DownloadManagerForBrowser(browser()), 1,
2085           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2086   scoped_ptr<DownloadUrlParameters> params(
2087       DownloadUrlParameters::FromWebContents(web_contents, url));
2088   params->set_prompt(true);
2089   DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
2090   observer->WaitForFinished();
2091   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2092   CheckDownloadStates(1, DownloadItem::COMPLETE);
2093   EXPECT_TRUE(DidShowFileChooser());
2094
2095   // Check state.
2096   EXPECT_EQ(1, browser()->tab_strip_model()->count());
2097   ASSERT_TRUE(CheckDownload(browser(), file, file));
2098 }
2099
2100 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrlToPath) {
2101   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
2102   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
2103
2104   WebContents* web_contents =
2105       browser()->tab_strip_model()->GetActiveWebContents();
2106   ASSERT_TRUE(web_contents);
2107
2108   base::ScopedTempDir other_directory;
2109   ASSERT_TRUE(other_directory.CreateUniqueTempDir());
2110   base::FilePath target_file_full_path
2111       = other_directory.path().Append(file.BaseName());
2112   content::DownloadTestObserver* observer(CreateWaiter(browser(), 1));
2113   scoped_ptr<DownloadUrlParameters> params(
2114       DownloadUrlParameters::FromWebContents(web_contents, url));
2115   params->set_file_path(target_file_full_path);
2116   DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
2117   observer->WaitForFinished();
2118   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2119
2120   // Check state.
2121   EXPECT_EQ(1, browser()->tab_strip_model()->count());
2122   ASSERT_TRUE(CheckDownloadFullPaths(browser(),
2123                                      target_file_full_path,
2124                                      OriginFile(file)));
2125
2126   // Temporary are treated as auto-opened, and after that open won't be
2127   // visible; wait for auto-open and confirm not visible.
2128   std::vector<DownloadItem*> downloads;
2129   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
2130   ASSERT_EQ(1u, downloads.size());
2131   content::DownloadUpdatedObserver(
2132       downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
2133 }
2134
2135 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaGet) {
2136   embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
2137   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
2138   EnableFileChooser(true);
2139   std::vector<DownloadItem*> download_items;
2140   GetDownloads(browser(), &download_items);
2141   ASSERT_TRUE(download_items.empty());
2142
2143   // Navigate to a non-HTML resource. The resource also has
2144   // Cache-Control: no-cache set, which normally requires revalidation
2145   // each time.
2146   GURL url = embedded_test_server()->GetURL("/downloads/image.jpg");
2147   ASSERT_TRUE(url.is_valid());
2148   ui_test_utils::NavigateToURL(browser(), url);
2149
2150   // Stop the test server, and then try to save the page. If cache validation
2151   // is not bypassed then this will fail since the server is no longer
2152   // reachable.
2153   ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
2154
2155   scoped_ptr<content::DownloadTestObserver> waiter(
2156       new content::DownloadTestObserverTerminal(
2157           DownloadManagerForBrowser(browser()), 1,
2158           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2159   chrome::SavePage(browser());
2160   waiter->WaitForFinished();
2161   EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2162   CheckDownloadStates(1, DownloadItem::COMPLETE);
2163
2164   // Validate that the correct file was downloaded.
2165   GetDownloads(browser(), &download_items);
2166   EXPECT_TRUE(DidShowFileChooser());
2167   ASSERT_EQ(1u, download_items.size());
2168   ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
2169
2170   // Try to download it via a context menu.
2171   scoped_ptr<content::DownloadTestObserver> waiter_context_menu(
2172       new content::DownloadTestObserverTerminal(
2173           DownloadManagerForBrowser(browser()), 1,
2174           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2175   content::ContextMenuParams context_menu_params;
2176   context_menu_params.media_type = blink::WebContextMenuData::MediaTypeImage;
2177   context_menu_params.src_url = url;
2178   context_menu_params.page_url = url;
2179   TestRenderViewContextMenu menu(
2180       browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
2181       context_menu_params);
2182   menu.Init();
2183   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS, 0);
2184   waiter_context_menu->WaitForFinished();
2185   EXPECT_EQ(
2186       1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2187   CheckDownloadStates(2, DownloadItem::COMPLETE);
2188
2189   // Validate that the correct file was downloaded via the context menu.
2190   download_items.clear();
2191   GetDownloads(browser(), &download_items);
2192   EXPECT_TRUE(DidShowFileChooser());
2193   ASSERT_EQ(2u, download_items.size());
2194   ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
2195   ASSERT_EQ(url, download_items[1]->GetOriginalUrl());
2196 }
2197
2198 // A EmbeddedTestServer::HandleRequestCallback function that checks for requests
2199 // with query string ?allow-post-only, and returns a 404 response if the method
2200 // is not POST.
2201 static scoped_ptr<net::test_server::HttpResponse> FilterPostOnlyURLsHandler(
2202     const net::test_server::HttpRequest& request) {
2203   scoped_ptr<net::test_server::BasicHttpResponse> response;
2204   if (request.relative_url.find("?allow-post-only") != std::string::npos &&
2205       request.method != net::test_server::METHOD_POST) {
2206     response.reset(new net::test_server::BasicHttpResponse());
2207     response->set_code(net::HTTP_NOT_FOUND);
2208   }
2209   return response.Pass();
2210 }
2211
2212 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaPost) {
2213   embedded_test_server()->RegisterRequestHandler(
2214       base::Bind(&FilterPostOnlyURLsHandler));
2215   embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
2216   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
2217   EnableFileChooser(true);
2218   std::vector<DownloadItem*> download_items;
2219   GetDownloads(browser(), &download_items);
2220   ASSERT_TRUE(download_items.empty());
2221
2222   // Navigate to a form page.
2223   GURL form_url =
2224       embedded_test_server()->GetURL("/downloads/form_page_to_post.html");
2225   ASSERT_TRUE(form_url.is_valid());
2226   ui_test_utils::NavigateToURL(browser(), form_url);
2227
2228   // Submit the form. This will send a POST reqeuest, and the response is a
2229   // JPEG image. The resource also has Cache-Control: no-cache set,
2230   // which normally requires revalidation each time.
2231   GURL jpeg_url =
2232       embedded_test_server()->GetURL("/downloads/image.jpg?allow-post-only");
2233   ASSERT_TRUE(jpeg_url.is_valid());
2234   WebContents* web_contents =
2235       browser()->tab_strip_model()->GetActiveWebContents();
2236   ASSERT_TRUE(web_contents != NULL);
2237   content::WindowedNotificationObserver observer(
2238       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
2239       content::Source<content::NavigationController>(
2240           &web_contents->GetController()));
2241   content::RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
2242   ASSERT_TRUE(render_frame_host != NULL);
2243   render_frame_host->ExecuteJavaScriptForTests(
2244       base::ASCIIToUTF16("SubmitForm()"));
2245   observer.Wait();
2246   EXPECT_EQ(jpeg_url, web_contents->GetURL());
2247
2248   // Stop the test server, and then try to save the page. If cache validation
2249   // is not bypassed then this will fail since the server is no longer
2250   // reachable. This will also fail if it tries to be retrieved via "GET"
2251   // rather than "POST".
2252   ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
2253   scoped_ptr<content::DownloadTestObserver> waiter(
2254       new content::DownloadTestObserverTerminal(
2255           DownloadManagerForBrowser(browser()), 1,
2256           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2257   chrome::SavePage(browser());
2258   waiter->WaitForFinished();
2259   EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2260   CheckDownloadStates(1, DownloadItem::COMPLETE);
2261
2262   // Validate that the correct file was downloaded.
2263   GetDownloads(browser(), &download_items);
2264   EXPECT_TRUE(DidShowFileChooser());
2265   ASSERT_EQ(1u, download_items.size());
2266   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
2267
2268   // Try to download it via a context menu.
2269   scoped_ptr<content::DownloadTestObserver> waiter_context_menu(
2270       new content::DownloadTestObserverTerminal(
2271           DownloadManagerForBrowser(browser()), 1,
2272           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2273   content::ContextMenuParams context_menu_params;
2274   context_menu_params.media_type = blink::WebContextMenuData::MediaTypeImage;
2275   context_menu_params.src_url = jpeg_url;
2276   context_menu_params.page_url = jpeg_url;
2277   TestRenderViewContextMenu menu(web_contents->GetMainFrame(),
2278                                  context_menu_params);
2279   menu.Init();
2280   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS, 0);
2281   waiter_context_menu->WaitForFinished();
2282   EXPECT_EQ(
2283       1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2284   CheckDownloadStates(2, DownloadItem::COMPLETE);
2285
2286   // Validate that the correct file was downloaded via the context menu.
2287   download_items.clear();
2288   GetDownloads(browser(), &download_items);
2289   EXPECT_TRUE(DidShowFileChooser());
2290   ASSERT_EQ(2u, download_items.size());
2291   ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
2292   ASSERT_EQ(jpeg_url, download_items[1]->GetOriginalUrl());
2293 }
2294
2295 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsServer) {
2296   DownloadInfo download_info[] = {
2297     {  // Normal navigated download.
2298       "a_zip_file.zip",
2299       DOWNLOAD_NAVIGATE,
2300       content::DOWNLOAD_INTERRUPT_REASON_NONE,
2301       true,
2302       false
2303     },
2304     {  // Normal direct download.
2305       "a_zip_file.zip",
2306       DOWNLOAD_DIRECT,
2307       content::DOWNLOAD_INTERRUPT_REASON_NONE,
2308       true,
2309       false
2310     },
2311     {  // Direct download with 404 error.
2312       "there_IS_no_spoon.zip",
2313       DOWNLOAD_DIRECT,
2314       content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
2315       true,
2316       false
2317     },
2318     {  // Navigated download with 404 error.
2319       "there_IS_no_spoon.zip",
2320       DOWNLOAD_NAVIGATE,
2321       content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
2322       false,
2323       false
2324     },
2325     {  // Direct download with 400 error.
2326       "zip_file_not_found.zip",
2327       DOWNLOAD_DIRECT,
2328       content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
2329       true,
2330       false
2331     },
2332     {  // Navigated download with 400 error.
2333       "zip_file_not_found.zip",
2334       DOWNLOAD_NAVIGATE,
2335       content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
2336       false,
2337       false
2338     }
2339   };
2340
2341   DownloadFilesCheckErrors(arraysize(download_info), download_info);
2342 }
2343
2344 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsFile) {
2345   FileErrorInjectInfo error_info[] = {
2346     {  // Navigated download with injected "Disk full" error in Initialize().
2347       { "a_zip_file.zip",
2348         DOWNLOAD_NAVIGATE,
2349         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2350         1
2351       },
2352       {
2353         "",
2354         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2355         0,
2356         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2357       }
2358     },
2359     {  // Direct download with injected "Disk full" error in Initialize().
2360       { "a_zip_file.zip",
2361         DOWNLOAD_DIRECT,
2362         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2363         1
2364       },
2365       {
2366         "",
2367         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2368         0,
2369         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2370       }
2371     },
2372     {  // Navigated download with injected "Disk full" error in Write().
2373       { "a_zip_file.zip",
2374         DOWNLOAD_NAVIGATE,
2375         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2376         1
2377       },
2378       {
2379         "",
2380         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2381         0,
2382         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2383       }
2384     },
2385     {  // Direct download with injected "Disk full" error in Write().
2386       { "a_zip_file.zip",
2387         DOWNLOAD_DIRECT,
2388         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2389         1
2390       },
2391       {
2392         "",
2393         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2394         0,
2395         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2396       }
2397     },
2398     {  // Navigated download with injected "Failed" error in Initialize().
2399       { "a_zip_file.zip",
2400         DOWNLOAD_NAVIGATE,
2401         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2402         1
2403       },
2404       {
2405         "",
2406         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2407         0,
2408         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2409       }
2410     },
2411     {  // Direct download with injected "Failed" error in Initialize().
2412       { "a_zip_file.zip",
2413         DOWNLOAD_DIRECT,
2414         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2415         1
2416       },
2417       {
2418         "",
2419         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2420         0,
2421         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2422       }
2423     },
2424     {  // Navigated download with injected "Failed" error in Write().
2425       { "a_zip_file.zip",
2426         DOWNLOAD_NAVIGATE,
2427         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2428         1
2429       },
2430       {
2431         "",
2432         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2433         0,
2434         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2435       }
2436     },
2437     {  // Direct download with injected "Failed" error in Write().
2438       { "a_zip_file.zip",
2439         DOWNLOAD_DIRECT,
2440         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2441         1
2442       },
2443       {
2444         "",
2445         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2446         0,
2447         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2448       }
2449     },
2450     {  // Navigated download with injected "Name too long" error in
2451        // Initialize().
2452       { "a_zip_file.zip",
2453         DOWNLOAD_NAVIGATE,
2454         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
2455         1
2456       },
2457       {
2458         "",
2459         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2460         0,
2461         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
2462       }
2463     },
2464     {  // Direct download with injected "Name too long" error in Initialize().
2465       { "a_zip_file.zip",
2466         DOWNLOAD_DIRECT,
2467         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
2468         1
2469       },
2470       {
2471         "",
2472         content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
2473         0,
2474         content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
2475       }
2476     },
2477     {  // Navigated download with injected "Name too long" error in Write().
2478       { "a_zip_file.zip",
2479         DOWNLOAD_NAVIGATE,
2480         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2481         1
2482       },
2483       {
2484         "",
2485         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2486         0,
2487         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2488       }
2489     },
2490     {  // Direct download with injected "Name too long" error in Write().
2491       { "a_zip_file.zip",
2492         DOWNLOAD_DIRECT,
2493         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2494         1
2495       },
2496       {
2497         "",
2498         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2499         0,
2500         content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
2501       }
2502     },
2503     {  // Direct download with injected "Disk full" error in 2nd Write().
2504       { "06bESSE21Evolution.ppt",
2505         DOWNLOAD_DIRECT,
2506         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2507         1
2508       },
2509       {
2510         "",
2511         content::TestFileErrorInjector::FILE_OPERATION_WRITE,
2512         1,
2513         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
2514       }
2515     }
2516   };
2517
2518   DownloadInsertFilesErrorCheckErrors(arraysize(error_info), error_info);
2519 }
2520
2521 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorReadonlyFolder) {
2522   DownloadInfo download_info[] = {
2523     {
2524       "a_zip_file.zip",
2525       DOWNLOAD_DIRECT,
2526       // This passes because we switch to the My Documents folder.
2527       content::DOWNLOAD_INTERRUPT_REASON_NONE,
2528       true,
2529       true
2530     },
2531     {
2532       "a_zip_file.zip",
2533       DOWNLOAD_NAVIGATE,
2534       // This passes because we switch to the My Documents folder.
2535       content::DOWNLOAD_INTERRUPT_REASON_NONE,
2536       true,
2537       true
2538     }
2539   };
2540
2541   DownloadFilesToReadonlyFolder(arraysize(download_info), download_info);
2542 }
2543
2544 // Test that we show a dangerous downloads warning for a dangerous file
2545 // downloaded through a blob: URL.
2546 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadDangerousBlobData) {
2547 #if defined(OS_WIN)
2548   // On Windows, if SafeBrowsing is enabled, certain file types (.exe, .cab,
2549   // .msi) will be handled by the DownloadProtectionService. However, if the URL
2550   // is non-standard (e.g. blob:) then those files won't be handled by the
2551   // DPS. We should be showing the dangerous download warning for any file
2552   // considered dangerous and isn't handled by the DPS.
2553   const char kFilename[] = "foo.exe";
2554 #else
2555   const char kFilename[] = "foo.swf";
2556 #endif
2557
2558   std::string path("downloads/download-dangerous-blob.html?filename=");
2559   path += kFilename;
2560
2561   // Need to use http urls because the blob js doesn't work on file urls for
2562   // security reasons.
2563   GURL url = net::URLRequestMockHTTPJob::GetMockUrl(path);
2564
2565   content::DownloadTestObserver* observer(DangerousDownloadWaiter(
2566       browser(), 1,
2567       content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
2568   ui_test_utils::NavigateToURL(browser(), url);
2569   observer->WaitForFinished();
2570
2571   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2572   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
2573 }
2574
2575 // A EmbeddedTestServer::HandleRequestCallback function that echoes the Referrer
2576 // header as its contents. Only responds to the relative URL /echoreferrer
2577 // E.g.:
2578 //    C -> S: GET /foo
2579 //            Referer: http://example.com/foo
2580 //    S -> C: HTTP/1.1 200 OK
2581 //            Content-Type: text/plain
2582 //
2583 //            http://example.com/foo
2584 static scoped_ptr<net::test_server::HttpResponse> EchoReferrerRequestHandler(
2585     const net::test_server::HttpRequest& request) {
2586   const std::string kReferrerHeader = "Referer";  // SIC
2587
2588   if (request.relative_url.find("/echoreferrer") != 0)
2589     return scoped_ptr<net::test_server::HttpResponse>();
2590
2591   scoped_ptr<net::test_server::BasicHttpResponse> response(
2592       new net::test_server::BasicHttpResponse());
2593   response->set_code(net::HTTP_OK);
2594   response->set_content_type("text/plain");
2595   auto referrer_header = request.headers.find(kReferrerHeader);
2596   if (referrer_header != request.headers.end())
2597     response->set_content(referrer_header->second);
2598   return response.Pass();
2599 }
2600
2601 IN_PROC_BROWSER_TEST_F(DownloadTest, LoadURLExternallyReferrerPolicy) {
2602   embedded_test_server()->RegisterRequestHandler(
2603       base::Bind(&EchoReferrerRequestHandler));
2604   embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
2605   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
2606   EnableFileChooser(true);
2607   std::vector<DownloadItem*> download_items;
2608   GetDownloads(browser(), &download_items);
2609   ASSERT_TRUE(download_items.empty());
2610
2611   // Navigate to a page with a referrer policy and a link on it. The link points
2612   // to /echoreferrer.
2613   GURL url = embedded_test_server()->GetURL("/downloads/referrer_policy.html");
2614   ASSERT_TRUE(url.is_valid());
2615   ui_test_utils::NavigateToURL(browser(), url);
2616
2617   scoped_ptr<content::DownloadTestObserver> waiter(
2618       new content::DownloadTestObserverTerminal(
2619           DownloadManagerForBrowser(browser()), 1,
2620           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2621
2622   // Click on the link with the alt key pressed. This will download the link
2623   // target.
2624   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
2625   blink::WebMouseEvent mouse_event;
2626   mouse_event.type = blink::WebInputEvent::MouseDown;
2627   mouse_event.button = blink::WebMouseEvent::ButtonLeft;
2628   mouse_event.x = 15;
2629   mouse_event.y = 15;
2630   mouse_event.clickCount = 1;
2631   mouse_event.modifiers = blink::WebInputEvent::AltKey;
2632   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
2633   mouse_event.type = blink::WebInputEvent::MouseUp;
2634   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
2635
2636   waiter->WaitForFinished();
2637   EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2638   CheckDownloadStates(1, DownloadItem::COMPLETE);
2639
2640   // Validate that the correct file was downloaded.
2641   GetDownloads(browser(), &download_items);
2642   ASSERT_EQ(1u, download_items.size());
2643   ASSERT_EQ(embedded_test_server()->GetURL("/echoreferrer"),
2644             download_items[0]->GetOriginalUrl());
2645
2646   // Check that the file contains the expected referrer.
2647   base::FilePath file(download_items[0]->GetTargetFilePath());
2648   std::string expected_contents = embedded_test_server()->GetURL("/").spec();
2649   ASSERT_TRUE(VerifyFile(file, expected_contents, expected_contents.length()));
2650 }
2651
2652 // This test ensures that the Referer header is properly sanitized when
2653 // Save Link As is chosen from the context menu.
2654 IN_PROC_BROWSER_TEST_F(DownloadTest, SaveLinkAsReferrerPolicyOrigin) {
2655   embedded_test_server()->RegisterRequestHandler(
2656       base::Bind(&EchoReferrerRequestHandler));
2657   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
2658   EnableFileChooser(true);
2659   std::vector<DownloadItem*> download_items;
2660   GetDownloads(browser(), &download_items);
2661   ASSERT_TRUE(download_items.empty());
2662
2663   // Navigate to the initial page, where Save Link As will be executed.
2664   GURL url = net::URLRequestMockHTTPJob::GetMockHttpsUrl(
2665       std::string("referrer_policy/referrer-policy-start.html?policy=origin") +
2666       "&redirect=" + embedded_test_server()->GetURL("/echoreferrer").spec() +
2667       "&link=true&target=");
2668   ASSERT_TRUE(url.is_valid());
2669   ui_test_utils::NavigateToURL(browser(), url);
2670
2671   scoped_ptr<content::DownloadTestObserver> waiter(
2672       new content::DownloadTestObserverTerminal(
2673           DownloadManagerForBrowser(browser()), 1,
2674           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2675
2676   // Right-click on the link and choose Save Link As. This will download the
2677   // link target.
2678   ContextMenuNotificationObserver context_menu_observer(
2679       IDC_CONTENT_CONTEXT_SAVELINKAS);
2680
2681   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
2682   blink::WebMouseEvent mouse_event;
2683   mouse_event.type = blink::WebInputEvent::MouseDown;
2684   mouse_event.button = blink::WebMouseEvent::ButtonRight;
2685   mouse_event.x = 15;
2686   mouse_event.y = 15;
2687   mouse_event.clickCount = 1;
2688   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
2689   mouse_event.type = blink::WebInputEvent::MouseUp;
2690   tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
2691
2692   waiter->WaitForFinished();
2693   EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2694   CheckDownloadStates(1, DownloadItem::COMPLETE);
2695
2696   // Validate that the correct file was downloaded.
2697   GetDownloads(browser(), &download_items);
2698   EXPECT_EQ(1u, download_items.size());
2699   EXPECT_EQ(embedded_test_server()->GetURL("/echoreferrer"),
2700             download_items[0]->GetOriginalUrl());
2701
2702   // Check that the file contains the expected referrer.
2703   base::FilePath file(download_items[0]->GetTargetFilePath());
2704   std::string expected_contents =
2705       net::URLRequestMockHTTPJob::GetMockHttpsUrl(std::string()).spec();
2706   EXPECT_TRUE(VerifyFile(file, expected_contents, expected_contents.length()));
2707 }
2708
2709 // This test ensures that the Referer header is properly sanitized when
2710 // Save Image As is chosen from the context menu.
2711 IN_PROC_BROWSER_TEST_F(DownloadTest, SaveImageAsReferrerPolicyDefault) {
2712   embedded_test_server()->RegisterRequestHandler(
2713       base::Bind(&EchoReferrerRequestHandler));
2714   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
2715   EnableFileChooser(true);
2716   std::vector<DownloadItem*> download_items;
2717   GetDownloads(browser(), &download_items);
2718   ASSERT_TRUE(download_items.empty());
2719
2720   GURL url = net::URLRequestMockHTTPJob::GetMockHttpsUrl("title1.html");
2721   GURL img_url = embedded_test_server()->GetURL("/echoreferrer");
2722   ASSERT_TRUE(url.is_valid());
2723   ui_test_utils::NavigateToURL(browser(), url);
2724
2725   // Try to download an image via a context menu.
2726   scoped_ptr<content::DownloadTestObserver> waiter_context_menu(
2727       new content::DownloadTestObserverTerminal(
2728           DownloadManagerForBrowser(browser()), 1,
2729           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
2730   content::ContextMenuParams context_menu_params;
2731   context_menu_params.media_type = blink::WebContextMenuData::MediaTypeImage;
2732   context_menu_params.page_url = url;
2733   context_menu_params.src_url = img_url;
2734   TestRenderViewContextMenu menu(
2735       browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
2736       context_menu_params);
2737   menu.Init();
2738   menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS, 0);
2739   waiter_context_menu->WaitForFinished();
2740   EXPECT_EQ(
2741       1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
2742   CheckDownloadStates(1, DownloadItem::COMPLETE);
2743
2744   // Validate that the correct file was downloaded via the context menu.
2745   download_items.clear();
2746   GetDownloads(browser(), &download_items);
2747   EXPECT_TRUE(DidShowFileChooser());
2748   ASSERT_EQ(1u, download_items.size());
2749   ASSERT_EQ(img_url, download_items[0]->GetOriginalUrl());
2750   base::FilePath file = download_items[0]->GetTargetFilePath();
2751   // The contents of the file is the value of the Referer header if there was
2752   // one.
2753   EXPECT_TRUE(VerifyFile(file, "", 0));
2754 }
2755
2756 // On mobile, the multiple downloads UI is an infobar. On desktop, it's a
2757 // bubble. Test each as appropriate.
2758 #if defined(OS_ANDROID) || defined(OS_IOS)
2759 IN_PROC_BROWSER_TEST_F(DownloadTest, TestMultipleDownloadsInfobar) {
2760   // Ensure that infobars are being used instead of bubbles.
2761   base::CommandLine::ForCurrentProcess()->AppendSwitch(
2762       switches::kDisablePermissionsBubbles);
2763
2764   // Create a downloads observer.
2765   scoped_ptr<content::DownloadTestObserver> downloads_observer(
2766         CreateWaiter(browser(), 2));
2767
2768   // Create an infobar observer.
2769   content::WindowedNotificationObserver infobar_added_1(
2770         chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
2771         content::NotificationService::AllSources());
2772   ui_test_utils::NavigateToURL(browser(),
2773                                net::URLRequestMockHTTPJob::GetMockUrl(
2774                                    "downloads/download-a_zip_file.html"));
2775   infobar_added_1.Wait();
2776
2777   InfoBarService* infobar_service = InfoBarService::FromWebContents(
2778        browser()->tab_strip_model()->GetActiveWebContents());
2779   // Verify that there is only one infobar.
2780   ASSERT_EQ(1u, infobar_service->infobar_count());
2781
2782   // Get the infobar at index 0.
2783   infobars::InfoBar* infobar = infobar_service->infobar_at(0);
2784   ConfirmInfoBarDelegate* confirm_infobar =
2785       infobar->delegate()->AsConfirmInfoBarDelegate();
2786   ASSERT_TRUE(confirm_infobar != NULL);
2787
2788   // Verify multi download warning infobar message.
2789   EXPECT_EQ(confirm_infobar->GetMessageText(),
2790             l10n_util::GetStringUTF16(IDS_MULTI_DOWNLOAD_WARNING));
2791
2792   // Click on the "Allow" button to allow multiple downloads.
2793   if (confirm_infobar->Accept())
2794     infobar_service->RemoveInfoBar(infobar);
2795   // Verify that there are no more infobars.
2796   EXPECT_EQ(0u, infobar_service->infobar_count());
2797
2798   // Waits for the download to complete.
2799   downloads_observer->WaitForFinished();
2800   EXPECT_EQ(2u, downloads_observer->NumDownloadsSeenInState(
2801       DownloadItem::COMPLETE));
2802 }
2803 #else
2804 IN_PROC_BROWSER_TEST_F(DownloadTest, TestMultipleDownloadsBubble) {
2805 #if defined(OS_WIN) && defined(USE_ASH)
2806   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
2807   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
2808           switches::kAshBrowserTests))
2809     return;
2810 #endif
2811
2812   // Enable permision bubbles.
2813   base::CommandLine::ForCurrentProcess()->AppendSwitch(
2814       switches::kEnablePermissionsBubbles);
2815
2816   // Create a downloads observer.
2817   scoped_ptr<content::DownloadTestObserver> downloads_observer(
2818         CreateWaiter(browser(), 2));
2819
2820   PermissionBubbleManager* permission_bubble_manager =
2821       PermissionBubbleManager::FromWebContents(
2822           browser()->tab_strip_model()->GetActiveWebContents());
2823   permission_bubble_manager->DisplayPendingRequests();
2824   permission_bubble_manager->set_auto_response_for_test(
2825       PermissionBubbleManager::ACCEPT_ALL);
2826
2827   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
2828       browser(), net::URLRequestMockHTTPJob::GetMockUrl(
2829                      "downloads/download-a_zip_file.html"),
2830       1);
2831
2832   // Waits for the download to complete.
2833   downloads_observer->WaitForFinished();
2834   EXPECT_EQ(2u, downloads_observer->NumDownloadsSeenInState(
2835       DownloadItem::COMPLETE));
2836
2837   browser()->tab_strip_model()->GetActiveWebContents()->Close();
2838 }
2839 #endif
2840
2841 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Renaming) {
2842   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
2843   content::DownloadManager* manager = DownloadManagerForBrowser(browser());
2844   base::FilePath origin_file(OriginFile(base::FilePath(FILE_PATH_LITERAL(
2845       "downloads/a_zip_file.zip"))));
2846   ASSERT_TRUE(base::PathExists(origin_file));
2847   std::string origin_contents;
2848   ASSERT_TRUE(base::ReadFileToString(origin_file, &origin_contents));
2849
2850   // Download the same url several times and expect that all downloaded files
2851   // after the zero-th contain a deduplication counter.
2852   for (int index = 0; index < 5; ++index) {
2853     DownloadAndWait(browser(), url);
2854     content::DownloadItem* item = manager->GetDownload(
2855         content::DownloadItem::kInvalidId + 1 + index);
2856     ASSERT_TRUE(item);
2857     ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
2858     base::FilePath target_path(item->GetTargetFilePath());
2859     EXPECT_EQ(std::string("a_zip_file") +
2860         (index == 0 ? std::string(".zip") :
2861                       base::StringPrintf(" (%d).zip", index)),
2862               target_path.BaseName().AsUTF8Unsafe());
2863     ASSERT_TRUE(base::PathExists(target_path));
2864     ASSERT_TRUE(VerifyFile(target_path, origin_contents,
2865                            origin_contents.size()));
2866   }
2867 }
2868
2869 // Test that the entire download pipeline handles unicode correctly.
2870 // Disabled on Windows due to flaky timeouts: crbug.com/446695
2871 #if defined(OS_WIN)
2872 #define MAYBE_DownloadTest_CrazyFilenames DISABLED_DownloadTest_CrazyFilenames
2873 #else
2874 #define MAYBE_DownloadTest_CrazyFilenames DownloadTest_CrazyFilenames
2875 #endif
2876 IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_DownloadTest_CrazyFilenames) {
2877   const wchar_t* kCrazyFilenames[] = {
2878     L"a_file_name.zip",
2879     L"\u89c6\u9891\u76f4\u64ad\u56fe\u7247.zip",  // chinese chars
2880     L"\u0412\u043e \u0424\u043b\u043e\u0440\u0438\u0434\u0435\u043e\u0431\u044a"
2881       L"\u044f\u0432\u043b\u0435\u043d\u0440\u0435\u0436\u0438\u043c \u0427"
2882       L"\u041f \u0438\u0437-\u0437\u0430 \u0443\u0442\u0435\u0447\u043a\u0438 "
2883       L"\u043d\u0435\u0444\u0442\u0438.zip",  // russian
2884     L"Desocupa\xe7\xe3o est\xe1vel.zip",
2885     // arabic:
2886     L"\u0638\u2026\u0638\u02c6\u0637\xa7\u0638\u201a\u0637\xb9 \u0638\u201e"
2887       L"\u0638\u201e\u0637\xb2\u0638\u0679\u0637\xa7\u0637\xb1\u0637\xa9.zip",
2888     L"\u05d4\u05e2\u05d3\u05e4\u05d5\u05ea.zip",  // hebrew
2889     L"\u092d\u093e\u0930\u0924.zip",  // hindi
2890     L"d\xe9stabilis\xe9.zip",  // french
2891     // korean
2892     L"\u97d3-\u4e2d \uc815\uc0c1, \ucc9c\uc548\ud568 \uc758\uacac.zip",
2893     L"jiho....tiho...miho.zip",
2894     L"jiho!@#$tiho$%^&-()_+=miho copy.zip",  // special chars
2895     L"Wohoo-to hoo+I.zip",
2896     L"Picture 1.zip",
2897     L"This is a very very long english sentence with spaces and , and +.zip",
2898   };
2899
2900   std::vector<DownloadItem*> download_items;
2901   base::FilePath origin(FILE_PATH_LITERAL("origin"));
2902   ASSERT_TRUE(base::CreateDirectory(DestinationFile(browser(), origin)));
2903
2904   for (size_t index = 0; index < arraysize(kCrazyFilenames); ++index) {
2905     base::string16 crazy16;
2906     std::string crazy8;
2907     const wchar_t* crazy_w = kCrazyFilenames[index];
2908     ASSERT_TRUE(base::WideToUTF8(crazy_w, wcslen(crazy_w), &crazy8));
2909     ASSERT_TRUE(base::WideToUTF16(crazy_w, wcslen(crazy_w), &crazy16));
2910     base::FilePath file_path(DestinationFile(browser(), origin.Append(
2911 #if defined(OS_WIN)
2912             crazy16
2913 #elif defined(OS_POSIX)
2914             crazy8
2915 #endif
2916         )));
2917
2918     // Create the file.
2919     EXPECT_EQ(static_cast<int>(crazy8.size()),
2920               base::WriteFile(file_path, crazy8.c_str(), crazy8.size()));
2921     GURL file_url(net::FilePathToFileURL(file_path));
2922
2923     // Download the file and check that the filename is correct.
2924     DownloadAndWait(browser(), file_url);
2925     GetDownloads(browser(), &download_items);
2926     ASSERT_EQ(1UL, download_items.size());
2927     base::FilePath downloaded(download_items[0]->GetTargetFilePath());
2928     download_items[0]->Remove();
2929     download_items.clear();
2930     ASSERT_TRUE(CheckDownloadFullPaths(
2931         browser(),
2932         downloaded,
2933         file_path));
2934   }
2935 }
2936
2937 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Remove) {
2938   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
2939   std::vector<DownloadItem*> download_items;
2940   GetDownloads(browser(), &download_items);
2941   ASSERT_TRUE(download_items.empty());
2942
2943   // Download a file.
2944   DownloadAndWaitWithDisposition(browser(),
2945                                  url,
2946                                  CURRENT_TAB,
2947                                  ui_test_utils::BROWSER_TEST_NONE);
2948   GetDownloads(browser(), &download_items);
2949   ASSERT_EQ(1UL, download_items.size());
2950   base::FilePath downloaded(download_items[0]->GetTargetFilePath());
2951
2952   // Remove the DownloadItem but not the file, then check that the file still
2953   // exists.
2954   download_items[0]->Remove();
2955   download_items.clear();
2956   GetDownloads(browser(), &download_items);
2957   ASSERT_EQ(0UL, download_items.size());
2958   ASSERT_TRUE(CheckDownloadFullPaths(
2959       browser(), downloaded, OriginFile(base::FilePath(
2960           FILE_PATH_LITERAL("downloads/a_zip_file.zip")))));
2961 }
2962
2963 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_PauseResumeCancel) {
2964   DownloadItem* download_item = CreateSlowTestDownload();
2965   ASSERT_TRUE(download_item);
2966   ASSERT_FALSE(download_item->GetTargetFilePath().empty());
2967   EXPECT_FALSE(download_item->IsPaused());
2968   EXPECT_NE(DownloadItem::CANCELLED, download_item->GetState());
2969   download_item->Pause();
2970   EXPECT_TRUE(download_item->IsPaused());
2971   download_item->Resume();
2972   EXPECT_FALSE(download_item->IsPaused());
2973   EXPECT_NE(DownloadItem::CANCELLED, download_item->GetState());
2974   download_item->Cancel(true);
2975   EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState());
2976 }
2977
2978 // The Mac downloaded files quarantine feature is implemented by the
2979 // Contents/Info.plist file in cocoa apps. browser_tests cannot test
2980 // quarantining files on Mac because it is not a cocoa app.
2981 // TODO(benjhayden) test the equivalents on other platforms.
2982
2983 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
2984 // Timing out on ARM linux: http://crbug.com/238459
2985 #define MAYBE_DownloadTest_PercentComplete DISABLED_DownloadTest_PercentComplete
2986 #elif defined(OS_MACOSX)
2987 // Disable on mac: http://crbug.com/238831
2988 #define MAYBE_DownloadTest_PercentComplete DISABLED_DownloadTest_PercentComplete
2989 #else
2990 #define MAYBE_DownloadTest_PercentComplete DownloadTest_PercentComplete
2991 #endif
2992 IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_DownloadTest_PercentComplete) {
2993   // Write a huge file.
2994   base::FilePath file_path(DestinationFile(
2995       browser(), base::FilePath(FILE_PATH_LITERAL("DownloadTest_BigZip.zip"))));
2996   base::File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_WRITE);
2997   ASSERT_TRUE(file.IsValid());
2998   int64 size = 1 << 25;
2999   EXPECT_EQ(1, file.Write(size, "a", 1));
3000   file.Close();
3001
3002 #if defined(OS_POSIX)
3003   // Make it readable by chronos on chromeos
3004   base::SetPosixFilePermissions(file_path, 0755);
3005 #endif
3006
3007   // Ensure that we have enough disk space.
3008   int64 free_space = base::SysInfo::AmountOfFreeDiskSpace(
3009       GetDownloadDirectory(browser()));
3010   ASSERT_LE(size, free_space) << "Not enough disk space to download. Got "
3011                               << free_space;
3012   GURL file_url(net::FilePathToFileURL(file_path));
3013   scoped_ptr<content::DownloadTestObserver> progress_waiter(
3014       CreateInProgressWaiter(browser(), 1));
3015
3016   // Start downloading a file, wait for it to be created.
3017   ui_test_utils::NavigateToURLWithDisposition(
3018       browser(), file_url, CURRENT_TAB, ui_test_utils::BROWSER_TEST_NONE);
3019   progress_waiter->WaitForFinished();
3020   EXPECT_EQ(1u, progress_waiter->NumDownloadsSeenInState(
3021       DownloadItem::IN_PROGRESS));
3022   std::vector<DownloadItem*> download_items;
3023   GetDownloads(browser(), &download_items);
3024   ASSERT_EQ(1UL, download_items.size());
3025
3026   // Wait for the download to complete, checking along the way that the
3027   // PercentComplete() never regresses.
3028   PercentWaiter waiter(download_items[0]);
3029   EXPECT_TRUE(waiter.WaitForFinished());
3030   EXPECT_EQ(DownloadItem::COMPLETE, download_items[0]->GetState());
3031   ASSERT_EQ(100, download_items[0]->PercentComplete());
3032
3033   // Check that the file downloaded correctly.
3034   ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
3035   int64 downloaded_size = 0;
3036   ASSERT_TRUE(base::GetFileSize(
3037       download_items[0]->GetTargetFilePath(), &downloaded_size));
3038   ASSERT_EQ(size + 1, downloaded_size);
3039   ASSERT_TRUE(base::DieFileDie(file_path, false));
3040   ASSERT_TRUE(base::DieFileDie(download_items[0]->GetTargetFilePath(), false));
3041 }
3042
3043 // A download that is interrupted due to a file error should be able to be
3044 // resumed.
3045 IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_NoPrompt) {
3046   base::CommandLine::ForCurrentProcess()->AppendSwitch(
3047       switches::kEnableDownloadResumption);
3048   scoped_refptr<content::TestFileErrorInjector> error_injector(
3049       content::TestFileErrorInjector::Create(
3050           DownloadManagerForBrowser(browser())));
3051   scoped_ptr<content::DownloadTestObserver> completion_observer(
3052       CreateWaiter(browser(), 1));
3053   EnableFileChooser(true);
3054
3055   DownloadItem* download = StartMockDownloadAndInjectError(
3056       error_injector.get(), content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
3057   ASSERT_TRUE(download);
3058
3059   download->Resume();
3060   completion_observer->WaitForFinished();
3061
3062   EXPECT_EQ(
3063       1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
3064   EXPECT_FALSE(DidShowFileChooser());
3065 }
3066
3067 // A download that's interrupted due to a reason that indicates that the target
3068 // path is invalid or unusable should cause a prompt to be displayed on
3069 // resumption.
3070 IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_WithPrompt) {
3071   base::CommandLine::ForCurrentProcess()->AppendSwitch(
3072       switches::kEnableDownloadResumption);
3073   scoped_refptr<content::TestFileErrorInjector> error_injector(
3074       content::TestFileErrorInjector::Create(
3075           DownloadManagerForBrowser(browser())));
3076   scoped_ptr<content::DownloadTestObserver> completion_observer(
3077       CreateWaiter(browser(), 1));
3078   EnableFileChooser(true);
3079
3080   DownloadItem* download = StartMockDownloadAndInjectError(
3081       error_injector.get(), content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE);
3082   ASSERT_TRUE(download);
3083
3084   download->Resume();
3085   completion_observer->WaitForFinished();
3086
3087   EXPECT_EQ(
3088       1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
3089   EXPECT_TRUE(DidShowFileChooser());
3090 }
3091
3092 // The user shouldn't be prompted on a resumed download unless a prompt is
3093 // necessary due to the interrupt reason.
3094 IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_WithPromptAlways) {
3095   base::CommandLine::ForCurrentProcess()->AppendSwitch(
3096       switches::kEnableDownloadResumption);
3097   browser()->profile()->GetPrefs()->SetBoolean(
3098       prefs::kPromptForDownload, true);
3099   scoped_refptr<content::TestFileErrorInjector> error_injector(
3100       content::TestFileErrorInjector::Create(
3101           DownloadManagerForBrowser(browser())));
3102   scoped_ptr<content::DownloadTestObserver> completion_observer(
3103       CreateWaiter(browser(), 1));
3104   EnableFileChooser(true);
3105
3106   DownloadItem* download = StartMockDownloadAndInjectError(
3107       error_injector.get(), content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
3108   ASSERT_TRUE(download);
3109
3110   // Prompts the user initially because of the kPromptForDownload preference.
3111   EXPECT_TRUE(DidShowFileChooser());
3112
3113   download->Resume();
3114   completion_observer->WaitForFinished();
3115
3116   EXPECT_EQ(
3117       1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
3118   // Shouldn't prompt for resumption.
3119   EXPECT_FALSE(DidShowFileChooser());
3120 }
3121
3122 // A download that is interrupted due to a transient error should be resumed
3123 // automatically.
3124 IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_Automatic) {
3125   base::CommandLine::ForCurrentProcess()->AppendSwitch(
3126       switches::kEnableDownloadResumption);
3127   scoped_refptr<content::TestFileErrorInjector> error_injector(
3128       content::TestFileErrorInjector::Create(
3129           DownloadManagerForBrowser(browser())));
3130
3131   DownloadItem* download = StartMockDownloadAndInjectError(
3132       error_injector.get(),
3133       content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
3134   ASSERT_TRUE(download);
3135
3136   // The number of times this the download is resumed automatically is defined
3137   // in DownloadItemImpl::kMaxAutoResumeAttempts. The number of DownloadFiles
3138   // created should be that number + 1 (for the original download request). We
3139   // only care that it is greater than 1.
3140   EXPECT_GT(1u, error_injector->TotalFileCount());
3141 }
3142
3143 // An interrupting download should be resumable multiple times.
3144 IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_MultipleAttempts) {
3145   base::CommandLine::ForCurrentProcess()->AppendSwitch(
3146       switches::kEnableDownloadResumption);
3147   scoped_refptr<content::TestFileErrorInjector> error_injector(
3148       content::TestFileErrorInjector::Create(
3149           DownloadManagerForBrowser(browser())));
3150   scoped_ptr<DownloadTestObserverNotInProgress> completion_observer(
3151       new DownloadTestObserverNotInProgress(
3152           DownloadManagerForBrowser(browser()), 1));
3153   // Wait for two transitions to a resumable state
3154   scoped_ptr<content::DownloadTestObserver> resumable_observer(
3155       new DownloadTestObserverResumable(
3156           DownloadManagerForBrowser(browser()), 2));
3157
3158   EnableFileChooser(true);
3159   DownloadItem* download = StartMockDownloadAndInjectError(
3160       error_injector.get(), content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
3161   ASSERT_TRUE(download);
3162
3163   content::TestFileErrorInjector::FileErrorInfo error_info;
3164   error_info.url = download->GetOriginalUrl().spec();
3165   error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
3166   error_info.operation_instance = 0;
3167   error_info.error = content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED;
3168   error_injector->AddError(error_info);
3169   error_injector->InjectErrors();
3170
3171   // Resuming should cause the download to be interrupted again due to the
3172   // errors we are injecting.
3173   download->Resume();
3174   resumable_observer->WaitForFinished();
3175   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
3176   ASSERT_EQ(content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
3177             download->GetLastReason());
3178
3179   error_injector->ClearErrors();
3180   error_injector->InjectErrors();
3181
3182   // No errors this time. The download should complete successfully.
3183   EXPECT_FALSE(completion_observer->IsFinished());
3184   completion_observer->StartObserving();
3185   download->Resume();
3186   completion_observer->WaitForFinished();
3187   EXPECT_EQ(DownloadItem::COMPLETE, download->GetState());
3188
3189   EXPECT_FALSE(DidShowFileChooser());
3190 }
3191
3192 // The file empty.bin is served with a MIME type of application/octet-stream.
3193 // The content body is empty. Make sure this case is handled properly and we
3194 // don't regress on http://crbug.com/320394.
3195 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_GZipWithNoContent) {
3196   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/empty.bin");
3197   // Downloading the same URL twice causes the second request to be served from
3198   // cached (with a high probability). This test verifies that that doesn't
3199   // happen regardless of whether the request is served via the cache or from
3200   // the network.
3201   DownloadAndWait(browser(), url);
3202   DownloadAndWait(browser(), url);
3203 }
3204
3205 #if defined(FULL_SAFE_BROWSING)
3206
3207 // The following two tests are only meaningful on OS_WIN since that's the only
3208 // platform where client download checks are currently performed.
3209 // TODO(asanka): Relax this restriction as other platforms are added.
3210 #if defined(OS_WIN)
3211 namespace {
3212
3213 // This is a custom DownloadTestObserver for
3214 // DangerousFileWithSBDisabledBeforeCompletion test that disables the
3215 // SafeBrowsing service when a single download is IN_PROGRESS and has a target
3216 // path assigned.  DownloadItemImpl is expected to call MaybeCompleteDownload
3217 // soon afterwards and we want to disable the service before then.
3218 class DisableSafeBrowsingOnInProgressDownload
3219     : public content::DownloadTestObserver {
3220  public:
3221   explicit DisableSafeBrowsingOnInProgressDownload(Browser* browser)
3222       : DownloadTestObserver(DownloadManagerForBrowser(browser),
3223                              1,
3224                              ON_DANGEROUS_DOWNLOAD_QUIT),
3225         browser_(browser),
3226         final_state_seen_(false) {
3227     Init();
3228   }
3229   ~DisableSafeBrowsingOnInProgressDownload() override {}
3230
3231   bool IsDownloadInFinalState(DownloadItem* download) override {
3232     if (download->GetState() != DownloadItem::IN_PROGRESS ||
3233         download->GetTargetFilePath().empty())
3234       return false;
3235
3236     if (final_state_seen_)
3237       return true;
3238
3239     final_state_seen_ = true;
3240     browser_->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
3241                                                 false);
3242     EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
3243               download->GetDangerType());
3244     EXPECT_FALSE(download->IsDangerous());
3245     EXPECT_TRUE(DownloadItemModel(download).IsDangerousFileBasedOnType());
3246     return true;
3247   }
3248
3249  private:
3250   Browser* browser_;
3251   bool final_state_seen_;
3252 };
3253
3254 }  // namespace
3255
3256 IN_PROC_BROWSER_TEST_F(DownloadTest,
3257                        DangerousFileWithSBDisabledBeforeCompletion) {
3258   browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
3259                                                true);
3260   GURL download_url = net::URLRequestMockHTTPJob::GetMockUrl(
3261       "downloads/dangerous/dangerous.exe");
3262   scoped_ptr<content::DownloadTestObserver> dangerous_observer(
3263       DangerousDownloadWaiter(
3264           browser(),
3265           1,
3266           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
3267   scoped_ptr<content::DownloadTestObserver> in_progress_observer(
3268       new DisableSafeBrowsingOnInProgressDownload(browser()));
3269   ui_test_utils::NavigateToURLWithDisposition(browser(),
3270                                               download_url,
3271                                               NEW_BACKGROUND_TAB,
3272                                               ui_test_utils::BROWSER_TEST_NONE);
3273   in_progress_observer->WaitForFinished();
3274
3275   // SafeBrowsing should have been disabled by our observer.
3276   ASSERT_FALSE(browser()->profile()->GetPrefs()->GetBoolean(
3277       prefs::kSafeBrowsingEnabled));
3278
3279   std::vector<DownloadItem*> downloads;
3280   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
3281   ASSERT_EQ(1u, downloads.size());
3282   DownloadItem* download = downloads[0];
3283
3284   dangerous_observer->WaitForFinished();
3285
3286   EXPECT_TRUE(download->IsDangerous());
3287   EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
3288             download->GetDangerType());
3289   download->Cancel(true);
3290 }
3291
3292 IN_PROC_BROWSER_TEST_F(DownloadTest, DangerousFileWithSBDisabledBeforeStart) {
3293   // Disable SafeBrowsing
3294   browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
3295                                                false);
3296
3297   GURL download_url = net::URLRequestMockHTTPJob::GetMockUrl(
3298       "downloads/dangerous/dangerous.exe");
3299   scoped_ptr<content::DownloadTestObserver> dangerous_observer(
3300       DangerousDownloadWaiter(
3301           browser(),
3302           1,
3303           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
3304   ui_test_utils::NavigateToURLWithDisposition(browser(),
3305                                               download_url,
3306                                               NEW_BACKGROUND_TAB,
3307                                               ui_test_utils::BROWSER_TEST_NONE);
3308   dangerous_observer->WaitForFinished();
3309
3310   std::vector<DownloadItem*> downloads;
3311   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
3312   ASSERT_EQ(1u, downloads.size());
3313
3314   DownloadItem* download = downloads[0];
3315   EXPECT_TRUE(download->IsDangerous());
3316   EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
3317             download->GetDangerType());
3318
3319   download->Cancel(true);
3320 }
3321
3322 IN_PROC_BROWSER_TEST_F(DownloadTest, SafeSupportedFile) {
3323   GURL download_url =
3324       net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
3325   DownloadAndWait(browser(), download_url);
3326
3327   std::vector<DownloadItem*> downloads;
3328   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
3329   ASSERT_EQ(1u, downloads.size());
3330
3331   DownloadItem* download = downloads[0];
3332   EXPECT_FALSE(download->IsDangerous());
3333   EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
3334             download->GetDangerType());
3335
3336   download->Cancel(true);
3337 }
3338
3339 #endif  // OS_WIN
3340
3341 IN_PROC_BROWSER_TEST_F(DownloadTest, FeedbackService) {
3342   // Make a dangerous file.
3343   base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
3344   GURL download_url(net::URLRequestMockHTTPJob::GetMockUrl(file));
3345   scoped_ptr<content::DownloadTestObserverInterrupted> observer(
3346       new content::DownloadTestObserverInterrupted(
3347           DownloadManagerForBrowser(browser()), 1,
3348           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
3349   ui_test_utils::NavigateToURLWithDisposition(
3350       browser(),
3351       GURL(download_url),
3352       NEW_BACKGROUND_TAB,
3353       ui_test_utils::BROWSER_TEST_NONE);
3354   observer->WaitForFinished();
3355
3356   // Get the download from the DownloadManager.
3357   std::vector<DownloadItem*> downloads;
3358   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
3359   ASSERT_EQ(1u, downloads.size());
3360   EXPECT_TRUE(downloads[0]->IsDangerous());
3361
3362   // Save fake pings for the download.
3363   safe_browsing::ClientDownloadReport fake_metadata;
3364   fake_metadata.mutable_download_request()->set_url("http://test");
3365   fake_metadata.mutable_download_request()->set_length(1);
3366   fake_metadata.mutable_download_request()->mutable_digests()->set_sha1("hi");
3367   fake_metadata.mutable_download_response()->set_verdict(
3368       safe_browsing::ClientDownloadResponse::UNCOMMON);
3369   std::string ping_request(
3370       fake_metadata.download_request().SerializeAsString());
3371   std::string ping_response(
3372       fake_metadata.download_response().SerializeAsString());
3373   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
3374   safe_browsing::DownloadProtectionService* download_protection_service =
3375       sb_service->download_protection_service();
3376   download_protection_service->feedback_service()->MaybeStorePingsForDownload(
3377       safe_browsing::DownloadProtectionService::UNCOMMON,
3378       downloads[0],
3379       ping_request,
3380       ping_response);
3381   ASSERT_TRUE(safe_browsing::DownloadFeedbackService::IsEnabledForDownload(
3382       *(downloads[0])));
3383
3384   // Begin feedback and check that the file is "stolen".
3385   download_protection_service->feedback_service()->BeginFeedbackForDownload(
3386       downloads[0]);
3387   std::vector<DownloadItem*> updated_downloads;
3388   GetDownloads(browser(), &updated_downloads);
3389   ASSERT_TRUE(updated_downloads.empty());
3390 }
3391 #endif
3392
3393 class DownloadTestWithShelf : public DownloadTest {
3394   void SetUpCommandLine(base::CommandLine* command_line) override {
3395     command_line->AppendSwitchASCII(switches::kEnableDownloadNotification,
3396                                     "disabled");
3397     DownloadTest::SetUpCommandLine(command_line);
3398   }
3399 };
3400
3401 // Test that the download shelf is shown by starting a download.
3402 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, DownloadAndWait) {
3403   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
3404   DownloadAndWait(browser(), url);
3405
3406   // The download shelf should be visible.
3407   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
3408 }
3409
3410 // Test that the download shelf is per-window by starting a download in one
3411 // tab, opening a second tab, closing the shelf, going back to the first tab,
3412 // and checking that the shelf is closed.
3413 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, PerWindowShelf) {
3414   base::FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
3415   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3416   base::FilePath download_file(
3417       FILE_PATH_LITERAL("download-test3-attachment.gif"));
3418
3419   // Download a file and wait.
3420   DownloadAndWait(browser(), url);
3421
3422   CheckDownload(browser(), download_file, file);
3423
3424   // Check state.
3425   EXPECT_EQ(1, browser()->tab_strip_model()->count());
3426   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
3427
3428   // Open a second tab and wait.
3429   EXPECT_NE(static_cast<WebContents*>(NULL),
3430             chrome::AddSelectedTabWithURL(browser(), GURL(url::kAboutBlankURL),
3431                                           ui::PAGE_TRANSITION_TYPED));
3432   EXPECT_EQ(2, browser()->tab_strip_model()->count());
3433   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
3434
3435   // Hide the download shelf.
3436   browser()->window()->GetDownloadShelf()->Close(DownloadShelf::AUTOMATIC);
3437   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3438
3439   // Go to the first tab.
3440   browser()->tab_strip_model()->ActivateTabAt(0, true);
3441   EXPECT_EQ(2, browser()->tab_strip_model()->count());
3442
3443   // The download shelf should not be visible.
3444   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3445 }
3446
3447 // Check whether the downloads shelf is closed when the downloads tab is
3448 // invoked.
3449 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, CloseShelfOnDownloadsTab) {
3450   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3451   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3452
3453   // Download the file and wait.  We do not expect the Select File dialog.
3454   DownloadAndWait(browser(), url);
3455
3456   // Check state.
3457   EXPECT_EQ(1, browser()->tab_strip_model()->count());
3458   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
3459
3460   // Open the downloads tab.
3461   chrome::ShowDownloads(browser());
3462   // The shelf should now be closed.
3463   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3464 }
3465
3466 // Test that when downloading an item in Incognito mode, check that the
3467 // download shelf is not visible after closing the Incognito window.
3468 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, IncognitoDownload) {
3469   Browser* incognito = CreateIncognitoBrowser();
3470   ASSERT_TRUE(incognito);
3471
3472   // Download a file in the Incognito window and wait.
3473   CreateAndSetDownloadsDirectory(incognito);
3474   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3475   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3476   // Since |incognito| is a separate browser, we have to set it up explicitly.
3477   incognito->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
3478                                                false);
3479   DownloadAndWait(incognito, url);
3480
3481   // Verify that the download shelf is showing for the Incognito window.
3482   EXPECT_TRUE(incognito->window()->IsDownloadShelfVisible());
3483
3484   // Verify that the regular window does not have a download shelf.
3485   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3486 }
3487
3488 // Download a file in a new window.
3489 // Verify that we have 2 windows, and the download shelf is not visible in the
3490 // first window, but is visible in the second window.
3491 // Close the new window.
3492 // Verify that we have 1 window, and the download shelf is not visible.
3493 //
3494 // Regression test for http://crbug.com/44454
3495 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, NewWindow) {
3496   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3497   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3498 #if !defined(OS_MACOSX)
3499   // See below.
3500   Browser* first_browser = browser();
3501 #endif
3502
3503   // Download a file in a new window and wait.
3504   DownloadAndWaitWithDisposition(browser(), url, NEW_WINDOW,
3505                                  ui_test_utils::BROWSER_TEST_NONE);
3506
3507   // When the download finishes, the download shelf SHOULD NOT be visible in
3508   // the first window.
3509   ExpectWindowCountAfterDownload(2);
3510   EXPECT_EQ(1, browser()->tab_strip_model()->count());
3511   // Download shelf should close. Download panel stays open on ChromeOS.
3512   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3513
3514   // The download shelf SHOULD be visible in the second window.
3515   std::set<Browser*> original_browsers;
3516   original_browsers.insert(browser());
3517   Browser* download_browser =
3518       ui_test_utils::GetBrowserNotInSet(original_browsers);
3519   ASSERT_TRUE(download_browser != NULL);
3520   EXPECT_NE(download_browser, browser());
3521   EXPECT_EQ(1, download_browser->tab_strip_model()->count());
3522   EXPECT_TRUE(download_browser->window()->IsDownloadShelfVisible());
3523
3524 #if !defined(OS_MACOSX)
3525   // On Mac OS X, the UI window close is delayed until the outermost
3526   // message loop runs.  So it isn't possible to get a BROWSER_CLOSED
3527   // notification inside of a test.
3528   content::WindowedNotificationObserver signal(
3529       chrome::NOTIFICATION_BROWSER_CLOSED,
3530       content::Source<Browser>(download_browser));
3531 #endif
3532
3533   // Close the new window.
3534   chrome::CloseWindow(download_browser);
3535
3536 #if !defined(OS_MACOSX)
3537   signal.Wait();
3538   EXPECT_EQ(first_browser, browser());
3539   ExpectWindowCountAfterDownload(1);
3540 #endif
3541
3542   EXPECT_EQ(1, browser()->tab_strip_model()->count());
3543   // Download shelf should close. Download panel stays open on ChromeOS.
3544   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3545
3546   CheckDownload(browser(), file, file);
3547 }
3548
3549 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, PRE_DownloadTest_History) {
3550   // Download a file and wait for it to be stored.
3551   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3552   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
3553   HistoryObserver observer(browser()->profile());
3554   DownloadAndWait(browser(), download_url);
3555   observer.WaitForStored();
3556   HistoryServiceFactory::GetForProfile(browser()->profile(),
3557                                        ServiceAccessType::IMPLICIT_ACCESS)
3558       ->FlushForTest(base::Bind(
3559           &base::MessageLoop::Quit,
3560           base::Unretained(base::MessageLoop::current()->current())));
3561   content::RunMessageLoop();
3562 }
3563
3564 #if defined(OS_CHROMEOS)
3565 // Times out on ChromeOS: http://crbug.com/217810
3566 #define MAYBE_DownloadTest_History DISABLED_DownloadTest_History
3567 #else
3568 #define MAYBE_DownloadTest_History DownloadTest_History
3569 #endif
3570 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, MAYBE_DownloadTest_History) {
3571   // This starts up right after PRE_DownloadTest_History and shares the same
3572   // profile directory.
3573   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3574   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
3575   std::vector<DownloadItem*> downloads;
3576   content::DownloadManager* manager = DownloadManagerForBrowser(browser());
3577
3578   // Wait for the history to be loaded with a single DownloadItem. Check that
3579   // it's the file that was downloaded in PRE_DownloadTest_History.
3580   CreatedObserver created_observer(manager);
3581   created_observer.Wait();
3582   manager->GetAllDownloads(&downloads);
3583   ASSERT_EQ(1UL, downloads.size());
3584   DownloadItem* item = downloads[0];
3585   EXPECT_EQ(file.value(), item->GetFullPath().BaseName().value());
3586   EXPECT_EQ(file.value(), item->GetTargetFilePath().BaseName().value());
3587   EXPECT_EQ(download_url, item->GetURL());
3588   // The following are set by download-test1.lib.mock-http-headers.
3589   std::string etag = item->GetETag();
3590   base::TrimWhitespaceASCII(etag, base::TRIM_ALL, &etag);
3591   EXPECT_EQ("abracadabra", etag);
3592
3593   std::string last_modified = item->GetLastModifiedTime();
3594   base::TrimWhitespaceASCII(last_modified, base::TRIM_ALL, &last_modified);
3595   EXPECT_EQ("Mon, 13 Nov 2006 20:31:09 GMT", last_modified);
3596
3597   // Downloads that were restored from history shouldn't cause the download
3598   // shelf to be displayed.
3599   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3600 }
3601
3602 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, HiddenDownload) {
3603   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
3604   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3605
3606   DownloadManager* download_manager = DownloadManagerForBrowser(browser());
3607   scoped_ptr<content::DownloadTestObserver> observer(
3608       new content::DownloadTestObserverTerminal(
3609           download_manager, 1,
3610           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
3611
3612   // Download and set IsHiddenDownload to true.
3613   WebContents* web_contents =
3614       browser()->tab_strip_model()->GetActiveWebContents();
3615   scoped_ptr<DownloadUrlParameters> params(
3616       DownloadUrlParameters::FromWebContents(web_contents, url));
3617   params->set_callback(base::Bind(&SetHiddenDownloadCallback));
3618   download_manager->DownloadUrl(params.Pass());
3619   observer->WaitForFinished();
3620
3621   // Verify that download shelf is not shown.
3622   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3623 }
3624
3625 // Test to make sure auto-open works.
3626 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, AutoOpen) {
3627   base::FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
3628   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
3629
3630   ASSERT_TRUE(
3631       GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
3632
3633   DownloadAndWait(browser(), url);
3634
3635   // Download shelf should close. Download panel stays open on ChromeOS.
3636   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3637 }
3638
3639 // Download an extension.  Expect a dangerous download warning.
3640 // Deny the download.
3641 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, CrxDenyInstall) {
3642   FeatureSwitch::ScopedOverride enable_easy_off_store_install(
3643       FeatureSwitch::easy_off_store_install(), true);
3644
3645   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
3646
3647   scoped_ptr<content::DownloadTestObserver> observer(DangerousDownloadWaiter(
3648       browser(), 1, content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
3649   ui_test_utils::NavigateToURL(browser(), extension_url);
3650
3651   observer->WaitForFinished();
3652
3653   // Download shelf should close.
3654   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
3655 }