gpu: Compositor management of GpuMemoryBuffer instances.

cc/resources/resource_provider.cc

 // Copyright 2012 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
+#include "cc/resources/gpu_memory_buffer_manager.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/texture_uploader.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "ui/gfx/frame_time.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
@@ skipping 65 matching lines @@
       return kBGRA_8888_GrPixelConfig;
     case RGBA_4444:
       return kRGBA_4444_GrPixelConfig;
     default:
       break;
   }
   DCHECK(false) << "Unsupported resource format.";
   return kSkia8888_GrPixelConfig;
 }
 
+gfx::GpuMemoryBuffer::Format ToGpuMemoryBufferFormat(ResourceFormat format) {
+  switch (format) {
+    case RGBA_8888:
+      return gfx::GpuMemoryBuffer::Format::RGBA_8888;
+    case BGRA_8888:
+      return gfx::GpuMemoryBuffer::Format::BGRA_8888;
+    case RGBA_4444:
+    case ALPHA_8:
+    case LUMINANCE_8:
+    case RGB_565:
+    case ETC1:
+      break;
+  }
+  NOTREACHED();
+  return gfx::GpuMemoryBuffer::Format::RGBA_8888;
+}
+
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
     DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
 
     if (unit_ != GL_TEXTURE0)
       GLC(gl_, gl_->ActiveTexture(unit_));
   }
 
@@ skipping 108 matching lines @@
       target(0),
       original_filter(0),
       filter(0),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(0),
       hint(TextureHintImmutable),
       type(InvalidType),
       format(RGBA_8888),
-      shared_bitmap(NULL) {
+      shared_bitmap(NULL),
+      gpu_memory_buffer(NULL) {
 }
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(GLuint texture_id,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum target,
                                      GLenum filter,
                                      GLenum texture_pool,
@@ skipping 25 matching lines @@
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(texture_pool),
       wrap_mode(wrap_mode),
       hint(hint),
       type(GLTexture),
       format(format),
-      shared_bitmap(NULL) {
+      shared_bitmap(NULL),
+      gpu_memory_buffer(NULL) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
   DCHECK_EQ(origin == Internal, !!texture_pool);
 }
 
 ResourceProvider::Resource::Resource(uint8_t* pixels,
                                      SharedBitmap* bitmap,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter,
                                      GLint wrap_mode)
@@ skipping 22 matching lines @@
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
-      shared_bitmap(bitmap) {
+      shared_bitmap(bitmap),
+      gpu_memory_buffer(NULL) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
   DCHECK(origin == Delegated || pixels);
   if (bitmap)
     shared_bitmap_id = bitmap->id();
 }
 
 ResourceProvider::Resource::Resource(const SharedBitmapId& bitmap_id,
                                      const gfx::Size& size,
                                      Origin origin,
                                      GLenum filter,
@@ skipping 24 matching lines @@
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureHintImmutable),
       type(Bitmap),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
-      shared_bitmap(NULL) {
+      shared_bitmap(NULL),
+      gpu_memory_buffer(NULL) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
 ResourceProvider::Child::Child() : marked_for_deletion(false) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
+    GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
     bool use_distance_field_text) {
   scoped_ptr<ResourceProvider> resource_provider(
       new ResourceProvider(output_surface,
                            shared_bitmap_manager,
+                           gpu_memory_buffer_manager,
                            blocking_main_thread_task_runner,
                            highp_threshold_min,
                            use_rgba_4444_texture_format,
                            id_allocation_chunk_size,
                            use_distance_field_text));
 
   if (resource_provider->ContextGL())
     resource_provider->InitializeGL();
   else
     resource_provider->InitializeSoftware();
@@ skipping 287 matching lines @@
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::External);
     DCHECK_EQ(Bitmap, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = NULL;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::Internal);
     delete[] resource->pixels;
   }
+  if (resource->gpu_memory_buffer) {
+    DCHECK(resource->origin != Resource::External);
+    delete resource->gpu_memory_buffer;
+  }

[vmpstr, 2014/10/08 17:52:25]

Somewhat unrelated, but should we also set allocated to false in here?

[reveman, 2014/10/08 19:15:31]

I don't think so. We're destroying the resource instance and we really shouldn't
be resetting things here. I can see how it's useful to do some of this here to
more easily detect use-after-free issues but we should be using smart pointers
for that type of thing instead. That's a separate issue though.

[vmpstr, 2014/10/08 19:31:13]

Acknowledged.

   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
 
 void ResourceProvider::SetPixels(ResourceId id,
                                  const uint8_t* image,
@@ skipping 205 matching lines @@
   DCHECK(resource->origin == Resource::Internal);
   resource->locked_for_write = false;
 }
 
 const ResourceProvider::Resource*
 ResourceProvider::LockForWriteToGpuMemoryBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK_EQ(GLTexture, resource->type);
   DCHECK(CanLockForWrite(id));
 
-  if (!resource->image_id) {
+  if (!resource->gpu_memory_buffer) {
+    scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
+        gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
+            resource->size,
+            ToGpuMemoryBufferFormat(resource->format),
+            gfx::GpuMemoryBuffer::MAP);
+    resource->gpu_memory_buffer = gpu_memory_buffer.release();
     resource->allocated = true;

[vmpstr, 2014/10/08 17:52:25]

If we set allocated to false when deleted, can we also DCHECK(!allocated) in the
destructor of the resource? Or is there some situations where we don't delete
the resource? I mean, there shouldn't be since we'd leak.

[reveman, 2014/10/08 19:15:31]

Ideally we'd have the destructor do the cleanup work instead of
DeleteResourceInternal. Some work needed to get to that state though and I'd
rather not get that mixed up with this patch that is large enough as it is.

[vmpstr, 2014/10/08 19:31:13]

Acknowledged.

-    GLES2Interface* gl = ContextGL();
-    DCHECK(gl);
-    resource->image_id =
-        gl->CreateImageCHROMIUM(resource->size.width(),
-                                resource->size.height(),
-                                TextureToStorageFormat(resource->format),
-                                GL_IMAGE_MAP_CHROMIUM);
-    DCHECK(resource->image_id);
   }
 
   resource->locked_for_write = true;
   return resource;
 }
 
 void ResourceProvider::UnlockForWriteToGpuMemoryBuffer(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->origin == Resource::Internal);
   DCHECK_EQ(GLTexture, resource->type);
 
+  if (!resource->image_id) {
+    GLES2Interface* gl = ContextGL();
+    DCHECK(gl);
+    resource->image_id =
+        gl->CreateImageCHROMIUM(resource->gpu_memory_buffer->AsClientBuffer(),
+                                resource->size.width(),
+                                resource->size.height(),
+                                GL_RGBA);
+    DCHECK(resource->image_id);
+  }
+
   resource->locked_for_write = false;
   resource->dirty_image = true;
 
   // GpuMemoryBuffer provides direct access to the memory used by the GPU.
   // Read lock fences are required to ensure that we're not trying to map a
   // buffer that is currently in-use by the GPU.
   resource->read_lock_fences_enabled = true;
 }
 
 const ResourceProvider::Resource* ResourceProvider::LockForWriteToSkSurface(
@@ skipping 122 matching lines @@
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
-      image_id_(resource_provider->LockForWriteToGpuMemoryBuffer(resource_id)
-                    ->image_id),
       gpu_memory_buffer_(
-          resource_provider->ContextGL()->MapImageCHROMIUM(image_id_)) {
-  resource_provider->ContextGL()->GetImageParameterivCHROMIUM(
-      image_id_, GL_IMAGE_ROWBYTES_CHROMIUM, &stride_);
+          resource_provider->LockForWriteToGpuMemoryBuffer(resource_id)
+              ->gpu_memory_buffer) {
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
-  resource_provider_->ContextGL()->UnmapImageCHROMIUM(image_id_);
   resource_provider_->UnlockForWriteToGpuMemoryBuffer(resource_id_);
 }
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
       sk_surface_(resource_provider->LockForWriteToSkSurface(resource_id)
                       ->sk_surface.get()) {
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
   resource_provider_->UnlockForWriteToSkSurface(resource_id_);
 }
 
 ResourceProvider::ResourceProvider(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
+    GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     bool use_rgba_4444_texture_format,
     size_t id_allocation_chunk_size,
     bool use_distance_field_text)
     : output_surface_(output_surface),
       shared_bitmap_manager_(shared_bitmap_manager),
+      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
@@ skipping 915 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc