[downloads] Move platform specific code out of DownloadTargetDeterminer.

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 <string>
+#include <vector>
+
 #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/memory/ptr_util.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_confirmation_result.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/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/file_type_policies.h"
+#include "chrome/common/safe_browsing/file_type_policies_test_util.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 66 matching lines @@
   SAVE_AS,
   AUTOMATIC,
   FORCED  // Requires that forced_file_path be non-empty.
 };
 
 // Used with DownloadTestCase. Type of intermediate filename to expect.
 enum TestCaseExpectIntermediate {
   EXPECT_CRDOWNLOAD,   // Expect path/to/target.crdownload.
   EXPECT_UNCONFIRMED,  // Expect path/to/Unconfirmed xxx.crdownload.
   EXPECT_LOCAL_PATH,   // Expect target path.
+  EXPECT_EMPTY,  // Expect empty path. Only for downloads which will be marked

[svaldez, 2016/10/28 17:29:36]

Align comments?

[asanka, 2016/11/07 19:50:15]

Done. The former was what clang-format did on its own given a long line. Turns
out if I manually align and wrap it, clang-format leaves it alone.

+                 // interrupted or cancelled.
 };
 
 // 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;
@@ skipping 24 matching lines @@
 
 class MockDownloadTargetDeterminerDelegate
     : public DownloadTargetDeterminerDelegate {
  public:
   MOCK_METHOD3(CheckDownloadUrl,
                void(content::DownloadItem*, const base::FilePath&,
                     const CheckDownloadUrlCallback&));
   MOCK_METHOD3(NotifyExtensions,
                void(content::DownloadItem*, const base::FilePath&,
                     const NotifyExtensionsCallback&));
-  MOCK_METHOD3(PromptUserForDownloadPath,
-               void(content::DownloadItem*, const base::FilePath&,
+  MOCK_METHOD4(RequestConfirmation,
+               void(content::DownloadItem*,
+                    const base::FilePath&,
+                    DownloadConfirmationReason,
                     const FileSelectedCallback&));
   MOCK_METHOD3(DetermineLocalPath,
                void(DownloadItem*, const base::FilePath&,
                     const LocalPathCallback&));
   MOCK_METHOD5(ReserveVirtualPath,
                void(DownloadItem*, const base::FilePath&, bool,
                     DownloadPathReservationTracker::FilenameConflictAction,
                     const ReservedPathCallback&));
   MOCK_METHOD2(GetFileMimeType,
                void(const base::FilePath&,
                     const GetFileMimeTypeCallback&));
 
   void SetupDefaults() {
     ON_CALL(*this, CheckDownloadUrl(_, _, _))
         .WillByDefault(WithArg<2>(
             ScheduleCallback(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)));
     ON_CALL(*this, NotifyExtensions(_, _, _))
         .WillByDefault(WithArg<2>(
             ScheduleCallback2(base::FilePath(),
                               DownloadPathReservationTracker::UNIQUIFY)));
     ON_CALL(*this, ReserveVirtualPath(_, _, _, _, _))
         .WillByDefault(Invoke(
             &MockDownloadTargetDeterminerDelegate::NullReserveVirtualPath));
-    ON_CALL(*this, PromptUserForDownloadPath(_, _, _))
-        .WillByDefault(Invoke(
-            &MockDownloadTargetDeterminerDelegate::NullPromptUser));
+    ON_CALL(*this, RequestConfirmation(_, _, _, _))
+        .WillByDefault(
+            Invoke(&MockDownloadTargetDeterminerDelegate::NullPromptUser));
     ON_CALL(*this, DetermineLocalPath(_, _, _))
         .WillByDefault(Invoke(
             &MockDownloadTargetDeterminerDelegate::NullDetermineLocalPath));
     ON_CALL(*this, GetFileMimeType(_, _))
         .WillByDefault(WithArg<1>(
             ScheduleCallback("")));
   }
  private:
   static void NullReserveVirtualPath(
       DownloadItem* download,
       const base::FilePath& virtual_path,
       bool create_directory,
       DownloadPathReservationTracker::FilenameConflictAction conflict_action,
       const DownloadTargetDeterminerDelegate::ReservedPathCallback& callback);
-  static void NullPromptUser(
-      DownloadItem* download, const base::FilePath& suggested_path,
-      const FileSelectedCallback& callback);
+  static void NullPromptUser(DownloadItem* download,
+                             const base::FilePath& suggested_path,
+                             DownloadConfirmationReason reason,
+                             const FileSelectedCallback& callback);
   static void NullDetermineLocalPath(
       DownloadItem* download, const base::FilePath& virtual_path,
       const LocalPathCallback& callback);
 };
 
 class DownloadTargetDeterminerTest : public ChromeRenderViewHostTestHarness {
  public:
   // ::testing::Test
   void SetUp() override;
   void TearDown() override;
 
   // Creates MockDownloadItem and sets up default expectations.
-  content::MockDownloadItem* CreateActiveDownloadItem(
+  std::unique_ptr<content::MockDownloadItem> CreateActiveDownloadItem(
       int32_t id,
       const DownloadTestCase& test_case);
 
   // Sets the AutoOpenBasedOnExtension user preference for |path|.
   void EnableAutoOpenBasedOnExtension(const base::FilePath& path);
 
   // Set the kDownloadDefaultDirectory managed preference to |path|.
   void SetManagedDownloadPath(const base::FilePath& path);
 
   // Set the kPromptForDownload user preference to |prompt|.
@@ skipping 35 matching lines @@
   }
 
   MockDownloadTargetDeterminerDelegate* delegate() {
     return &delegate_;
   }
 
   DownloadPrefs* download_prefs() {
     return download_prefs_.get();
   }
 
-  // Shortcut
-  const FileTypePolicies* Policies() const {
-    return FileTypePolicies::GetInstance();
-  }
+ private:
+  void SetUpFileTypePolicies();
 
- 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_;
+  safe_browsing::FileTypePoliciesTestOverlay file_type_configuration_;
 };
 
 void DownloadTargetDeterminerTest::SetUp() {
   ChromeRenderViewHostTestHarness::SetUp();
   CHECK(profile());
   download_prefs_.reset(new DownloadPrefs(profile()));
   web_contents()->SetDelegate(&web_contents_delegate_);
   ASSERT_TRUE(test_download_dir_.CreateUniqueTempDir());
   test_virtual_dir_ = test_download_dir().Append(FILE_PATH_LITERAL("virtual"));
   download_prefs_->SetDownloadPath(test_download_dir());
   delegate_.SetupDefaults();
+  SetUpFileTypePolicies();
 }
 
 void DownloadTargetDeterminerTest::TearDown() {
   download_prefs_.reset();
   ChromeRenderViewHostTestHarness::TearDown();
 }
 
-content::MockDownloadItem*
+std::unique_ptr<content::MockDownloadItem>
 DownloadTargetDeterminerTest::CreateActiveDownloadItem(
     int32_t id,
     const DownloadTestCase& test_case) {
-  content::MockDownloadItem* item =
-      new ::testing::NiceMock<content::MockDownloadItem>();
+  std::unique_ptr<content::MockDownloadItem> item =
+      base::MakeUnique<::testing::NiceMock<content::MockDownloadItem>>();
   GURL download_url(test_case.url);
   std::vector<GURL> url_chain;
   url_chain.push_back(download_url);
   base::FilePath forced_file_path =
       GetPathInDownloadDir(test_case.forced_file_path);
   DownloadItem::TargetDisposition initial_disposition =
       (test_case.test_type == SAVE_AS) ?
       DownloadItem::TARGET_DISPOSITION_PROMPT :
       DownloadItem::TARGET_DISPOSITION_OVERWRITE;
   EXPECT_EQ(test_case.test_type == FORCED,
@@ skipping 82 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
 }
 
 std::unique_ptr<DownloadTargetInfo>
 DownloadTargetDeterminerTest::RunDownloadTargetDeterminer(
     const base::FilePath& initial_virtual_path,
     content::MockDownloadItem* item) {
   std::unique_ptr<DownloadTargetInfo> target_info;
   base::RunLoop run_loop;
   DownloadTargetDeterminer::Start(
-      item, initial_virtual_path, download_prefs_.get(), delegate(),
-      base::Bind(&CompletionCallbackWrapper,
-                 run_loop.QuitClosure(),
+      item, initial_virtual_path, DownloadPathReservationTracker::UNIQUIFY,
+      download_prefs_.get(), delegate(),
+      base::Bind(&CompletionCallbackWrapper, run_loop.QuitClosure(),
                  &target_info));
   run_loop.Run();
   ::testing::Mock::VerifyAndClearExpectations(delegate());
   return target_info;
 }
 
 void DownloadTargetDeterminerTest::RunTestCasesWithActiveItem(
     const DownloadTestCase test_cases[],
     size_t test_case_count) {
   for (size_t i = 0; i < test_case_count; ++i) {
-    std::unique_ptr<content::MockDownloadItem> item(
-        CreateActiveDownloadItem(i, test_cases[i]));
+    std::unique_ptr<content::MockDownloadItem> item =
+        CreateActiveDownloadItem(i, test_cases[i]);
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     RunTestCase(test_cases[i], base::FilePath(), item.get());
   }
 }
 
 void DownloadTargetDeterminerTest::VerifyDownloadTarget(
     const DownloadTestCase& test_case,
     const DownloadTargetInfo* target_info) {
   base::FilePath expected_local_path(
       GetPathInDownloadDir(test_case.expected_local_path));
@@ skipping 25 matching lines @@
           FILE_PATH_LITERAL(".crdownload")));
       EXPECT_EQ(0u,
                 target_info->intermediate_path.BaseName().value().find(
                     FILE_PATH_LITERAL("Unconfirmed ")));
       break;
 
     case EXPECT_LOCAL_PATH:
       EXPECT_EQ(expected_local_path.value(),
                 target_info->intermediate_path.value());
       break;
+
+    case EXPECT_EMPTY:
+      EXPECT_TRUE(target_info->intermediate_path.empty());
+      break;
   }
 }
 
+void DownloadTargetDeterminerTest::SetUpFileTypePolicies() {
+  std::unique_ptr<safe_browsing::DownloadFileTypeConfig> fake_file_type_config =
+      base::MakeUnique<safe_browsing::DownloadFileTypeConfig>();
+  auto file_type = fake_file_type_config->mutable_default_file_type();
+  file_type->set_uma_value(-1);
+  auto platform_settings = file_type->add_platform_settings();
+  platform_settings->set_danger_level(DownloadFileType::NOT_DANGEROUS);
+  platform_settings->set_auto_open_hint(DownloadFileType::ALLOW_AUTO_OPEN);
+
+  file_type = fake_file_type_config->add_file_types();
+  file_type->set_extension("kindabad");
+  file_type->set_uma_value(-1);
+  platform_settings = file_type->add_platform_settings();
+  platform_settings->set_danger_level(DownloadFileType::ALLOW_ON_USER_GESTURE);
+  platform_settings->set_auto_open_hint(DownloadFileType::ALLOW_AUTO_OPEN);
+
+  file_type = fake_file_type_config->add_file_types();
+  file_type->set_extension("bad");
+  file_type->set_uma_value(-1);
+  platform_settings = file_type->add_platform_settings();
+  platform_settings->set_danger_level(DownloadFileType::DANGEROUS);
+  platform_settings->set_auto_open_hint(DownloadFileType::DISALLOW_AUTO_OPEN);
+
+  file_type_configuration_.SwapConfig(fake_file_type_config);
+}
+
 // static
 void MockDownloadTargetDeterminerDelegate::NullReserveVirtualPath(
     DownloadItem* download,
     const base::FilePath& virtual_path,
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     const DownloadTargetDeterminerDelegate::ReservedPathCallback& callback) {
-  callback.Run(virtual_path, true);
+  callback.Run(virtual_path, DownloadTargetResult::SUCCESS);
 }
 
 // static
 void MockDownloadTargetDeterminerDelegate::NullPromptUser(
-    DownloadItem* download, const base::FilePath& suggested_path,
+    DownloadItem* download,
+    const base::FilePath& suggested_path,
+    DownloadConfirmationReason reason,
     const FileSelectedCallback& callback) {
-  callback.Run(suggested_path);
+  callback.Run(DownloadConfirmationResult::CONFIRMED, suggested_path);
 }
 
 // static
 void MockDownloadTargetDeterminerDelegate::NullDetermineLocalPath(
     DownloadItem* download, const base::FilePath& virtual_path,
     const LocalPathCallback& callback) {
   callback.Run(virtual_path);
 }
 
 // NotifyExtensions implementation that overrides the path so that the target
 // file is in a subdirectory called 'overridden'. If the extension is '.remove',
 // the extension is removed.
 void NotifyExtensionsOverridePath(
     content::DownloadItem* download,
     const base::FilePath& path,
     const DownloadTargetDeterminerDelegate::NotifyExtensionsCallback&
         callback) {
   base::FilePath new_path =
       base::FilePath()
       .AppendASCII("overridden")
       .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) {
+TEST_F(DownloadTargetDeterminerTest, Basic) {
   const DownloadTestCase kBasicTestCases[] = {
-      {// 0: Automatic Safe
+      {// Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-      {// 1: Save_As Safe
+      {// Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
-      {// 2: Automatic Dangerous
+      {// Automatic Dangerous
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
+       "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
-      {// 3: Forced Safe
+      {// Forced Safe
        FORCED, content::DOWNLOAD_DANGER_TYPE_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},
   };
 
-  // The test assumes that .crx files have a danger level of
+  // The test assumes that .kindabad files have a danger level of
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
   RunTestCasesWithActiveItem(kBasicTestCases, arraysize(kBasicTestCases));
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_CancelSaveAs) {
+TEST_F(DownloadTargetDeterminerTest, CancelSaveAs) {
   const DownloadTestCase kCancelSaveAsTestCases[] = {
       {// 0: Save_As Safe, Cancelled.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        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())));
+  ON_CALL(*delegate(), RequestConfirmation(_, _, _, _))
+      .WillByDefault(WithArg<3>(ScheduleCallback2(
+          DownloadConfirmationResult::CANCELED, base::FilePath())));
   RunTestCasesWithActiveItem(kCancelSaveAsTestCases,
                              arraysize(kCancelSaveAsTestCases));
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
 // 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) {
+TEST_F(DownloadTargetDeterminerTest, DangerousUrl) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
       {// 0: Automatic Dangerous URL
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
        DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
        "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {// 1: Save As Dangerous URL
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
        DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.txt",
        "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
       {// 2: Forced Dangerous URL
        FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
        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,
        DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
        "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.html"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {// 4: Save As Dangerous URL + Dangerous file
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
        DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.html",
        "", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
       {// 5: Forced Dangerous URL + Dangerous file
        FORCED, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL,
        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) {
+TEST_F(DownloadTargetDeterminerTest, MaybeDangerousContent) {
   const DownloadTestCase kSafeBrowsingTestCases[] = {
       {// 0: Automatic Maybe dangerous content
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
        DownloadFileType::ALLOW_ON_USER_GESTURE,
-       "http://phishing.example.com/foo.crx", "", FILE_PATH_LITERAL(""),
+       "http://phishing.example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 1: Automatic Maybe dangerous content with DANGEROUS type.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.swf", "",
+       DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.bad", "",
        FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.swf"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.bad"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
-
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {// 2: Save As Maybe dangerous content
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS,
+       "http://phishing.example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_UNCONFIRMED},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
       {// 3: Forced Maybe dangerous content
        FORCED, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
-       DownloadFileType::NOT_DANGEROUS, "http://phishing.example.com/foo.crx",
-       "", FILE_PATH_LITERAL("forced-foo.crx"),
+       DownloadFileType::NOT_DANGEROUS,
+       "http://phishing.example.com/foo.kindabad", "",
+       FILE_PATH_LITERAL("forced-foo.kindabad"),
 
-       FILE_PATH_LITERAL("forced-foo.crx"),
+       FILE_PATH_LITERAL("forced-foo.kindabad"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
   };
 
   // Test assumptions:
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
   ASSERT_EQ(DownloadFileType::DANGEROUS,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.swf"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.bad"))));
 
   ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
       .WillByDefault(WithArg<2>(ScheduleCallback(
           content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)));
   RunTestCasesWithActiveItem(kSafeBrowsingTestCases,
                              arraysize(kSafeBrowsingTestCases));
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
 // Test whether the last saved directory is used for 'Save As' downloads.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_LastSavePath) {
+TEST_F(DownloadTargetDeterminerTest, 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,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD}};
@@ skipping 33 matching lines @@
        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 =
         GetPathInDownloadDir(FILE_PATH_LITERAL("foo.txt"));
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, prompt_path, _));
+    EXPECT_CALL(*delegate(),
+                RequestConfirmation(_, prompt_path,
+                                    DownloadConfirmationReason::SAVE_AS, _));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesPre,
                                arraysize(kLastSavePathTestCasesPre));
   }
 
   // Try with a non-empty last save path.
   {
     SCOPED_TRACE(testing::Message()
                  << "Running with local last_selected_directory");
     download_prefs()->SetSaveFilePath(test_download_dir().AppendASCII("foo"));
     base::FilePath prompt_path =
         GetPathInDownloadDir(FILE_PATH_LITERAL("foo/foo.txt"));
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, prompt_path, _));
+    EXPECT_CALL(*delegate(),
+                RequestConfirmation(_, prompt_path,
+                                    DownloadConfirmationReason::SAVE_AS, _));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesPost,
                                arraysize(kLastSavePathTestCasesPost));
   }
 
   // And again, but this time use a virtual directory.
   {
     SCOPED_TRACE(testing::Message()
                  << "Running with virtual last_selected_directory");
     base::FilePath last_selected_dir = test_virtual_dir().AppendASCII("foo");
     base::FilePath virtual_path = last_selected_dir.AppendASCII("foo.txt");
     download_prefs()->SetSaveFilePath(last_selected_dir);
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(
-        _, last_selected_dir.AppendASCII("foo.txt"), _));
+    EXPECT_CALL(*delegate(),
+                RequestConfirmation(_, last_selected_dir.AppendASCII("foo.txt"),
+                                    DownloadConfirmationReason::SAVE_AS, _));
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, virtual_path, _))
         .WillOnce(WithArg<2>(ScheduleCallback(
             GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")))));
     RunTestCasesWithActiveItem(kLastSavePathTestCasesVirtual,
                                arraysize(kLastSavePathTestCasesVirtual));
   }
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
 // These tests are run with the default downloads folder set to a virtual
 // directory.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_DefaultVirtual) {
+TEST_F(DownloadTargetDeterminerTest, 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,
         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);
   }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
   {
     SCOPED_TRACE(testing::Message() << "Save As to virtual directory");
     const DownloadTestCase kSaveAsToVirtualDir = {
         SAVE_AS,
         content::DOWNLOAD_DANGER_TYPE_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"))));
+    EXPECT_CALL(*delegate(), RequestConfirmation(
+                                 _, test_virtual_dir().AppendASCII("bar.txt"),
+                                 DownloadConfirmationReason::SAVE_AS, _))
+        .WillOnce(WithArg<3>(
+            ScheduleCallback2(DownloadConfirmationResult::CONFIRMED,
+                              test_virtual_dir().AppendASCII("prompted.txt"))));
     RunTestCasesWithActiveItem(&kSaveAsToVirtualDir, 1);
   }
 
+  // "Save as" is not supported on Android.

[svaldez, 2016/10/28 17:29:36]

Should this move up one test?

[asanka, 2016/11/07 19:50:15]

Should be removed. At the DTD layer, Android deals correctly with Save As. The
lack of supports is from the higher layers.

   {
     SCOPED_TRACE(testing::Message() << "Save As to local directory");
     const DownloadTestCase kSaveAsToLocalDir = {
         SAVE_AS,
         content::DOWNLOAD_DANGER_TYPE_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(
+    EXPECT_CALL(*delegate(), RequestConfirmation(
+                                 _, test_virtual_dir().AppendASCII("bar.txt"),
+                                 DownloadConfirmationReason::SAVE_AS, _))
+        .WillOnce(WithArg<3>(ScheduleCallback2(
+            DownloadConfirmationResult::CONFIRMED,
             GetPathInDownloadDir(FILE_PATH_LITERAL("foo-x.txt")))));
     RunTestCasesWithActiveItem(&kSaveAsToLocalDir, 1);
   }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
   {
     SCOPED_TRACE(testing::Message() << "Forced safe download");
     const DownloadTestCase kForcedSafe = {
         FORCED,
         content::DOWNLOAD_DANGER_TYPE_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) {
+TEST_F(DownloadTargetDeterminerTest, InactiveDownload) {
   const DownloadTestCase kInactiveTestCases[] = {
       {AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD}
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
-  };
+       EXPECT_CRDOWNLOAD}};

[svaldez, 2016/10/28 17:29:36]

Extra whitespace?

[asanka, 2016/11/07 19:50:15]

Reformatted.

 
   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));
+    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(), RequestConfirmation(_, _, _, _)).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());
   }
 }
 
+namespace {
+
+// TODO(asanka): Once we can use C++14, make this a constexpr and use
+// static_assert where ASSERT* is used. Once we can use C++17 switch to using
+// reflection.
+size_t CountDownloadTargetResultValues() {

[svaldez, 2016/10/28 17:29:36]

Seems excessive since if we forget to add a test case in kTestCases and here, we
won't notice.

[asanka, 2016/11/07 19:50:15]

This one fails to compile if we forget to add an enum value here, and the test
fails if we forget to add a test case.

+  size_t count = 0;
+  DownloadTargetResult result = DownloadTargetResult::SUCCESS;
+  switch (result) {
+    case DownloadTargetResult::SUCCESS:
+      count++;
+    case DownloadTargetResult::USER_CANCELED:
+      count++;
+    case DownloadTargetResult::UNEXPECTED:
+      count++;
+    case DownloadTargetResult::NAME_TOO_LONG:
+      count++;
+    case DownloadTargetResult::CONFLICT:
+      count++;
+    case DownloadTargetResult::PATH_NOT_WRITEABLE:
+      count++;
+      // Oh you added a new |DownloadTargetResult| type? Add a case here for
+      // your new value and increment |count|. Don't forget to update the tests
+      // below. If not, the try bots will remind you.
+  }
+  return count;
+}
+
+}  // namespace
+
 // 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,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
-       "text/plain", FILE_PATH_LITERAL(""),
+TEST_F(DownloadTargetDeterminerTest, ReservationFailed_Confirmation) {
+  DownloadTestCase download_test_case = {
+      // 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,
+      DownloadFileType::NOT_DANGEROUS,
+      "http://example.com/foo.txt",
+      "text/plain",
+      FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("bar.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+      FILE_PATH_LITERAL("bar.txt"),
+      DownloadItem::TARGET_DISPOSITION_PROMPT,
 
-       EXPECT_CRDOWNLOAD},
+      EXPECT_CRDOWNLOAD};
+
+  struct {
+    DownloadTargetResult result;
+    DownloadConfirmationReason expected_confirmation_reason;
+  } kTestCases[] = {
+      // Reservation succeeded. No confirmation needed.
+      {DownloadTargetResult::SUCCESS, DownloadConfirmationReason::NONE},
+
+      // User cancelled the reservation. No further confirmation needed.
+      {DownloadTargetResult::USER_CANCELED, DownloadConfirmationReason::NONE},
+
+      // An unexpected error occurred. The download will be marked as
+      // interrupted. No confirmation needed.
+      {DownloadTargetResult::UNEXPECTED, DownloadConfirmationReason::NONE},
+
+      // The name was too long. Need to confirm with user.
+      {DownloadTargetResult::NAME_TOO_LONG,
+       DownloadConfirmationReason::NAME_TOO_LONG},
+
+      // Pathname conflict. User confirmation needed.
+      {DownloadTargetResult::CONFLICT,
+       DownloadConfirmationReason::TARGET_CONFLICT},
+
+      // The path is not writeable. Prompt user for a new path.
+      {DownloadTargetResult::PATH_NOT_WRITEABLE,
+       DownloadConfirmationReason::TARGET_NOT_WRITEABLE},
   };
 
-  // Setup ReserveVirtualPath() to fail.
-  ON_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _))
-      .WillByDefault(WithArg<4>(ScheduleCallback2(
-          GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")), false)));
-  RunTestCasesWithActiveItem(kReservationFailedCases,
-                             arraysize(kReservationFailedCases));
+  ASSERT_EQ(CountDownloadTargetResultValues(), arraysize(kTestCases))

[svaldez, 2016/10/28 17:29:36]

This seems kind of fragile. Maybe something like:

for (int i = 0; i < kNumDownloadConfirmationReason; i++) {
  DownloadConfirmationReason expected_reason;
  DownloadTargetResult result = static_cast<DownloadTargetResult>(i);
  switch(result) {
    case SUCCESS: expected_reason = NONE; break;
    ...
    // No default case should cause a compile error when a new enum is added?
  }
}

[asanka, 2016/11/07 19:50:15]

Hmm. I tried something like that here. Better?

+      << "All enumeration values for DownloadTargetResult must be tested";
+
+  for (auto& test_case : kTestCases) {
+    SCOPED_TRACE(::testing::Message() << "DownloadTargetResult "
+                                      << static_cast<int>(test_case.result));
+    ON_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _))
+        .WillByDefault(WithArg<4>(ScheduleCallback2(
+            GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")),
+            test_case.result)));
+    if (test_case.expected_confirmation_reason !=
+        DownloadConfirmationReason::NONE) {
+      EXPECT_CALL(
+          *delegate(),
+          RequestConfirmation(_, _, test_case.expected_confirmation_reason, _));
+    } else {
+      EXPECT_CALL(*delegate(), RequestConfirmation(_, _, _, _)).Times(0);
+    }
+
+    download_test_case.expected_disposition =
+        test_case.expected_confirmation_reason ==
+                DownloadConfirmationReason::NONE
+            ? content::DownloadItem::TARGET_DISPOSITION_OVERWRITE
+            : content::DownloadItem::TARGET_DISPOSITION_PROMPT;
+    std::unique_ptr<content::MockDownloadItem> item = CreateActiveDownloadItem(
+        static_cast<int>(test_case.result), download_test_case);
+    RunTestCase(download_test_case, base::FilePath(), item.get());
+  }
 }
 
 // If the local path could not be determined, the download should be cancelled.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_LocalPathFailed) {
+TEST_F(DownloadTargetDeterminerTest, LocalPathFailed) {
   const DownloadTestCase kLocalPathFailedCases[] = {
       {// 0: Automatic download.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        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) {
+TEST_F(DownloadTargetDeterminerTest, 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,
-       DownloadFileType::NOT_DANGEROUS, "http://visited.example.com/foo.crx",
-       "application/xml", FILE_PATH_LITERAL(""),
+       DownloadFileType::NOT_DANGEROUS,
+       "http://visited.example.com/foo.kindabad", "application/xml",
+       FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
 
       {// 1: Dangerous due to not having visited referrer before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
        DownloadFileType::ALLOW_ON_USER_GESTURE,
-       "http://not-visited.example.com/foo.crx", "application/xml",
+       "http://not-visited.example.com/foo.kindabad", "application/xml",
        FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {// 2: Safe because the user is being prompted.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS,
-       "http://not-visited.example.com/foo.crx", "application/xml",
+       "http://not-visited.example.com/foo.kindabad", "application/xml",
        FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
       {// 3: Safe because of forced path.
        FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS,
-       "http://not-visited.example.com/foo.crx", "application/xml",
-       FILE_PATH_LITERAL("foo.crx"),
+       "http://not-visited.example.com/foo.kindabad", "application/xml",
+       FILE_PATH_LITERAL("foo.kindabad"),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_LOCAL_PATH},
   };
 
-  // This test assumes that the danger level of .crx files is
+  // This test assumes that the danger level of .kindabad files is
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
 
   // 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 =
@@ skipping 17 matching lines @@
 
       FILE_PATH_LITERAL("foo.txt"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_CRDOWNLOAD};
 
   const DownloadTestCase kAllowOnUserGesture = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
       DownloadFileType::ALLOW_ON_USER_GESTURE,
-      "http://example.com/foo.crx",
+      "http://example.com/foo.kindabad",
       "application/octet-stream",
       FILE_PATH_LITERAL(""),
 
-      FILE_PATH_LITERAL("foo.crx"),
+      FILE_PATH_LITERAL("foo.kindabad"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_UNCONFIRMED};
 
   const DownloadTestCase kDangerousFile = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
       DownloadFileType::DANGEROUS,
-      "http://example.com/foo.swf",
+      "http://example.com/foo.bad",
       "application/octet-stream",
       FILE_PATH_LITERAL(""),
 
-      FILE_PATH_LITERAL("foo.swf"),
+      FILE_PATH_LITERAL("foo.bad"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_UNCONFIRMED};
 
   const struct {
     ui::PageTransition page_transition;
     content::DownloadDangerType expected_danger_type;
     const DownloadTestCase& template_download_test_case;
   } kTestCases[] = {
       {// Benign file type. Results in a danger type of NOT_DANGEROUS. Page
@@ skipping 32 matching lines @@
        content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, kAllowOnUserGesture},
 
       {// File type is DANGEROUS. PageTransition is irrelevant.
        static_cast<ui::PageTransition>(ui::PAGE_TRANSITION_TYPED |
                                        ui::PAGE_TRANSITION_FROM_ADDRESS_BAR),
        content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE, kDangerousFile},
   };
 
   // Test assumptions:
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
   ASSERT_EQ(DownloadFileType::DANGEROUS,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.swf"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.bad"))));
   ASSERT_EQ(DownloadFileType::NOT_DANGEROUS,
-            Policies()->GetFileDangerLevel(
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
                 base::FilePath(FILE_PATH_LITERAL("foo.txt"))));
 
   for (const auto& test_case : kTestCases) {
     // The template download test case describes what to expect if the page
     // transition was LINK. If the expectation is that the page transition type
     // causes the download to be considered safe, then download_test_case needs
     // to be adjusted accordingly.
     DownloadTestCase download_test_case = test_case.template_download_test_case;
     download_test_case.expected_danger_type = test_case.expected_danger_type;
     if (test_case.expected_danger_type ==
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
       download_test_case.expected_danger_level =
           DownloadFileType::NOT_DANGEROUS;
       download_test_case.expected_intermediate = EXPECT_CRDOWNLOAD;
     }
 
-    std::unique_ptr<content::MockDownloadItem> item(
-        CreateActiveDownloadItem(1, download_test_case));
+    std::unique_ptr<content::MockDownloadItem> item =
+        CreateActiveDownloadItem(1, download_test_case);
     EXPECT_CALL(*item, GetTransitionType())
         .WillRepeatedly(Return(test_case.page_transition));
     RunTestCase(download_test_case, base::FilePath(), item.get());
   }
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
 // These test cases are run with "Prompt for download" user preference set to
 // true.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_PromptAlways) {
+TEST_F(DownloadTargetDeterminerTest, PromptAlways_SafeAutomatic) {
+  const DownloadTestCase kSafeAutomatic = {
+      // 0: Safe Automatic - Should prompt because of "Prompt for download"
+      //    preference setting.
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
+      "http://example.com/automatic.txt",
+      "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("automatic.txt"),
+      DownloadItem::TARGET_DISPOSITION_PROMPT,
+
+      EXPECT_CRDOWNLOAD};
+
+  SetPromptForDownload(true);
+  EXPECT_CALL(*delegate(),
+              RequestConfirmation(
+                  _, GetPathInDownloadDir(FILE_PATH_LITERAL("automatic.txt")),
+                  DownloadConfirmationReason::PREFERENCE, _));
+  RunTestCasesWithActiveItem(&kSafeAutomatic, 1);
+}
+
+TEST_F(DownloadTargetDeterminerTest, PromptAlways_SafeSaveAs) {
+  const DownloadTestCase kSafeSaveAs = {
+      // 1: Safe Save As - Should prompt because of "Save as" invocation.
+      SAVE_AS,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
+      "http://example.com/save-as.txt",
+      "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("save-as.txt"),
+      DownloadItem::TARGET_DISPOSITION_PROMPT,
+
+      EXPECT_CRDOWNLOAD};
+
+  SetPromptForDownload(true);
+  EXPECT_CALL(*delegate(),
+              RequestConfirmation(
+                  _, GetPathInDownloadDir(FILE_PATH_LITERAL("save-as.txt")),
+                  DownloadConfirmationReason::SAVE_AS, _));
+  RunTestCasesWithActiveItem(&kSafeSaveAs, 1);
+}
+
+TEST_F(DownloadTargetDeterminerTest, PromptAlways_SafeForced) {
+  const DownloadTestCase kSafeForced = {
+      // 2: Safe Forced - Shouldn't prompt.
+      FORCED,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      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};
+
+  SetPromptForDownload(true);
+  RunTestCasesWithActiveItem(&kSafeForced, 1);
+}
+
+TEST_F(DownloadTargetDeterminerTest, PromptAlways_AutoOpen) {
+  const DownloadTestCase kAutoOpen = {
+      // 3: Automatic - The filename extension is marked as one that we will
+      //    open automatically. Shouldn't prompt.
+      AUTOMATIC,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      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(&kAutoOpen, 1);
+}
+
+// If an embedder responds to a RequestConfirmation with a new path and a
+// CONTINUE_WITHOUT_CONFIRMATION, then we shouldn't consider the file as safe.
+TEST_F(DownloadTargetDeterminerTest, ContinueWithoutConfirmation_SaveAs) {
+  const DownloadTestCase kTestCase = {
+      SAVE_AS,
+      content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+      DownloadFileType::ALLOW_ON_USER_GESTURE,
+      "http://example.com/save-as.kindabad",
+      "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("foo.kindabad"),
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+      EXPECT_UNCONFIRMED};
+
+  EXPECT_CALL(*delegate(),
+              RequestConfirmation(_, GetPathInDownloadDir(
+                                         FILE_PATH_LITERAL("save-as.kindabad")),
+                                  DownloadConfirmationReason::SAVE_AS, _))
+      .WillOnce(WithArg<3>(ScheduleCallback2(
+          DownloadConfirmationResult::CONTINUE_WITHOUT_CONFIRMATION,
+          GetPathInDownloadDir(FILE_PATH_LITERAL("foo.kindabad")))));
+  RunTestCasesWithActiveItem(&kTestCase, 1);
+}
+
+// Same as ContinueWithoutConfirmation_SaveAs, but the embedder response
+// indicates that the user confirmed the path. Hence the danger level of the
+// download and the disposition should be updated accordingly.
+TEST_F(DownloadTargetDeterminerTest, ContinueWithConfirmation_SaveAs) {
+  const DownloadTestCase kTestCase = {
+      SAVE_AS,
+      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      DownloadFileType::NOT_DANGEROUS,
+      "http://example.com/save-as.kindabad",
+      "text/plain",
+      FILE_PATH_LITERAL(""),
+
+      FILE_PATH_LITERAL("foo.kindabad"),
+      DownloadItem::TARGET_DISPOSITION_PROMPT,
+
+      EXPECT_CRDOWNLOAD};
+
+  EXPECT_CALL(*delegate(),
+              RequestConfirmation(_, GetPathInDownloadDir(
+                                         FILE_PATH_LITERAL("save-as.kindabad")),
+                                  DownloadConfirmationReason::SAVE_AS, _))
+      .WillOnce(WithArg<3>(ScheduleCallback2(
+          DownloadConfirmationResult::CONFIRMED,
+          GetPathInDownloadDir(FILE_PATH_LITERAL("foo.kindabad")))));
+  RunTestCasesWithActiveItem(&kTestCase, 1);
+}
+
+#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, PromptAlways_Extension) {
   const DownloadTestCase kPromptingTestCases[] = {
-      {// 0: Safe Automatic - Should prompt because of "Prompt for download"
-       //    preference setting.
-       AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       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,
-       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,
-       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.dummy", "",
+      {// 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,
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
+       "http://example.com/foo.kindabad", extensions::Extension::kMimeType,
        FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.dummy"),
+       FILE_PATH_LITERAL("foo.kindabad"),
+       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+
+       EXPECT_UNCONFIRMED},
+
+      {// 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,
+       DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.user.js", "",
+       FILE_PATH_LITERAL(""),
+
+       FILE_PATH_LITERAL("foo.user.js"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_CRDOWNLOAD},
   };
 
   SetPromptForDownload(true);
-  EnableAutoOpenBasedOnExtension(
-      base::FilePath(FILE_PATH_LITERAL("dummy.dummy")));
-  RunTestCasesWithActiveItem(kPromptingTestCases,
-                             arraysize(kPromptingTestCases));
-}
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
-
-#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,
-     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,
-     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,
-     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) {
+TEST_F(DownloadTargetDeterminerTest, ManagedPath) {
   const DownloadTestCase kManagedPathTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        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,
        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) {
+TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsSafe) {
   const DownloadTestCase kNotifyExtensionsTestCases[] = {
       {// 0: Automatic Safe
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_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},
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_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},
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
       {// 2: Automatic Dangerous
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-       "", FILE_PATH_LITERAL(""),
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
+       "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("overridden/foo.crx"),
+       FILE_PATH_LITERAL("overridden/foo.kindabad"),
        DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
        EXPECT_UNCONFIRMED},
 
       {// 3: Forced Safe
        FORCED, content::DOWNLOAD_DANGER_TYPE_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},
   };
 
   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) {
+TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsUnsafe) {
   const DownloadTestCase kNotHandledBySafeBrowsing = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
       DownloadFileType::ALLOW_ON_USER_GESTURE,
-      "http://example.com/foo.crx.remove",
+      "http://example.com/foo.kindabad.remove",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
-      FILE_PATH_LITERAL("overridden/foo.crx"),
+      FILE_PATH_LITERAL("overridden/foo.kindabad"),
       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_UNCONFIRMED};
 
   const DownloadTestCase kHandledBySafeBrowsing = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
       DownloadFileType::ALLOW_ON_USER_GESTURE,
-      "http://example.com/foo.crx.remove",
+      "http://example.com/foo.kindabad.remove",
       "text/plain",
       FILE_PATH_LITERAL(""),
 
-      FILE_PATH_LITERAL("overridden/foo.crx"),
+      FILE_PATH_LITERAL("overridden/foo.kindabad"),
       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) {
+TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsConflict) {
   const DownloadTestCase kNotifyExtensionsTestCase = {
       AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_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;
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(0, test_case));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(0, test_case);
   base::FilePath overridden_path(FILE_PATH_LITERAL("overridden/foo.txt"));
   base::FilePath full_overridden_path =
       GetPathInDownloadDir(overridden_path.value());
 
   // First case: An extension sets the conflict_action to OVERWRITE.
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::OVERWRITE)));
-  EXPECT_CALL(*delegate(), ReserveVirtualPath(
-      _, full_overridden_path, true, DownloadPathReservationTracker::OVERWRITE,
-      _)).WillOnce(WithArg<4>(
-          ScheduleCallback2(full_overridden_path, true)));
+  EXPECT_CALL(*delegate(),
+              ReserveVirtualPath(_, full_overridden_path, true,
+                                 DownloadPathReservationTracker::OVERWRITE, _))
+      .WillOnce(WithArg<4>(ScheduleCallback2(full_overridden_path,
+                                             DownloadTargetResult::SUCCESS)));
 
   RunTestCase(test_case, base::FilePath(), item.get());
 
   // Second case: An extension sets the conflict_action to PROMPT.
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::PROMPT)));
-  EXPECT_CALL(*delegate(), ReserveVirtualPath(
-      _, full_overridden_path, true, DownloadPathReservationTracker::PROMPT, _))
-      .WillOnce(WithArg<4>(
-          ScheduleCallback2(full_overridden_path, true)));
+  EXPECT_CALL(*delegate(),
+              ReserveVirtualPath(_, full_overridden_path, true,
+                                 DownloadPathReservationTracker::PROMPT, _))
+      .WillOnce(WithArg<4>(ScheduleCallback2(full_overridden_path,
+                                             DownloadTargetResult::SUCCESS)));
   RunTestCase(test_case, base::FilePath(), item.get());
 }
 
-#if !BUILDFLAG(ANDROID_JAVA_UI)
 // Test that relative paths returned by extensions are always relative to the
 // default downloads path.
-TEST_F(DownloadTargetDeterminerTest,
-       TargetDeterminer_NotifyExtensionsDefaultPath) {
+TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsDefaultPath) {
   const DownloadTestCase kNotifyExtensionsTestCase = {
-      SAVE_AS,
+      AUTOMATIC,
       content::DOWNLOAD_DANGER_TYPE_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,
+      DownloadItem::TARGET_DISPOSITION_OVERWRITE,
 
       EXPECT_CRDOWNLOAD};
 
   const DownloadTestCase& test_case = kNotifyExtensionsTestCase;
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(0, test_case));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(0, test_case);
   base::FilePath overridden_path(FILE_PATH_LITERAL("overridden/foo.txt"));
   base::FilePath full_overridden_path =
       GetPathInDownloadDir(overridden_path.value());
 
   download_prefs()->SetSaveFilePath(GetPathInDownloadDir(
       FILE_PATH_LITERAL("last_selected")));
 
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .WillOnce(WithArg<2>(
           ScheduleCallback2(overridden_path,
                             DownloadPathReservationTracker::UNIQUIFY)));
-  EXPECT_CALL(*delegate(),
-              PromptUserForDownloadPath(_, full_overridden_path, _))
-      .WillOnce(WithArg<2>(
-          ScheduleCallback(full_overridden_path)));
   RunTestCase(test_case, base::FilePath(), item.get());
 }
-#endif  // !BUILDFLAG(ANDROID_JAVA_UI)
 
-TEST_F(DownloadTargetDeterminerTest,
-       TargetDeterminer_InitialVirtualPathUnsafe) {
+TEST_F(DownloadTargetDeterminerTest, 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,
       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;
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(1, test_case));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(1, test_case);
   EXPECT_CALL(*item, GetLastReason())
       .WillRepeatedly(Return(
           content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED));
   EXPECT_CALL(*item, GetTargetDisposition())
       .WillRepeatedly(Return(DownloadItem::TARGET_DISPOSITION_PROMPT));
   RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
 }
 
 // Prompting behavior for resumed downloads is based on the last interrupt
 // reason. If the reason indicates that the target path may not be suitable for
 // the download (ACCESS_DENIED, NO_SPACE, etc..), then the user should be
 // prompted, and not otherwise. These test cases shouldn't result in prompting
 // since the error is set to NETWORK_FAILED.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ResumedNoPrompt) {
+TEST_F(DownloadTargetDeterminerTest, 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,
-       DownloadFileType::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: Initial path used.
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-       DownloadFileType::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,
 
        EXPECT_CRDOWNLOAD},
 
       {// 2: Automatic Dangerous: Initial path is ignored since the user hasn't
        // been prompted before.
        AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
-       DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
-       FILE_PATH_LITERAL(""),
+       DownloadFileType::ALLOW_ON_USER_GESTURE,
+       "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-       FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+       FILE_PATH_LITERAL("foo.kindabad"),
+       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,
        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
+  // The test assumes that .kindabad files have a danger level of
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
   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));
+    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(
             content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED));
     // Extensions should be notified if a new path is being generated and there
     // is no forced path. In the test cases above, this is true for tests with
     // type == AUTOMATIC.
     EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
         .Times(test_case.test_type == AUTOMATIC ? 1 : 0);
     EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
+    EXPECT_CALL(*delegate(), RequestConfirmation(_, expected_path, _, _))
         .Times(0);
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
     EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _));
     RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
   }
 }
 
 // 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) {
+TEST_F(DownloadTargetDeterminerTest, 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,
       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;
   base::FilePath expected_path =
       GetPathInDownloadDir(test_case.expected_local_path);
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(0, test_case));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(0, test_case);
   ON_CALL(*item.get(), GetLastReason())
       .WillByDefault(Return(content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE));
   EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
       .Times(test_case.test_type == AUTOMATIC ? 1 : 0);
   EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
-  EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, _, _))
-      .Times(0);
+  EXPECT_CALL(*delegate(), RequestConfirmation(_, _, _, _)).Times(0);
   EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
   EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _));
   RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
 }
 
 // Prompting behavior for resumed downloads is based on the last interrupt
 // reason. If the reason indicates that the target path may not be suitable for
 // the download (ACCESS_DENIED, NO_SPACE, etc..), then the user should be
 // prompted, and not otherwise. These test cases result in prompting since the
 // error is set to NO_SPACE.
-TEST_F(DownloadTargetDeterminerTest, TargetDeterminer_ResumedWithPrompt) {
+TEST_F(DownloadTargetDeterminerTest, 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,
        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
+       FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
        EXPECT_CRDOWNLOAD},
 
       {// 1: Save_As Safe
        SAVE_AS, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
        DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
        "text/plain", FILE_PATH_LITERAL(""),
 
        kInitialPath, DownloadItem::TARGET_DISPOSITION_PROMPT,
 
        EXPECT_CRDOWNLOAD},
 
       {
           // 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,
-          DownloadFileType::ALLOW_ON_USER_GESTURE,
-#else
-          content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-          DownloadFileType::NOT_DANGEROUS,
-#endif
-          "http://example.com/foo.crx", "", FILE_PATH_LITERAL(""),
+          AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+          DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.kindabad",

[svaldez, 2016/10/28 17:29:36]

Should this be ".bad"?

[asanka, 2016/11/07 19:50:15]

Added another test case for .bad. The semantics are subtly different.

+          "", FILE_PATH_LITERAL(""),
 
-          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,
-#else
+          FILE_PATH_LITERAL("foo.kindabad"),
           DownloadItem::TARGET_DISPOSITION_PROMPT, EXPECT_CRDOWNLOAD,
-#endif
       },
   };
 
-  // The test assumes that .xml files have a danger level of
-  // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
   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));
+    std::unique_ptr<content::MockDownloadItem> item =
+        CreateActiveDownloadItem(i, test_case);
     ON_CALL(*item.get(), GetLastReason())
         .WillByDefault(Return(
             content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE));
     EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
         .Times(test_case.test_type == AUTOMATIC ? 1 : 0);
     EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
-#if BUILDFLAG(ANDROID_JAVA_UI)
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
-        .Times(0);
-#else
-    EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _));
-#endif
+    EXPECT_CALL(*delegate(), RequestConfirmation(_, expected_path, _, _));
     EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
     EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _));
     RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
   }
 }
 
 // Test intermediate filename generation for resumed downloads.
-TEST_F(DownloadTargetDeterminerTest,
-       TargetDeterminer_IntermediateNameForResumed) {
+TEST_F(DownloadTargetDeterminerTest, IntermediateNameForResumed) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType kInitialPath[] =
       FILE_PATH_LITERAL("some_path/bar.txt");
 
   struct IntermediateNameTestCase {
     // General test case settings.
     DownloadTestCase general;
 
     // Value of DownloadItem::GetFullPath() during test run, relative
@@ skipping 22 matching lines @@
         "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,
-        DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-        "", FILE_PATH_LITERAL(""),
+        DownloadFileType::ALLOW_ON_USER_GESTURE,
+        "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-        FILE_PATH_LITERAL("foo.crx"),
+        FILE_PATH_LITERAL("foo.kindabad"),
         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,
-        DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx",
-        "", FILE_PATH_LITERAL(""),
+        DownloadFileType::ALLOW_ON_USER_GESTURE,
+        "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
 
-        FILE_PATH_LITERAL("foo.crx"),
+        FILE_PATH_LITERAL("foo.kindabad"),
         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,
         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
+  // The test assumes that .kindabad files have a danger level of
   // ALLOW_ON_USER_GESTURE.
   ASSERT_EQ(DownloadFileType::ALLOW_ON_USER_GESTURE,
-            Policies()->GetFileDangerLevel(
-                base::FilePath(FILE_PATH_LITERAL("foo.crx"))));
+            safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+                base::FilePath(FILE_PATH_LITERAL("foo.kindabad"))));
 
   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));
+    std::unique_ptr<content::MockDownloadItem> item =
+        CreateActiveDownloadItem(i, test_case.general);
 
     ON_CALL(*item.get(), GetLastReason())
         .WillByDefault(Return(
             content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED));
     ON_CALL(*item.get(), GetFullPath())
         .WillByDefault(ReturnRefOfCopy(
             GetPathInDownloadDir(test_case.initial_intermediate_path)));
     ON_CALL(*item.get(), GetDangerType())
         .WillByDefault(Return(test_case.general.expected_danger_type));
 
     std::unique_ptr<DownloadTargetInfo> target_info =
         RunDownloadTargetDeterminer(GetPathInDownloadDir(kInitialPath),
                                     item.get());
     VerifyDownloadTarget(test_case.general, target_info.get());
     base::FilePath expected_intermediate_path =
         GetPathInDownloadDir(test_case.expected_intermediate_path);
     if (!expected_intermediate_path.empty())
       EXPECT_EQ(expected_intermediate_path, target_info->intermediate_path);
   }
 }
 
 // Test MIME type determination based on the target filename.
-TEST_F(DownloadTargetDeterminerTest,
-       TargetDeterminer_MIMETypeDetermination) {
+TEST_F(DownloadTargetDeterminerTest, MIMETypeDetermination) {
   // All test cases run with GetPathInDownloadDir(kInitialPath) as the inital
   // path.
   const base::FilePath::CharType kInitialPath[] =
       FILE_PATH_LITERAL("some_path/bar.txt");
 
   struct MIMETypeTestCase {
     // General test case settings.
     DownloadTestCase general;
 
     // Expected MIME type for test case.
@@ skipping 52 matching lines @@
       {{// 5: x-x509-user-cert mime-type.
         AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
         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},
        ""},
-
   };
 
   ON_CALL(*delegate(), GetFileMimeType(
       GetPathInDownloadDir(FILE_PATH_LITERAL("foo.png")), _))
       .WillByDefault(WithArg<1>(
           ScheduleCallback("image/png")));
 
   for (size_t i = 0; i < arraysize(kMIMETypeTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Running test case " << i);
     const MIMETypeTestCase& test_case = kMIMETypeTestCases[i];
-    std::unique_ptr<content::MockDownloadItem> item(
-        CreateActiveDownloadItem(i, test_case.general));
+    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);
   }
 }
 
 #if defined(ENABLE_PLUGINS)
 
 void DummyGetPluginsCallback(
@@ skipping 100 matching lines @@
 
  protected:
   content::PluginServiceFilter* old_plugin_service_filter_;
   testing::StrictMock<MockPluginServiceFilter> mock_plugin_filter_;
   // The ShadowingAtExitManager destroys the tainted PluginService instance.
   base::ShadowingAtExitManager at_exit_manager_;
 };
 
 // Check if secure handling of filetypes is determined correctly for PPAPI
 // plugins.
-TEST_F(DownloadTargetDeterminerTestWithPlugin,
-       TargetDeterminer_CheckForSecureHandling_PPAPI) {
+TEST_F(DownloadTargetDeterminerTestWithPlugin, 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,
       DownloadFileType::NOT_DANGEROUS,
@@ skipping 16 matching lines @@
     ASSERT_FALSE(plugin_service->GetPluginInfoArray(
         GURL(), kTestMIMEType, false, &info, NULL));
     ASSERT_EQ(0u, info.size())
         << "Name: " << info[0].name << ", Path: " << info[0].path.value();
   }
 
   ON_CALL(*delegate(), GetFileMimeType(
       GetPathInDownloadDir(FILE_PATH_LITERAL("foo.fakeext")), _))
       .WillByDefault(WithArg<1>(
           ScheduleCallback(kTestMIMEType)));
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(1, kSecureHandlingTestCase));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(1, kSecureHandlingTestCase);
   std::unique_ptr<DownloadTargetInfo> target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 
   // Register a PPAPI plugin. This should count as handling the filetype
   // securely.
   ScopedRegisterInternalPlugin ppapi_plugin(
       plugin_service,
       content::WebPluginInfo::PLUGIN_TYPE_PEPPER_OUT_OF_PROCESS,
       test_download_dir().AppendASCII("ppapi"),
@@ skipping 10 matching lines @@
   EXPECT_CALL(mock_plugin_filter_, MockPluginAvailable(ppapi_plugin.path()))
       .WillRepeatedly(Return(false));
   target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 }
 
 // Check if secure handling of filetypes is determined correctly for
 // BrowserPlugins.
 TEST_F(DownloadTargetDeterminerTestWithPlugin,
-       TargetDeterminer_CheckForSecureHandling_BrowserPlugin) {
+       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,
       DownloadFileType::NOT_DANGEROUS,
@@ skipping 16 matching lines @@
     ASSERT_FALSE(plugin_service->GetPluginInfoArray(
         GURL(), kTestMIMEType, false, &info, NULL));
     ASSERT_EQ(0u, info.size())
         << "Name: " << info[0].name << ", Path: " << info[0].path.value();
   }
 
   ON_CALL(*delegate(), GetFileMimeType(
       GetPathInDownloadDir(FILE_PATH_LITERAL("foo.fakeext")), _))
       .WillByDefault(WithArg<1>(
           ScheduleCallback(kTestMIMEType)));
-  std::unique_ptr<content::MockDownloadItem> item(
-      CreateActiveDownloadItem(1, kSecureHandlingTestCase));
+  std::unique_ptr<content::MockDownloadItem> item =
+      CreateActiveDownloadItem(1, kSecureHandlingTestCase);
   std::unique_ptr<DownloadTargetInfo> target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 
   // Register a BrowserPlugin. This should count as handling the filetype
   // securely.
   ScopedRegisterInternalPlugin browser_plugin(
       plugin_service,
       content::WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN,
       test_download_dir().AppendASCII("browser_plugin"),
@@ skipping 10 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