Allow creating GLImage-backed textures with glTexStorage2D.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 2821 matching lines @@
 
 bool BackTexture::AllocateNativeGpuMemoryBuffer(const gfx::Size& size,
                                                 GLenum format,
                                                 bool zero) {
   DCHECK(format == GL_RGB || format == GL_RGBA);
   scoped_refptr<gl::GLImage> image =
       decoder_->GetContextGroup()->image_factory()->CreateAnonymousImage(
           size,
           format == GL_RGB ? gfx::BufferFormat::RGBX_8888
                            : gfx::BufferFormat::RGBA_8888,
-          format);
+          gfx::BufferUsage::SCANOUT, format);
   if (!image || !image->BindTexImage(Target()))
     return false;
 
   image_ = image;
   decoder_->texture_manager()->SetLevelInfo(
       texture_ref_.get(), Target(), 0, image_->GetInternalFormat(),
       size.width(), size.height(), 1, 0, image_->GetInternalFormat(),
       GL_UNSIGNED_BYTE, gfx::Rect(size));
   decoder_->texture_manager()->SetLevelImage(texture_ref_.get(), Target(), 0,
                                              image_.get(), Texture::BOUND);
@@ skipping 8017 matching lines @@
         iparams[0] = texture->swizzle_b();
       }
       return;
     case GL_TEXTURE_SWIZZLE_A:
       if (fparams) {
         fparams[0] = static_cast<GLfloat>(texture->swizzle_a());
       } else {
         iparams[0] = texture->swizzle_a();
       }
       return;
+    case GL_TEXTURE_BUFFER_USAGE_CHROMIUM:
+      if (fparams) {
+        fparams[0] = static_cast<GLfloat>(texture->buffer_usage());
+      } else {
+        iparams[0] = texture->buffer_usage();
+      }
+      return;
     default:
       break;
   }
   if (fparams) {
     glGetTexParameterfv(target, pname, fparams);
   } else {
     glGetTexParameteriv(target, pname, iparams);
   }
 }
 
@@ skipping 6495 matching lines @@
   Texture* texture = texture_ref->texture();
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "texture is immutable");
     return;
   }
 
+  if (texture->buffer_usage() != GL_NONE) {
+    ScopedGLErrorSuppressor suppressor("GLES2CmdDecoder::TexStorageImpl",
+                                       state_.GetErrorState());
+    gfx::Size size(width, height);
+    gfx::BufferFormat buffer_format;
+    GLint real_internal_format;
+    switch (internal_format) {
+      case GL_RGBA8_OES:
+        buffer_format = gfx::BufferFormat::RGBA_8888;
+        real_internal_format = GL_RGBA;
+        break;
+      case GL_BGRA8_EXT:
+        buffer_format = gfx::BufferFormat::BGRA_8888;
+        real_internal_format = GL_BGRA_EXT;
+        break;
+      case GL_RGBA16F_EXT:
+        buffer_format = gfx::BufferFormat::RGBA_F16;
+        real_internal_format = GL_RGBA;
+        break;
+      default:
+        LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, function_name,
+                           "Invalid buffer format");
+        return;
+    }
+
+    if (levels != 1) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
+                         "Levels != 1 for buffer");
+      return;
+    }
+    if (depth > 1) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
+                         "depth > 1 for buffer");
+      return;
+    }
+    DCHECK_EQ(GL_TEXTURE_BUFFER_SCANOUT_CHROMIUM, texture->buffer_usage());
+
+    gfx::BufferUsage buffer_usage = gfx::BufferUsage::SCANOUT;
+    scoped_refptr<gl::GLImage> image =
+        GetContextGroup()->image_factory()->CreateAnonymousImage(
+            gfx::Size(width, height), buffer_format, buffer_usage,
+            real_internal_format);
+    if (!image || !image->BindTexImage(target)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                         "Cannot create GL Image");
+      return;
+    }
+
+    texture_manager()->SetLevelInfo(
+        texture_ref, target, 0, image->GetInternalFormat(), width, height, 1, 0,
+        image->GetInternalFormat(), GL_UNSIGNED_BYTE, gfx::Rect(size));
+    texture_manager()->SetLevelImage(texture_ref, target, 0, image.get(),
+                                     Texture::BOUND);
+    return;
+  }
+
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
 
   std::vector<int32_t> level_size(levels);
   {
     GLsizei level_width = width;
     GLsizei level_height = height;
     GLsizei level_depth = depth;
     base::CheckedNumeric<uint32_t> estimated_size(0);
@@ skipping 2299 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu