WIP - Refactor programmatic 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/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/download_destination_observer.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_download_item.h"
+#include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread.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 48 matching lines @@
   void SetDefaultExpectations() {
     EXPECT_CALL(*this, AssertStateConsistent(_))
         .WillRepeatedly(Return());
     EXPECT_CALL(*this, ShouldOpenFileBasedOnExtension(_))
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*this, ShouldOpenDownload(_, _))
         .WillRepeatedly(Return(true));
   }
 };
 
-class MockRequestHandle : public DownloadRequestHandleInterface {
+class MockRequestHandle : public DownloadRequestHandle {
  public:
-  MOCK_CONST_METHOD0(GetWebContents, WebContents*());
-  MOCK_CONST_METHOD0(GetDownloadManager, DownloadManager*());
+  MOCK_METHOD1(Start, void(const RequestStartedCallback&));
   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
 // MockDownloadFile::Rename as follows:
 //   EXPECT_CALL(download_file, Rename*(_,_))
@@ skipping 120 matching lines @@
     // 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());
+    DownloadItemImpl* download = new DownloadItemImpl(
+        &delegate_, next_id++, *(info_.get()), 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(_));
     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(
+    scoped_ptr<DownloadRequestHandle> request_handle(
         new NiceMock<MockRequestHandle>);
     item->Start(download_file.Pass(), request_handle.Pass());
     loop_.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(_))
@@ skipping 142 matching lines @@
   MockObserver observer(item);
 
   DestroyDownloadItem(item);
   ASSERT_TRUE(observer.CheckDestroyed());
 }
 
 TEST_F(DownloadItemTest, ContinueAfterInterrupted) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
 
+  TestBrowserContext test_browser_context;
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
-  DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
+  EXPECT_CALL(*mock_delegate(), GetBrowserContext())
+      .WillRepeatedly(Return(&test_browser_context));
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
+
   // Interrupt the download, using a continuable interrupt.
   EXPECT_CALL(*download_file, FullPath())
       .WillOnce(Return(base::FilePath()));
   EXPECT_CALL(*download_file, Detach());
   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 checked by verifying the expectation
+  // for the MockResumeInterruptedDownload() call for the mock_delegate() 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);
 
+  TestBrowserContext test_browser_context;
   DownloadItemImpl* item = CreateDownloadItem();
   MockObserver observer(item);
-  DownloadItemImplDelegate::DownloadTargetCallback callback;
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
 
+  EXPECT_CALL(*mock_delegate(), GetBrowserContext())
+      .WillRepeatedly(Return(&test_browser_context));
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _))
+      .Times(0);
+
   // Interrupt the download, using a restartable interrupt.
   EXPECT_CALL(*download_file, Cancel());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
   ASSERT_TRUE(observer.CheckUpdated());
   // Should not try to auto-resume.
   ASSERT_EQ(1, observer.GetInterruptCount());
   ASSERT_EQ(0, observer.GetResumeCount());
   RunAllPendingInMessageLoops();
 
   CleanupItem(item, download_file, DownloadItem::INTERRUPTED);
 }
 
 TEST_F(DownloadItemTest, LimitRestartsAfterInterrupted) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableDownloadResumption);
 
+  TestBrowserContext test_browser_context;
   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;
+  scoped_ptr<DownloadRequestHandle> request_handle;
   DownloadItemImplDelegate::DownloadTargetCallback callback;
 
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _))
       .WillRepeatedly(SaveArg<1>(&callback));
+  EXPECT_CALL(*mock_delegate(), GetBrowserContext())
+      .WillRepeatedly(Return(&test_browser_context));
+  EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _))
+      .Times(DownloadItemImpl::kMaxAutoResumeAttempts);
   for (int i = 0; i < (DownloadItemImpl::kMaxAutoResumeAttempts + 1); ++i) {
     DVLOG(20) << "Loop iteration " << i;
 
     mock_download_file = new NiceMock<MockDownloadFile>;
     download_file.reset(mock_download_file);
     mock_request_handle = new NiceMock<MockRequestHandle>;
     request_handle.reset(mock_request_handle);
 
     ON_CALL(*mock_download_file, FullPath())
         .WillByDefault(Return(base::FilePath()));
 
-    // 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, _))
@@ skipping 93 matching lines @@
   EXPECT_EQ(new_intermediate_path, item->GetFullPath());
 
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 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(
+  scoped_ptr<DownloadRequestHandle> 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->Pause();
   ASSERT_TRUE(observer.CheckUpdated());
 
   ASSERT_TRUE(item->IsPaused());
@@ skipping 28 matching lines @@
             item->GetFileNameToReportUser().value());
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 // 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(
+  scoped_ptr<DownloadRequestHandle> request_handle(
       new NiceMock<MockRequestHandle>);
   EXPECT_CALL(*mock_delegate(), DetermineDownloadTarget(item, _));
   item->Start(download_file.Pass(), request_handle.Pass());
   RunAllPendingInMessageLoops();
 
   CleanupItem(item, mock_download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Test that the delegate is invoked after the download file is renamed.
 TEST_F(DownloadItemTest, CallbackAfterRename) {
@@ skipping 592 matching lines @@
                  base::Unretained(&returned_path)));
   RunAllPendingInMessageLoops();
   EXPECT_TRUE(returned_path.empty());
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content