Allow creating GLImage-backed textures with glTexStorage2D.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 364 matching lines @@
     best_texture_format = viz::RGBA_8888;
     return;
   }
 
   DCHECK(IsGpuResourceType(default_resource_type));
 
   const auto& caps = compositor_context_provider->ContextCapabilities();
   use_texture_storage_ext = caps.texture_storage;
   use_texture_format_bgra = caps.texture_format_bgra8888;
   use_texture_usage_hint = caps.texture_usage;
+  use_texture_buffer_chromium = caps.texture_buffer_chromium;
   use_sync_query = caps.sync_query;
 
   if (caps.disable_one_component_textures) {
     yuv_resource_format = yuv_highbit_resource_format = viz::RGBA_8888;
   } else {
     yuv_resource_format = caps.texture_rg ? viz::RED_8 : viz::LUMINANCE_8;
     yuv_highbit_resource_format = caps.texture_half_float_linear
                                       ? viz::LUMINANCE_F16
                                       : yuv_resource_format;
   }
@@ skipping 165 matching lines @@
 }
 
 viz::ResourceId ResourceProvider::CreateResource(
     const gfx::Size& size,
     TextureHint hint,
     viz::ResourceFormat format,
     const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
   switch (settings_.default_resource_type) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
-      // GPU memory buffers don't support viz::LUMINANCE_F16 yet.
+      // GPU memory buffers don't support LUMINANCE_F16 yet.
       if (format != viz::LUMINANCE_F16) {
-        return CreateGLTexture(
-            size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER, format,
-            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, color_space);
+        TextureHint new_hint =
+            static_cast<TextureHint>(hint | TEXTURE_HINT_IMAGE);
+        return CreateGLTexture(size, new_hint, RESOURCE_TYPE_GL_TEXTURE, format,
+                               gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+                               color_space);
       }
     // Fall through and use a regular texture.
     case RESOURCE_TYPE_GL_TEXTURE:
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GL_TEXTURE, format,
                              gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
                              color_space);
 
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(viz::RGBA_8888, format);
       return CreateBitmap(size, color_space);
@@ skipping 32 matching lines @@
     viz::ResourceFormat format,
     gfx::BufferUsage usage,
     const gfx::ColorSpace& color_space) {
   DCHECK_LE(size.width(), settings_.max_texture_size);
   DCHECK_LE(size.height(), settings_.max_texture_size);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(crbug.com/590317): We should not assume that all resources created by
   // ResourceProvider are GPU_READ_CPU_READ_WRITE. We should determine this
   // based on the current RasterBufferProvider's needs.
-  GLenum target = type == RESOURCE_TYPE_GPU_MEMORY_BUFFER
-                      ? GetImageTextureTarget(usage, format)
-                      : GL_TEXTURE_2D;
+  GLenum target =
+      type == RESOURCE_TYPE_GPU_MEMORY_BUFFER || (hint & TEXTURE_HINT_IMAGE)
+          ? GetImageTextureTarget(usage, format)
+          : GL_TEXTURE_2D;
 
   viz::ResourceId id = next_id_++;
   Resource* resource =
       InsertResource(id, Resource(0, size, Resource::INTERNAL, target,
                                   GL_LINEAR, hint, type, format));
   resource->usage = usage;
   resource->allocated = false;
   resource->color_space = color_space;
   return id;
 }
@@ skipping 1283 matching lines @@
   if (resource->allocated)
     return;
   LazyCreate(resource);
   if (!resource->gl_id)
     return;
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   viz::ResourceFormat format = resource->format;
   gl->BindTexture(resource->target, resource->gl_id);
-  if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) {
+  bool can_use_texture_storage =
+      (settings_.use_texture_storage_ext &&
+       IsFormatSupportedForStorage(format, settings_.use_texture_format_bgra) &&
+       (resource->hint & TEXTURE_HINT_IMMUTABLE));
+  bool can_use_texture_buffer =
+      can_use_texture_storage && settings_.use_texture_buffer_chromium;
+  if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER ||
+      ((resource->hint & TEXTURE_HINT_IMAGE) && !can_use_texture_buffer)) {
     resource->gpu_memory_buffer =
         gpu_memory_buffer_manager_->CreateGpuMemoryBuffer(
             size, BufferFormat(format), resource->usage,
             gpu::kNullSurfaceHandle);
     // Note that this impacts overlay compositing, not rasterization.
     if (resource->gpu_memory_buffer &&
         settings_.enable_color_correct_rasterization) {
       resource->gpu_memory_buffer->SetColorSpaceForScanout(
           resource->color_space);
     }
 
     LazyCreateImage(resource);
     resource->dirty_image = true;
     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;
-  } else if (settings_.use_texture_storage_ext &&
-             IsFormatSupportedForStorage(format,
-                                         settings_.use_texture_format_bgra) &&
-             (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
+  } else if (can_use_texture_storage) {
     GLenum storage_format = TextureToStorageFormat(format);
+    if (resource->hint & TEXTURE_HINT_IMAGE) {
+      DCHECK(settings_.use_texture_buffer_chromium);
+      gl->TexParameteri(resource->target, GL_TEXTURE_BUFFER_USAGE_CHROMIUM,
+                        GL_TEXTURE_BUFFER_SCANOUT_CHROMIUM);
+      resource->is_overlay_candidate = true;
+    }
+
     gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(),
                         size.height());
+    if ((resource->hint & TEXTURE_HINT_IMAGE) &&
+        settings_.enable_color_correct_rasterization) {
+      gl->SetColorSpaceForScanoutCHROMIUM(
+          resource->gl_id,
+          reinterpret_cast<GLColorSpace>(&resource->color_space));
+    }
   } else {
     // viz::ETC1 does not support preallocation.
     if (format != viz::ETC1) {
       gl->TexImage2D(resource->target, 0, GLInternalFormat(format),
                      size.width(), size.height(), 0, GLDataFormat(format),
                      GLDataType(format), nullptr);
     }
   }
 }
 
@@ skipping 164 matching lines @@
     } else {
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 }  // namespace cc