src/content/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 // This file contains download browser tests that are known to be runnable
   6 // in a pure content context.  Over time tests should be migrated here.
   7
   8 #include "base/command_line.h"
   9 #include "base/files/file_path.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/threading/platform_thread.h"
  16 #include "base/time/time.h"
  17 #include "content/browser/byte_stream.h"
  18 #include "content/browser/download/download_file_factory.h"
  19 #include "content/browser/download/download_file_impl.h"
  20 #include "content/browser/download/download_item_impl.h"
  21 #include "content/browser/download/download_manager_impl.h"
  22 #include "content/browser/download/download_resource_handler.h"
  23 #include "content/browser/web_contents/web_contents_impl.h"
  24 #include "content/public/browser/power_save_blocker.h"
  25 #include "content/public/common/content_switches.h"
  26 #include "content/public/common/webplugininfo.h"
  27 #include "content/public/test/browser_test_utils.h"
  28 #include "content/public/test/content_browser_test.h"
  29 #include "content/public/test/content_browser_test_utils.h"
  30 #include "content/public/test/download_test_observer.h"
  31 #include "content/public/test/test_file_error_injector.h"
  32 #include "content/public/test/test_utils.h"
  33 #include "content/shell/browser/shell.h"
  34 #include "content/shell/browser/shell_browser_context.h"
  35 #include "content/shell/browser/shell_download_manager_delegate.h"
  36 #include "content/shell/browser/shell_network_delegate.h"
  37 #include "content/test/net/url_request_slow_download_job.h"
  38 #include "net/test/embedded_test_server/embedded_test_server.h"
  39 #include "net/test/embedded_test_server/http_request.h"
  40 #include "net/test/embedded_test_server/http_response.h"
  41 #include "net/test/spawned_test_server/spawned_test_server.h"
  42 #include "net/test/url_request/url_request_mock_http_job.h"
  43 #include "testing/gmock/include/gmock/gmock.h"
  44 #include "testing/gtest/include/gtest/gtest.h"
  45 #include "url/gurl.h"
  46
  47 #if defined(ENABLE_PLUGINS)
  48 #include "content/browser/plugin_service_impl.h"
  49 #endif
  50
  51 using ::net::test_server::EmbeddedTestServer;
  52 using ::testing::AllOf;
  53 using ::testing::Field;
  54 using ::testing::InSequence;
  55 using ::testing::Property;
  56 using ::testing::Return;
  57 using ::testing::StrictMock;
  58 using ::testing::_;
  59
  60 namespace content {
  61
  62 namespace {
  63
  64 class MockDownloadItemObserver : public DownloadItem::Observer {
  65  public:
  66   MockDownloadItemObserver() {}
  67   virtual ~MockDownloadItemObserver() {}
  68
  69   MOCK_METHOD1(OnDownloadUpdated, void(DownloadItem*));
  70   MOCK_METHOD1(OnDownloadOpened, void(DownloadItem*));
  71   MOCK_METHOD1(OnDownloadRemoved, void(DownloadItem*));
  72   MOCK_METHOD1(OnDownloadDestroyed, void(DownloadItem*));
  73 };
  74
  75 class MockDownloadManagerObserver : public DownloadManager::Observer {
  76  public:
  77   MockDownloadManagerObserver(DownloadManager* manager) {
  78     manager_ = manager;
  79     manager->AddObserver(this);
  80   }
  81   virtual ~MockDownloadManagerObserver() {
  82     if (manager_)
  83       manager_->RemoveObserver(this);
  84   }
  85
  86   MOCK_METHOD2(OnDownloadCreated, void(DownloadManager*, DownloadItem*));
  87   MOCK_METHOD1(ModelChanged, void(DownloadManager*));
  88   void ManagerGoingDown(DownloadManager* manager) {
  89     DCHECK_EQ(manager_, manager);
  90     MockManagerGoingDown(manager);
  91
  92     manager_->RemoveObserver(this);
  93     manager_ = NULL;
  94   }
  95
  96   MOCK_METHOD1(MockManagerGoingDown, void(DownloadManager*));
  97  private:
  98   DownloadManager* manager_;
  99 };
 100
 101 class DownloadFileWithDelayFactory;
 102
 103 static DownloadManagerImpl* DownloadManagerForShell(Shell* shell) {
 104   // We're in a content_browsertest; we know that the DownloadManager
 105   // is a DownloadManagerImpl.
 106   return static_cast<DownloadManagerImpl*>(
 107       BrowserContext::GetDownloadManager(
 108           shell->web_contents()->GetBrowserContext()));
 109 }
 110
 111 class DownloadFileWithDelay : public DownloadFileImpl {
 112  public:
 113   DownloadFileWithDelay(
 114       scoped_ptr<DownloadSaveInfo> save_info,
 115       const base::FilePath& default_download_directory,
 116       const GURL& url,
 117       const GURL& referrer_url,
 118       bool calculate_hash,
 119       scoped_ptr<ByteStreamReader> stream,
 120       const net::BoundNetLog& bound_net_log,
 121       scoped_ptr<PowerSaveBlocker> power_save_blocker,
 122       base::WeakPtr<DownloadDestinationObserver> observer,
 123       base::WeakPtr<DownloadFileWithDelayFactory> owner);
 124
 125   virtual ~DownloadFileWithDelay();
 126
 127   // Wraps DownloadFileImpl::Rename* and intercepts the return callback,
 128   // storing it in the factory that produced this object for later
 129   // retrieval.
 130   virtual void RenameAndUniquify(
 131       const base::FilePath& full_path,
 132       const RenameCompletionCallback& callback) OVERRIDE;
 133   virtual void RenameAndAnnotate(
 134       const base::FilePath& full_path,
 135       const RenameCompletionCallback& callback) OVERRIDE;
 136
 137  private:
 138   static void RenameCallbackWrapper(
 139       const base::WeakPtr<DownloadFileWithDelayFactory>& factory,
 140       const RenameCompletionCallback& original_callback,
 141       DownloadInterruptReason reason,
 142       const base::FilePath& path);
 143
 144   // This variable may only be read on the FILE thread, and may only be
 145   // indirected through (e.g. methods on DownloadFileWithDelayFactory called)
 146   // on the UI thread.  This is because after construction,
 147   // DownloadFileWithDelay lives on the file thread, but
 148   // DownloadFileWithDelayFactory is purely a UI thread object.
 149   base::WeakPtr<DownloadFileWithDelayFactory> owner_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(DownloadFileWithDelay);
 152 };
 153
 154 // All routines on this class must be called on the UI thread.
 155 class DownloadFileWithDelayFactory : public DownloadFileFactory {
 156  public:
 157   DownloadFileWithDelayFactory();
 158   virtual ~DownloadFileWithDelayFactory();
 159
 160   // DownloadFileFactory interface.
 161   virtual DownloadFile* CreateFile(
 162       scoped_ptr<DownloadSaveInfo> save_info,
 163       const base::FilePath& default_download_directory,
 164       const GURL& url,
 165       const GURL& referrer_url,
 166       bool calculate_hash,
 167       scoped_ptr<ByteStreamReader> stream,
 168       const net::BoundNetLog& bound_net_log,
 169       base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE;
 170
 171   void AddRenameCallback(base::Closure callback);
 172   void GetAllRenameCallbacks(std::vector<base::Closure>* results);
 173
 174   // Do not return until GetAllRenameCallbacks() will return a non-empty list.
 175   void WaitForSomeCallback();
 176
 177  private:
 178   base::WeakPtrFactory<DownloadFileWithDelayFactory> weak_ptr_factory_;
 179   std::vector<base::Closure> rename_callbacks_;
 180   bool waiting_;
 181
 182   DISALLOW_COPY_AND_ASSIGN(DownloadFileWithDelayFactory);
 183 };
 184
 185 DownloadFileWithDelay::DownloadFileWithDelay(
 186     scoped_ptr<DownloadSaveInfo> save_info,
 187     const base::FilePath& default_download_directory,
 188     const GURL& url,
 189     const GURL& referrer_url,
 190     bool calculate_hash,
 191     scoped_ptr<ByteStreamReader> stream,
 192     const net::BoundNetLog& bound_net_log,
 193     scoped_ptr<PowerSaveBlocker> power_save_blocker,
 194     base::WeakPtr<DownloadDestinationObserver> observer,
 195     base::WeakPtr<DownloadFileWithDelayFactory> owner)
 196     : DownloadFileImpl(
 197         save_info.Pass(), default_download_directory, url, referrer_url,
 198         calculate_hash, stream.Pass(), bound_net_log, observer),
 199       owner_(owner) {}
 200
 201 DownloadFileWithDelay::~DownloadFileWithDelay() {}
 202
 203 void DownloadFileWithDelay::RenameAndUniquify(
 204     const base::FilePath& full_path,
 205     const RenameCompletionCallback& callback) {
 206   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 207   DownloadFileImpl::RenameAndUniquify(
 208       full_path, base::Bind(DownloadFileWithDelay::RenameCallbackWrapper,
 209                             owner_, callback));
 210 }
 211
 212 void DownloadFileWithDelay::RenameAndAnnotate(
 213     const base::FilePath& full_path, const RenameCompletionCallback& callback) {
 214   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 215   DownloadFileImpl::RenameAndAnnotate(
 216       full_path, base::Bind(DownloadFileWithDelay::RenameCallbackWrapper,
 217                             owner_, callback));
 218 }
 219
 220 // static
 221 void DownloadFileWithDelay::RenameCallbackWrapper(
 222     const base::WeakPtr<DownloadFileWithDelayFactory>& factory,
 223     const RenameCompletionCallback& original_callback,
 224     DownloadInterruptReason reason,
 225     const base::FilePath& path) {
 226   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 227   if (!factory)
 228     return;
 229   factory->AddRenameCallback(base::Bind(original_callback, reason, path));
 230 }
 231
 232 DownloadFileWithDelayFactory::DownloadFileWithDelayFactory()
 233     : weak_ptr_factory_(this),
 234       waiting_(false) {}
 235 DownloadFileWithDelayFactory::~DownloadFileWithDelayFactory() {}
 236
 237 DownloadFile* DownloadFileWithDelayFactory::CreateFile(
 238     scoped_ptr<DownloadSaveInfo> save_info,
 239     const base::FilePath& default_download_directory,
 240     const GURL& url,
 241     const GURL& referrer_url,
 242     bool calculate_hash,
 243     scoped_ptr<ByteStreamReader> stream,
 244     const net::BoundNetLog& bound_net_log,
 245     base::WeakPtr<DownloadDestinationObserver> observer) {
 246   scoped_ptr<PowerSaveBlocker> psb(
 247       PowerSaveBlocker::Create(
 248           PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
 249           "Download in progress"));
 250   return new DownloadFileWithDelay(
 251       save_info.Pass(), default_download_directory, url, referrer_url,
 252       calculate_hash, stream.Pass(), bound_net_log,
 253       psb.Pass(), observer, weak_ptr_factory_.GetWeakPtr());
 254 }
 255
 256 void DownloadFileWithDelayFactory::AddRenameCallback(base::Closure callback) {
 257   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 258   rename_callbacks_.push_back(callback);
 259   if (waiting_)
 260     base::MessageLoopForUI::current()->Quit();
 261 }
 262
 263 void DownloadFileWithDelayFactory::GetAllRenameCallbacks(
 264     std::vector<base::Closure>* results) {
 265   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 266   results->swap(rename_callbacks_);
 267 }
 268
 269 void DownloadFileWithDelayFactory::WaitForSomeCallback() {
 270   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 271
 272   if (rename_callbacks_.empty()) {
 273     waiting_ = true;
 274     RunMessageLoop();
 275     waiting_ = false;
 276   }
 277 }
 278
 279 class CountingDownloadFile : public DownloadFileImpl {
 280  public:
 281   CountingDownloadFile(
 282     scoped_ptr<DownloadSaveInfo> save_info,
 283     const base::FilePath& default_downloads_directory,
 284     const GURL& url,
 285     const GURL& referrer_url,
 286     bool calculate_hash,
 287     scoped_ptr<ByteStreamReader> stream,
 288     const net::BoundNetLog& bound_net_log,
 289     scoped_ptr<PowerSaveBlocker> power_save_blocker,
 290     base::WeakPtr<DownloadDestinationObserver> observer)
 291       : DownloadFileImpl(save_info.Pass(), default_downloads_directory,
 292                          url, referrer_url, calculate_hash,
 293                          stream.Pass(), bound_net_log, observer) {}
 294
 295   virtual ~CountingDownloadFile() {
 296     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 297     active_files_--;
 298   }
 299
 300   virtual void Initialize(const InitializeCallback& callback) OVERRIDE {
 301     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 302     active_files_++;
 303     return DownloadFileImpl::Initialize(callback);
 304   }
 305
 306   static void GetNumberActiveFiles(int* result) {
 307     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 308     *result = active_files_;
 309   }
 310
 311   // Can be called on any thread, and will block (running message loop)
 312   // until data is returned.
 313   static int GetNumberActiveFilesFromFileThread() {
 314     int result = -1;
 315     BrowserThread::PostTaskAndReply(
 316         BrowserThread::FILE,
 317         FROM_HERE,
 318         base::Bind(&CountingDownloadFile::GetNumberActiveFiles, &result),
 319         base::MessageLoop::current()->QuitClosure());
 320     base::MessageLoop::current()->Run();
 321     DCHECK_NE(-1, result);
 322     return result;
 323   }
 324
 325  private:
 326   static int active_files_;
 327 };
 328
 329 int CountingDownloadFile::active_files_ = 0;
 330
 331 class CountingDownloadFileFactory : public DownloadFileFactory {
 332  public:
 333   CountingDownloadFileFactory() {}
 334   virtual ~CountingDownloadFileFactory() {}
 335
 336   // DownloadFileFactory interface.
 337   virtual DownloadFile* CreateFile(
 338     scoped_ptr<DownloadSaveInfo> save_info,
 339     const base::FilePath& default_downloads_directory,
 340     const GURL& url,
 341     const GURL& referrer_url,
 342     bool calculate_hash,
 343     scoped_ptr<ByteStreamReader> stream,
 344     const net::BoundNetLog& bound_net_log,
 345     base::WeakPtr<DownloadDestinationObserver> observer) OVERRIDE {
 346     scoped_ptr<PowerSaveBlocker> psb(
 347         PowerSaveBlocker::Create(
 348             PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
 349             "Download in progress"));
 350     return new CountingDownloadFile(
 351         save_info.Pass(), default_downloads_directory, url, referrer_url,
 352         calculate_hash, stream.Pass(), bound_net_log,
 353         psb.Pass(), observer);
 354   }
 355 };
 356
 357 class TestShellDownloadManagerDelegate : public ShellDownloadManagerDelegate {
 358  public:
 359   TestShellDownloadManagerDelegate()
 360       : delay_download_open_(false) {}
 361   virtual ~TestShellDownloadManagerDelegate() {}
 362
 363   virtual bool ShouldOpenDownload(
 364       DownloadItem* item,
 365       const DownloadOpenDelayedCallback& callback) OVERRIDE {
 366     if (delay_download_open_) {
 367       delayed_callbacks_.push_back(callback);
 368       return false;
 369     }
 370     return true;
 371   }
 372
 373   void SetDelayedOpen(bool delay) {
 374     delay_download_open_ = delay;
 375   }
 376
 377   void GetDelayedCallbacks(
 378       std::vector<DownloadOpenDelayedCallback>* callbacks) {
 379     callbacks->swap(delayed_callbacks_);
 380   }
 381  private:
 382   bool delay_download_open_;
 383   std::vector<DownloadOpenDelayedCallback> delayed_callbacks_;
 384 };
 385
 386 // Record all state transitions and byte counts on the observed download.
 387 class RecordingDownloadObserver : DownloadItem::Observer {
 388  public:
 389   struct RecordStruct {
 390     DownloadItem::DownloadState state;
 391     int bytes_received;
 392   };
 393
 394   typedef std::vector<RecordStruct> RecordVector;
 395
 396   RecordingDownloadObserver(DownloadItem* download)
 397       : download_(download) {
 398     last_state_.state = download->GetState();
 399     last_state_.bytes_received = download->GetReceivedBytes();
 400     download_->AddObserver(this);
 401   }
 402
 403   virtual ~RecordingDownloadObserver() {
 404     RemoveObserver();
 405   }
 406
 407   void CompareToExpectedRecord(const RecordStruct expected[], size_t size) {
 408     EXPECT_EQ(size, record_.size());
 409     int min = size > record_.size() ? record_.size() : size;
 410     for (int i = 0; i < min; ++i) {
 411       EXPECT_EQ(expected[i].state, record_[i].state) << "Iteration " << i;
 412       EXPECT_EQ(expected[i].bytes_received, record_[i].bytes_received)
 413           << "Iteration " << i;
 414     }
 415   }
 416
 417  private:
 418   virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE {
 419     DCHECK_EQ(download_, download);
 420     DownloadItem::DownloadState state = download->GetState();
 421     int bytes = download->GetReceivedBytes();
 422     if (last_state_.state != state || last_state_.bytes_received > bytes) {
 423       last_state_.state = state;
 424       last_state_.bytes_received = bytes;
 425       record_.push_back(last_state_);
 426     }
 427   }
 428
 429   virtual void OnDownloadDestroyed(DownloadItem* download) OVERRIDE {
 430     DCHECK_EQ(download_, download);
 431     RemoveObserver();
 432   }
 433
 434   void RemoveObserver() {
 435     if (download_) {
 436       download_->RemoveObserver(this);
 437       download_ = NULL;
 438     }
 439   }
 440
 441   DownloadItem* download_;
 442   RecordStruct last_state_;
 443   RecordVector record_;
 444 };
 445
 446 // Get the next created download.
 447 class DownloadCreateObserver : DownloadManager::Observer {
 448  public:
 449   DownloadCreateObserver(DownloadManager* manager)
 450       : manager_(manager),
 451         item_(NULL),
 452         waiting_(false) {
 453     manager_->AddObserver(this);
 454   }
 455
 456   virtual ~DownloadCreateObserver() {
 457     if (manager_)
 458       manager_->RemoveObserver(this);
 459     manager_ = NULL;
 460   }
 461
 462   virtual void ManagerGoingDown(DownloadManager* manager) OVERRIDE {
 463     DCHECK_EQ(manager_, manager);
 464     manager_->RemoveObserver(this);
 465     manager_ = NULL;
 466   }
 467
 468   virtual void OnDownloadCreated(DownloadManager* manager,
 469                                  DownloadItem* download) OVERRIDE {
 470     if (!item_)
 471       item_ = download;
 472
 473     if (waiting_)
 474       base::MessageLoopForUI::current()->Quit();
 475   }
 476
 477   DownloadItem* WaitForFinished() {
 478     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 479     if (!item_) {
 480       waiting_ = true;
 481       RunMessageLoop();
 482       waiting_ = false;
 483     }
 484     return item_;
 485   }
 486
 487  private:
 488   DownloadManager* manager_;
 489   DownloadItem* item_;
 490   bool waiting_;
 491 };
 492
 493
 494 // Filter for waiting for a certain number of bytes.
 495 bool DataReceivedFilter(int number_of_bytes, DownloadItem* download) {
 496   return download->GetReceivedBytes() >= number_of_bytes;
 497 }
 498
 499 // Filter for download completion.
 500 bool DownloadCompleteFilter(DownloadItem* download) {
 501   return download->GetState() == DownloadItem::COMPLETE;
 502 }
 503
 504 // Filter for saving the size of the download when the first IN_PROGRESS
 505 // is hit.
 506 bool InitialSizeFilter(int* download_size, DownloadItem* download) {
 507   if (download->GetState() != DownloadItem::IN_PROGRESS)
 508     return false;
 509
 510   *download_size = download->GetReceivedBytes();
 511   return true;
 512 }
 513
 514 // Request handler to be used with CreateRedirectHandler().
 515 scoped_ptr<net::test_server::HttpResponse> HandleRequestAndSendRedirectResponse(
 516     const std::string& relative_url,
 517     const GURL& target_url,
 518     const net::test_server::HttpRequest& request) {
 519   scoped_ptr<net::test_server::BasicHttpResponse> response;
 520   if (request.relative_url == relative_url) {
 521     response.reset(new net::test_server::BasicHttpResponse);
 522     response->set_code(net::HTTP_FOUND);
 523     response->AddCustomHeader("Location", target_url.spec());
 524   }
 525   return response.PassAs<net::test_server::HttpResponse>();
 526 }
 527
 528 // Creates a request handler for EmbeddedTestServer that responds with a HTTP
 529 // 302 redirect if the request URL matches |relative_url|.
 530 EmbeddedTestServer::HandleRequestCallback CreateRedirectHandler(
 531     const std::string& relative_url,
 532     const GURL& target_url) {
 533   return base::Bind(
 534       &HandleRequestAndSendRedirectResponse, relative_url, target_url);
 535 }
 536
 537 // Request handler to be used with CreateBasicResponseHandler().
 538 scoped_ptr<net::test_server::HttpResponse> HandleRequestAndSendBasicResponse(
 539     const std::string& relative_url,
 540     const std::string& content_type,
 541     const std::string& body,
 542     const net::test_server::HttpRequest& request) {
 543   scoped_ptr<net::test_server::BasicHttpResponse> response;
 544   if (request.relative_url == relative_url) {
 545     response.reset(new net::test_server::BasicHttpResponse);
 546     response->set_content_type(content_type);
 547     response->set_content(body);
 548   }
 549   return response.PassAs<net::test_server::HttpResponse>();
 550 }
 551
 552 // Creates a request handler for an EmbeddedTestServer that response with an
 553 // HTTP 200 status code, a Content-Type header and a body.
 554 EmbeddedTestServer::HandleRequestCallback CreateBasicResponseHandler(
 555     const std::string& relative_url,
 556     const std::string& content_type,
 557     const std::string& body) {
 558   return base::Bind(
 559       &HandleRequestAndSendBasicResponse, relative_url, content_type, body);
 560 }
 561
 562 }  // namespace
 563
 564 class DownloadContentTest : public ContentBrowserTest {
 565  protected:
 566   // An initial send from a website of at least this size will not be
 567   // help up by buffering in the underlying downloads ByteStream data
 568   // transfer.  This is important because on resumption tests we wait
 569   // until we've gotten the data we expect before allowing the test server
 570   // to send its reset, to get around hard close semantics on the Windows
 571   // socket layer implementation.
 572   int GetSafeBufferChunk() const {
 573     return (DownloadResourceHandler::kDownloadByteStreamSize /
 574        ByteStreamWriter::kFractionBufferBeforeSending) + 1;
 575   }
 576
 577   virtual void SetUpOnMainThread() OVERRIDE {
 578     ASSERT_TRUE(downloads_directory_.CreateUniqueTempDir());
 579
 580     test_delegate_.reset(new TestShellDownloadManagerDelegate());
 581     test_delegate_->SetDownloadBehaviorForTesting(downloads_directory_.path());
 582     DownloadManager* manager = DownloadManagerForShell(shell());
 583     manager->GetDelegate()->Shutdown();
 584     manager->SetDelegate(test_delegate_.get());
 585     test_delegate_->SetDownloadManager(manager);
 586
 587     BrowserThread::PostTask(
 588         BrowserThread::IO, FROM_HERE,
 589         base::Bind(&URLRequestSlowDownloadJob::AddUrlHandler));
 590     base::FilePath mock_base(GetTestFilePath("download", ""));
 591     BrowserThread::PostTask(
 592         BrowserThread::IO,
 593         FROM_HERE,
 594         base::Bind(
 595             &net::URLRequestMockHTTPJob::AddUrlHandler,
 596             mock_base,
 597             make_scoped_refptr(content::BrowserThread::GetBlockingPool())));
 598   }
 599
 600   TestShellDownloadManagerDelegate* GetDownloadManagerDelegate() {
 601     return test_delegate_.get();
 602   }
 603
 604   // Create a DownloadTestObserverTerminal that will wait for the
 605   // specified number of downloads to finish.
 606   DownloadTestObserver* CreateWaiter(
 607       Shell* shell, int num_downloads) {
 608     DownloadManager* download_manager = DownloadManagerForShell(shell);
 609     return new DownloadTestObserverTerminal(download_manager, num_downloads,
 610         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
 611   }
 612
 613   // Create a DownloadTestObserverInProgress that will wait for the
 614   // specified number of downloads to start.
 615   DownloadCreateObserver* CreateInProgressWaiter(
 616       Shell* shell, int num_downloads) {
 617     DownloadManager* download_manager = DownloadManagerForShell(shell);
 618     return new DownloadCreateObserver(download_manager);
 619   }
 620
 621   DownloadTestObserver* CreateInterruptedWaiter(
 622       Shell* shell, int num_downloads) {
 623     DownloadManager* download_manager = DownloadManagerForShell(shell);
 624     return new DownloadTestObserverInterrupted(download_manager, num_downloads,
 625         DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
 626   }
 627
 628   // Note: Cannot be used with other alternative DownloadFileFactorys
 629   void SetupEnsureNoPendingDownloads() {
 630     DownloadManagerForShell(shell())->SetDownloadFileFactoryForTesting(
 631         scoped_ptr<DownloadFileFactory>(
 632             new CountingDownloadFileFactory()).Pass());
 633   }
 634
 635   bool EnsureNoPendingDownloads() {
 636     bool result = true;
 637     BrowserThread::PostTask(
 638         BrowserThread::IO, FROM_HERE,
 639         base::Bind(&EnsureNoPendingDownloadJobsOnIO, &result));
 640     base::MessageLoop::current()->Run();
 641     return result &&
 642            (CountingDownloadFile::GetNumberActiveFilesFromFileThread() == 0);
 643   }
 644
 645   void NavigateToURLAndWaitForDownload(
 646       Shell* shell,
 647       const GURL& url,
 648       DownloadItem::DownloadState expected_terminal_state) {
 649     scoped_ptr<DownloadTestObserver> observer(CreateWaiter(shell, 1));
 650     NavigateToURL(shell, url);
 651     observer->WaitForFinished();
 652     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(expected_terminal_state));
 653   }
 654
 655   // Checks that |path| is has |file_size| bytes, and matches the |value|
 656   // string.
 657   bool VerifyFile(const base::FilePath& path,
 658                   const std::string& value,
 659                   const int64 file_size) {
 660     std::string file_contents;
 661
 662     bool read = base::ReadFileToString(path, &file_contents);
 663     EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
 664     if (!read)
 665       return false;  // Couldn't read the file.
 666
 667     // Note: we don't handle really large files (more than size_t can hold)
 668     // so we will fail in that case.
 669     size_t expected_size = static_cast<size_t>(file_size);
 670
 671     // Check the size.
 672     EXPECT_EQ(expected_size, file_contents.size());
 673     if (expected_size != file_contents.size())
 674       return false;
 675
 676     // Check the contents.
 677     EXPECT_EQ(value, file_contents);
 678     if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
 679       return false;
 680
 681     return true;
 682   }
 683
 684   // Start a download and return the item.
 685   DownloadItem* StartDownloadAndReturnItem(GURL url) {
 686     scoped_ptr<DownloadCreateObserver> observer(
 687         CreateInProgressWaiter(shell(), 1));
 688     NavigateToURL(shell(), url);
 689     observer->WaitForFinished();
 690     std::vector<DownloadItem*> downloads;
 691     DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
 692     EXPECT_EQ(1u, downloads.size());
 693     if (1u != downloads.size())
 694       return NULL;
 695     return downloads[0];
 696   }
 697
 698   // Wait for data
 699   void WaitForData(DownloadItem* download, int size) {
 700     DownloadUpdatedObserver data_observer(
 701         download, base::Bind(&DataReceivedFilter, size));
 702     data_observer.WaitForEvent();
 703     ASSERT_EQ(size, download->GetReceivedBytes());
 704     ASSERT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
 705   }
 706
 707   // Tell the test server to release a pending RST and confirm
 708   // that the interrupt is received properly (for download resumption
 709   // testing).
 710   void ReleaseRSTAndConfirmInterruptForResume(DownloadItem* download) {
 711     scoped_ptr<DownloadTestObserver> rst_observer(
 712         CreateInterruptedWaiter(shell(), 1));
 713     NavigateToURL(shell(), test_server()->GetURL("download-finish"));
 714     rst_observer->WaitForFinished();
 715     EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
 716   }
 717
 718   // Confirm file status expected for the given location in a stream
 719   // provided by the resume test server.
 720   void ConfirmFileStatusForResume(
 721       DownloadItem* download, bool file_exists,
 722       int received_bytes, int total_bytes,
 723       const base::FilePath& expected_filename) {
 724     // expected_filename is only known if the file exists.
 725     ASSERT_EQ(file_exists, !expected_filename.empty());
 726     EXPECT_EQ(received_bytes, download->GetReceivedBytes());
 727     EXPECT_EQ(total_bytes, download->GetTotalBytes());
 728     EXPECT_EQ(expected_filename.value(),
 729               download->GetFullPath().BaseName().value());
 730     EXPECT_EQ(file_exists,
 731               (!download->GetFullPath().empty() &&
 732                base::PathExists(download->GetFullPath())));
 733
 734     if (file_exists) {
 735       std::string file_contents;
 736       EXPECT_TRUE(base::ReadFileToString(
 737           download->GetFullPath(), &file_contents));
 738
 739       ASSERT_EQ(static_cast<size_t>(received_bytes), file_contents.size());
 740       for (int i = 0; i < received_bytes; ++i) {
 741         EXPECT_EQ(static_cast<char>((i * 2 + 15) % 256), file_contents[i])
 742             << "File contents diverged at position " << i
 743             << " for " << expected_filename.value();
 744
 745         if (static_cast<char>((i * 2 + 15) % 256) != file_contents[i])
 746           return;
 747       }
 748     }
 749   }
 750
 751  private:
 752   static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
 753     if (URLRequestSlowDownloadJob::NumberOutstandingRequests())
 754       *result = false;
 755     BrowserThread::PostTask(
 756         BrowserThread::UI, FROM_HERE, base::MessageLoop::QuitClosure());
 757   }
 758
 759   // Location of the downloads directory for these tests
 760   base::ScopedTempDir downloads_directory_;
 761   scoped_ptr<TestShellDownloadManagerDelegate> test_delegate_;
 762 };
 763
 764 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadCancelled) {
 765   SetupEnsureNoPendingDownloads();
 766
 767   // Create a download, wait until it's started, and confirm
 768   // we're in the expected state.
 769   scoped_ptr<DownloadCreateObserver> observer(
 770       CreateInProgressWaiter(shell(), 1));
 771   NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
 772   observer->WaitForFinished();
 773
 774   std::vector<DownloadItem*> downloads;
 775   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
 776   ASSERT_EQ(1u, downloads.size());
 777   ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
 778
 779   // Cancel the download and wait for download system quiesce.
 780   downloads[0]->Cancel(true);
 781   scoped_refptr<DownloadTestFlushObserver> flush_observer(
 782       new DownloadTestFlushObserver(DownloadManagerForShell(shell())));
 783   flush_observer->WaitForFlush();
 784
 785   // Get the important info from other threads and check it.
 786   EXPECT_TRUE(EnsureNoPendingDownloads());
 787 }
 788
 789 // Check that downloading multiple (in this case, 2) files does not result in
 790 // corrupted files.
 791 IN_PROC_BROWSER_TEST_F(DownloadContentTest, MultiDownload) {
 792   SetupEnsureNoPendingDownloads();
 793
 794   // Create a download, wait until it's started, and confirm
 795   // we're in the expected state.
 796   scoped_ptr<DownloadCreateObserver> observer1(
 797       CreateInProgressWaiter(shell(), 1));
 798   NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
 799   observer1->WaitForFinished();
 800
 801   std::vector<DownloadItem*> downloads;
 802   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
 803   ASSERT_EQ(1u, downloads.size());
 804   ASSERT_EQ(DownloadItem::IN_PROGRESS, downloads[0]->GetState());
 805   DownloadItem* download1 = downloads[0];  // The only download.
 806
 807   // Start the second download and wait until it's done.
 808   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
 809   GURL url(net::URLRequestMockHTTPJob::GetMockUrl(file));
 810   // Download the file and wait.
 811   NavigateToURLAndWaitForDownload(shell(), url, DownloadItem::COMPLETE);
 812
 813   // Should now have 2 items on the manager.
 814   downloads.clear();
 815   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
 816   ASSERT_EQ(2u, downloads.size());
 817   // We don't know the order of the downloads.
 818   DownloadItem* download2 = downloads[(download1 == downloads[0]) ? 1 : 0];
 819
 820   ASSERT_EQ(DownloadItem::IN_PROGRESS, download1->GetState());
 821   ASSERT_EQ(DownloadItem::COMPLETE, download2->GetState());
 822
 823   // Allow the first request to finish.
 824   scoped_ptr<DownloadTestObserver> observer2(CreateWaiter(shell(), 1));
 825   NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kFinishDownloadUrl));
 826   observer2->WaitForFinished();  // Wait for the third request.
 827   EXPECT_EQ(1u, observer2->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 828
 829   // Get the important info from other threads and check it.
 830   EXPECT_TRUE(EnsureNoPendingDownloads());
 831
 832   // The |DownloadItem|s should now be done and have the final file names.
 833   // Verify that the files have the expected data and size.
 834   // |file1| should be full of '*'s, and |file2| should be the same as the
 835   // source file.
 836   base::FilePath file1(download1->GetTargetFilePath());
 837   size_t file_size1 = URLRequestSlowDownloadJob::kFirstDownloadSize +
 838                       URLRequestSlowDownloadJob::kSecondDownloadSize;
 839   std::string expected_contents(file_size1, '*');
 840   ASSERT_TRUE(VerifyFile(file1, expected_contents, file_size1));
 841
 842   base::FilePath file2(download2->GetTargetFilePath());
 843   ASSERT_TRUE(base::ContentsEqual(
 844       file2, GetTestFilePath("download", "download-test.lib")));
 845 }
 846
 847 #if defined(ENABLE_PLUGINS)
 848 // Content served with a MIME type of application/octet-stream should be
 849 // downloaded even when a plugin can be found that handles the file type.
 850 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadOctetStream) {
 851   const base::FilePath::CharType kTestFilePath[] =
 852       FILE_PATH_LITERAL("octet-stream.abc");
 853   const char kTestPluginName[] = "TestPlugin";
 854   const char kTestMimeType[] = "application/x-test-mime-type";
 855   const char kTestFileType[] = "abc";
 856
 857   WebPluginInfo plugin_info;
 858   plugin_info.name = base::ASCIIToUTF16(kTestPluginName);
 859   plugin_info.mime_types.push_back(
 860       WebPluginMimeType(kTestMimeType, kTestFileType, ""));
 861   PluginServiceImpl::GetInstance()->RegisterInternalPlugin(plugin_info, false);
 862
 863   // The following is served with a Content-Type of application/octet-stream.
 864   GURL url(
 865       net::URLRequestMockHTTPJob::GetMockUrl(base::FilePath(kTestFilePath)));
 866   NavigateToURLAndWaitForDownload(shell(), url, DownloadItem::COMPLETE);
 867 }
 868 #endif
 869
 870 // Try to cancel just before we release the download file, by delaying final
 871 // rename callback.
 872 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelAtFinalRename) {
 873   // Setup new factory.
 874   DownloadFileWithDelayFactory* file_factory =
 875       new DownloadFileWithDelayFactory();
 876   DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
 877   download_manager->SetDownloadFileFactoryForTesting(
 878       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
 879
 880   // Create a download
 881   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
 882   NavigateToURL(shell(), net::URLRequestMockHTTPJob::GetMockUrl(file));
 883
 884   // Wait until the first (intermediate file) rename and execute the callback.
 885   file_factory->WaitForSomeCallback();
 886   std::vector<base::Closure> callbacks;
 887   file_factory->GetAllRenameCallbacks(&callbacks);
 888   ASSERT_EQ(1u, callbacks.size());
 889   callbacks[0].Run();
 890   callbacks.clear();
 891
 892   // Wait until the second (final) rename callback is posted.
 893   file_factory->WaitForSomeCallback();
 894   file_factory->GetAllRenameCallbacks(&callbacks);
 895   ASSERT_EQ(1u, callbacks.size());
 896
 897   // Cancel it.
 898   std::vector<DownloadItem*> items;
 899   download_manager->GetAllDownloads(&items);
 900   ASSERT_EQ(1u, items.size());
 901   items[0]->Cancel(true);
 902   RunAllPendingInMessageLoop();
 903
 904   // Check state.
 905   EXPECT_EQ(DownloadItem::CANCELLED, items[0]->GetState());
 906
 907   // Run final rename callback.
 908   callbacks[0].Run();
 909   callbacks.clear();
 910
 911   // Check state.
 912   EXPECT_EQ(DownloadItem::CANCELLED, items[0]->GetState());
 913 }
 914
 915 // Try to cancel just after we release the download file, by delaying
 916 // in ShouldOpenDownload.
 917 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelAtRelease) {
 918   DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
 919
 920   // Mark delegate for delayed open.
 921   GetDownloadManagerDelegate()->SetDelayedOpen(true);
 922
 923   // Setup new factory.
 924   DownloadFileWithDelayFactory* file_factory =
 925       new DownloadFileWithDelayFactory();
 926   download_manager->SetDownloadFileFactoryForTesting(
 927       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
 928
 929   // Create a download
 930   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
 931   NavigateToURL(shell(), net::URLRequestMockHTTPJob::GetMockUrl(file));
 932
 933   // Wait until the first (intermediate file) rename and execute the callback.
 934   file_factory->WaitForSomeCallback();
 935   std::vector<base::Closure> callbacks;
 936   file_factory->GetAllRenameCallbacks(&callbacks);
 937   ASSERT_EQ(1u, callbacks.size());
 938   callbacks[0].Run();
 939   callbacks.clear();
 940
 941   // Wait until the second (final) rename callback is posted.
 942   file_factory->WaitForSomeCallback();
 943   file_factory->GetAllRenameCallbacks(&callbacks);
 944   ASSERT_EQ(1u, callbacks.size());
 945
 946   // Call it.
 947   callbacks[0].Run();
 948   callbacks.clear();
 949
 950   // Confirm download still IN_PROGRESS (internal state COMPLETING).
 951   std::vector<DownloadItem*> items;
 952   download_manager->GetAllDownloads(&items);
 953   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 954
 955   // Cancel the download; confirm cancel fails.
 956   ASSERT_EQ(1u, items.size());
 957   items[0]->Cancel(true);
 958   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 959
 960   // Need to complete open test.
 961   std::vector<DownloadOpenDelayedCallback> delayed_callbacks;
 962   GetDownloadManagerDelegate()->GetDelayedCallbacks(
 963       &delayed_callbacks);
 964   ASSERT_EQ(1u, delayed_callbacks.size());
 965   delayed_callbacks[0].Run(true);
 966
 967   // *Now* the download should be complete.
 968   EXPECT_EQ(DownloadItem::COMPLETE, items[0]->GetState());
 969 }
 970
 971 // Try to shutdown with a download in progress to make sure shutdown path
 972 // works properly.
 973 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ShutdownInProgress) {
 974   // Create a download that won't complete.
 975   scoped_ptr<DownloadCreateObserver> observer(
 976       CreateInProgressWaiter(shell(), 1));
 977   NavigateToURL(shell(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
 978   observer->WaitForFinished();
 979
 980   // Get the item.
 981   std::vector<DownloadItem*> items;
 982   DownloadManagerForShell(shell())->GetAllDownloads(&items);
 983   ASSERT_EQ(1u, items.size());
 984   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
 985
 986   // Shutdown the download manager and make sure we get the right
 987   // notifications in the right order.
 988   StrictMock<MockDownloadItemObserver> item_observer;
 989   items[0]->AddObserver(&item_observer);
 990   MockDownloadManagerObserver manager_observer(
 991       DownloadManagerForShell(shell()));
 992   // Don't care about ModelChanged() events.
 993   EXPECT_CALL(manager_observer, ModelChanged(_))
 994       .WillRepeatedly(Return());
 995   {
 996     InSequence notifications;
 997
 998     EXPECT_CALL(manager_observer, MockManagerGoingDown(
 999         DownloadManagerForShell(shell())))
1000         .WillOnce(Return());
1001     EXPECT_CALL(item_observer, OnDownloadUpdated(
1002         AllOf(items[0],
1003               Property(&DownloadItem::GetState, DownloadItem::CANCELLED))))
1004         .WillOnce(Return());
1005     EXPECT_CALL(item_observer, OnDownloadDestroyed(items[0]))
1006         .WillOnce(Return());
1007   }
1008
1009   // See http://crbug.com/324525.  If we have a refcount release/post task
1010   // race, the second post will stall the IO thread long enough so that we'll
1011   // lose the race and crash.  The first stall is just to give the UI thread
1012   // a chance to get the second stall onto the IO thread queue after the cancel
1013   // message created by Shutdown and before the notification callback
1014   // created by the IO thread in canceling the request.
1015   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
1016                           base::Bind(&base::PlatformThread::Sleep,
1017                                      base::TimeDelta::FromMilliseconds(25)));
1018   DownloadManagerForShell(shell())->Shutdown();
1019   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
1020                           base::Bind(&base::PlatformThread::Sleep,
1021                                      base::TimeDelta::FromMilliseconds(25)));
1022   items.clear();
1023 }
1024
1025 // Try to shutdown just after we release the download file, by delaying
1026 // release.
1027 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ShutdownAtRelease) {
1028   DownloadManagerImpl* download_manager(DownloadManagerForShell(shell()));
1029
1030   // Mark delegate for delayed open.
1031   GetDownloadManagerDelegate()->SetDelayedOpen(true);
1032
1033   // Setup new factory.
1034   DownloadFileWithDelayFactory* file_factory =
1035       new DownloadFileWithDelayFactory();
1036   download_manager->SetDownloadFileFactoryForTesting(
1037       scoped_ptr<DownloadFileFactory>(file_factory).Pass());
1038
1039   // Create a download
1040   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
1041   NavigateToURL(shell(), net::URLRequestMockHTTPJob::GetMockUrl(file));
1042
1043   // Wait until the first (intermediate file) rename and execute the callback.
1044   file_factory->WaitForSomeCallback();
1045   std::vector<base::Closure> callbacks;
1046   file_factory->GetAllRenameCallbacks(&callbacks);
1047   ASSERT_EQ(1u, callbacks.size());
1048   callbacks[0].Run();
1049   callbacks.clear();
1050
1051   // Wait until the second (final) rename callback is posted.
1052   file_factory->WaitForSomeCallback();
1053   file_factory->GetAllRenameCallbacks(&callbacks);
1054   ASSERT_EQ(1u, callbacks.size());
1055
1056   // Call it.
1057   callbacks[0].Run();
1058   callbacks.clear();
1059
1060   // Confirm download isn't complete yet.
1061   std::vector<DownloadItem*> items;
1062   DownloadManagerForShell(shell())->GetAllDownloads(&items);
1063   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
1064
1065   // Cancel the download; confirm cancel fails anyway.
1066   ASSERT_EQ(1u, items.size());
1067   items[0]->Cancel(true);
1068   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
1069   RunAllPendingInMessageLoop();
1070   EXPECT_EQ(DownloadItem::IN_PROGRESS, items[0]->GetState());
1071
1072   MockDownloadItemObserver observer;
1073   items[0]->AddObserver(&observer);
1074   EXPECT_CALL(observer, OnDownloadDestroyed(items[0]));
1075
1076   // Shutdown the download manager.  Mostly this is confirming a lack of
1077   // crashes.
1078   DownloadManagerForShell(shell())->Shutdown();
1079 }
1080
1081 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeInterruptedDownload) {
1082   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1083       switches::kEnableDownloadResumption);
1084   ASSERT_TRUE(test_server()->Start());
1085
1086   GURL url = test_server()->GetURL(
1087       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
1088                    GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1089
1090   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
1091   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
1092
1093   DownloadItem* download(StartDownloadAndReturnItem(url));
1094   WaitForData(download, GetSafeBufferChunk());
1095   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
1096
1097   // Confirm resumption while in progress doesn't do anything.
1098   download->Resume();
1099   ASSERT_EQ(GetSafeBufferChunk(), download->GetReceivedBytes());
1100   ASSERT_EQ(DownloadItem::IN_PROGRESS, download->GetState());
1101
1102   // Tell the server to send the RST and confirm the interrupt happens.
1103   ReleaseRSTAndConfirmInterruptForResume(download);
1104   ConfirmFileStatusForResume(
1105       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1106       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1107
1108   // Resume, confirming received bytes on resumption is correct.
1109   // Make sure no creation calls are included.
1110   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(0);
1111   int initial_size = 0;
1112   DownloadUpdatedObserver initial_size_observer(
1113       download, base::Bind(&InitialSizeFilter, &initial_size));
1114   download->Resume();
1115   initial_size_observer.WaitForEvent();
1116   EXPECT_EQ(GetSafeBufferChunk(), initial_size);
1117   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
1118
1119   // and wait for expected data.
1120   WaitForData(download, GetSafeBufferChunk() * 2);
1121
1122   // Tell the server to send the RST and confirm the interrupt happens.
1123   ReleaseRSTAndConfirmInterruptForResume(download);
1124   ConfirmFileStatusForResume(
1125       download, true, GetSafeBufferChunk() * 2, GetSafeBufferChunk() * 3,
1126       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1127
1128   // Resume and wait for completion.
1129   DownloadUpdatedObserver completion_observer(
1130       download, base::Bind(DownloadCompleteFilter));
1131   download->Resume();
1132   completion_observer.WaitForEvent();
1133
1134   ConfirmFileStatusForResume(
1135       download, true, GetSafeBufferChunk() * 3, GetSafeBufferChunk() * 3,
1136       base::FilePath(FILE_PATH_LITERAL("rangereset")));
1137
1138   // Confirm resumption while complete doesn't do anything.
1139   download->Resume();
1140   ASSERT_EQ(GetSafeBufferChunk() * 3, download->GetReceivedBytes());
1141   ASSERT_EQ(DownloadItem::COMPLETE, download->GetState());
1142   RunAllPendingInMessageLoop();
1143   ASSERT_EQ(GetSafeBufferChunk() * 3, download->GetReceivedBytes());
1144   ASSERT_EQ(DownloadItem::COMPLETE, download->GetState());
1145 }
1146
1147 // Confirm restart fallback happens if a range request is bounced.
1148 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeInterruptedDownloadNoRange) {
1149   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1150       switches::kEnableDownloadResumption);
1151   ASSERT_TRUE(test_server()->Start());
1152
1153   // Auto-restart if server doesn't handle ranges.
1154   GURL url = test_server()->GetURL(
1155       base::StringPrintf(
1156           // First download hits an RST, rest don't, no ranges.
1157           "rangereset?size=%d&rst_boundary=%d&"
1158           "token=NoRange&rst_limit=1&bounce_range",
1159           GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1160
1161   // Start the download and wait for first data chunk.
1162   DownloadItem* download(StartDownloadAndReturnItem(url));
1163   WaitForData(download, GetSafeBufferChunk());
1164
1165   RecordingDownloadObserver recorder(download);
1166
1167   ReleaseRSTAndConfirmInterruptForResume(download);
1168   ConfirmFileStatusForResume(
1169       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1170       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1171
1172   DownloadUpdatedObserver completion_observer(
1173       download, base::Bind(DownloadCompleteFilter));
1174   download->Resume();
1175   completion_observer.WaitForEvent();
1176
1177   ConfirmFileStatusForResume(
1178       download, true, GetSafeBufferChunk() * 3, GetSafeBufferChunk() * 3,
1179       base::FilePath(FILE_PATH_LITERAL("rangereset")));
1180
1181   static const RecordingDownloadObserver::RecordStruct expected_record[] = {
1182     // Result of RST
1183     {DownloadItem::INTERRUPTED, GetSafeBufferChunk()},
1184     // Starting continuation
1185     {DownloadItem::IN_PROGRESS, GetSafeBufferChunk()},
1186     // Notification of receiving whole file.
1187     {DownloadItem::IN_PROGRESS, 0},
1188     // Completion.
1189     {DownloadItem::COMPLETE, GetSafeBufferChunk() * 3},
1190   };
1191
1192   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
1193 }
1194
1195 // Confirm restart fallback happens if a precondition is failed.
1196 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
1197                        ResumeInterruptedDownloadBadPrecondition) {
1198   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1199       switches::kEnableDownloadResumption);
1200   ASSERT_TRUE(test_server()->Start());
1201
1202   GURL url = test_server()->GetURL(base::StringPrintf(
1203       // First download hits an RST, rest don't, precondition fail.
1204       "rangereset?size=%d&rst_boundary=%d&"
1205       "token=BadPrecondition&rst_limit=1&fail_precondition=2",
1206       GetSafeBufferChunk() * 3,
1207       GetSafeBufferChunk()));
1208
1209   // Start the download and wait for first data chunk.
1210   DownloadItem* download(StartDownloadAndReturnItem(url));
1211   WaitForData(download, GetSafeBufferChunk());
1212
1213   RecordingDownloadObserver recorder(download);
1214
1215   ReleaseRSTAndConfirmInterruptForResume(download);
1216   ConfirmFileStatusForResume(
1217       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1218       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1219   EXPECT_EQ("BadPrecondition2", download->GetETag());
1220
1221   DownloadUpdatedObserver completion_observer(
1222       download, base::Bind(DownloadCompleteFilter));
1223   download->Resume();
1224   completion_observer.WaitForEvent();
1225
1226   ConfirmFileStatusForResume(
1227       download, true, GetSafeBufferChunk() * 3, GetSafeBufferChunk() * 3,
1228       base::FilePath(FILE_PATH_LITERAL("rangereset")));
1229   EXPECT_EQ("BadPrecondition0", download->GetETag());
1230
1231   static const RecordingDownloadObserver::RecordStruct expected_record[] = {
1232     // Result of RST
1233     {DownloadItem::INTERRUPTED, GetSafeBufferChunk()},
1234     // Starting continuation
1235     {DownloadItem::IN_PROGRESS, GetSafeBufferChunk()},
1236     // Server precondition fail.
1237     {DownloadItem::INTERRUPTED, 0},
1238     // Notification of successful restart.
1239     {DownloadItem::IN_PROGRESS, 0},
1240     // Completion.
1241     {DownloadItem::COMPLETE, GetSafeBufferChunk() * 3},
1242   };
1243
1244   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
1245 }
1246
1247 // Confirm we don't try to resume if we don't have a verifier.
1248 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
1249                        ResumeInterruptedDownloadNoVerifiers) {
1250   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1251       switches::kEnableDownloadResumption);
1252   ASSERT_TRUE(test_server()->Start());
1253
1254   GURL url = test_server()->GetURL(
1255       base::StringPrintf(
1256           // First download hits an RST, rest don't, no verifiers.
1257           "rangereset?size=%d&rst_boundary=%d&"
1258           "token=NoRange&rst_limit=1&no_verifiers",
1259           GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1260
1261   // Start the download and wait for first data chunk.
1262   DownloadItem* download(StartDownloadAndReturnItem(url));
1263   WaitForData(download, GetSafeBufferChunk());
1264
1265   RecordingDownloadObserver recorder(download);
1266
1267   ReleaseRSTAndConfirmInterruptForResume(download);
1268   ConfirmFileStatusForResume(
1269       download, false, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1270       base::FilePath());
1271
1272   DownloadUpdatedObserver completion_observer(
1273       download, base::Bind(DownloadCompleteFilter));
1274   download->Resume();
1275   completion_observer.WaitForEvent();
1276
1277   ConfirmFileStatusForResume(
1278       download, true, GetSafeBufferChunk() * 3, GetSafeBufferChunk() * 3,
1279       base::FilePath(FILE_PATH_LITERAL("rangereset")));
1280
1281   static const RecordingDownloadObserver::RecordStruct expected_record[] = {
1282     // Result of RST
1283     {DownloadItem::INTERRUPTED, GetSafeBufferChunk()},
1284     // Restart for lack of verifiers
1285     {DownloadItem::IN_PROGRESS, 0},
1286     // Completion.
1287     {DownloadItem::COMPLETE, GetSafeBufferChunk() * 3},
1288   };
1289
1290   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
1291 }
1292
1293 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeWithDeletedFile) {
1294   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1295       switches::kEnableDownloadResumption);
1296   ASSERT_TRUE(test_server()->Start());
1297
1298   GURL url = test_server()->GetURL(
1299       base::StringPrintf(
1300           // First download hits an RST, rest don't
1301           "rangereset?size=%d&rst_boundary=%d&"
1302           "token=NoRange&rst_limit=1",
1303           GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1304
1305   // Start the download and wait for first data chunk.
1306   DownloadItem* download(StartDownloadAndReturnItem(url));
1307   WaitForData(download, GetSafeBufferChunk());
1308
1309   RecordingDownloadObserver recorder(download);
1310
1311   ReleaseRSTAndConfirmInterruptForResume(download);
1312   ConfirmFileStatusForResume(
1313       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1314       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1315
1316   // Delete the intermediate file.
1317   base::DeleteFile(download->GetFullPath(), false);
1318
1319   DownloadUpdatedObserver completion_observer(
1320       download, base::Bind(DownloadCompleteFilter));
1321   download->Resume();
1322   completion_observer.WaitForEvent();
1323
1324   ConfirmFileStatusForResume(
1325       download, true, GetSafeBufferChunk() * 3, GetSafeBufferChunk() * 3,
1326       base::FilePath(FILE_PATH_LITERAL("rangereset")));
1327
1328   static const RecordingDownloadObserver::RecordStruct expected_record[] = {
1329     // Result of RST
1330     {DownloadItem::INTERRUPTED, GetSafeBufferChunk()},
1331     // Starting continuation
1332     {DownloadItem::IN_PROGRESS, GetSafeBufferChunk()},
1333     // Error because file isn't there.
1334     {DownloadItem::INTERRUPTED, 0},
1335     // Restart.
1336     {DownloadItem::IN_PROGRESS, 0},
1337     // Completion.
1338     {DownloadItem::COMPLETE, GetSafeBufferChunk() * 3},
1339   };
1340
1341   recorder.CompareToExpectedRecord(expected_record, arraysize(expected_record));
1342 }
1343
1344 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeWithFileInitError) {
1345   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1346       switches::kEnableDownloadResumption);
1347   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
1348   GURL url(net::URLRequestMockHTTPJob::GetMockUrl(file));
1349
1350   // Setup the error injector.
1351   scoped_refptr<TestFileErrorInjector> injector(
1352       TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
1353
1354   TestFileErrorInjector::FileErrorInfo err = {
1355     url.spec(),
1356     TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
1357     0,
1358     DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE
1359   };
1360   injector->AddError(err);
1361   injector->InjectErrors();
1362
1363   // Start and watch for interrupt.
1364   scoped_ptr<DownloadTestObserver> int_observer(
1365       CreateInterruptedWaiter(shell(), 1));
1366   DownloadItem* download(StartDownloadAndReturnItem(url));
1367   int_observer->WaitForFinished();
1368   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
1369   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1370             download->GetLastReason());
1371   EXPECT_EQ(0, download->GetReceivedBytes());
1372   EXPECT_TRUE(download->GetFullPath().empty());
1373   EXPECT_TRUE(download->GetTargetFilePath().empty());
1374
1375   // We need to make sure that any cross-thread downloads communication has
1376   // quiesced before clearing and injecting the new errors, as the
1377   // InjectErrors() routine alters the currently in use download file
1378   // factory, which is a file thread object.
1379   RunAllPendingInMessageLoop(BrowserThread::FILE);
1380   RunAllPendingInMessageLoop();
1381
1382   // Clear the old errors list.
1383   injector->ClearErrors();
1384   injector->InjectErrors();
1385
1386   // Resume and watch completion.
1387   DownloadUpdatedObserver completion_observer(
1388       download, base::Bind(DownloadCompleteFilter));
1389   download->Resume();
1390   completion_observer.WaitForEvent();
1391   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
1392 }
1393
1394 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
1395                        ResumeWithFileIntermediateRenameError) {
1396   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1397       switches::kEnableDownloadResumption);
1398   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
1399   GURL url(net::URLRequestMockHTTPJob::GetMockUrl(file));
1400
1401   // Setup the error injector.
1402   scoped_refptr<TestFileErrorInjector> injector(
1403       TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
1404
1405   TestFileErrorInjector::FileErrorInfo err = {
1406     url.spec(),
1407     TestFileErrorInjector::FILE_OPERATION_RENAME_UNIQUIFY,
1408     0,
1409     DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE
1410   };
1411   injector->AddError(err);
1412   injector->InjectErrors();
1413
1414   // Start and watch for interrupt.
1415   scoped_ptr<DownloadTestObserver> int_observer(
1416       CreateInterruptedWaiter(shell(), 1));
1417   DownloadItem* download(StartDownloadAndReturnItem(url));
1418   int_observer->WaitForFinished();
1419   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
1420   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1421             download->GetLastReason());
1422   EXPECT_TRUE(download->GetFullPath().empty());
1423   // Target path will have been set after file name determination. GetFullPath()
1424   // being empty is sufficient to signal that filename determination needs to be
1425   // redone.
1426   EXPECT_FALSE(download->GetTargetFilePath().empty());
1427
1428   // We need to make sure that any cross-thread downloads communication has
1429   // quiesced before clearing and injecting the new errors, as the
1430   // InjectErrors() routine alters the currently in use download file
1431   // factory, which is a file thread object.
1432   RunAllPendingInMessageLoop(BrowserThread::FILE);
1433   RunAllPendingInMessageLoop();
1434
1435   // Clear the old errors list.
1436   injector->ClearErrors();
1437   injector->InjectErrors();
1438
1439   // Resume and watch completion.
1440   DownloadUpdatedObserver completion_observer(
1441       download, base::Bind(DownloadCompleteFilter));
1442   download->Resume();
1443   completion_observer.WaitForEvent();
1444   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
1445 }
1446
1447 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeWithFileFinalRenameError) {
1448   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1449       switches::kEnableDownloadResumption);
1450   base::FilePath file(FILE_PATH_LITERAL("download-test.lib"));
1451   GURL url(net::URLRequestMockHTTPJob::GetMockUrl(file));
1452
1453   // Setup the error injector.
1454   scoped_refptr<TestFileErrorInjector> injector(
1455       TestFileErrorInjector::Create(DownloadManagerForShell(shell())));
1456
1457   DownloadManagerForShell(shell())->RemoveAllDownloads();
1458   TestFileErrorInjector::FileErrorInfo err = {
1459     url.spec(),
1460     TestFileErrorInjector::FILE_OPERATION_RENAME_ANNOTATE,
1461     0,
1462     DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE
1463   };
1464   injector->AddError(err);
1465   injector->InjectErrors();
1466
1467   // Start and watch for interrupt.
1468   scoped_ptr<DownloadTestObserver> int_observer(
1469       CreateInterruptedWaiter(shell(), 1));
1470   DownloadItem* download(StartDownloadAndReturnItem(url));
1471   int_observer->WaitForFinished();
1472   ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
1473   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1474             download->GetLastReason());
1475   EXPECT_TRUE(download->GetFullPath().empty());
1476   // Target path should still be intact.
1477   EXPECT_FALSE(download->GetTargetFilePath().empty());
1478
1479   // We need to make sure that any cross-thread downloads communication has
1480   // quiesced before clearing and injecting the new errors, as the
1481   // InjectErrors() routine alters the currently in use download file
1482   // factory, which is a file thread object.
1483   RunAllPendingInMessageLoop(BrowserThread::FILE);
1484   RunAllPendingInMessageLoop();
1485
1486   // Clear the old errors list.
1487   injector->ClearErrors();
1488   injector->InjectErrors();
1489
1490   // Resume and watch completion.
1491   DownloadUpdatedObserver completion_observer(
1492       download, base::Bind(DownloadCompleteFilter));
1493   download->Resume();
1494   completion_observer.WaitForEvent();
1495   EXPECT_EQ(download->GetState(), DownloadItem::COMPLETE);
1496 }
1497
1498 // An interrupted download should remove the intermediate file when it is
1499 // cancelled.
1500 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelInterruptedDownload) {
1501   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1502       switches::kEnableDownloadResumption);
1503   ASSERT_TRUE(test_server()->Start());
1504
1505   GURL url1 = test_server()->GetURL(
1506       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
1507                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1508
1509   DownloadItem* download(StartDownloadAndReturnItem(url1));
1510   WaitForData(download, GetSafeBufferChunk());
1511
1512   ReleaseRSTAndConfirmInterruptForResume(download);
1513   ConfirmFileStatusForResume(
1514       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1515       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1516
1517   base::FilePath intermediate_path(download->GetFullPath());
1518   ASSERT_FALSE(intermediate_path.empty());
1519   EXPECT_TRUE(base::PathExists(intermediate_path));
1520
1521   download->Cancel(true /* user_cancel */);
1522   RunAllPendingInMessageLoop(BrowserThread::FILE);
1523   RunAllPendingInMessageLoop();
1524
1525   // The intermediate file should now be gone.
1526   EXPECT_FALSE(base::PathExists(intermediate_path));
1527   EXPECT_TRUE(download->GetFullPath().empty());
1528 }
1529
1530 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveDownload) {
1531   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1532       switches::kEnableDownloadResumption);
1533   ASSERT_TRUE(test_server()->Start());
1534
1535   // An interrupted download should remove the intermediate file when it is
1536   // removed.
1537   {
1538     GURL url1 = test_server()->GetURL(
1539         base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
1540                            GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1541
1542     DownloadItem* download(StartDownloadAndReturnItem(url1));
1543     WaitForData(download, GetSafeBufferChunk());
1544     ReleaseRSTAndConfirmInterruptForResume(download);
1545     ConfirmFileStatusForResume(
1546         download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1547         base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1548
1549     base::FilePath intermediate_path(download->GetFullPath());
1550     ASSERT_FALSE(intermediate_path.empty());
1551     EXPECT_TRUE(base::PathExists(intermediate_path));
1552
1553     download->Remove();
1554     RunAllPendingInMessageLoop(BrowserThread::FILE);
1555     RunAllPendingInMessageLoop();
1556
1557     // The intermediate file should now be gone.
1558     EXPECT_FALSE(base::PathExists(intermediate_path));
1559   }
1560
1561   // A completed download shouldn't delete the downloaded file when it is
1562   // removed.
1563   {
1564     // Start the second download and wait until it's done.
1565     base::FilePath file2(FILE_PATH_LITERAL("download-test.lib"));
1566     GURL url2(net::URLRequestMockHTTPJob::GetMockUrl(file2));
1567     scoped_ptr<DownloadTestObserver> completion_observer(
1568         CreateWaiter(shell(), 1));
1569     DownloadItem* download(StartDownloadAndReturnItem(url2));
1570     completion_observer->WaitForFinished();
1571
1572     // The target path should exist.
1573     base::FilePath target_path(download->GetTargetFilePath());
1574     EXPECT_TRUE(base::PathExists(target_path));
1575     download->Remove();
1576     RunAllPendingInMessageLoop(BrowserThread::FILE);
1577     RunAllPendingInMessageLoop();
1578
1579     // The file should still exist.
1580     EXPECT_TRUE(base::PathExists(target_path));
1581   }
1582 }
1583
1584 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RemoveResumingDownload) {
1585   SetupEnsureNoPendingDownloads();
1586   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1587       switches::kEnableDownloadResumption);
1588   ASSERT_TRUE(test_server()->Start());
1589
1590   GURL url = test_server()->GetURL(
1591       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
1592                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1593
1594   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
1595   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
1596
1597   DownloadItem* download(StartDownloadAndReturnItem(url));
1598   WaitForData(download, GetSafeBufferChunk());
1599   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
1600
1601   // Tell the server to send the RST and confirm the interrupt happens.
1602   ReleaseRSTAndConfirmInterruptForResume(download);
1603   ConfirmFileStatusForResume(
1604       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1605       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1606
1607   base::FilePath intermediate_path(download->GetFullPath());
1608   ASSERT_FALSE(intermediate_path.empty());
1609   EXPECT_TRUE(base::PathExists(intermediate_path));
1610
1611   // Resume and remove download. We expect only a single OnDownloadCreated()
1612   // call, and that's for the second download created below.
1613   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
1614   download->Resume();
1615   download->Remove();
1616
1617   // The intermediate file should now be gone.
1618   RunAllPendingInMessageLoop(BrowserThread::FILE);
1619   RunAllPendingInMessageLoop();
1620   EXPECT_FALSE(base::PathExists(intermediate_path));
1621
1622   // Start the second download and wait until it's done. The test server is
1623   // single threaded. The response to this download request should follow the
1624   // response to the previous resumption request.
1625   GURL url2(test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
1626   NavigateToURLAndWaitForDownload(shell(), url2, DownloadItem::COMPLETE);
1627
1628   EXPECT_TRUE(EnsureNoPendingDownloads());
1629 }
1630
1631 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CancelResumingDownload) {
1632   SetupEnsureNoPendingDownloads();
1633   base::CommandLine::ForCurrentProcess()->AppendSwitch(
1634       switches::kEnableDownloadResumption);
1635   ASSERT_TRUE(test_server()->Start());
1636
1637   GURL url = test_server()->GetURL(
1638       base::StringPrintf("rangereset?size=%d&rst_boundary=%d",
1639                          GetSafeBufferChunk() * 3, GetSafeBufferChunk()));
1640
1641   MockDownloadManagerObserver dm_observer(DownloadManagerForShell(shell()));
1642   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
1643
1644   DownloadItem* download(StartDownloadAndReturnItem(url));
1645   WaitForData(download, GetSafeBufferChunk());
1646   ::testing::Mock::VerifyAndClearExpectations(&dm_observer);
1647
1648   // Tell the server to send the RST and confirm the interrupt happens.
1649   ReleaseRSTAndConfirmInterruptForResume(download);
1650   ConfirmFileStatusForResume(
1651       download, true, GetSafeBufferChunk(), GetSafeBufferChunk() * 3,
1652       base::FilePath(FILE_PATH_LITERAL("rangereset.crdownload")));
1653
1654   base::FilePath intermediate_path(download->GetFullPath());
1655   ASSERT_FALSE(intermediate_path.empty());
1656   EXPECT_TRUE(base::PathExists(intermediate_path));
1657
1658   // Resume and cancel download. We expect only a single OnDownloadCreated()
1659   // call, and that's for the second download created below.
1660   EXPECT_CALL(dm_observer, OnDownloadCreated(_,_)).Times(1);
1661   download->Resume();
1662   download->Cancel(true);
1663
1664   // The intermediate file should now be gone.
1665   RunAllPendingInMessageLoop(BrowserThread::FILE);
1666   RunAllPendingInMessageLoop();
1667   EXPECT_FALSE(base::PathExists(intermediate_path));
1668   EXPECT_TRUE(download->GetFullPath().empty());
1669
1670   // Start the second download and wait until it's done. The test server is
1671   // single threaded. The response to this download request should follow the
1672   // response to the previous resumption request.
1673   GURL url2(test_server()->GetURL("rangereset?size=100&rst_limit=0&token=x"));
1674   NavigateToURLAndWaitForDownload(shell(), url2, DownloadItem::COMPLETE);
1675
1676   EXPECT_TRUE(EnsureNoPendingDownloads());
1677 }
1678
1679 // Check that the cookie policy is correctly updated when downloading a file
1680 // that redirects cross origin.
1681 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CookiePolicy) {
1682   ASSERT_TRUE(test_server()->Start());
1683   net::HostPortPair host_port = test_server()->host_port_pair();
1684   DCHECK_EQ(host_port.host(), std::string("127.0.0.1"));
1685
1686   // Block third-party cookies.
1687   ShellNetworkDelegate::SetAcceptAllCookies(false);
1688
1689   // |url| redirects to a different origin |download| which tries to set a
1690   // cookie.
1691   std::string download(base::StringPrintf(
1692       "http://localhost:%d/set-cookie?A=B", host_port.port()));
1693   GURL url(test_server()->GetURL("server-redirect?" + download));
1694
1695   // Download the file.
1696   SetupEnsureNoPendingDownloads();
1697   scoped_ptr<DownloadUrlParameters> dl_params(
1698       DownloadUrlParameters::FromWebContents(shell()->web_contents(), url));
1699   scoped_ptr<DownloadTestObserver> observer(CreateWaiter(shell(), 1));
1700   DownloadManagerForShell(shell())->DownloadUrl(dl_params.Pass());
1701   observer->WaitForFinished();
1702
1703   // Get the important info from other threads and check it.
1704   EXPECT_TRUE(EnsureNoPendingDownloads());
1705
1706   std::vector<DownloadItem*> downloads;
1707   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
1708   ASSERT_EQ(1u, downloads.size());
1709   ASSERT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
1710
1711   // Check that the cookies were correctly set.
1712   EXPECT_EQ("A=B",
1713             content::GetCookies(shell()->web_contents()->GetBrowserContext(),
1714                                 GURL(download)));
1715 }
1716
1717 // A filename suggestion specified via a @download attribute should not be
1718 // effective if the final download URL is in another origin from the original
1719 // download URL.
1720 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
1721                        DownloadAttributeCrossOriginRedirect) {
1722   EmbeddedTestServer origin_one;
1723   EmbeddedTestServer origin_two;
1724   ASSERT_TRUE(origin_one.InitializeAndWaitUntilReady());
1725   ASSERT_TRUE(origin_two.InitializeAndWaitUntilReady());
1726
1727   // The download-attribute.html page contains an anchor element whose href is
1728   // set to the value of the query parameter (specified as |target| in the URL
1729   // below). The suggested filename for the anchor is 'suggested-filename'. When
1730   // the page is loaded, a script simulates a click on the anchor, triggering a
1731   // download of the target URL.
1732   //
1733   // We construct two test servers; origin_one and origin_two. Once started, the
1734   // server URLs will differ by the port number. Therefore they will be in
1735   // different origins.
1736   GURL download_url = origin_one.GetURL("/ping");
1737   GURL referrer_url = origin_one.GetURL(
1738       std::string("/download-attribute.html?target=") + download_url.spec());
1739
1740   // <origin_one>/download-attribute.html initiates a download of
1741   // <origin_one>/ping, which redirects to <origin_two>/download.
1742   origin_one.ServeFilesFromDirectory(GetTestFilePath("download", ""));
1743   origin_one.RegisterRequestHandler(
1744       CreateRedirectHandler("/ping", origin_two.GetURL("/download")));
1745   origin_two.RegisterRequestHandler(CreateBasicResponseHandler(
1746       "/download", "application/octet-stream", "Hello"));
1747
1748   NavigateToURLAndWaitForDownload(
1749       shell(), referrer_url, DownloadItem::COMPLETE);
1750
1751   std::vector<DownloadItem*> downloads;
1752   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
1753   ASSERT_EQ(1u, downloads.size());
1754
1755   EXPECT_EQ(FILE_PATH_LITERAL("download"),
1756             downloads[0]->GetTargetFilePath().BaseName().value());
1757   ASSERT_TRUE(origin_one.ShutdownAndWaitUntilComplete());
1758   ASSERT_TRUE(origin_two.ShutdownAndWaitUntilComplete());
1759 }
1760
1761 // A filename suggestion specified via a @download attribute should be effective
1762 // if the final download URL is in the same origin as the initial download URL.
1763 // Test that this holds even if there are cross origin redirects in the middle
1764 // of the redirect chain.
1765 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
1766                        DownloadAttributeSameOriginRedirect) {
1767   EmbeddedTestServer origin_one;
1768   EmbeddedTestServer origin_two;
1769   ASSERT_TRUE(origin_one.InitializeAndWaitUntilReady());
1770   ASSERT_TRUE(origin_two.InitializeAndWaitUntilReady());
1771
1772   // The download-attribute.html page contains an anchor element whose href is
1773   // set to the value of the query parameter (specified as |target| in the URL
1774   // below). The suggested filename for the anchor is 'suggested-filename'. When
1775   // the page is loaded, a script simulates a click on the anchor, triggering a
1776   // download of the target URL.
1777   //
1778   // We construct two test servers; origin_one and origin_two. Once started, the
1779   // server URLs will differ by the port number. Therefore they will be in
1780   // different origins.
1781   GURL download_url = origin_one.GetURL("/ping");
1782   GURL referrer_url = origin_one.GetURL(
1783       std::string("/download-attribute.html?target=") + download_url.spec());
1784   origin_one.ServeFilesFromDirectory(GetTestFilePath("download", ""));
1785
1786   // <origin_one>/download-attribute.html initiates a download of
1787   // <origin_one>/ping, which redirects to <origin_two>/pong, and then finally
1788   // to <origin_one>/download.
1789   origin_one.RegisterRequestHandler(
1790       CreateRedirectHandler("/ping", origin_two.GetURL("/pong")));
1791   origin_two.RegisterRequestHandler(
1792       CreateRedirectHandler("/pong", origin_one.GetURL("/download")));
1793   origin_one.RegisterRequestHandler(CreateBasicResponseHandler(
1794       "/download", "application/octet-stream", "Hello"));
1795
1796   NavigateToURLAndWaitForDownload(
1797       shell(), referrer_url, DownloadItem::COMPLETE);
1798
1799   std::vector<DownloadItem*> downloads;
1800   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
1801   ASSERT_EQ(1u, downloads.size());
1802
1803   EXPECT_EQ(FILE_PATH_LITERAL("suggested-filename"),
1804             downloads[0]->GetTargetFilePath().BaseName().value());
1805   ASSERT_TRUE(origin_one.ShutdownAndWaitUntilComplete());
1806   ASSERT_TRUE(origin_two.ShutdownAndWaitUntilComplete());
1807 }
1808
1809 // The file empty.bin is served with a MIME type of application/octet-stream.
1810 // The content body is empty. Make sure this case is handled properly and we
1811 // don't regress on http://crbug.com/320394.
1812 IN_PROC_BROWSER_TEST_F(DownloadContentTest, DownloadGZipWithNoContent) {
1813   EmbeddedTestServer test_server;
1814   ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
1815
1816   GURL url = test_server.GetURL("/empty.bin");
1817   test_server.ServeFilesFromDirectory(GetTestFilePath("download", ""));
1818
1819   NavigateToURLAndWaitForDownload(shell(), url, DownloadItem::COMPLETE);
1820   // That's it. This should work without crashing.
1821 }
1822
1823 }  // namespace content