| // Copyright 2014 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 "components/javascript_dialogs/app_modal_dialog_manager.h" |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/i18n/rtl.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "build/build_config.h" |
| #include "components/javascript_dialogs/app_modal_dialog_queue.h" |
| #include "components/javascript_dialogs/app_modal_dialog_view.h" |
| #include "components/javascript_dialogs/extensions_client.h" |
| #include "components/strings/grit/components_strings.h" |
| #include "components/url_formatter/elide_url.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/javascript_dialog_type.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/gfx/font_list.h" |
| #include "url/origin.h" |
| |
| namespace javascript_dialogs { |
| |
| namespace { |
| |
| class DefaultExtensionsClient : public ExtensionsClient { |
| public: |
| DefaultExtensionsClient() = default; |
| |
| DefaultExtensionsClient(const DefaultExtensionsClient&) = delete; |
| DefaultExtensionsClient& operator=(const DefaultExtensionsClient&) = delete; |
| |
| ~DefaultExtensionsClient() override = default; |
| |
| private: |
| // ExtensionsClient: |
| void OnDialogOpened(content::WebContents* web_contents) override {} |
| void OnDialogClosed(content::WebContents* web_contents) override {} |
| bool GetExtensionName(content::WebContents* web_contents, |
| const url::Origin& alerting_frame_origin, |
| std::string* name_out) override { |
| return false; |
| } |
| }; |
| |
| bool ShouldDisplaySuppressCheckbox( |
| ChromeJavaScriptDialogExtraData* extra_data) { |
| return extra_data->has_already_shown_a_dialog_; |
| } |
| |
| } // namespace |
| |
| // static |
| AppModalDialogManager* AppModalDialogManager::GetInstance() { |
| return base::Singleton<AppModalDialogManager>::get(); |
| } |
| |
| void AppModalDialogManager::SetNativeDialogFactory( |
| AppModalViewFactory factory) { |
| view_factory_ = std::move(factory); |
| } |
| |
| void AppModalDialogManager::SetExtensionsClient( |
| std::unique_ptr<ExtensionsClient> extensions_client) { |
| extensions_client_ = std::move(extensions_client); |
| } |
| |
| AppModalDialogManager::AppModalDialogManager() |
| : extensions_client_(new DefaultExtensionsClient) {} |
| |
| AppModalDialogManager::~AppModalDialogManager() = default; |
| |
| std::u16string AppModalDialogManager::GetTitle( |
| content::WebContents* web_contents, |
| const url::Origin& alerting_frame_origin) { |
| // For extensions, show the extension name, but only if the origin of |
| // the alert matches the top-level WebContents. |
| std::string name; |
| if (extensions_client_->GetExtensionName(web_contents, alerting_frame_origin, |
| &name)) |
| return base::UTF8ToUTF16(name); |
| |
| // Otherwise, return the formatted URL. |
| return GetTitleImpl(web_contents->GetMainFrame()->GetLastCommittedOrigin(), |
| alerting_frame_origin); |
| } |
| |
| namespace { |
| |
| // If an origin is opaque but has a precursor, then returns the precursor |
| // origin. If the origin is not opaque, returns it unchanged. Unwrapping origins |
| // allows the dialog code to provide the user with a clearer picture of which |
| // page is actually showing the dialog. |
| url::Origin UnwrapOriginIfOpaque(const url::Origin& origin) { |
| if (!origin.opaque()) |
| return origin; |
| |
| const url::SchemeHostPort& precursor = |
| origin.GetTupleOrPrecursorTupleIfOpaque(); |
| if (!precursor.IsValid()) |
| return origin; |
| |
| return url::Origin::CreateFromNormalizedTuple( |
| precursor.scheme(), precursor.host(), precursor.port()); |
| } |
| |
| } // namespace |
| |
| // static |
| std::u16string AppModalDialogManager::GetTitleImpl( |
| const url::Origin& main_frame_origin, |
| const url::Origin& alerting_frame_origin) { |
| // Note that `Origin::Create()` handles unwrapping of `blob:` and |
| // `filesystem:` schemed URLs, so no special handling is needed for that. |
| // However, origins can be opaque but have precursors that are origins that a |
| // user would be able to make sense of, so do unwrapping for that. |
| const url::Origin unwrapped_main_frame_origin = |
| UnwrapOriginIfOpaque(main_frame_origin); |
| const url::Origin unwrapped_alerting_frame_origin = |
| UnwrapOriginIfOpaque(alerting_frame_origin); |
| |
| bool is_same_origin_as_main_frame = |
| unwrapped_alerting_frame_origin.IsSameOriginWith( |
| unwrapped_main_frame_origin); |
| if (unwrapped_alerting_frame_origin.GetURL().IsStandard() && |
| !unwrapped_alerting_frame_origin.GetURL().SchemeIsFile()) { |
| std::u16string origin_string = |
| url_formatter::FormatOriginForSecurityDisplay( |
| unwrapped_alerting_frame_origin, |
| url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS); |
| return l10n_util::GetStringFUTF16( |
| is_same_origin_as_main_frame ? IDS_JAVASCRIPT_MESSAGEBOX_TITLE |
| : IDS_JAVASCRIPT_MESSAGEBOX_TITLE_IFRAME, |
| base::i18n::GetDisplayStringInLTRDirectionality(origin_string)); |
| } |
| return l10n_util::GetStringUTF16( |
| is_same_origin_as_main_frame |
| ? IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL |
| : IDS_JAVASCRIPT_MESSAGEBOX_TITLE_NONSTANDARD_URL_IFRAME); |
| } |
| |
| void AppModalDialogManager::RunJavaScriptDialog( |
| content::WebContents* web_contents, |
| content::RenderFrameHost* render_frame_host, |
| content::JavaScriptDialogType dialog_type, |
| const std::u16string& message_text, |
| const std::u16string& default_prompt_text, |
| DialogClosedCallback callback, |
| bool* did_suppress_message) { |
| *did_suppress_message = false; |
| |
| ChromeJavaScriptDialogExtraData* extra_data = |
| &javascript_dialog_extra_data_[web_contents]; |
| |
| if (extra_data->suppress_javascript_messages_) { |
| *did_suppress_message = true; |
| return; |
| } |
| |
| std::u16string dialog_title = |
| GetTitle(web_contents, render_frame_host->GetLastCommittedOrigin()); |
| |
| extensions_client_->OnDialogOpened(web_contents); |
| |
| AppModalDialogQueue::GetInstance()->AddDialog(new AppModalDialogController( |
| web_contents, &javascript_dialog_extra_data_, dialog_title, dialog_type, |
| message_text, default_prompt_text, |
| ShouldDisplaySuppressCheckbox(extra_data), |
| false, // is_before_unload_dialog |
| false, // is_reload |
| base::BindOnce(&AppModalDialogManager::OnDialogClosed, |
| base::Unretained(this), web_contents, |
| std::move(callback)))); |
| } |
| |
| void AppModalDialogManager::RunBeforeUnloadDialog( |
| content::WebContents* web_contents, |
| content::RenderFrameHost* render_frame_host, |
| bool is_reload, |
| DialogClosedCallback callback) { |
| RunBeforeUnloadDialogWithOptions(web_contents, render_frame_host, is_reload, |
| false, std::move(callback)); |
| } |
| |
| void AppModalDialogManager::RunBeforeUnloadDialogWithOptions( |
| content::WebContents* web_contents, |
| content::RenderFrameHost* render_frame_host, |
| bool is_reload, |
| bool is_app, |
| DialogClosedCallback callback) { |
| ChromeJavaScriptDialogExtraData* extra_data = |
| &javascript_dialog_extra_data_[web_contents]; |
| |
| if (extra_data->suppress_javascript_messages_) { |
| // If a site harassed the user enough for them to put it on mute, then it |
| // lost its privilege to deny unloading. |
| std::move(callback).Run(true, std::u16string()); |
| return; |
| } |
| |
| // Build the dialog message. We explicitly do _not_ allow the webpage to |
| // specify the contents of this dialog, as per the current spec |
| // |
| // https://html.spec.whatwg.org/#unloading-documents, step 8: |
| // |
| // "The message shown to the user is not customizable, but instead |
| // determined by the user agent. In particular, the actual value of the |
| // returnValue attribute is ignored." |
| // |
| // This message used to be customizable, but it was frequently abused by |
| // scam websites so the specification was changed. |
| |
| std::u16string title; |
| if (is_app) { |
| title = l10n_util::GetStringUTF16( |
| is_reload ? IDS_BEFORERELOAD_APP_MESSAGEBOX_TITLE |
| : IDS_BEFOREUNLOAD_APP_MESSAGEBOX_TITLE); |
| } else { |
| title = l10n_util::GetStringUTF16(is_reload |
| ? IDS_BEFORERELOAD_MESSAGEBOX_TITLE |
| : IDS_BEFOREUNLOAD_MESSAGEBOX_TITLE); |
| } |
| const std::u16string message = |
| l10n_util::GetStringUTF16(IDS_BEFOREUNLOAD_MESSAGEBOX_MESSAGE); |
| |
| extensions_client_->OnDialogOpened(web_contents); |
| |
| AppModalDialogQueue::GetInstance()->AddDialog(new AppModalDialogController( |
| web_contents, &javascript_dialog_extra_data_, title, |
| content::JAVASCRIPT_DIALOG_TYPE_CONFIRM, message, |
| std::u16string(), // default_prompt_text |
| ShouldDisplaySuppressCheckbox(extra_data), |
| true, // is_before_unload_dialog |
| is_reload, |
| base::BindOnce(&AppModalDialogManager::OnDialogClosed, |
| base::Unretained(this), web_contents, |
| std::move(callback)))); |
| } |
| |
| bool AppModalDialogManager::HandleJavaScriptDialog( |
| content::WebContents* web_contents, |
| bool accept, |
| const std::u16string* prompt_override) { |
| AppModalDialogQueue* dialog_queue = AppModalDialogQueue::GetInstance(); |
| if (!dialog_queue->HasActiveDialog() || |
| dialog_queue->active_dialog()->web_contents() != web_contents) { |
| return false; |
| } |
| |
| AppModalDialogController* dialog = |
| static_cast<AppModalDialogController*>(dialog_queue->active_dialog()); |
| |
| if (dialog->javascript_dialog_type() == |
| content::JavaScriptDialogType::JAVASCRIPT_DIALOG_TYPE_ALERT) { |
| // Alert dialogs only have one button: OK. Any "handling" of this dialog has |
| // to be a click on the OK button. |
| accept = true; |
| } |
| |
| if (accept) { |
| if (prompt_override) |
| dialog->SetOverridePromptText(*prompt_override); |
| dialog->view()->AcceptAppModalDialog(); |
| } else { |
| dialog->view()->CancelAppModalDialog(); |
| } |
| return true; |
| } |
| |
| void AppModalDialogManager::CancelDialogs(content::WebContents* web_contents, |
| bool reset_state) { |
| AppModalDialogQueue* queue = AppModalDialogQueue::GetInstance(); |
| for (auto* dialog : *queue) { |
| if (dialog->web_contents() == web_contents) |
| dialog->Invalidate(); |
| } |
| AppModalDialogController* active_dialog = queue->active_dialog(); |
| if (active_dialog && active_dialog->web_contents() == web_contents) |
| active_dialog->Invalidate(); |
| |
| if (reset_state) |
| javascript_dialog_extra_data_.erase(web_contents); |
| } |
| |
| void AppModalDialogManager::OnDialogClosed(content::WebContents* web_contents, |
| DialogClosedCallback callback, |
| bool success, |
| const std::u16string& user_input) { |
| // If an extension opened this dialog then the extension may shut down its |
| // lazy background page after the dialog closes. (Dialogs are closed before |
| // their WebContents is destroyed so |web_contents| is still valid here.) |
| extensions_client_->OnDialogClosed(web_contents); |
| std::move(callback).Run(success, user_input); |
| } |
| |
| } // namespace javascript_dialogs |