Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(134)

Unified Diff: third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp

Issue 2300633004: Allow canvases to be GPU-accelerated in Workers (Closed)
Patch Set: test expectation Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp b/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
index c572b79a3a5b4552538ef754a612b11024fea9a7..28b72be0fd4be892ea2765f5bd3bf0ca5b1f087d 100644
--- a/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
+++ b/third_party/WebKit/Source/platform/graphics/AcceleratedStaticBitmapImage.cpp
@@ -6,10 +6,13 @@
#include "gpu/command_buffer/client/gles2_interface.h"
#include "gpu/command_buffer/common/sync_token.h"
+#include "platform/CrossThreadFunctional.h"
#include "platform/graphics/StaticBitmapImage.h"
+#include "platform/graphics/gpu/SharedGpuContext.h"
#include "platform/graphics/skia/SkiaUtils.h"
#include "public/platform/Platform.h"
#include "public/platform/WebGraphicsContext3DProvider.h"
+#include "public/platform/WebTaskRunner.h"
#include "skia/ext/texture_handle.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/gpu/GrContext.h"
@@ -20,37 +23,50 @@
namespace blink {
-PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::create(sk_sp<SkImage> image)
+PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::createFromSharedContextImage(sk_sp<SkImage> image)
{
return adoptRef(new AcceleratedStaticBitmapImage(std::move(image)));
}
-PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::create(sk_sp<SkImage> image, sk_sp<GrContext> grContext, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
+PassRefPtr<AcceleratedStaticBitmapImage> AcceleratedStaticBitmapImage::createFromWebGLContextImage(sk_sp<SkImage> image, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
{
- return adoptRef(new AcceleratedStaticBitmapImage(std::move(image), std::move(grContext), mailbox, syncToken));
+ return adoptRef(new AcceleratedStaticBitmapImage(std::move(image), mailbox, syncToken));
}
AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image)
: StaticBitmapImage(std::move(image))
- , m_imageIsForSharedMainThreadContext(true)
+ , m_sharedContextId(SharedGpuContext::contextId())
{
+ m_threadChecker.DetachFromThread();
}
-AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image, sk_sp<GrContext> grContext, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
+AcceleratedStaticBitmapImage::AcceleratedStaticBitmapImage(sk_sp<SkImage> image, const gpu::Mailbox& mailbox, const gpu::SyncToken& syncToken)
: StaticBitmapImage(std::move(image))
- , m_imageIsForSharedMainThreadContext(false) // TODO(danakj): Could be true though, caller would know.
- , m_grContext(std::move(grContext))
+ , m_sharedContextId(SharedGpuContext::kNoSharedContext)
, m_hasMailbox(true)
, m_mailbox(mailbox)
, m_syncToken(syncToken)
{
- DCHECK(m_grContext);
+ m_threadChecker.DetachFromThread();
+
+ // Note: In this case, m_image is not usable directly because it is not in the shared context.
+ // It is just used to hold a reference to the texture object in the origin context until the
+ // mailbox can be consumed.
}
-AcceleratedStaticBitmapImage::~AcceleratedStaticBitmapImage() = default;
+AcceleratedStaticBitmapImage::~AcceleratedStaticBitmapImage()
+{
+ // Avoid leaking mailboxes in cases where the texture gets recycled by skia.
+ if (m_hasMailbox && SharedGpuContext::isValid())
+ SharedGpuContext::gl()->ProduceTextureDirectCHROMIUM(0, GL_TEXTURE_2D, m_mailbox.name);
+ releaseImageThreadSafe();
+}
void AcceleratedStaticBitmapImage::copyToTexture(WebGraphicsContext3DProvider* destProvider, GLuint destTextureId, GLenum internalFormat, GLenum destType, bool flipY)
{
+ checkThread();
+ if (!isValid())
+ return;
// |destProvider| may not be the same context as the one used for |m_image| so we use a mailbox to
// generate a texture id for |destProvider| to access.
ensureMailbox();
@@ -66,26 +82,49 @@ void AcceleratedStaticBitmapImage::copyToTexture(WebGraphicsContext3DProvider* d
sk_sp<SkImage> AcceleratedStaticBitmapImage::imageForCurrentFrame()
{
- // This must return an SkImage that can be used with the shared main thread context. If |m_image| satisfies that, we are done.
- if (m_imageIsForSharedMainThreadContext)
- return m_image;
+ checkThread();
+ if (!isValid())
+ return nullptr;
+ createImageFromMailboxIfNeeded();
+ return m_image;
+}
+
+void AcceleratedStaticBitmapImage::draw(SkCanvas* canvas, const SkPaint& paint, const FloatRect& dstRect, const FloatRect& srcRect, RespectImageOrientationEnum respectImageOrientation, ImageClampingMode imageClampingMode)
+{
+ checkThread();
+ if (!isValid())
+ return;
+ createImageFromMailboxIfNeeded();
+ StaticBitmapImage::draw(canvas, paint, dstRect, srcRect, respectImageOrientation, imageClampingMode);
+}
- // TODO(xidachen): make this work on a worker thread.
- DCHECK(isMainThread());
+bool AcceleratedStaticBitmapImage::isValid()
+{
+ if (!m_image)
+ return false;
+ if (!SharedGpuContext::isValid())
+ return false; // Gpu context was lost
+ if (imageBelongsToSharedContext() && m_sharedContextId != SharedGpuContext::contextId())
+ return false; // Gpu context was lost an restored since resource was created
+ return true;
+}
- // If the SkImage came from any other context than the shared main thread one, we expect to be given a mailbox at construction. We
- // use the mailbox to generate a texture id for the shared main thread context to use.
- DCHECK(m_hasMailbox);
+bool AcceleratedStaticBitmapImage::imageBelongsToSharedContext()
+{
+ return m_sharedContextId != SharedGpuContext::kNoSharedContext;
+}
- auto sharedMainThreadContextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
- gpu::gles2::GLES2Interface* sharedGL = sharedMainThreadContextProvider->contextGL();
- GrContext* sharedGrContext = sharedMainThreadContextProvider->grContext();
- if (!sharedGrContext)
- return nullptr; // Can happen if the context is lost, the SkImage won't be any good now anyway.
+void AcceleratedStaticBitmapImage::createImageFromMailboxIfNeeded()
+{
+ if (imageBelongsToSharedContext())
+ return;
+ DCHECK(m_hasMailbox);
+ gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+ GrContext* sharedGrContext = SharedGpuContext::gr();
+ DCHECK(sharedGL && sharedGrContext); // context isValid already checked in callers
sharedGL->WaitSyncTokenCHROMIUM(m_syncToken.GetData());
GLuint sharedContextTextureId = sharedGL->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, m_mailbox.name);
-
GrGLTextureInfo textureInfo;
textureInfo.fTarget = GL_TEXTURE_2D;
textureInfo.fID = sharedContextTextureId;
@@ -96,11 +135,11 @@ sk_sp<SkImage> AcceleratedStaticBitmapImage::imageForCurrentFrame()
backendTexture.fConfig = kSkia8888_GrPixelConfig;
backendTexture.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(textureInfo);
- m_image = SkImage::MakeFromAdoptedTexture(sharedGrContext, backendTexture);
- m_imageIsForSharedMainThreadContext = true;
- // Can drop the ref on the GrContext since m_image is now backed by a texture from the shared main thread context.
- m_grContext = nullptr;
- return m_image;
+ sk_sp<SkImage> newImage = SkImage::MakeFromAdoptedTexture(sharedGrContext, backendTexture);
+ releaseImageThreadSafe();
+ m_image = newImage;
+
+ m_sharedContextId = SharedGpuContext::contextId();
}
void AcceleratedStaticBitmapImage::ensureMailbox()
@@ -108,15 +147,12 @@ void AcceleratedStaticBitmapImage::ensureMailbox()
if (m_hasMailbox)
return;
- // If we weren't given a mailbox at creation, then we were given a SkImage that is assumed to be from the shared main thread context.
- DCHECK(m_imageIsForSharedMainThreadContext);
- auto sharedMainThreadContextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+ DCHECK(m_image);
- gpu::gles2::GLES2Interface* sharedGL = sharedMainThreadContextProvider->contextGL();
- GrContext* sharedGrContext = sharedMainThreadContextProvider->grContext();
+ gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+ GrContext* sharedGrContext = SharedGpuContext::gr();
if (!sharedGrContext)
return; // Can happen if the context is lost, the SkImage won't be any good now anyway.
-
GLuint imageTextureId = skia::GrBackendObjectToGrGLTextureInfo(m_image->getTextureHandle(true))->fID;
sharedGL->BindTexture(GL_TEXTURE_2D, imageTextureId);
@@ -133,4 +169,49 @@ void AcceleratedStaticBitmapImage::ensureMailbox()
m_hasMailbox = true;
}
+void AcceleratedStaticBitmapImage::transfer()
+{
+ checkThread();
+ ensureMailbox();
+ m_sharedContextId = SharedGpuContext::kNoSharedContext;
+ // If image thread is set, it means that the image has been consumed on the current thread,
+ // which may happen when we have chained transfers. When that is the case, we must not
+ // reset m_imageThread to ensure that releaseImage is called on the right thread.
+ if (!m_imageThread)
+ m_imageThread = Platform::current()->currentThread();
+ m_detachThreadAtNextCheck = true;
+}
+
+void AcceleratedStaticBitmapImage::checkThread()
+{
+ if (m_detachThreadAtNextCheck) {
+ m_threadChecker.DetachFromThread();
+ m_detachThreadAtNextCheck = false;
+ }
+ CHECK(m_threadChecker.CalledOnValidThread());
+}
+
+void releaseImage(sk_sp<SkImage>&& image, std::unique_ptr<gpu::SyncToken>&& syncToken)
+{
+ if (SharedGpuContext::isValid() && syncToken->HasData())
+ SharedGpuContext::gl()->WaitSyncTokenCHROMIUM(syncToken->GetData());
+ image.reset();
+}
+
+void AcceleratedStaticBitmapImage::releaseImageThreadSafe()
+{
+ // If m_image belongs to a GrContext that is on another thread, it
+ // must be released on that thread.
+ if (m_imageThread && m_image && m_imageThread != Platform::current()->currentThread() && SharedGpuContext::isValid()) {
+ gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+ std::unique_ptr<gpu::SyncToken> releaseSyncToken(new gpu::SyncToken);
+ const GLuint64 fenceSync = sharedGL->InsertFenceSyncCHROMIUM();
+ sharedGL->Flush();
+ sharedGL->GenSyncTokenCHROMIUM(fenceSync, releaseSyncToken->GetData());
+ m_imageThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, crossThreadBind(&releaseImage, passed(std::move(m_image)), passed(std::move(releaseSyncToken))));
+ }
+ m_image = nullptr;
+ m_imageThread = nullptr;
+}
+
} // namespace blink

Powered by Google App Engine
This is Rietveld 408576698