[downloads] Move platform specific code out of DownloadTargetDeterminer.

content/browser/download/download_manager_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 "content/browser/download/download_manager_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 263 matching lines @@
     : public DownloadFileFactory,
       public base::SupportsWeakPtr<MockDownloadFileFactory> {
  public:
   MockDownloadFileFactory() {}
   virtual ~MockDownloadFileFactory() {}
 
   // Overridden method from DownloadFileFactory
   MOCK_METHOD2(MockCreateFile,
                MockDownloadFile*(const DownloadSaveInfo&, ByteStreamReader*));
 
-  virtual DownloadFile* CreateFile(
+  DownloadFile* CreateFile(
       std::unique_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
       std::unique_ptr<ByteStreamReader> byte_stream,
       const std::vector<DownloadItem::ReceivedSlice>& received_slices,
       const net::NetLogWithSource& net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) override {
     return MockCreateFile(*save_info, byte_stream.get());
   }
 };
 
@@ skipping 67 matching lines @@
 
 }  // namespace
 
 class DownloadManagerTest : public testing::Test {
  public:
   static const char* kTestData;
   static const size_t kTestDataLen;
 
   DownloadManagerTest()
       : callback_called_(false),
+        target_disposition_(DownloadItem::TARGET_DISPOSITION_OVERWRITE),
+        danger_type_(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
+        interrupt_reason_(DOWNLOAD_INTERRUPT_REASON_NONE),
         ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
-        next_download_id_(0) {
-  }
+        next_download_id_(0) {}
 
   // We tear down everything in TearDown().
   ~DownloadManagerTest() override {}
 
   // Create a MockDownloadItemFactory and MockDownloadManagerDelegate,
   // then create a DownloadManager that points
   // at all of those.
   void SetUp() override {
     DCHECK(!download_manager_);
 
@@ skipping 82 matching lines @@
   }
 
   MockDownloadManagerObserver& GetMockObserver() {
     return *observer_;
   }
 
   void DownloadTargetDeterminedCallback(
       const base::FilePath& target_path,
       DownloadItem::TargetDisposition disposition,
       DownloadDangerType danger_type,
-      const base::FilePath& intermediate_path) {
+      const base::FilePath& intermediate_path,
+      DownloadInterruptReason interrupt_reason) {
     callback_called_ = true;
     target_path_ = target_path;
     target_disposition_ = disposition;
     danger_type_ = danger_type;
     intermediate_path_ = intermediate_path;
+    interrupt_reason_ = interrupt_reason;
   }
 
   void DetermineDownloadTarget(DownloadItemImpl* item) {
     download_manager_->DetermineDownloadTarget(
         item, base::Bind(
             &DownloadManagerTest::DownloadTargetDeterminedCallback,
             base::Unretained(this)));
   }
 
  protected:
   // Key test variable; we'll keep it available to sub-classes.
   std::unique_ptr<DownloadManagerImpl> download_manager_;
   base::WeakPtr<MockDownloadFileFactory> mock_download_file_factory_;
 
   // Target detetermined callback.
   bool callback_called_;
   base::FilePath target_path_;
   DownloadItem::TargetDisposition target_disposition_;
   DownloadDangerType danger_type_;
   base::FilePath intermediate_path_;
+  DownloadInterruptReason interrupt_reason_;
 
   std::vector<GURL> download_urls_;
 
  private:
   base::MessageLoopForUI message_loop_;
   TestBrowserThread ui_thread_;
   TestBrowserThread file_thread_;
   base::WeakPtr<MockDownloadItemFactory> mock_download_item_factory_;
   std::unique_ptr<MockDownloadManagerDelegate> mock_download_manager_delegate_;
   std::unique_ptr<MockBrowserContext> mock_browser_context_;
@@ skipping 53 matching lines @@
   MockDownloadItemImpl& item(AddItemToManager());
 
   base::FilePath path(FILE_PATH_LITERAL("random_filepath.txt"));
   EXPECT_CALL(GetMockDownloadManagerDelegate(),
               DetermineDownloadTarget(&item, _))
       .WillOnce(Return(false));
   EXPECT_CALL(item, GetForcedFilePath())
       .WillOnce(ReturnRef(path));
 
   // Confirm that the callback was called with the right values in this case.
-  callback_called_ = false;
   DetermineDownloadTarget(&item);
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(path, target_path_);
   EXPECT_EQ(DownloadItem::TARGET_DISPOSITION_OVERWRITE, target_disposition_);
   EXPECT_EQ(DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, danger_type_);
   EXPECT_EQ(path, intermediate_path_);
+  EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason_);
 }
 
 TEST_F(DownloadManagerTest, GetDownloadByGuid) {
   for (uint32_t i = 0; i < 4; ++i)
     AddItemToManager();
 
   MockDownloadItemImpl& item = GetMockDownloadItem(0);
   DownloadItem* result = download_manager_->GetDownloadByGuid(item.GetGuid());
   ASSERT_TRUE(result);
   ASSERT_EQ(static_cast<DownloadItem*>(&item), result);
@@ skipping 38 matching lines @@
   EXPECT_CALL(GetMockDownloadItem(1), Remove()).Times(0);
 
   base::Callback<bool(const GURL&)> url_filter =
       GetSingleURLFilter(download_urls_[0]);
   int remove_count = download_manager_->RemoveDownloadsByURLAndTime(
       url_filter, base::Time(), base::Time::Max());
   EXPECT_EQ(remove_count, 1);
 }
 
 }  // namespace content