// 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 <sstream>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/file_util.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/files/scoped_temp_dir.h"
#include "base/memory/ref_counted.h"
#include "base/path_service.h"
#include "base/prefs/pref_service.h"
#include "base/stl_util.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/sys_info.h"
#include "base/test/test_file_util.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/common/cancelable_request.h"
#include "chrome/browser/download/chrome_download_manager_delegate.h"
#include "chrome/browser/download/download_browsertest.h"
#include "chrome/browser/download/download_crx_util.h"
#include "chrome/browser/download/download_history.h"
#include "chrome/browser/download/download_item_model.h"
#include "chrome/browser/download/download_prefs.h"
#include "chrome/browser/download/download_request_limiter.h"
#include "chrome/browser/download/download_service.h"
#include "chrome/browser/download/download_service_factory.h"
#include "chrome/browser/download/download_shelf.h"
#include "chrome/browser/download/download_target_determiner.h"
#include "chrome/browser/download/download_test_file_activity_observer.h"
#include "chrome/browser/extensions/extension_install_prompt.h"
#include "chrome/browser/extensions/extension_service.h"
#include "chrome/browser/history/download_row.h"
#include "chrome/browser/history/history_service.h"
#include "chrome/browser/history/history_service_factory.h"
#include "chrome/browser/infobars/infobar_service.h"
#include "chrome/browser/net/url_request_mock_util.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
#include "chrome/browser/safe_browsing/download_feedback_service.h"
#include "chrome/browser/safe_browsing/download_protection_service.h"
#include "chrome/browser/safe_browsing/safe_browsing_service.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_finder.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/browser/ui/browser_tabstrip.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/chrome_pages.h"
#include "chrome/browser/ui/host_desktop.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/safe_browsing/csd.pb.h"
#include "chrome/common/url_constants.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/test_switches.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/infobars/core/confirm_infobar_delegate.h"
#include "components/infobars/core/infobar.h"
#include "content/public/browser/download_interrupt_reasons.h"
#include "content/public/browser/download_item.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/download_save_info.h"
#include "content/public/browser/download_url_parameters.h"
#include "content/public/browser/notification_source.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/resource_context.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/context_menu_params.h"
#include "content/public/common/page_transition_types.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/download_test_observer.h"
#include "content/public/test/test_file_error_injector.h"
#include "content/public/test/test_navigation_observer.h"
#include "content/test/net/url_request_mock_http_job.h"
#include "content/test/net/url_request_slow_download_job.h"
#include "extensions/browser/extension_system.h"
#include "extensions/common/feature_switch.h"
#include "grit/generated_resources.h"
#include "net/base/filename_util.h"
#include "net/test/spawned_test_server/spawned_test_server.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/l10n/l10n_util.h"
using content::BrowserContext;
using content::BrowserThread;
using content::DownloadItem;
using content::DownloadManager;
using content::DownloadUrlParameters;
using content::URLRequestMockHTTPJob;
using content::URLRequestSlowDownloadJob;
using content::WebContents;
using extensions::Extension;
using extensions::FeatureSwitch;
namespace {
class CreatedObserver : public content::DownloadManager::Observer {
public:
explicit CreatedObserver(content::DownloadManager* manager)
: manager_(manager),
waiting_(false) {
manager->AddObserver(this);
}
virtual ~CreatedObserver() {
if (manager_)
manager_->RemoveObserver(this);
}
void Wait() {
std::vector<DownloadItem*> downloads;
manager_->GetAllDownloads(&downloads);
if (!downloads.empty())
return;
waiting_ = true;
content::RunMessageLoop();
waiting_ = false;
}
private:
virtual void OnDownloadCreated(content::DownloadManager* manager,
content::DownloadItem* item) OVERRIDE {
DCHECK_EQ(manager_, manager);
if (waiting_)
base::MessageLoopForUI::current()->Quit();
}
content::DownloadManager* manager_;
bool waiting_;
DISALLOW_COPY_AND_ASSIGN(CreatedObserver);
};
class PercentWaiter : public content::DownloadItem::Observer {
public:
explicit PercentWaiter(DownloadItem* item)
: item_(item),
waiting_(false),
error_(false),
prev_percent_(0) {
item_->AddObserver(this);
}
virtual ~PercentWaiter() {
if (item_)
item_->RemoveObserver(this);
}
bool WaitForFinished() {
if (item_->GetState() == DownloadItem::COMPLETE) {
return item_->PercentComplete() == 100;
}
waiting_ = true;
content::RunMessageLoop();
waiting_ = false;
return !error_;
}
private:
virtual void OnDownloadUpdated(content::DownloadItem* item) OVERRIDE {
DCHECK_EQ(item_, item);
if (!error_ &&
((prev_percent_ > item_->PercentComplete()) ||
(item_->GetState() == DownloadItem::COMPLETE &&
(item_->PercentComplete() != 100)))) {
error_ = true;
if (waiting_)
base::MessageLoopForUI::current()->Quit();
}
if (item_->GetState() == DownloadItem::COMPLETE && waiting_)
base::MessageLoopForUI::current()->Quit();
}
virtual void OnDownloadDestroyed(content::DownloadItem* item) OVERRIDE {
DCHECK_EQ(item_, item);
item_->RemoveObserver(this);
item_ = NULL;
}
content::DownloadItem* item_;
bool waiting_;
bool error_;
int prev_percent_;
DISALLOW_COPY_AND_ASSIGN(PercentWaiter);
};
// DownloadTestObserver subclass that observes one download until it transitions
// from a non-resumable state to a resumable state a specified number of
// times. Note that this observer can only observe a single download.
class DownloadTestObserverResumable : public content::DownloadTestObserver {
public:
// Construct a new observer. |transition_count| is the number of times the
// download should transition from a non-resumable state to a resumable state.
DownloadTestObserverResumable(DownloadManager* download_manager,
size_t transition_count)
: DownloadTestObserver(download_manager, 1,
ON_DANGEROUS_DOWNLOAD_FAIL),
was_previously_resumable_(false),
transitions_left_(transition_count) {
Init();
}
virtual ~DownloadTestObserverResumable() {}
private:
virtual bool IsDownloadInFinalState(DownloadItem* download) OVERRIDE {
bool is_resumable_now = download->CanResume();
if (!was_previously_resumable_ && is_resumable_now)
--transitions_left_;
was_previously_resumable_ = is_resumable_now;
return transitions_left_ == 0;
}
bool was_previously_resumable_;
size_t transitions_left_;
DISALLOW_COPY_AND_ASSIGN(DownloadTestObserverResumable);
};
// IDs and paths of CRX files used in tests.
const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
const base::FilePath kGoodCrxPath(FILE_PATH_LITERAL("extensions/good.crx"));
const char kLargeThemeCrxId[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
const base::FilePath kLargeThemePath(
FILE_PATH_LITERAL("extensions/theme2.crx"));
// Get History Information.
class DownloadsHistoryDataCollector {
public:
explicit DownloadsHistoryDataCollector(Profile* profile)
: profile_(profile), result_valid_(false) {}
bool WaitForDownloadInfo(
scoped_ptr<std::vector<history::DownloadRow> >* results) {
HistoryService* hs = HistoryServiceFactory::GetForProfile(
profile_, Profile::EXPLICIT_ACCESS);
DCHECK(hs);
hs->QueryDownloads(
base::Bind(&DownloadsHistoryDataCollector::OnQueryDownloadsComplete,
base::Unretained(this)));
content::RunMessageLoop();
if (result_valid_) {
*results = results_.Pass();
}
return result_valid_;
}
private:
void OnQueryDownloadsComplete(
scoped_ptr<std::vector<history::DownloadRow> > entries) {
result_valid_ = true;
results_ = entries.Pass();
base::MessageLoopForUI::current()->Quit();
}
Profile* profile_;
scoped_ptr<std::vector<history::DownloadRow> > results_;
bool result_valid_;
CancelableRequestConsumer callback_consumer_;
DISALLOW_COPY_AND_ASSIGN(DownloadsHistoryDataCollector);
};
// Mock that simulates a permissions dialog where the user denies
// permission to install. TODO(skerner): This could be shared with
// extensions tests. Find a common place for this class.
class MockAbortExtensionInstallPrompt : public ExtensionInstallPrompt {
public:
MockAbortExtensionInstallPrompt() :
ExtensionInstallPrompt(NULL) {
}
// Simulate a user abort on an extension installation.
virtual void ConfirmInstall(
Delegate* delegate,
const Extension* extension,
const ShowDialogCallback& show_dialog_callback) OVERRIDE {
delegate->InstallUIAbort(true);
base::MessageLoopForUI::current()->Quit();
}
virtual void OnInstallSuccess(const Extension* extension,
SkBitmap* icon) OVERRIDE {
}
virtual void OnInstallFailure(
const extensions::CrxInstallerError& error) OVERRIDE {
}
};
// Mock that simulates a permissions dialog where the user allows
// installation.
class MockAutoConfirmExtensionInstallPrompt : public ExtensionInstallPrompt {
public:
explicit MockAutoConfirmExtensionInstallPrompt(
content::WebContents* web_contents)
: ExtensionInstallPrompt(web_contents) {}
// Proceed without confirmation prompt.
virtual void ConfirmInstall(
Delegate* delegate,
const Extension* extension,
const ShowDialogCallback& show_dialog_callback) OVERRIDE {
delegate->InstallUIProceed();
}
virtual void OnInstallSuccess(const Extension* extension,
SkBitmap* icon) OVERRIDE {
}
virtual void OnInstallFailure(
const extensions::CrxInstallerError& error) OVERRIDE {
}
};
static DownloadManager* DownloadManagerForBrowser(Browser* browser) {
return BrowserContext::GetDownloadManager(browser->profile());
}
bool WasAutoOpened(DownloadItem* item) {
return item->GetAutoOpened();
}
// Called when a download starts. Marks the download as hidden.
void SetHiddenDownloadCallback(DownloadItem* item,
content::DownloadInterruptReason reason) {
DownloadItemModel(item).SetShouldShowInShelf(false);
}
// Callback for HistoryObserver; used in DownloadHistoryCheck
bool HasDataAndName(const history::DownloadRow& row) {
return row.received_bytes > 0 && !row.target_path.empty();
}
} // namespace
DownloadTestObserverNotInProgress::DownloadTestObserverNotInProgress(
DownloadManager* download_manager,
size_t count)
: DownloadTestObserver(download_manager, count, ON_DANGEROUS_DOWNLOAD_FAIL),
started_observing_(false) {
Init();
}
DownloadTestObserverNotInProgress::~DownloadTestObserverNotInProgress() {}
void DownloadTestObserverNotInProgress::StartObserving() {
started_observing_ = true;
}
bool DownloadTestObserverNotInProgress::IsDownloadInFinalState(
DownloadItem* download) {
return started_observing_ &&
download->GetState() != DownloadItem::IN_PROGRESS;
}
class HistoryObserver : public DownloadHistory::Observer {
public:
typedef base::Callback<bool(const history::DownloadRow&)> FilterCallback;
explicit HistoryObserver(Profile* profile)
: profile_(profile),
waiting_(false),
seen_stored_(false) {
DownloadServiceFactory::GetForBrowserContext(profile_)->
GetDownloadHistory()->AddObserver(this);
}
virtual ~HistoryObserver() {
DownloadService* service = DownloadServiceFactory::GetForBrowserContext(
profile_);
if (service && service->GetDownloadHistory())
service->GetDownloadHistory()->RemoveObserver(this);
}
void SetFilterCallback(const FilterCallback& callback) {
callback_ = callback;
}
virtual void OnDownloadStored(
content::DownloadItem* item,
const history::DownloadRow& info) OVERRIDE {
if (!callback_.is_null() && (!callback_.Run(info)))
return;
seen_stored_ = true;
if (waiting_)
base::MessageLoopForUI::current()->Quit();
}
virtual void OnDownloadHistoryDestroyed() OVERRIDE {
DownloadServiceFactory::GetForBrowserContext(profile_)->
GetDownloadHistory()->RemoveObserver(this);
}
void WaitForStored() {
if (seen_stored_)
return;
waiting_ = true;
content::RunMessageLoop();
waiting_ = false;
}
private:
Profile* profile_;
bool waiting_;
bool seen_stored_;
FilterCallback callback_;
DISALLOW_COPY_AND_ASSIGN(HistoryObserver);
};
class DownloadTest : public InProcessBrowserTest {
public:
// Choice of navigation or direct fetch. Used by |DownloadFileCheckErrors()|.
enum DownloadMethod {
DOWNLOAD_NAVIGATE,
DOWNLOAD_DIRECT
};
// Information passed in to |DownloadFileCheckErrors()|.
struct DownloadInfo {
const char* url_name; // URL for the download.
DownloadMethod download_method; // Navigation or Direct.
// Download interrupt reason (NONE is OK).
content::DownloadInterruptReason reason;
bool show_download_item; // True if the download item appears on the shelf.
bool should_redirect_to_documents; // True if we save it in "My Documents".
};
struct FileErrorInjectInfo {
DownloadInfo download_info;
content::TestFileErrorInjector::FileErrorInfo error_info;
};
DownloadTest() {}
virtual void SetUpOnMainThread() OVERRIDE {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
ASSERT_TRUE(InitialSetup());
}
virtual void CleanUpOnMainThread() OVERRIDE {
// Needs to be torn down on the main thread. file_activity_observer_ holds a
// reference to the ChromeDownloadManagerDelegate which should be destroyed
// on the UI thread.
file_activity_observer_.reset();
}
virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
command_line->AppendSwitch(switches::kDisablePluginsDiscovery);
}
// Returning false indicates a failure of the setup, and should be asserted
// in the caller.
virtual bool InitialSetup() {
bool have_test_dir = PathService::Get(chrome::DIR_TEST_DATA, &test_dir_);
EXPECT_TRUE(have_test_dir);
if (!have_test_dir)
return false;
// Sanity check default values for window / tab count and shelf visibility.
int window_count = chrome::GetTotalBrowserCount();
EXPECT_EQ(1, window_count);
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Set up the temporary download folder.
bool created_downloads_dir = CreateAndSetDownloadsDirectory(browser());
EXPECT_TRUE(created_downloads_dir);
if (!created_downloads_dir)
return false;
browser()->profile()->GetPrefs()->SetBoolean(
prefs::kPromptForDownload, false);
DownloadManager* manager = DownloadManagerForBrowser(browser());
DownloadPrefs::FromDownloadManager(manager)->ResetAutoOpen();
manager->RemoveAllDownloads();
file_activity_observer_.reset(
new DownloadTestFileActivityObserver(browser()->profile()));
return true;
}
protected:
enum SizeTestType {
SIZE_TEST_TYPE_KNOWN,
SIZE_TEST_TYPE_UNKNOWN,
};
base::FilePath GetDownloadsDirectory() {
return downloads_directory_.path();
}
// Location of the file source (the place from which it is downloaded).
base::FilePath OriginFile(base::FilePath file) {
return test_dir_.Append(file);
}
// Location of the file destination (place to which it is downloaded).
base::FilePath DestinationFile(Browser* browser, base::FilePath file) {
return GetDownloadDirectory(browser).Append(file.BaseName());
}
// Must be called after browser creation. Creates a temporary
// directory for downloads that is auto-deleted on destruction.
// Returning false indicates a failure of the function, and should be asserted
// in the caller.
bool CreateAndSetDownloadsDirectory(Browser* browser) {
if (!browser)
return false;
if (!downloads_directory_.CreateUniqueTempDir())
return false;
browser->profile()->GetPrefs()->SetFilePath(
prefs::kDownloadDefaultDirectory,
downloads_directory_.path());
browser->profile()->GetPrefs()->SetFilePath(
prefs::kSaveFileDefaultDirectory,
downloads_directory_.path());
return true;
}
DownloadPrefs* GetDownloadPrefs(Browser* browser) {
return DownloadPrefs::FromDownloadManager(
DownloadManagerForBrowser(browser));
}
base::FilePath GetDownloadDirectory(Browser* browser) {
return GetDownloadPrefs(browser)->DownloadPath();
}
// Create a DownloadTestObserverTerminal that will wait for the
// specified number of downloads to finish.
content::DownloadTestObserver* CreateWaiter(
Browser* browser, int num_downloads) {
DownloadManager* download_manager = DownloadManagerForBrowser(browser);
return new content::DownloadTestObserverTerminal(
download_manager, num_downloads,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL);
}
// Create a DownloadTestObserverInProgress that will wait for the
// specified number of downloads to start.
content::DownloadTestObserver* CreateInProgressWaiter(
Browser* browser, int num_downloads) {
DownloadManager* download_manager = DownloadManagerForBrowser(browser);
return new content::DownloadTestObserverInProgress(
download_manager, num_downloads);
}
// Create a DownloadTestObserverTerminal that will wait for the
// specified number of downloads to finish, or for
// a dangerous download warning to be shown.
content::DownloadTestObserver* DangerousDownloadWaiter(
Browser* browser,
int num_downloads,
content::DownloadTestObserver::DangerousDownloadAction
dangerous_download_action) {
DownloadManager* download_manager = DownloadManagerForBrowser(browser);
return new content::DownloadTestObserverTerminal(
download_manager, num_downloads,
dangerous_download_action);
}
void CheckDownloadStatesForBrowser(Browser* browser,
size_t num,
DownloadItem::DownloadState state) {
std::vector<DownloadItem*> download_items;
GetDownloads(browser, &download_items);
EXPECT_EQ(num, download_items.size());
for (size_t i = 0; i < download_items.size(); ++i) {
EXPECT_EQ(state, download_items[i]->GetState()) << " Item " << i;
}
}
void CheckDownloadStates(size_t num, DownloadItem::DownloadState state) {
CheckDownloadStatesForBrowser(browser(), num, state);
}
// Download |url|, then wait for the download to finish.
// |disposition| indicates where the navigation occurs (current tab, new
// foreground tab, etc).
// |browser_test_flags| indicate what to wait for, and is an OR of 0 or more
// values in the ui_test_utils::BrowserTestWaitFlags enum.
void DownloadAndWaitWithDisposition(Browser* browser,
const GURL& url,
WindowOpenDisposition disposition,
int browser_test_flags) {
// Setup notification, navigate, and block.
scoped_ptr<content::DownloadTestObserver> observer(
CreateWaiter(browser, 1));
// This call will block until the condition specified by
// |browser_test_flags|, but will not wait for the download to finish.
ui_test_utils::NavigateToURLWithDisposition(browser,
url,
disposition,
browser_test_flags);
// Waits for the download to complete.
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
// We don't expect a file chooser to be shown.
EXPECT_FALSE(DidShowFileChooser());
}
// Download a file in the current tab, then wait for the download to finish.
void DownloadAndWait(Browser* browser,
const GURL& url) {
DownloadAndWaitWithDisposition(
browser,
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
}
// Should only be called when the download is known to have finished
// (in error or not).
// Returning false indicates a failure of the function, and should be asserted
// in the caller.
bool CheckDownload(Browser* browser,
const base::FilePath& downloaded_filename,
const base::FilePath& origin_filename) {
// Find the path to which the data will be downloaded.
base::FilePath downloaded_file(
DestinationFile(browser, downloaded_filename));
// Find the origin path (from which the data comes).
base::FilePath origin_file(OriginFile(origin_filename));
return CheckDownloadFullPaths(browser, downloaded_file, origin_file);
}
// A version of CheckDownload that allows complete path specification.
bool CheckDownloadFullPaths(Browser* browser,
const base::FilePath& downloaded_file,
const base::FilePath& origin_file) {
bool origin_file_exists = base::PathExists(origin_file);
EXPECT_TRUE(origin_file_exists) << origin_file.value();
if (!origin_file_exists)
return false;
// Confirm the downloaded data file exists.
bool downloaded_file_exists = base::PathExists(downloaded_file);
EXPECT_TRUE(downloaded_file_exists) << downloaded_file.value();
if (!downloaded_file_exists)
return false;
int64 origin_file_size = 0;
EXPECT_TRUE(base::GetFileSize(origin_file, &origin_file_size));
std::string original_file_contents;
EXPECT_TRUE(base::ReadFileToString(origin_file, &original_file_contents));
EXPECT_TRUE(
VerifyFile(downloaded_file, original_file_contents, origin_file_size));
// Delete the downloaded copy of the file.
bool downloaded_file_deleted = base::DieFileDie(downloaded_file, false);
EXPECT_TRUE(downloaded_file_deleted);
return downloaded_file_deleted;
}
content::DownloadTestObserver* CreateInProgressDownloadObserver(
size_t download_count) {
DownloadManager* manager = DownloadManagerForBrowser(browser());
return new content::DownloadTestObserverInProgress(
manager, download_count);
}
DownloadItem* CreateSlowTestDownload() {
scoped_ptr<content::DownloadTestObserver> observer(
CreateInProgressDownloadObserver(1));
GURL slow_download_url(URLRequestSlowDownloadJob::kUnknownSizeUrl);
DownloadManager* manager = DownloadManagerForBrowser(browser());
EXPECT_EQ(0, manager->NonMaliciousInProgressCount());
EXPECT_EQ(0, manager->InProgressCount());
if (manager->InProgressCount() != 0)
return NULL;
ui_test_utils::NavigateToURLWithDisposition(
browser(), slow_download_url, CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
DownloadManager::DownloadVector items;
manager->GetAllDownloads(&items);
DownloadItem* new_item = NULL;
for (DownloadManager::DownloadVector::iterator iter = items.begin();
iter != items.end(); ++iter) {
if ((*iter)->GetState() == DownloadItem::IN_PROGRESS) {
// There should be only one IN_PROGRESS item.
EXPECT_EQ(NULL, new_item);
new_item = *iter;
}
}
return new_item;
}
bool RunSizeTest(Browser* browser,
SizeTestType type,
const std::string& partial_indication,
const std::string& total_indication) {
EXPECT_TRUE(type == SIZE_TEST_TYPE_UNKNOWN || type == SIZE_TEST_TYPE_KNOWN);
if (type != SIZE_TEST_TYPE_KNOWN && type != SIZE_TEST_TYPE_UNKNOWN)
return false;
GURL url(type == SIZE_TEST_TYPE_KNOWN ?
URLRequestSlowDownloadJob::kKnownSizeUrl :
URLRequestSlowDownloadJob::kUnknownSizeUrl);
// TODO(ahendrickson) -- |expected_title_in_progress| and
// |expected_title_finished| need to be checked.
base::FilePath filename;
net::FileURLToFilePath(url, &filename);
base::string16 expected_title_in_progress(
base::ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
base::string16 expected_title_finished(
base::ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
// Download a partial web page in a background tab and wait.
// The mock system will not complete until it gets a special URL.
scoped_ptr<content::DownloadTestObserver> observer(
CreateWaiter(browser, 1));
ui_test_utils::NavigateToURL(browser, url);
// TODO(ahendrickson): check download status text before downloading.
// Need to:
// - Add a member function to the |DownloadShelf| interface class, that
// indicates how many members it has.
// - Add a member function to |DownloadShelf| to get the status text
// of a given member (for example, via the name in |DownloadItemView|'s
// GetAccessibleState() member function), by index.
// - Iterate over browser->window()->GetDownloadShelf()'s members
// to see if any match the status text we want. Start with the last one.
// Allow the request to finish. We do this by loading a second URL in a
// separate tab.
GURL finish_url(URLRequestSlowDownloadJob::kFinishDownloadUrl);
ui_test_utils::NavigateToURLWithDisposition(
browser,
finish_url,
NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);
EXPECT_EQ(2, browser->tab_strip_model()->count());
// TODO(ahendrickson): check download status text after downloading.
base::FilePath basefilename(filename.BaseName());
net::FileURLToFilePath(url, &filename);
base::FilePath download_path =
downloads_directory_.path().Append(basefilename);
EXPECT_TRUE(browser->window()->IsDownloadShelfVisible());
bool downloaded_path_exists = base::PathExists(download_path);
EXPECT_TRUE(downloaded_path_exists);
if (!downloaded_path_exists)
return false;
// Check the file contents.
size_t file_size = URLRequestSlowDownloadJob::kFirstDownloadSize +
URLRequestSlowDownloadJob::kSecondDownloadSize;
std::string expected_contents(file_size, '*');
EXPECT_TRUE(VerifyFile(download_path, expected_contents, file_size));
// Delete the file we just downloaded.
EXPECT_TRUE(base::DieFileDie(download_path, true));
EXPECT_FALSE(base::PathExists(download_path));
return true;
}
void GetDownloads(Browser* browser, std::vector<DownloadItem*>* downloads) {
DCHECK(downloads);
DownloadManager* manager = DownloadManagerForBrowser(browser);
manager->GetAllDownloads(downloads);
}
static void ExpectWindowCountAfterDownload(size_t expected) {
EXPECT_EQ(expected, chrome::GetTotalBrowserCount());
}
void EnableFileChooser(bool enable) {
file_activity_observer_->EnableFileChooser(enable);
}
bool DidShowFileChooser() {
return file_activity_observer_->TestAndResetDidShowFileChooser();
}
// Checks that |path| is has |file_size| bytes, and matches the |value|
// string.
bool VerifyFile(const base::FilePath& path,
const std::string& value,
const int64 file_size) {
std::string file_contents;
bool read = base::ReadFileToString(path, &file_contents);
EXPECT_TRUE(read) << "Failed reading file: " << path.value() << std::endl;
if (!read)
return false; // Couldn't read the file.
// Note: we don't handle really large files (more than size_t can hold)
// so we will fail in that case.
size_t expected_size = static_cast<size_t>(file_size);
// Check the size.
EXPECT_EQ(expected_size, file_contents.size());
if (expected_size != file_contents.size())
return false;
// Check the contents.
EXPECT_EQ(value, file_contents);
if (memcmp(file_contents.c_str(), value.c_str(), expected_size) != 0)
return false;
return true;
}
// Attempts to download a file, based on information in |download_info|.
// If a Select File dialog opens, will automatically choose the default.
void DownloadFilesCheckErrorsSetup() {
ASSERT_TRUE(test_server()->Start());
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
EnableFileChooser(true);
}
void DownloadFilesCheckErrorsLoopBody(const DownloadInfo& download_info,
size_t i) {
std::stringstream s;
s << " " << __FUNCTION__ << "()"
<< " index = " << i
<< " url = '" << download_info.url_name << "'"
<< " method = "
<< ((download_info.download_method == DOWNLOAD_DIRECT) ?
"DOWNLOAD_DIRECT" : "DOWNLOAD_NAVIGATE")
<< " show_item = " << download_info.show_download_item
<< " reason = " << DownloadInterruptReasonToString(download_info.reason);
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
size_t downloads_expected = download_items.size();
std::string server_path = "files/downloads/";
server_path += download_info.url_name;
GURL url = test_server()->GetURL(server_path);
ASSERT_TRUE(url.is_valid()) << s.str();
DownloadManager* download_manager = DownloadManagerForBrowser(browser());
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(web_contents) << s.str();
scoped_ptr<content::DownloadTestObserver> observer(
new content::DownloadTestObserverTerminal(
download_manager,
1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
if (download_info.download_method == DOWNLOAD_DIRECT) {
// Go directly to download. Don't wait for navigation.
scoped_refptr<content::DownloadTestItemCreationObserver>
creation_observer(new content::DownloadTestItemCreationObserver);
scoped_ptr<DownloadUrlParameters> params(
DownloadUrlParameters::FromWebContents(web_contents, url));
params->set_callback(creation_observer->callback());
DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
// Wait until the item is created, or we have determined that it
// won't be.
creation_observer->WaitForDownloadItemCreation();
EXPECT_EQ(download_info.show_download_item,
creation_observer->succeeded());
if (download_info.show_download_item) {
EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE,
creation_observer->interrupt_reason());
EXPECT_NE(content::DownloadItem::kInvalidId,
creation_observer->download_id());
} else {
EXPECT_NE(content::DOWNLOAD_INTERRUPT_REASON_NONE,
creation_observer->interrupt_reason());
EXPECT_EQ(content::DownloadItem::kInvalidId,
creation_observer->download_id());
}
} else {
// Navigate to URL normally, wait until done.
ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(),
url,
1);
}
if (download_info.show_download_item) {
downloads_expected++;
observer->WaitForFinished();
DownloadItem::DownloadState final_state =
(download_info.reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
DownloadItem::COMPLETE :
DownloadItem::INTERRUPTED;
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(final_state));
}
// Wait till the |DownloadFile|s are destroyed.
content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
// Validate that the correct files were downloaded.
download_items.clear();
GetDownloads(browser(), &download_items);
ASSERT_EQ(downloads_expected, download_items.size()) << s.str();
if (download_info.show_download_item) {
// Find the last download item.
DownloadItem* item = download_items[0];
for (size_t d = 1; d < downloads_expected; ++d) {
if (download_items[d]->GetStartTime() > item->GetStartTime())
item = download_items[d];
}
ASSERT_EQ(url, item->GetOriginalUrl()) << s.str();
ASSERT_EQ(download_info.reason, item->GetLastReason()) << s.str();
if (item->GetState() == content::DownloadItem::COMPLETE) {
// Clean up the file, in case it ended up in the My Documents folder.
base::FilePath destination_folder = GetDownloadDirectory(browser());
base::FilePath my_downloaded_file = item->GetTargetFilePath();
EXPECT_TRUE(base::PathExists(my_downloaded_file));
EXPECT_TRUE(base::DeleteFile(my_downloaded_file, false));
EXPECT_EQ(download_info.should_redirect_to_documents ?
std::string::npos :
0u,
my_downloaded_file.value().find(destination_folder.value()));
if (download_info.should_redirect_to_documents) {
// If it's not where we asked it to be, it should be in the
// My Documents folder.
base::FilePath my_docs_folder;
EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DOCUMENTS,
&my_docs_folder));
EXPECT_EQ(0u,
my_downloaded_file.value().find(my_docs_folder.value()));
}
}
}
}
// Attempts to download a set of files, based on information in the
// |download_info| array. |count| is the number of files.
// If a Select File dialog appears, it will choose the default and return
// immediately.
void DownloadFilesCheckErrors(size_t count, DownloadInfo* download_info) {
DownloadFilesCheckErrorsSetup();
for (size_t i = 0; i < count; ++i) {
DownloadFilesCheckErrorsLoopBody(download_info[i], i);
}
}
void DownloadInsertFilesErrorCheckErrorsLoopBody(
scoped_refptr<content::TestFileErrorInjector> injector,
const FileErrorInjectInfo& info,
size_t i) {
std::stringstream s;
s << " " << __FUNCTION__ << "()"
<< " index = " << i
<< " url = " << info.error_info.url
<< " operation code = "
<< content::TestFileErrorInjector::DebugString(info.error_info.code)
<< " instance = " << info.error_info.operation_instance
<< " error = "
<< content::DownloadInterruptReasonToString(info.error_info.error);
injector->ClearErrors();
injector->AddError(info.error_info);
injector->InjectErrors();
DownloadFilesCheckErrorsLoopBody(info.download_info, i);
size_t expected_successes = info.download_info.show_download_item ? 1u : 0u;
EXPECT_EQ(expected_successes, injector->TotalFileCount()) << s.str();
EXPECT_EQ(0u, injector->CurrentFileCount()) << s.str();
if (info.download_info.show_download_item)
EXPECT_TRUE(injector->HadFile(GURL(info.error_info.url))) << s.str();
}
void DownloadInsertFilesErrorCheckErrors(size_t count,
FileErrorInjectInfo* info) {
DownloadFilesCheckErrorsSetup();
// Set up file failures.
scoped_refptr<content::TestFileErrorInjector> injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
for (size_t i = 0; i < count; ++i) {
// Set up the full URL, for download file tracking.
std::string server_path = "files/downloads/";
server_path += info[i].download_info.url_name;
GURL url = test_server()->GetURL(server_path);
info[i].error_info.url = url.spec();
DownloadInsertFilesErrorCheckErrorsLoopBody(injector, info[i], i);
}
}
// Attempts to download a file to a read-only folder, based on information
// in |download_info|.
void DownloadFilesToReadonlyFolder(size_t count,
DownloadInfo* download_info) {
DownloadFilesCheckErrorsSetup();
// Make the test folder unwritable.
base::FilePath destination_folder = GetDownloadDirectory(browser());
DVLOG(1) << " " << __FUNCTION__ << "()"
<< " folder = '" << destination_folder.value() << "'";
file_util::PermissionRestorer permission_restorer(destination_folder);
EXPECT_TRUE(file_util::MakeFileUnwritable(destination_folder));
for (size_t i = 0; i < count; ++i) {
DownloadFilesCheckErrorsLoopBody(download_info[i], i);
}
}
// A mock install prompt that simulates the user allowing an install request.
void SetAllowMockInstallPrompt() {
download_crx_util::SetMockInstallPromptForTesting(
scoped_ptr<ExtensionInstallPrompt>(
new MockAutoConfirmExtensionInstallPrompt(
browser()->tab_strip_model()->GetActiveWebContents())));
}
// This method:
// * Starts a mock download by navigating browser() to a URLRequestMockHTTPJob
// mock URL.
// * Injects |error| on the first write using |error_injector|.
// * Waits for the download to be interrupted.
// * Clears the errors on |error_injector|.
// * Returns the resulting interrupted download.
DownloadItem* StartMockDownloadAndInjectError(
content::TestFileErrorInjector* error_injector,
content::DownloadInterruptReason error) {
base::FilePath file_path(FILE_PATH_LITERAL("download-test1.lib"));
GURL url = URLRequestMockHTTPJob::GetMockUrl(file_path);
content::TestFileErrorInjector::FileErrorInfo error_info;
error_info.url = url.spec();
error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
error_info.operation_instance = 0;
error_info.error = error;
error_injector->ClearErrors();
error_injector->AddError(error_info);
error_injector->InjectErrors();
scoped_ptr<content::DownloadTestObserver> observer(
new DownloadTestObserverResumable(
DownloadManagerForBrowser(browser()), 1));
ui_test_utils::NavigateToURL(browser(), url);
observer->WaitForFinished();
content::DownloadManager::DownloadVector downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
EXPECT_EQ(1u, downloads.size());
if (downloads.size() != 1)
return NULL;
error_injector->ClearErrors();
error_injector->InjectErrors();
DownloadItem* download = downloads[0];
EXPECT_EQ(DownloadItem::INTERRUPTED, download->GetState());
EXPECT_EQ(error, download->GetLastReason());
return download;
}
private:
static void EnsureNoPendingDownloadJobsOnIO(bool* result) {
if (URLRequestSlowDownloadJob::NumberOutstandingRequests())
*result = false;
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, base::MessageLoop::QuitClosure());
}
// Location of the test data.
base::FilePath test_dir_;
// Location of the downloads directory for these tests
base::ScopedTempDir downloads_directory_;
scoped_ptr<DownloadTestFileActivityObserver> file_activity_observer_;
};
// NOTES:
//
// Files for these tests are found in DIR_TEST_DATA (currently
// "chrome\test\data\", see chrome_paths.cc).
// Mock responses have extension .mock-http-headers appended to the file name.
// Download a file due to the associated MIME type.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeType) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// Download the file and wait. We do not expect the Select File dialog.
DownloadAndWait(browser(), url);
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
}
#if defined(OS_WIN)
// Download a file and confirm that the zone identifier (on windows)
// is set to internet.
IN_PROC_BROWSER_TEST_F(DownloadTest, CheckInternetZone) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// Download the file and wait. We do not expect the Select File dialog.
DownloadAndWait(browser(), url);
// Check state. Special file state must be checked before CheckDownload,
// as CheckDownload will delete the output file.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
base::FilePath downloaded_file(DestinationFile(browser(), file));
if (base::VolumeSupportsADS(downloaded_file))
EXPECT_TRUE(base::HasInternetZoneIdentifier(downloaded_file));
CheckDownload(browser(), file, file);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
}
#endif
// Put up a Select File dialog when the file is downloaded, due to
// downloads preferences settings.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeTypeSelect) {
// Re-enable prompting.
browser()->profile()->GetPrefs()->SetBoolean(
prefs::kPromptForDownload, true);
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
EnableFileChooser(true);
// Download the file and wait. We expect the Select File dialog to appear
// due to the MIME type, but we still wait until the download completes.
scoped_ptr<content::DownloadTestObserver> observer(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()),
1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
ui_test_utils::NavigateToURLWithDisposition(
browser(), url, CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
EXPECT_TRUE(DidShowFileChooser());
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
}
// Access a file with a viewable mime-type, verify that a download
// did not initiate.
IN_PROC_BROWSER_TEST_F(DownloadTest, NoDownload) {
base::FilePath file(FILE_PATH_LITERAL("download-test2.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
base::FilePath file_path(DestinationFile(browser(), file));
// Open a web page and wait.
ui_test_utils::NavigateToURL(browser(), url);
// Check that we did not download the web page.
EXPECT_FALSE(base::PathExists(file_path));
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, MimeTypesToShowNotDownload) {
ASSERT_TRUE(test_server()->Start());
// These files should all be displayed in the browser.
const char* mime_types[] = {
// It is unclear whether to display text/css or download it.
// Firefox 3: Display
// Internet Explorer 7: Download
// Safari 3.2: Download
// We choose to match Firefox due to the lot of complains
// from the users if css files are downloaded:
// http://code.google.com/p/chromium/issues/detail?id=7192
"text/css",
"text/javascript",
"text/plain",
"application/x-javascript",
"text/html",
"text/xml",
"text/xsl",
"application/xhtml+xml",
"image/png",
"image/gif",
"image/jpeg",
"image/bmp",
};
for (size_t i = 0; i < arraysize(mime_types); ++i) {
const char* mime_type = mime_types[i];
std::string path("contenttype?");
GURL url(test_server()->GetURL(path + mime_type));
ui_test_utils::NavigateToURL(browser(), url);
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
}
// Verify that when the DownloadResourceThrottle cancels a download, the
// download never makes it to the downloads system.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadResourceThrottleCancels) {
// Navigate to a page with the same domain as the file to download. We can't
// navigate directly to the file we don't want to download because cross-site
// navigations reset the TabDownloadState.
base::FilePath same_site_path(FILE_PATH_LITERAL("download_script.html"));
GURL same_site_url(URLRequestMockHTTPJob::GetMockUrl(same_site_path));
ui_test_utils::NavigateToURL(browser(), same_site_url);
// Make sure the initial navigation didn't trigger a download.
std::vector<content::DownloadItem*> items;
DownloadManagerForBrowser(browser())->GetAllDownloads(&items);
EXPECT_EQ(0u, items.size());
// Disable downloads for the tab.
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
DownloadRequestLimiter::TabDownloadState* tab_download_state =
g_browser_process->download_request_limiter()->GetDownloadState(
web_contents, web_contents, true);
ASSERT_TRUE(tab_download_state);
tab_download_state->set_download_status(
DownloadRequestLimiter::DOWNLOADS_NOT_ALLOWED);
// Try to start the download via Javascript and wait for the corresponding
// load stop event.
content::TestNavigationObserver observer(web_contents);
bool download_assempted;
ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
browser()->tab_strip_model()->GetActiveWebContents(),
"window.domAutomationController.send(startDownload());",
&download_assempted));
ASSERT_TRUE(download_assempted);
observer.Wait();
// Check that we did not download the file.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
base::FilePath file_path(DestinationFile(browser(), file));
EXPECT_FALSE(base::PathExists(file_path));
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Verify that there's no pending download. The resource throttle
// should have deleted it before it created a download item, so it
// shouldn't be available as a cancelled download either.
DownloadManagerForBrowser(browser())->GetAllDownloads(&items);
EXPECT_EQ(0u, items.size());
}
// Download a 0-size file with a content-disposition header, verify that the
// download tab opened and the file exists as the filename specified in the
// header. This also ensures we properly handle empty file downloads.
// The download shelf should be visible in the current tab.
IN_PROC_BROWSER_TEST_F(DownloadTest, ContentDisposition) {
base::FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
base::FilePath download_file(
FILE_PATH_LITERAL("download-test3-attachment.gif"));
// Download a file and wait.
DownloadAndWait(browser(), url);
CheckDownload(browser(), download_file, file);
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
}
// Test that the download shelf is per-window by starting a download in one
// tab, opening a second tab, closing the shelf, going back to the first tab,
// and checking that the shelf is closed.
IN_PROC_BROWSER_TEST_F(DownloadTest, PerWindowShelf) {
base::FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
base::FilePath download_file(
FILE_PATH_LITERAL("download-test3-attachment.gif"));
// Download a file and wait.
DownloadAndWait(browser(), url);
CheckDownload(browser(), download_file, file);
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
// Open a second tab and wait.
EXPECT_NE(static_cast<WebContents*>(NULL),
chrome::AddSelectedTabWithURL(browser(),
GURL(url::kAboutBlankURL),
content::PAGE_TRANSITION_TYPED));
EXPECT_EQ(2, browser()->tab_strip_model()->count());
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
// Hide the download shelf.
browser()->window()->GetDownloadShelf()->Close(DownloadShelf::AUTOMATIC);
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Go to the first tab.
browser()->tab_strip_model()->ActivateTabAt(0, true);
EXPECT_EQ(2, browser()->tab_strip_model()->count());
// The download shelf should not be visible.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// Check whether the downloads shelf is closed when the downloads tab is
// invoked.
IN_PROC_BROWSER_TEST_F(DownloadTest, CloseShelfOnDownloadsTab) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// Download the file and wait. We do not expect the Select File dialog.
DownloadAndWait(browser(), url);
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
// Open the downloads tab.
chrome::ShowDownloads(browser());
// The shelf should now be closed.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// UnknownSize and KnownSize are tests which depend on
// URLRequestSlowDownloadJob to serve content in a certain way. Data will be
// sent in two chunks where the first chunk is 35K and the second chunk is 10K.
// The test will first attempt to download a file; but the server will "pause"
// in the middle until the server receives a second request for
// "download-finish". At that time, the download will finish.
// These tests don't currently test much due to holes in |RunSizeTest()|. See
// comments in that routine for details.
IN_PROC_BROWSER_TEST_F(DownloadTest, UnknownSize) {
ASSERT_TRUE(RunSizeTest(browser(), SIZE_TEST_TYPE_UNKNOWN,
"32.0 KB - ", "100% - "));
}
IN_PROC_BROWSER_TEST_F(DownloadTest, KnownSize) {
ASSERT_TRUE(RunSizeTest(browser(), SIZE_TEST_TYPE_KNOWN,
"71% - ", "100% - "));
}
// Test that when downloading an item in Incognito mode, we don't crash when
// closing the last Incognito window (http://crbug.com/13983).
// Also check that the download shelf is not visible after closing the
// Incognito window.
IN_PROC_BROWSER_TEST_F(DownloadTest, IncognitoDownload) {
Browser* incognito = CreateIncognitoBrowser();
ASSERT_TRUE(incognito);
int window_count = chrome::GetTotalBrowserCount();
EXPECT_EQ(2, window_count);
// Download a file in the Incognito window and wait.
CreateAndSetDownloadsDirectory(incognito);
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// Since |incognito| is a separate browser, we have to set it up explicitly.
incognito->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
false);
DownloadAndWait(incognito, url);
// We should still have 2 windows.
ExpectWindowCountAfterDownload(2);
// Verify that the download shelf is showing for the Incognito window.
EXPECT_TRUE(incognito->window()->IsDownloadShelfVisible());
#if !defined(OS_MACOSX)
// On Mac OS X, the UI window close is delayed until the outermost
// message loop runs. So it isn't possible to get a BROWSER_CLOSED
// notification inside of a test.
content::WindowedNotificationObserver signal(
chrome::NOTIFICATION_BROWSER_CLOSED,
content::Source<Browser>(incognito));
#endif
// Close the Incognito window and don't crash.
chrome::CloseWindow(incognito);
#if !defined(OS_MACOSX)
signal.Wait();
ExpectWindowCountAfterDownload(1);
#endif
// Verify that the regular window does not have a download shelf.
// On ChromeOS, the download panel is common to both profiles, so
// it is still visible.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
CheckDownload(browser(), file, file);
}
// Download one file on-record, then download the same file off-record, and test
// that the filename is deduplicated. The previous test tests for a specific
// bug; this next test tests that filename deduplication happens independently
// of DownloadManager/CDMD.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_IncognitoRegular) {
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
// Read the origin file now so that we can compare the downloaded files to it
// later.
base::FilePath origin(OriginFile(base::FilePath(FILE_PATH_LITERAL(
"downloads/a_zip_file.zip"))));
ASSERT_TRUE(base::PathExists(origin));
int64 origin_file_size = 0;
EXPECT_TRUE(base::GetFileSize(origin, &origin_file_size));
std::string original_contents;
EXPECT_TRUE(base::ReadFileToString(origin, &original_contents));
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
// Download a file in the on-record browser and check that it was downloaded
// correctly.
DownloadAndWaitWithDisposition(browser(),
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
GetDownloads(browser(), &download_items);
ASSERT_EQ(1UL, download_items.size());
ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file.zip")),
download_items[0]->GetTargetFilePath().BaseName());
ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
original_contents, origin_file_size));
// Setup an incognito window.
Browser* incognito = CreateIncognitoBrowser();
ASSERT_TRUE(incognito);
int window_count = BrowserList::GetInstance(
browser()->host_desktop_type())->size();
EXPECT_EQ(2, window_count);
incognito->profile()->GetPrefs()->SetFilePath(
prefs::kDownloadDefaultDirectory,
GetDownloadsDirectory());
incognito->profile()->GetPrefs()->SetFilePath(
prefs::kSaveFileDefaultDirectory,
GetDownloadsDirectory());
download_items.clear();
GetDownloads(incognito, &download_items);
ASSERT_TRUE(download_items.empty());
// Download a file in the incognito browser and check that it was downloaded
// correctly.
DownloadAndWaitWithDisposition(incognito,
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
EXPECT_TRUE(incognito->window()->IsDownloadShelfVisible());
GetDownloads(incognito, &download_items);
ASSERT_EQ(1UL, download_items.size());
ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file (1).zip")),
download_items[0]->GetTargetFilePath().BaseName());
ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
original_contents, origin_file_size));
}
// Navigate to a new background page, but don't download. Confirm that the
// download shelf is not visible and that we have two tabs.
IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
// Because it's an HTML link, it should open a web page rather than
// downloading.
base::FilePath file1(FILE_PATH_LITERAL("download-test2.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
// Open a web page and wait.
ui_test_utils::NavigateToURLWithDisposition(
browser(),
url,
NEW_BACKGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// We should have two tabs now.
EXPECT_EQ(2, browser()->tab_strip_model()->count());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// Download a file in a background tab. Verify that the tab is closed
// automatically, and that the download shelf is visible in the current tab.
IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab1) {
// Download a file in a new background tab and wait. The tab is automatically
// closed when the download begins.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
DownloadAndWaitWithDisposition(
browser(),
url,
NEW_BACKGROUND_TAB,
0);
// When the download finishes, we should still have one tab.
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
}
// Open a web page in the current tab, then download a file in another tab via
// a Javascript call.
// Verify that we have 2 tabs, and the download shelf is visible in the current
// tab.
//
// The download_page1.html page contains an openNew() function that opens a
// tab and then downloads download-test1.lib.
IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab2) {
// Because it's an HTML link, it should open a web page rather than
// downloading.
base::FilePath file1(FILE_PATH_LITERAL("download_page1.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
// Open a web page and wait.
ui_test_utils::NavigateToURL(browser(), url);
// Download a file in a new tab and wait (via Javascript).
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
DownloadAndWaitWithDisposition(browser(),
GURL("javascript:openNew()"),
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
// When the download finishes, we should have two tabs.
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
EXPECT_EQ(2, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
}
// Open a web page in the current tab, open another tab via a Javascript call,
// then download a file in the new tab.
// Verify that we have 2 tabs, and the download shelf is visible in the current
// tab.
//
// The download_page2.html page contains an openNew() function that opens a
// tab.
IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab3) {
// Because it's an HTML link, it should open a web page rather than
// downloading.
base::FilePath file1(FILE_PATH_LITERAL("download_page2.html"));
GURL url1(URLRequestMockHTTPJob::GetMockUrl(file1));
// Open a web page and wait.
ui_test_utils::NavigateToURL(browser(), url1);
// Open a new tab and wait.
ui_test_utils::NavigateToURLWithDisposition(
browser(),
GURL("javascript:openNew()"),
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
EXPECT_EQ(2, browser()->tab_strip_model()->count());
// Download a file and wait.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
DownloadAndWaitWithDisposition(browser(),
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
// When the download finishes, we should have two tabs.
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
EXPECT_EQ(2, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
}
// Open a web page in the current tab, then download a file via Javascript,
// which will do so in a temporary tab.
// Verify that we have 1 tab, and the download shelf is visible.
//
// The download_page3.html page contains an openNew() function that opens a
// tab with download-test1.lib in the URL. When the URL is determined to be
// a download, the tab is closed automatically.
IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab2) {
// Because it's an HTML link, it should open a web page rather than
// downloading.
base::FilePath file1(FILE_PATH_LITERAL("download_page3.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
// Open a web page and wait.
ui_test_utils::NavigateToURL(browser(), url);
// Download a file and wait.
// The file to download is "download-test1.lib".
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
DownloadAndWaitWithDisposition(browser(),
GURL("javascript:openNew()"),
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
// When the download finishes, we should still have one tab.
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
}
// Open a web page in the current tab, then call Javascript via a button to
// download a file in a new tab, which is closed automatically when the
// download begins.
// Verify that we have 1 tab, and the download shelf is visible.
//
// The download_page4.html page contains a form with download-test1.lib as the
// action.
IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab3) {
// Because it's an HTML link, it should open a web page rather than
// downloading.
base::FilePath file1(FILE_PATH_LITERAL("download_page4.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
// Open a web page and wait.
ui_test_utils::NavigateToURL(browser(), url);
// Download a file in a new tab and wait. The tab will automatically close
// when the download begins.
// The file to download is "download-test1.lib".
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
DownloadAndWaitWithDisposition(
browser(),
GURL("javascript:document.getElementById('form').submit()"),
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
// When the download finishes, we should still have one tab.
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
}
// Download a file in a new window.
// Verify that we have 2 windows, and the download shelf is not visible in the
// first window, but is visible in the second window.
// Close the new window.
// Verify that we have 1 window, and the download shelf is not visible.
//
// Regression test for http://crbug.com/44454
IN_PROC_BROWSER_TEST_F(DownloadTest, NewWindow) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
#if !defined(OS_MACOSX)
// See below.
Browser* first_browser = browser();
#endif
// Download a file in a new window and wait.
DownloadAndWaitWithDisposition(browser(),
url,
NEW_WINDOW,
ui_test_utils::BROWSER_TEST_NONE);
// When the download finishes, the download shelf SHOULD NOT be visible in
// the first window.
ExpectWindowCountAfterDownload(2);
EXPECT_EQ(1, browser()->tab_strip_model()->count());
// Download shelf should close. Download panel stays open on ChromeOS.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// The download shelf SHOULD be visible in the second window.
std::set<Browser*> original_browsers;
original_browsers.insert(browser());
Browser* download_browser =
ui_test_utils::GetBrowserNotInSet(original_browsers);
ASSERT_TRUE(download_browser != NULL);
EXPECT_NE(download_browser, browser());
EXPECT_EQ(1, download_browser->tab_strip_model()->count());
EXPECT_TRUE(download_browser->window()->IsDownloadShelfVisible());
#if !defined(OS_MACOSX)
// On Mac OS X, the UI window close is delayed until the outermost
// message loop runs. So it isn't possible to get a BROWSER_CLOSED
// notification inside of a test.
content::WindowedNotificationObserver signal(
chrome::NOTIFICATION_BROWSER_CLOSED,
content::Source<Browser>(download_browser));
#endif
// Close the new window.
chrome::CloseWindow(download_browser);
#if !defined(OS_MACOSX)
signal.Wait();
EXPECT_EQ(first_browser, browser());
ExpectWindowCountAfterDownload(1);
#endif
EXPECT_EQ(1, browser()->tab_strip_model()->count());
// Download shelf should close. Download panel stays open on ChromeOS.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
CheckDownload(browser(), file, file);
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
GURL download_url(URLRequestSlowDownloadJob::kKnownSizeUrl);
base::FilePath file(net::GenerateFileName(download_url,
std::string(),
std::string(),
std::string(),
std::string(),
std::string()));
// We use the server so that we can get a redirect and test url_chain
// persistence.
ASSERT_TRUE(test_server()->Start());
GURL redirect_url = test_server()->GetURL(
"server-redirect?" + download_url.spec());
// Download the url and wait until the object has been stored.
base::Time start(base::Time::Now());
HistoryObserver observer(browser()->profile());
observer.SetFilterCallback(base::Bind(&HasDataAndName));
ui_test_utils::NavigateToURL(browser(), redirect_url);
observer.WaitForStored();
// Get the details on what was stored into the history.
scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
ASSERT_TRUE(DownloadsHistoryDataCollector(
browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
ASSERT_EQ(1u, downloads_in_database->size());
// Confirm history storage is what you expect for a partially completed
// slow download job.
history::DownloadRow& row(downloads_in_database->at(0));
EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
EXPECT_EQ(DownloadTargetDeterminer::GetCrDownloadPath(
DestinationFile(browser(), file)),
row.current_path);
ASSERT_EQ(2u, row.url_chain.size());
EXPECT_EQ(redirect_url.spec(), row.url_chain[0].spec());
EXPECT_EQ(download_url.spec(), row.url_chain[1].spec());
EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, row.danger_type);
EXPECT_LE(start, row.start_time);
EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize, row.received_bytes);
EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize
+ URLRequestSlowDownloadJob::kSecondDownloadSize, row.total_bytes);
EXPECT_EQ(content::DownloadItem::IN_PROGRESS, row.state);
EXPECT_FALSE(row.opened);
// Finish the download. We're ok relying on the history to be flushed
// at this point as our queries will be behind the history updates
// invoked by completion.
scoped_ptr<content::DownloadTestObserver> download_observer(
CreateWaiter(browser(), 1));
ui_test_utils::NavigateToURL(browser(),
GURL(URLRequestSlowDownloadJob::kErrorDownloadUrl));
download_observer->WaitForFinished();
EXPECT_EQ(1u, download_observer->NumDownloadsSeenInState(
DownloadItem::INTERRUPTED));
base::Time end(base::Time::Now());
// Get what was stored in the history.
ASSERT_TRUE(DownloadsHistoryDataCollector(
browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
ASSERT_EQ(1u, downloads_in_database->size());
// Confirm history storage is what you expect for an interrupted slow download
// job. The download isn't continuable, so there's no intermediate file.
history::DownloadRow& row1(downloads_in_database->at(0));
EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
EXPECT_TRUE(row1.current_path.empty());
ASSERT_EQ(2u, row1.url_chain.size());
EXPECT_EQ(redirect_url.spec(), row1.url_chain[0].spec());
EXPECT_EQ(download_url.spec(), row1.url_chain[1].spec());
EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, row1.danger_type);
EXPECT_LE(start, row1.start_time);
EXPECT_GE(end, row1.end_time);
EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize,
row1.received_bytes);
EXPECT_EQ(URLRequestSlowDownloadJob::kFirstDownloadSize
+ URLRequestSlowDownloadJob::kSecondDownloadSize, row1.total_bytes);
EXPECT_EQ(content::DownloadItem::INTERRUPTED, row1.state);
EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED,
row1.interrupt_reason);
EXPECT_FALSE(row1.opened);
}
// Make sure a dangerous file shows up properly in the history.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryDangerCheck) {
#if defined(OS_WIN) && defined(USE_ASH)
// Disable this test in Metro+Ash for now (http://crbug.com/262796).
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
return;
#endif
// .swf file so that it's dangerous on all platforms (including CrOS).
base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
// Download the url and wait until the object has been stored.
scoped_ptr<content::DownloadTestObserver> download_observer(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_IGNORE));
base::Time start(base::Time::Now());
HistoryObserver observer(browser()->profile());
observer.SetFilterCallback(base::Bind(&HasDataAndName));
ui_test_utils::NavigateToURL(browser(), download_url);
observer.WaitForStored();
// Get the details on what was stored into the history.
scoped_ptr<std::vector<history::DownloadRow> > downloads_in_database;
ASSERT_TRUE(DownloadsHistoryDataCollector(
browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
ASSERT_EQ(1u, downloads_in_database->size());
// Confirm history storage is what you expect for an unvalidated
// dangerous file.
history::DownloadRow& row(downloads_in_database->at(0));
EXPECT_EQ(DestinationFile(browser(), file), row.target_path);
EXPECT_NE(DownloadTargetDeterminer::GetCrDownloadPath(
DestinationFile(browser(), file)),
row.current_path);
EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE, row.danger_type);
EXPECT_LE(start, row.start_time);
EXPECT_EQ(content::DownloadItem::IN_PROGRESS, row.state);
EXPECT_FALSE(row.opened);
// Validate the download and wait for it to finish.
std::vector<DownloadItem*> downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
downloads[0]->ValidateDangerousDownload();
download_observer->WaitForFinished();
// Get history details and confirm it's what you expect.
downloads_in_database->clear();
ASSERT_TRUE(DownloadsHistoryDataCollector(
browser()->profile()).WaitForDownloadInfo(&downloads_in_database));
ASSERT_EQ(1u, downloads_in_database->size());
history::DownloadRow& row1(downloads_in_database->at(0));
EXPECT_EQ(DestinationFile(browser(), file), row1.target_path);
EXPECT_EQ(DestinationFile(browser(), file), row1.current_path);
EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED, row1.danger_type);
EXPECT_LE(start, row1.start_time);
EXPECT_EQ(content::DownloadItem::COMPLETE, row1.state);
EXPECT_FALSE(row1.opened);
// Not checking file size--not relevant to the point of the test, and
// the file size is actually different on Windows and other platforms,
// because for source control simplicity it's actually a text file, and
// there are CRLF transformations for those files.
}
IN_PROC_BROWSER_TEST_F(DownloadTest, PRE_DownloadTest_History) {
// Download a file and wait for it to be stored.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
HistoryObserver observer(browser()->profile());
DownloadAndWait(browser(), download_url);
observer.WaitForStored();
HistoryServiceFactory::GetForProfile(
browser()->profile(), Profile::IMPLICIT_ACCESS)->FlushForTest(
base::Bind(&base::MessageLoop::Quit,
base::Unretained(base::MessageLoop::current()->current())));
content::RunMessageLoop();
}
#if defined(OS_CHROMEOS)
#define MAYBE_DownloadTest_History DISABLED_DownloadTest_History
#else
#define MAYBE_DownloadTest_History DownloadTest_History
#endif
IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_DownloadTest_History) {
// This starts up right after PRE_DownloadTest_History and shares the same
// profile directory.
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
std::vector<DownloadItem*> downloads;
content::DownloadManager* manager = DownloadManagerForBrowser(browser());
// Wait for the history to be loaded with a single DownloadItem. Check that
// it's the file that was downloaded in PRE_DownloadTest_History.
CreatedObserver created_observer(manager);
created_observer.Wait();
manager->GetAllDownloads(&downloads);
ASSERT_EQ(1UL, downloads.size());
DownloadItem* item = downloads[0];
EXPECT_EQ(file.value(), item->GetFullPath().BaseName().value());
EXPECT_EQ(file.value(), item->GetTargetFilePath().BaseName().value());
EXPECT_EQ(download_url, item->GetURL());
// The following are set by download-test1.lib.mock-http-headers.
std::string etag = item->GetETag();
base::TrimWhitespaceASCII(etag, base::TRIM_ALL, &etag);
EXPECT_EQ("abracadabra", etag);
std::string last_modified = item->GetLastModifiedTime();
base::TrimWhitespaceASCII(last_modified, base::TRIM_ALL, &last_modified);
EXPECT_EQ("Mon, 13 Nov 2006 20:31:09 GMT", last_modified);
// Downloads that were restored from history shouldn't cause the download
// shelf to be displayed.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// Test for crbug.com/14505. This tests that chrome:// urls are still functional
// after download of a file while viewing another chrome://.
IN_PROC_BROWSER_TEST_F(DownloadTest, ChromeURLAfterDownload) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
GURL flags_url(chrome::kChromeUIFlagsURL);
GURL extensions_url(chrome::kChromeUIExtensionsFrameURL);
ui_test_utils::NavigateToURL(browser(), flags_url);
DownloadAndWait(browser(), download_url);
ui_test_utils::NavigateToURL(browser(), extensions_url);
WebContents* contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(contents);
bool webui_responded = false;
EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
contents,
"window.domAutomationController.send(window.webuiResponded);",
&webui_responded));
EXPECT_TRUE(webui_responded);
}
// Test for crbug.com/12745. This tests that if a download is initiated from
// a chrome:// page that has registered and onunload handler, the browser
// will be able to close.
IN_PROC_BROWSER_TEST_F(DownloadTest, BrowserCloseAfterDownload) {
GURL downloads_url(chrome::kChromeUIFlagsURL);
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
ui_test_utils::NavigateToURL(browser(), downloads_url);
WebContents* contents = browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(contents);
bool result = false;
EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
contents,
"window.onunload = function() { var do_nothing = 0; }; "
"window.domAutomationController.send(true);",
&result));
EXPECT_TRUE(result);
DownloadAndWait(browser(), download_url);
content::WindowedNotificationObserver signal(
chrome::NOTIFICATION_BROWSER_CLOSED,
content::Source<Browser>(browser()));
chrome::CloseWindow(browser());
signal.Wait();
}
// Test to make sure the 'download' attribute in anchor tag is respected.
IN_PROC_BROWSER_TEST_F(DownloadTest, AnchorDownloadTag) {
base::FilePath file(FILE_PATH_LITERAL("download-anchor-attrib.html"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// Create a download, wait until it's complete, and confirm
// we're in the expected state.
scoped_ptr<content::DownloadTestObserver> observer(
CreateWaiter(browser(), 1));
ui_test_utils::NavigateToURL(browser(), url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
// Confirm the downloaded data exists.
base::FilePath downloaded_file = GetDownloadDirectory(browser());
downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
EXPECT_TRUE(base::PathExists(downloaded_file));
}
// Test to make sure auto-open works.
IN_PROC_BROWSER_TEST_F(DownloadTest, AutoOpen) {
base::FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
ASSERT_TRUE(
GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
DownloadAndWait(browser(), url);
// Find the download and confirm it was opened.
std::vector<DownloadItem*> downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->GetState());
// Unfortunately, this will block forever, causing a timeout, if
// the download is never opened.
content::DownloadUpdatedObserver(
downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
EXPECT_TRUE(downloads[0]->GetOpened()); // Confirm it anyway.
// As long as we're here, confirmed everything else is good.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
CheckDownload(browser(), file, file);
// Download shelf should close. Download panel stays open on ChromeOS.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// Download an extension. Expect a dangerous download warning.
// Deny the download.
IN_PROC_BROWSER_TEST_F(DownloadTest, CrxDenyInstall) {
FeatureSwitch::ScopedOverride enable_easy_off_store_install(
FeatureSwitch::easy_off_store_install(), true);
GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
ui_test_utils::NavigateToURL(browser(), extension_url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::CANCELLED));
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
// Download shelf should close.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Check that the CRX is not installed.
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
}
// Download an extension. Expect a dangerous download warning.
// Allow the download, deny the install.
IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallDenysPermissions) {
FeatureSwitch::ScopedOverride enable_easy_off_store_install(
FeatureSwitch::easy_off_store_install(), true);
GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
// Install a mock install UI that simulates a user denying permission to
// finish the install.
download_crx_util::SetMockInstallPromptForTesting(
scoped_ptr<ExtensionInstallPrompt>(
new MockAbortExtensionInstallPrompt()));
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
ui_test_utils::NavigateToURL(browser(), extension_url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
// Download shelf should close from auto-open.
content::DownloadManager::DownloadVector downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
content::DownloadUpdatedObserver(
downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Check that the extension was not installed.
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
}
// Download an extension. Expect a dangerous download warning.
// Allow the download, and the install.
IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallAcceptPermissions) {
FeatureSwitch::ScopedOverride enable_easy_off_store_install(
FeatureSwitch::easy_off_store_install(), true);
GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
// Install a mock install UI that simulates a user allowing permission to
// finish the install.
SetAllowMockInstallPrompt();
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
ui_test_utils::NavigateToURL(browser(), extension_url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
// Download shelf should close from auto-open.
content::DownloadManager::DownloadVector downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
content::DownloadUpdatedObserver(
downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Check that the extension was installed.
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
ASSERT_TRUE(extension_service->GetExtensionById(kGoodCrxId, false));
}
// Test installing a CRX that fails integrity checks.
IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInvalid) {
base::FilePath file(FILE_PATH_LITERAL("extensions/bad_signature.crx"));
GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(file));
// Install a mock install UI that simulates a user allowing permission to
// finish the install, and dismisses any error message. We check that the
// install failed below.
SetAllowMockInstallPrompt();
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
ui_test_utils::NavigateToURL(browser(), extension_url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
// Check that the extension was not installed.
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
}
// Install a large (100kb) theme.
IN_PROC_BROWSER_TEST_F(DownloadTest, CrxLargeTheme) {
FeatureSwitch::ScopedOverride enable_easy_off_store_install(
FeatureSwitch::easy_off_store_install(), true);
GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kLargeThemePath));
// Install a mock install UI that simulates a user allowing permission to
// finish the install.
SetAllowMockInstallPrompt();
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
ui_test_utils::NavigateToURL(browser(), extension_url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
// Download shelf should close from auto-open.
content::DownloadManager::DownloadVector downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
content::DownloadUpdatedObserver(
downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
// Check that the extension was installed.
ExtensionService* extension_service = extensions::ExtensionSystem::Get(
browser()->profile())->extension_service();
ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
}
// Tests for download initiation functions.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrl) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
// DownloadUrl always prompts; return acceptance of whatever it prompts.
EnableFileChooser(true);
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(web_contents);
content::DownloadTestObserver* observer(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
scoped_ptr<DownloadUrlParameters> params(
DownloadUrlParameters::FromWebContents(web_contents, url));
params->set_prompt(true);
DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
EXPECT_TRUE(DidShowFileChooser());
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
ASSERT_TRUE(CheckDownload(browser(), file, file));
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrlToPath) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(web_contents);
base::ScopedTempDir other_directory;
ASSERT_TRUE(other_directory.CreateUniqueTempDir());
base::FilePath target_file_full_path
= other_directory.path().Append(file.BaseName());
content::DownloadTestObserver* observer(CreateWaiter(browser(), 1));
scoped_ptr<DownloadUrlParameters> params(
DownloadUrlParameters::FromWebContents(web_contents, url));
params->set_file_path(target_file_full_path);
DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
// Check state.
EXPECT_EQ(1, browser()->tab_strip_model()->count());
ASSERT_TRUE(CheckDownloadFullPaths(browser(),
target_file_full_path,
OriginFile(file)));
// Temporary are treated as auto-opened, and after that open won't be
// visible; wait for auto-open and confirm not visible.
std::vector<DownloadItem*> downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
content::DownloadUpdatedObserver(
downloads[0], base::Bind(&WasAutoOpened)).WaitForEvent();
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaGet) {
// Do initial setup.
ASSERT_TRUE(test_server()->Start());
EnableFileChooser(true);
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
// Navigate to a non-HTML resource. The resource also has
// Cache-Control: no-cache set, which normally requires revalidation
// each time.
GURL url = test_server()->GetURL("files/downloads/image.jpg");
ASSERT_TRUE(url.is_valid());
ui_test_utils::NavigateToURL(browser(), url);
// Stop the test server, and then try to save the page. If cache validation
// is not bypassed then this will fail since the server is no longer
// reachable.
ASSERT_TRUE(test_server()->Stop());
scoped_ptr<content::DownloadTestObserver> waiter(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
chrome::SavePage(browser());
waiter->WaitForFinished();
EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
// Validate that the correct file was downloaded.
GetDownloads(browser(), &download_items);
EXPECT_TRUE(DidShowFileChooser());
ASSERT_EQ(1u, download_items.size());
ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
// Try to download it via a context menu.
scoped_ptr<content::DownloadTestObserver> waiter_context_menu(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
content::ContextMenuParams context_menu_params;
context_menu_params.media_type = blink::WebContextMenuData::MediaTypeImage;
context_menu_params.src_url = url;
context_menu_params.page_url = url;
TestRenderViewContextMenu menu(
browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
context_menu_params);
menu.Init();
menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS, 0);
waiter_context_menu->WaitForFinished();
EXPECT_EQ(
1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(2, DownloadItem::COMPLETE);
// Validate that the correct file was downloaded via the context menu.
download_items.clear();
GetDownloads(browser(), &download_items);
EXPECT_TRUE(DidShowFileChooser());
ASSERT_EQ(2u, download_items.size());
ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
ASSERT_EQ(url, download_items[1]->GetOriginalUrl());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaPost) {
// Do initial setup.
ASSERT_TRUE(test_server()->Start());
EnableFileChooser(true);
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
// Navigate to a form page.
GURL form_url = test_server()->GetURL(
"files/downloads/form_page_to_post.html");
ASSERT_TRUE(form_url.is_valid());
ui_test_utils::NavigateToURL(browser(), form_url);
// Submit the form. This will send a POST reqeuest, and the response is a
// JPEG image. The resource also has Cache-Control: no-cache set,
// which normally requires revalidation each time.
GURL jpeg_url = test_server()->GetURL("files/post/downloads/image.jpg");
ASSERT_TRUE(jpeg_url.is_valid());
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(web_contents != NULL);
content::WindowedNotificationObserver observer(
content::NOTIFICATION_NAV_ENTRY_COMMITTED,
content::Source<content::NavigationController>(
&web_contents->GetController()));
content::RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
ASSERT_TRUE(render_frame_host != NULL);
render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16("SubmitForm()"));
observer.Wait();
EXPECT_EQ(jpeg_url, web_contents->GetURL());
// Stop the test server, and then try to save the page. If cache validation
// is not bypassed then this will fail since the server is no longer
// reachable. This will also fail if it tries to be retrieved via "GET"
// rather than "POST".
ASSERT_TRUE(test_server()->Stop());
scoped_ptr<content::DownloadTestObserver> waiter(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
chrome::SavePage(browser());
waiter->WaitForFinished();
EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
// Validate that the correct file was downloaded.
GetDownloads(browser(), &download_items);
EXPECT_TRUE(DidShowFileChooser());
ASSERT_EQ(1u, download_items.size());
ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
// Try to download it via a context menu.
scoped_ptr<content::DownloadTestObserver> waiter_context_menu(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
content::ContextMenuParams context_menu_params;
context_menu_params.media_type = blink::WebContextMenuData::MediaTypeImage;
context_menu_params.src_url = jpeg_url;
context_menu_params.page_url = jpeg_url;
TestRenderViewContextMenu menu(web_contents->GetMainFrame(),
context_menu_params);
menu.Init();
menu.ExecuteCommand(IDC_CONTENT_CONTEXT_SAVEIMAGEAS, 0);
waiter_context_menu->WaitForFinished();
EXPECT_EQ(
1u, waiter_context_menu->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(2, DownloadItem::COMPLETE);
// Validate that the correct file was downloaded via the context menu.
download_items.clear();
GetDownloads(browser(), &download_items);
EXPECT_TRUE(DidShowFileChooser());
ASSERT_EQ(2u, download_items.size());
ASSERT_EQ(jpeg_url, download_items[0]->GetOriginalUrl());
ASSERT_EQ(jpeg_url, download_items[1]->GetOriginalUrl());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsServer) {
DownloadInfo download_info[] = {
{ // Normal navigated download.
"a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_NONE,
true,
false
},
{ // Normal direct download.
"a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_NONE,
true,
false
},
{ // Direct download with 404 error.
"there_IS_no_spoon.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
true,
false
},
{ // Navigated download with 404 error.
"there_IS_no_spoon.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT,
false,
false
},
{ // Direct download with 400 error.
"zip_file_not_found.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
true,
false
},
{ // Navigated download with 400 error.
"zip_file_not_found.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
false,
false
}
};
DownloadFilesCheckErrors(ARRAYSIZE_UNSAFE(download_info), download_info);
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsFile) {
FileErrorInjectInfo error_info[] = {
{ // Navigated download with injected "Disk full" error in Initialize().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
}
},
{ // Direct download with injected "Disk full" error in Initialize().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
}
},
{ // Navigated download with injected "Disk full" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
}
},
{ // Direct download with injected "Disk full" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
}
},
{ // Navigated download with injected "Failed" error in Initialize().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Direct download with injected "Failed" error in Initialize().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Navigated download with injected "Failed" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Direct download with injected "Failed" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Navigated download with injected "Name too long" error in
// Initialize().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
}
},
{ // Direct download with injected "Name too long" error in Initialize().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG,
}
},
{ // Navigated download with injected "Name too long" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_NAVIGATE,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Direct download with injected "Name too long" error in Write().
{ "a_zip_file.zip",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
0,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
}
},
{ // Direct download with injected "Disk full" error in 2nd Write().
{ "06bESSE21Evolution.ppt",
DOWNLOAD_DIRECT,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
1
},
{
"",
content::TestFileErrorInjector::FILE_OPERATION_WRITE,
1,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
}
}
};
DownloadInsertFilesErrorCheckErrors(ARRAYSIZE_UNSAFE(error_info), error_info);
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorReadonlyFolder) {
DownloadInfo download_info[] = {
{
"a_zip_file.zip",
DOWNLOAD_DIRECT,
// This passes because we switch to the My Documents folder.
content::DOWNLOAD_INTERRUPT_REASON_NONE,
true,
true
},
{
"a_zip_file.zip",
DOWNLOAD_NAVIGATE,
// This passes because we switch to the My Documents folder.
content::DOWNLOAD_INTERRUPT_REASON_NONE,
true,
true
}
};
DownloadFilesToReadonlyFolder(ARRAYSIZE_UNSAFE(download_info), download_info);
}
// Test that we show a dangerous downloads warning for a dangerous file
// downloaded through a blob: URL.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadDangerousBlobData) {
#if defined(OS_WIN)
// On Windows, if SafeBrowsing is enabled, certain file types (.exe, .cab,
// .msi) will be handled by the DownloadProtectionService. However, if the URL
// is non-standard (e.g. blob:) then those files won't be handled by the
// DPS. We should be showing the dangerous download warning for any file
// considered dangerous and isn't handled by the DPS.
const char kFilename[] = "foo.exe";
#else
const char kFilename[] = "foo.swf";
#endif
std::string path("files/downloads/download-dangerous-blob.html?filename=");
path += kFilename;
// Need to use http urls because the blob js doesn't work on file urls for
// security reasons.
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL(path));
content::DownloadTestObserver* observer(DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
ui_test_utils::NavigateToURL(browser(), url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, LoadURLExternallyReferrerPolicy) {
// Do initial setup.
ASSERT_TRUE(test_server()->Start());
EnableFileChooser(true);
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
// Navigate to a page with a referrer policy and a link on it. The link points
// to testserver's /echoheader.
GURL url = test_server()->GetURL("files/downloads/referrer_policy.html");
ASSERT_TRUE(url.is_valid());
ui_test_utils::NavigateToURL(browser(), url);
scoped_ptr<content::DownloadTestObserver> waiter(
new content::DownloadTestObserverTerminal(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
// Click on the link with the alt key pressed. This will download the link
// target.
WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
blink::WebMouseEvent mouse_event;
mouse_event.type = blink::WebInputEvent::MouseDown;
mouse_event.button = blink::WebMouseEvent::ButtonLeft;
mouse_event.x = 15;
mouse_event.y = 15;
mouse_event.clickCount = 1;
mouse_event.modifiers = blink::WebInputEvent::AltKey;
tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
mouse_event.type = blink::WebInputEvent::MouseUp;
tab->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
waiter->WaitForFinished();
EXPECT_EQ(1u, waiter->NumDownloadsSeenInState(DownloadItem::COMPLETE));
CheckDownloadStates(1, DownloadItem::COMPLETE);
// Validate that the correct file was downloaded.
GetDownloads(browser(), &download_items);
ASSERT_EQ(1u, download_items.size());
ASSERT_EQ(test_server()->GetURL("echoheader?Referer"),
download_items[0]->GetOriginalUrl());
// Check that the file contains the expected referrer.
base::FilePath file(download_items[0]->GetTargetFilePath());
std::string expected_contents = test_server()->GetURL(std::string()).spec();
ASSERT_TRUE(VerifyFile(file, expected_contents, expected_contents.length()));
}
IN_PROC_BROWSER_TEST_F(DownloadTest, HiddenDownload) {
base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
DownloadManager* download_manager = DownloadManagerForBrowser(browser());
scoped_ptr<content::DownloadTestObserver> observer(
new content::DownloadTestObserverTerminal(
download_manager,
1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
// Download and set IsHiddenDownload to true.
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
scoped_ptr<DownloadUrlParameters> params(
DownloadUrlParameters::FromWebContents(web_contents, url));
params->set_callback(base::Bind(&SetHiddenDownloadCallback));
download_manager->DownloadUrl(params.Pass());
observer->WaitForFinished();
// Verify that download shelf is not shown.
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
// Verify the multiple downloads infobar.
IN_PROC_BROWSER_TEST_F(DownloadTest, TestMultipleDownloadsInfobar) {
#if defined(OS_WIN) && defined(USE_ASH)
// Disable this test in Metro+Ash for now (http://crbug.com/262796).
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
return;
#endif
ASSERT_TRUE(test_server()->Start());
// Create a downloads observer.
scoped_ptr<content::DownloadTestObserver> downloads_observer(
CreateWaiter(browser(), 2));
// Create an infobar observer.
content::WindowedNotificationObserver infobar_added_1(
chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
content::NotificationService::AllSources());
ui_test_utils::NavigateToURL(
browser(),
test_server()->GetURL("files/downloads/download-a_zip_file.html"));
infobar_added_1.Wait();
InfoBarService* infobar_service = InfoBarService::FromWebContents(
browser()->tab_strip_model()->GetActiveWebContents());
// Verify that there is only one infobar.
ASSERT_EQ(1u, infobar_service->infobar_count());
// Get the infobar at index 0.
infobars::InfoBar* infobar = infobar_service->infobar_at(0);
ConfirmInfoBarDelegate* confirm_infobar =
infobar->delegate()->AsConfirmInfoBarDelegate();
ASSERT_TRUE(confirm_infobar != NULL);
// Verify multi download warning infobar message.
EXPECT_EQ(confirm_infobar->GetMessageText(),
l10n_util::GetStringUTF16(IDS_MULTI_DOWNLOAD_WARNING));
// Click on the "Allow" button to allow multiple downloads.
if (confirm_infobar->Accept())
infobar_service->RemoveInfoBar(infobar);
// Verify that there are no more infobars.
EXPECT_EQ(0u, infobar_service->infobar_count());
// Waits for the download to complete.
downloads_observer->WaitForFinished();
EXPECT_EQ(2u, downloads_observer->NumDownloadsSeenInState(
DownloadItem::COMPLETE));
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Renaming) {
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
content::DownloadManager* manager = DownloadManagerForBrowser(browser());
base::FilePath origin_file(OriginFile(base::FilePath(FILE_PATH_LITERAL(
"downloads/a_zip_file.zip"))));
ASSERT_TRUE(base::PathExists(origin_file));
std::string origin_contents;
ASSERT_TRUE(base::ReadFileToString(origin_file, &origin_contents));
// Download the same url several times and expect that all downloaded files
// after the zero-th contain a deduplication counter.
for (int index = 0; index < 5; ++index) {
DownloadAndWait(browser(), url);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
content::DownloadItem* item = manager->GetDownload(
content::DownloadItem::kInvalidId + 1 + index);
ASSERT_TRUE(item);
ASSERT_EQ(DownloadItem::COMPLETE, item->GetState());
base::FilePath target_path(item->GetTargetFilePath());
EXPECT_EQ(std::string("a_zip_file") +
(index == 0 ? std::string(".zip") :
base::StringPrintf(" (%d).zip", index)),
target_path.BaseName().AsUTF8Unsafe());
ASSERT_TRUE(base::PathExists(target_path));
ASSERT_TRUE(VerifyFile(target_path, origin_contents,
origin_contents.size()));
}
}
// Test that the entire download pipeline handles unicode correctly.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_CrazyFilenames) {
const wchar_t* kCrazyFilenames[] = {
L"a_file_name.zip",
L"\u89c6\u9891\u76f4\u64ad\u56fe\u7247.zip", // chinese chars
L"\u0412\u043e \u0424\u043b\u043e\u0440\u0438\u0434\u0435\u043e\u0431\u044a"
L"\u044f\u0432\u043b\u0435\u043d\u0440\u0435\u0436\u0438\u043c \u0427"
L"\u041f \u0438\u0437-\u0437\u0430 \u0443\u0442\u0435\u0447\u043a\u0438 "
L"\u043d\u0435\u0444\u0442\u0438.zip", // russian
L"Desocupa\xe7\xe3o est\xe1vel.zip",
// arabic:
L"\u0638\u2026\u0638\u02c6\u0637\xa7\u0638\u201a\u0637\xb9 \u0638\u201e"
L"\u0638\u201e\u0637\xb2\u0638\u0679\u0637\xa7\u0637\xb1\u0637\xa9.zip",
L"\u05d4\u05e2\u05d3\u05e4\u05d5\u05ea.zip", // hebrew
L"\u092d\u093e\u0930\u0924.zip", // hindi
L"d\xe9stabilis\xe9.zip", // french
// korean
L"\u97d3-\u4e2d \uc815\uc0c1, \ucc9c\uc548\ud568 \uc758\uacac.zip",
L"jiho....tiho...miho.zip",
L"jiho!@#$tiho$%^&-()_+=miho copy.zip", // special chars
L"Wohoo-to hoo+I.zip",
L"Picture 1.zip",
L"This is a very very long english sentence with spaces and , and +.zip",
};
std::vector<DownloadItem*> download_items;
base::FilePath origin(FILE_PATH_LITERAL("origin"));
ASSERT_TRUE(base::CreateDirectory(DestinationFile(browser(), origin)));
for (size_t index = 0; index < arraysize(kCrazyFilenames); ++index) {
base::string16 crazy16;
std::string crazy8;
const wchar_t* crazy_w = kCrazyFilenames[index];
ASSERT_TRUE(base::WideToUTF8(crazy_w, wcslen(crazy_w), &crazy8));
ASSERT_TRUE(base::WideToUTF16(crazy_w, wcslen(crazy_w), &crazy16));
base::FilePath file_path(DestinationFile(browser(), origin.Append(
#if defined(OS_WIN)
crazy16
#elif defined(OS_POSIX)
crazy8
#endif
)));
// Create the file.
EXPECT_EQ(static_cast<int>(crazy8.size()),
base::WriteFile(file_path, crazy8.c_str(), crazy8.size()));
GURL file_url(net::FilePathToFileURL(file_path));
// Download the file and check that the filename is correct.
DownloadAndWait(browser(), file_url);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
GetDownloads(browser(), &download_items);
ASSERT_EQ(1UL, download_items.size());
base::FilePath downloaded(download_items[0]->GetTargetFilePath());
download_items[0]->Remove();
download_items.clear();
ASSERT_TRUE(CheckDownloadFullPaths(
browser(),
downloaded,
file_path));
}
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Remove) {
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL("files/downloads/a_zip_file.zip"));
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_TRUE(download_items.empty());
// Download a file.
DownloadAndWaitWithDisposition(browser(),
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
GetDownloads(browser(), &download_items);
ASSERT_EQ(1UL, download_items.size());
base::FilePath downloaded(download_items[0]->GetTargetFilePath());
// Remove the DownloadItem but not the file, then check that the file still
// exists.
download_items[0]->Remove();
download_items.clear();
GetDownloads(browser(), &download_items);
ASSERT_EQ(0UL, download_items.size());
ASSERT_TRUE(CheckDownloadFullPaths(
browser(), downloaded, OriginFile(base::FilePath(
FILE_PATH_LITERAL("downloads/a_zip_file.zip")))));
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_PauseResumeCancel) {
DownloadItem* download_item = CreateSlowTestDownload();
ASSERT_TRUE(download_item);
ASSERT_FALSE(download_item->GetTargetFilePath().empty());
EXPECT_FALSE(download_item->IsPaused());
EXPECT_NE(DownloadItem::CANCELLED, download_item->GetState());
download_item->Pause();
EXPECT_TRUE(download_item->IsPaused());
download_item->Resume();
EXPECT_FALSE(download_item->IsPaused());
EXPECT_NE(DownloadItem::CANCELLED, download_item->GetState());
download_item->Cancel(true);
EXPECT_EQ(DownloadItem::CANCELLED, download_item->GetState());
}
// The Mac downloaded files quarantine feature is implemented by the
// Contents/Info.plist file in cocoa apps. browser_tests cannot test
// quarantining files on Mac because it is not a cocoa app.
// TODO(benjhayden) test the equivalents on other platforms.
#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
// Timing out on ARM linux: http://crbug.com/238459
#define MAYBE_DownloadTest_PercentComplete DISABLED_DownloadTest_PercentComplete
#elif defined(OS_MACOSX)
// Disable on mac: http://crbug.com/238831
#define MAYBE_DownloadTest_PercentComplete DISABLED_DownloadTest_PercentComplete
#else
#define MAYBE_DownloadTest_PercentComplete DownloadTest_PercentComplete
#endif
IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_DownloadTest_PercentComplete) {
// Write a huge file.
base::FilePath file_path(DestinationFile(
browser(), base::FilePath(FILE_PATH_LITERAL("DownloadTest_BigZip.zip"))));
base::File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_WRITE);
ASSERT_TRUE(file.IsValid());
int64 size = 1 << 25;
EXPECT_EQ(1, file.Write(size, "a", 1));
file.Close();
#if defined(OS_POSIX)
// Make it readable by chronos on chromeos
base::SetPosixFilePermissions(file_path, 0755);
#endif
// Ensure that we have enough disk space.
int64 free_space = base::SysInfo::AmountOfFreeDiskSpace(
GetDownloadDirectory(browser()));
ASSERT_LE(size, free_space) << "Not enough disk space to download. Got "
<< free_space;
GURL file_url(net::FilePathToFileURL(file_path));
scoped_ptr<content::DownloadTestObserver> progress_waiter(
CreateInProgressWaiter(browser(), 1));
// Start downloading a file, wait for it to be created.
ui_test_utils::NavigateToURLWithDisposition(
browser(), file_url, CURRENT_TAB, ui_test_utils::BROWSER_TEST_NONE);
progress_waiter->WaitForFinished();
EXPECT_EQ(1u, progress_waiter->NumDownloadsSeenInState(
DownloadItem::IN_PROGRESS));
std::vector<DownloadItem*> download_items;
GetDownloads(browser(), &download_items);
ASSERT_EQ(1UL, download_items.size());
// Wait for the download to complete, checking along the way that the
// PercentComplete() never regresses.
PercentWaiter waiter(download_items[0]);
EXPECT_TRUE(waiter.WaitForFinished());
EXPECT_EQ(DownloadItem::COMPLETE, download_items[0]->GetState());
ASSERT_EQ(100, download_items[0]->PercentComplete());
EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
// Check that the file downloaded correctly.
ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
int64 downloaded_size = 0;
ASSERT_TRUE(base::GetFileSize(
download_items[0]->GetTargetFilePath(), &downloaded_size));
ASSERT_EQ(size + 1, downloaded_size);
ASSERT_TRUE(base::DieFileDie(file_path, false));
ASSERT_TRUE(base::DieFileDie(download_items[0]->GetTargetFilePath(), false));
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_DenyDanger) {
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL("files/downloads/dangerous/dangerous.crx"));
scoped_ptr<content::DownloadTestObserver> observer(
DangerousDownloadWaiter(
browser(), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
ui_test_utils::NavigateToURL(browser(), url);
observer->WaitForFinished();
EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::CANCELLED));
EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
}
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadPrefs_SaveFilePath) {
DownloadPrefs* on_prefs = DownloadServiceFactory::GetForBrowserContext(
browser()->profile())->GetDownloadManagerDelegate()->download_prefs();
DownloadPrefs* off_prefs = DownloadServiceFactory::GetForBrowserContext(
browser()->profile()->GetOffTheRecordProfile())
->GetDownloadManagerDelegate()->download_prefs();
base::FilePath dir(on_prefs->SaveFilePath());
EXPECT_EQ(dir.value(), off_prefs->SaveFilePath().value());
on_prefs->SetSaveFilePath(dir.AppendASCII("on"));
EXPECT_EQ(dir.AppendASCII("on").value(), on_prefs->SaveFilePath().value());
EXPECT_EQ(dir.AppendASCII("on").value(), off_prefs->SaveFilePath().value());
on_prefs->SetSaveFilePath(dir);
EXPECT_EQ(dir.value(), on_prefs->SaveFilePath().value());
EXPECT_EQ(dir.value(), off_prefs->SaveFilePath().value());
off_prefs->SetSaveFilePath(dir.AppendASCII("off"));
EXPECT_EQ(dir.value(), on_prefs->SaveFilePath().value());
EXPECT_EQ(dir.AppendASCII("off").value(), off_prefs->SaveFilePath().value());
on_prefs->SetSaveFilePath(dir.AppendASCII("on"));
EXPECT_EQ(dir.AppendASCII("on").value(), on_prefs->SaveFilePath().value());
EXPECT_EQ(dir.AppendASCII("off").value(), off_prefs->SaveFilePath().value());
}
// A download that is interrupted due to a file error should be able to be
// resumed.
IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_NoPrompt) {
CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kEnableDownloadResumption);
scoped_refptr<content::TestFileErrorInjector> error_injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
scoped_ptr<content::DownloadTestObserver> completion_observer(
CreateWaiter(browser(), 1));
EnableFileChooser(true);
DownloadItem* download = StartMockDownloadAndInjectError(
error_injector,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
ASSERT_TRUE(download);
download->Resume();
completion_observer->WaitForFinished();
EXPECT_EQ(
1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
EXPECT_FALSE(DidShowFileChooser());
}
// A download that's interrupted due to a reason that indicates that the target
// path is invalid or unusable should cause a prompt to be displayed on
// resumption.
IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_WithPrompt) {
CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kEnableDownloadResumption);
scoped_refptr<content::TestFileErrorInjector> error_injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
scoped_ptr<content::DownloadTestObserver> completion_observer(
CreateWaiter(browser(), 1));
EnableFileChooser(true);
DownloadItem* download = StartMockDownloadAndInjectError(
error_injector,
content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE);
ASSERT_TRUE(download);
download->Resume();
completion_observer->WaitForFinished();
EXPECT_EQ(
1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
EXPECT_TRUE(DidShowFileChooser());
}
// The user shouldn't be prompted on a resumed download unless a prompt is
// necessary due to the interrupt reason.
IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_WithPromptAlways) {
CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kEnableDownloadResumption);
browser()->profile()->GetPrefs()->SetBoolean(
prefs::kPromptForDownload, true);
scoped_refptr<content::TestFileErrorInjector> error_injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
scoped_ptr<content::DownloadTestObserver> completion_observer(
CreateWaiter(browser(), 1));
EnableFileChooser(true);
DownloadItem* download = StartMockDownloadAndInjectError(
error_injector,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
ASSERT_TRUE(download);
// Prompts the user initially because of the kPromptForDownload preference.
EXPECT_TRUE(DidShowFileChooser());
download->Resume();
completion_observer->WaitForFinished();
EXPECT_EQ(
1u, completion_observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
// Shouldn't prompt for resumption.
EXPECT_FALSE(DidShowFileChooser());
}
// A download that is interrupted due to a transient error should be resumed
// automatically.
IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_Automatic) {
CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kEnableDownloadResumption);
scoped_refptr<content::TestFileErrorInjector> error_injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
DownloadItem* download = StartMockDownloadAndInjectError(
error_injector,
content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR);
ASSERT_TRUE(download);
// The number of times this the download is resumed automatically is defined
// in DownloadItemImpl::kMaxAutoResumeAttempts. The number of DownloadFiles
// created should be that number + 1 (for the original download request). We
// only care that it is greater than 1.
EXPECT_GT(1u, error_injector->TotalFileCount());
}
// An interrupting download should be resumable multiple times.
IN_PROC_BROWSER_TEST_F(DownloadTest, Resumption_MultipleAttempts) {
CommandLine::ForCurrentProcess()->AppendSwitch(
switches::kEnableDownloadResumption);
scoped_refptr<content::TestFileErrorInjector> error_injector(
content::TestFileErrorInjector::Create(
DownloadManagerForBrowser(browser())));
scoped_ptr<DownloadTestObserverNotInProgress> completion_observer(
new DownloadTestObserverNotInProgress(
DownloadManagerForBrowser(browser()), 1));
// Wait for two transitions to a resumable state
scoped_ptr<content::DownloadTestObserver> resumable_observer(
new DownloadTestObserverResumable(
DownloadManagerForBrowser(browser()), 2));
EnableFileChooser(true);
DownloadItem* download = StartMockDownloadAndInjectError(
error_injector,
content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
ASSERT_TRUE(download);
content::TestFileErrorInjector::FileErrorInfo error_info;
error_info.url = download->GetOriginalUrl().spec();
error_info.code = content::TestFileErrorInjector::FILE_OPERATION_WRITE;
error_info.operation_instance = 0;
error_info.error = content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED;
error_injector->AddError(error_info);
error_injector->InjectErrors();
// Resuming should cause the download to be interrupted again due to the
// errors we are injecting.
download->Resume();
resumable_observer->WaitForFinished();
ASSERT_EQ(DownloadItem::INTERRUPTED, download->GetState());
ASSERT_EQ(content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED,
download->GetLastReason());
error_injector->ClearErrors();
error_injector->InjectErrors();
// No errors this time. The download should complete successfully.
EXPECT_FALSE(completion_observer->IsFinished());
completion_observer->StartObserving();
download->Resume();
completion_observer->WaitForFinished();
EXPECT_EQ(DownloadItem::COMPLETE, download->GetState());
EXPECT_FALSE(DidShowFileChooser());
}
// The file empty.bin is served with a MIME type of application/octet-stream.
// The content body is empty. Make sure this case is handled properly and we
// don't regress on http://crbug.com/320394.
IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_GZipWithNoContent) {
ASSERT_TRUE(test_server()->Start());
GURL url(test_server()->GetURL("files/downloads/empty.bin"));
// Downloading the same URL twice causes the second request to be served from
// cached (with a high probability). This test verifies that that doesn't
// happen regardless of whether the request is served via the cache or from
// the network.
DownloadAndWait(browser(), url);
DownloadAndWait(browser(), url);
}
#if defined(FULL_SAFE_BROWSING)
IN_PROC_BROWSER_TEST_F(DownloadTest, FeedbackService) {
// Make a dangerous file.
base::FilePath file(FILE_PATH_LITERAL("downloads/dangerous/dangerous.swf"));
GURL download_url(content::URLRequestMockHTTPJob::GetMockUrl(file));
scoped_ptr<content::DownloadTestObserverInterrupted> observer(
new content::DownloadTestObserverInterrupted(
DownloadManagerForBrowser(browser()), 1,
content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
ui_test_utils::NavigateToURLWithDisposition(
browser(),
GURL(download_url),
NEW_BACKGROUND_TAB,
ui_test_utils::BROWSER_TEST_NONE);
observer->WaitForFinished();
// Get the download from the DownloadManager.
std::vector<DownloadItem*> downloads;
DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
ASSERT_EQ(1u, downloads.size());
EXPECT_TRUE(downloads[0]->IsDangerous());
// Save fake pings for the download.
safe_browsing::ClientDownloadReport fake_metadata;
fake_metadata.mutable_download_request()->set_url("http://test");
fake_metadata.mutable_download_request()->set_length(1);
fake_metadata.mutable_download_request()->mutable_digests()->set_sha1("hi");
fake_metadata.mutable_download_response()->set_verdict(
safe_browsing::ClientDownloadResponse::UNCOMMON);
std::string ping_request(
fake_metadata.download_request().SerializeAsString());
std::string ping_response(
fake_metadata.download_response().SerializeAsString());
SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
safe_browsing::DownloadProtectionService* download_protection_service =
sb_service->download_protection_service();
download_protection_service->feedback_service()->MaybeStorePingsForDownload(
safe_browsing::DownloadProtectionService::UNCOMMON,
downloads[0],
ping_request,
ping_response);
ASSERT_TRUE(safe_browsing::DownloadFeedbackService::IsEnabledForDownload(
*(downloads[0])));
// Begin feedback and check that the file is "stolen".
download_protection_service->feedback_service()->BeginFeedbackForDownload(
downloads[0]);
std::vector<DownloadItem*> updated_downloads;
GetDownloads(browser(), &updated_downloads);
ASSERT_TRUE(updated_downloads.empty());
}
#endif