Fix a problem that user validated dangerous download cannot resume

chrome/browser/download/download_target_determiner_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 1894 matching lines @@
     const MIMETypeTestCase& test_case = kMIMETypeTestCases[i];
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case.general));
     std::unique_ptr<DownloadTargetInfo> target_info =
         RunDownloadTargetDeterminer(GetPathInDownloadDir(kInitialPath),
                                     item.get());
     EXPECT_EQ(test_case.expected_mime_type, target_info->mime_type);
   }
 }
 
+// Test that a user validated download won't be treated as dangerous.
+TEST_F(DownloadTargetDeterminerTest, ResumedWithUserValidatedDownload) {
+  const base::FilePath::CharType kInitialPath[] =
+      FILE_PATH_LITERAL("some_path/bar.txt");
+  const base::FilePath::CharType* kIntermediatePath =
+      FILE_PATH_LITERAL("foo.crx.crdownload");
+
+  const DownloadTestCase kUserValidatedTestCase = {
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED,
+      DownloadFileType::NOT_DANGEROUS,
+      "http://example.com/foo.crx",
+      "",
+      FILE_PATH_LITERAL(""),
+      FILE_PATH_LITERAL("foo.crx"),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+      EXPECT_CRDOWNLOAD};
+
+  const DownloadTestCase& test_case = kUserValidatedTestCase;
+  std::unique_ptr<content::MockDownloadItem> item(
+      CreateActiveDownloadItem(0, test_case));
+  base::FilePath expected_path =
+      GetPathInDownloadDir(test_case.expected_local_path);
+  ON_CALL(*item.get(), GetDangerType())
+      .WillByDefault(Return(content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED));
+  ON_CALL(*item.get(), GetFullPath())
+      .WillByDefault(ReturnRefOfCopy(GetPathInDownloadDir(kIntermediatePath)));
+  ON_CALL(*item.get(), GetLastReason())
+      .WillByDefault(Return(content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED));
+  EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _));
+  EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
+  EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
+      .Times(0);
+  EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
+  EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _)).Times(0);
+  RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
+}
+
 #if BUILDFLAG(ENABLE_PLUGINS)
 
 void DummyGetPluginsCallback(
     const base::Closure& closure,
     const std::vector<content::WebPluginInfo>& plugins) {
   closure.Run();
 }
 
 void ForceRefreshOfPlugins() {
 #if !defined(OS_WIN)
@@ skipping 231 matching lines @@
   EXPECT_CALL(mock_plugin_filter_, MockPluginAvailable(browser_plugin.path()))
       .WillRepeatedly(Return(false));
   target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 }
 
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
 }  // namespace