[Downloads] Always call DM::StartDownload() for explicit downloads.

content/browser/download/download_item_impl_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/mock_download_file.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_destination_observer.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_download_item.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/web_contents_tester.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ skipping 52 matching lines @@
 class MockRequestHandle : public DownloadRequestHandleInterface {
  public:
   MOCK_CONST_METHOD0(GetWebContents, WebContents*());
   MOCK_CONST_METHOD0(GetDownloadManager, DownloadManager*());
   MOCK_CONST_METHOD0(PauseRequest, void());
   MOCK_CONST_METHOD0(ResumeRequest, void());
   MOCK_CONST_METHOD0(CancelRequest, void());
   MOCK_CONST_METHOD0(DebugString, std::string());
 };
 
-// Schedules a task to invoke the RenameCompletionCallback with |new_path| on
-// the UI thread. Should only be used as the action for
+// Schedules a task to invoke the DownloadFile::RenameCompletionCallback with
+// |new_path| on the UI thread. Should only be used as the action for
 // MockDownloadFile::Rename as follows:
+//
 //   EXPECT_CALL(download_file, Rename*(_,_))
 //       .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
 //                                        new_path));
 ACTION_P2(ScheduleRenameCallback, interrupt_reason, new_path) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(arg1, interrupt_reason, new_path));
 }
 
+// Schedules a task to invoke DownloadFile::InitializedCallback with
+// |interrupt_reason| on the UI thread. Should be used as the action for
+// MockDownloadFile::Initialize as follows:
+//   EXPECT_CALL(download_file, Initialize(_))
+//       .WillOnce(ScheduleInitializeCallback(DOWNLOAD_INTERRUPT_REASON_NONE));
+ACTION_P(ScheduleInitializeCallback, interrupt_reason) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE, base::Bind(arg0, interrupt_reason));
+}
+
 }  // namespace
 
 class DownloadItemTest : public testing::Test {
  public:
   class MockObserver : public DownloadItem::Observer {
    public:
     explicit MockObserver(DownloadItem* item)
       : item_(item),
         last_state_(item->GetState()),
         removed_(false),
@@ skipping 69 matching lines @@
     DownloadItem* item_;
     DownloadItem::DownloadState last_state_;
     bool removed_;
     bool destroyed_;
     bool updated_;
     int interrupt_count_;
     int resume_count_;
   };
 
   DownloadItemTest()
-      : ui_thread_(BrowserThread::UI, &loop_),
-        file_thread_(BrowserThread::FILE, &loop_),
-        delegate_() {
+      : delegate_(),
+        next_download_id_(DownloadItem::kInvalidId + 1) {
+    create_info_.reset(new DownloadCreateInfo());
+    create_info_->save_info =
+        scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo());
+    create_info_->save_info->prompt_for_save_location = false;
+    create_info_->url_chain.push_back(GURL());
+    create_info_->etag = "SomethingToSatisfyResumption";
   }
 
   ~DownloadItemTest() {
   }
 
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
-    ui_thread_.DeprecatedGetThreadObject()->message_loop()->RunUntilIdle();
+    base::RunLoop run_loop;
+    run_loop.RunUntilIdle();
     STLDeleteElements(&allocated_downloads_);
     allocated_downloads_.clear();
   }
 
   // This class keeps ownership of the created download item; it will
   // be torn down at the end of the test unless DestroyDownloadItem is
   // called.
   DownloadItemImpl* CreateDownloadItem() {
-    // Normally, the download system takes ownership of info, and is
-    // responsible for deleting it.  In these unit tests, however, we
-    // don't call the function that deletes it, so we do so ourselves.
-    scoped_ptr<DownloadCreateInfo> info_;
-
-    info_.reset(new DownloadCreateInfo());
-    static uint32 next_id = DownloadItem::kInvalidId + 1;
-    info_->save_info = scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo());
-    info_->save_info->prompt_for_save_location = false;
-    info_->url_chain.push_back(GURL());
-    info_->etag = "SomethingToSatisfyResumption";
-
-    DownloadItemImpl* download =
-        new DownloadItemImpl(
-            &delegate_, next_id++, *(info_.get()), net::BoundNetLog());
+    create_info_->download_id = ++next_download_id_;
+    DownloadItemImpl* download = new DownloadItemImpl(&delegate_,
+                                                      create_info_->download_id,
+                                                      *create_info_,
+                                                      net::BoundNetLog());
     allocated_downloads_.insert(download);
     return download;
   }
 
   // Add DownloadFile to DownloadItem
   MockDownloadFile* AddDownloadFileToDownloadItem(
       DownloadItemImpl* item,
       DownloadItemImplDelegate::DownloadTargetCallback *callback) {
-    MockDownloadFile* mock_download_file(new StrictMock<MockDownloadFile>);
-    scoped_ptr<DownloadFile> download_file(mock_download_file);
-    EXPECT_CALL(*mock_download_file, Initialize(_));
+    MockDownloadFile* mock_download_file = NULL;
+    scoped_ptr<DownloadFile> download_file;
     if (callback) {
       // Save the callback.
       EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
           .WillOnce(SaveArg<1>(callback));
     } else {
       // Drop it on the floor.
       EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _));
     }
 
-    scoped_ptr<DownloadRequestHandleInterface> request_handle(
+    // Only create a DownloadFile if the request was successful.
+    if (create_info_->interrupt_reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
+      mock_download_file = new StrictMock<MockDownloadFile>;
+      download_file.reset(mock_download_file);
+      EXPECT_CALL(*mock_download_file, Initialize(_))
+          .WillOnce(ScheduleInitializeCallback(DOWNLOAD_INTERRUPT_REASON_NONE));
+      EXPECT_CALL(*mock_download_file, FullPath())
+          .WillRepeatedly(Return(base::FilePath()));
+    }
+
+    scoped_ptr<MockRequestHandle> request_handle(
         new NiceMock<MockRequestHandle>);
-    item->Start(download_file.Pass(), request_handle.Pass());
-    loop_.RunUntilIdle();
+    EXPECT_CALL(*request_handle, GetWebContents())
+        .WillRepeatedly(Return(GetWebContents()));
+    item->Start(download_file.Pass(),
+                request_handle.PassAs<DownloadRequestHandleInterface>(),
+                *create_info_);
+    base::RunLoop().RunUntilIdle();
 
     // So that we don't have a function writing to a stack variable
     // lying around if the above failed.
     mock_delegate()->VerifyAndClearExpectations();
     EXPECT_CALL(*mock_delegate(), AssertStateConsistent(_))
         .WillRepeatedly(Return());
     EXPECT_CALL(*mock_delegate(), ShouldOpenFileBasedOnExtension(_))
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(_, _))
         .WillRepeatedly(Return(true));
@@ skipping 26 matching lines @@
   // Cleanup a download item (specifically get rid of the DownloadFile on it).
   // The item must be in the expected state.
   void CleanupItem(DownloadItemImpl* item,
                    MockDownloadFile* download_file,
                    DownloadItem::DownloadState expected_state) {
     EXPECT_EQ(expected_state, item->GetState());
 
     if (expected_state == DownloadItem::IN_PROGRESS) {
       EXPECT_CALL(*download_file, Cancel());
       item->Cancel(true);
-      loop_.RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
   }
 
   // Destroy a previously created download item.
   void DestroyDownloadItem(DownloadItem* item) {
     allocated_downloads_.erase(item);
     delete item;
   }
 
   void RunAllPendingInMessageLoops() {
-    loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   MockDelegate* mock_delegate() {
     return &delegate_;
   }
 
   void OnDownloadFileAcquired(base::FilePath* return_path,
                               const base::FilePath& path) {
     *return_path = path;
   }
 
+  DownloadCreateInfo* create_info() {
+    return create_info_.get();
+  }
+
+  virtual WebContents* GetWebContents() {
+    return NULL;
+  }
+
  private:
-  base::MessageLoopForUI loop_;
-  TestBrowserThread ui_thread_;    // UI thread
-  TestBrowserThread file_thread_;  // FILE thread
   StrictMock<MockDelegate> delegate_;
   std::set<DownloadItem*> allocated_downloads_;
+  scoped_ptr<DownloadCreateInfo> create_info_;
+  uint32 next_download_id_;
+  TestBrowserThreadBundle thread_bundle_;
+};
+
+// Test fixture for resumption tests. These currently require a WebContents().
+// Therefore a TestBrowserContext() and a test WebContents() need to be created
+// for these tests.
+class DownloadItemTestWithResumption : public DownloadItemTest {
+ public:
+  virtual void SetUp() OVERRIDE {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableDownloadResumption);
+    browser_context_.reset(new TestBrowserContext);
+    scoped_refptr<SiteInstance> site_instance(
+        SiteInstance::Create(browser_context_.get()));
+    web_contents_.reset(WebContentsTester::CreateTestWebContents(
+        browser_context_.get(), site_instance.get()));
+    DownloadItemTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    web_contents_.reset();
+    browser_context_.reset();
+    DownloadItemTest::TearDown();
+  }
+
+  virtual WebContents* GetWebContents() OVERRIDE {
+    return web_contents_.get();
+  }
+
+ private:
+  scoped_ptr<TestBrowserContext> browser_context_;
+  scoped_ptr<WebContents> web_contents_;
 };
 
 // Tests to ensure calls that change a DownloadItem generate an update to
 // observers.
 // State changing functions not tested:
 //  void OpenDownload();
 //  void ShowDownloadInShell();
 //  void CompleteDelayedDownload();
 //  set_* mutators
 
@@ skipping 60 matching lines @@
 }
 
 TEST_F(DownloadItemTest, NotificationAfterDestroyed) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
 
   DestroyDownloadItem(item);
   ASSERT_TRUE(observer.CheckDestroyed());
 }
 
-TEST_F(DownloadItemTest, ContinueAfterInterrupted) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
-
+// Test that a download is resumed automatcially after a continuable interrupt.
+TEST_F(DownloadItemTestWithResumption, ContinueAfterInterrupted) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
   DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   // Interrupt the download, using a continuable interrupt.
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(Return(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
   ASSERT_TRUE(observer.CheckUpdated());
-  // Should attempt to auto-resume.  Because we don't have a mock WebContents,
-  // ResumeInterruptedDownload() will abort early, with another interrupt,
-  // which will be ignored.
+  // Should attempt to auto-resume. This is verified by the
+  // MockResumeInterruptedDownload() test expectation above.
   ASSERT_EQ(1, observer.GetInterruptCount());
   ASSERT_EQ(0, observer.GetResumeCount());
   RunAllPendingInMessageLoops();
 
   CleanupItem(item, download_file, DownloadItem::INTERRUPTED);
 }
 
-// Same as above, but with a non-continuable interrupt.
-TEST_F(DownloadItemTest, RestartAfterInterrupted) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
-
+// Test that automatic resumption doesn't happen after a non-continuable
+// interrupt.
+TEST_F(DownloadItemTestWithResumption, RestartAfterInterrupted) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
   DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
   // Interrupt the download, using a restartable interrupt.
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
@@ skipping 30 matching lines @@
   RunAllPendingInMessageLoops();
 
   ASSERT_TRUE(observer.CheckUpdated());
   // Should not try to auto-resume.
   ASSERT_EQ(1, observer.GetInterruptCount());
   ASSERT_EQ(0, observer.GetResumeCount());
 
   CleanupItem(item, download_file, DownloadItem::INTERRUPTED);
 }
 
-TEST_F(DownloadItemTest, LimitRestartsAfterInterrupted) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
+// Test that automatic resumption only happens a limited number of times. The
+// limit is currently hardcoded as DownloadItemImpl::kMaxAutoResumeAttempts.
+TEST_F(DownloadItemTestWithResumption, LimitRestartsAfterInterrupted) {
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockObserver observer(item);
+  base::FilePath target_path(kDummyPath);
+  base::FilePath intermediate_path(target_path.InsertBeforeExtensionASCII("x"));
+
+  for (int i = 0; i < (DownloadItemImpl::kMaxAutoResumeAttempts + 1); ++i) {
+    DVLOG(20) << "Loop iteration " << i;
+    DownloadItemImplDelegate::DownloadTargetCallback callback;
+    MockDownloadFile* download_file =
+        AddDownloadFileToDownloadItem(item, &callback);
+    EXPECT_FALSE(callback.is_null());
+    if (i == 0)
+      EXPECT_CALL(*download_file, RenameAndUniquify(intermediate_path, _))
+          .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
+                                           intermediate_path));
+    else
+      EXPECT_EQ(intermediate_path, item->GetFullPath());
+
+    callback.Run(target_path,
+                 DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                 DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                 intermediate_path);
+    RunAllPendingInMessageLoops();
+    ASSERT_EQ(i, observer.GetResumeCount());
+    EXPECT_CALL(*download_file, Detach());
+    // FILE_TRANSIENT_ERROR is a continuable interrupt that causes the download
+    // to be resumed automatically. However, it should only attempt to resume if
+    // the number of conesecutive automatic resumptions is less than
+    // kMaxAutoResumeAttempts.
+    EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _))
+        .Times(i < DownloadItemImpl::kMaxAutoResumeAttempts ? 1 : 0);
+    item->DestinationObserverAsWeakPtr()->DestinationError(
+        DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
+    ASSERT_EQ(i + 1, observer.GetInterruptCount());
+  }
+  EXPECT_EQ(DownloadItemImpl::kMaxAutoResumeAttempts,
+            observer.GetResumeCount());
+}
+
+// If the download attempts to resume and the resumption request fails, the
+// subsequent Start() call shouldn't update the origin state (URL redirect
+// chains, Content-Disposition, download URL, etc..)
+TEST_F(DownloadItemTestWithResumption,
+       FailedResumptionDoesntUpdateOriginState) {
+  const char* kContentDisposition = "attachment; filename=foo";
+  const char* kFirstETag = "ABC";
+  const char* kFirstLastModified = "Yesterday";
+  const char* kFirstURL = "http://www.example.com/download";
+  create_info()->content_disposition = kContentDisposition;
+  create_info()->etag = kFirstETag;
+  create_info()->last_modified = kFirstLastModified;
+  create_info()->url_chain.push_back(GURL(kFirstURL));
 
   DownloadItemImpl* item = CreateDownloadItem();
-  base::WeakPtr<DownloadDestinationObserver> as_observer(
-      item->DestinationObserverAsWeakPtr());
-  MockObserver observer(item);
-  MockDownloadFile* mock_download_file(NULL);
-  scoped_ptr<DownloadFile> download_file;
-  MockRequestHandle* mock_request_handle(NULL);
-  scoped_ptr<DownloadRequestHandleInterface> request_handle;
-  DownloadItemImplDelegate::DownloadTargetCallback callback;
+  MockDownloadFile* download_file =
+      DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
+  EXPECT_EQ(kContentDisposition, item->GetContentDisposition());
+  EXPECT_EQ(kFirstETag, item->GetETag());
+  EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
+  EXPECT_EQ(kFirstURL, item->GetURL().spec());
 
-  EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
-      .WillRepeatedly(SaveArg<1>(&callback));
-  for (int i = 0; i < (DownloadItemImpl::kMaxAutoResumeAttempts + 1); ++i) {
-    DVLOG(20) << "Loop iteration " << i;
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
+  EXPECT_CALL(*download_file, Detach());
+  item->DestinationObserverAsWeakPtr()->DestinationError(
+      DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
+  EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
 
-    mock_download_file = new NiceMock<MockDownloadFile>;
-    download_file.reset(mock_download_file);
-    mock_request_handle = new NiceMock<MockRequestHandle>;
-    request_handle.reset(mock_request_handle);
+  // Now change the create info. The changes should not cause the DownloadItem
+  // to be updated.
+  const char* kSecondContentDisposition = "attachment; filename=bar";
+  const char* kSecondETag = "123";
+  const char* kSecondLastModified = "Today";
+  const char* kSecondURL = "http://example.com/another-download";
+  create_info()->content_disposition = kSecondContentDisposition;
+  create_info()->etag = kSecondETag;
+  create_info()->last_modified = kSecondLastModified;
+  create_info()->url_chain.clear();
+  create_info()->url_chain.push_back(GURL(kSecondURL));
+  create_info()->interrupt_reason = DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED;
 
-    ON_CALL(*mock_download_file, FullPath())
-        .WillByDefault(Return(base::FilePath()));
+  // The following ends up calling DownloadItem::Start(), but shouldn't result
+  // in an origin update.
+  DownloadItemImplDelegate::DownloadTargetCallback download_target_callback;
+  download_file =
+      AddDownloadFileToDownloadItem(item, &download_target_callback);
 
-    // It's too complicated to set up a WebContents instance that would cause
-    // the MockDownloadItemDelegate's ResumeInterruptedDownload() function
-    // to be callled, so we simply verify that GetWebContents() is called.
-    if (i < (DownloadItemImpl::kMaxAutoResumeAttempts - 1)) {
-      EXPECT_CALL(*mock_request_handle, GetWebContents())
-          .WillRepeatedly(Return(static_cast<WebContents*>(NULL)));
-    }
-
-    // Copied key parts of DoIntermediateRename & AddDownloadFileToDownloadItem
-    // to allow for holding onto the request handle.
-    item->Start(download_file.Pass(), request_handle.Pass());
-    RunAllPendingInMessageLoops();
-    if (i == 0) {
-      // Target determination is only done the first time through.
-      base::FilePath target_path(kDummyPath);
-      base::FilePath intermediate_path(
-          target_path.InsertBeforeExtensionASCII("x"));
-      EXPECT_CALL(*mock_download_file, RenameAndUniquify(intermediate_path, _))
-          .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
-                                           intermediate_path));
-      callback.Run(target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-                   DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path);
-      RunAllPendingInMessageLoops();
-    }
-    ASSERT_EQ(i, observer.GetResumeCount());
-
-    // Use a continuable interrupt.
-    item->DestinationObserverAsWeakPtr()->DestinationError(
-        DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
-
-    ASSERT_EQ(i + 1, observer.GetInterruptCount());
-    ::testing::Mock::VerifyAndClearExpectations(mock_download_file);
-  }
-
-  CleanupItem(item, mock_download_file, DownloadItem::INTERRUPTED);
+  EXPECT_EQ(kContentDisposition, item->GetContentDisposition());
+  EXPECT_EQ(kFirstETag, item->GetETag());
+  EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
+  EXPECT_EQ(kFirstURL, item->GetURL().spec());
+  EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, item->GetLastReason());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterRemove) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file = AddDownloadFileToDownloadItem(item, NULL);
   EXPECT_CALL(*download_file, Cancel());
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   MockObserver observer(item);
 
   item->Remove();
   ASSERT_TRUE(observer.CheckUpdated());
   ASSERT_TRUE(observer.CheckRemoved());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterOnContentCheckCompleted) {
   // Setting to NOT_DANGEROUS does not trigger a notification.
   DownloadItemImpl* safe_item = CreateDownloadItem();
   MockObserver safe_observer(safe_item);
 
   safe_item->OnAllDataSaved(std::string());
   EXPECT_TRUE(safe_observer.CheckUpdated());
   safe_item->OnContentCheckCompleted(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
   EXPECT_TRUE(safe_observer.CheckUpdated());
 
   // Setting to unsafe url or unsafe file should trigger a notification.
-  DownloadItemImpl* unsafeurl_item =
-      CreateDownloadItem();
+  DownloadItemImpl* unsafeurl_item = CreateDownloadItem();
   MockObserver unsafeurl_observer(unsafeurl_item);
 
   unsafeurl_item->OnAllDataSaved(std::string());
   EXPECT_TRUE(unsafeurl_observer.CheckUpdated());
   unsafeurl_item->OnContentCheckCompleted(DOWNLOAD_DANGER_TYPE_DANGEROUS_URL);
   EXPECT_TRUE(unsafeurl_observer.CheckUpdated());
 
   unsafeurl_item->ValidateDangerousDownload();
   EXPECT_TRUE(unsafeurl_observer.CheckUpdated());
 
-  DownloadItemImpl* unsafefile_item =
-      CreateDownloadItem();
+  DownloadItemImpl* unsafefile_item = CreateDownloadItem();
   MockObserver unsafefile_observer(unsafefile_item);
 
   unsafefile_item->OnAllDataSaved(std::string());
   EXPECT_TRUE(unsafefile_observer.CheckUpdated());
   unsafefile_item->OnContentCheckCompleted(DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   EXPECT_TRUE(unsafefile_observer.CheckUpdated());
 
   unsafefile_item->ValidateDangerousDownload();
   EXPECT_TRUE(unsafefile_observer.CheckUpdated());
 }
@@ skipping 32 matching lines @@
 TEST_F(DownloadItemTest, NotificationAfterTogglePause) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   scoped_ptr<DownloadFile> download_file(mock_download_file);
   scoped_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
 
   EXPECT_CALL(*mock_download_file, Initialize(_));
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(_, _));
-  item->Start(download_file.Pass(), request_handle.Pass());
+  item->Start(download_file.Pass(), request_handle.Pass(), *create_info());
 
   item->Pause();
   ASSERT_TRUE(observer.CheckUpdated());
 
   ASSERT_TRUE(item->IsPaused());
 
   item->Resume();
   ASSERT_TRUE(observer.CheckUpdated());
 
   RunAllPendingInMessageLoops();
@@ skipping 26 matching lines @@
 
 // Test to make sure that Start method calls DF initialize properly.
 TEST_F(DownloadItemTest, Start) {
   MockDownloadFile* mock_download_file(new MockDownloadFile);
   scoped_ptr<DownloadFile> download_file(mock_download_file);
   DownloadItemImpl* item = CreateDownloadItem();
   EXPECT_CALL(*mock_download_file, Initialize(_));
   scoped_ptr<DownloadRequestHandleInterface> request_handle(
       new NiceMock<MockRequestHandle>);
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _));
-  item->Start(download_file.Pass(), request_handle.Pass());
+  item->Start(download_file.Pass(), request_handle.Pass(), *create_info());
   RunAllPendingInMessageLoops();
 
   CleanupItem(item, mock_download_file, DownloadItem::IN_PROGRESS);
 }
 
+// Handling of downloads initiated via a failed request. In this case, Start()
+// will get called with a DownloadCreateInfo with a non-zero interrupt_reason.
+TEST_F(DownloadItemTest, StartFailedDownload) {
+  create_info()->interrupt_reason = DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED;
+  DownloadItemImpl* item = CreateDownloadItem();
+  // The download is considered to be IN_PROGRESS even though there's an
+  // interrupt reason. It will transition to INTERRUPTED once Start() is called.
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+
+  // DownloadFile and DownloadRequestHandleInterface objects aren't created for
+  // failed downloads.
+  scoped_ptr<DownloadFile> null_download_file;
+  scoped_ptr<DownloadRequestHandleInterface> null_request_handle;
+  DownloadItemImplDelegate::DownloadTargetCallback download_target_callback;
+  EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
+      .WillOnce(SaveArg<1>(&download_target_callback));
+  item->Start(
+      null_download_file.Pass(), null_request_handle.Pass(), *create_info());
+  RunAllPendingInMessageLoops();
+
+  // The DownloadItemImpl should attempt to determine a target path even if the
+  // download was interrupted.
+  ASSERT_FALSE(download_target_callback.is_null());
+  ASSERT_EQ(DownloadItem::INTERRUPTED, item->GetState());
+  base::FilePath target_path(FILE_PATH_LITERAL("foo"));
+  download_target_callback.Run(target_path,
+                               DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                               DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                               target_path);
+  RunAllPendingInMessageLoops();
+
+  EXPECT_EQ(target_path, item->GetTargetFilePath());
+  CleanupItem(item, NULL, DownloadItem::INTERRUPTED);
+}
+
 // Test that the delegate is invoked after the download file is renamed.
 TEST_F(DownloadItemTest, CallbackAfterRename) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       AddDownloadFileToDownloadItem(item, &callback);
   base::FilePath final_path(base::FilePath(kDummyPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(final_path.InsertBeforeExtensionASCII("x"));
   base::FilePath new_intermediate_path(
       final_path.InsertBeforeExtensionASCII("y"));
@@ skipping 96 matching lines @@
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_TRUE(item->GetFullPath().empty());
   EXPECT_EQ(final_path, item->GetTargetFilePath());
 }
 
 // As above. But if the download can be resumed by continuing, then the
 // intermediate path should be retained when the download is interrupted after
 // the intermediate rename succeeds.
-TEST_F(DownloadItemTest, InterruptedBeforeIntermediateRename_Continue) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
+TEST_F(DownloadItemTestWithResumption,
+       InterruptedBeforeIntermediateRename_Continue) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       AddDownloadFileToDownloadItem(item, &callback);
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
   ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   base::FilePath final_path(base::FilePath(kDummyPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(final_path.InsertBeforeExtensionASCII("x"));
@@ skipping 12 matching lines @@
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   mock_delegate()->VerifyAndClearExpectations();
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(new_intermediate_path, item->GetFullPath());
   EXPECT_EQ(final_path, item->GetTargetFilePath());
 }
 
 // As above. If the intermediate rename fails, then the interrupt reason should
 // be set to the destination error and the intermediate path should be empty.
-TEST_F(DownloadItemTest, InterruptedBeforeIntermediateRename_Failed) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
+TEST_F(DownloadItemTestWithResumption,
+       InterruptedBeforeIntermediateRename_Failed) {
   DownloadItemImpl* item = CreateDownloadItem();
   DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       AddDownloadFileToDownloadItem(item, &callback);
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
   ASSERT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   base::FilePath final_path(base::FilePath(kDummyPath).AppendASCII("foo.bar"));
   base::FilePath intermediate_path(final_path.InsertBeforeExtensionASCII("x"));
@@ skipping 377 matching lines @@
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->StealDangerousDownload(
       base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                  weak_ptr_factory.GetWeakPtr(),
                  base::Unretained(&returned_path)));
   RunAllPendingInMessageLoops();
   EXPECT_EQ(full_path, returned_path);
 }
 
-TEST_F(DownloadItemTest, StealInterruptedDangerousDownload) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
+TEST_F(DownloadItemTestWithResumption, StealInterruptedDangerousDownload) {
   base::FilePath returned_path;
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   base::FilePath full_path = item->GetFullPath();
   EXPECT_FALSE(full_path.empty());
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(Return(full_path));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
   ASSERT_TRUE(item->IsDangerous());
 
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->StealDangerousDownload(
       base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                  weak_ptr_factory.GetWeakPtr(),
                  base::Unretained(&returned_path)));
   RunAllPendingInMessageLoops();
   EXPECT_EQ(full_path, returned_path);
 }
 
-TEST_F(DownloadItemTest, StealInterruptedNonResumableDangerousDownload) {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableDownloadResumption);
+TEST_F(DownloadItemTestWithResumption,
+       StealInterruptedNonResumableDangerousDownload) {
   base::FilePath returned_path;
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
   ASSERT_TRUE(item->IsDangerous());
 
   EXPECT_CALL(*mock_delegate(), DownloadRemoved(_));
   base::WeakPtrFactory<DownloadItemTest> weak_ptr_factory(this);
   item->StealDangerousDownload(
       base::Bind(&DownloadItemTest::OnDownloadFileAcquired,
                  weak_ptr_factory.GetWeakPtr(),
                  base::Unretained(&returned_path)));
   RunAllPendingInMessageLoops();
   EXPECT_TRUE(returned_path.empty());
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content