bool WebKitJSStrategies::isAvailable() const
{
webkitTrace();
// Shared workers do not work across multiple processes, and using network process is tied to multiple secondary process model.
//return !WebProcess::shared().usesNetworkProcess();
return true;
}
void WebKitJSStrategies::loadResourceSynchronously(NetworkingContext* context, unsigned long resourceLoadIdentifier, const ResourceRequest& request, StoredCredentials storedCredentials, ClientCredentialPolicy clientCredentialPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
{
webkitTrace();
if (!WebProcess::shared().usesNetworkProcess()) {
LoaderStrategy::loadResourceSynchronously(context, resourceLoadIdentifier, request, storedCredentials, clientCredentialPolicy, error, response, data);
return;
}
WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(context);
// FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
// EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
// but in the meantime we have to make sure not to mis-cast.
WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
WebPage* webPage = webFrame ? webFrame->page() : 0;
NetworkResourceLoadParameters loadParameters;
loadParameters.identifier = resourceLoadIdentifier;
loadParameters.webPageID = webPage ? webPage->pageID() : 0;
loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
loadParameters.request = request;
loadParameters.priority = ResourceLoadPriorityHighest;
loadParameters.contentSniffingPolicy = SniffContent;
loadParameters.allowStoredCredentials = storedCredentials;
loadParameters.clientCredentialPolicy = clientCredentialPolicy;
loadParameters.inPrivateBrowsingMode = context->storageSession().isPrivateBrowsingSession();
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = context->shouldClearReferrerOnHTTPSToHTTPRedirect();
data.resize(0);
if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, data), 0)) {
response = ResourceResponse();
error = internalError(request.url());
}
}
BlobRegistry* WebKitJSStrategies::createBlobRegistry()
{
webkitTrace();
if (!WebProcess::shared().usesNetworkProcess())
return LoaderStrategy::createBlobRegistry();
return new BlobRegistryProxy;
}
static void coalesceRectsIfPossible(const IntRect& clipRect, Vector<IntRect>& rects)
{
webkitTrace();
const unsigned int cRectThreshold = 10;
const float cWastedSpaceThreshold = 0.75f;
bool useUnionedRect = (rects.size() <= 1) || (rects.size() > cRectThreshold);
if (!useUnionedRect) {
// Attempt to guess whether or not we should use the unioned rect or the individual rects.
// We do this by computing the percentage of "wasted space" in the union. If that wasted space
// is too large, then we will do individual rect painting instead.
float unionPixels = (clipRect.width() * clipRect.height());
float singlePixels = 0;
for (size_t i = 0; i < rects.size(); ++i)
singlePixels += rects[i].width() * rects[i].height();
float wastedSpace = 1 - (singlePixels / unionPixels);
if (wastedSpace <= cWastedSpaceThreshold)
useUnionedRect = true;
}
if (!useUnionedRect)
return;
rects.clear();
rects.append(clipRect);
}
void DrawingBuffer::commit(long x, long y, long width, long height)
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_context)
return;
if (width < 0)
width = m_size.width();
if (height < 0)
height = m_size.height();
m_context->makeContextCurrent();
if (m_multisampleFBO) {
m_context->bindFramebuffer(Extensions3D::READ_FRAMEBUFFER, m_multisampleFBO);
m_context->bindFramebuffer(Extensions3D::DRAW_FRAMEBUFFER, m_fbo);
if (m_scissorEnabled)
m_context->disable(GraphicsContext3D::SCISSOR_TEST);
// Use NEAREST, because there is no scale performed during the blit.
m_context->getExtensions()->blitFramebuffer(x, y, width, height, x, y, width, height, GraphicsContext3D::COLOR_BUFFER_BIT, GraphicsContext3D::NEAREST);
if (m_scissorEnabled)
m_context->enable(GraphicsContext3D::SCISSOR_TEST);
}
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
}
PassRefPtr<DocumentLoader> FrameLoaderClientJS::createDocumentLoader(const ResourceRequest& request, const SubstituteData& subtituteData) {
webkitTrace();
RefPtr<WebCore::DocumentLoader> loader = WebCore::DocumentLoaderJS::create(request, subtituteData);
//GRefPtr<WebKitWebDataSource> webDataSource(adoptGRef(kitNew(loader.get())));
//loader->setDataSource(webDataSource.get());
return loader.release();
}
// Only way to ensure that we're not getting a bad framebuffer on some AMD/OSX devices.
// FIXME: This can be removed once renderbufferStorageMultisample starts reporting GL_OUT_OF_MEMORY properly.
bool DrawingBuffer::checkBufferIntegrity()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_multisampleFBO)
return true;
if (m_scissorEnabled)
m_context->disable(GraphicsContext3D::SCISSOR_TEST);
m_context->colorMask(true, true, true, true);
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
m_context->clearColor(1.0f, 0.0f, 1.0f, 1.0f);
m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
commit(0, 0, 1, 1);
unsigned char pixel[4] = {0, 0, 0, 0};
m_context->readPixels(0, 0, 1, 1, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, &pixel);
if (m_scissorEnabled)
m_context->enable(GraphicsContext3D::SCISSOR_TEST);
return (pixel[0] == 0xFF && pixel[1] == 0x00 && pixel[2] == 0xFF && pixel[3] == 0xFF);
}
static void paintWebView(WebView* webView, Frame* frame, const Region& dirtyRegion)
{
webkitTrace();
if (!webView->p()->backingStore)
return;
Vector<IntRect> rects = dirtyRegion.rects();
coalesceRectsIfPossible(dirtyRegion.bounds(), rects);
RefPtr<cairo_t> backingStoreContext = adoptRef(cairo_create(webView->p()->backingStore->cairoSurface()));
GraphicsContext gc(backingStoreContext.get());
gc.applyDeviceScaleFactor(frame->page()->deviceScaleFactor());
for (size_t i = 0; i < rects.size(); i++) {
const IntRect& rect = rects[i];
gc.save();
gc.clip(rect);
if (webView->p()->transparent)
gc.clearRect(rect);
frame->view()->paint(&gc, rect);
gc.restore();
}
gc.save();
gc.clip(dirtyRegion.bounds());
gc.restore();
}
bool DrawingBuffer::multisample() const
{
#if PLATFORM(JS)
webkitTrace();
#endif
return m_context && m_context->getContextAttributes().antialias && m_multisampleExtensionSupported;
}
void FrameLoaderClientJS::forceLayout() {
webkitTrace();
FrameView* view = m_frame->view();
view->setNeedsLayout();
if (view)
view->forceLayout(true);
}
PassRefPtr<IDBFactoryBackendInterface> WebKitJSStrategies::createIDBFactoryBackend(const String& databaseDirectoryIdentifier)
{
webkitTrace();
#if !ENABLE(DATABASE_PROCESS)
return DatabaseStrategy::createIDBFactoryBackend(databaseDirectoryIdentifier);
#endif
return WebIDBFactoryBackend::create(databaseDirectoryIdentifier);
}
void FrameLoaderClientJS::committedLoad(DocumentLoader* loader, const char* data, int length) {
webkitTrace();
ASSERT(loader->frame());
loader->commitData(data, length);
Frame* coreFrame = loader->frame();
if (coreFrame && coreFrame->document()->isMediaDocument())
loader->cancelMainResourceLoad(coreFrame->loader().client().pluginWillHandleLoadError(loader->response()));
}
void DrawingBuffer::clear()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_context)
return;
m_context->makeContextCurrent();
if (!m_size.isEmpty()) {
s_currentResourceUsePixels -= m_size.width() * m_size.height();
m_size = IntSize();
}
if (m_colorBuffer) {
m_context->deleteTexture(m_colorBuffer);
m_colorBuffer = 0;
}
if (m_frontColorBuffer) {
m_context->deleteTexture(m_frontColorBuffer);
m_frontColorBuffer = 0;
}
if (m_multisampleColorBuffer) {
m_context->deleteRenderbuffer(m_multisampleColorBuffer);
m_multisampleColorBuffer = 0;
}
if (m_depthStencilBuffer) {
m_context->deleteRenderbuffer(m_depthStencilBuffer);
m_depthStencilBuffer = 0;
}
if (m_depthBuffer) {
m_context->deleteRenderbuffer(m_depthBuffer);
m_depthBuffer = 0;
}
if (m_stencilBuffer) {
m_context->deleteRenderbuffer(m_stencilBuffer);
m_stencilBuffer = 0;
}
if (m_multisampleFBO) {
m_context->deleteFramebuffer(m_multisampleFBO);
m_multisampleFBO = 0;
}
if (m_fbo) {
m_context->deleteFramebuffer(m_fbo);
m_fbo = 0;
}
}
void DrawingBuffer::bind()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_context)
return;
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo);
}
Widget::Widget(PlatformWidget widget)
: m_parent(0)
, m_widget(widget)
, m_selfVisible(false)
, m_parentVisible(false)
, m_frame(0, 0, 0, 0)
{
webkitTrace();
init(widget);
}
PlatformContextCairo::PlatformContextCairo(cairo_t* cr)
: m_cr(cr)
{
#if PLATFORM(JS)
webkitTrace();
#endif
m_stateStack.append(State());
m_state = &m_stateStack.last();
}
std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, GraphicsLayerClient* client)
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!factory)
return std::make_unique<GraphicsLayerTextureMapper>(client);
return factory->createGraphicsLayer(client);
}
void DrawingBuffer::restoreFramebufferBinding()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_context || !m_framebufferBinding)
return;
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding);
}
GLContextEGL::GLContextEGL(EGLContext context, EGLSurface surface, EGLSurfaceType type)
: m_context(context)
, m_surface(surface)
, m_type(type)
#if USE(CAIRO)
, m_cairoDevice(0)
#endif
{
#if PLATFORM(JS)
webkitTrace();
#endif
}
void ChromeClientJS::paint(WebCore::Timer<ChromeClientJS>*)
{
webkitTrace();
if (m_view->m_private->acceleratedContext && m_view->m_private->acceleratedContext->enabled())
return;
if(m_dirtyRegion.isEmpty() || !m_view->m_private->backingStore)
return;
static const double minimumFrameInterval = 1.0 / 60.0; // No more than 60 frames a second.
double timeSinceLastDisplay = monotonicallyIncreasingTime() - m_lastDisplayTime;
double timeUntilNextDisplay = minimumFrameInterval - timeSinceLastDisplay;
if (timeUntilNextDisplay > 0 && !m_forcePaint) {
m_displayTimer.startOneShot(timeUntilNextDisplay);
return;
}
m_forcePaint = false;
Frame& frame = (m_view->m_private->mainFrame->coreFrame()->mainFrame());
if (!frame.contentRenderer() || !frame.view())
return;
frame.view()->updateLayoutAndStyleIfNeededRecursive();
performAllPendingScrolls();
paintWebView(m_view, &frame, m_dirtyRegion);
const IntRect& rect = m_dirtyRegion;
SDL_Rect offset;
offset.x = rect.x();
offset.y = rect.y();
offset.w = rect.width();
offset.h = rect.height();
// Bit blitting is done by locking and unlocking the backstore, we should only do this when
// we're sure we have a solid backstore surface with no errors. Part of the problem we may
// have with this approach is the backstore may only require a small sub-set that needs to be
// blitted which might be a lot of overhead to send to the screen. However, there may be
// use cases where the backstore is not representative of the screen (only the dirtyRegion)
// in this case we'll have incorrect rendering. We need to have drawImage and UpperBlit implemented
// in worker proxies for this to work.
SDL_UnlockSurface(m_view->m_private->backingStore->widget());
SDL_LockSurface(m_view->m_private->backingStore->widget());
m_dirtyRegion = IntRect();
m_lastDisplayTime = monotonicallyIncreasingTime();
m_repaintSoonSourceId = 0;
}
static void clearEverywhereInBackingStore(WebView* webView, cairo_t* cr)
{
webkitTrace();
// The strategy here is to quickly draw white into this new canvas, so that
// when a user quickly resizes the WebView in an environment that has opaque
// resizing (like Gnome Shell), there are no drawing artifacts.
if (!webView->p()->transparent) {
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
} else
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
}
/* \reimp (GraphicsLayer.h): The current size might change, thus we need to update the whole display.
*/
void GraphicsLayerTextureMapper::setNeedsDisplay()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!drawsContent())
return;
m_needsDisplay = true;
notifyChange(DisplayChange);
addRepaintRect(FloatRect(FloatPoint(), m_size));
}
static void clipOutOldWidgetArea(cairo_t* cr, const IntSize& oldSize, const IntSize& newSize)
{
webkitTrace();
cairo_move_to(cr, oldSize.width(), 0);
cairo_line_to(cr, newSize.width(), 0);
cairo_line_to(cr, newSize.width(), newSize.height());
cairo_line_to(cr, 0, newSize.height());
cairo_line_to(cr, 0, oldSize.height());
cairo_line_to(cr, oldSize.width(), oldSize.height());
cairo_close_path(cr);
cairo_clip(cr);
}
ResourceLoadScheduler* WebKitJSStrategies::resourceLoadScheduler()
{
webkitTrace();
static ResourceLoadScheduler* scheduler;
if (!scheduler) {
if (WebProcess::shared().usesNetworkProcess())
scheduler = &WebProcess::shared().webResourceLoadScheduler();
else
scheduler = WebCore::resourceLoadScheduler();
}
return scheduler;
}
void DrawingBuffer::createSecondaryBuffers()
{
#if PLATFORM(JS)
webkitTrace();
#endif
// create a multisample FBO
if (multisample()) {
m_multisampleFBO = m_context->createFramebuffer();
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_multisampleFBO);
m_multisampleColorBuffer = m_context->createRenderbuffer();
}
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setDrawsContent(bool value)
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (value == drawsContent())
return;
GraphicsLayer::setDrawsContent(value);
notifyChange(DrawsContentChange);
if (value)
setNeedsDisplay();
}
cairo_device_t* GLContextEGL::cairoDevice()
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (m_cairoDevice)
return m_cairoDevice;
#if ENABLE(ACCELERATED_2D_CANVAS)
m_cairoDevice = cairo_egl_device_create(sharedEGLDisplay(), m_context);
#endif
return m_cairoDevice;
}
void ChromeClientJS::invalidateContentsAndRootView(const IntRect& updateRect, bool immediate)
{
webkitTrace();
if (m_view->m_private->acceleratedContext && m_view->m_private->acceleratedContext->enabled()) {
m_view->m_private->acceleratedContext->setNonCompositedContentsNeedDisplay(updateRect);
return;
}
if (updateRect.isEmpty())
return;
m_dirtyRegion.unite(updateRect);
m_displayTimer.startOneShot(0);
}
void ChromeClientJS::performAllPendingScrolls()
{
webkitTrace();
if (!m_view->m_private->backingStore)
return;
// Scroll all pending scroll rects and invalidate those parts of the widget.
for (size_t i = 0; i < m_rectsToScroll.size(); i++) {
IntRect& scrollRect = m_rectsToScroll[i];
m_view->m_private->backingStore->scroll(scrollRect, m_scrollOffsets[i]);
}
m_rectsToScroll.clear();
m_scrollOffsets.clear();
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect)
{
#if PLATFORM(JS)
webkitTrace();
#endif
if (!m_layer->textureMapper())
return;
flushCompositingStateForThisLayerOnly();
if (maskLayer())
maskLayer()->flushCompositingState(rect);
if (replicaLayer())
replicaLayer()->flushCompositingState(rect);
for (size_t i = 0; i < children().size(); ++i)
children()[i]->flushCompositingState(rect);
}
