Allow binding multiple textures to one DC Layer overlay.

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>
 
 #include <algorithm>
 #include <cmath>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ skipping 1678 matching lines @@
 
   // Wrapper for glOverlayPromotionHintCHROMIUIM
   void DoOverlayPromotionHintCHROMIUM(GLuint client_id,
                                       GLboolean promotion_hint,
                                       GLint display_x,
                                       GLint display_y);
 
   // Wrapper for glSetDrawRectangleCHROMIUM
   void DoSetDrawRectangleCHROMIUM(GLint x, GLint y, GLint width, GLint height);
 
+  void DoSetDCLayerTextureCHROMIUM(GLuint index, GLuint texture_id);
   void DoSetEnableDCLayersCHROMIUM(GLboolean enable);
 
   // Wrapper for glReadBuffer
   void DoReadBuffer(GLenum src);
 
   // Wrapper for glRenderbufferStorage.
   void DoRenderbufferStorage(
       GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 
   // Handler for glRenderbufferStorageMultisampleCHROMIUM.
@@ skipping 759 matching lines @@
   struct DCLayerSharedState {
     float opacity;
     bool is_clipped;
     gfx::Rect clip_rect;
     int z_order;
     gfx::Transform transform;
   };
 
   std::unique_ptr<DCLayerSharedState> dc_layer_shared_state_;
 
+  // Allow up to 4 planes - Y, U, V, A. Some may be missing, depending on the
+  // texture format.
+  uint32_t dc_layer_textures_[4] = {};
+
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 const GLES2DecoderImpl::CommandInfo GLES2DecoderImpl::command_info[] = {
 #define GLES2_CMD_OP(name)                                   \
   {                                                          \
     &GLES2DecoderImpl::Handle##name, cmds::name::kArgFlags,  \
         cmds::name::cmd_flags,                               \
         sizeof(cmds::name) / sizeof(CommandBufferEntry) - 1, \
   }                                                          \
@@ skipping 6273 matching lines @@
     return;
   }
   gfx::Rect rect(x, y, width, height);
   if (!surface_->SetDrawRectangle(rect)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSetDrawRectangleCHROMIUM",
                        "failed on surface");
   }
   OnFboChanged();
 }
 
+void GLES2DecoderImpl::DoSetDCLayerTextureCHROMIUM(GLuint index,
+                                                   GLuint texture_id) {
+  if (index >= arraysize(dc_layer_textures_)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSetDCLayerTextureCHROMIUM",
+                       "texture index too large");
+    return;
+  }
+  dc_layer_textures_[index] = texture_id;
+}
+
 void GLES2DecoderImpl::DoSetEnableDCLayersCHROMIUM(GLboolean enable) {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
   if (framebuffer) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSetEnableDCLayersCHROMIUM",
                        "framebuffer must not be bound");
     return;
   }
   if (!supports_dc_layers_) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glSetEnableDCLayersCHROMIUM",
                        "surface doesn't support SetDrawRectangle");
@@ skipping 3301 matching lines @@
     return error::kNoError;
   }
 
   if (!dc_layer_shared_state_) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glScheduleDCLayerCHROMIUM",
         "glScheduleDCLayerSharedStateCHROMIUM has not been called");
     return error::kNoError;
   }
 
-  gl::GLImage* image = nullptr;
-  GLuint contents_texture_id = c.contents_texture_id;
-  if (contents_texture_id) {
-    TextureRef* ref = texture_manager()->GetTexture(contents_texture_id);
-    if (!ref) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleDCLayerCHROMIUM",
-                         "unknown texture");
-      return error::kNoError;
+  std::vector<scoped_refptr<gl::GLImage>> images;
+
+  for (int contents_texture_id : dc_layer_textures_) {
+    scoped_refptr<gl::GLImage> image;
+    if (contents_texture_id) {
+      TextureRef* ref = texture_manager()->GetTexture(contents_texture_id);
+      if (!ref) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleDCLayerCHROMIUM",
+                           "unknown texture");
+        return error::kNoError;
+      }
+      Texture::ImageState image_state;
+      image = ref->texture()->GetLevelImage(ref->texture()->target(), 0,
+                                            &image_state);
+      if (!image) {
+        LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleDCLayerCHROMIUM",
+                           "unsupported texture format");
+        return error::kNoError;
+      }
     }
-    Texture::ImageState image_state;
-    image = ref->texture()->GetLevelImage(ref->texture()->target(), 0,
-                                          &image_state);
-    if (!image) {
-      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleDCLayerCHROMIUM",
-                         "unsupported texture format");
-      return error::kNoError;
-    }
+    images.push_back(image);
   }
 
+  memset(dc_layer_textures_, 0, sizeof dc_layer_textures_);
+
   const GLfloat* mem = GetSharedMemoryAs<const GLfloat*>(c.shm_id, c.shm_offset,
                                                          8 * sizeof(GLfloat));
   if (!mem) {
     return error::kOutOfBounds;
   }
   gfx::RectF contents_rect(mem[0], mem[1], mem[2], mem[3]);
   gfx::RectF bounds_rect(mem[4], mem[5], mem[6], mem[7]);
 
   ui::DCRendererLayerParams params = ui::DCRendererLayerParams(
       dc_layer_shared_state_->is_clipped, dc_layer_shared_state_->clip_rect,
-      dc_layer_shared_state_->z_order, dc_layer_shared_state_->transform, image,
-      contents_rect, gfx::ToEnclosingRect(bounds_rect), c.background_color,
-      c.edge_aa_mask, dc_layer_shared_state_->opacity, filter);
+      dc_layer_shared_state_->z_order, dc_layer_shared_state_->transform,
+      images, contents_rect, gfx::ToEnclosingRect(bounds_rect),
+      c.background_color, c.edge_aa_mask, dc_layer_shared_state_->opacity,
+      filter);
   if (!surface_->ScheduleDCLayer(params)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glScheduleDCLayerCHROMIUM",
                        "failed to schedule DCLayer");
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoScheduleCALayerInUseQueryCHROMIUM(
     GLsizei count,
     const volatile GLuint* textures) {
@@ skipping 7477 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