void PermissionManagerQt::RequestPermission(content::PermissionType permission,
content::RenderFrameHost *frameHost,
int request_id,
const GURL& requesting_origin,
bool user_gesture,
const base::Callback<void(content::PermissionStatus)>& callback)
{
Q_UNUSED(user_gesture);
BrowserContextAdapter::PermissionType permissionType = toQt(permission);
if (permissionType == BrowserContextAdapter::UnsupportedPermission) {
callback.Run(content::PERMISSION_STATUS_DENIED);
return;
}
content::WebContents *webContents = frameHost->GetRenderViewHost()->GetDelegate()->GetAsWebContents();
WebContentsDelegateQt* contentsDelegate = static_cast<WebContentsDelegateQt*>(webContents->GetDelegate());
Q_ASSERT(contentsDelegate);
Request request = {
request_id,
permissionType,
toQt(requesting_origin),
callback
};
m_requests.append(request);
if (permissionType == BrowserContextAdapter::GeolocationPermission)
contentsDelegate->requestGeolocationPermission(request.origin);
}
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())
m_viewClient->loadFinished(true /* success */, toQt(validated_url), true /* isErrorPage */);
return;
}
if (render_frame_host->GetParent())
return;
m_viewClient->loadFinished(true, toQt(validated_url));
content::NavigationEntry *entry = web_contents()->GetController().GetActiveEntry();
if (!entry)
return;
content::FaviconStatus &favicon = entry->GetFavicon();
if (favicon.valid)
m_viewClient->iconChanged(toQt(favicon.url));
else
m_viewClient->iconChanged(QUrl());
}
void PathResult::drawResult(Painter *p) const
{
if (size() >= 2) {
QPen pe = p->pen();
QBrush br(Qt::SolidPattern);
pe.setWidth(2);
const_iterator prev = begin();
const_iterator curr = begin() + 1;
for (int i = 0; curr != end(); i++, curr++, prev++) {
QColor c = QColor::fromHsl(360.0 / size() * i, 255, 128);
pe.setColor(c);
br.setColor(c);
p->setPen(pe);
p->setBrush(br);
p->drawLine(toQt(*prev), toQt(*curr));
p->drawEllipse(toQt(*curr), 1, 1);
}
p->drawMarker(toQt((Point2i) (Point2f) first()));
p->drawMarker(toQt((Point2i) (Point2f) last()));
}
}
static void serializeNavigationHistory(const content::NavigationController &controller, QDataStream &output)
{
const int currentIndex = controller.GetCurrentEntryIndex();
const int count = controller.GetEntryCount();
const int pendingIndex = controller.GetPendingEntryIndex();
output << kHistoryStreamVersion;
output << count;
output << currentIndex;
// Logic taken from SerializedNavigationEntry::WriteToPickle.
for (int i = 0; i < count; ++i) {
const content::NavigationEntry* entry = (i == pendingIndex)
? controller.GetPendingEntry()
: controller.GetEntryAtIndex(i);
if (entry->GetVirtualURL().is_valid()) {
if (entry->GetHasPostData())
entry->GetPageState().RemovePasswordData();
std::string encodedPageState = entry->GetPageState().ToEncodedData();
output << toQt(entry->GetVirtualURL());
output << toQt(entry->GetTitle());
output << QByteArray(encodedPageState.data(), encodedPageState.size());
output << static_cast<qint32>(entry->GetTransitionType());
output << entry->GetHasPostData();
output << toQt(entry->GetReferrer().url);
output << static_cast<qint32>(entry->GetReferrer().policy);
output << toQt(entry->GetOriginalRequestURL());
output << entry->GetIsOverridingUserAgent();
output << static_cast<qint64>(entry->GetTimestamp().ToInternalValue());
output << entry->GetHttpStatusCode();
}
}
}
void WebContentsDelegateQt::NavigationStateChanged(content::WebContents* source, content::InvalidateTypes changed_flags)
{
if (changed_flags & content::INVALIDATE_TYPE_URL)
m_viewClient->urlChanged(toQt(source->GetVisibleURL()));
if (changed_flags & content::INVALIDATE_TYPE_TITLE)
m_viewClient->titleChanged(toQt(source->GetTitle()));
}
static WebEngineContextMenuData fromParams(const content::ContextMenuParams ¶ms)
{
WebEngineContextMenuData ret;
ret.pos = QPoint(params.x, params.y);
ret.linkUrl = toQt(params.link_url);
ret.linkText = toQt(params.link_text.data());
ret.selectedText = toQt(params.selection_text.data());
return ret;
}
void PermissionManagerQt::ResetPermission(
content::PermissionType permission,
const GURL& requesting_origin,
const GURL& /*embedding_origin*/)
{
const BrowserContextAdapter::PermissionType permissionType = toQt(permission);
if (permissionType == BrowserContextAdapter::UnsupportedPermission)
return;
QPair<QUrl, BrowserContextAdapter::PermissionType> key(toQt(requesting_origin), permissionType);
m_permissions.remove(key);
}
QUrl WebContentsAdapter::requestedUrl() const
{
Q_D(const WebContentsAdapter);
content::NavigationEntry* entry = d->webContents->GetController().GetVisibleEntry();
content::NavigationEntry* pendingEntry = d->webContents->GetController().GetPendingEntry();
if (entry) {
if (!entry->GetOriginalRequestURL().is_empty())
return toQt(entry->GetOriginalRequestURL());
if (pendingEntry && pendingEntry == entry)
return toQt(entry->GetURL());
}
return QUrl();
}
int PermissionManagerQt::SubscribePermissionStatusChange(
content::PermissionType permission,
const GURL& requesting_origin,
const GURL& /*embedding_origin*/,
const base::Callback<void(content::PermissionStatus)>& callback)
{
Subscriber subscriber = {
m_subscriberCount++,
toQt(permission),
toQt(requesting_origin),
callback
};
m_subscribers.append(subscriber);
return subscriber.id;
}
content::PermissionStatus PermissionManagerQt::GetPermissionStatus(
content::PermissionType permission,
const GURL& requesting_origin,
const GURL& /*embedding_origin*/)
{
const BrowserContextAdapter::PermissionType permissionType = toQt(permission);
if (permissionType == BrowserContextAdapter::UnsupportedPermission)
return content::PERMISSION_STATUS_DENIED;
QPair<QUrl, BrowserContextAdapter::PermissionType> key(toQt(requesting_origin), permissionType);
if (!m_permissions.contains(key))
return content::PERMISSION_STATUS_ASK;
if (m_permissions[key])
return content::PERMISSION_STATUS_GRANTED;
return content::PERMISSION_STATUS_DENIED;
}
bool NetworkDelegateQt::OnCanSetCookie(const net::URLRequest& request,
const std::string& cookie_line,
net::CookieOptions*)
{
Q_ASSERT(m_requestContextGetter);
return m_requestContextGetter->m_cookieDelegate->canSetCookie(toQt(request.first_party_for_cookies()), QByteArray::fromStdString(cookie_line), toQt(request.url()));
}
void WebContentsDelegateQt::DidFailLoad(content::RenderFrameHost* render_frame_host, const GURL& validated_url, int error_code, const base::string16& error_description, bool was_ignored_by_handler)
{
Q_UNUSED(was_ignored_by_handler);
if (validated_url.spec() == content::kUnreachableWebDataURL) {
m_loadingErrorFrameList.removeOne(render_frame_host->GetRoutingID());
qCritical("Loading error-page failed. This shouldn't happen.");
if (!render_frame_host->GetParent())
m_viewClient->loadFinished(false /* success */, toQt(validated_url), true /* isErrorPage */);
return;
}
if (render_frame_host->GetParent())
return;
m_viewClient->loadFinished(false /* success */ , toQt(validated_url), false /* isErrorPage */, error_code, toQt(error_description));
m_viewClient->loadProgressChanged(0);
}
void WebContentsDelegateQt::DidStartProvisionalLoadForFrame(content::RenderFrameHost* render_frame_host, const GURL& validated_url, bool is_error_page, bool is_iframe_srcdoc)
{
if (is_error_page) {
m_loadingErrorFrameList.append(render_frame_host->GetRoutingID());
// Trigger LoadStarted signal for main frame's error page only.
if (!render_frame_host->GetParent())
m_viewClient->loadStarted(toQt(validated_url), true);
return;
}
if (render_frame_host->GetParent())
return;
m_loadingErrorFrameList.clear();
m_viewClient->loadStarted(toQt(validated_url));
}
QUrl WebContentsAdapter::getNavigationEntryIconUrl(int index)
{
Q_D(WebContentsAdapter);
content::NavigationEntry *entry = d->webContents->GetController().GetEntryAtIndex(index);
if (!entry)
return QUrl();
content::FaviconStatus favicon = entry->GetFavicon();
return favicon.valid ? toQt(favicon.url) : QUrl();
}
QUrl WebContentsAdapter::iconUrl() const
{
Q_D(const WebContentsAdapter);
if (content::NavigationEntry* entry = d->webContents->GetController().GetVisibleEntry()) {
content::FaviconStatus favicon = entry->GetFavicon();
if (favicon.valid)
return toQt(favicon.url);
}
return QUrl();
}
CertificateErrorControllerPrivate::CertificateErrorControllerPrivate(int cert_error,
const net::SSLInfo& ssl_info,
const GURL &request_url,
ResourceType::Type resource_type,
bool _overridable,
bool strict_enforcement,
const base::Callback<void(bool)>& cb
)
: certError(CertificateErrorController::CertificateError(cert_error))
, requestUrl(toQt(request_url))
, resourceType(CertificateErrorController::ResourceType(resource_type))
, overridable(_overridable)
, strictEnforcement(strict_enforcement)
, callback(cb)
{
if (ssl_info.cert) {
validStart = toQt(ssl_info.cert->valid_start());
validExpiry = toQt(ssl_info.cert->valid_expiry());
}
}
Q_FOREACH (content::FaviconURL candidate, candidates) {
if (candidate.icon_type == content::FaviconURL::FAVICON && !candidate.icon_url.is_empty()) {
content::NavigationEntry *entry = web_contents()->GetController().GetActiveEntry();
if (!entry)
continue;
content::FaviconStatus &favicon = entry->GetFavicon();
favicon.url = candidate.icon_url;
favicon.valid = toQt(candidate.icon_url).isValid();
break;
}
}
void PermissionManagerQt::CancelPermissionRequest(content::PermissionType permission,
content::RenderFrameHost *frameHost,
int request_id,
const GURL& requesting_origin)
{
Q_UNUSED(frameHost);
const BrowserContextAdapter::PermissionType permissionType = toQt(permission);
if (permissionType == BrowserContextAdapter::UnsupportedPermission)
return;
// Should we add API to cancel permissions in the UI level?
const QUrl origin = toQt(requesting_origin);
auto it = m_requests.begin();
while (it != m_requests.end()) {
if (it->id == request_id && it->type == permissionType && it->origin == origin) {
m_requests.erase(it);
return;
}
}
qWarning() << "PermissionManagerQt::CancelPermissionRequest called on unknown request" << request_id << origin << permissionType;
}
// Constructor.
SetComponentCommand::SetComponentCommand(beCore::ReflectedComponent *pReflectedComponent, uint4 componentIdx,
const lean::any &component, beCore::ComponentMonitor *pComponentMonitor, QUndoCommand *pParent)
: QUndoCommand(
QCoreApplication::translate("SetComponentCommand", "Replaced component '%1'").arg(
makeName(toQt( LEAN_ASSERT_NOT_NULL(pReflectedComponent)->GetComponentName(componentIdx) ))
),
pParent ),
m_pReflectedComponent( LEAN_ASSERT_NOT_NULL(pReflectedComponent) ),
m_componentIdx( componentIdx ),
m_previousComponent( *pReflectedComponent->GetComponent(m_componentIdx) ),
m_component( component ),
m_pComponentMonitor( pComponentMonitor )
{
}
// Constructor.
ChangePropertyCommand::ChangePropertyCommand(beCore::PropertyProvider *pPropertyProvider, uint4 propertyID, QUndoCommand *pParent)
: QUndoCommand(
QCoreApplication::translate("ChangePropertyCommand", "Changed property '%1'").arg(
makeName(toQt( LEAN_ASSERT_NOT_NULL(pPropertyProvider)->GetPropertyName(propertyID) ))
),
pParent ),
m_pPropertyProvider( LEAN_ASSERT_NOT_NULL(pPropertyProvider) ),
m_propertyID( propertyID ),
m_previousData( createPropertyData(*m_pPropertyProvider, m_propertyID), lean::consume ),
m_data( createPropertyData(*m_pPropertyProvider, m_propertyID), lean::consume ),
m_bIgnoreOnce(false)
{
m_pPropertyProvider->GetProperty(m_propertyID, m_previousData.property_type().type_info().type, m_previousData.data(), m_previousData.count());
m_pPropertyProvider->GetProperty(m_propertyID, m_data.property_type().type_info().type, m_data.data(), m_data.count());
}
void URLRequestQrcJobQt::startGetHead()
{
// Get qrc file path.
QString qrcFilePath = ':' + toQt(request_->url()).path(QUrl::RemovePath | QUrl::RemoveQuery);
m_file.setFileName(qrcFilePath);
QFileInfo qrcFileInfo(m_file);
// Get qrc file mime type.
QMimeDatabase mimeDatabase;
QMimeType mimeType = mimeDatabase.mimeTypeForFile(qrcFileInfo);
m_mimeType = mimeType.name().toStdString();
// Open file
if (m_file.open(QIODevice::ReadOnly)) {
m_remainingBytes = m_file.size();
// Notify that the headers are complete
NotifyHeadersComplete();
} else {
NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, ERR_INVALID_URL));
}
}
QString WebContentsAdapter::getNavigationEntryTitle(int index)
{
Q_D(WebContentsAdapter);
content::NavigationEntry *entry = d->webContents->GetController().GetEntryAtIndex(index);
return entry ? toQt(entry->GetTitle()) : QString();
}
QString WebContentsAdapter::pageTitle() const
{
Q_D(const WebContentsAdapter);
return toQt(d->webContents->GetTitle());
}
static QString getQStringForMessageId(int message_id) {
base::string16 string = l10n_util::GetStringUTF16(message_id);
return toQt(string);
}
QUrl URLRequestCustomJobDelegate::url() const
{
return toQt(m_job->request()->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;
}
QUrl WebContentsAdapter::getNavigationEntryUrl(int index)
{
Q_D(WebContentsAdapter);
content::NavigationEntry *entry = d->webContents->GetController().GetEntryAtIndex(index);
return entry ? toQt(entry->GetURL()) : QUrl();
}
QString UserScript::sourceCode() const
{
if (isNull())
return QString();
return toQt(scriptData->source);
}
QString WebContentsAdapter::selectedText() const
{
Q_D(const WebContentsAdapter);
return toQt(d->webContents->GetRenderViewHost()->GetView()->GetSelectedText());
}
QDateTime WebContentsAdapter::getNavigationEntryTimestamp(int index)
{
Q_D(WebContentsAdapter);
content::NavigationEntry *entry = d->webContents->GetController().GetEntryAtIndex(index);
return entry ? toQt(entry->GetTimestamp()) : QDateTime();
}
