GraphicsContext* ImageBuffer::context() const
{
if (!isSurfaceValid())
return 0;
ASSERT(m_context.get());
return m_context.get();
}
void ImageBuffer::putByteArray(Multiply multiplied, const unsigned char* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
{
if (!isSurfaceValid())
return;
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
int originX = sourceRect.x();
int destX = destPoint.x() + sourceRect.x();
ASSERT(destX >= 0);
ASSERT(destX < m_surface->size().width());
ASSERT(originX >= 0);
ASSERT(originX < sourceRect.maxX());
int originY = sourceRect.y();
int destY = destPoint.y() + sourceRect.y();
ASSERT(destY >= 0);
ASSERT(destY < m_surface->size().height());
ASSERT(originY >= 0);
ASSERT(originY < sourceRect.maxY());
const size_t srcBytesPerRow = 4 * sourceSize.width();
const void* srcAddr = source + originY * srcBytesPerRow + originX * 4;
SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
SkImageInfo info = SkImageInfo::Make(sourceRect.width(), sourceRect.height(), kRGBA_8888_SkColorType, alphaType);
m_surface->writePixels(info, srcAddr, srcBytesPerRow, destX, destY);
}
void ImageBuffer::transformColorSpace(ColorSpace srcColorSpace, ColorSpace dstColorSpace)
{
const uint8_t* lookUpTable = ColorSpaceUtilities::getConversionLUT(dstColorSpace, srcColorSpace);
if (!lookUpTable)
return;
// FIXME: Disable color space conversions on accelerated canvases (for now).
if (context()->isAccelerated() || !isSurfaceValid())
return;
const SkBitmap& bitmap = m_surface->bitmap();
if (bitmap.isNull())
return;
ASSERT(bitmap.colorType() == kN32_SkColorType);
IntSize size = m_surface->size();
SkAutoLockPixels bitmapLock(bitmap);
for (int y = 0; y < size.height(); ++y) {
uint32_t* srcRow = bitmap.getAddr32(0, y);
for (int x = 0; x < size.width(); ++x) {
SkColor color = SkPMColorToColor(srcRow[x]);
srcRow[x] = SkPreMultiplyARGB(
SkColorGetA(color),
lookUpTable[SkColorGetR(color)],
lookUpTable[SkColorGetG(color)],
lookUpTable[SkColorGetB(color)]);
}
}
}
void Movie::initFromMovieFile(const Common::String &fileName, bool transparent) {
_transparent = transparent;
releaseMovie();
_video = new Video::QuickTimeDecoder();
if (!_video->loadFile(fileName)) {
// Replace any colon with an underscore, since only Mac OS X
// supports that. See PegasusEngine::detectOpeningClosingDirectory()
// for more info.
Common::String newName(fileName);
if (newName.contains(':'))
for (uint i = 0; i < newName.size(); i++)
if (newName[i] == ':')
newName.setChar('_', i);
if (!_video->loadFile(newName))
error("Could not load video '%s'", fileName.c_str());
}
Common::Rect bounds(0, 0, _video->getWidth(), _video->getHeight());
sizeElement(_video->getWidth(), _video->getHeight());
_movieBox = bounds;
if (!isSurfaceValid())
allocateSurface(bounds);
setStart(0, getScale());
TimeBase::setStop(_video->getDuration().convertToFramerate(getScale()).totalNumberOfFrames(), getScale());
}
bool ImageBuffer::copyToPlatformTexture(WebGraphicsContext3D* context, Platform3DObject texture, GLenum internalFormat, GLenum destType, GLint level, bool premultiplyAlpha, bool flipY)
{
if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(GL_TEXTURE_2D, internalFormat, destType, level))
return false;
if (!isSurfaceValid())
return false;
RefPtr<const SkImage> textureImage = m_surface->newImageSnapshot(PreferAcceleration);
if (!textureImage)
return false;
if (!m_surface->isAccelerated())
return false;
ASSERT(textureImage->isTextureBacked()); // isAccelerated() check above should guarantee this
// Get the texture ID, flushing pending operations if needed.
Platform3DObject textureId = textureImage->getTextureHandle(true);
if (!textureId)
return false;
OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
if (!provider)
return false;
WebGraphicsContext3D* sharedContext = provider->context3d();
if (!sharedContext)
return false;
OwnPtr<WebExternalTextureMailbox> mailbox = adoptPtr(new WebExternalTextureMailbox);
// Contexts may be in a different share group. We must transfer the texture through a mailbox first
sharedContext->genMailboxCHROMIUM(mailbox->name);
sharedContext->produceTextureDirectCHROMIUM(textureId, GL_TEXTURE_2D, mailbox->name);
sharedContext->flush();
mailbox->validSyncToken = sharedContext->insertSyncPoint(mailbox->syncToken);
if (mailbox->validSyncToken)
context->waitSyncToken(mailbox->syncToken);
Platform3DObject sourceTexture = context->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox->name);
// The canvas is stored in a premultiplied format, so unpremultiply if necessary.
// The canvas is stored in an inverted position, so the flip semantics are reversed.
context->copyTextureCHROMIUM(GL_TEXTURE_2D, sourceTexture, texture, internalFormat, destType, flipY ? GL_FALSE : GL_TRUE, GL_FALSE, premultiplyAlpha ? GL_FALSE : GL_TRUE);
context->deleteTexture(sourceTexture);
context->flush();
WGC3Dbyte syncToken[24];
if (context->insertSyncPoint(syncToken))
sharedContext->waitSyncToken(syncToken);
// Undo grContext texture binding changes introduced in this function
provider->grContext()->resetContext(kTextureBinding_GrGLBackendState);
return true;
}
void ImageBuffer::draw(GraphicsContext& context, const FloatRect& destRect, const FloatRect* srcPtr, SkXfermode::Mode op)
{
if (!isSurfaceValid())
return;
FloatRect srcRect = srcPtr ? *srcPtr : FloatRect(FloatPoint(), FloatSize(size()));
m_surface->draw(context, destRect, srcRect, op);
}
PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior) const
{
if (!isSurfaceValid())
return BitmapImage::create(NativeImageSkia::create());
const SkBitmap& bitmap = m_surface->bitmap();
return BitmapImage::create(NativeImageSkia::create(copyBehavior == CopyBackingStore ? deepSkBitmapCopy(bitmap) : bitmap));
}
PassRefPtr<SkImage> ImageBuffer::newSkImageSnapshot() const
{
if (m_snapshotState == InitialSnapshotState)
m_snapshotState = DidAcquireSnapshot;
if (!isSurfaceValid())
return nullptr;
return m_surface->newImageSnapshot();
}
PassRefPtr<Image> ImageBuffer::newImageSnapshot() const
{
if (!isSurfaceValid())
return nullptr;
RefPtr<SkImage> snapshot = m_surface->newImageSnapshot();
if (!snapshot)
return nullptr;
return StaticBitmapImage::create(snapshot);
}
PassRefPtr<SkImage> ImageBuffer::newSkImageSnapshot(AccelerationHint hint, SnapshotReason reason) const
{
if (m_snapshotState == InitialSnapshotState)
m_snapshotState = DidAcquireSnapshot;
if (!isSurfaceValid())
return nullptr;
return m_surface->newImageSnapshot(hint, reason);
}
static void nativeAllocateBuffers(JNIEnv* /* env */ , jclass /* clazz */,
jlong nativeObject) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
return;
}
surface->allocateBuffers();
}
void PixelImage::drawImage(const Common::Rect &sourceBounds, const Common::Rect &destBounds) {
if (!isSurfaceValid())
return;
// Draw from sourceBounds to destBounds based on _transparent
if (_transparent)
copyToCurrentPortTransparent(sourceBounds, destBounds);
else
copyToCurrentPort(sourceBounds, destBounds);
}
void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const FloatSize& scale,
const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect, WebBlendMode blendMode, const IntSize& repeatSpacing)
{
if (!isSurfaceValid())
return;
const SkBitmap& bitmap = m_surface->bitmap();
RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
image->drawPattern(context, srcRect, scale, phase, op, destRect, blendMode, repeatSpacing);
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage;
if (!isSurfaceValid() || !encodeImage(m_surface->bitmap(), mimeType, quality, &encodedImage))
return "data:,";
return "data:" + mimeType + ";base64," + base64Encode(encodedImage);
}
static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(sur)) {
doThrowIAE(env);
return JNI_FALSE;
}
int value = 0;
ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get());
anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
return value;
}
static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject canvasObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
return;
}
// detach the canvas from the surface
env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap, (jlong)0);
// unlock surface
status_t err = surface->unlockAndPost();
if (err < 0) {
doThrowIAE(env);
}
}
bool ImageBuffer::copyToPlatformTexture(WebGraphicsContext3D* context, Platform3DObject texture, GLenum internalFormat, GLenum destType, GLint level, bool premultiplyAlpha, bool flipY)
{
if (!m_surface->isAccelerated() || !getBackingTexture() || !isSurfaceValid())
return false;
if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(internalFormat, destType, level))
return false;
OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
if (!provider)
return false;
WebGraphicsContext3D* sharedContext = provider->context3d();
if (!sharedContext)
return false;
OwnPtr<WebExternalTextureMailbox> mailbox = adoptPtr(new WebExternalTextureMailbox);
// Contexts may be in a different share group. We must transfer the texture through a mailbox first
sharedContext->genMailboxCHROMIUM(mailbox->name);
sharedContext->produceTextureDirectCHROMIUM(getBackingTexture(), GL_TEXTURE_2D, mailbox->name);
sharedContext->flush();
mailbox->syncPoint = sharedContext->insertSyncPoint();
context->waitSyncPoint(mailbox->syncPoint);
Platform3DObject sourceTexture = context->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox->name);
// The canvas is stored in a premultiplied format, so unpremultiply if necessary.
context->pixelStorei(GC3D_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, !premultiplyAlpha);
// The canvas is stored in an inverted position, so the flip semantics are reversed.
context->pixelStorei(GC3D_UNPACK_FLIP_Y_CHROMIUM, !flipY);
context->copyTextureCHROMIUM(GL_TEXTURE_2D, sourceTexture, texture, level, internalFormat, destType);
context->pixelStorei(GC3D_UNPACK_FLIP_Y_CHROMIUM, false);
context->pixelStorei(GC3D_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, false);
context->deleteTexture(sourceTexture);
context->flush();
sharedContext->waitSyncPoint(context->insertSyncPoint());
// Undo grContext texture binding changes introduced in this function
provider->grContext()->resetContext(kTextureBinding_GrGLBackendState);
return true;
}
static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject canvasObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
return;
}
// detach the canvas from the surface
Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
nativeCanvas->setBitmap(SkBitmap());
// unlock surface
status_t err = surface->unlockAndPost();
if (err < 0) {
doThrowIAE(env);
}
}
static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject canvasObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
return;
}
// detach the canvas from the surface
SkCanvas* nativeCanvas = SkNEW(SkCanvas);
swapCanvasPtr(env, canvasObj, nativeCanvas);
// unlock surface
status_t err = surface->unlockAndPost();
if (err < 0) {
doThrowIAE(env);
}
}
bool ImageBuffer::getImageData(Multiply multiplied, const IntRect& rect, WTF::ArrayBufferContents& contents) const
{
CheckedNumeric<int> dataSize = 4;
dataSize *= rect.width();
dataSize *= rect.height();
if (!dataSize.IsValid())
return false;
if (!isSurfaceValid()) {
size_t allocSizeInBytes = rect.width() * rect.height() * 4;
void* data;
WTF::ArrayBufferContents::allocateMemoryOrNull(allocSizeInBytes, WTF::ArrayBufferContents::ZeroInitialize, data);
if (!data)
return false;
WTF::ArrayBufferContents result(data, allocSizeInBytes, WTF::ArrayBufferContents::NotShared);
result.transfer(contents);
return true;
}
DCHECK(canvas());
RefPtr<SkImage> snapshot = m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonGetImageData);
if (!snapshot)
return false;
const bool mayHaveStrayArea =
m_surface->isAccelerated() // GPU readback may fail silently
|| rect.x() < 0
|| rect.y() < 0
|| rect.maxX() > m_surface->size().width()
|| rect.maxY() > m_surface->size().height();
size_t allocSizeInBytes = rect.width() * rect.height() * 4;
void* data;
WTF::ArrayBufferContents::InitializationPolicy initializationPolicy = mayHaveStrayArea ? WTF::ArrayBufferContents::ZeroInitialize : WTF::ArrayBufferContents::DontInitialize;
WTF::ArrayBufferContents::allocateMemoryOrNull(allocSizeInBytes, initializationPolicy, data);
if (!data)
return false;
WTF::ArrayBufferContents result(data, allocSizeInBytes, WTF::ArrayBufferContents::NotShared);
SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), kRGBA_8888_SkColorType, alphaType);
snapshot->readPixels(info, result.data(), 4 * rect.width(), rect.x(), rect.y());
result.transfer(contents);
return true;
}
static void nativeSetDirtyRect(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject dirtyRect) {
#ifdef QCOM_BSP
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
doThrowIAE(env);
return;
}
Rect rect;
rect.left = env->GetIntField(dirtyRect, gRectClassInfo.left);
rect.top = env->GetIntField(dirtyRect, gRectClassInfo.top);
rect.right = env->GetIntField(dirtyRect, gRectClassInfo.right);
rect.bottom = env->GetIntField(dirtyRect, gRectClassInfo.bottom);
surface->setDirtyRect(&rect);
#endif
}
bool ImageBuffer::getImageData(Multiply multiplied, const IntRect& rect, WTF::ArrayBufferContents& contents) const
{
Checked<int, RecordOverflow> dataSize = 4;
dataSize *= rect.width();
dataSize *= rect.height();
if (dataSize.hasOverflowed())
return false;
if (!isSurfaceValid()) {
WTF::ArrayBufferContents result(rect.width() * rect.height(), 4, WTF::ArrayBufferContents::NotShared, WTF::ArrayBufferContents::ZeroInitialize);
result.transfer(contents);
return true;
}
ASSERT(canvas());
RefPtr<SkImage> snapshot = m_surface->newImageSnapshot(PreferNoAcceleration);
if (!snapshot)
return false;
const bool mayHaveStrayArea =
m_surface->isAccelerated() // GPU readback may fail silently
|| rect.x() < 0
|| rect.y() < 0
|| rect.maxX() > m_surface->size().width()
|| rect.maxY() > m_surface->size().height();
WTF::ArrayBufferContents result(
rect.width() * rect.height(), 4,
WTF::ArrayBufferContents::NotShared,
mayHaveStrayArea
? WTF::ArrayBufferContents::ZeroInitialize
: WTF::ArrayBufferContents::DontInitialize);
SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), kRGBA_8888_SkColorType, alphaType);
snapshot->readPixels(info, result.data(), 4 * rect.width(), rect.x(), rect.y());
result.transfer(contents);
return true;
}
void ImageBuffer::draw(GraphicsContext* context, const FloatRect& destRect, const FloatRect* srcPtr, CompositeOperator op, WebBlendMode blendMode)
{
if (!isSurfaceValid())
return;
FloatRect srcRect = srcPtr ? *srcPtr : FloatRect(FloatPoint(), size());
RefPtr<SkPicture> picture = m_surface->getPicture();
if (picture) {
context->drawPicture(picture.get(), destRect, srcRect, op, blendMode);
return;
}
SkBitmap bitmap = m_surface->bitmap();
// For ImageBufferSurface that enables cachedBitmap, Use the cached Bitmap for CPU side usage
// if it is available, otherwise generate and use it.
if (!context->isAccelerated() && m_surface->isAccelerated() && m_surface->cachedBitmapEnabled() && isSurfaceValid()) {
m_surface->updateCachedBitmapIfNeeded();
bitmap = m_surface->cachedBitmap();
}
RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
context->drawImage(image.get(), destRect, srcRect, op, blendMode, DoNotRespectImageOrientation);
}
PassRefPtr<Uint8ClampedArray> ImageBuffer::getImageData(Multiply multiplied, const IntRect& rect) const
{
if (!isSurfaceValid())
return Uint8ClampedArray::create(rect.width() * rect.height() * 4);
float area = 4.0f * rect.width() * rect.height();
if (area > static_cast<float>(std::numeric_limits<int>::max()))
return nullptr;
RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::createUninitialized(rect.width() * rect.height() * 4);
if (rect.x() < 0
|| rect.y() < 0
|| rect.maxX() > m_surface->size().width()
|| rect.maxY() > m_surface->size().height())
result->zeroFill();
SkAlphaType alphaType = (multiplied == Premultiplied) ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), kRGBA_8888_SkColorType, alphaType);
m_surface->willAccessPixels();
context()->readPixels(info, result->data(), 4 * rect.width(), rect.x(), rect.y());
return result.release();
}
PassRefPtr<SkImage> ImageBuffer::newSkImageSnapshot() const
{
if (!isSurfaceValid())
return nullptr;
return m_surface->newImageSnapshot();
}
static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
if (!isSurfaceValid(surface)) {
doThrowIAE(env);
return 0;
}
Rect dirtyRect;
Rect* dirtyRectPtr = NULL;
if (dirtyRectObj) {
dirtyRect.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
dirtyRect.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
dirtyRect.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
dirtyRectPtr = &dirtyRect;
}
ANativeWindow_Buffer outBuffer;
status_t err = surface->lock(&outBuffer, dirtyRectPtr);
if (err < 0) {
const char* const exception = (err == NO_MEMORY) ?
OutOfResourcesException :
"java/lang/IllegalArgumentException";
jniThrowException(env, exception, NULL);
return 0;
}
// Associate a SkCanvas object to this surface
env->SetIntField(canvasObj, gCanvasClassInfo.mSurfaceFormat, outBuffer.format);
SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height,
convertPixelFormat(outBuffer.format),
kPremul_SkAlphaType);
if (outBuffer.format == PIXEL_FORMAT_RGBX_8888) {
info.fAlphaType = kOpaque_SkAlphaType;
}
SkBitmap bitmap;
ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
bitmap.setInfo(info, bpr);
if (outBuffer.width > 0 && outBuffer.height > 0) {
bitmap.setPixels(outBuffer.bits);
} else {
// be safe with an empty bitmap.
bitmap.setPixels(NULL);
}
env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap,
reinterpret_cast<jlong>(&bitmap));
if (dirtyRectPtr) {
SkCanvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
nativeCanvas->clipRect( SkRect::Make(reinterpret_cast<const SkIRect&>(dirtyRect)) );
}
if (dirtyRectObj) {
env->SetIntField(dirtyRectObj, gRectClassInfo.left, dirtyRect.left);
env->SetIntField(dirtyRectObj, gRectClassInfo.top, dirtyRect.top);
env->SetIntField(dirtyRectObj, gRectClassInfo.right, dirtyRect.right);
env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);
}
// Create another reference to the surface and return it. This reference
// should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,
// because the latter could be replaced while the surface is locked.
sp<Surface> lockedSurface(surface);
lockedSurface->incStrong(&sRefBaseOwner);
return (jlong) lockedSurface.get();
}
static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
}
SkCanvas* ImageBuffer::canvas() const
{
if (!isSurfaceValid())
return nullptr;
return m_surface->canvas();
}
bool ImageBuffer::copyToPlatformTexture(gpu::gles2::GLES2Interface* gl, GLuint texture, GLenum internalFormat, GLenum destType, GLint level, bool premultiplyAlpha, bool flipY)
{
if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(GL_TEXTURE_2D, internalFormat, destType, level))
return false;
if (!isSurfaceValid())
return false;
RefPtr<const SkImage> textureImage = m_surface->newImageSnapshot(PreferAcceleration, SnapshotReasonCopyToWebGLTexture);
if (!textureImage)
return false;
if (!m_surface->isAccelerated())
return false;
ASSERT(textureImage->isTextureBacked()); // isAccelerated() check above should guarantee this
// Get the texture ID, flushing pending operations if needed.
const GrGLTextureInfo* textureInfo = skia::GrBackendObjectToGrGLTextureInfo(textureImage->getTextureHandle(true));
if (!textureInfo || !textureInfo->fID)
return false;
std::unique_ptr<WebGraphicsContext3DProvider> provider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
if (!provider)
return false;
gpu::gles2::GLES2Interface* sharedGL = provider->contextGL();
std::unique_ptr<WebExternalTextureMailbox> mailbox = wrapUnique(new WebExternalTextureMailbox);
mailbox->textureSize = WebSize(textureImage->width(), textureImage->height());
// Contexts may be in a different share group. We must transfer the texture through a mailbox first
sharedGL->GenMailboxCHROMIUM(mailbox->name);
sharedGL->ProduceTextureDirectCHROMIUM(textureInfo->fID, textureInfo->fTarget, mailbox->name);
const GLuint64 sharedFenceSync = sharedGL->InsertFenceSyncCHROMIUM();
sharedGL->Flush();
sharedGL->GenSyncTokenCHROMIUM(sharedFenceSync, mailbox->syncToken);
mailbox->validSyncToken = true;
gl->WaitSyncTokenCHROMIUM(mailbox->syncToken);
GLuint sourceTexture = gl->CreateAndConsumeTextureCHROMIUM(textureInfo->fTarget, mailbox->name);
// The canvas is stored in a premultiplied format, so unpremultiply if necessary.
// The canvas is stored in an inverted position, so the flip semantics are reversed.
gl->CopyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY ? GL_FALSE : GL_TRUE, GL_FALSE, premultiplyAlpha ? GL_FALSE : GL_TRUE);
gl->DeleteTextures(1, &sourceTexture);
const GLuint64 contextFenceSync = gl->InsertFenceSyncCHROMIUM();
gl->Flush();
GLbyte syncToken[24];
gl->GenSyncTokenCHROMIUM(contextFenceSync, syncToken);
sharedGL->WaitSyncTokenCHROMIUM(syncToken);
// Undo grContext texture binding changes introduced in this function
provider->grContext()->resetContext(kTextureBinding_GrGLBackendState);
return true;
}