diff options
Diffstat (limited to 'src/core/web_contents_delegate_qt.cpp')
-rw-r--r-- | src/core/web_contents_delegate_qt.cpp | 787 |
1 files changed, 513 insertions, 274 deletions
diff --git a/src/core/web_contents_delegate_qt.cpp b/src/core/web_contents_delegate_qt.cpp index 20de0546f..4df73fb69 100644 --- a/src/core/web_contents_delegate_qt.cpp +++ b/src/core/web_contents_delegate_qt.cpp @@ -1,41 +1,5 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtWebEngine module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only // Copyright 2013 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be @@ -43,43 +7,51 @@ #include "web_contents_delegate_qt.h" -#include "profile_adapter.h" +#include "certificate_error_controller.h" #include "color_chooser_controller.h" #include "color_chooser_qt.h" -#include "favicon_manager.h" +#include "custom_handlers/protocol_handler_registry_factory.h" +#include "custom_handlers/register_protocol_handler_request_controller_impl.h" +#include "desktop_media_controller.h" +#include "desktop_media_controller_p.h" #include "file_picker_controller.h" +#include "find_text_helper.h" +#include "javascript_dialog_manager_qt.h" #include "media_capture_devices_dispatcher.h" -#include "net/network_delegate_qt.h" +#include "native_web_keyboard_event_qt.h" +#include "profile_adapter.h" #include "profile_qt.h" +#include "qwebengineloadinginfo.h" #include "qwebengineregisterprotocolhandlerrequest.h" -#include "register_protocol_handler_request_controller_impl.h" #include "render_widget_host_view_qt.h" #include "type_conversion.h" #include "visited_links_manager_qt.h" #include "web_contents_adapter_client.h" #include "web_contents_adapter.h" +#include "web_contents_view_qt.h" #include "web_engine_context.h" +#include "web_engine_error.h" #include "web_engine_settings.h" +#include "certificate_error_controller.h" -#include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h" +#include "components/custom_handlers/protocol_handler_registry.h" #include "components/web_cache/browser/web_cache_manager.h" -#include "content/browser/frame_host/render_frame_host_impl.h" -#include "content/browser/renderer_host/render_widget_host_impl.h" +#include "content/browser/renderer_host/render_frame_host_impl.h" +#include "content/browser/web_contents/web_contents_impl.h" #include "content/public/browser/browser_context.h" +#include "content/public/browser/file_select_listener.h" #include "content/public/browser/invalidate_type.h" +#include "content/public/browser/media_stream_request.h" #include "content/public/browser/navigation_entry.h" #include "content/public/browser/navigation_handle.h" #include "content/public/browser/render_view_host.h" #include "content/public/browser/render_frame_host.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/web_contents.h" -#include "content/public/common/favicon_url.h" -#include "content/public/common/file_chooser_params.h" -#include "content/public/common/frame_navigate_params.h" #include "content/public/common/url_constants.h" -#include "content/public/common/web_preferences.h" #include "net/base/data_url.h" #include "net/base/url_util.h" +#include "third_party/blink/public/mojom/mediastream/media_stream.mojom.h" #include <QDesktopServices> #include <QTimer> @@ -87,22 +59,23 @@ namespace QtWebEngineCore { -// Maps the LogSeverity defines in base/logging.h to the web engines message levels. -static WebContentsAdapterClient::JavaScriptConsoleMessageLevel mapToJavascriptConsoleMessageLevel(int32_t messageLevel) +static WebContentsAdapterClient::JavaScriptConsoleMessageLevel mapToJavascriptConsoleMessageLevel(blink::mojom::ConsoleMessageLevel log_level) { - if (messageLevel < 1) + switch (log_level) { + case blink::mojom::ConsoleMessageLevel::kVerbose: + case blink::mojom::ConsoleMessageLevel::kInfo: return WebContentsAdapterClient::Info; - else if (messageLevel > 1) + case blink::mojom::ConsoleMessageLevel::kWarning: + return WebContentsAdapterClient::Warning; + case blink::mojom::ConsoleMessageLevel::kError: return WebContentsAdapterClient::Error; - - return WebContentsAdapterClient::Warning; + } } WebContentsDelegateQt::WebContentsDelegateQt(content::WebContents *webContents, WebContentsAdapterClient *adapterClient) : m_viewClient(adapterClient) - , m_lastReceivedFindReply(0) - , m_faviconManager(new FaviconManager(webContents, adapterClient)) - , m_lastLoadProgress(-1) + , m_findTextHelper(new FindTextHelper(webContents, adapterClient)) + , m_loadingState(determineLoadingState(webContents)) , m_frameFocusedObserver(adapterClient) { webContents->SetDelegate(this); @@ -122,7 +95,7 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents content::SiteInstance *target_site_instance = params.source_site_instance.get(); content::Referrer referrer = params.referrer; if (params.disposition != WindowOpenDisposition::CURRENT_TAB) { - QSharedPointer<WebContentsAdapter> targetAdapter = createWindow(0, params.disposition, gfx::Rect(), params.user_gesture); + QSharedPointer<WebContentsAdapter> targetAdapter = createWindow(nullptr, params.disposition, gfx::Rect(), toQt(params.url), params.user_gesture); if (targetAdapter) { if (targetAdapter->profile() != source->GetBrowserContext()) { target_site_instance = nullptr; @@ -131,11 +104,16 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents if (!targetAdapter->isInitialized()) targetAdapter->initialize(target_site_instance); target = targetAdapter->webContents(); + } else { + return target; } } Q_ASSERT(target); content::NavigationController::LoadURLParams load_url_params(params.url); + load_url_params.initiator_frame_token = params.initiator_frame_token; + load_url_params.initiator_process_id = params.initiator_process_id; + load_url_params.initiator_origin = params.initiator_origin; load_url_params.source_site_instance = target_site_instance; load_url_params.referrer = referrer; load_url_params.frame_tree_node_id = params.frame_tree_node_id; @@ -145,8 +123,13 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents load_url_params.should_replace_current_entry = params.should_replace_current_entry; load_url_params.is_renderer_initiated = params.is_renderer_initiated; load_url_params.started_from_context_menu = params.started_from_context_menu; + load_url_params.has_user_gesture = params.user_gesture; + load_url_params.blob_url_loader_factory = params.blob_url_loader_factory; load_url_params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE; - if (params.uses_post) { + load_url_params.href_translate = params.href_translate; + load_url_params.reload_type = params.reload_type; + load_url_params.impression = params.impression; + if (params.post_data) { load_url_params.load_type = content::NavigationController::LOAD_TYPE_HTTP_POST; load_url_params.post_data = params.post_data; } @@ -155,7 +138,7 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents return target; } -static bool shouldUseActualURL(const content::NavigationEntry *entry) +static bool shouldUseActualURL(content::NavigationEntry *entry) { Q_ASSERT(entry); @@ -167,6 +150,10 @@ static bool shouldUseActualURL(const content::NavigationEntry *entry) if (entry->GetPageType() != content::PAGE_TYPE_NORMAL) return false; + // Show the virtual URL based on custom base, if present + if (!entry->GetBaseURLForDataURL().is_empty()) + return false; + // Show invalid data URL std::string mime_type, charset, data; if (!net::DataURL::Parse(entry->GetURL(), &mime_type, &charset, &data)) @@ -178,58 +165,61 @@ static bool shouldUseActualURL(const content::NavigationEntry *entry) void WebContentsDelegateQt::NavigationStateChanged(content::WebContents* source, content::InvalidateTypes changed_flags) { - if (changed_flags & content::INVALIDATE_TYPE_URL) { - content::NavigationEntry *entry = source->GetController().GetVisibleEntry(); - - QUrl newUrl; - if (source->GetVisibleURL().SchemeIs(content::kViewSourceScheme)) { - Q_ASSERT(entry); - GURL url = entry->GetURL(); - - // Strip user name, password and reference section from view-source URLs - if (url.has_password() || url.has_username() || url.has_ref()) { - GURL strippedUrl = net::SimplifyUrlForRequest(entry->GetURL()); - newUrl = QUrl(QString("%1:%2").arg(content::kViewSourceScheme, QString::fromStdString(strippedUrl.spec()))); - } - } - - // If there is a visible entry there are special cases when we dont wan't to use the actual URL - if (entry && newUrl.isEmpty()) - newUrl = shouldUseActualURL(entry) ? toQt(entry->GetURL()) : toQt(entry->GetVirtualURL()); - - if (m_url != newUrl) { - m_url = newUrl; - m_viewClient->urlChanged(m_url); - } + if (changed_flags & content::INVALIDATE_TYPE_URL && !m_pendingUrlUpdate) { + m_pendingUrlUpdate = true; + base::WeakPtr<WebContentsDelegateQt> delegate = AsWeakPtr(); + QTimer::singleShot(0, [delegate, this](){ if (delegate) m_viewClient->urlChanged();}); } if (changed_flags & content::INVALIDATE_TYPE_TITLE) { QString newTitle = toQt(source->GetTitle()); if (m_title != newTitle) { m_title = newTitle; - m_viewClient->titleChanged(m_title); + QTimer::singleShot(0, [delegate = AsWeakPtr(), title = newTitle] () { + if (delegate) + delegate->adapterClient()->titleChanged(title); + }); } } - // NavigationStateChanged gets called with INVALIDATE_TYPE_TAB by AudioStateProvider::Notify, - // whenever an audio sound gets played or stopped, this is the only way to actually figure out - // if there was a recently played audio sound. // Make sure to only emit the signal when loading isn't in progress, because it causes multiple // false signals to be emitted. - if ((changed_flags & content::INVALIDATE_TYPE_TAB) && !(changed_flags & content::INVALIDATE_TYPE_LOAD)) { + if ((changed_flags & content::INVALIDATE_TYPE_AUDIO) && !(changed_flags & content::INVALIDATE_TYPE_LOAD)) { m_viewClient->recentlyAudibleChanged(source->IsCurrentlyAudible()); } } -void WebContentsDelegateQt::AddNewContents(content::WebContents* source, std::unique_ptr<content::WebContents> new_contents, WindowOpenDisposition disposition, const gfx::Rect& initial_pos, bool user_gesture, bool* was_blocked) +QUrl WebContentsDelegateQt::url(content::WebContents *source) const +{ + content::NavigationEntry *entry = source->GetController().GetVisibleEntry(); + QUrl newUrl; + if (entry) { + GURL url = entry->GetURL(); + // Strip user name, password and reference section from view-source URLs + if (source->GetVisibleURL().SchemeIs(content::kViewSourceScheme) && + (url.has_password() || url.has_username() || url.has_ref())) { + GURL strippedUrl = net::SimplifyUrlForRequest(url); + newUrl = QUrl(QString("%1:%2").arg(content::kViewSourceScheme, QString::fromStdString(strippedUrl.spec()))); + } + // If there is a visible entry there are special cases where we dont wan't to use the actual URL + if (newUrl.isEmpty()) + newUrl = shouldUseActualURL(entry) ? toQt(url) : toQt(entry->GetVirtualURL()); + } + m_pendingUrlUpdate = false; + return newUrl; +} +void WebContentsDelegateQt::AddNewContents(content::WebContents *source, std::unique_ptr<content::WebContents> new_contents, const GURL &target_url, + WindowOpenDisposition disposition, const blink::mojom::WindowFeatures &window_features, bool user_gesture, bool *was_blocked) { Q_UNUSED(source) - QSharedPointer<WebContentsAdapter> newAdapter = createWindow(std::move(new_contents), disposition, initial_pos, user_gesture); + QSharedPointer<WebContentsAdapter> newAdapter = createWindow(std::move(new_contents), disposition, window_features.bounds, toQt(target_url), user_gesture); // Chromium can forget to pass user-agent override settings to new windows (see QTBUG-61774 and QTBUG-76249), // so set it here. Note the actual value doesn't really matter here. Only the second value does, but we try // to give the correct user-agent anyway. if (newAdapter) - newAdapter->webContents()->SetUserAgentOverride(newAdapter->profileAdapter()->httpUserAgent().toStdString(), true); + newAdapter->webContents()->SetUserAgentOverride( + blink::UserAgentOverride::UserAgentOnly(newAdapter->profileAdapter()->httpUserAgent().toStdString()), + true); if (newAdapter && !newAdapter->isInitialized()) newAdapter->loadDefault(); if (was_blocked) @@ -238,37 +228,60 @@ void WebContentsDelegateQt::AddNewContents(content::WebContents* source, std::un void WebContentsDelegateQt::CloseContents(content::WebContents *source) { - m_viewClient->close(); GetJavaScriptDialogManager(source)->CancelDialogs(source, /* whatever?: */false); + // Must be the last call because close() might trigger the destruction of this object. + m_viewClient->close(); } -void WebContentsDelegateQt::LoadProgressChanged(content::WebContents */*source*/, double progress) +void WebContentsDelegateQt::LoadProgressChanged(double progress) { - if (!m_loadingErrorFrameList.isEmpty()) - return; - if (m_lastLoadProgress < 0) // suppress signals that aren't between loadStarted and loadFinished + if (!m_loadingInfo.isLoading()) // suppress signals that aren't between loadStarted and loadFinished return; - m_lastLoadProgress = qMax(m_lastLoadProgress, qRound(progress * 100)); // ensure monotonicity - m_lastLoadProgress = qMin(m_lastLoadProgress, 100); - m_viewClient->loadProgressChanged(m_lastLoadProgress); + + int p = qMin(qRound(progress * 100), 100); + if (p > m_loadingInfo.progress) { // ensure strict monotonic increase + m_loadingInfo.progress = p; + m_viewClient->loadProgressChanged(p); + } } -void WebContentsDelegateQt::HandleKeyboardEvent(content::WebContents *, const content::NativeWebKeyboardEvent &event) +bool WebContentsDelegateQt::HandleKeyboardEvent(content::WebContents *, const content::NativeWebKeyboardEvent &event) { - Q_ASSERT(!event.skip_in_browser); + Q_ASSERT(!event.skip_if_unhandled); if (event.os_event) - m_viewClient->unhandledKeyEvent(reinterpret_cast<QKeyEvent *>(event.os_event)); + m_viewClient->unhandledKeyEvent(ToKeyEvent(event.os_event)); + // FIXME: ? + return true; } void WebContentsDelegateQt::RenderFrameCreated(content::RenderFrameHost *render_frame_host) { content::FrameTreeNode *node = static_cast<content::RenderFrameHostImpl *>(render_frame_host)->frame_tree_node(); m_frameFocusedObserver.addNode(node); + + // If it's a child frame (render_widget_host_view_child_frame) install an InputEventObserver on + // it. Note that it is only needed for WheelEventAck. + RenderWidgetHostViewQt::registerInputEventObserver(web_contents(), render_frame_host); } -void WebContentsDelegateQt::RenderFrameDeleted(content::RenderFrameHost *render_frame_host) +void WebContentsDelegateQt::PrimaryMainFrameRenderProcessGone(base::TerminationStatus status) { - m_loadingErrorFrameList.removeOne(render_frame_host->GetRoutingID()); + // RenderProcessHost::FastShutdownIfPossible results in TERMINATION_STATUS_STILL_RUNNING + if (status != base::TERMINATION_STATUS_STILL_RUNNING) { + m_viewClient->renderProcessTerminated( + m_viewClient->renderProcessExitStatus(status), + web_contents()->GetCrashedErrorCode()); + } + + // Based one TabLoadTracker::RenderProcessGone + + if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION + || status == base::TERMINATION_STATUS_STILL_RUNNING) { + return; + } + LOG(INFO) << "ProcessGone: " << int(status) << " (" << web_contents()->GetCrashedErrorCode() << ")"; + + setLoadingState(LoadingState::Unloaded); } void WebContentsDelegateQt::RenderFrameHostChanged(content::RenderFrameHost *old_host, content::RenderFrameHost *new_host) @@ -281,6 +294,16 @@ void WebContentsDelegateQt::RenderFrameHostChanged(content::RenderFrameHost *old if (new_host) { content::FrameTreeNode *new_node = static_cast<content::RenderFrameHostImpl *>(new_host)->frame_tree_node(); m_frameFocusedObserver.addNode(new_node); + + // Is this a main frame? + if (new_host->GetFrameOwnerElementType() == blink::FrameOwnerElementType::kNone) { + content::RenderProcessHost *renderProcessHost = new_host->GetProcess(); + const base::Process &process = renderProcessHost->GetProcess(); + if (process.IsValid()) { + m_viewClient->renderProcessPidChanged(process.Pid()); + m_viewClient->zoomUpdateIsNeeded(); + } + } } } @@ -288,48 +311,93 @@ void WebContentsDelegateQt::RenderViewHostChanged(content::RenderViewHost *, con { if (newHost && newHost->GetWidget() && newHost->GetWidget()->GetView()) { auto rwhv = static_cast<RenderWidgetHostViewQt *>(newHost->GetWidget()->GetView()); - m_viewClient->widgetChanged(rwhv->delegate()); + Q_ASSERT(rwhv->delegate()); + rwhv->delegate()->adapterClientChanged(m_viewClient); + m_viewClient->zoomUpdateIsNeeded(); + auto backgroundColor = m_viewClient->backgroundColor(); + if (backgroundColor != Qt::white) + m_viewClient->webContentsAdapter()->setBackgroundColor(backgroundColor); } } -void WebContentsDelegateQt::EmitLoadStarted(const QUrl &url, bool isErrorPage) +void WebContentsDelegateQt::RenderViewReady() { - if (m_lastLoadProgress >= 0 && m_lastLoadProgress < 100) // already running + // The render view might have returned after a crash without us getting a RenderViewHostChanged call + content::RenderWidgetHostView *newHostView = web_contents()->GetRenderWidgetHostView(); + if (newHostView) { + auto *rwhv = static_cast<RenderWidgetHostViewQt *>(newHostView); + Q_ASSERT(rwhv->delegate()); + rwhv->delegate()->updateAdapterClientIfNeeded(m_viewClient); + } +} + +void WebContentsDelegateQt::emitLoadStarted(bool isErrorPage) +{ + for (auto &&wc : m_certificateErrorControllers) + if (auto controller = wc.lock()) + controller->deactivate(); + m_certificateErrorControllers.clear(); + + // only report first ever load start or separate one for error page only + if (!isErrorPage && m_loadingInfo.isLoading()) // already running return; - m_viewClient->loadStarted(url, isErrorPage); - m_viewClient->updateNavigationActions(); - m_viewClient->loadProgressChanged(0); - m_lastLoadProgress = 0; + + m_isDocumentEmpty = true; // reset to default which may only be overridden on actual resource load complete + if (!isErrorPage) { + m_loadingInfo.progress = 0; + m_viewClient->loadStarted(QWebEngineLoadingInfo(m_loadingInfo.url, QWebEngineLoadingInfo::LoadStartedStatus)); + m_viewClient->updateNavigationActions(); + m_viewClient->loadProgressChanged(0); + } } void WebContentsDelegateQt::DidStartNavigation(content::NavigationHandle *navigation_handle) { - if (!navigation_handle->IsInMainFrame()) - return; + if (!webEngineSettings()->testAttribute(QWebEngineSettings::ErrorPageEnabled)) + navigation_handle->SetSilentlyIgnoreErrors(); - // Error-pages are not reported as separate started navigations. - Q_ASSERT(!navigation_handle->IsErrorPage()); + if (!navigation_handle->IsInMainFrame() || navigation_handle->IsSameDocument()) + return; - m_loadingErrorFrameList.clear(); - m_faviconManager->resetCandidates(); - EmitLoadStarted(toQt(navigation_handle->GetURL())); + m_loadingInfo.url = toQt(navigation_handle->GetURL()); + // IsErrorPage is only set after navigation commit, so check it otherwise: error page shouldn't have navigation entry + bool isErrorPage = m_loadingInfo.triggersErrorPage && !navigation_handle->GetNavigationEntry(); + emitLoadStarted(isErrorPage); } -void WebContentsDelegateQt::EmitLoadFinished(bool success, const QUrl &url, bool isErrorPage, int errorCode, const QString &errorDescription) +void WebContentsDelegateQt::emitLoadFinished(bool isErrorPage) { - if (m_lastLoadProgress < 0) // not currently running + if (!m_loadingInfo.isLoading()) // not currently running + return; + + Q_ASSERT(!isErrorPage || webEngineSettings()->testAttribute(QWebEngineSettings::ErrorPageEnabled)); + Q_ASSERT((m_loadingInfo.triggersErrorPage && webEngineSettings()->testAttribute(QWebEngineSettings::ErrorPageEnabled)) || !m_loadingInfo.triggersErrorPage); + + if (isErrorPage) { + m_loadingInfo.isErrorPage = isErrorPage; return; - m_lastLoadProgress = -1; - m_viewClient->loadProgressChanged(100); - m_viewClient->loadFinished(success, url, isErrorPage, errorCode, errorDescription); + } + + if (m_loadingInfo.progress < 100) { + m_loadingInfo.progress = 100; + m_viewClient->loadProgressChanged(100); + } + + auto loadStatus = m_loadingInfo.success + ? QWebEngineLoadingInfo::LoadSucceededStatus + : (m_loadingInfo.errorCode == WebEngineError::UserAbortedError + ? QWebEngineLoadingInfo::LoadStoppedStatus : QWebEngineLoadingInfo::LoadFailedStatus); + QWebEngineLoadingInfo info(m_loadingInfo.url, loadStatus, m_loadingInfo.isErrorPage, + m_loadingInfo.errorDescription, m_loadingInfo.errorCode, + QWebEngineLoadingInfo::ErrorDomain(m_loadingInfo.errorDomain), + m_loadingInfo.responseHeaders); + m_viewClient->loadFinished(std::move(info)); m_viewClient->updateNavigationActions(); } -void WebContentsDelegateQt::EmitLoadCommitted() +void WebContentsDelegateQt::emitLoadCommitted() { - // Make sure that we don't set the findNext WebFindOptions on a new frame. - m_lastSearchedString = QString(); - + m_findTextHelper->handleLoadCommitted(); m_viewClient->loadCommitted(); m_viewClient->updateNavigationActions(); } @@ -347,108 +415,146 @@ void WebContentsDelegateQt::DidFinishNavigation(content::NavigationHandle *navig profileAdapter->visitedLinksManager()->addUrl(url); } - EmitLoadCommitted(); + emitLoadCommitted(); + } + + const net::HttpResponseHeaders * const responseHeaders = navigation_handle->GetResponseHeaders(); + if (responseHeaders != nullptr) { + m_loadingInfo.responseHeaders.clear(); + std::size_t iter = 0; + std::string headerName; + std::string headerValue; + while (responseHeaders->EnumerateHeaderLines(&iter, &headerName, &headerValue)) { + m_loadingInfo.responseHeaders.insert( + QByteArray::fromStdString(headerName), + QByteArray::fromStdString(headerValue) + ); + } } + // Success is reported by DidFinishLoad, but DidFailLoad is now dead code and needs to be handled below if (navigation_handle->GetNetErrorCode() == net::OK) return; // WebContentsObserver::DidFailLoad is not called any longer so we have to report the failure here. - const net::Error error_code = navigation_handle->GetNetErrorCode(); - const std::string error_description = net::ErrorToString(error_code); - didFailLoad(toQt(navigation_handle->GetURL()), error_code, toQt(error_description)); + int error_code = navigation_handle->GetNetErrorCode(); + if (error_code == net::ERR_HTTP_RESPONSE_CODE_FAILURE) + if (auto entry = web_contents()->GetController().GetActiveEntry()) + error_code = entry->GetHttpStatusCode(); + didFailLoad(toQt(navigation_handle->GetURL()), error_code, WebEngineError::toQtErrorDescription(error_code)); // The load will succede as an error-page load later, and we reported the original error above if (navigation_handle->IsErrorPage()) { // Now report we are starting to load an error-page. - m_loadingErrorFrameList.append(navigation_handle->GetRenderFrameHost()->GetRoutingID()); - m_faviconManager->resetCandidates(); - EmitLoadStarted(toQt(GURL(content::kUnreachableWebDataURL)), true); // If it is already committed we will not see another DidFinishNavigation call or a DidFinishLoad call. if (navigation_handle->HasCommitted()) - EmitLoadCommitted(); + emitLoadCommitted(); } } +void WebContentsDelegateQt::PrimaryPageChanged(content::Page &) +{ + // Based on TabLoadTracker::PrimaryPageChanged + + if (!web_contents()->ShouldShowLoadingUI()) + return; + + // A transition to loading requires both DidStartLoading (navigation + // committed) and DidReceiveResponse (data has been transmitted over the + // network) events to occur. This is because NavigationThrottles can block + // actual network requests, but not the rest of the state machinery. + setLoadingState(LoadingState::Loading); +} + +void WebContentsDelegateQt::DidStopLoading() +{ + // Based on TabLoadTracker::DidStopLoading + + // NOTE: PageAlmostIdle feature not implemented + + setLoadingState(LoadingState::Loaded); + + emitLoadFinished(); + m_loadingInfo.clear(); +} + void WebContentsDelegateQt::didFailLoad(const QUrl &url, int errorCode, const QString &errorDescription) { m_viewClient->iconChanged(QUrl()); - EmitLoadFinished(false /* success */ , url, false /* isErrorPage */, errorCode, errorDescription); + bool errorPageEnabled = webEngineSettings()->testAttribute(QWebEngineSettings::ErrorPageEnabled); + // Delay notifying failure until the error-page is done loading. + // Error-pages are not loaded on failures due to abort. + bool aborted = (errorCode == -3 /* ERR_ABORTED*/ ); + m_loadingInfo.success = false; + m_loadingInfo.url = url; + m_loadingInfo.errorCode = errorCode; + m_loadingInfo.errorDomain = WebEngineError::toQtErrorDomain(errorCode); + m_loadingInfo.errorDescription = errorDescription; + m_loadingInfo.triggersErrorPage = errorPageEnabled && !aborted; } -void WebContentsDelegateQt::DidFailLoad(content::RenderFrameHost* render_frame_host, const GURL& validated_url, int error_code, const base::string16& error_description) +void WebContentsDelegateQt::DidFailLoad(content::RenderFrameHost* render_frame_host, const GURL& validated_url, int error_code) { - if (render_frame_host != web_contents()->GetMainFrame()) + setLoadingState(LoadingState::Loaded); + + if (render_frame_host != web_contents()->GetPrimaryMainFrame()) return; if (validated_url.spec() == content::kUnreachableWebDataURL) { // error-pages should only ever fail due to abort: Q_ASSERT(error_code == -3 /* ERR_ABORTED */); - m_loadingErrorFrameList.removeOne(render_frame_host->GetRoutingID()); m_viewClient->iconChanged(QUrl()); - - EmitLoadFinished(false /* success */, toQt(validated_url), true /* isErrorPage */); + emitLoadFinished(/* isErrorPage = */true); return; } - - didFailLoad(toQt(validated_url), error_code, toQt(error_description)); + didFailLoad(toQt(validated_url), error_code, WebEngineError::toQtErrorDescription(error_code)); } void WebContentsDelegateQt::DidFinishLoad(content::RenderFrameHost* render_frame_host, const GURL& validated_url) { Q_ASSERT(validated_url.is_valid()); if (validated_url.spec() == content::kUnreachableWebDataURL) { - m_loadingErrorFrameList.removeOne(render_frame_host->GetRoutingID()); - m_viewClient->iconChanged(QUrl()); - // Trigger LoadFinished signal for main frame's error page only. - if (!render_frame_host->GetParent()) - EmitLoadFinished(true /* success */, toQt(validated_url), true /* isErrorPage */); + if (!render_frame_host->GetParent()) { + m_viewClient->iconChanged(QUrl()); + emitLoadFinished(/* isErrorPage = */true); + } return; } - if (render_frame_host->GetParent()) + if (render_frame_host->GetParent()) { + m_viewClient->updateNavigationActions(); return; - - if (!m_faviconManager->hasCandidate()) - m_viewClient->iconChanged(QUrl()); + } content::NavigationEntry *entry = web_contents()->GetController().GetActiveEntry(); - int http_statuscode = 0; - if (entry) - http_statuscode = entry->GetHttpStatusCode(); - EmitLoadFinished(true /* success */ , toQt(validated_url), false /* isErrorPage */, http_statuscode); -} + int http_statuscode = entry ? entry->GetHttpStatusCode() : 0; + bool errorPageEnabled = webEngineSettings()->testAttribute(QWebEngineSettings::ErrorPageEnabled); + bool triggersErrorPage = errorPageEnabled && (http_statuscode >= 400) && m_isDocumentEmpty; -void WebContentsDelegateQt::DidUpdateFaviconURL(const std::vector<content::FaviconURL> &candidates) -{ - QList<FaviconInfo> faviconCandidates; - faviconCandidates.reserve(static_cast<int>(candidates.size())); - for (const content::FaviconURL &candidate : candidates) { - // Store invalid candidates too for later debugging via API - faviconCandidates.append(toFaviconInfo(candidate)); - } - - // Favicon URL can be changed from JavaScript too. Thus we need to reset - // the current candidate icon list to not handle previous icon as a candidate. - m_faviconManager->resetCandidates(); - m_faviconManager->update(faviconCandidates); + m_loadingInfo.success = http_statuscode < 400; + m_loadingInfo.url = toQt(validated_url); + m_loadingInfo.errorCode = http_statuscode; + m_loadingInfo.errorDomain = WebEngineError::toQtErrorDomain(http_statuscode); + m_loadingInfo.errorDescription = WebEngineError::toQtErrorDescription(http_statuscode); + m_loadingInfo.triggersErrorPage = triggersErrorPage; } -void WebContentsDelegateQt::WebContentsCreated(content::WebContents */*source_contents*/, +void WebContentsDelegateQt::WebContentsCreated(content::WebContents * /*source_contents*/, int /*opener_render_process_id*/, int /*opener_render_frame_id*/, const std::string &/*frame_name*/, - const GURL &target_url, content::WebContents */*new_contents*/) + const GURL &/*target_url*/, content::WebContents *newContents) { - m_initialTargetUrl = toQt(target_url); + if (auto *view = static_cast<content::WebContentsImpl *>(newContents)->GetView()) + static_cast<WebContentsViewQt *>(view)->setFactoryClient(m_viewClient); } -content::ColorChooser *WebContentsDelegateQt::OpenColorChooser(content::WebContents *source, SkColor color, const std::vector<blink::mojom::ColorSuggestionPtr> &suggestion) +std::unique_ptr<content::ColorChooser> WebContentsDelegateQt::OpenColorChooser(content::WebContents *source, SkColor color, const std::vector<blink::mojom::ColorSuggestionPtr> &suggestion) { Q_UNUSED(suggestion); - ColorChooserQt *colorChooser = new ColorChooserQt(source, toQt(color)); + auto colorChooser = std::make_unique<ColorChooserQt>(source, toQt(color)); m_viewClient->showColorDialog(colorChooser->controller()); return colorChooser; @@ -458,39 +564,43 @@ content::JavaScriptDialogManager *WebContentsDelegateQt::GetJavaScriptDialogMana return JavaScriptDialogManagerQt::GetInstance(); } -void WebContentsDelegateQt::EnterFullscreenModeForTab(content::WebContents *web_contents, const GURL& origin, const blink::WebFullscreenOptions &) +void WebContentsDelegateQt::EnterFullscreenModeForTab(content::RenderFrameHost *requesting_frame, const blink::mojom::FullscreenOptions &options) { - Q_UNUSED(web_contents); + Q_UNUSED(options); if (!m_viewClient->isFullScreenMode()) - m_viewClient->requestFullScreenMode(toQt(origin), true); + m_viewClient->requestFullScreenMode(toQt(requesting_frame->GetLastCommittedURL().DeprecatedGetOriginAsURL()), true); } void WebContentsDelegateQt::ExitFullscreenModeForTab(content::WebContents *web_contents) { if (m_viewClient->isFullScreenMode()) - m_viewClient->requestFullScreenMode(toQt(web_contents->GetLastCommittedURL().GetOrigin()), false); + m_viewClient->requestFullScreenMode(toQt(web_contents->GetLastCommittedURL().DeprecatedGetOriginAsURL()), false); } -bool WebContentsDelegateQt::IsFullscreenForTabOrPending(const content::WebContents* web_contents) const +bool WebContentsDelegateQt::IsFullscreenForTabOrPending(const content::WebContents* web_contents) { Q_UNUSED(web_contents); return m_viewClient->isFullScreenMode(); } -ASSERT_ENUMS_MATCH(FilePickerController::Open, content::FileChooserParams::Open) -ASSERT_ENUMS_MATCH(FilePickerController::OpenMultiple, content::FileChooserParams::OpenMultiple) -ASSERT_ENUMS_MATCH(FilePickerController::UploadFolder, content::FileChooserParams::UploadFolder) -ASSERT_ENUMS_MATCH(FilePickerController::Save, content::FileChooserParams::Save) +ASSERT_ENUMS_MATCH(FilePickerController::Open, blink::mojom::FileChooserParams::Mode::kOpen) +ASSERT_ENUMS_MATCH(FilePickerController::OpenMultiple, blink::mojom::FileChooserParams::Mode::kOpenMultiple) +ASSERT_ENUMS_MATCH(FilePickerController::UploadFolder, blink::mojom::FileChooserParams::Mode::kUploadFolder) +ASSERT_ENUMS_MATCH(FilePickerController::Save, blink::mojom::FileChooserParams::Mode::kSave) -void WebContentsDelegateQt::RunFileChooser(content::RenderFrameHost *frameHost, const content::FileChooserParams ¶ms) +extern FilePickerController *createFilePickerController(FilePickerController::FileChooserMode mode, scoped_refptr<content::FileSelectListener> listener, const QString &defaultFileName, const QStringList &acceptedMimeTypes, QObject *parent = nullptr); + +void WebContentsDelegateQt::RunFileChooser(content::RenderFrameHost * /*frameHost*/, + scoped_refptr<content::FileSelectListener> listener, + const blink::mojom::FileChooserParams& params) { QStringList acceptedMimeTypes; acceptedMimeTypes.reserve(params.accept_types.size()); - for (std::vector<base::string16>::const_iterator it = params.accept_types.begin(); it < params.accept_types.end(); ++it) + for (std::vector<std::u16string>::const_iterator it = params.accept_types.begin(); it < params.accept_types.end(); ++it) acceptedMimeTypes.append(toQt(*it)); - m_filePickerController.reset(new FilePickerController(static_cast<FilePickerController::FileChooserMode>(params.mode), - frameHost, toQt(params.default_file_name.value()), acceptedMimeTypes)); + m_filePickerController.reset(createFilePickerController(static_cast<FilePickerController::FileChooserMode>(params.mode), + listener, toQt(params.default_file_name.value()), acceptedMimeTypes)); // Defer the call to not block base::MessageLoop::RunTask with modal dialogs. QTimer::singleShot(0, [this] () { @@ -498,27 +608,58 @@ void WebContentsDelegateQt::RunFileChooser(content::RenderFrameHost *frameHost, }); } -bool WebContentsDelegateQt::DidAddMessageToConsole(content::WebContents *source, int32_t level, const base::string16 &message, int32_t line_no, const base::string16 &source_id) +bool WebContentsDelegateQt::DidAddMessageToConsole(content::WebContents *source, blink::mojom::ConsoleMessageLevel log_level, + const std::u16string &message, int32_t line_no, const std::u16string &source_id) { - Q_UNUSED(source) - m_viewClient->javaScriptConsoleMessage(mapToJavascriptConsoleMessageLevel(level), toQt(message), static_cast<int>(line_no), toQt(source_id)); + Q_UNUSED(source); + m_viewClient->javaScriptConsoleMessage(mapToJavascriptConsoleMessageLevel(log_level), toQt(message), static_cast<int>(line_no), toQt(source_id)); return false; } void WebContentsDelegateQt::FindReply(content::WebContents *source, int request_id, int number_of_matches, const gfx::Rect& selection_rect, int active_match_ordinal, bool final_update) { - Q_UNUSED(source) - Q_UNUSED(selection_rect) - Q_UNUSED(active_match_ordinal) - if (final_update && request_id > m_lastReceivedFindReply) { - m_lastReceivedFindReply = request_id; - m_viewClient->didFindText(request_id, number_of_matches); - } + m_findTextHelper->handleFindReply(source, request_id, number_of_matches, selection_rect, active_match_ordinal, final_update); +} + +static void processMediaAccessRequest(content::WebContents *webContents, + const content::MediaStreamRequest &request, + content::MediaResponseCallback callback, + content::DesktopMediaID id) +{ + MediaCaptureDevicesDispatcher::GetInstance()->processMediaAccessRequest( + webContents, request, std::move(callback), id); +} + +static inline bool needsPickerDialog(const content::MediaStreamRequest &request) +{ + return (request.requested_video_device_id.empty() && // device already selected in chooseDesktopMedia + (request.video_type == blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE + || request.video_type == blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE)); } void WebContentsDelegateQt::RequestMediaAccessPermission(content::WebContents *web_contents, const content::MediaStreamRequest &request, content::MediaResponseCallback callback) { - MediaCaptureDevicesDispatcher::GetInstance()->processMediaAccessRequest(m_viewClient, web_contents, request, std::move(callback)); + if (needsPickerDialog(request)) { +#if QT_CONFIG(webengine_webrtc) + base::OnceCallback<void(content::DesktopMediaID)> cb = base::BindOnce( + &processMediaAccessRequest, web_contents, std::move(request), std::move(callback)); + // ownership is taken by the request + auto *controller = new DesktopMediaController( + new DesktopMediaControllerPrivate(std::move(cb))); + QObject::connect(controller, &DesktopMediaController::mediaListsInitialized, [controller, delegate = AsWeakPtr()]() { + if (delegate) + delegate->adapterClient()->desktopMediaRequested(controller); + else + controller->deleteLater(); + }); +#else + // To keep the old behavior return the default screen even if webrtc is disabled + processMediaAccessRequest(web_contents, std::move(request), std::move(callback), + content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN, 0)); +#endif // QT_CONFIG(webengine_webrtc) + } else { + processMediaAccessRequest(web_contents, std::move(request), std::move(callback), {}); + } } void WebContentsDelegateQt::SetContentsBounds(content::WebContents *source, const gfx::Rect &bounds) @@ -529,43 +670,22 @@ void WebContentsDelegateQt::SetContentsBounds(content::WebContents *source, cons QRect frameGeometry(toQt(bounds)); QRect geometry; if (RenderWidgetHostViewQt *rwhv = static_cast<RenderWidgetHostViewQt*>(web_contents()->GetRenderWidgetHostView())) { - if (rwhv->delegate() && rwhv->delegate()->window()) - geometry = frameGeometry.marginsRemoved(rwhv->delegate()->window()->frameMargins()); + if (rwhv->delegate() && rwhv->delegate()->Window()) + geometry = frameGeometry.marginsRemoved(rwhv->delegate()->Window()->frameMargins()); } m_viewClient->requestGeometryChange(geometry, frameGeometry); } void WebContentsDelegateQt::UpdateTargetURL(content::WebContents* source, const GURL& url) { - Q_UNUSED(source) + Q_UNUSED(source); m_viewClient->didUpdateTargetURL(toQt(url)); } -void WebContentsDelegateQt::OnVisibilityChanged(content::Visibility visibility) -{ - if (visibility != content::Visibility::HIDDEN) - web_cache::WebCacheManager::GetInstance()->ObserveActivity(web_contents()->GetMainFrame()->GetProcess()->GetID()); -} - -void WebContentsDelegateQt::DidFirstVisuallyNonEmptyPaint() -{ - RenderWidgetHostViewQt *rwhv = static_cast<RenderWidgetHostViewQt*>(web_contents()->GetRenderWidgetHostView()); - if (!rwhv) - return; - - RenderWidgetHostViewQt::LoadVisuallyCommittedState loadVisuallyCommittedState = rwhv->getLoadVisuallyCommittedState(); - if (loadVisuallyCommittedState == RenderWidgetHostViewQt::NotCommitted) { - rwhv->setLoadVisuallyCommittedState(RenderWidgetHostViewQt::DidFirstVisuallyNonEmptyPaint); - } else if (loadVisuallyCommittedState == RenderWidgetHostViewQt::DidFirstCompositorFrameSwap) { - m_viewClient->loadVisuallyCommitted(); - rwhv->setLoadVisuallyCommittedState(RenderWidgetHostViewQt::NotCommitted); - } -} - void WebContentsDelegateQt::ActivateContents(content::WebContents* contents) { - WebEngineSettings *settings = m_viewClient->webEngineSettings(); - if (settings->testAttribute(settings->Attribute::AllowWindowActivationFromJavaScript)) + QWebEngineSettings *settings = m_viewClient->webEngineSettings(); + if (settings->testAttribute(QWebEngineSettings::AllowWindowActivationFromJavaScript)) contents->Focus(); } @@ -574,29 +694,38 @@ void WebContentsDelegateQt::RequestToLockMouse(content::WebContents *web_content Q_UNUSED(user_gesture); if (last_unlocked_by_target) - web_contents->GotResponseToLockMouseRequest(true); + web_contents->GotResponseToLockMouseRequest(blink::mojom::PointerLockResult::kSuccess); else - m_viewClient->runMouseLockPermissionRequest(toQt(web_contents->GetVisibleURL())); + m_viewClient->runMouseLockPermissionRequest(toQt(web_contents->GetLastCommittedURL().DeprecatedGetOriginAsURL())); } -void WebContentsDelegateQt::overrideWebPreferences(content::WebContents *webContents, content::WebPreferences *webPreferences) +void WebContentsDelegateQt::overrideWebPreferences(content::WebContents *webContents, blink::web_pref::WebPreferences *webPreferences) { - m_viewClient->webEngineSettings()->overrideWebPreferences(webContents, webPreferences); + WebEngineSettings::get(m_viewClient->webEngineSettings())->overrideWebPreferences(webContents, webPreferences); } -QWeakPointer<WebContentsAdapter> WebContentsDelegateQt::createWindow(std::unique_ptr<content::WebContents> new_contents, WindowOpenDisposition disposition, const gfx::Rect& initial_pos, bool user_gesture) +QSharedPointer<WebContentsAdapter> +WebContentsDelegateQt::createWindow(std::unique_ptr<content::WebContents> new_contents, + WindowOpenDisposition disposition, const gfx::Rect &initial_pos, const QUrl &url, + bool user_gesture) { QSharedPointer<WebContentsAdapter> newAdapter = QSharedPointer<WebContentsAdapter>::create(std::move(new_contents)); - m_viewClient->adoptNewWindow(newAdapter, static_cast<WebContentsAdapterClient::WindowOpenDisposition>(disposition), user_gesture, toQt(initial_pos), m_initialTargetUrl); - - // If the client didn't reference the adapter, it will be deleted now, and the weak pointer zeroed. - return newAdapter; + return m_viewClient->adoptNewWindow( + std::move(newAdapter), + static_cast<WebContentsAdapterClient::WindowOpenDisposition>(disposition), user_gesture, + toQt(initial_pos), url); } -void WebContentsDelegateQt::allowCertificateError(const QSharedPointer<CertificateErrorController> &errorController) +void WebContentsDelegateQt::allowCertificateError( + const QSharedPointer<CertificateErrorController> &controller) { - m_viewClient->allowCertificateError(errorController); + QWebEngineCertificateError error(controller); + m_viewClient->allowCertificateError(error); + if (!error.isOverridable() || (!controller->deferred() && !controller->answered())) + error.rejectCertificate(); + else + m_certificateErrorControllers.append(controller); } void WebContentsDelegateQt::selectClientCert(const QSharedPointer<ClientCertSelectController> &selectController) @@ -604,26 +733,26 @@ void WebContentsDelegateQt::selectClientCert(const QSharedPointer<ClientCertSele m_viewClient->selectClientCert(selectController); } -void WebContentsDelegateQt::requestGeolocationPermission(const QUrl &requestingOrigin) +void WebContentsDelegateQt::requestFeaturePermission(ProfileAdapter::PermissionType feature, const QUrl &requestingOrigin) { - m_viewClient->runGeolocationPermissionRequest(requestingOrigin); + m_viewClient->runFeaturePermissionRequest(feature, requestingOrigin); } extern WebContentsAdapterClient::NavigationType pageTransitionToNavigationType(ui::PageTransition transition); void WebContentsDelegateQt::launchExternalURL(const QUrl &url, ui::PageTransition page_transition, bool is_main_frame, bool has_user_gesture) { - WebEngineSettings *settings = m_viewClient->webEngineSettings(); + QWebEngineSettings *settings = m_viewClient->webEngineSettings(); bool navigationAllowedByPolicy = false; bool navigationRequestAccepted = true; switch (settings->unknownUrlSchemePolicy()) { - case WebEngineSettings::DisallowUnknownUrlSchemes: + case QWebEngineSettings::DisallowUnknownUrlSchemes: break; - case WebEngineSettings::AllowUnknownUrlSchemesFromUserInteraction: + case QWebEngineSettings::AllowUnknownUrlSchemesFromUserInteraction: navigationAllowedByPolicy = has_user_gesture; break; - case WebEngineSettings::AllowAllUnknownUrlSchemes: + case QWebEngineSettings::AllowAllUnknownUrlSchemes: navigationAllowedByPolicy = true; break; default: @@ -631,10 +760,8 @@ void WebContentsDelegateQt::launchExternalURL(const QUrl &url, ui::PageTransitio } if (navigationAllowedByPolicy) { - int navigationRequestAction = WebContentsAdapterClient::AcceptRequest; - m_viewClient->navigationRequested(pageTransitionToNavigationType(page_transition), url, navigationRequestAction, is_main_frame); - navigationRequestAccepted = navigationRequestAction == WebContentsAdapterClient::AcceptRequest; -#ifndef QT_NO_DESKTOPSERVICES + m_viewClient->navigationRequested(pageTransitionToNavigationType(page_transition), url, navigationRequestAccepted, is_main_frame, false); +#if QT_CONFIG(desktopservices) if (navigationRequestAccepted) QDesktopServices::openUrl(url); #endif @@ -645,7 +772,7 @@ void WebContentsDelegateQt::launchExternalURL(const QUrl &url, ui::PageTransitio if (!navigationAllowedByPolicy) errorDescription = QStringLiteral("Launching external protocol forbidden by WebEngineSettings::UnknownUrlSchemePolicy"); else - errorDescription = QStringLiteral("Launching external protocol suppressed by WebContentsAdapterClient::navigationRequested"); + errorDescription = QStringLiteral("Launching external protocol suppressed by 'navigationRequested' API"); didFailLoad(url, net::Error::ERR_ABORTED, errorDescription); } } @@ -659,53 +786,45 @@ void WebContentsDelegateQt::BeforeUnloadFired(content::WebContents *tab, bool pr m_viewClient->windowCloseRejected(); } -void WebContentsDelegateQt::BeforeUnloadFired(const base::TimeTicks &proceed_time) { - Q_UNUSED(proceed_time); -} - -bool WebContentsDelegateQt::CheckMediaAccessPermission(content::RenderFrameHost *, const GURL& security_origin, content::MediaStreamType type) +bool WebContentsDelegateQt::CheckMediaAccessPermission(content::RenderFrameHost *, const GURL& security_origin, blink::mojom::MediaStreamType type) { switch (type) { - case content::MEDIA_DEVICE_AUDIO_CAPTURE: + case blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE: return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::AudioCapturePermission); - case content::MEDIA_DEVICE_VIDEO_CAPTURE: + case blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE: return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::VideoCapturePermission); default: LOG(INFO) << "WebContentsDelegateQt::CheckMediaAccessPermission: " - << "Unsupported media stream type checked" << type; + << "Unsupported media stream type checked " << type; return false; } } -void WebContentsDelegateQt::RegisterProtocolHandler(content::WebContents *webContents, const std::string &protocol, const GURL &url, bool) +void WebContentsDelegateQt::RegisterProtocolHandler(content::RenderFrameHost *frameHost, const std::string &protocol, const GURL &url, bool) { - content::BrowserContext *context = webContents->GetBrowserContext(); - if (context->IsOffTheRecord()) - return; + content::BrowserContext *context = frameHost->GetBrowserContext(); - ProtocolHandler handler = - ProtocolHandler::CreateProtocolHandler(protocol, url); + custom_handlers::ProtocolHandler handler = + custom_handlers::ProtocolHandler::CreateProtocolHandler(protocol, url); - ProtocolHandlerRegistry *registry = + custom_handlers::ProtocolHandlerRegistry *registry = ProtocolHandlerRegistryFactory::GetForBrowserContext(context); if (registry->SilentlyHandleRegisterHandlerRequest(handler)) return; QWebEngineRegisterProtocolHandlerRequest request( - QSharedPointer<RegisterProtocolHandlerRequestControllerImpl>::create(webContents, handler)); + QSharedPointer<RegisterProtocolHandlerRequestControllerImpl>::create(content::WebContents::FromRenderFrameHost(frameHost), handler)); m_viewClient->runRegisterProtocolHandlerRequest(std::move(request)); } -void WebContentsDelegateQt::UnregisterProtocolHandler(content::WebContents *webContents, const std::string &protocol, const GURL &url, bool) +void WebContentsDelegateQt::UnregisterProtocolHandler(content::RenderFrameHost *frameHost, const std::string &protocol, const GURL &url, bool) { - content::BrowserContext* context = webContents->GetBrowserContext(); - if (context->IsOffTheRecord()) - return; + content::BrowserContext* context = frameHost->GetBrowserContext(); - ProtocolHandler handler = - ProtocolHandler::CreateProtocolHandler(protocol, url); + custom_handlers::ProtocolHandler handler = + custom_handlers::ProtocolHandler::CreateProtocolHandler(protocol, url); - ProtocolHandlerRegistry* registry = + custom_handlers::ProtocolHandlerRegistry* registry = ProtocolHandlerRegistryFactory::GetForBrowserContext(context); registry->RemoveHandler(handler); } @@ -716,13 +835,43 @@ bool WebContentsDelegateQt::TakeFocus(content::WebContents *source, bool reverse return m_viewClient->passOnFocus(reverse); } -FaviconManager *WebContentsDelegateQt::faviconManager() +void WebContentsDelegateQt::ContentsZoomChange(bool zoom_in) { - return m_faviconManager.data(); + WebContentsAdapter *adapter = webContentsAdapter(); + if (zoom_in) + adapter->setZoomFactor(adapter->currentZoomFactor() + 0.1f); + else + adapter->setZoomFactor(adapter->currentZoomFactor() - 0.1f); +} + +void WebContentsDelegateQt::ResourceLoadComplete(content::RenderFrameHost* render_frame_host, + const content::GlobalRequestID& request_id, + const blink::mojom::ResourceLoadInfo& resource_load_info) +{ + Q_UNUSED(render_frame_host); + Q_UNUSED(request_id); + + if (resource_load_info.request_destination == network::mojom::RequestDestination::kDocument) { + m_isDocumentEmpty = (resource_load_info.raw_body_bytes == 0); + } +} + +void WebContentsDelegateQt::InnerWebContentsAttached(content::WebContents *inner_web_contents, + content::RenderFrameHost *render_frame_host, + bool is_full_page) +{ + blink::web_pref::WebPreferences guestPrefs = inner_web_contents->GetOrCreateWebPreferences(); + webEngineSettings()->overrideWebPreferences(inner_web_contents, &guestPrefs); + inner_web_contents->SetWebPreferences(guestPrefs); +} + +FindTextHelper *WebContentsDelegateQt::findTextHelper() +{ + return m_findTextHelper.data(); } WebEngineSettings *WebContentsDelegateQt::webEngineSettings() const { - return m_viewClient->webEngineSettings(); + return WebEngineSettings::get(m_viewClient->webEngineSettings()); } WebContentsAdapter *WebContentsDelegateQt::webContentsAdapter() const @@ -730,6 +879,96 @@ WebContentsAdapter *WebContentsDelegateQt::webContentsAdapter() const return m_viewClient->webContentsAdapter(); } +void WebContentsDelegateQt::copyStateFrom(WebContentsDelegateQt *source) +{ + m_title = source->m_title; + NavigationStateChanged(web_contents(), content::INVALIDATE_TYPE_URL); +} + +WebContentsDelegateQt::LoadingState WebContentsDelegateQt::determineLoadingState(content::WebContents *contents) +{ + // Based on TabLoadTracker::DetermineLoadingState + + if (contents->ShouldShowLoadingUI() && !contents->IsWaitingForResponse()) + return LoadingState::Loading; + + content::NavigationController &controller = contents->GetController(); + if (controller.GetLastCommittedEntry() != nullptr && !controller.IsInitialNavigation() && !controller.NeedsReload()) + return LoadingState::Loaded; + + return LoadingState::Unloaded; +} + +void WebContentsDelegateQt::setLoadingState(LoadingState state) +{ + if (m_loadingState == state) + return; + + m_loadingState = state; + + webContentsAdapter()->updateRecommendedState(); +} + +int &WebContentsDelegateQt::streamCount(blink::mojom::MediaStreamType type) +{ + // Based on MediaStreamCaptureIndicator::WebContentsDeviceUsage::GetStreamCount + switch (type) { + case blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE: + return m_audioStreamCount; + + case blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE: + return m_videoStreamCount; + + case blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE: + case blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE: + return m_mirroringStreamCount; + + case blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE: + case blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE: + case blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE: + case blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE: + case blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE_THIS_TAB: + case blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE_SET: + return m_desktopStreamCount; + + case blink::mojom::MediaStreamType::NO_SERVICE: + case blink::mojom::MediaStreamType::NUM_MEDIA_TYPES: + NOTREACHED(); + return m_videoStreamCount; + } + NOTREACHED(); + return m_videoStreamCount; +} + +void WebContentsDelegateQt::addDevices(const blink::mojom::StreamDevices &devices) +{ + if (devices.audio_device.has_value()) + addDevice(devices.audio_device.value()); + if (devices.video_device.has_value()) + addDevice(devices.video_device.value()); + + webContentsAdapter()->updateRecommendedState(); +} + +void WebContentsDelegateQt::removeDevices(const blink::mojom::StreamDevices &devices) +{ + if (devices.audio_device.has_value()) + removeDevice(devices.audio_device.value()); + if (devices.video_device.has_value()) + removeDevice(devices.video_device.value()); + + webContentsAdapter()->updateRecommendedState(); +} + +void WebContentsDelegateQt::addDevice(const blink::MediaStreamDevice &device) +{ + ++streamCount(device.type); +} + +void WebContentsDelegateQt::removeDevice(const blink::MediaStreamDevice &device) +{ + --streamCount(device.type); +} FrameFocusedObserver::FrameFocusedObserver(WebContentsAdapterClient *adapterClient) : m_viewClient(adapterClient) |