Skia representation of SharedImageBackingAHardwareBuffer.

Add a GL backed skia representation of
SharedImageBackingAHardwareBuffer. Update unit test.

Bug: 891060
Change-Id: Ib3b458615be13e7a536a12097e8452052b78a14f
Reviewed-on: https://chromium-review.googlesource.com/c/1330205Reviewed-by: Antoine Labour <piman@chromium.org>
Commit-Queue: vikas soni <vikassoni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#607760}

gpu/command_buffer/service/shared_image_backing_factory_ahardwarebuffer.h

@@ -24,13 +24,12 @@ struct Mailbox;
 
 // Implementation of SharedImageBackingFactory that produces AHardwareBuffer
 // backed SharedImages. This is meant to be used on Android only.
-class GPU_GLES2_EXPORT SharedImageBackingFactoryAHardwareBuffer
+class GPU_GLES2_EXPORT SharedImageBackingFactoryAHB
     : public SharedImageBackingFactory {
  public:
-  SharedImageBackingFactoryAHardwareBuffer(
-      const GpuDriverBugWorkarounds& workarounds,
-      const GpuFeatureInfo& gpu_feature_info);
-  ~SharedImageBackingFactoryAHardwareBuffer() override;
+  SharedImageBackingFactoryAHB(const GpuDriverBugWorkarounds& workarounds,
+                               const GpuFeatureInfo& gpu_feature_info);
+  ~SharedImageBackingFactoryAHB() override;
 
   // SharedImageBackingFactory implementation.
   std::unique_ptr<SharedImageBacking> CreateSharedImage(
@@ -72,7 +71,7 @@ class GPU_GLES2_EXPORT SharedImageBackingFactoryAHardwareBuffer
   // Used to limit the max size of AHardwareBuffer.
   int32_t max_gl_texture_size_ = 0;
 
-  DISALLOW_COPY_AND_ASSIGN(SharedImageBackingFactoryAHardwareBuffer);
+  DISALLOW_COPY_AND_ASSIGN(SharedImageBackingFactoryAHB);
 };
 
 }  // namespace gpu

gpu/command_buffer/service/shared_image_backing_factory_ahardwarebuffer_unittest.cc

@@ -8,6 +8,7 @@
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/shared_image_usage.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
+#include "gpu/command_buffer/service/raster_decoder_context_state.h"
 #include "gpu/command_buffer/service/shared_image_backing.h"
 #include "gpu/command_buffer/service/shared_image_factory.h"
 #include "gpu/command_buffer/service/shared_image_manager.h"
@@ -15,16 +16,20 @@
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkImage.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/gpu/GrBackendSurface.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/init/gl_factory.h"
 
 namespace gpu {
 namespace {
 
-class SharedImageBackingFactoryAHardwareBufferTest : public testing::Test {
+class SharedImageBackingFactoryAHBTest : public testing::Test {
  public:
   void SetUp() override {
     // AHardwareBuffer is only supported on ANDROID O+. Hence these tests
@@ -42,9 +47,14 @@ class SharedImageBackingFactoryAHardwareBufferTest : public testing::Test {
 
     GpuDriverBugWorkarounds workarounds;
     workarounds.max_texture_size = INT_MAX - 1;
-    backing_factory_ =
-        std::make_unique<SharedImageBackingFactoryAHardwareBuffer>(
-            workarounds, GpuFeatureInfo());
+    backing_factory_ = std::make_unique<SharedImageBackingFactoryAHB>(
+        workarounds, GpuFeatureInfo());
+
+    scoped_refptr<gl::GLShareGroup> share_group = new gl::GLShareGroup();
+    context_state_ = new raster::RasterDecoderContextState(
+        std::move(share_group), surface_, context_,
+        false /* use_virtualized_gl_contexts */);
+    context_state_->InitializeGrContext(workarounds, nullptr);
 
     memory_type_tracker_ = std::make_unique<MemoryTypeTracker>(nullptr);
     shared_image_representation_factory_ =
@@ -52,10 +62,13 @@ class SharedImageBackingFactoryAHardwareBufferTest : public testing::Test {
             &shared_image_manager_, nullptr);
   }
 
+  GrContext* gr_context() { return context_state_->gr_context; }
+
  protected:
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
-  std::unique_ptr<SharedImageBackingFactoryAHardwareBuffer> backing_factory_;
+  scoped_refptr<raster::RasterDecoderContextState> context_state_;
+  std::unique_ptr<SharedImageBackingFactoryAHB> backing_factory_;
   gles2::MailboxManagerImpl mailbox_manager_;
   SharedImageManager shared_image_manager_;
   std::unique_ptr<MemoryTypeTracker> memory_type_tracker_;
@@ -64,7 +77,7 @@ class SharedImageBackingFactoryAHardwareBufferTest : public testing::Test {
 };
 
 // Basic test to check creation and deletion of AHB backed shared image.
-TEST_F(SharedImageBackingFactoryAHardwareBufferTest, Basic) {
+TEST_F(SharedImageBackingFactoryAHBTest, Basic) {
   if (!base::AndroidHardwareBufferCompat::IsSupportAvailable())
     return;
 
@@ -72,7 +85,11 @@ TEST_F(SharedImageBackingFactoryAHardwareBufferTest, Basic) {
   auto format = viz::ResourceFormat::RGBA_8888;
   gfx::Size size(256, 256);
   auto color_space = gfx::ColorSpace::CreateSRGB();
-  uint32_t usage = SHARED_IMAGE_USAGE_GLES2;
+
+  // SHARED_IMAGE_USAGE_DISPLAY for skia read and SHARED_IMAGE_USAGE_RASTER for
+  // skia write.
+  uint32_t usage = SHARED_IMAGE_USAGE_GLES2 | SHARED_IMAGE_USAGE_RASTER |
+                   SHARED_IMAGE_USAGE_DISPLAY;
   auto backing = backing_factory_->CreateSharedImage(mailbox, format, size,
                                                      color_space, usage);
   EXPECT_TRUE(backing);
@@ -84,7 +101,7 @@ TEST_F(SharedImageBackingFactoryAHardwareBufferTest, Basic) {
   }
 
   // First, validate via a legacy mailbox.
-  GLenum expected_target = GL_TEXTURE_EXTERNAL_OES;
+  GLenum expected_target = GL_TEXTURE_2D;
   EXPECT_TRUE(backing->ProduceLegacyMailbox(&mailbox_manager_));
   TextureBase* texture_base = mailbox_manager_.ConsumeTexture(mailbox);
 
@@ -116,12 +133,115 @@ TEST_F(SharedImageBackingFactoryAHardwareBufferTest, Basic) {
   EXPECT_EQ(usage, gl_representation->usage());
   gl_representation.reset();
 
+  // Finally, validate a SharedImageRepresentationSkia.
+  auto skia_representation =
+      shared_image_representation_factory_->ProduceSkia(mailbox);
+  EXPECT_TRUE(skia_representation);
+  auto surface = skia_representation->BeginWriteAccess(
+      gr_context(), 0, kRGBA_8888_SkColorType,
+      SkSurfaceProps(0, kUnknown_SkPixelGeometry));
+  EXPECT_TRUE(surface);
+  EXPECT_EQ(size.width(), surface->width());
+  EXPECT_EQ(size.height(), surface->height());
+  skia_representation->EndWriteAccess(std::move(surface));
+  GrBackendTexture backend_texture;
+  EXPECT_TRUE(skia_representation->BeginReadAccess(
+
+      kRGBA_8888_SkColorType, &backend_texture));
+  EXPECT_EQ(size.width(), backend_texture.width());
+  EXPECT_EQ(size.width(), backend_texture.width());
+  skia_representation->EndReadAccess();
+  skia_representation.reset();
+
+  factory_ref.reset();
+  EXPECT_FALSE(mailbox_manager_.ConsumeTexture(mailbox));
+}
+
+// Test to check interaction between Gl and skia GL representations.
+// We write to a GL texture using gl representation and then read from skia
+// representation.
+TEST_F(SharedImageBackingFactoryAHBTest, GLSkiaGL) {
+  if (!base::AndroidHardwareBufferCompat::IsSupportAvailable())
+    return;
+
+  // Create a backing using mailbox.
+  auto mailbox = Mailbox::Generate();
+  auto format = viz::ResourceFormat::RGBA_8888;
+  gfx::Size size(1, 1);
+  auto color_space = gfx::ColorSpace::CreateSRGB();
+  uint32_t usage = SHARED_IMAGE_USAGE_GLES2 | SHARED_IMAGE_USAGE_DISPLAY;
+  auto backing = backing_factory_->CreateSharedImage(mailbox, format, size,
+                                                     color_space, usage);
+  EXPECT_TRUE(backing);
+
+  GLenum expected_target = GL_TEXTURE_2D;
+  std::unique_ptr<SharedImageRepresentationFactoryRef> factory_ref =
+      shared_image_manager_.Register(std::move(backing),
+                                     memory_type_tracker_.get());
+
+  // Create a SharedImageRepresentationGLTexture.
+  auto gl_representation =
+      shared_image_representation_factory_->ProduceGLTexture(mailbox);
+  EXPECT_TRUE(gl_representation);
+  EXPECT_EQ(expected_target, gl_representation->GetTexture()->target());
+
+  // Create an FBO.
+  GLuint fbo = 0;
+  gl::GLApi* api = gl::g_current_gl_context;
+  api->glGenFramebuffersEXTFn(1, &fbo);
+  api->glBindFramebufferEXTFn(GL_FRAMEBUFFER, fbo);
+
+  // Attach the texture to FBO.
+  api->glFramebufferTexture2DEXTFn(
+      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+      gl_representation->GetTexture()->target(),
+      gl_representation->GetTexture()->service_id(), 0);
+
+  // Set the clear color to green.
+  api->glClearColorFn(0.0f, 1.0f, 0.0f, 1.0f);
+  api->glClearFn(GL_COLOR_BUFFER_BIT);
+  gl_representation.reset();
+
+  // Next create a SharedImageRepresentationSkia to read back the texture data.
+  auto skia_representation =
+      shared_image_representation_factory_->ProduceSkia(mailbox);
+  EXPECT_TRUE(skia_representation);
+  GrBackendTexture backend_texture;
+  EXPECT_TRUE(skia_representation->BeginReadAccess(kRGBA_8888_SkColorType,
+                                                   &backend_texture));
+  EXPECT_EQ(size.width(), backend_texture.width());
+  EXPECT_EQ(size.width(), backend_texture.width());
+
+  // Create an Sk Image from GrBackendTexture.
+  auto sk_image = SkImage::MakeFromTexture(
+      gr_context(), backend_texture, kTopLeft_GrSurfaceOrigin,
+      kRGBA_8888_SkColorType, kOpaque_SkAlphaType, nullptr);
+
+  SkImageInfo dst_info =
+      SkImageInfo::Make(size.width(), size.height(), kRGBA_8888_SkColorType,
+                        kOpaque_SkAlphaType, nullptr);
+
+  const int num_pixels = size.width() * size.height();
+  std::unique_ptr<uint8_t[]> dst_pixels(new uint8_t[num_pixels * 4]());
+
+  // Read back pixels from Sk Image.
+  EXPECT_TRUE(sk_image->readPixels(dst_info, dst_pixels.get(),
+                                   dst_info.minRowBytes(), 0, 0));
+  skia_representation->EndReadAccess();
+
+  // Compare the pixel values.
+  EXPECT_EQ(dst_pixels[0], 0);
+  EXPECT_EQ(dst_pixels[1], 255);
+  EXPECT_EQ(dst_pixels[2], 0);
+  EXPECT_EQ(dst_pixels[3], 255);
+
+  skia_representation.reset();
   factory_ref.reset();
   EXPECT_FALSE(mailbox_manager_.ConsumeTexture(mailbox));
 }
 
 // Test to check invalid format support.
-TEST_F(SharedImageBackingFactoryAHardwareBufferTest, InvalidFormat) {
+TEST_F(SharedImageBackingFactoryAHBTest, InvalidFormat) {
   if (!base::AndroidHardwareBufferCompat::IsSupportAvailable())
     return;
 
@@ -136,7 +256,7 @@ TEST_F(SharedImageBackingFactoryAHardwareBufferTest, InvalidFormat) {
 }
 
 // Test to check invalid size support.
-TEST_F(SharedImageBackingFactoryAHardwareBufferTest, InvalidSize) {
+TEST_F(SharedImageBackingFactoryAHBTest, InvalidSize) {
   if (!base::AndroidHardwareBufferCompat::IsSupportAvailable())
     return;
 
@@ -155,7 +275,7 @@ TEST_F(SharedImageBackingFactoryAHardwareBufferTest, InvalidSize) {
   EXPECT_FALSE(backing);
 }
 
-TEST_F(SharedImageBackingFactoryAHardwareBufferTest, EstimatedSize) {
+TEST_F(SharedImageBackingFactoryAHBTest, EstimatedSize) {
   if (!base::AndroidHardwareBufferCompat::IsSupportAvailable())
     return;
 

gpu/command_buffer/service/shared_image_factory.cc

@@ -97,7 +97,7 @@ bool SharedImageFactory::CreateSharedImage(const Mailbox& mailbox,
                                            const gfx::ColorSpace& color_space,
                                            uint32_t usage) {
   // TODO(piman): depending on handle.type, choose platform-specific backing
-  // factory, e.g. SharedImageBackingFactoryAHardwareBuffer.
+  // factory, e.g. SharedImageBackingFactoryAHB.
   std::unique_ptr<SharedImageBacking> backing =
       backing_factory_->CreateSharedImage(mailbox, client_id, std::move(handle),
                                           format, surface_handle, size,

gpu/command_buffer/service/texture_manager.h

@@ -37,7 +37,7 @@ class DecoderContext;
 class ServiceDiscardableManager;
 class SharedImageBackingGLTexture;
 class SharedImageBackingFactoryGLTexture;
-class SharedImageBackingAHardwareBuffer;
+class SharedImageBackingAHB;
 class SharedImageRepresentationGLTexture;
 
 namespace gles2 {
@@ -355,7 +355,7 @@ class GPU_GLES2_EXPORT Texture final : public TextureBase {
   friend class MailboxManagerTest;
   friend class gpu::SharedImageBackingGLTexture;
   friend class gpu::SharedImageBackingFactoryGLTexture;
-  friend class gpu::SharedImageBackingAHardwareBuffer;
+  friend class gpu::SharedImageBackingAHB;
   friend class TextureDefinition;
   friend class TextureManager;
   friend class TextureRef;