Use FileTypePolicies for download danger classifications.

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"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/value_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
-#include "chrome/browser/download/download_extensions.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_target_determiner.h"
 #include "chrome/browser/download/download_target_info.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/safe_browsing/file_type_policies.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/prefs/pref_service.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
@@ skipping 17 matching lines @@
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Ref;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::ReturnRefOfCopy;
 using ::testing::Truly;
 using ::testing::WithArg;
 using ::testing::_;
 using content::DownloadItem;
+using safe_browsing::FileTypePolicies;
+using safe_browsing::DownloadFileType;
 
 namespace {
 
 // No-op delegate.
 class NullWebContentsDelegate : public content::WebContentsDelegate {
  public:
   NullWebContentsDelegate() {}
   ~NullWebContentsDelegate() override {}
 };
 
@@ skipping 38 matching lines @@
 // Typical download test case. Used with
 // DownloadTargetDeterminerTest::RunTestCase().
 struct DownloadTestCase {
   // Type of test.
   TestCaseType test_type;
 
   // Expected danger type. Verified at the end of target determination.
   content::DownloadDangerType expected_danger_type;
 
   // Expected danger level. Verified at the end of target determination.
-  download_util::DownloadDangerLevel expected_danger_level;
+  DownloadFileType::DangerLevel expected_danger_level;
 
   // Value of DownloadItem::GetURL()
   const char* url;
 
   // Value of DownloadItem::GetMimeType()
   const char* mime_type;
 
   // Should be non-empty if |test_type| == FORCED. Value of GetForcedFilePath().
   const base::FilePath::CharType* forced_file_path;
 
@@ skipping 124 matching lines @@
   }
 
   MockDownloadTargetDeterminerDelegate* delegate() {
     return &delegate_;
   }
 
   DownloadPrefs* download_prefs() {
     return download_prefs_.get();
   }
 
+  // Shortcut
+  const FileTypePolicies* Policies() const {
+    return FileTypePolicies::GetInstance();
+  }
+
  private:
   std::unique_ptr<DownloadPrefs> download_prefs_;
   ::testing::NiceMock<MockDownloadTargetDeterminerDelegate> delegate_;
   NullWebContentsDelegate web_contents_delegate_;
   base::ScopedTempDir test_download_dir_;
   base::FilePath test_virtual_dir_;
 };
 
 void DownloadTargetDeterminerTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
@@ skipping 220 matching lines @@
       .Append(path.BaseName());
   if (new_path.MatchesExtension(FILE_PATH_LITERAL(".remove")))
     new_path = new_path.RemoveExtension();
   callback.Run(new_path, DownloadPathReservationTracker::UNIQUIFY);
 }
 
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_Basic) {
   const DownloadTestCase kBasicTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 2: Automatic Dangerous
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Forced Safe
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
        FILE_PATH_LITERAL("forced-foo.txt"),
 
        FILE_PATH_LITERAL("forced-foo.txt"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
   // The test assumes that .crx files have a danger level of
   // ALLOW_ON_USER_GESTURE.
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   RunTestCasesWithActiveItem(kBasicTestCases, arraysize(kBasicTestCases));
 }
 
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_CancelSaveAs) {
   const DownloadTestCase kCancelSaveAsTestCases[] = {
       {// 0: Save_As Safe, Cancelled.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL(""), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_LOCAL_PATH}};
   ON_CALL(*delegate(), PromptUserForDownloadPath(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(base::FilePath())));
   RunTestCasesWithActiveItem(kCancelSaveAsTestCases,
                              arraysize(kCancelSaveAsTestCases));
 }
 
 // The SafeBrowsing check is performed early. Make sure that a download item
 // that has been marked as DANGEROUS_URL behaves correctly.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_DangerousUrl) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
       {// 0: Automatic Dangerous URL
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 1: Save As Dangerous URL
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
 
       {// 2: Forced Dangerous URL
        FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.txt", "",
-       FILE_PATH_LITERAL("forced-foo.txt"),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
+       "", FILE_PATH_LITERAL("forced-foo.txt"),
 
        FILE_PATH_LITERAL("forced-foo.txt"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Automatic Dangerous URL + Dangerous file. Dangerous URL takes
        // precedence.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.html", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.html"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 4: Save As Dangerous URL + Dangerous file
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.html", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
 
       {// 5: Forced Dangerous URL + Dangerous file
        FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.html", "",
-       FILE_PATH_LITERAL("forced-foo.html"),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
+       "", FILE_PATH_LITERAL("forced-foo.html"),
 
        FILE_PATH_LITERAL("forced-foo.html"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
   };
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL)));
   RunTestCasesWithActiveItem(kSafeBrowsingTestCases,
                              arraysize(kSafeBrowsingTestCases));
 }
 
 // The SafeBrowsing check is performed early. Make sure that a download item
 // that has been marked as MAYBE_DANGEROUS_CONTENT behaves correctly.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_MaybeDangerousContent) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
       {// 0: Automatic Maybe dangerous content
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       download_util::ALLOW_ON_USER_GESTURE,
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
        "http://phishing.example.com/foo.crx", "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 1: Automatic Maybe dangerous content with DANGEROUS type.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       download_util::DANGEROUS, "http://phishing.example.com/foo.swf", "",
+       DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.swf", "",
        FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.swf"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 2: Save As Maybe dangerous content
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.crx", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Forced Maybe dangerous content
        FORCED, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       download_util::NOT_DANGEROUS, "http://phishing.example.com/foo.crx", "",
-       FILE_PATH_LITERAL("forced-foo.crx"),
+       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
+       "", FILE_PATH_LITERAL("forced-foo.crx"),
 
        FILE_PATH_LITERAL("forced-foo.crx"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
   };
 
   // Test assumptions:
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
-  ASSERT_EQ(download_util::DANGEROUS,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::DANGEROUS,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.swf"))));
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)));
   RunTestCasesWithActiveItem(kSafeBrowsingTestCases,
                              arraysize(kSafeBrowsingTestCases));
 }
 
 // Test whether the last saved directory is used for 'Save As' downloads.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_LastSavePath) {
   const DownloadTestCase kLastSavePathTestCasesPre[] = {
       {// 0: If the last save path is empty, then the default download directory
        //    should be used.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD}};
 
   // These test cases are run with a last save path set to a non-emtpy local
   // download directory.
   const DownloadTestCase kLastSavePathTestCasesPost[] = {
       {// 0: This test case is run with the last download directory set to
        //    '<test_download_dir()>/foo'.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo/foo.txt"),
        DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Start an automatic download. This should be saved to the user's
        //    default download directory and not the last used Save As directory.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
   };
 
   // This test case is run with the last save path set to a non-empty virtual
   // directory.
   const DownloadTestCase kLastSavePathTestCasesVirtual[] = {
       {SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("bar.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_LOCAL_PATH},
   };
 
   {
     SCOPED_TRACE(testing::Message()
                  << "Running with default download path");
     base::FilePath prompt_path =
@@ skipping 36 matching lines @@
 // directory.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_DefaultVirtual) {
   // The default download directory is the virutal path.
   download_prefs()->SetDownloadPath(test_virtual_dir());
 
   {
     SCOPED_TRACE(testing::Message() << "Automatic Safe Download");
     const DownloadTestCase kAutomaticDownloadToVirtualDir = {
         AUTOMATIC,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS,
+        DownloadFileType::NOT_DANGEROUS,
         "http://example.com/foo.txt",
         "text/plain",
         FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo-local.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_LOCAL_PATH};
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, _, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-local.txt")))));
     RunTestCasesWithActiveItem(&kAutomaticDownloadToVirtualDir, 1);
   }
 
   {
     SCOPED_TRACE(testing::Message() << "Save As to virtual directory");
     const DownloadTestCase kSaveAsToVirtualDir = {
         SAVE_AS,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS,
+        DownloadFileType::NOT_DANGEROUS,
         "http://example.com/bar.txt",
         "text/plain",
         FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo-local.txt"),
         DownloadItem::TARGET_DISPOSITION_PROMPT,
 
         EXPECT_LOCAL_PATH};
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, _, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-local.txt")))));
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
         _, test_virtual_dir().AppendASCII("bar.txt"), _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             test_virtual_dir().AppendASCII("prompted.txt"))));
     RunTestCasesWithActiveItem(&kSaveAsToVirtualDir, 1);
   }
 
   {
     SCOPED_TRACE(testing::Message() << "Save As to local directory");
     const DownloadTestCase kSaveAsToLocalDir = {
         SAVE_AS,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS,
+        DownloadFileType::NOT_DANGEROUS,
         "http://example.com/bar.txt",
         "text/plain",
         FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo-x.txt"),
         DownloadItem::TARGET_DISPOSITION_PROMPT,
 
         EXPECT_CRDOWNLOAD};
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
         _, test_virtual_dir().AppendASCII("bar.txt"), _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-x.txt")))));
     RunTestCasesWithActiveItem(&kSaveAsToLocalDir, 1);
   }
 
   {
     SCOPED_TRACE(testing::Message() << "Forced safe download");
     const DownloadTestCase kForcedSafe = {
         FORCED,
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS,
+        DownloadFileType::NOT_DANGEROUS,
         "http://example.com/foo.txt",
         "",
         FILE_PATH_LITERAL("forced-foo.txt"),
 
         FILE_PATH_LITERAL("forced-foo.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_LOCAL_PATH};
     RunTestCasesWithActiveItem(&kForcedSafe, 1);
   }
 }
 
 // Test that an inactive download will still get a virtual or local download
 // path.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_InactiveDownload) {
   const DownloadTestCase kInactiveTestCases[] = {
       {AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD}};
 
   for (size_t i = 0; i < arraysize(kInactiveTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     const DownloadTestCase& test_case = kInactiveTestCases[i];
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case));
     EXPECT_CALL(*item.get(), GetState())
         .WillRepeatedly(Return(content::DownloadItem::CANCELLED));
 
     EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, _, _)).Times(0);
     EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _)).Times(0);
     EXPECT_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _)).Times(0);
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, _, _)).Times(1);
     RunTestCase(test_case, base::FilePath(), item.get());
   }
 }
 
 // If the reserved path could not be verified, then the user should see a
 // prompt.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ReservationFailed) {
   const DownloadTestCase kReservationFailedCases[] = {
       {// 0: Automatic download. Since the reservation fails, the disposition of
        // the target is to prompt, but the returned path is used.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("bar.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
   };
 
   // Setup ReserveVirtualPath() to fail.
   ON_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _))
       .WillByDefault(WithArg<4>(ScheduleCallback2(
           GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")), false)));
   RunTestCasesWithActiveItem(kReservationFailedCases,
                              arraysize(kReservationFailedCases));
 }
 
 // If the local path could not be determined, the download should be cancelled.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_LocalPathFailed) {
   const DownloadTestCase kLocalPathFailedCases[] = {
       {// 0: Automatic download.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL(""), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
   // The default download directory is the virtual path.
   download_prefs()->SetDownloadPath(test_virtual_dir());
   // Simulate failed call to DetermineLocalPath.
   EXPECT_CALL(*delegate(), DetermineLocalPath(
       _, GetPathInDownloadDir(FILE_PATH_LITERAL("virtual/foo.txt")), _))
       .WillOnce(WithArg<2>(ScheduleCallback(base::FilePath())));
   RunTestCasesWithActiveItem(kLocalPathFailedCases,
                              arraysize(kLocalPathFailedCases));
 }
 
 // Downloads that have a danger level of ALLOW_ON_USER_GESTURE should be marked
 // as safe depending on whether there was a user gesture associated with the
 // download and whether the referrer was visited prior to today.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_VisitedReferrer) {
   const DownloadTestCase kVisitedReferrerCases[] = {
       // http://visited.example.com/ is added to the history as a visit that
       // happened prior to today.
       {// 0: Safe download due to visiting referrer before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://visited.example.com/foo.crx",
+       DownloadFileType::NOT_DANGEROUS, "http://visited.example.com/foo.crx",
        "application/xml", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Dangerous due to not having visited referrer before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       download_util::ALLOW_ON_USER_GESTURE,
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
        "http://not-visited.example.com/foo.crx", "application/xml",
        FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 2: Safe because the user is being prompted.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://not-visited.example.com/foo.crx",
-       "application/xml", FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS,
+       "http://not-visited.example.com/foo.crx", "application/xml",
+       FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 3: Safe because of forced path.
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://not-visited.example.com/foo.crx",
-       "application/xml", FILE_PATH_LITERAL("foo.crx"),
+       DownloadFileType::NOT_DANGEROUS,
+       "http://not-visited.example.com/foo.crx", "application/xml",
+       FILE_PATH_LITERAL("foo.crx"),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
   // This test assumes that the danger level of .crx files is
   // ALLOW_ON_USER_GESTURE.
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
 
   // First the history service must exist.
   ASSERT_TRUE(profile()->CreateHistoryService(false, false));
 
   GURL url("http://visited.example.com/visited-link.html");
   // The time of visit is picked to be several seconds prior to the most recent
   // midnight.
   base::Time time_of_visit(
       base::Time::Now().LocalMidnight() - base::TimeDelta::FromSeconds(10));
   history::HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile(),
                                            ServiceAccessType::EXPLICIT_ACCESS);
   ASSERT_TRUE(history_service);
   history_service->AddPage(url, time_of_visit, history::SOURCE_BROWSED);
 
   RunTestCasesWithActiveItem(kVisitedReferrerCases,
                              arraysize(kVisitedReferrerCases));
 }
 
 // These test cases are run with "Prompt for download" user preference set to
 // true.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_PromptAlways) {
   const DownloadTestCase kPromptingTestCases[] = {
       {// 0: Safe Automatic - Should prompt because of "Prompt for download"
        //    preference setting.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Safe Forced - Shouldn't prompt.
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL("foo.txt"),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL("foo.txt"),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
 
       {// 2: Automatic - The filename extension is marked as one that we will
        //    open automatically. Shouldn't prompt.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.dummy", "",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.dummy", "",
        FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.dummy"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
   };
 
   SetPromptForDownload(true);
   EnableAutoOpenBasedOnExtension(
       base::FilePath(FILE_PATH_LITERAL("dummy.dummy")));
   RunTestCasesWithActiveItem(kPromptingTestCases,
                              arraysize(kPromptingTestCases));
 }
 
 #if defined(ENABLE_EXTENSIONS)
 // These test cases are run with "Prompt for download" user preference set to
 // true. Automatic extension downloads shouldn't cause prompting.
 // Android doesn't support extensions.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_PromptAlways_Extension) {
   const DownloadTestCase kPromptingTestCases[] = {
     {// 0: Automatic Browser Extension download. - Shouldn't prompt for browser
      //    extension downloads even if "Prompt for download" preference is set.
      AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-     download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
+     DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
      extensions::Extension::kMimeType, FILE_PATH_LITERAL(""),
 
      FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
      EXPECT_UNCONFIRMED},
 
 #if defined(OS_WIN)
     {// 1: Automatic User Script - Shouldn't prompt for user script downloads
      //    even if "Prompt for download" preference is set. ".js" files are
      //    considered dangerous on Windows.
      AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-     download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.user.js", "",
+     DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.user.js", "",
      FILE_PATH_LITERAL(""),
 
      FILE_PATH_LITERAL("foo.user.js"),
      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
      EXPECT_UNCONFIRMED},
 #else
     {// 1: Automatic User Script - Shouldn't prompt for user script downloads
      //    even if "Prompt for download" preference is set.
      AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-     download_util::NOT_DANGEROUS, "http://example.com/foo.user.js", "",
+     DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.user.js", "",
      FILE_PATH_LITERAL(""),
 
      FILE_PATH_LITERAL("foo.user.js"),
      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
      EXPECT_CRDOWNLOAD},
 #endif
   };
 
   SetPromptForDownload(true);
   RunTestCasesWithActiveItem(kPromptingTestCases,
                              arraysize(kPromptingTestCases));
 }
 #endif  // defined(ENABLE_EXTENSIONS)
 
 // If the download path is managed, then we don't show any prompts.
 // Note that if the download path is managed, then PromptForDownload() is false.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ManagedPath) {
   const DownloadTestCase kManagedPathTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
   };
 
   SetManagedDownloadPath(test_download_dir());
   ASSERT_TRUE(download_prefs()->IsDownloadPathManaged());
   RunTestCasesWithActiveItem(kManagedPathTestCases,
                              arraysize(kManagedPathTestCases));
 }
 
 // Test basic functionality supporting extensions that want to override download
 // filenames.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_NotifyExtensionsSafe) {
   const DownloadTestCase kNotifyExtensionsTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("overridden/foo.txt"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("overridden/foo.txt"),
        DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 2: Automatic Dangerous
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
+       "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("overridden/foo.crx"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Forced Safe
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
        FILE_PATH_LITERAL("forced-foo.txt"),
 
        FILE_PATH_LITERAL("forced-foo.txt"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
   ON_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillByDefault(Invoke(&NotifyExtensionsOverridePath));
   RunTestCasesWithActiveItem(kNotifyExtensionsTestCases,
                              arraysize(kNotifyExtensionsTestCases));
 }
 
 // Test that filenames provided by extensions are passed into SafeBrowsing
 // checks and dangerous download checks.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_NotifyExtensionsUnsafe) {
   const DownloadTestCase kNotHandledBySafeBrowsing = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-      download_util::ALLOW_ON_USER_GESTURE,
+      DownloadFileType::ALLOW_ON_USER_GESTURE,
       "http://example.com/foo.crx.remove",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("overridden/foo.crx"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_UNCONFIRMED};
 
   const DownloadTestCase kHandledBySafeBrowsing = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-      download_util::ALLOW_ON_USER_GESTURE,
+      DownloadFileType::ALLOW_ON_USER_GESTURE,
       "http://example.com/foo.crx.remove",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("overridden/foo.crx"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_UNCONFIRMED};
 
   ON_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillByDefault(Invoke(&NotifyExtensionsOverridePath));
   RunTestCasesWithActiveItem(&kNotHandledBySafeBrowsing, 1);
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)));
   RunTestCasesWithActiveItem(&kHandledBySafeBrowsing, 1);
 }
 
 // Test that conflict actions set by extensions are passed correctly into
 // ReserveVirtualPath.
 TEST_F(DownloadTargetDeterminerTest,
        TargetDeterminer_NotifyExtensionsConflict) {
   const DownloadTestCase kNotifyExtensionsTestCase = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.txt",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("overridden/foo.txt"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_CRDOWNLOAD};
 
   const DownloadTestCase& test_case = kNotifyExtensionsTestCase;
@@ skipping 27 matching lines @@
   RunTestCase(test_case, base::FilePath(), item.get());
 }
 
 // Test that relative paths returned by extensions are always relative to the
 // default downloads path.
 TEST_F(DownloadTargetDeterminerTest,
        TargetDeterminer_NotifyExtensionsDefaultPath) {
   const DownloadTestCase kNotifyExtensionsTestCase = {
       SAVE_AS,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.txt",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("overridden/foo.txt"),
       DownloadItem::TARGET_DISPOSITION_PROMPT,
 
       EXPECT_CRDOWNLOAD};
 
   const DownloadTestCase& test_case = kNotifyExtensionsTestCase;
@@ skipping 21 matching lines @@
        TargetDeterminer_InitialVirtualPathUnsafe) {
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.html");
 
   const DownloadTestCase kInitialPathTestCase = {
       // 0: Save As Save. The path generated based on the DownloadItem is safe,
       // but the initial path is unsafe. However, the download is not considered
       // dangerous since the user has been prompted.
       SAVE_AS,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.txt",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
       kInitialPath,
       DownloadItem::TARGET_DISPOSITION_PROMPT,
 
       EXPECT_CRDOWNLOAD};
 
   const DownloadTestCase& test_case = kInitialPathTestCase;
@@ skipping 15 matching lines @@
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ResumedNoPrompt) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.txt");
 
   const DownloadTestCase kResumedTestCases[] = {
       {// 0: Automatic Safe: Initial path is ignored since the user has not been
        // prompted before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
        FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe: Initial path used.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
        FILE_PATH_LITERAL(""),
 
        kInitialPath, DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {// 2: Automatic Dangerous: Initial path is ignored since the user hasn't
        // been prompted before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
+       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
        FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Forced Safe: Initial path is ignored due to the forced path.
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
        FILE_PATH_LITERAL("forced-foo.txt"),
 
        FILE_PATH_LITERAL("forced-foo.txt"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
   // The test assumes that .crx files have a danger level of
   // ALLOW_ON_USER_GESTURE.
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   for (size_t i = 0; i < arraysize(kResumedTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     const DownloadTestCase& test_case = kResumedTestCases[i];
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case));
     base::FilePath expected_path =
         GetPathInDownloadDir(test_case.expected_local_path);
     ON_CALL(*item.get(), GetLastReason())
         .WillByDefault(Return(
@@ skipping 14 matching lines @@
 
 // Test that a forced download doesn't prompt, even if the interrupt reason
 // suggests that the target path may not be suitable for downloads.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ResumedForcedDownload) {
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.txt");
   const DownloadTestCase kResumedForcedDownload = {
       // 3: Forced Safe
       FORCED,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.txt",
       "",
       FILE_PATH_LITERAL("forced-foo.txt"),
 
       FILE_PATH_LITERAL("forced-foo.txt"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_LOCAL_PATH};
 
   const DownloadTestCase& test_case = kResumedForcedDownload;
@@ skipping 20 matching lines @@
 // error is set to NO_SPACE.
 TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ResumedWithPrompt) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType* kInitialPath =
       FILE_PATH_LITERAL("some_path/bar.txt");
 
   const DownloadTestCase kResumedTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"),
 #if BUILDFLAG(ANDROID_JAVA_UI)
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 #else
        DownloadItem::TARGET_DISPOSITION_PROMPT,
 #endif
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "text/plain",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
+       "text/plain", FILE_PATH_LITERAL(""),
 
-       kInitialPath,
-       DownloadItem::TARGET_DISPOSITION_PROMPT,
+       kInitialPath, DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
-      {// 2: Automatic Dangerous
-       AUTOMATIC,
+      {
+          // 2: Automatic Dangerous
+          AUTOMATIC,
 #if BUILDFLAG(ANDROID_JAVA_UI)
-       // If we don't prompt user, the file will be treated as dangerous.
-       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       download_util::ALLOW_ON_USER_GESTURE,
+          // If we don't prompt user, the file will be treated as dangerous.
+          content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+          DownloadFileType::ALLOW_ON_USER_GESTURE,
 #else
-       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       download_util::NOT_DANGEROUS,
+          content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+          DownloadFileType::NOT_DANGEROUS,
 #endif
-       "http://example.com/foo.crx", "",
-       FILE_PATH_LITERAL(""),
+          "http://example.com/foo.crx", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"),
+          FILE_PATH_LITERAL("foo.crx"),
 #if BUILDFLAG(ANDROID_JAVA_UI)
-       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-       // Dangerous download will have an unconfirmed intermediate file name.
-       EXPECT_UNCONFIRMED,
+          DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+          // Dangerous download will have an unconfirmed intermediate file name.
+          EXPECT_UNCONFIRMED,
 #else
-       DownloadItem::TARGET_DISPOSITION_PROMPT,
-       EXPECT_CRDOWNLOAD,
+          DownloadItem::TARGET_DISPOSITION_PROMPT, EXPECT_CRDOWNLOAD,
 #endif
       },
   };
 
   // The test assumes that .xml files have a danger level of
   // ALLOW_ON_USER_GESTURE.
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
   for (size_t i = 0; i < arraysize(kResumedTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     download_prefs()->SetSaveFilePath(test_download_dir());
     const DownloadTestCase& test_case = kResumedTestCases[i];
     base::FilePath expected_path =
         GetPathInDownloadDir(test_case.expected_local_path);
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case));
     ON_CALL(*item.get(), GetLastReason())
@@ skipping 29 matching lines @@
     // Value of DownloadItem::GetFullPath() during test run, relative
     // to test download path.
     const base::FilePath::CharType* initial_intermediate_path;
 
     // Expected intermediate path relatvie to the test download path. An exact
     // match is performed if this string is non-empty. Ignored otherwise.
     const base::FilePath::CharType* expected_intermediate_path;
   } kIntermediateNameTestCases[] = {
       {{// 0: Automatic Safe
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.txt",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
         "text/plain", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        FILE_PATH_LITERAL("bar.txt.crdownload"),
        FILE_PATH_LITERAL("foo.txt.crdownload")},
 
       {{// 1: Save_As Safe
         SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.txt",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
         "text/plain", FILE_PATH_LITERAL(""),
 
         kInitialPath, DownloadItem::TARGET_DISPOSITION_PROMPT,
 
         EXPECT_CRDOWNLOAD},
        FILE_PATH_LITERAL("foo.txt.crdownload"),
        FILE_PATH_LITERAL("some_path/bar.txt.crdownload")},
 
       {{// 2: Automatic Dangerous
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-        download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
-        FILE_PATH_LITERAL(""),
+        DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
+        "", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.crx"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_UNCONFIRMED},
        FILE_PATH_LITERAL("Unconfirmed abcd.crdownload"),
        FILE_PATH_LITERAL("Unconfirmed abcd.crdownload")},
 
       {{// 3: Automatic Dangerous
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-        download_util::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
-        FILE_PATH_LITERAL(""),
+        DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
+        "", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.crx"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_UNCONFIRMED},
        FILE_PATH_LITERAL("other_path/Unconfirmed abcd.crdownload"),
        // Rely on the EXPECT_UNCONFIRMED check in the general test settings. A
        // new intermediate path of the form "Unconfirmed <number>.crdownload"
        // should be generated for this case since the initial intermediate path
        // is in the wrong directory.
        FILE_PATH_LITERAL("")},
 
       {{// 3: Forced Safe: Initial path is ignored due to the forced path.
         FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.txt", "",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt", "",
         FILE_PATH_LITERAL("forced-foo.txt"),
 
         FILE_PATH_LITERAL("forced-foo.txt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_LOCAL_PATH},
        FILE_PATH_LITERAL("forced-foo.txt"),
        FILE_PATH_LITERAL("forced-foo.txt")},
   };
 
   // The test assumes that .crx files have a danger level of
   // ALLOW_ON_USER_GESTURE.
-  ASSERT_EQ(download_util::ALLOW_ON_USER_GESTURE,
-            download_util::GetFileDangerLevel(
+  ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
+            Policies()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
 
   for (size_t i = 0; i < arraysize(kIntermediateNameTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     const IntermediateNameTestCase& test_case = kIntermediateNameTestCases[i];
     std::unique_ptr<content::MockDownloadItem> item(
         CreateActiveDownloadItem(i, test_case.general));
 
     ON_CALL(*item.get(), GetLastReason())
         .WillByDefault(Return(
@@ skipping 25 matching lines @@
 
   struct MIMETypeTestCase {
     // General test case settings.
     DownloadTestCase general;
 
     // Expected MIME type for test case.
     const char* expected_mime_type;
   } kMIMETypeTestCases[] = {
       {{// 0:
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.png", "image/png",
-        FILE_PATH_LITERAL(""),
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.png",
+        "image/png", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.png"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        "image/png"},
       {{// 1: Empty MIME type in response.
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.png", "",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.png", "",
         FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.png"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        "image/png"},
       {{// 2: Forced path.
         FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.abc", "",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.abc", "",
         FILE_PATH_LITERAL("foo.png"),
 
         FILE_PATH_LITERAL("foo.png"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        "image/png"},
       {{// 3: Unknown file type.
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.notarealext", "",
-        FILE_PATH_LITERAL(""),
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.notarealext",
+        "", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.notarealext"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        ""},
       {{// 4: Unknown file type.
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.notarealext",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.notarealext",
         "image/png", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("foo.notarealext"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        ""},
       {{// 5: x-x509-user-cert mime-type.
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-        download_util::NOT_DANGEROUS, "http://example.com/foo.notarealext",
+        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.notarealext",
         "application/x-x509-user-cert", FILE_PATH_LITERAL(""),
 
         FILE_PATH_LITERAL("user.crt"),
         DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
         EXPECT_CRDOWNLOAD},
        ""},
 
   };
 
@@ skipping 131 matching lines @@
        TargetDeterminer_CheckForSecureHandling_PPAPI) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType kInitialPath[] =
       FILE_PATH_LITERAL("some_path/bar.txt");
   const char kTestMIMEType[] = "application/x-example-should-not-exist";
 
   DownloadTestCase kSecureHandlingTestCase = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.fakeext",
       "",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("foo.fakeext"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_CRDOWNLOAD};
 
   content::PluginService* plugin_service =
@@ skipping 48 matching lines @@
        TargetDeterminer_CheckForSecureHandling_BrowserPlugin) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType kInitialPath[] =
       FILE_PATH_LITERAL("some_path/bar.txt");
   const char kTestMIMEType[] = "application/x-example-should-not-exist";
 
   DownloadTestCase kSecureHandlingTestCase = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download_util::NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
       "http://example.com/foo.fakeext",
       "",
       FILE_PATH_LITERAL(""),
 
       FILE_PATH_LITERAL("foo.fakeext"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_CRDOWNLOAD};
 
   content::PluginService* plugin_service =
@@ skipping 38 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  // defined(ENABLE_PLUGINS)
 
 }  // namespace