Enable "Hide Extension" option when "Save Link As" on the Mac

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 "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_service.h"
@@ skipping 447 matching lines @@
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     const DownloadTargetDeterminerDelegate::ReservedPathCallback& callback) {
   callback.Run(virtual_path, true);
 }
 
 // static
 void MockDownloadTargetDeterminerDelegate::NullPromptUser(
     DownloadItem* download, const base::FilePath& suggested_path,
     const FileSelectedCallback& callback) {
-  callback.Run(suggested_path);
+  callback.Run(suggested_path, false);
 }
 
 // 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
@@ skipping 96 matching lines @@
       "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())));
+      .WillByDefault(WithArg<2>(ScheduleCallback2(base::FilePath(), false)));
   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
@@ skipping 274 matching lines @@
       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"))));
+        .WillOnce(WithArg<2>(ScheduleCallback2(
+            test_virtual_dir().AppendASCII("prompted.txt"), false)));
     RunTestCasesWithActiveItem(&kSaveAsToVirtualDir, 1);
   }
 
   {
     SCOPED_TRACE(testing::Message() << "Save As to local directory");
     const DownloadTestCase kSaveAsToLocalDir = {
       SAVE_AS,
       content::DOWNLOAD_DANGER_TYPE_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")))));
+        .WillOnce(WithArg<2>(ScheduleCallback2(
+            GetPathInDownloadDir(FILE_PATH_LITERAL("foo-x.txt")), false)));
     RunTestCasesWithActiveItem(&kSaveAsToLocalDir, 1);
   }
 
   {
     SCOPED_TRACE(testing::Message() << "Forced safe download");
     const DownloadTestCase kForcedSafe = {
       FORCED,
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       "http://example.com/foo.txt", "",
       FILE_PATH_LITERAL("forced-foo.txt"),
@@ skipping 514 matching lines @@
   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)));
+          ScheduleCallback2(full_overridden_path, false)));
   RunTestCase(test_case, base::FilePath(), item.get());
 }
 
 TEST_F(DownloadTargetDeterminerTest,
        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,
@@ skipping 792 matching lines @@
   EXPECT_CALL(mock_plugin_filter_, MockPluginAvailable(npapi_plugin.path()))
       .WillRepeatedly(Return(true));
 
   target_info = RunDownloadTargetDeterminer(
       GetPathInDownloadDir(kInitialPath), item.get());
   EXPECT_FALSE(target_info->is_filetype_handled_safely);
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 }  // namespace