Download resumption - Preliminary

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/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "content/browser/download/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_manager.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/public/browser/download_id.h"
 #include "content/public/browser/download_interrupt_reasons.h"
+#include "content/public/browser/download_url_parameters.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::MockDownloadItem;
 using content::WebContents;
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Property;
 using ::testing::Return;
 
 DownloadId::Domain kValidDownloadItemIdDomain = "valid DownloadId::Domain";
 
 namespace {
 class MockDelegate : public DownloadItemImplDelegate {
  public:
   MockDelegate(DownloadFileManager* file_manager)
       : file_manager_(file_manager) {
   }
   MOCK_METHOD1(ShouldOpenFileBasedOnExtension, bool(const FilePath& path));
   MOCK_METHOD1(ShouldOpenDownload, bool(DownloadItemImpl* download));
   MOCK_METHOD1(CheckForFileRemoval, void(DownloadItemImpl* download));
-  MOCK_METHOD1(MaybeCompleteDownload, void(DownloadItemImpl* download));
+  MOCK_METHOD1(MaybeCompleteDownload, void(int32 download_id));
+  MOCK_METHOD2(RestartInterruptedDownload,
+               void(DownloadItemImpl* download,
+                    const content::DownloadUrlParameters::OnStartedCallback&));
   MOCK_CONST_METHOD0(GetBrowserContext, content::BrowserContext*());
   MOCK_METHOD1(DownloadStopped, void(DownloadItemImpl* download));
   MOCK_METHOD1(DownloadCompleted, void(DownloadItemImpl* download));
   MOCK_METHOD1(DownloadOpened, void(DownloadItemImpl* download));
   MOCK_METHOD1(DownloadRemoved, void(DownloadItemImpl* download));
   MOCK_METHOD1(DownloadRenamedToIntermediateName,
                void(DownloadItemImpl* download));
   MOCK_METHOD1(DownloadRenamedToFinalName, void(DownloadItemImpl* download));
   MOCK_CONST_METHOD1(AssertStateConsistent, void(DownloadItemImpl* download));
   virtual DownloadFileManager* GetDownloadFileManager() OVERRIDE {
     return file_manager_;
   }
  private:
   DownloadFileManager* file_manager_;
 };
 
 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_METHOD1(SetRequestId, void(int new_request_id));
+  MOCK_CONST_METHOD0(RequestId, int());
   MOCK_CONST_METHOD0(DebugString, std::string());
 };
 
 class MockDownloadFileFactory : public content::DownloadFileFactory {
  public:
   content::DownloadFile* CreateFile(
       DownloadCreateInfo* info,
       scoped_ptr<content::ByteStreamReader> stream_reader,
       DownloadManager* mgr,
       bool calculate_hash,
@@ skipping 135 matching lines @@
     static int next_id;
     info_->download_id =
         content::DownloadId(kValidDownloadItemIdDomain, ++next_id);
     info_->prompt_user_for_save_location = false;
     info_->url_chain.push_back(GURL());
     info_->state = state;
 
     scoped_ptr<DownloadRequestHandleInterface> request_handle(
         new testing::NiceMock<MockRequestHandle>);
     DownloadItemImpl* download =
-        new DownloadItemImpl(&delegate_, *(info_.get()),
-                             request_handle.Pass(), net::BoundNetLog());
+        new DownloadItemImpl(&delegate_, *(info_.get()), net::BoundNetLog());
+    download->SetRequest(request_handle.Pass());
     allocated_downloads_.insert(download);
     return download;
   }
 
   // Destroy a previously created download item.
   void DestroyDownloadItem(DownloadItem* item) {
     allocated_downloads_.erase(item);
     delete item;
   }
 
@@ skipping 76 matching lines @@
   MockObserver observer(item);
 
   item->OnDownloadedFileRemoved();
   ASSERT_TRUE(observer.CheckUpdated());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterInterrupted) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
   MockObserver observer(item);
 
+  EXPECT_CALL(*mock_delegate(), RestartInterruptedDownload(_,_))
+      .Times(0);
+
   item->Interrupt(content::DOWNLOAD_INTERRUPT_REASON_NONE);
   ASSERT_TRUE(observer.CheckUpdated());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterDelete) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
   MockObserver observer(item);
 
   item->Delete(DownloadItem::DELETE_DUE_TO_BROWSER_SHUTDOWN);
   ASSERT_TRUE(observer.CheckUpdated());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterDestroyed) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
   MockObserver observer(item);
 
   DestroyDownloadItem(item);
   ASSERT_TRUE(observer.CheckDestroyed());
 }
 
+TEST_F(DownloadItemTest, RestartAfterInterrupted) {
+  DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
+  MockObserver observer(item);
+  // Pretend we've recorded it in the history DB, to allow restart.
+  item->SetDbHandle(DownloadItem::kUninitializedHandle);
+  item->SetIsPersisted();
+
+  EXPECT_CALL(*mock_delegate(), RestartInterruptedDownload(item,_))
+      .Times(1);
+
+//EXPECT_CALL(item, IsInterrupted())
+//  .Times(1)
+//  .WillOnce(Return(true));
+
+  item->Interrupt(content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
+  ASSERT_TRUE(observer.CheckUpdated());
+}
+
+TEST_F(DownloadItemTest, LimitRestartsAfterInterrupted) {
+  DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
+  MockObserver observer(item);
+  // Pretend we've recorded it in the history DB, to allow restart.
+  item->SetDbHandle(DownloadItem::kUninitializedHandle);
+  item->SetIsPersisted();
+
+  EXPECT_CALL(*mock_delegate(), RestartInterruptedDownload(item,_))
+      .Times(DownloadItemImpl::kMaxAutoResumeAttempts);
+
+  scoped_ptr<DownloadRequestHandleInterface> request_handle(
+    new testing::NiceMock<MockRequestHandle>);
+
+  for (int i = 0; i < (DownloadItemImpl::kMaxAutoResumeAttempts + 2); ++i) {
+    item->Interrupt(content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
+    // Should call delegate->RestartInterruptedDownload() here, up to
+    // kMaxAutoResumeAttempts times.
+    item->Resume(request_handle.Pass());
+  }
+}
+
 TEST_F(DownloadItemTest, NotificationAfterRemove) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
   MockObserver observer(item);
 
   item->Remove();
   ASSERT_TRUE(observer.CheckUpdated());
   ASSERT_TRUE(observer.CheckRemoved());
 }
 
 TEST_F(DownloadItemTest, NotificationAfterOnContentCheckCompleted) {
@@ skipping 155 matching lines @@
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
 
   const content::DownloadInterruptReason reason(
       content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
 
   // Confirm interrupt sets state properly.
   item->Interrupt(reason);
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(reason, item->GetLastReason());
 
-  // Cancel should result in no change.
+  // Cancel should kill it.
   item->Cancel(true);
-  EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
+  EXPECT_EQ(DownloadItem::CANCELLED, item->GetState());
   EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED,
             item->GetLastReason());
 }
 
 TEST_F(DownloadItemTest, Canceled) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
 
   // Confirm cancel sets state properly.
   EXPECT_CALL(*mock_delegate(), DownloadStopped(item));
   item->Cancel(true);
   EXPECT_EQ(DownloadItem::CANCELLED, item->GetState());
 }
 
 TEST_F(DownloadItemTest, FileRemoved) {
   DownloadItemImpl* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
 
   EXPECT_FALSE(item->GetFileExternallyRemoved());
   item->OnDownloadedFileRemoved();
   EXPECT_TRUE(item->GetFileExternallyRemoved());
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }