Add command buffer function glScheduleCALayerFilterEffectsCHROMIUM.

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 1059 matching lines @@
   void DoTraceEndCHROMIUM(void);
 
   void DoDrawBuffersEXT(GLsizei count, const GLenum* bufs);
 
   void DoLoseContextCHROMIUM(GLenum current, GLenum other);
 
   void DoFlushDriverCachesCHROMIUM(void);
 
   void DoMatrixLoadfCHROMIUM(GLenum matrix_mode, const GLfloat* matrix);
   void DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode);
+  void DoScheduleCALayerFilterEffectsCHROMIUM(
+      GLsizei count,
+      const GLCALayerFilterEffect* filter_effects);
   void DoScheduleCALayerInUseQueryCHROMIUM(GLsizei count,
                                            const GLuint* textures);
 
   // Creates a Program for the given program.
   Program* CreateProgram(GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
@@ skipping 942 matching lines @@
   // populated, since they are needed to implement the workaround.
   bool NeedsCopyTextureImageWorkaround(GLenum internal_format,
                                        int32_t channels_exist,
                                        GLuint* source_texture_service_id,
                                        GLenum* source_texture_target);
 
   // Whether a texture backed by a Chromium Image needs to emulate GL_RGB format
   // using GL_RGBA and glColorMask.
   bool ChromiumImageNeedsRGBEmulation();
 
+  // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
+  // equivalent functions reset shared state.
+  void ClearScheduleCALayerState();
+
   bool InitializeCopyTexImageBlitter(const char* function_name);
   bool InitializeCopyTextureCHROMIUM(const char* function_name);
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
@@ skipping 240 matching lines @@
 
   struct CALayerSharedState{
     float opacity;
     bool is_clipped;
     gfx::Rect clip_rect;
     int sorting_context_id;
     gfx::Transform transform;
   };
 
   std::unique_ptr<CALayerSharedState> ca_layer_shared_state_;
+  std::vector<ui::CARendererLayerParams::FilterEffect> ca_layer_filter_effects_;
 
   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 8443 matching lines @@
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                                      &is_tracing);
   if (is_tracing) {
     bool is_offscreen = !!offscreen_target_frame_buffer_.get();
     ScopedFrameBufferBinder binder(this, GetBackbufferServiceId());
     gpu_state_tracer_->TakeSnapshotWithCurrentFramebuffer(
         is_offscreen ? offscreen_size_ : surface_->GetSize());
   }
 
-  // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
-  // equivalent functions reset shared state.
-  ca_layer_shared_state_.reset();
+  ClearScheduleCALayerState();
 
   if (supports_async_swap_) {
     TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
     surface_->PostSubBufferAsync(
         c.x, c.y, c.width, c.height,
         base::Bind(&GLES2DecoderImpl::FinishSwapBuffers,
                    base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->PostSubBuffer(c.x, c.y, c.width, c.height));
   }
@@ skipping 107 matching lines @@
   }
 
   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]);
 
+  // TODO(erikchen): Pass through filter effects. https://crbug.com/581526.
+  ca_layer_filter_effects_.clear();
   ui::CARendererLayerParams params = ui::CARendererLayerParams(
       ca_layer_shared_state_->is_clipped, ca_layer_shared_state_->clip_rect,
       ca_layer_shared_state_->sorting_context_id,
       ca_layer_shared_state_->transform, image, contents_rect,
       gfx::ToEnclosingRect(bounds_rect), c.background_color, c.edge_aa_mask,
       ca_layer_shared_state_->opacity, filter);
   if (!surface_->ScheduleCALayer(params)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glScheduleCALayerCHROMIUM",
                        "failed to schedule CALayer");
   }
   return error::kNoError;
 }
 
+void GLES2DecoderImpl::DoScheduleCALayerFilterEffectsCHROMIUM(
+    GLsizei count,
+    const GLCALayerFilterEffect* filter_effects) {
+  std::vector<ui::CARendererLayerParams::FilterEffect> effects;
+  effects.reserve(count);
+  for (GLsizei i = 0; i < count; ++i) {
+    const GLCALayerFilterEffect& filter_effect = filter_effects[i];
+    GLint min =
+        static_cast<GLint>(ui::CARendererLayerParams::FilterEffectType::MIN);
+    GLint max =
+        static_cast<GLint>(ui::CARendererLayerParams::FilterEffectType::MAX);
+    if (filter_effect.type < min || filter_effect.type > max) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+                         "glScheduleCALayerFilterEffectsCHROMIUM",
+                         "Invalid filter type.");
+      return;
+    }
+    ui::CARendererLayerParams::FilterEffectType filter_type =
+        static_cast<ui::CARendererLayerParams::FilterEffectType>(
+            filter_effect.type);
+
+    ui::CARendererLayerParams::FilterEffect& effect = effects[i];
+    effect.type = filter_type;
+    effect.amount = filter_effect.amount;
+    effect.drop_shadow_offset = gfx::Point(filter_effect.drop_shadow_offset_x,
+                                           filter_effect.drop_shadow_offset_y);
+
+    static_assert(sizeof(GLuint) == sizeof(SkColor),
+                  "GLuint and SkColor must have the same size.");
+    effect.drop_shadow_color =
+        static_cast<SkColor>(filter_effect.drop_shadow_color);
+  }
+
+  ca_layer_filter_effects_.swap(effects);
+}
+
 void GLES2DecoderImpl::DoScheduleCALayerInUseQueryCHROMIUM(
     GLsizei count,
     const GLuint* textures) {
   std::vector<gl::GLSurface::CALayerInUseQuery> queries;
   queries.reserve(count);
   for (GLsizei i = 0; i < count; ++i) {
     gl::GLImage* image = nullptr;
     GLuint texture_id = textures[i];
     if (texture_id) {
       TextureRef* ref = texture_manager()->GetTexture(texture_id);
@@ skipping 2902 matching lines @@
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                                      &is_tracing);
   if (is_tracing) {
     ScopedFrameBufferBinder binder(this, GetBackbufferServiceId());
     gpu_state_tracer_->TakeSnapshotWithCurrentFramebuffer(
         is_offscreen ? offscreen_size_ : surface_->GetSize());
   }
 
-  // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
-  // equivalent functions reset shared state.
-  ca_layer_shared_state_.reset();
+  ClearScheduleCALayerState();
 
   // If offscreen then don't actually SwapBuffers to the display. Just copy
   // the rendered frame to another frame buffer.
   if (is_offscreen) {
     TRACE_EVENT2("gpu", "Offscreen",
         "width", offscreen_size_.width(), "height", offscreen_size_.height());
     if (offscreen_size_ != offscreen_saved_color_texture_->size()) {
       // Workaround for NVIDIA driver bug on OS X; crbug.com/89557,
       // crbug.com/94163. TODO(kbr): figure out reproduction so Apple will
       // fix this.
@@ skipping 99 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoCommitOverlayPlanes() {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCommitOverlayPlanes");
   if (!supports_commit_overlay_planes_) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCommitOverlayPlanes",
                        "command not supported by surface");
     return;
   }
-  // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
-  // equivalent functions reset shared state.
-  ca_layer_shared_state_.reset();
+  ClearScheduleCALayerState();
   if (supports_async_swap_) {
     surface_->CommitOverlayPlanesAsync(base::Bind(
         &GLES2DecoderImpl::FinishSwapBuffers, base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->CommitOverlayPlanes());
   }
 }
 
 void GLES2DecoderImpl::DoSwapInterval(int interval) {
   context_->SetSwapInterval(interval);
@@ skipping 3414 matching lines @@
   *source_texture_target = texture->texture()->target();
   *source_texture_service_id = texture->service_id();
   return true;
 }
 
 bool GLES2DecoderImpl::ChromiumImageNeedsRGBEmulation() {
   gpu::ImageFactory* factory = GetContextGroup()->image_factory();
   return factory ? !factory->SupportsFormatRGB() : false;
 }
 
+void GLES2DecoderImpl::ClearScheduleCALayerState() {
+  ca_layer_shared_state_.reset();
+  ca_layer_filter_effects_.clear();
+}
+
 error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
       *static_cast<const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
@@ skipping 143 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