Refactor AcceleratedStaticBitmapImage

third_party/WebKit/Source/platform/graphics/SkiaTextureHolder.cpp

Index: third_party/WebKit/Source/platform/graphics/SkiaTextureHolder.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/SkiaTextureHolder.cpp b/third_party/WebKit/Source/platform/graphics/SkiaTextureHolder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6999d3f4946f62198b5b0c315ae2428971aaac9
--- /dev/null
+++ b/third_party/WebKit/Source/platform/graphics/SkiaTextureHolder.cpp
@@ -0,0 +1,91 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "platform/graphics/SkiaTextureHolder.h"
+
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "platform/CrossThreadFunctional.h"
+#include "platform/graphics/MailboxTextureHolder.h"
+#include "platform/graphics/gpu/SharedGpuContext.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebTaskRunner.h"
+#include "skia/ext/texture_handle.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+
+namespace blink {
+
+SkiaTextureHolder::SkiaTextureHolder(sk_sp<SkImage> image)
+    : m_image(std::move(image)),
+      m_sharedContextId(SharedGpuContext::contextId()) {}
+
+SkiaTextureHolder::SkiaTextureHolder(
+    std::unique_ptr<TextureHolder> textureHolder) {
+  DCHECK(textureHolder->isMailboxTextureHolder());
+  const gpu::Mailbox mailbox = textureHolder->mailbox();
+  const gpu::SyncToken syncToken = textureHolder->syncToken();
+  const IntSize mailboxSize = textureHolder->size();
+
+  gpu::gles2::GLES2Interface* sharedGL = SharedGpuContext::gl();
+  GrContext* sharedGrContext = SharedGpuContext::gr();
+  DCHECK(sharedGL &&
+         sharedGrContext);  // context isValid already checked in callers
+
+  sharedGL->WaitSyncTokenCHROMIUM(syncToken.GetConstData());
+  GLuint sharedContextTextureId =
+      sharedGL->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+  GrGLTextureInfo textureInfo;
+  textureInfo.fTarget = GL_TEXTURE_2D;
+  textureInfo.fID = sharedContextTextureId;
+  GrBackendTextureDesc backendTexture;
+  backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
+  backendTexture.fWidth = mailboxSize.width();
+  backendTexture.fHeight = mailboxSize.height();
+  backendTexture.fConfig = kSkia8888_GrPixelConfig;
+  backendTexture.fTextureHandle =
+      skia::GrGLTextureInfoToGrBackendObject(textureInfo);
+
+  sk_sp<SkImage> newImage =
+      SkImage::MakeFromAdoptedTexture(sharedGrContext, backendTexture);
+  releaseImageThreadSafe();
+  m_image = newImage;
+  m_sharedContextId = SharedGpuContext::contextId();
+}
+
+SkiaTextureHolder::~SkiaTextureHolder() {
+  releaseImageThreadSafe();
+}
+
+unsigned SkiaTextureHolder::sharedContextId() {
+  return m_sharedContextId;
+}
+
+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 SkiaTextureHolder::releaseImageThreadSafe() {
+  // If m_image belongs to a GrContext that is on another thread, it
+  // must be released on that thread.
+  if (m_imageThreadTaskRunner && m_image &&
+      !m_imageThreadTaskRunner.get()->isCloneOf(
+          Platform::current()->currentThread()->getWebTaskRunner()) &&

[xidachen, 2016/11/04 02:23:35]

haraken@: The problem is in here. Let's give an example, suppose the m_image in
this class was created on a worker thread, and now we are back to the main
thread. We want to release that m_image which could be gpu texture backed. The
way to release it is to go back to the worker thread and delete the texture.

However, suppose the m_image was created on the main thread and currently we are
still on the main thread, then we don't need anything inside here, all we need
to do is set m_image = nullptr.

So we need a logic to tell us whether the current thread is the same as the
thread where m_image was created. Since m_imageThreadTaskRunner is a clone, we
need some kind of API to tell whether m_imageThreadTaskRunner is a clone of
currentThread()->getWebTaskRunner() or not. Does that make sense?

The other possible way is to keep a WebThread* m_imageThread to tell which
thread the m_image was created. However, it seems to be a bit dangerous. Because
m_image could be created on a worker thread, and when we are back to the main
thread, the worker thread could have gone out of scope, then the m_imageThread
will point to some undefined memory, is that correct?

+      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_imageThreadTaskRunner->postTask(
+        BLINK_FROM_HERE,
+        crossThreadBind(&releaseImage, passed(std::move(m_image)),
+                        passed(std::move(releaseSyncToken))));
+  }
+  m_image = nullptr;
+  m_imageThreadTaskRunner = nullptr;
+}
+
+}  // namespace blink