color-profile-layer-filter.html issue

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 208 matching lines @@
 
   // Whether a color matrix needs to be applied by the shaders when drawing
   // the RPDQ.
   bool use_color_matrix = false;
 
   gfx::QuadF surface_quad;
 
   gfx::Transform contents_device_transform;
 
   gfx::RectF tex_coord_rect;
+
+  // The color space of the texture bound for sampling (from filter_image or
+  // contents_resource_lock, depending on the path taken).
+  gfx::ColorSpace contents_color_space;
 };
 
 static GLint GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 class GLRenderer::ScopedUseGrContext {
  public:
@@ skipping 404 matching lines @@
   backend_texture_description.fTextureHandle =
       skia::GrGLTextureInfoToGrBackendObject(texture_info);
   backend_texture_description.fOrigin =
       flip_texture ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
 
   return SkImage::MakeFromTexture(context, backend_texture_description);
 }
 
 static sk_sp<SkImage> ApplyImageFilter(
     std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
-    ResourceProvider* resource_provider,
     const gfx::RectF& src_rect,
     const gfx::RectF& dst_rect,
     const gfx::Vector2dF& scale,
     sk_sp<SkImageFilter> filter,
-    const Resource* source_texture_resource,
+    const ResourceProvider::ScopedReadLockGL& source_texture_lock,
     SkIPoint* offset,
     SkIRect* subset,
     bool flip_texture,
     const gfx::PointF& origin) {
   if (!filter || !use_gr_context)
     return nullptr;
 
-  ResourceProvider::ScopedReadLockGL lock(resource_provider,
-                                          source_texture_resource->id());
-
   sk_sp<SkImage> src_image =
-      WrapTexture(lock, use_gr_context->context(), flip_texture);
+      WrapTexture(source_texture_lock, use_gr_context->context(), flip_texture);
 
   if (!src_image) {
     TRACE_EVENT_INSTANT0("cc",
                          "ApplyImageFilter wrap background texture failed",
                          TRACE_EVENT_SCOPE_THREAD);
     return nullptr;
   }
 
   SkMatrix local_matrix;
   local_matrix.setTranslate(origin.x(), origin.y());
@@ skipping 356 matching lines @@
                                     const gfx::QuadF* clip_region) {
   auto bypass = render_pass_bypass_quads_.find(quad->render_pass_id);
   DrawRenderPassDrawQuadParams params;
   params.quad = quad;
   params.clip_region = clip_region;
   params.window_matrix = current_frame()->window_matrix;
   params.projection_matrix = current_frame()->projection_matrix;
   params.tex_coord_rect = quad->tex_coord_rect;
   if (bypass != render_pass_bypass_quads_.end()) {
     TileDrawQuad* tile_quad = &bypass->second;
-    // RGBA_8888 here is arbitrary and unused.
+    // RGBA_8888 and the gfx::ColorSpace() here are arbitrary and unused.
     Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
-                           ResourceFormat::RGBA_8888,
-                           current_frame()->current_render_pass->color_space);
+                           ResourceFormat::RGBA_8888, gfx::ColorSpace());
     // The projection matrix used by GLRenderer has a flip.  As tile texture
     // inputs are oriented opposite to framebuffer outputs, don't flip via
     // texture coords and let the projection matrix naturallyd o it.
     params.flip_texture = false;
     params.contents_texture = &tile_resource;
     DrawRenderPassQuadInternal(&params);
   } else {
     ScopedResource* contents_texture =
         render_pass_textures_[quad->render_pass_id].get();
     DCHECK(contents_texture);
@@ skipping 173 matching lines @@
         gfx::QuadF local_clip = MapQuadToLocalSpace(transform, clip_quad);
         params->dst_rect.Intersect(local_clip.BoundingBox());
         // If we've been fully clipped out (by crop rect or clipping), there's
         // nothing to draw.
         if (params->dst_rect.IsEmpty()) {
           return false;
         }
         SkIPoint offset;
         SkIRect subset;
         gfx::RectF src_rect(quad->rect);
+
+        ResourceProvider::ScopedReadLockGL prefilter_contents_texture_lock(
+            resource_provider_, params->contents_texture->id());
+        params->contents_color_space =
+            prefilter_contents_texture_lock.color_space();
         params->filter_image = ApplyImageFilter(
-            ScopedUseGrContext::Create(this), resource_provider_, src_rect,
-            params->dst_rect, quad->filters_scale, std::move(filter),
-            params->contents_texture, &offset, &subset, params->flip_texture,
-            quad->filters_origin);
+            ScopedUseGrContext::Create(this), src_rect, params->dst_rect,
+            quad->filters_scale, std::move(filter),
+            prefilter_contents_texture_lock, &offset, &subset,
+            params->flip_texture, quad->filters_origin);
         if (!params->filter_image)
           return false;
         params->dst_rect =
             gfx::RectF(src_rect.x() + offset.fX, src_rect.y() + offset.fY,
                        subset.width(), subset.height());
         params->src_offset.SetPoint(subset.x(), subset.y());
         gfx::RectF tex_rect = gfx::RectF(gfx::PointF(params->src_offset),
                                          params->dst_rect.size());
         params->tex_coord_rect = tex_rect;
       }
@@ skipping 14 matching lines @@
     GrSurfaceOrigin origin;
     GLuint filter_image_id =
         skia::GrBackendObjectToGrGLTextureInfo(
             params->filter_image->getTextureHandle(true, &origin))
             ->fID;
     DCHECK(filter_image_id);
     DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
     gl_->BindTexture(GL_TEXTURE_2D, filter_image_id);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
+    // |params->contents_color_space| was populated when |params->filter_image|
+    // was populated.
     params->source_needs_flip = kBottomLeft_GrSurfaceOrigin == origin;
   } else {
     params->contents_resource_lock =
         base::MakeUnique<ResourceProvider::ScopedSamplerGL>(
             resource_provider_, params->contents_texture->id(), GL_LINEAR);
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               params->contents_resource_lock->target());
+    params->contents_color_space =
+        params->contents_resource_lock->color_space();
     params->source_needs_flip = params->flip_texture;
   }
 }
 
 void GLRenderer::UpdateRPDQBlendMode(DrawRenderPassDrawQuadParams* params) {
   SkBlendMode blend_mode = params->quad->shared_quad_state->blend_mode;
   SetBlendEnabled(!params->use_shaders_for_blending &&
                   (params->quad->ShouldDrawWithBlending() ||
                    !IsDefaultBlendMode(blend_mode)));
   if (!params->use_shaders_for_blending) {
@@ skipping 15 matching lines @@
           : BLEND_MODE_NONE;
 
   SamplerType sampler_type = SAMPLER_TYPE_2D;
   MaskMode mask_mode = NO_MASK;
   bool mask_for_background = params->mask_for_background;
   if (params->mask_resource_lock) {
     mask_mode = HAS_MASK;
     sampler_type =
         SamplerTypeFromTextureTarget(params->mask_resource_lock->target());
   }
-
   SetUseProgram(ProgramKey::RenderPass(
                     tex_coord_precision, sampler_type, shader_blend_mode,
                     params->use_aa ? USE_AA : NO_AA, mask_mode,
                     mask_for_background, params->use_color_matrix),
-                params->contents_resource_lock
-                    ? params->contents_resource_lock->color_space()
-                    : gfx::ColorSpace());
+                params->contents_color_space);
 }
 
 void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
   gfx::RectF tex_rect = params->tex_coord_rect;
 
   gfx::Size texture_size;
   if (params->filter_image) {
     texture_size.set_width(params->filter_image->width());
     texture_size.set_height(params->filter_image->height());
   } else {
@@ skipping 2267 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc