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 561 matching lines @@
 ResourceId ResourceProvider::CreateResource(
     const gfx::Size& size,
     TextureHint hint,
     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 LUMINANCE_F16 yet.
       if (format != 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(RGBA_8888, format);
       return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceId ResourceProvider::CreateGpuMemoryBufferResource(
     const gfx::Size& size,
     TextureHint hint,
     ResourceFormat format,
     gfx::BufferUsage usage,
     const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
   switch (settings_.default_resource_type) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
     case RESOURCE_TYPE_GL_TEXTURE: {
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER,

[ericrk, 2017/06/27 00:31:30]

Do we want similar logic here? Can we just move the TEXTURE_HINT_IMAGE logic to
CreateGLTexture?

I think we're currently OK as we only call this through the zero-copy path.
However, moving the logic to CreateGLTexture would make things more uniform, and
should still be fine, as zero copy doesn't pass the immutable flag.

WDYT?

                              format, usage, color_space);
     }
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
       return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceId ResourceProvider::CreateGLTexture(
     const gfx::Size& size,
     TextureHint hint,
     ResourceType type,
     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;
 
   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 1344 matching lines @@
   if (resource->allocated)
     return;
   LazyCreate(resource);
   if (!resource->gl_id)
     return;
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   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));
+  if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER ||
+      ((resource->hint & TEXTURE_HINT_IMAGE) && !can_use_texture_storage)) {
     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) {
+      gl->TexParameteri(resource->target, GL_TEXTURE_BUFFER_USAGE_CHROMIUM,
+                        GL_TEXTURE_BUFFER_SCANOUT_CHROMIUM);
+    }
+
     gl->TexStorage2DEXT(resource->target, 1, storage_format, size.width(),
                         size.height());
   } else {
     // ETC1 does not support preallocation.
     if (format != 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