cc: RenderSurfaceImpl tile mask layer.

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 206 matching lines @@
   // Whether the original background texture is needed for the mask.
   bool mask_for_background = false;
 
   // 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;
 };
 
 static GLint GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 class GLRenderer::ScopedUseGrContext {
  public:
@@ skipping 791 matching lines @@
 }
 
 void GLRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad,
                                     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.
     Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
                            ResourceFormat::RGBA_8888,
                            current_frame()->current_render_pass->color_space);
     // 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;
@@ skipping 187 matching lines @@
             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);
         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;
       }
     }
   }
   return true;
 }
 
 void GLRenderer::UpdateRPDQTexturesForSampling(
     DrawRenderPassDrawQuadParams* params) {
   if (params->quad->mask_resource_id()) {
     params->mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
@@ skipping 59 matching lines @@
   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());
 }
 
 void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
-  gfx::RectF tex_rect = params->quad->tex_coord_rect;
-  if (tex_rect.IsEmpty()) {
-    // TODO(sunxd): make this never be empty.
-    tex_rect =
-        gfx::RectF(gfx::PointF(params->src_offset), params->dst_rect.size());
-  }
+  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 {
     texture_size = params->contents_texture->size();
   }
   tex_rect.Scale(1.0f / texture_size.width(), 1.0f / texture_size.height());
 
@@ skipping 1983 matching lines @@
   DCHECK(contents_texture);
 
   // Configure parameters as if drawing to a framebuffer the size of the
   // screen.
   DrawRenderPassDrawQuadParams params;
   params.quad = ca_layer_overlay->rpdq;
   params.flip_texture = true;
   params.contents_texture = contents_texture;
   params.quad_to_target_transform =
       params.quad->shared_quad_state->quad_to_target_transform;
+  params.tex_coord_rect = params.quad->tex_coord_rect;
 
   // Calculate projection and window matrices using InitializeViewport(). This
   // requires creating a dummy DrawingFrame.
   {
     DrawingFrame dummy_frame;
     gfx::Rect frame_rect(current_frame()->device_viewport_size);
     force_drawing_frame_framebuffer_unflipped_ = true;
     InitializeViewport(&dummy_frame, frame_rect, frame_rect, frame_rect.size());
     force_drawing_frame_framebuffer_unflipped_ = false;
     params.projection_matrix = dummy_frame.projection_matrix;
@@ skipping 251 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