void GraphicsContext3DPrivate::createGraphicsSurface()
{
static PendingSurfaceOperation pendingOperation = DeletePreviousSurface | Resize | CreateSurface;
if (!(m_surfaceOperation & pendingOperation))
return;
if (m_surfaceOperation & DeletePreviousSurface) {
m_previousGraphicsSurface = nullptr;
m_surfaceOperation &= ~DeletePreviousSurface;
}
if (!(m_surfaceOperation & pendingOperation))
return;
// Don't release current graphics surface until we have prepared surface
// with requested size. This is to avoid flashing during resize.
if (m_surfaceOperation & Resize) {
m_previousGraphicsSurface = m_graphicsSurface;
m_surfaceOperation &= ~Resize;
m_surfaceOperation |= DeletePreviousSurface;
m_size = IntSize(m_context->m_currentWidth, m_context->m_currentHeight);
} else
m_surfaceOperation &= ~CreateSurface;
m_targetRect = IntRect(IntPoint(), m_size);
if (m_size.isEmpty()) {
if (m_graphicsSurface) {
m_graphicsSurface = nullptr;
m_surfaceHandle = GraphicsSurfaceToken();
makeContextCurrent();
}
return;
}
m_offScreenContext->releaseCurrent();
GraphicsSurface::Flags flags = GraphicsSurface::SupportsTextureTarget | GraphicsSurface::SupportsSharing;
if (m_context->m_attrs.alpha)
flags |= GraphicsSurface::SupportsAlpha;
m_graphicsSurface = GraphicsSurface::create(m_size, flags, m_offScreenContext->handle());
if (!m_graphicsSurface)
m_surfaceHandle = GraphicsSurfaceToken();
else
m_surfaceHandle = GraphicsSurfaceToken(m_graphicsSurface->exportToken());
makeContextCurrent();
}
bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder* decoder, WebCore::GraphicsSurfaceToken& token)
{
#if OS(WINDOWS)
uint64_t frontBufferHandle;
if (!decoder->decode(frontBufferHandle))
return false;
token.frontBufferHandle = reinterpret_cast<GraphicsSurfaceToken::BufferHandle>(frontBufferHandle);
uint64_t backBufferHandle;
if (!decoder->decode(backBufferHandle))
return false;
token.backBufferHandle = reinterpret_cast<GraphicsSurfaceToken::BufferHandle>(backBufferHandle);
#elif OS(DARWIN)
Attachment frontAttachment, backAttachment;
if (!decoder->decode(frontAttachment))
return false;
if (!decoder->decode(backAttachment))
return false;
token = GraphicsSurfaceToken(frontAttachment.port(), backAttachment.port());
#elif OS(LINUX)
if (!decoder->decode(token.frontBufferHandle))
return false;
#endif
return true;
}
void CoordinatedGraphicsLayer::destroyCanvasIfNeeded()
{
if (!(m_pendingCanvasOperation & DestroyCanvas))
return;
if (m_isValidCanvas) {
m_isValidCanvas = false;
m_layerState.canvasToken = GraphicsSurfaceToken();
m_layerState.canvasChanged = true;
}
m_pendingCanvasOperation &= ~DestroyCanvas;
}
void CoordinatedGraphicsLayer::destroyPlatformLayerIfNeeded()
{
if (!(m_pendingPlatformLayerOperation & DestroyPlatformLayer))
return;
if (m_isValidPlatformLayer) {
m_isValidPlatformLayer = false;
m_layerState.platformLayerToken = GraphicsSurfaceToken();
m_layerState.platformLayerChanged = true;
}
m_pendingPlatformLayerOperation &= ~DestroyPlatformLayer;
}
void GraphicsContext3DPrivate::releaseResources()
{
if (m_context->m_renderStyle == GraphicsContext3D::RenderToCurrentGLContext)
return;
// Release the current context and drawable only after destroying any associated gl resources.
#if USE(GRAPHICS_SURFACE)
if (m_previousGraphicsSurface)
m_previousGraphicsSurface = nullptr;
if (m_graphicsSurface)
m_graphicsSurface = nullptr;
m_surfaceHandle = GraphicsSurfaceToken();
#endif
if (m_offScreenSurface)
m_offScreenSurface->destroy();
if (m_offScreenContext) {
m_offScreenContext->destroy();
m_offScreenContext->releaseCurrent();
}
}
GraphicsContext3DPrivate::GraphicsContext3DPrivate(GraphicsContext3D* context, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
: m_context(context)
, m_hostWindow(hostWindow)
, m_pendingSurfaceResize(false)
{
if (m_hostWindow && m_hostWindow->platformPageClient()) {
// FIXME: Implement this code path for WebKit1.
// Get Evas object from platformPageClient and set EvasGL related members.
return;
}
m_platformContext = GLPlatformContext::createContext(renderStyle);
if (!m_platformContext)
return;
if (renderStyle == GraphicsContext3D::RenderOffscreen) {
#if USE(GRAPHICS_SURFACE)
m_platformSurface = GLPlatformSurface::createTransportSurface();
#else
m_platformSurface = GLPlatformSurface::createOffscreenSurface();
#endif
if (!m_platformSurface) {
m_platformContext = nullptr;
return;
}
if (!m_platformContext->initialize(m_platformSurface.get()) || !m_platformContext->makeCurrent(m_platformSurface.get())) {
releaseResources();
m_platformContext = nullptr;
m_platformSurface = nullptr;
#if USE(GRAPHICS_SURFACE)
} else
m_surfaceHandle = GraphicsSurfaceToken(m_platformSurface->handle());
#else
}
#endif
}
GraphicsSurfaceToken GraphicsSurface::platformExport()
{
return GraphicsSurfaceToken(m_platformSurface);
}
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext, const IntSize& size, GraphicsSurface::Flags flags)
: m_context(0)
, m_size(size)
, m_frontBufferTexture(0)
, m_frontBufferReadTexture(0)
, m_backBufferTexture(0)
, m_backBufferReadTexture(0)
, m_readFbo(0)
, m_drawFbo(0)
{
#if PLATFORM(QT)
QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
CGLContextObj shareContextObject = static_cast<CGLContextObj>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("cglContextObj"), shareContext));
if (!shareContextObject)
return;
CGLPixelFormatObj pixelFormatObject = CGLGetPixelFormat(shareContextObject);
if (kCGLNoError != CGLCreateContext(pixelFormatObject, shareContextObject, &m_context))
return;
CGLRetainContext(m_context);
#endif
unsigned pixelFormat = 'BGRA';
unsigned bytesPerElement = 4;
int width = m_size.width();
int height = m_size.height();
unsigned long bytesPerRow = IOSurfaceAlignProperty(kIOSurfaceBytesPerRow, width * bytesPerElement);
if (!bytesPerRow)
return;
unsigned long allocSize = IOSurfaceAlignProperty(kIOSurfaceAllocSize, height * bytesPerRow);
if (!allocSize)
return;
const void *keys[6];
const void *values[6];
keys[0] = kIOSurfaceWidth;
values[0] = CFNumberCreate(0, kCFNumberIntType, &width);
keys[1] = kIOSurfaceHeight;
values[1] = CFNumberCreate(0, kCFNumberIntType, &height);
keys[2] = kIOSurfacePixelFormat;
values[2] = CFNumberCreate(0, kCFNumberIntType, &pixelFormat);
keys[3] = kIOSurfaceBytesPerElement;
values[3] = CFNumberCreate(0, kCFNumberIntType, &bytesPerElement);
keys[4] = kIOSurfaceBytesPerRow;
values[4] = CFNumberCreate(0, kCFNumberLongType, &bytesPerRow);
keys[5] = kIOSurfaceAllocSize;
values[5] = CFNumberCreate(0, kCFNumberLongType, &allocSize);
CFDictionaryRef dict = CFDictionaryCreate(0, keys, values, 6, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
for (unsigned i = 0; i < 6; i++)
CFRelease(values[i]);
m_frontBuffer = IOSurfaceCreate(dict);
m_backBuffer = IOSurfaceCreate(dict);
if (!(flags & GraphicsSurface::SupportsSharing))
return;
m_token = GraphicsSurfaceToken(IOSurfaceCreateMachPort(m_frontBuffer), IOSurfaceCreateMachPort(m_backBuffer));
}
void CoordinatedGraphicsLayer::setContentsToCanvas(PlatformLayer* platformLayer)
{
#if USE(GRAPHICS_SURFACE)
if (m_canvasPlatformLayer) {
ASSERT(m_canvasToken.isValid());
if (!platformLayer) {
m_pendingCanvasOperation |= DestroyCanvas;
m_pendingCanvasOperation &= ~CreateCanvas;
} else if ((m_canvasSize != platformLayer->platformLayerSize()) || (m_canvasToken != platformLayer->graphicsSurfaceToken())) {
// m_canvasToken can be different to platformLayer->graphicsSurfaceToken(), even if m_canvasPlatformLayer equals platformLayer.
m_pendingCanvasOperation |= RecreateCanvas;
}
} else {
if (platformLayer)
m_pendingCanvasOperation |= CreateAndSyncCanvas;
}
m_canvasPlatformLayer = platformLayer;
// m_canvasToken is updated only here. In detail, when GraphicsContext3D is changed or reshaped, m_canvasToken is changed and setContentsToCanvas() is always called.
m_canvasSize = m_canvasPlatformLayer ? m_canvasPlatformLayer->platformLayerSize() : IntSize();
m_canvasToken = m_canvasPlatformLayer ? m_canvasPlatformLayer->graphicsSurfaceToken() : GraphicsSurfaceToken();
ASSERT(!(!m_canvasToken.isValid() && m_canvasPlatformLayer));
notifyFlushRequired();
#else
UNUSED_PARAM(platformLayer);
#endif
}
bool WebCoordinatedSurface::createHandle(Handle& handle)
{
handle.m_size = m_size;
handle.m_flags = m_flags;
#if USE(GRAPHICS_SURFACE)
handle.m_graphicsSurfaceToken = m_graphicsSurface ? m_graphicsSurface->exportToken() : GraphicsSurfaceToken();
if (handle.m_graphicsSurfaceToken.isValid())
return true;
#endif
if (!m_bitmap->createHandle(handle.m_bitmapHandle))
return false;
return true;
}
void CoordinatedGraphicsLayer::setContentsToPlatformLayer(PlatformLayer* platformLayer, ContentsLayerPurpose)
{
#if USE(GRAPHICS_SURFACE)
if (m_platformLayer) {
ASSERT(m_platformLayerToken.isValid());
if (!platformLayer) {
m_pendingPlatformLayerOperation |= DestroyPlatformLayer;
m_pendingPlatformLayerOperation &= ~CreatePlatformLayer;
} else if ((m_platformLayerSize != platformLayer->platformLayerSize()) || (m_platformLayerToken != platformLayer->graphicsSurfaceToken())) {
// m_platformLayerToken can be different to platformLayer->graphicsSurfaceToken(), even if m_platformLayer equals platformLayer.
m_pendingPlatformLayerOperation |= RecreatePlatformLayer;
}
} else {
if (platformLayer)
m_pendingPlatformLayerOperation |= CreateAndSyncPlatformLayer;
}
m_platformLayer = platformLayer;
// m_platformLayerToken is updated only here.
// In detail, when GraphicsContext3D is changed or reshaped, m_platformLayerToken is changed and setContentsToPlatformLayer() is always called.
m_platformLayerSize = m_platformLayer ? m_platformLayer->platformLayerSize() : IntSize();
m_platformLayerToken = m_platformLayer ? m_platformLayer->graphicsSurfaceToken() : GraphicsSurfaceToken();
ASSERT(!(!m_platformLayerToken.isValid() && m_platformLayer));
notifyFlushRequired();
#elif USE(COORDINATED_GRAPHICS_THREADED)
if (m_platformLayer != platformLayer)
m_shouldSyncPlatformLayer = true;
m_platformLayer = platformLayer;
notifyFlushRequired();
#else
UNUSED_PARAM(platformLayer);
#endif
}
