Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1817)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/download/download_target_determiner_unittest.cc

Issue 2453633006: [downloads] Move platform specific code out of DownloadTargetDeterminer. (Closed)
Patch Set: . Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/download/download_target_determiner_delegate.h ('k') | chrome/browser/download/download_target_info.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/download/download_target_determiner_unittest.cc
diff --git a/chrome/browser/download/download_target_determiner_unittest.cc b/chrome/browser/download/download_target_determiner_unittest.cc
index 6755620a8df141d234e62ab55012313215008da8..20d8991dacaccc811676e0fde6c402c940c25cab 100644
--- a/chrome/browser/download/download_target_determiner_unittest.cc
+++ b/chrome/browser/download/download_target_determiner_unittest.cc
@@ -5,11 +5,15 @@
#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"
@@ -18,12 +22,15 @@
#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"
@@ -112,6 +119,8 @@ 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 interrupted or cancelled.
};
// Typical download test case. Used with
@@ -156,9 +165,11 @@ class MockDownloadTargetDeterminerDelegate
MOCK_METHOD3(NotifyExtensions,
void(content::DownloadItem*, const base::FilePath&,
const NotifyExtensionsCallback&));
- MOCK_METHOD3(PromptUserForDownloadPath,
- void(content::DownloadItem*, const base::FilePath&,
- const FileSelectedCallback&));
+ MOCK_METHOD4(RequestConfirmation,
+ void(content::DownloadItem*,
+ const base::FilePath&,
+ DownloadConfirmationReason,
+ const ConfirmationCallback&));
MOCK_METHOD3(DetermineLocalPath,
void(DownloadItem*, const base::FilePath&,
const LocalPathCallback&));
@@ -181,9 +192,9 @@ class MockDownloadTargetDeterminerDelegate
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));
@@ -198,9 +209,10 @@ class MockDownloadTargetDeterminerDelegate
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 ConfirmationCallback& callback);
static void NullDetermineLocalPath(
DownloadItem* download, const base::FilePath& virtual_path,
const LocalPathCallback& callback);
@@ -213,7 +225,7 @@ class DownloadTargetDeterminerTest : public ChromeRenderViewHostTestHarness {
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);
@@ -269,17 +281,15 @@ class DownloadTargetDeterminerTest : public ChromeRenderViewHostTestHarness {
return download_prefs_.get();
}
- // Shortcut
- const FileTypePolicies* Policies() const {
- return FileTypePolicies::GetInstance();
- }
-
private:
+ void SetUpFileTypePolicies();
+
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() {
@@ -291,6 +301,7 @@ void DownloadTargetDeterminerTest::SetUp() {
test_virtual_dir_ = test_download_dir().Append(FILE_PATH_LITERAL("virtual"));
download_prefs_->SetDownloadPath(test_download_dir());
delegate_.SetupDefaults();
+ SetUpFileTypePolicies();
}
void DownloadTargetDeterminerTest::TearDown() {
@@ -298,12 +309,12 @@ void DownloadTargetDeterminerTest::TearDown() {
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);
@@ -407,9 +418,9 @@ DownloadTargetDeterminerTest::RunDownloadTargetDeterminer(
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());
@@ -420,8 +431,8 @@ 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());
}
@@ -467,9 +478,39 @@ void DownloadTargetDeterminerTest::VerifyDownloadTarget(
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,
@@ -477,14 +518,16 @@ void MockDownloadTargetDeterminerDelegate::NullReserveVirtualPath(
bool create_directory,
DownloadPathReservationTracker::FilenameConflictAction conflict_action,
const DownloadTargetDeterminerDelegate::ReservedPathCallback& callback) {
- callback.Run(virtual_path, true);
+ callback.Run(PathValidationResult::SUCCESS, virtual_path);
}
// static
void MockDownloadTargetDeterminerDelegate::NullPromptUser(
- DownloadItem* download, const base::FilePath& suggested_path,
- const FileSelectedCallback& callback) {
- callback.Run(suggested_path);
+ DownloadItem* download,
+ const base::FilePath& suggested_path,
+ DownloadConfirmationReason reason,
+ const ConfirmationCallback& callback) {
+ callback.Run(DownloadConfirmationResult::CONFIRMED, suggested_path);
}
// static
@@ -513,55 +556,53 @@ void NotifyExtensionsOverridePath(
TEST_F(DownloadTargetDeterminerTest, Basic) {
const DownloadTestCase kBasicTestCases[] = {
- {// 0: Automatic Safe
- AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
- DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
- "text/plain", FILE_PATH_LITERAL(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_CRDOWNLOAD},
+ EXPECT_CRDOWNLOAD},
-#if !defined(OS_ANDROID)
- {// 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(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
- EXPECT_CRDOWNLOAD},
-#endif // !defined(OS_ANDROID)
+ EXPECT_CRDOWNLOAD},
- {// 2: Automatic Dangerous
- AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
- DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
- FILE_PATH_LITERAL(""),
+ {// Automatic Dangerous
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+ 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},
+ 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"),
+ {// 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,
+ FILE_PATH_LITERAL("forced-foo.txt"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_LOCAL_PATH},
+ 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 !defined(OS_ANDROID)
TEST_F(DownloadTargetDeterminerTest, CancelSaveAs) {
const DownloadTestCase kCancelSaveAsTestCases[] = {
{// 0: Save_As Safe, Cancelled.
@@ -572,77 +613,74 @@ TEST_F(DownloadTargetDeterminerTest, CancelSaveAs) {
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 // !defined(OS_ANDROID)
// The SafeBrowsing check is performed early. Make sure that a download item
// that has been marked as DANGEROUS_URL behaves correctly.
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(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
+ EXPECT_UNCONFIRMED},
-#if !defined(OS_ANDROID)
- {// 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(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
- EXPECT_UNCONFIRMED},
-#endif // !defined(OS_ANDROID)
+ EXPECT_UNCONFIRMED},
- {// 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"),
+ {// 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,
+ FILE_PATH_LITERAL("forced-foo.txt"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
+ 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(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.html"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
+ EXPECT_UNCONFIRMED},
-#if !defined(OS_ANDROID)
- {// 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(""),
+ {// 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,
+ FILE_PATH_LITERAL("foo.html"), DownloadItem::TARGET_DISPOSITION_PROMPT,
- EXPECT_UNCONFIRMED},
-#endif // !defined(OS_ANDROID)
+ EXPECT_UNCONFIRMED},
- {// 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"),
+ {// 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,
+ FILE_PATH_LITERAL("forced-foo.html"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
+ EXPECT_UNCONFIRMED},
};
ON_CALL(*delegate(), CheckDownloadUrl(_, _, _))
@@ -656,53 +694,50 @@ TEST_F(DownloadTargetDeterminerTest, DangerousUrl) {
// that has been marked as MAYBE_DANGEROUS_CONTENT behaves correctly.
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(""),
-
- FILE_PATH_LITERAL("foo.crx"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ {// 0: Automatic Maybe dangerous content
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+ DownloadFileType::ALLOW_ON_USER_GESTURE,
+ "http://phishing.example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
- EXPECT_UNCONFIRMED},
+ 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", "",
- FILE_PATH_LITERAL(""),
-
- FILE_PATH_LITERAL("foo.swf"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ {// 1: Automatic Maybe dangerous content with DANGEROUS type.
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+ DownloadFileType::DANGEROUS, "http://phishing.example.com/foo.bad", "",
+ FILE_PATH_LITERAL(""),
- EXPECT_UNCONFIRMED},
+ FILE_PATH_LITERAL("foo.bad"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ EXPECT_UNCONFIRMED},
-#if !defined(OS_ANDROID)
- {// 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(""),
+ {// 2: Save As Maybe dangerous content
+ SAVE_AS, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+ 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 // !defined(OS_ANDROID)
+ EXPECT_UNCONFIRMED},
- {// 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"),
+ {// 3: Forced Maybe dangerous content
+ FORCED, content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+ DownloadFileType::NOT_DANGEROUS,
+ "http://phishing.example.com/foo.kindabad", "",
+ FILE_PATH_LITERAL("forced-foo.kindabad"),
- FILE_PATH_LITERAL("forced-foo.crx"),
- DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ FILE_PATH_LITERAL("forced-foo.kindabad"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
- };
+ 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(
@@ -711,7 +746,6 @@ TEST_F(DownloadTargetDeterminerTest, MaybeDangerousContent) {
arraysize(kSafeBrowsingTestCases));
}
-#if !defined(OS_ANDROID)
// Test whether the last saved directory is used for 'Save As' downloads.
TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
const DownloadTestCase kLastSavePathTestCasesPre[] = {
@@ -767,7 +801,9 @@ TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
<< "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));
}
@@ -779,7 +815,9 @@ TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
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));
}
@@ -791,8 +829,9 @@ TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
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")))));
@@ -800,7 +839,6 @@ TEST_F(DownloadTargetDeterminerTest, LastSavePath) {
arraysize(kLastSavePathTestCasesVirtual));
}
}
-#endif // !defined(OS_ANDROID)
// These tests are run with the default downloads folder set to a virtual
// directory.
@@ -828,7 +866,6 @@ TEST_F(DownloadTargetDeterminerTest, DefaultVirtual) {
RunTestCasesWithActiveItem(&kAutomaticDownloadToVirtualDir, 1);
}
-#if !defined(OS_ANDROID)
{
SCOPED_TRACE(testing::Message() << "Save As to virtual directory");
const DownloadTestCase kSaveAsToVirtualDir = {
@@ -846,10 +883,12 @@ TEST_F(DownloadTargetDeterminerTest, DefaultVirtual) {
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);
}
@@ -867,13 +906,14 @@ TEST_F(DownloadTargetDeterminerTest, DefaultVirtual) {
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 // !defined(OS_ANDROID)
{
SCOPED_TRACE(testing::Message() << "Forced safe download");
@@ -896,63 +936,98 @@ TEST_F(DownloadTargetDeterminerTest, DefaultVirtual) {
// Test that an inactive download will still get a virtual or local download
// path.
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 !defined(OS_ANDROID)
- {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,
+ const DownloadTestCase kBaseTestCase = {
+ 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};
- EXPECT_CRDOWNLOAD}
-#endif // !defined(OS_ANDROID)
- };
+ const struct {
+ TestCaseType type;
+ DownloadItem::TargetDisposition disposition;
+ } kTestCases[] = {{AUTOMATIC, DownloadItem::TARGET_DISPOSITION_OVERWRITE},
+ {SAVE_AS, DownloadItem::TARGET_DISPOSITION_PROMPT}};
- 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));
+ for (const auto& test_case : kTestCases) {
+ DownloadTestCase download_test_case = kBaseTestCase;
+ download_test_case.test_type = test_case.type;
+ download_test_case.expected_disposition = test_case.disposition;
+ std::unique_ptr<content::MockDownloadItem> item =
+ CreateActiveDownloadItem(1, download_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());
+
+ // Each test case has a non-empty target path. The test will fail if the
+ // target determination doesn't result in that path.
+ RunTestCase(download_test_case, base::FilePath(), item.get());
}
}
// If the reserved path could not be verified, then the user should see a
// prompt.
-TEST_F(DownloadTargetDeterminerTest, 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};
- // Setup ReserveVirtualPath() to fail.
- ON_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _))
- .WillByDefault(WithArg<4>(ScheduleCallback2(
- GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")), false)));
- RunTestCasesWithActiveItem(kReservationFailedCases,
- arraysize(kReservationFailedCases));
+ struct TestCase {
+ PathValidationResult result;
+ DownloadConfirmationReason expected_confirmation_reason;
+ } kTestCases[] = {
+ {PathValidationResult::SUCCESS, DownloadConfirmationReason::NONE},
+ {PathValidationResult::CONFLICT,
+ DownloadConfirmationReason::TARGET_CONFLICT},
+ {PathValidationResult::PATH_NOT_WRITABLE,
+ DownloadConfirmationReason::TARGET_PATH_NOT_WRITEABLE},
+ {PathValidationResult::NAME_TOO_LONG,
+ DownloadConfirmationReason::NAME_TOO_LONG}};
+
+ for (const auto& test_case : kTestCases) {
+ SCOPED_TRACE(::testing::Message() << "PathValidationResult "
+ << static_cast<int>(test_case.result));
+ ON_CALL(*delegate(), ReserveVirtualPath(_, _, _, _, _))
+ .WillByDefault(WithArg<4>(ScheduleCallback2(
+ test_case.result,
+ GetPathInDownloadDir(FILE_PATH_LITERAL("bar.txt")))));
+ 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.
@@ -983,53 +1058,58 @@ TEST_F(DownloadTargetDeterminerTest, LocalPathFailed) {
// download and whether the referrer was visited prior to today.
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(""),
+ // 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.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},
+ 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",
- FILE_PATH_LITERAL(""),
+ {// 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.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},
+ EXPECT_UNCONFIRMED},
-#if !defined(OS_ANDROID)
- {// 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", FILE_PATH_LITERAL(""),
+ {// 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.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 // !defined(OS_ANDROID)
+ EXPECT_CRDOWNLOAD},
- {// 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"),
+ {// 3: Safe because of forced path.
+ FORCED, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+ DownloadFileType::NOT_DANGEROUS,
+ "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},
+ 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));
@@ -1067,11 +1147,11 @@ TEST_F(DownloadTargetDeterminerTest, TransitionType) {
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};
@@ -1080,11 +1160,11 @@ TEST_F(DownloadTargetDeterminerTest, TransitionType) {
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};
@@ -1137,13 +1217,13 @@ TEST_F(DownloadTargetDeterminerTest, TransitionType) {
// 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) {
@@ -1160,57 +1240,157 @@ TEST_F(DownloadTargetDeterminerTest, TransitionType) {
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 !defined(OS_ANDROID)
// These test cases are run with "Prompt for download" user preference set to
// true.
-TEST_F(DownloadTargetDeterminerTest, PromptAlways) {
- 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(""),
+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("foo.txt"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+ FILE_PATH_LITERAL("automatic.txt"),
+ DownloadItem::TARGET_DISPOSITION_PROMPT,
- EXPECT_CRDOWNLOAD},
+ 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"),
+ SetPromptForDownload(true);
+ EXPECT_CALL(*delegate(),
+ RequestConfirmation(
+ _, GetPathInDownloadDir(FILE_PATH_LITERAL("automatic.txt")),
+ DownloadConfirmationReason::PREFERENCE, _));
+ RunTestCasesWithActiveItem(&kSafeAutomatic, 1);
+}
- FILE_PATH_LITERAL("foo.txt"), DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+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(""),
- EXPECT_LOCAL_PATH},
+ FILE_PATH_LITERAL("save-as.txt"),
+ DownloadItem::TARGET_DISPOSITION_PROMPT,
- {// 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", "",
- FILE_PATH_LITERAL(""),
+ EXPECT_CRDOWNLOAD};
- FILE_PATH_LITERAL("foo.dummy"),
- DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ SetPromptForDownload(true);
+ EXPECT_CALL(*delegate(),
+ RequestConfirmation(
+ _, GetPathInDownloadDir(FILE_PATH_LITERAL("save-as.txt")),
+ DownloadConfirmationReason::SAVE_AS, _));
+ RunTestCasesWithActiveItem(&kSafeSaveAs, 1);
+}
- EXPECT_CRDOWNLOAD},
- };
+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(kPromptingTestCases,
- arraysize(kPromptingTestCases));
+ 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);
}
-#endif // !defined(OS_ANDROID)
#if BUILDFLAG(ENABLE_EXTENSIONS)
// These test cases are run with "Prompt for download" user preference set to
@@ -1218,40 +1398,29 @@ TEST_F(DownloadTargetDeterminerTest, PromptAlways) {
// Android doesn't support extensions.
TEST_F(DownloadTargetDeterminerTest, 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
+ {// 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.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);
@@ -1293,47 +1462,45 @@ TEST_F(DownloadTargetDeterminerTest, ManagedPath) {
// filenames.
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(""),
+ {// 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,
+ FILE_PATH_LITERAL("overridden/foo.txt"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_CRDOWNLOAD},
+ EXPECT_CRDOWNLOAD},
-#if !defined(OS_ANDROID)
- {// 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(""),
+ {// 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,
+ FILE_PATH_LITERAL("overridden/foo.txt"),
+ DownloadItem::TARGET_DISPOSITION_PROMPT,
- EXPECT_CRDOWNLOAD},
-#endif // !defined(OS_ANDROID)
+ EXPECT_CRDOWNLOAD},
- {// 2: Automatic Dangerous
- AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
- DownloadFileType::ALLOW_ON_USER_GESTURE, "http://example.com/foo.crx", "",
- FILE_PATH_LITERAL(""),
+ {// 2: Automatic Dangerous
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+ DownloadFileType::ALLOW_ON_USER_GESTURE,
+ "http://example.com/foo.kindabad", "", FILE_PATH_LITERAL(""),
- FILE_PATH_LITERAL("overridden/foo.crx"),
- DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+ FILE_PATH_LITERAL("overridden/foo.kindabad"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_UNCONFIRMED},
+ 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"),
+ {// 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,
+ FILE_PATH_LITERAL("forced-foo.txt"),
+ DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- EXPECT_LOCAL_PATH},
+ EXPECT_LOCAL_PATH},
};
ON_CALL(*delegate(), NotifyExtensions(_, _, _))
@@ -1349,11 +1516,11 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsUnsafe) {
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};
@@ -1362,11 +1529,11 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsUnsafe) {
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};
@@ -1398,8 +1565,8 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsConflict) {
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());
@@ -1409,10 +1576,11 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsConflict) {
.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(PathValidationResult::SUCCESS,
+ full_overridden_path)));
RunTestCase(test_case, base::FilePath(), item.get());
@@ -1421,19 +1589,19 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsConflict) {
.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(PathValidationResult::SUCCESS,
+ full_overridden_path)));
RunTestCase(test_case, base::FilePath(), item.get());
}
-#if !defined(OS_ANDROID)
// Test that relative paths returned by extensions are always relative to the
// default downloads path.
TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsDefaultPath) {
const DownloadTestCase kNotifyExtensionsTestCase = {
- SAVE_AS,
+ AUTOMATIC,
content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
DownloadFileType::NOT_DANGEROUS,
"http://example.com/foo.txt",
@@ -1441,13 +1609,13 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsDefaultPath) {
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());
@@ -1459,13 +1627,8 @@ TEST_F(DownloadTargetDeterminerTest, NotifyExtensionsDefaultPath) {
.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 // !defined(OS_ANDROID)
TEST_F(DownloadTargetDeterminerTest, InitialVirtualPathUnsafe) {
const base::FilePath::CharType* kInitialPath =
@@ -1488,8 +1651,8 @@ TEST_F(DownloadTargetDeterminerTest, InitialVirtualPathUnsafe) {
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));
@@ -1513,8 +1676,8 @@ TEST_F(DownloadTargetDeterminerTest, ResumedNoPrompt) {
{// 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,
@@ -1522,8 +1685,8 @@ TEST_F(DownloadTargetDeterminerTest, ResumedNoPrompt) {
{// 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,
@@ -1532,10 +1695,11 @@ TEST_F(DownloadTargetDeterminerTest, ResumedNoPrompt) {
{// 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},
@@ -1550,16 +1714,16 @@ TEST_F(DownloadTargetDeterminerTest, ResumedNoPrompt) {
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())
@@ -1570,15 +1734,8 @@ TEST_F(DownloadTargetDeterminerTest, ResumedNoPrompt) {
// type == AUTOMATIC.
EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _))
.Times(test_case.test_type == AUTOMATIC ? 1 : 0);
- // When resuming an AUTOMATIC download with non-empty initial path, the file
- // name conflict action should be UNIQUIFY.
- DownloadPathReservationTracker::FilenameConflictAction action =
- test_case.test_type == AUTOMATIC ?
- DownloadPathReservationTracker::UNIQUIFY :
- DownloadPathReservationTracker::OVERWRITE;
- EXPECT_CALL(*delegate(), ReserveVirtualPath(
- _, expected_path, false, action, _));
- EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
+ EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
+ EXPECT_CALL(*delegate(), RequestConfirmation(_, expected_path, _, _))
.Times(0);
EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _));
@@ -1608,15 +1765,14 @@ TEST_F(DownloadTargetDeterminerTest, ResumedForcedDownload) {
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());
@@ -1639,12 +1795,7 @@ TEST_F(DownloadTargetDeterminerTest, ResumedWithPrompt) {
DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.txt",
"text/plain", FILE_PATH_LITERAL(""),
- FILE_PATH_LITERAL("foo.txt"),
-#if defined(OS_ANDROID)
- 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
@@ -1658,53 +1809,43 @@ TEST_F(DownloadTargetDeterminerTest, ResumedWithPrompt) {
{
// 2: Automatic Dangerous
- AUTOMATIC,
-#if defined(OS_ANDROID)
- // 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(""),
-
- FILE_PATH_LITERAL("foo.crx"),
-#if defined(OS_ANDROID)
- DownloadItem::TARGET_DISPOSITION_OVERWRITE,
- // Dangerous download will have an unconfirmed intermediate file name.
- EXPECT_UNCONFIRMED,
-#else
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+ DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.kindabad",
+ "", FILE_PATH_LITERAL(""),
+
+ FILE_PATH_LITERAL("foo.kindabad"),
DownloadItem::TARGET_DISPOSITION_PROMPT, EXPECT_CRDOWNLOAD,
-#endif
+ },
+
+ {
+ // 3: Automatic Dangerous
+ AUTOMATIC, content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+ DownloadFileType::NOT_DANGEROUS, "http://example.com/foo.bad", "",
+ FILE_PATH_LITERAL(""),
+
+ FILE_PATH_LITERAL("foo.bad"), DownloadItem::TARGET_DISPOSITION_PROMPT,
+ EXPECT_CRDOWNLOAD,
},
};
- // 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 defined(OS_ANDROID)
- 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());
@@ -1755,10 +1896,10 @@ TEST_F(DownloadTargetDeterminerTest, IntermediateNameForResumed) {
{{// 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},
@@ -1767,10 +1908,10 @@ TEST_F(DownloadTargetDeterminerTest, IntermediateNameForResumed) {
{{// 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},
@@ -1794,17 +1935,17 @@ TEST_F(DownloadTargetDeterminerTest, IntermediateNameForResumed) {
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(
@@ -1900,7 +2041,6 @@ TEST_F(DownloadTargetDeterminerTest, MIMETypeDetermination) {
EXPECT_CRDOWNLOAD},
""},
-
};
ON_CALL(*delegate(), GetFileMimeType(
@@ -1911,8 +2051,8 @@ TEST_F(DownloadTargetDeterminerTest, MIMETypeDetermination) {
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());
@@ -1951,10 +2091,9 @@ TEST_F(DownloadTargetDeterminerTest, ResumedWithUserValidatedDownload) {
.WillByDefault(Return(content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED));
EXPECT_CALL(*delegate(), NotifyExtensions(_, _, _));
EXPECT_CALL(*delegate(), ReserveVirtualPath(_, expected_path, false, _, _));
- EXPECT_CALL(*delegate(), PromptUserForDownloadPath(_, expected_path, _))
- .Times(0);
EXPECT_CALL(*delegate(), DetermineLocalPath(_, expected_path, _));
EXPECT_CALL(*delegate(), CheckDownloadUrl(_, expected_path, _)).Times(0);
+ EXPECT_CALL(*delegate(), RequestConfirmation(_, _, _, _)).Times(0);
RunTestCase(test_case, GetPathInDownloadDir(kInitialPath), item.get());
}
@@ -2108,8 +2247,8 @@ TEST_F(DownloadTargetDeterminerTestWithPlugin, CheckForSecureHandling_PPAPI) {
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);
@@ -2177,8 +2316,8 @@ TEST_F(DownloadTargetDeterminerTestWithPlugin,
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);
« no previous file with comments | « chrome/browser/download/download_target_determiner_delegate.h ('k') | chrome/browser/download/download_target_info.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698