Remove kGpuMemoryBuffer resource type

They are only created in ResourceProviderTest, not used in production.
Also remove ScopedWriteLockGpuMemoryBuffer and helper functions in
LayerTreeResourceProvider.

Bug: None
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I8ddd10fe5c0f86f994dbfeb966200154304d8432
Reviewed-on: https://chromium-review.googlesource.com/1011558
Commit-Queue: Antoine Labour <piman@chromium.org>
Reviewed-by: Sunny Sachanandani <sunnyps@chromium.org>
Cr-Commit-Position: refs/heads/master@{#551087}

cc/resources/layer_tree_resource_provider.cc

@@ -371,36 +371,6 @@ viz::ResourceId LayerTreeResourceProvider::CreateGpuTextureResource(
   return id;
 }
 
-viz::ResourceId LayerTreeResourceProvider::CreateGpuMemoryBufferResource(
-    const gfx::Size& size,
-    viz::ResourceTextureHint hint,
-    viz::ResourceFormat format,
-    gfx::BufferUsage usage,
-    const gfx::ColorSpace& color_space) {
-  DCHECK(compositor_context_provider_);
-  DCHECK(!size.IsEmpty());
-  DCHECK(compositor_context_provider_);
-  DCHECK_LE(size.width(), settings_.max_texture_size);
-  DCHECK_LE(size.height(), settings_.max_texture_size);
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-
-  viz::ResourceId id = next_id_++;
-  viz::internal::Resource* resource = InsertResource(
-      id, viz::internal::Resource(size, viz::internal::Resource::INTERNAL, hint,
-                                  viz::ResourceType::kGpuMemoryBuffer, format,
-                                  color_space));
-  resource->target = GetImageTextureTarget(
-      compositor_context_provider_->ContextCapabilities(), usage, format);
-  resource->buffer_format = BufferFormat(format);
-  resource->usage = usage;
-  resource->is_overlay_candidate = 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;
-  return id;
-}
-
 viz::ResourceId LayerTreeResourceProvider::CreateBitmapResource(
     const gfx::Size& size,
     const gfx::ColorSpace& color_space,
@@ -573,38 +543,6 @@ void LayerTreeResourceProvider::CreateMailbox(
   resource->SetLocallyUsed();
 }
 
-void LayerTreeResourceProvider::CreateAndBindImage(
-    viz::internal::Resource* resource) {
-  DCHECK(resource->gpu_memory_buffer);
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
-  // TODO(reveman): This avoids a performance problem on ARM ChromeOS
-  // devices. This only works with shared memory backed buffers.
-  // https://crbug.com/580166
-  DCHECK_EQ(resource->gpu_memory_buffer->GetHandle().type,
-            gfx::SHARED_MEMORY_BUFFER);
-#endif
-  CreateTexture(resource);
-
-  gpu::gles2::GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-
-  gl->BindTexture(resource->target, resource->gl_id);
-
-  if (!resource->image_id) {
-    resource->image_id = gl->CreateImageCHROMIUM(
-        resource->gpu_memory_buffer->AsClientBuffer(), resource->size.width(),
-        resource->size.height(), GLInternalFormat(resource->format));
-
-    DCHECK(resource->image_id ||
-           gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
-
-    gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
-  } else {
-    gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->image_id);
-    gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
-  }
-}
-
 void LayerTreeResourceProvider::AllocateForTesting(viz::ResourceId id) {
   viz::internal::Resource* resource = GetResource(id);
   if (!resource->allocated) {
@@ -922,48 +860,6 @@ void LayerTreeResourceProvider::ScopedWriteLockRaster::LazyAllocate(
   }
 }
 
-LayerTreeResourceProvider::ScopedWriteLockGpuMemoryBuffer ::
-    ScopedWriteLockGpuMemoryBuffer(LayerTreeResourceProvider* resource_provider,
-                                   viz::ResourceId resource_id)
-    : resource_provider_(resource_provider), resource_id_(resource_id) {
-  viz::internal::Resource* resource =
-      resource_provider->LockForWrite(resource_id);
-  DCHECK_EQ(resource->type, viz::ResourceType::kGpuMemoryBuffer);
-  size_ = resource->size;
-  format_ = resource->format;
-  usage_ = resource->usage;
-  color_space_ = resource_provider->GetResourceColorSpaceForRaster(resource);
-  gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer);
-}
-
-LayerTreeResourceProvider::ScopedWriteLockGpuMemoryBuffer::
-    ~ScopedWriteLockGpuMemoryBuffer() {
-  viz::internal::Resource* resource =
-      resource_provider_->GetResource(resource_id_);
-  // Avoid crashing in release builds if GpuMemoryBuffer allocation fails.
-  // http://crbug.com/554541
-  if (gpu_memory_buffer_) {
-    resource->gpu_memory_buffer = std::move(gpu_memory_buffer_);
-    resource->allocated = true;
-    resource_provider_->CreateAndBindImage(resource);
-  }
-  resource_provider_->UnlockForWrite(resource);
-}
-
-gfx::GpuMemoryBuffer* LayerTreeResourceProvider::
-    ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
-  if (!gpu_memory_buffer_) {
-    gpu_memory_buffer_ =
-        resource_provider_->gpu_memory_buffer_manager()->CreateGpuMemoryBuffer(
-            size_, BufferFormat(format_), usage_, gpu::kNullSurfaceHandle);
-    // Avoid crashing in release builds if GpuMemoryBuffer allocation fails.
-    // http://crbug.com/554541
-    if (gpu_memory_buffer_ && color_space_.IsValid())
-      gpu_memory_buffer_->SetColorSpace(color_space_);
-  }
-  return gpu_memory_buffer_.get();
-}
-
 LayerTreeResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     LayerTreeResourceProvider* resource_provider,
     viz::ResourceId resource_id)

cc/resources/layer_tree_resource_provider.h

@@ -64,12 +64,6 @@ class CC_EXPORT LayerTreeResourceProvider : public ResourceProvider {
                                            viz::ResourceTextureHint hint,
                                            viz::ResourceFormat format,
                                            const gfx::ColorSpace& color_space);
-  viz::ResourceId CreateGpuMemoryBufferResource(
-      const gfx::Size& size,
-      viz::ResourceTextureHint hint,
-      viz::ResourceFormat format,
-      gfx::BufferUsage usage,
-      const gfx::ColorSpace& color_space);
   viz::ResourceId CreateBitmapResource(const gfx::Size& size,
                                        const gfx::ColorSpace& color_space,
                                        viz::ResourceFormat format);
@@ -237,29 +231,6 @@ class CC_EXPORT LayerTreeResourceProvider : public ResourceProvider {
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockRaster);
   };
 
-  class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
-   public:
-    ScopedWriteLockGpuMemoryBuffer(LayerTreeResourceProvider* resource_provider,
-                                   viz::ResourceId resource_id);
-    ~ScopedWriteLockGpuMemoryBuffer();
-    gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
-    const gfx::ColorSpace& color_space_for_raster() const {
-      return color_space_;
-    }
-
-   private:
-    LayerTreeResourceProvider* const resource_provider_;
-    const viz::ResourceId resource_id_;
-
-    gfx::Size size_;
-    viz::ResourceFormat format_;
-    gfx::BufferUsage usage_;
-    gfx::ColorSpace color_space_;
-    std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
-  };
-
   class CC_EXPORT ScopedWriteLockSoftware {
    public:
     ScopedWriteLockSoftware(LayerTreeResourceProvider* resource_provider,

cc/resources/resource_provider.cc

@@ -105,13 +105,6 @@ void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
   if (!lost_resource && resource->origin == viz::internal::Resource::INTERNAL)
     WaitSyncTokenInternal(resource);
 
-  if (resource->image_id) {
-    DCHECK_EQ(resource->origin, viz::internal::Resource::INTERNAL);
-    GLES2Interface* gl = ContextGL();
-    DCHECK(gl);
-    gl->DestroyImageCHROMIUM(resource->image_id);
-  }
-
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
@@ -126,11 +119,6 @@ void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
     resource->owned_shared_bitmap = nullptr;
   }
 
-  if (resource->gpu_memory_buffer) {
-    DCHECK_EQ(viz::ResourceType::kGpuMemoryBuffer, resource->type);
-    resource->gpu_memory_buffer = nullptr;
-  }
-
   resources_.erase(it);
 }
 
@@ -201,18 +189,11 @@ bool ResourceProvider::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  const uint64_t tracing_process_id =
-      base::trace_event::MemoryDumpManager::GetInstance()
-          ->GetTracingProcessId();
-
   for (const auto& resource_entry : resources_) {
     const auto& resource = resource_entry.second;
 
     bool backing_memory_allocated = false;
     switch (resource.type) {
-      case viz::ResourceType::kGpuMemoryBuffer:
-        backing_memory_allocated = !!resource.gpu_memory_buffer;
-        break;
       case viz::ResourceType::kTexture:
         backing_memory_allocated = !!resource.gl_id;
         break;
@@ -250,18 +231,6 @@ bool ResourceProvider::OnMemoryDump(
     base::trace_event::MemoryAllocatorDumpGuid guid;
     base::UnguessableToken shared_memory_guid;
     switch (resource.type) {
-      case viz::ResourceType::kGpuMemoryBuffer:
-        // GpuMemoryBuffers may be backed by shared memory, and in that case we
-        // use the guid from there to attribute for the global shared memory
-        // dumps. Otherwise, they may be backed by native structures, and we
-        // fall back to that with GetGUIDForTracing.
-        shared_memory_guid =
-            resource.gpu_memory_buffer->GetHandle().handle.GetGUID();
-        if (shared_memory_guid.is_empty()) {
-          guid =
-              resource.gpu_memory_buffer->GetGUIDForTracing(tracing_process_id);
-        }
-        break;
       case viz::ResourceType::kTexture:
         DCHECK(resource.gl_id);
         guid = gl::GetGLTextureClientGUIDForTracing(

components/viz/common/resources/resource.cc

@@ -6,7 +6,6 @@
 
 #include "build/build_config.h"
 #include "components/viz/common/quads/shared_bitmap.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 
 namespace viz {
 namespace internal {
@@ -80,7 +79,6 @@ void Resource::SetGenerateMipmap() {
   DCHECK(is_gpu_resource_type());
   DCHECK_EQ(target, static_cast<GLenum>(GL_TEXTURE_2D));
   DCHECK(hint & ResourceTextureHint::kMipmap);
-  DCHECK(!gpu_memory_buffer);
   mipmap_state = GENERATE;
 }
 

components/viz/common/resources/resource.h

@@ -184,8 +184,6 @@ struct VIZ_COMMON_EXPORT Resource {
   GLenum filter = GL_LINEAR;
   // The current min filter for GpuMemoryBuffer- and texture-backed resources.
   GLenum min_filter = GL_LINEAR;
-  // The GL image id for GpuMemoryBuffer-backed resources.
-  GLuint image_id = 0;
   // A hint for texture-backed resources about how the resource will be used,
   // that dictates how it should be allocated/used.
   ResourceTextureHint hint = ResourceTextureHint::kDefault;
@@ -212,8 +210,6 @@ struct VIZ_COMMON_EXPORT Resource {
   SharedBitmap* shared_bitmap = nullptr;
   // Ownership of |shared_bitmap| for when it is created internally.
   std::unique_ptr<SharedBitmap> owned_shared_bitmap;
-  // The GpuMemoryBuffer ownership for GpuMemoryBuffer-backed resources.
-  std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
   // The color space for all resource types, to control how the resource should
   // be drawn to output device.
   gfx::ColorSpace color_space;

components/viz/common/resources/resource_type.h

@@ -9,7 +9,6 @@ namespace viz {
 
 // Types of resources that can be sent to the viz compositing service.
 enum class ResourceType {
-  kGpuMemoryBuffer,
   kTexture,
   kBitmap,
 };

components/viz/service/display/software_renderer.cc

@@ -168,16 +168,8 @@ void SoftwareRenderer::PrepareSurfaceForPass(
 }
 
 bool SoftwareRenderer::IsSoftwareResource(ResourceId resource_id) const {
-  switch (resource_provider_->GetResourceType(resource_id)) {
-    case ResourceType::kGpuMemoryBuffer:
-    case ResourceType::kTexture:
-      return false;
-    case ResourceType::kBitmap:
-      return true;
-  }
-
-  LOG(FATAL) << "Invalid resource type.";
-  return false;
+  return resource_provider_->GetResourceType(resource_id) ==
+         ResourceType::kBitmap;
 }
 
 void SoftwareRenderer::DoDrawQuad(const DrawQuad* quad,