blob: 7eb0db69c156ae7c400fbb125a1ad2f77b8b4fcd [file] [log] [blame] [edit]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/download/save_package_file_picker.h"
#include <stddef.h>
#include <memory>
#include "base/command_line.h"
#include "base/functional/bind.h"
#include "base/i18n/file_util_icu.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "chrome/browser/download/chrome_download_manager_delegate.h"
#include "chrome/browser/download/download_prefs.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/chrome_select_file_policy.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/grit/generated_resources.h"
#include "components/prefs/pref_member.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/save_page_type.h"
#include "content/public/browser/web_contents.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/shell_dialogs/selected_file_info.h"
using content::RenderProcessHost;
using content::SavePageType;
using content::WebContents;
namespace {
// If false, we don't prompt the user as to where to save the file. This
// exists only for testing.
bool g_should_prompt_for_filename = true;
void OnSavePackageDownloadCreated(download::DownloadItem* download) {
ChromeDownloadManagerDelegate::DisableSafeBrowsing(download);
}
// Adds "Webpage, HTML Only" type to FileTypeInfo.
void AddHtmlOnlyFileTypeInfo(
ui::SelectFileDialog::FileTypeInfo* file_type_info,
const base::FilePath::StringType& extra_extension) {
file_type_info->extension_description_overrides.push_back(
l10n_util::GetStringUTF16(IDS_SAVE_PAGE_DESC_HTML_ONLY));
std::vector<base::FilePath::StringType> extensions;
extensions.push_back(FILE_PATH_LITERAL("html"));
extensions.push_back(FILE_PATH_LITERAL("htm"));
if (!extra_extension.empty())
extensions.push_back(extra_extension);
file_type_info->extensions.emplace_back(std::move(extensions));
}
// Adds "Webpage, Single File" type to FileTypeInfo.
void AddSingleFileFileTypeInfo(
ui::SelectFileDialog::FileTypeInfo* file_type_info) {
file_type_info->extension_description_overrides.push_back(
l10n_util::GetStringUTF16(IDS_SAVE_PAGE_DESC_SINGLE_FILE));
file_type_info->extensions.emplace_back(
std::initializer_list<base::FilePath::StringType>{
FILE_PATH_LITERAL("mhtml")});
}
// Chrome OS intentionally does not support "Webpage, Complete" type.
// See https://crbug.com/40951429
#if !BUILDFLAG(IS_CHROMEOS)
// Adds "Webpage, Complete" type to FileTypeInfo.
void AddCompleteFileTypeInfo(
ui::SelectFileDialog::FileTypeInfo* file_type_info,
const base::FilePath::StringType& extra_extension) {
file_type_info->extension_description_overrides.push_back(
l10n_util::GetStringUTF16(IDS_SAVE_PAGE_DESC_COMPLETE));
std::vector<base::FilePath::StringType> extensions;
extensions.push_back(FILE_PATH_LITERAL("htm"));
extensions.push_back(FILE_PATH_LITERAL("html"));
if (!extra_extension.empty())
extensions.push_back(extra_extension);
file_type_info->extensions.push_back(extensions);
}
#endif // BUILDFLAG(IS_CHROMEOS)
// Checks whether this is a blocked page (e.g., when a child user is accessing
// a mature site).
// Recall that the blocked page is an interstitial. In the past, old
// (non-committed) interstitials couldn't be easily identified, while the
// committed ones can only be matched by page title. To prevent future bugs due
// to changing the page title, we make a conservative choice here and only
// check for PAGE_TYPE_ERROR. The result is that we may include a few other
// error pages (failed DNS lookups, SSL errors, etc), which shouldn't affect
// functionality.
bool IsErrorPage(content::WebContents* web_contents) {
if (web_contents->GetController().GetActiveEntry() == nullptr)
return false;
return web_contents->GetController().GetLastCommittedEntry()->GetPageType() ==
content::PAGE_TYPE_ERROR;
}
} // anonymous namespace
// TODO(crbug.com/41439108): REMOVE DIRTY HACK
// To prevent access to blocked websites, we are temporarily disabling the
// HTML-only download of error pages for child users only.
// Note that MHTML is still available, so the save functionality is preserved.
bool SavePackageFilePicker::ShouldSaveAsOnlyHTML(
content::WebContents* web_contents) const {
Profile* profile =
Profile::FromBrowserContext(web_contents->GetBrowserContext());
return !profile->IsChild() || !IsErrorPage(web_contents);
}
bool SavePackageFilePicker::ShouldSaveAsMHTMLByDefault() const {
#if !BUILDFLAG(IS_CHROMEOS)
if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kSavePageAsMHTML))
return false;
#endif
return can_save_as_complete_;
}
SavePackageFilePicker::SavePackageFilePicker(
content::WebContents* web_contents,
const base::FilePath& suggested_path,
const base::FilePath::StringType& default_extension,
bool can_save_as_complete,
DownloadPrefs* download_prefs,
content::SavePackagePathPickedCallback callback)
: render_process_id_(
web_contents->GetPrimaryMainFrame()->GetProcess()->GetDeprecatedID()),
can_save_as_complete_(can_save_as_complete),
download_prefs_(download_prefs),
callback_(std::move(callback)) {
base::FilePath suggested_path_copy = suggested_path;
base::FilePath::StringType default_extension_copy = default_extension;
size_t file_type_index = 0;
ui::SelectFileDialog::FileTypeInfo file_type_info;
file_type_info.allowed_paths =
ui::SelectFileDialog::FileTypeInfo::NATIVE_PATH;
if (can_save_as_complete_) {
// The option index is not zero-based. Put a dummy entry.
save_types_.push_back(content::SAVE_PAGE_TYPE_UNKNOWN);
base::FilePath::StringType extra_extension;
if (!ShouldSaveAsMHTMLByDefault() &&
!suggested_path_copy.FinalExtension().empty() &&
!suggested_path_copy.MatchesExtension(FILE_PATH_LITERAL(".htm")) &&
!suggested_path_copy.MatchesExtension(FILE_PATH_LITERAL(".html"))) {
extra_extension = suggested_path_copy.FinalExtension().substr(1);
}
if (ShouldSaveAsOnlyHTML(web_contents)) {
AddHtmlOnlyFileTypeInfo(&file_type_info, extra_extension);
save_types_.push_back(content::SAVE_PAGE_TYPE_AS_ONLY_HTML);
}
AddSingleFileFileTypeInfo(&file_type_info);
save_types_.push_back(content::SAVE_PAGE_TYPE_AS_MHTML);
#if !BUILDFLAG(IS_CHROMEOS)
AddCompleteFileTypeInfo(&file_type_info, extra_extension);
save_types_.push_back(content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML);
#endif // BUILDFLAG(IS_CHROMEOS)
file_type_info.include_all_files = false;
const content::SavePageType preferred_save_type =
ShouldSaveAsMHTMLByDefault() ? content::SAVE_PAGE_TYPE_AS_MHTML
: static_cast<content::SavePageType>(
download_prefs_->save_file_type());
// Select the item saved in the pref.
for (size_t i = 0; i < save_types_.size(); ++i) {
if (save_types_[i] == preferred_save_type) {
file_type_index = i;
break;
}
}
// If the item saved in the pref was not found, use the last item.
if (!file_type_index) {
file_type_index = save_types_.size() - 1;
}
} else {
// The contents can not be saved as complete-HTML, so do not show the file
// filters.
file_type_info.extensions.resize(1);
file_type_info.extensions[0].push_back(
suggested_path_copy.FinalExtension());
if (!file_type_info.extensions[0][0].empty()) {
// Drop the .
file_type_info.extensions[0][0].erase(0, 1);
}
file_type_info.include_all_files = true;
file_type_index = 1;
}
if (file_type_index < save_types_.size() &&
save_types_[file_type_index] == content::SAVE_PAGE_TYPE_AS_MHTML) {
default_extension_copy = FILE_PATH_LITERAL("mhtml");
suggested_path_copy =
suggested_path_copy.ReplaceExtension(default_extension_copy);
}
if (g_should_prompt_for_filename) {
select_file_dialog_ = ui::SelectFileDialog::Create(
this, std::make_unique<ChromeSelectFilePolicy>(web_contents));
select_file_dialog_->SelectFile(
ui::SelectFileDialog::SELECT_SAVEAS_FILE, std::u16string(),
suggested_path_copy, &file_type_info, file_type_index,
default_extension_copy,
platform_util::GetTopLevel(web_contents->GetNativeView()),
/*caller=*/
web_contents
? &web_contents->GetPrimaryMainFrame()->GetLastCommittedURL()
: nullptr);
return;
}
// If |g_should_prompt_for_filename| is unset or |select_file_dialog_| could
// not be instantiated for some reason, just use 'suggested_path_copy' instead
// of opening the dialog prompt. Go through FileSelected() for consistency.
FileSelected(ui::SelectedFileInfo(suggested_path_copy), file_type_index);
}
SavePackageFilePicker::~SavePackageFilePicker() {
if (select_file_dialog_) {
select_file_dialog_->ListenerDestroyed();
}
}
void SavePackageFilePicker::SetShouldPromptUser(bool should_prompt) {
g_should_prompt_for_filename = should_prompt;
}
void SavePackageFilePicker::FileSelected(const ui::SelectedFileInfo& file,
int index) {
std::unique_ptr<SavePackageFilePicker> delete_this(this);
RenderProcessHost* process = RenderProcessHost::FromID(render_process_id_);
if (!process)
return;
SavePageType save_type = content::SAVE_PAGE_TYPE_UNKNOWN;
if (can_save_as_complete_) {
DCHECK_LT(index, static_cast<int>(save_types_.size()));
save_type = save_types_[index];
if (select_file_dialog_ &&
select_file_dialog_->HasMultipleFileTypeChoices()) {
download_prefs_->SetSaveFileType(save_type);
}
} else {
// Use "HTML Only" type as a dummy.
save_type = content::SAVE_PAGE_TYPE_AS_ONLY_HTML;
}
base::FilePath path = file.path();
base::i18n::NormalizeFileNameEncoding(&path);
download_prefs_->SetSaveFilePath(path.DirName());
content::SavePackagePathPickedParams params;
params.file_path = path;
params.save_type = save_type;
#if BUILDFLAG(IS_MAC)
params.file_tags = file.file_tags;
#endif
std::move(callback_).Run(std::move(params),
base::BindOnce(&OnSavePackageDownloadCreated));
}
void SavePackageFilePicker::FileSelectionCanceled() {
delete this;
}