void WebContentsAdapter::setContent(const QByteArray &data, const QString &mimeType, const QUrl &baseUrl)
{
Q_D(WebContentsAdapter);
QByteArray encodedData = data.toPercentEncoding();
std::string urlString("data:");
urlString.append(mimeType.toStdString());
urlString.append(",");
urlString.append(encodedData.constData(), encodedData.length());
GURL dataUrlToLoad(urlString);
if (dataUrlToLoad.spec().size() > content::GetMaxURLChars()) {
d->adapterClient->loadFinished(false, baseUrl, false, net::ERR_ABORTED);
return;
}
content::NavigationController::LoadURLParams params((dataUrlToLoad));
params.load_type = content::NavigationController::LOAD_TYPE_DATA;
params.base_url_for_data_url = toGurl(baseUrl);
params.virtual_url_for_data_url = baseUrl.isEmpty() ? GURL(url::kAboutBlankURL) : toGurl(baseUrl);
params.can_load_local_resources = true;
params.transition_type = ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_API);
params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
d->webContents->GetController().LoadURLWithParams(params);
d->webContents->Focus();
d->webContents->Unselect();
}
void WebContentsAdapter::download(const QUrl &url, const QString &suggestedFileName)
{
content::BrowserContext *bctx = webContents()->GetBrowserContext();
content::DownloadManager *dlm = content::BrowserContext::GetDownloadManager(bctx);
if (!dlm)
return;
scoped_ptr<content::DownloadUrlParameters> params(
content::DownloadUrlParameters::FromWebContents(webContents(), toGurl(url)));
params->set_suggested_name(toString16(suggestedFileName));
dlm->DownloadUrl(params.Pass());
}
void WebContentsAdapter::load(const QUrl &url)
{
// The situation can occur when relying on the editingFinished signal in QML to set the url
// of the WebView.
// When enter is pressed, onEditingFinished fires and the url of the webview is set, which
// calls into this and focuses the webview, taking the focus from the TextField/TextInput,
// which in turn leads to editingFinished firing again. This scenario would cause a crash
// down the line when unwinding as the first RenderWidgetHostViewQtDelegateQuick instance is
// a dangling pointer by that time.
if (LoadRecursionGuard::isGuarded(this))
return;
LoadRecursionGuard guard(this);
Q_UNUSED(guard);
Q_D(WebContentsAdapter);
content::NavigationController::LoadURLParams params(toGurl(url));
params.transition_type = ui::PageTransitionFromInt(ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
d->webContents->GetController().LoadURLWithParams(params);
d->webContents->Focus();
}
void URLRequestCustomJobDelegate::redirect(const QUrl &url)
{
m_job->redirect(toGurl(url));
}
int NetworkDelegateQt::OnBeforeURLRequest(net::URLRequest *request, const net::CompletionCallback &callback, GURL *newUrl)
{
Q_ASSERT(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
Q_ASSERT(m_requestContextGetter);
const content::ResourceRequestInfo *resourceInfo = content::ResourceRequestInfo::ForRequest(request);
content::ResourceType resourceType = content::RESOURCE_TYPE_LAST_TYPE;
int navigationType = QWebEngineUrlRequestInfo::NavigationTypeOther;
if (resourceInfo) {
resourceType = resourceInfo->GetResourceType();
navigationType = pageTransitionToNavigationType(resourceInfo->GetPageTransition());
}
const QUrl qUrl = toQt(request->url());
QWebEngineUrlRequestInterceptor* interceptor = m_requestContextGetter->m_requestInterceptor;
if (interceptor) {
QWebEngineUrlRequestInfoPrivate *infoPrivate = new QWebEngineUrlRequestInfoPrivate(static_cast<QWebEngineUrlRequestInfo::ResourceType>(resourceType)
, static_cast<QWebEngineUrlRequestInfo::NavigationType>(navigationType)
, qUrl
, toQt(request->first_party_for_cookies())
, QByteArray::fromStdString(request->method()));
QWebEngineUrlRequestInfo requestInfo(infoPrivate);
interceptor->interceptRequest(requestInfo);
if (requestInfo.changed()) {
int result = infoPrivate->shouldBlockRequest ? net::ERR_BLOCKED_BY_CLIENT : net::OK;
if (qUrl != infoPrivate->url)
*newUrl = toGurl(infoPrivate->url);
if (!infoPrivate->extraHeaders.isEmpty()) {
auto end = infoPrivate->extraHeaders.constEnd();
for (auto header = infoPrivate->extraHeaders.constBegin(); header != end; ++header)
request->SetExtraRequestHeaderByName(header.key().toStdString(), header.value().toStdString(), /* overwrite */ true);
}
if (result != net::OK)
return result;
}
}
if (!resourceInfo)
return net::OK;
int renderProcessId;
int renderFrameId;
// Only intercept MAIN_FRAME and SUB_FRAME with an associated render frame.
if (!content::IsResourceTypeFrame(resourceType) || !resourceInfo->GetRenderFrameForRequest(request, &renderProcessId, &renderFrameId))
return net::OK;
// Track active requests since |callback| and |new_url| are valid
// only until OnURLRequestDestroyed is called for this request.
m_activeRequests.insert(request);
RequestParams params = {
qUrl,
resourceInfo->IsMainFrame(),
navigationType,
renderProcessId,
renderFrameId
};
content::BrowserThread::PostTask(
content::BrowserThread::UI,
FROM_HERE,
base::Bind(&NetworkDelegateQt::NotifyNavigationRequestedOnUIThread,
base::Unretained(this),
request,
params,
callback)
);
// We'll run the callback after we notified the UI thread.
return net::ERR_IO_PENDING;
}
static void deserializeNavigationHistory(QDataStream &input, int *currentIndex, ScopedVector<content::NavigationEntry> *entries, content::BrowserContext *browserContext)
{
int version;
input >> version;
if (version != kHistoryStreamVersion) {
// We do not try to decode previous history stream versions.
// Make sure that our history is cleared and mark the rest of the stream as invalid.
input.setStatus(QDataStream::ReadCorruptData);
*currentIndex = -1;
return;
}
int count;
input >> count >> *currentIndex;
int pageId = 0;
entries->reserve(count);
// Logic taken from SerializedNavigationEntry::ReadFromPickle and ToNavigationEntries.
for (int i = 0; i < count; ++i) {
QUrl virtualUrl, referrerUrl, originalRequestUrl;
QString title;
QByteArray pageState;
qint32 transitionType, referrerPolicy;
bool hasPostData, isOverridingUserAgent;
qint64 timestamp;
int httpStatusCode;
input >> virtualUrl;
input >> title;
input >> pageState;
input >> transitionType;
input >> hasPostData;
input >> referrerUrl;
input >> referrerPolicy;
input >> originalRequestUrl;
input >> isOverridingUserAgent;
input >> timestamp;
input >> httpStatusCode;
// If we couldn't unpack the entry successfully, abort everything.
if (input.status() != QDataStream::Ok) {
*currentIndex = -1;
for (content::NavigationEntry *entry : *entries)
delete entry;
entries->clear();
return;
}
scoped_ptr<content::NavigationEntry> entry = content::NavigationController::CreateNavigationEntry(
toGurl(virtualUrl),
content::Referrer(toGurl(referrerUrl), static_cast<blink::WebReferrerPolicy>(referrerPolicy)),
// Use a transition type of reload so that we don't incorrectly
// increase the typed count.
ui::PAGE_TRANSITION_RELOAD,
false,
// The extra headers are not sync'ed across sessions.
std::string(),
browserContext);
entry->SetTitle(toString16(title));
entry->SetPageState(content::PageState::CreateFromEncodedData(std::string(pageState.data(), pageState.size())));
entry->SetPageID(pageId++);
entry->SetHasPostData(hasPostData);
entry->SetOriginalRequestURL(toGurl(originalRequestUrl));
entry->SetIsOverridingUserAgent(isOverridingUserAgent);
entry->SetTimestamp(base::Time::FromInternalValue(timestamp));
entry->SetHttpStatusCode(httpStatusCode);
entries->push_back(entry.release());
}
}
