Use FileTypePolicies for download danger classifications.

chrome/browser/download/chrome_download_manager_delegate_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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 29 matching lines @@
 using ::testing::Invoke;
 using ::testing::Ref;
 using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::SetArgPointee;
 using ::testing::WithArg;
 using ::testing::_;
 using content::DownloadItem;
+using safe_browsing::DownloadFileType;
 
 namespace {
 
 class MockWebContentsDelegate : public content::WebContentsDelegate {
  public:
   ~MockWebContentsDelegate() override {}
 };
 
 // Google Mock action that posts a task to the current message loop that invokes
 // the first argument of the mocked method as a callback. Said argument must be
@@ skipping 356 matching lines @@
           Return(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT));
 
   {
     const std::string kDangerousContentDisposition(
         "attachment; filename=\"foo.swf\"");
     EXPECT_CALL(*download_item, GetContentDisposition())
         .WillRepeatedly(Return(kDangerousContentDisposition));
     DownloadTargetInfo target_info;
     DetermineDownloadTarget(download_item.get(), &target_info);
 
-    EXPECT_EQ(download_util::DANGEROUS,
+    EXPECT_EQ(DownloadFileType::DANGEROUS,
               DownloadItemModel(download_item.get()).GetDangerLevel());
     EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
               target_info.danger_type);
   }
 
   {
     const std::string kSafeContentDisposition(
         "attachment; filename=\"foo.txt\"");
     EXPECT_CALL(*download_item, GetContentDisposition())
         .WillRepeatedly(Return(kSafeContentDisposition));
     DownloadTargetInfo target_info;
     DetermineDownloadTarget(download_item.get(), &target_info);
-    EXPECT_EQ(download_util::NOT_DANGEROUS,
+    EXPECT_EQ(DownloadFileType::NOT_DANGEROUS,
               DownloadItemModel(download_item.get()).GetDangerLevel());
     EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
               target_info.danger_type);
   }
 
   {
     const std::string kModerateContentDisposition(
         "attachment; filename=\"foo.crx\"");
     EXPECT_CALL(*download_item, GetContentDisposition())
         .WillRepeatedly(Return(kModerateContentDisposition));
     DownloadTargetInfo target_info;
     DetermineDownloadTarget(download_item.get(), &target_info);
-    EXPECT_EQ(download_util::ALLOW_ON_USER_GESTURE,
+    EXPECT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
               DownloadItemModel(download_item.get()).GetDangerLevel());
     EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
               target_info.danger_type);
   }
 }
 
 TEST_F(ChromeDownloadManagerDelegateTest, CheckForFileExistence) {
   const char kData[] = "helloworld";
   const size_t kDataLength = sizeof(kData) - 1;
   base::FilePath existing_path = default_download_path().AppendASCII("foo");
@@ skipping 11 matching lines @@
   EXPECT_CALL(*download_item, GetTargetFilePath())
       .WillRepeatedly(ReturnRef(non_existent_path));
   EXPECT_FALSE(CheckForFileExistence(download_item.get()));
 }
 
 #if defined(FULL_SAFE_BROWSING)
 namespace {
 
 struct SafeBrowsingTestParameters {
   content::DownloadDangerType initial_danger_type;
-  download_util::DownloadDangerLevel initial_danger_level;
+  DownloadFileType::DangerLevel initial_danger_level;
   safe_browsing::DownloadProtectionService::DownloadCheckResult verdict;
 
   content::DownloadDangerType expected_danger_type;
 };
 
 class TestDownloadProtectionService
     : public safe_browsing::DownloadProtectionService {
  public:
   TestDownloadProtectionService() : DownloadProtectionService(nullptr) {}
 
@@ skipping 28 matching lines @@
       .WillByDefault(Return(test_download_protection_service_.get()));
 }
 
 void ChromeDownloadManagerDelegateTestWithSafeBrowsing::TearDown() {
   test_download_protection_service_.reset();
   ChromeDownloadManagerDelegateTest::TearDown();
 }
 
 const SafeBrowsingTestParameters kSafeBrowsingTestCases[] = {
     // SAFE verdict for a safe file.
-    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, download_util::NOT_DANGEROUS,
+    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::SAFE,
 
      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
 
     // UNKNOWN verdict for a safe file.
-    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, download_util::NOT_DANGEROUS,
+    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::UNKNOWN,
 
      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
 
     // DANGEROUS verdict for a safe file.
-    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, download_util::NOT_DANGEROUS,
+    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::DANGEROUS,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
 
     // UNCOMMON verdict for a safe file.
-    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, download_util::NOT_DANGEROUS,
+    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::UNCOMMON,
 
      content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
 
     // POTENTIALLY_UNWANTED verdict for a safe file.
-    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, download_util::NOT_DANGEROUS,
+    {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
 
      content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
 
     // SAFE verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::ALLOW_ON_USER_GESTURE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::SAFE,
 
      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
 
     // UNKNOWN verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::ALLOW_ON_USER_GESTURE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::UNKNOWN,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
 
     // DANGEROUS verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::ALLOW_ON_USER_GESTURE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::DANGEROUS,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
 
     // UNCOMMON verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::ALLOW_ON_USER_GESTURE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::UNCOMMON,
 
      content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
 
     // POTENTIALLY_UNWANTED verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::ALLOW_ON_USER_GESTURE,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
 
      content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
 
     // SAFE verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::DANGEROUS, safe_browsing::DownloadProtectionService::SAFE,
+     DownloadFileType::DANGEROUS,
+     safe_browsing::DownloadProtectionService::SAFE,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
 
     // UNKNOWN verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::DANGEROUS,
+     DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::UNKNOWN,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
 
     // DANGEROUS verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::DANGEROUS,
+     DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::DANGEROUS,
 
      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
 
     // UNCOMMON verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::DANGEROUS,
+     DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::UNCOMMON,
 
      content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
 
     // POTENTIALLY_UNWANTED verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-     download_util::DANGEROUS,
+     DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
 
      content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
 };
 
 INSTANTIATE_TEST_CASE_P(_,
                         ChromeDownloadManagerDelegateTestWithSafeBrowsing,
                         ::testing::ValuesIn(kSafeBrowsingTestCases));
 
 }  // namespace
 
 TEST_P(ChromeDownloadManagerDelegateTestWithSafeBrowsing, CheckClientDownload) {
   const SafeBrowsingTestParameters& kParameters = GetParam();
 
   std::unique_ptr<content::MockDownloadItem> download_item =
       CreateActiveDownloadItem(0);
   EXPECT_CALL(*delegate(), GetDownloadProtectionService());
   EXPECT_CALL(*download_protection_service(), MockCheckClientDownload())
       .WillOnce(Return(kParameters.verdict));
   EXPECT_CALL(*download_item, GetDangerType())
       .WillRepeatedly(Return(kParameters.initial_danger_type));
 
-  if (kParameters.initial_danger_level != download_util::NOT_DANGEROUS) {
+  if (kParameters.initial_danger_level != DownloadFileType::NOT_DANGEROUS) {
     DownloadItemModel(download_item.get())
         .SetDangerLevel(kParameters.initial_danger_level);
   }
 
   if (kParameters.expected_danger_type !=
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
     EXPECT_CALL(*download_item,
                 OnContentCheckCompleted(kParameters.expected_danger_type));
   } else {
     EXPECT_CALL(*download_item, OnContentCheckCompleted(_)).Times(0);
   }
 
   base::RunLoop run_loop;
   ASSERT_FALSE(delegate()->ShouldCompleteDownload(download_item.get(),
                                                   run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 #endif  // FULL_SAFE_BROWSING