void DumpRenderTreeSupportEfl::setDefersLoading(Evas_Object* ewkView, bool defers)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return;
page->setDefersLoading(defers);
}
bool DumpRenderTreeSupportEfl::findString(const Evas_Object* ewkView, const char* text, WebCore::FindOptions options)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return false;
return page->findString(String::fromUTF8(text), options);
}
void WKBundlePageStartMonitoringScrollOperations(WKBundlePageRef pageRef)
{
WebKit::WebPage* webPage = toImpl(pageRef);
WebCore::Page* page = webPage ? webPage->corePage() : nullptr;
if (!page)
return;
page->ensureTestTrigger();
}
static void invalidateView(Evas_Object* webView)
{
Evas_Coord width, height;
Evas_Object* mainFrame = ewk_view_frame_main_get(webView);
if (mainFrame && ewk_frame_contents_size_get(mainFrame, &width, &height)) {
WebCore::Page* page = EWKPrivate::corePage(webView);
if (page)
page->mainFrame()->view()->invalidateRect(WebCore::IntRect(0, 0, width, height));
}
}
void DumpRenderTreeSupportEfl::addUserScript(const Evas_Object* ewkView, const String& sourceCode, bool runAtStart, bool allFrames)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return;
page->group().addUserScriptToWorld(WebCore::mainThreadNormalWorld(), sourceCode, WebCore::KURL(),
nullptr, nullptr, runAtStart ? WebCore::InjectAtDocumentStart : WebCore::InjectAtDocumentEnd,
allFrames ? WebCore::InjectInAllFrames : WebCore::InjectInTopFrameOnly);
}
static void WebHistoryRestoreIndex(JNIEnv* env, jobject obj, jint frame, jint index)
{
LOG_ASSERT(frame, "RestoreState needs a valid Frame pointer!");
WebCore::Frame* pFrame = (WebCore::Frame*)frame;
WebCore::Page* page = pFrame->page();
WebCore::HistoryItem* currentItem =
page->backForwardList()->entries()[index].get();
// load the current page with FrameLoadTypeIndexedBackForward so that it
// will use cache when it is possible
page->goToItem(currentItem, FrameLoadTypeIndexedBackForward);
}
void DumpRenderTreeSupportEfl::setSelectTrailingWhitespaceEnabled(Evas_Object* ewkView, bool enabled)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return;
WebCore::EditorClientEfl* editorClient = static_cast<WebCore::EditorClientEfl*>(page->editorClient());
if (!editorClient)
return;
editorClient->setSelectTrailingWhitespaceEnabled(enabled);
}
static void collapseSelection(GtkClipboard* clipboard, WebKitWebView* webView)
{
if (viewSettingClipboard && viewSettingClipboard == webView)
return;
WebCore::Page* corePage = core(webView);
if (!corePage)
return;
Frame& frame = corePage->focusController().focusedOrMainFrame();
// Collapse the selection without clearing it
frame.selection().setBase(frame.selection().extent(), frame.selection().affinity());
}
void WKBundlePageRegisterScrollOperationCompletionCallback(WKBundlePageRef pageRef, WKBundlePageTestNotificationCallback callback, void* context)
{
if (!callback)
return;
WebKit::WebPage* webPage = toImpl(pageRef);
WebCore::Page* page = webPage ? webPage->corePage() : nullptr;
if (!page || !page->expectsWheelEventTriggers())
return;
page->ensureTestTrigger().setTestCallbackAndStartNotificationTimer([=]() {
callback(context);
});
}
void GeolocationClientQt::startUpdating()
{
if (!m_location && (m_location = QGeoPositionInfoSource::createDefaultSource(this)))
connect(m_location, SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(positionUpdated(QGeoPositionInfo)));
if (!m_location) {
WebCore::Page* page = QWebPagePrivate::core(m_page);
RefPtr<WebCore::GeolocationError> error = GeolocationError::create(GeolocationError::PositionUnavailable, failedToStartServiceErrorMessage);
page->geolocationController()->errorOccurred(error.get());
return;
}
m_location->startUpdates();
}
Eina_Bool ewk_history_clear(Ewk_History* history)
{
EWK_HISTORY_CORE_GET_OR_RETURN(history, core, false);
WebCore::Page* page = core->page();
if (page && page->groupPtr())
page->groupPtr()->removeVisitedLinks();
const int limit = ewk_history_limit_get(history);
ewk_history_limit_set(history, 0);
ewk_history_limit_set(history, limit);
return true;
}
void DumpRenderTreeSupportEfl::setComposition(Evas_Object* ewkView, const char* text, int start, int length)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page || !page->focusController() || !page->focusController()->focusedOrMainFrame())
return;
WebCore::Editor* editor = page->focusController()->focusedOrMainFrame()->editor();
if (!editor || (!editor->canEdit() && !editor->hasComposition()))
return;
const String compositionString = String::fromUTF8(text);
Vector<WebCore::CompositionUnderline> underlines;
underlines.append(WebCore::CompositionUnderline(0, compositionString.length(), WebCore::Color(0, 0, 0), false));
editor->setComposition(compositionString, underlines, start, start + length);
}
void DumpRenderTreeSupportEfl::dumpConfigurationForViewport(Evas_Object* ewkView, int deviceDPI, const WebCore::IntSize& deviceSize, const WebCore::IntSize& availableSize)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page)
return;
WebCore::ViewportArguments arguments = page->mainFrame()->document()->viewportArguments();
WebCore::ViewportAttributes attributes = computeViewportAttributes(arguments,
/* default layout width for non-mobile pages */ 980,
deviceSize.width(), deviceSize.height(),
deviceDPI,
availableSize);
restrictMinimumScaleFactorToViewportSize(attributes, availableSize);
restrictScaleFactorToInitialScaleIfNotUserScalable(attributes);
fprintf(stdout, "viewport size %dx%d scale %f with limits [%f, %f] and userScalable %f\n", attributes.layoutSize.width(), attributes.layoutSize.height(), attributes.initialScale, attributes.minimumScale, attributes.maximumScale, attributes.userScalable);
}
void WebPluginInfoProvider::getWebVisiblePluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins)
{
ASSERT_ARG(plugins, plugins.isEmpty());
getPluginInfo(page, plugins);
#if PLATFORM(MAC)
if (auto* document = page.mainFrame().document()) {
if (auto* securityOrigin = document->securityOrigin()) {
if (securityOrigin->isLocal())
return;
}
}
for (int32_t i = plugins.size() - 1; i >= 0; --i) {
auto& info = plugins.at(i);
// Allow built-in plugins. Also tentatively allow plugins that the client might later selectively permit.
if (info.isApplicationPlugin || info.clientLoadPolicy == WebCore::PluginLoadClientPolicyAsk)
continue;
if (info.clientLoadPolicy == WebCore::PluginLoadClientPolicyBlock)
plugins.remove(i);
}
#endif
}
bool DumpRenderTreeSupportEfl::compositionRange(Evas_Object* ewkView, int* start, int* length)
{
*start = *length = 0;
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page || !page->focusController() || !page->focusController()->focusedOrMainFrame())
return false;
WebCore::Editor* editor = page->focusController()->focusedOrMainFrame()->editor();
if (!editor || !editor->hasComposition())
return false;
*start = editor->compositionStart();
*length = editor->compositionEnd() - *start;
return true;
}
WebCore::IntRect DumpRenderTreeSupportEfl::firstRectForCharacterRange(Evas_Object* ewkView, int location, int length)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page || !page->focusController() || !page->focusController()->focusedOrMainFrame() || !page->focusController()->focusedOrMainFrame()->editor())
return WebCore::IntRect();
if ((location + length < location) && (location + length))
length = 0;
WebCore::Frame* frame = page->focusController()->focusedOrMainFrame();
WebCore::Editor* editor = frame->editor();
RefPtr<WebCore::Range> range = WebCore::TextIterator::rangeFromLocationAndLength(frame->selection()->rootEditableElementOrDocumentElement(), location, length);
if (!range)
return WebCore::IntRect();
return editor->firstRectForRange(range.get());
}
void DumpRenderTreeSupportEfl::confirmComposition(Evas_Object* ewkView, const char* text)
{
WebCore::Page* page = EWKPrivate::corePage(ewkView);
if (!page || !page->focusController() || !page->focusController()->focusedOrMainFrame())
return;
WebCore::Editor* editor = page->focusController()->focusedOrMainFrame()->editor();
if (!editor)
return;
if (!editor->hasComposition()) {
editor->insertText(String::fromUTF8(text), 0);
return;
}
if (text) {
editor->confirmComposition(String::fromUTF8(text));
return;
}
editor->confirmComposition();
}
void ewk_paint_context_paint_contents(Ewk_Paint_Context* context, WebCore::FrameView* view, const Eina_Rectangle* area)
{
EINA_SAFETY_ON_NULL_RETURN(context);
EINA_SAFETY_ON_NULL_RETURN(view);
EINA_SAFETY_ON_NULL_RETURN(area);
WebCore::IntRect paintArea(*area);
if (view->isTransparent())
context->graphicContext->clearRect(paintArea);
view->paintContents(context->graphicContext.get(), paintArea);
#if ENABLE(INSPECTOR)
WebCore::Page* page = view->frame()->page();
if (page) {
WebCore::InspectorController* controller = page->inspectorController();
if (controller->highlightedNode())
controller->drawHighlight(*context->graphicContext);
}
#endif
}
void DumpRenderTreeSupportEfl::setEditingBehavior(Evas_Object* ewkView, const char* editingBehavior)
{
WebCore::EditingBehaviorType coreEditingBehavior;
if (!strcmp(editingBehavior, "win"))
coreEditingBehavior = WebCore::EditingWindowsBehavior;
else if (!strcmp(editingBehavior, "mac"))
coreEditingBehavior = WebCore::EditingMacBehavior;
else if (!strcmp(editingBehavior, "unix"))
coreEditingBehavior = WebCore::EditingUnixBehavior;
else {
ASSERT_NOT_REACHED();
return;
}
WebCore::Page* corePage = EWKPrivate::corePage(ewkView);
if (!corePage)
return;
corePage->settings()->setEditingBehaviorType(coreEditingBehavior);
}
static void setSelectionPrimaryClipboardIfNeeded(WebKitWebView* webView)
{
if (!gtk_widget_has_screen(GTK_WIDGET(webView)))
return;
GtkClipboard* clipboard = gtk_widget_get_clipboard(GTK_WIDGET(webView), GDK_SELECTION_PRIMARY);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
WebCore::Page* corePage = core(webView);
Frame* targetFrame = corePage->focusController()->focusedOrMainFrame();
if (!targetFrame->selection()->isRange())
return;
dataObject->clear();
dataObject->setRange(targetFrame->selection()->toNormalizedRange());
viewSettingClipboard = webView;
GClosure* callback = g_cclosure_new_object(G_CALLBACK(collapseSelection), G_OBJECT(webView));
g_closure_set_marshal(callback, g_cclosure_marshal_VOID__VOID);
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard, PasteboardHelper::DoNotIncludeSmartPaste, callback);
viewSettingClipboard = 0;
}
// Modifies the top of the graphics layer tree to add layers needed to support
// the inner/outer viewport fixed-position model for pinch zoom. When finished,
// the tree will look like this (with * denoting added layers):
//
// *innerViewportContainerLayer (fixed pos container)
// +- *pageScaleLayer
// | +- *innerViewportScrollLayer
// | +-- overflowControlsHostLayer (root layer)
// | +-- rootTransformLayer (optional)
// | +-- outerViewportContainerLayer (fixed pos container) [frame container layer in RenderLayerCompositor]
// | | +-- outerViewportScrollLayer [frame scroll layer in RenderLayerCompositor]
// | | +-- content layers ...
// | +-- horizontal ScrollbarLayer (non-overlay)
// | +-- verticalScrollbarLayer (non-overlay)
// | +-- scroll corner (non-overlay)
// +- *horizontalScrollbarLayer (overlay)
// +- *verticalScrollbarLayer (overlay)
//
void PinchViewports::setOverflowControlsHostLayer(GraphicsLayer* layer)
{
if (layer) {
ASSERT(!m_innerViewportScrollLayer->children().size());
m_innerViewportScrollLayer->addChild(layer);
} else {
m_innerViewportScrollLayer->removeAllChildren();
return;
}
WebCore::Page* page = m_owner->page();
if (!page)
return;
// We only need to disable the existing (outer viewport) scrollbars
// if the existing ones are already overlay.
// FIXME: If we knew in advance before the overflowControlsHostLayer goes
// away, we would re-enable the drawing of these scrollbars.
if (GraphicsLayer* scrollbar = m_owner->compositor()->layerForHorizontalScrollbar())
scrollbar->setDrawsContent(!page->mainFrame()->view()->hasOverlayScrollbars());
if (GraphicsLayer* scrollbar = m_owner->compositor()->layerForVerticalScrollbar())
scrollbar->setDrawsContent(!page->mainFrame()->view()->hasOverlayScrollbars());
}
void GeolocationClientQt::positionUpdated(const QGeoPositionInfo &geoPosition)
{
if (!geoPosition.isValid())
return;
QGeoCoordinate coord = geoPosition.coordinate();
double latitude = coord.latitude();
double longitude = coord.longitude();
bool providesAltitude = (geoPosition.coordinate().type() == QGeoCoordinate::Coordinate3D);
double altitude = coord.altitude();
double accuracy = geoPosition.attribute(QGeoPositionInfo::HorizontalAccuracy);
bool providesAltitudeAccuracy = geoPosition.hasAttribute(QGeoPositionInfo::VerticalAccuracy);
double altitudeAccuracy = geoPosition.attribute(QGeoPositionInfo::VerticalAccuracy);
bool providesHeading = geoPosition.hasAttribute(QGeoPositionInfo::Direction);
double heading = geoPosition.attribute(QGeoPositionInfo::Direction);
bool providesSpeed = geoPosition.hasAttribute(QGeoPositionInfo::GroundSpeed);
double speed = geoPosition.attribute(QGeoPositionInfo::GroundSpeed);
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
double timeStampInSeconds = geoPosition.timestamp().toMSecsSinceEpoch() / 1000;
#else
QDateTime datetime = geoPosition.timestamp();
double timeStampInSeconds = (datetime.toTime_t() + datetime.time().msec()) / 1000;
#endif
m_lastPosition = GeolocationPosition::create(timeStampInSeconds, latitude, longitude,
accuracy, providesAltitude, altitude,
providesAltitudeAccuracy, altitudeAccuracy,
providesHeading, heading, providesSpeed, speed);
WebCore::Page* page = QWebPagePrivate::core(m_page);
page->geolocationController()->positionChanged(m_lastPosition.get());
}
/*!
Clears the history.
\sa count(), items()
*/
void QWebHistory::clear()
{
//shortcut to private BackForwardListImpl
WebCore::BackForwardListImpl* lst = d->lst;
//clear visited links
WebCore::Page* page = static_cast<WebCore::BackForwardListImpl*>(lst)->page();
if (page && page->groupPtr())
page->groupPtr()->removeVisitedLinks();
//if count() == 0 then just return
if (!lst->entries().size())
return;
RefPtr<WebCore::HistoryItem> current = lst->currentItem();
int capacity = lst->capacity();
lst->setCapacity(0);
lst->setCapacity(capacity); //revert capacity
lst->addItem(current.get()); //insert old current item
lst->goToItem(current.get()); //and set it as current again
d->page()->updateNavigationActions();
}
void WebPluginInfoProvider::getPluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins)
{
#if ENABLE(NETSCAPE_PLUGIN_API)
populatePluginCache(page);
if (page.mainFrame().loader().subframeLoader().allowPlugins()) {
plugins = m_cachedPlugins;
return;
}
plugins = m_cachedApplicationPlugins;
#else
UNUSED_PARAM(page);
UNUSED_PARAM(plugins);
#endif // ENABLE(NETSCAPE_PLUGIN_API)
}
void WebPluginInfoProvider::populatePluginCache(const WebCore::Page& page)
{
if (!m_pluginCacheIsPopulated) {
HangDetectionDisabler hangDetectionDisabler;
if (!WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebProcessProxy::GetPlugins(m_shouldRefreshPlugins), Messages::WebProcessProxy::GetPlugins::Reply(m_cachedPlugins, m_cachedApplicationPlugins), 0))
return;
m_shouldRefreshPlugins = false;
m_pluginCacheIsPopulated = true;
}
#if PLATFORM(MAC)
String pageHost = page.mainFrame().loader().documentLoader()->responseURL().host();
for (auto& info : m_cachedPlugins) {
if (auto clientPolicy = pluginLoadClientPolicyForHost(pageHost, info))
info.clientLoadPolicy = *clientPolicy;
}
#else
UNUSED_PARAM(page);
#endif // not PLATFORM(MAC)
}
void DumpRenderTreeSupportEfl::setCSSGridLayoutEnabled(const Evas_Object* ewkView, bool enabled)
{
WebCore::Page* corePage = EWKPrivate::corePage(ewkView);
if (corePage)
corePage->settings()->setCSSGridLayoutEnabled(enabled);
}
/*!
Sets the current item to be the specified \a item in the history and goes to the page.
\sa back(), forward()
*/
void QWebHistory::goToItem(const QWebHistoryItem &item)
{
WebCore::Page* page = static_cast<WebCore::BackForwardListImpl*>(d->lst)->page();
page->goToItem(item.d->item, WebCore::FrameLoadTypeIndexedBackForward);
}
void DumpRenderTreeSupportEfl::setInteractiveFormValidationEnabled(Evas_Object* ewkView, bool enabled)
{
WebCore::Page* corePage = EWKPrivate::corePage(ewkView);
if (corePage)
corePage->settings()->setInteractiveFormValidationEnabled(enabled);
}
void DumpRenderTreeSupportEfl::setValidationMessageTimerMagnification(Evas_Object* ewkView, int value)
{
WebCore::Page* corePage = EWKPrivate::corePage(ewkView);
if (corePage)
corePage->settings()->setValidationMessageTimerMagnification(value);
}
/*!
Sets the current item to be the specified \a item in the history and goes to the page.
\sa back(), forward()
*/
void QWebHistory::goToItem(const QWebHistoryItem &item)
{
d->lst->goToItem(item.d->item);
WebCore::Page* page = d->lst->page();
page->goToItem(currentItem().d->item, WebCore::FrameLoadTypeIndexedBackForward);
}