Accept framebuffer size in CreateGpuMemoryBuffer()

This CL extends the GpuMemoryBufferFactory interface to allow
CreateGpuMemoryBuffer() to take a framebuffer size. This is so that we
can take advantage of the framebuffer_size parameter in the
SurfaceFactoryOzone::CreateNativePixmap() argument. This is useful in
Chrome OS to be able to allocate a buffer of a specific size while
adding a DRM framebuffer of a different size. For example, suppose a
hardware video decoder needs buffers of size 640x368 to decode a video
whose visible rectangle is 640x360. In this case, the size of the DRM
framebuffer should be 640x360 so that the display controller doesn't
sample non-visible data if the video gets promoted to a hardware
overlay.

The extended API is needed because the new direct VD uses a
GpuMemoryBufferFactory to allocate native buffers. It is only needed
within the GPU process (it doesn't need to be exposed to clients). The
extended API is used in CL:2340115.

Bug: b:162880731
Test: None.
Change-Id: Idf0c13e598fe730098424458af7515a320e6d511
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2340069Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Reviewed-by: Peng Huang <penghuang@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Commit-Queue: Andres Calderon Jaramillo <andrescj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798995}

components/viz/service/display_embedder/in_process_gpu_memory_buffer_manager.cc

@@ -60,7 +60,8 @@ InProcessGpuMemoryBufferManager::CreateGpuMemoryBuffer(
   gfx::GpuMemoryBufferId id(next_gpu_memory_id_++);
   gfx::GpuMemoryBufferHandle buffer_handle =
       gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
-          id, size, format, usage, client_id_, surface_handle);
+          id, size, /*framebuffer_size=*/size, format, usage, client_id_,
+          surface_handle);
 
   AllocatedBufferInfo buffer_info(buffer_handle, size, format);
 

gpu/ipc/service/gpu_memory_buffer_factory.cc

@@ -54,8 +54,9 @@ void GpuMemoryBufferFactory::CreateGpuMemoryBufferAsync(
     CreateGpuMemoryBufferAsyncCallback callback) {
   // By default, we assume it's ok to allocate GMBs synchronously on the IO
   // thread. However, subclasses can override this assumption.
-  std::move(callback).Run(CreateGpuMemoryBuffer(id, size, format, usage,
-                                                client_id, surface_handle));
+  std::move(callback).Run(
+      CreateGpuMemoryBuffer(id, size, /*framebuffer_size=*/size, format, usage,
+                            client_id, surface_handle));
 }
 
 }  // namespace gpu

gpu/ipc/service/gpu_memory_buffer_factory.h

@@ -35,10 +35,14 @@ class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactory {
   // Creates a new GPU memory buffer instance. A valid handle is returned on
   // success. This method is thread-safe but it should not be called on the IO
   // thread as it can lead to deadlocks (see https://crbug.com/981721). Instead
-  // use the asynchronous version on the IO thread.
+  // use the asynchronous version on the IO thread. |framebuffer_size| specifies
+  // the size used to create a framebuffer when the |usage| requires it and the
+  // particular GpuMemoryBufferFactory implementation supports it (for example,
+  // when creating a buffer for scanout using the Ozone/DRM backend).
   virtual gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,

gpu/ipc/service/gpu_memory_buffer_factory_android_hardware_buffer.cc

@@ -54,10 +54,12 @@ gfx::GpuMemoryBufferHandle
 GpuMemoryBufferFactoryAndroidHardwareBuffer::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
+    const gfx::Size& framebuffer_size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     SurfaceHandle surface_handle) {
+  DCHECK_EQ(framebuffer_size, size);
   auto buffer = GpuMemoryBufferImplAndroidHardwareBuffer::Create(
       id, size, format, usage, GpuMemoryBufferImpl::DestructionCallback());
   if (!buffer) {

gpu/ipc/service/gpu_memory_buffer_factory_android_hardware_buffer.h

@@ -32,6 +32,7 @@ class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactoryAndroidHardwareBuffer
   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,

gpu/ipc/service/gpu_memory_buffer_factory_dxgi.cc

@@ -20,11 +20,13 @@ GpuMemoryBufferFactoryDXGI::~GpuMemoryBufferFactoryDXGI() {}
 gfx::GpuMemoryBufferHandle GpuMemoryBufferFactoryDXGI::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
+    const gfx::Size& framebuffer_size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     SurfaceHandle surface_handle) {
   TRACE_EVENT0("gpu", "GpuMemoryBufferFactoryDXGI::CreateGpuMemoryBuffer");
+  DCHECK_EQ(framebuffer_size, size);
 
   gfx::GpuMemoryBufferHandle handle;
 

gpu/ipc/service/gpu_memory_buffer_factory_dxgi.h

@@ -36,6 +36,7 @@ class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactoryDXGI
   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,

gpu/ipc/service/gpu_memory_buffer_factory_io_surface.cc

@@ -37,11 +37,13 @@ gfx::GpuMemoryBufferHandle
 GpuMemoryBufferFactoryIOSurface::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
+    const gfx::Size& framebuffer_size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     SurfaceHandle surface_handle) {
   DCHECK_NE(client_id, kAnonymousClientId);
+  DCHECK_EQ(framebuffer_size, size);
 
   bool should_clear = true;
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface(

gpu/ipc/service/gpu_memory_buffer_factory_io_surface.h

@@ -38,6 +38,7 @@ class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactoryIOSurface
   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,

gpu/ipc/service/gpu_memory_buffer_factory_native_pixmap.cc

@@ -68,6 +68,7 @@ gfx::GpuMemoryBufferHandle
 GpuMemoryBufferFactoryNativePixmap::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
+    const gfx::Size& framebuffer_size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
@@ -78,11 +79,12 @@ GpuMemoryBufferFactoryNativePixmap::CreateGpuMemoryBuffer(
         ui::OzonePlatform::GetInstance()
             ->GetSurfaceFactoryOzone()
             ->CreateNativePixmap(surface_handle, GetVulkanDevice(), size,
-                                 format, usage);
+                                 format, usage, framebuffer_size);
     return CreateGpuMemoryBufferFromNativePixmap(id, size, format, usage,
                                                  client_id, std::move(pixmap));
   }
 #endif
+  DCHECK_EQ(framebuffer_size, size);
 
 #if defined(USE_X11)
   DCHECK(!features::IsUsingOzonePlatform());
@@ -126,8 +128,9 @@ void GpuMemoryBufferFactoryNativePixmap::CreateGpuMemoryBufferAsync(
 #endif
 
 #if defined(USE_X11)
-  std::move(callback).Run(CreateGpuMemoryBuffer(id, size, format, usage,
-                                                client_id, surface_handle));
+  std::move(callback).Run(
+      CreateGpuMemoryBuffer(id, size, /*framebuffer_size=*/size, format, usage,
+                            client_id, surface_handle));
 #else
   NOTIMPLEMENTED();
   std::move(callback).Run(gfx::GpuMemoryBufferHandle());

gpu/ipc/service/gpu_memory_buffer_factory_native_pixmap.h

@@ -37,6 +37,7 @@ class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactoryNativePixmap
   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,

gpu/ipc/service/gpu_memory_buffer_factory_test_template.h

@@ -81,9 +81,9 @@ TYPED_TEST_P(GpuMemoryBufferFactoryTest, CreateGpuMemoryBuffer) {
         continue;
 
       gfx::GpuMemoryBufferHandle handle =
-          TestFixture::factory_.CreateGpuMemoryBuffer(kBufferId, buffer_size,
-                                                      format, usage, kClientId,
-                                                      gpu::kNullSurfaceHandle);
+          TestFixture::factory_.CreateGpuMemoryBuffer(
+              kBufferId, buffer_size, /*framebuffer_size=*/buffer_size, format,
+              usage, kClientId, gpu::kNullSurfaceHandle);
       EXPECT_NE(handle.type, gfx::EMPTY_BUFFER);
       TestFixture::factory_.DestroyGpuMemoryBuffer(kBufferId, kClientId);
     }

gpu/vulkan/vulkan_image_unittest.cc

@@ -166,7 +166,8 @@ TEST_F(VulkanImageTest, CreateFromGpuMemoryBufferHandle) {
     gfx::BufferUsage buffer_usage = gfx::BufferUsage::SCANOUT;
     int client_id = 1;
     auto gmb_handle = factory->CreateGpuMemoryBuffer(
-        id, size, format.buffer, buffer_usage, client_id, kNullSurfaceHandle);
+        id, size, /*framebuffer_size=*/size, format.buffer, buffer_usage,
+        client_id, kNullSurfaceHandle);
     EXPECT_TRUE(!gmb_handle.is_null());
     EXPECT_EQ(gmb_handle.type,
               gfx::GpuMemoryBufferType::ANDROID_HARDWARE_BUFFER);

media/gpu/chromeos/platform_video_frame_utils.cc

@@ -51,9 +51,9 @@ gfx::GpuMemoryBufferHandle AllocateGpuMemoryBufferHandle(
 
   // TODO(hiroh): Rename the client id to more generic one.
   gmb_handle = factory->CreateGpuMemoryBuffer(
-      gfx::GpuMemoryBufferId(gpu_memory_buffer_id), coded_size, *buffer_format,
-      buffer_usage, gpu::kPlatformVideoFramePoolClientId,
-      gfx::kNullAcceleratedWidget);
+      gfx::GpuMemoryBufferId(gpu_memory_buffer_id), coded_size,
+      /*framebuffer_size=*/coded_size, *buffer_format, buffer_usage,
+      gpu::kPlatformVideoFramePoolClientId, gfx::kNullAcceleratedWidget);
   DCHECK(gmb_handle.is_null() || gmb_handle.type != gfx::NATIVE_PIXMAP ||
          VideoFrame::NumPlanes(pixel_format) ==
              gmb_handle.native_pixmap_handle.planes.size());

media/gpu/chromeos/platform_video_frame_utils_unittest.cc

@@ -85,6 +85,7 @@ class FakeGpuMemoryBufferFactory : public gpu::GpuMemoryBufferFactory {
   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(
       gfx::GpuMemoryBufferId id,
       const gfx::Size& size,
+      const gfx::Size& framebuffer_size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       int client_id,