Tweak comments and put in tests for ignoring safe browsing results.

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_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_id.h"
 #include "content/public/browser/download_destination_observer.h"
 #include "content/public/browser/download_interrupt_reasons.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 ::testing::_;
-using ::testing::AllOf;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace {
 
 const int kDownloadChunkSize = 1000;
 const int kDownloadSpeed = 1000;
 const int kDummyDBHandle = 10;
 const FilePath::CharType kDummyPath[] = FILE_PATH_LITERAL("/testpath");
 
 } // namespace
 
 namespace content {
 
 namespace {
 
 DownloadId::Domain kValidDownloadItemIdDomain = "valid DownloadId::Domain";
 
 class MockDelegate : public DownloadItemImplDelegate {
  public:
   MOCK_METHOD2(DetermineDownloadTarget, void(
       DownloadItemImpl*, const DownloadTargetCallback&));
+  MOCK_METHOD2(ShouldCompleteDownload,
+               bool(DownloadItemImpl*, const base::Closure&));
   MOCK_METHOD2(ShouldOpenDownload,
                bool(DownloadItemImpl*, const ShouldOpenDownloadCallback&));
   MOCK_METHOD1(ShouldOpenFileBasedOnExtension, bool(const FilePath&));
   MOCK_METHOD1(CheckForFileRemoval, void(DownloadItemImpl*));
   MOCK_CONST_METHOD0(GetBrowserContext, BrowserContext*());
   MOCK_METHOD1(UpdatePersistence, void(DownloadItemImpl*));
   MOCK_METHOD1(DownloadOpened, void(DownloadItemImpl*));
   MOCK_METHOD1(DownloadRemoved, void(DownloadItemImpl*));
   MOCK_METHOD1(ShowDownloadInBrowser, void(DownloadItemImpl*));
   MOCK_CONST_METHOD1(AssertStateConsistent, void(DownloadItemImpl*));
@@ skipping 419 matching lines @@
   EXPECT_CALL(*mock_delegate(), ShowDownloadInBrowser(item))
       .Times(1);
 
   callback.Run(final_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, intermediate_path);
   RunAllPendingInMessageLoops();
   // All the callbacks should have happened by now.
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   ::testing::Mock::VerifyAndClearExpectations(mock_delegate());
 
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(Return(true));
   EXPECT_CALL(*download_file, RenameAndAnnotate(final_path, _))
       .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
                                        final_path));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
   RunAllPendingInMessageLoops();
   ::testing::Mock::VerifyAndClearExpectations(download_file);
   ::testing::Mock::VerifyAndClearExpectations(mock_delegate());
@@ skipping 149 matching lines @@
   // InProgress
   ASSERT_TRUE(item->IsInProgress());
   ASSERT_FALSE(item->GetTargetFilePath().empty());
   EXPECT_TRUE(item->CanShowInFolder());
   EXPECT_TRUE(item->CanOpenDownload());
 
   // Complete
   EXPECT_CALL(*download_file, RenameAndAnnotate(_, _))
       .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
                                        FilePath(kDummyPath)));
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(Return(true));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
   RunAllPendingInMessageLoops();
 
   ASSERT_TRUE(item->IsComplete());
   EXPECT_TRUE(item->CanShowInFolder());
   EXPECT_TRUE(item->CanOpenDownload());
 }
 
 TEST_F(DownloadItemTest, EnabledActionsForTemporaryDownload) {
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file = DoIntermediateRename(item);
   item->SetIsTemporary(true);
 
   // InProgress Temporary
   ASSERT_TRUE(item->IsInProgress());
   ASSERT_FALSE(item->GetTargetFilePath().empty());
   ASSERT_TRUE(item->IsTemporary());
   EXPECT_FALSE(item->CanShowInFolder());
   EXPECT_FALSE(item->CanOpenDownload());
 
   // Complete Temporary
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(Return(true));
   EXPECT_CALL(*download_file, RenameAndAnnotate(_, _))
       .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
                                        FilePath(kDummyPath)));
   EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
       .WillOnce(Return(true));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
   RunAllPendingInMessageLoops();
 
   ASSERT_TRUE(item->IsComplete());
@@ skipping 22 matching lines @@
 
   EXPECT_CALL(*download_file, Cancel());
   item->Cancel(true);
   RunAllPendingInMessageLoops();
 
   ASSERT_TRUE(item->IsCancelled());
   EXPECT_FALSE(item->CanShowInFolder());
   EXPECT_FALSE(item->CanOpenDownload());
 }
 
+// Test various aspects of the delegate completion blocker.
+
+// Just allowing completion.
+TEST_F(DownloadItemTest, CompleteDelegate_ReturnTrue) {
+  // Test to confirm that if we have a callback that returns true,
+  // we complete immediately.
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockDownloadFile* download_file = DoIntermediateRename(item);
+
+  // Drive the delegate interaction.
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(Return(true));
+  item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  EXPECT_FALSE(item->IsDangerous());
+
+  // Make sure the download can complete.
+  EXPECT_CALL(*download_file, RenameAndAnnotate(FilePath(kDummyPath), _))
+      .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
+                                       FilePath(kDummyPath)));
+  EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*download_file, Detach());
+  RunAllPendingInMessageLoops();
+  EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
+}
+
+// Just delaying completion.
+TEST_F(DownloadItemTest, CompleteDelegate_BlockOnce) {
+  // Test to confirm that if we have a callback that returns true,
+  // we complete immediately.
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockDownloadFile* download_file = DoIntermediateRename(item);
+
+  // Drive the delegate interaction.
+  base::Closure delegate_callback;
+  base::Closure copy_delegate_callback;
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(DoAll(SaveArg<1>(&delegate_callback),
+                      Return(false)))
+      .WillOnce(Return(true));
+  item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
+  ASSERT_FALSE(delegate_callback.is_null());
+  copy_delegate_callback = delegate_callback;
+  delegate_callback.Reset();
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  copy_delegate_callback.Run();
+  ASSERT_TRUE(delegate_callback.is_null());
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  EXPECT_FALSE(item->IsDangerous());
+
+  // Make sure the download can complete.
+  EXPECT_CALL(*download_file, RenameAndAnnotate(FilePath(kDummyPath), _))
+      .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
+                                       FilePath(kDummyPath)));
+  EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*download_file, Detach());
+  RunAllPendingInMessageLoops();
+  EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
+}
+
+// Delay and set danger.
+TEST_F(DownloadItemTest, CompleteDelegate_SetDanger) {
+  // Test to confirm that if we have a callback that returns true,
+  // we complete immediately.
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockDownloadFile* download_file = DoIntermediateRename(item);
+
+  // Drive the delegate interaction.
+  base::Closure delegate_callback;
+  base::Closure copy_delegate_callback;
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(DoAll(SaveArg<1>(&delegate_callback),
+                      Return(false)))
+      .WillOnce(Return(true));
+  item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
+  ASSERT_FALSE(delegate_callback.is_null());
+  copy_delegate_callback = delegate_callback;
+  delegate_callback.Reset();
+  EXPECT_FALSE(item->IsDangerous());
+  item->OnContentCheckCompleted(
+      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  copy_delegate_callback.Run();
+  ASSERT_TRUE(delegate_callback.is_null());
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  EXPECT_TRUE(item->IsDangerous());
+
+  // Make sure the download doesn't complete until we've validated it.
+  EXPECT_CALL(*download_file, RenameAndAnnotate(FilePath(kDummyPath), _))
+      .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
+                                       FilePath(kDummyPath)));
+  EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*download_file, Detach());
+  RunAllPendingInMessageLoops();
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  EXPECT_TRUE(item->IsDangerous());
+
+  item->DangerousDownloadValidated();
+  EXPECT_EQ(DownloadItem::DANGEROUS_BUT_VALIDATED, item->GetSafetyState());
+  RunAllPendingInMessageLoops();
+  EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
+}
+
+// Just delaying completion twice.
+TEST_F(DownloadItemTest, CompleteDelegate_BlockTwice) {
+  // Test to confirm that if we have a callback that returns true,
+  // we complete immediately.
+  DownloadItemImpl* item = CreateDownloadItem();
+  MockDownloadFile* download_file = DoIntermediateRename(item);
+
+  // Drive the delegate interaction.
+  base::Closure delegate_callback;
+  base::Closure copy_delegate_callback;
+  EXPECT_CALL(*mock_delegate(), ShouldCompleteDownload(item, _))
+      .WillOnce(DoAll(SaveArg<1>(&delegate_callback),
+                      Return(false)))
+      .WillOnce(DoAll(SaveArg<1>(&delegate_callback),
+                      Return(false)))
+      .WillOnce(Return(true));
+  item->DestinationObserverAsWeakPtr()->DestinationCompleted("");
+  ASSERT_FALSE(delegate_callback.is_null());
+  copy_delegate_callback = delegate_callback;
+  delegate_callback.Reset();
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  copy_delegate_callback.Run();
+  ASSERT_FALSE(delegate_callback.is_null());
+  copy_delegate_callback = delegate_callback;
+  delegate_callback.Reset();
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  copy_delegate_callback.Run();
+  ASSERT_TRUE(delegate_callback.is_null());
+  EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
+  EXPECT_FALSE(item->IsDangerous());
+
+  // Make sure the download can complete.
+  EXPECT_CALL(*download_file, RenameAndAnnotate(FilePath(kDummyPath), _))
+      .WillOnce(ScheduleRenameCallback(DOWNLOAD_INTERRUPT_REASON_NONE,
+                                       FilePath(kDummyPath)));
+  EXPECT_CALL(*mock_delegate(), ShouldOpenDownload(item, _))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*download_file, Detach());
+  RunAllPendingInMessageLoops();
+  EXPECT_EQ(DownloadItem::COMPLETE, item->GetState());
+}
+
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content