cc: Reformat renderers to make them work with mask tiling.

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 1299 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),
                 current_frame()->current_render_pass->color_space);
 }
 
 void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
-  gfx::RectF tex_rect(params->src_offset.x(), params->src_offset.y(),
-                      params->dst_rect.width(), params->dst_rect.height());
+  gfx::RectF tex_rect = params->quad->tex_coord_rect;
   gfx::Size texture_size;

[trchen, 2017/03/02 00:32:56]

nits: move this down right before #1328

[sunxd, 2017/03/02 17:21:39]

Done.

+  if (tex_rect.IsEmpty()) {
+    // The tex_coord_rect is not produced in RenderSufaceImpl::AppendQuads.
+    tex_rect =
+        gfx::RectF(gfx::PointF(params->src_offset), params->dst_rect.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());
 
   DCHECK(current_program_->vertex_tex_transform_location() != -1 ||
          IsContextLost());
@@ skipping 18 matching lines @@
     DCHECK_NE(current_program_->mask_tex_coord_scale_location(), 1);
     DCHECK_NE(current_program_->mask_tex_coord_offset_location(), 1);
     gl_->Uniform1i(current_program_->mask_sampler_location(), 1);
 
     gfx::RectF mask_uv_rect = params->quad->mask_uv_rect;
     if (SamplerTypeFromTextureTarget(params->mask_resource_lock->target()) !=
         SAMPLER_TYPE_2D) {
       mask_uv_rect.Scale(params->quad->mask_texture_size.width(),
                          params->quad->mask_texture_size.height());
     }
+
+    SkMatrix tex_to_mask = SkMatrix::MakeRectToRect(RectFToSkRect(tex_rect),
+                                                    RectFToSkRect(mask_uv_rect),
+                                                    SkMatrix::kFill_ScaleToFit);

[trchen, 2017/03/02 00:32:56]

Thanks for saving everyone's brain cells!

However it looks like it introduced some behavioral changes. I think the
original code was equivalent to:

SkMatrix tex_to_mask = 
    SkMatrix::MakeRectToRect(SkRect::makeWH(tex_rect.width(),
tex_rect.height()),
        RectFToSkRect(mask_uv_rect),
        SkMatrix::kFill_ScaleToFit);

I think your version is more correct, and is probably related to the bug your
test exposed:
https://codereview.chromium.org/2689253002/diff/200001/third_party/WebKit/Lay...
I'm surprised your test didn't fail. Could you investigate and add test if it is
a separate issue?

[sunxd, 2017/03/02 17:21:39]

Yes I noticed that this didn't fix the bug in that test. The new logic here
should be correct as tex_rect can have an offset, this should fix bugs that when
we tile masks, we apply textures from the same (0, 0) offset for every tile.

I tried playing with that test a while and found that even if we disable masks,
we get the same result: you can see the tiny difference by adding/removing
will-change: transform in devtools quickly.

I assume this is a bug with filters. Moreover, in my UI patterns work I
discovered that blur filters cannot work correctly with backface visibility
(while firefox do), so I guess the code is buggy somewhere.

A small demo: https://jsfiddle.net/579v9aho/3/
Blurred divs seem to be chopped off at certain rotation degrees and backface
visibility is not correctly displayed.

[trchen, 2017/03/04 02:59:39]

Alright. I see why. As GLRenderer::UpdateRPDQWithSkiaFilters changes the
geometry of the quad, the corresponding mask_uv_rect should be updated too (but
didn't). It was a double fail before your CL, and it became a single fail after
yours. (So blur+mask still fails, but fail in a subtly different way.)

For non-filtered code path, tex_rect.location() was always zero because our code
is smart enough to never over-draw. With tiled masks, there will be non-trivial
tex_rect.location(). I'm convinced that tests with tiled mask will catch this
behavioral change.
Nah, backface visibility is another story. Basically all 4 major vendors treat
3D context differently, and none implements backface-visibility according to the
spec. Your demo kind of works (or not working) as intended.
Yea, that chopping looks incorrect, and there are weird edge bleeding at some
certain degrees. Anyway, let's ignore it for another day. :)

+
     if (params->source_needs_flip) {
       // Mask textures are oriented vertically flipped relative to the
       // framebuffer and the RenderPass contents texture, so we flip the tex
       // coords from the RenderPass texture to find the mask texture coords.
-      gl_->Uniform2f(
-          current_program_->mask_tex_coord_offset_location(), mask_uv_rect.x(),
-          mask_uv_rect.height() / tex_rect.height() + mask_uv_rect.y());
-      gl_->Uniform2f(current_program_->mask_tex_coord_scale_location(),
-                     mask_uv_rect.width() / tex_rect.width(),
-                     -mask_uv_rect.height() / tex_rect.height());
-    } else {
-      // Tile textures are oriented the same way as mask textures.
-      gl_->Uniform2f(current_program_->mask_tex_coord_offset_location(),
-                     mask_uv_rect.x(), mask_uv_rect.y());
-      gl_->Uniform2f(current_program_->mask_tex_coord_scale_location(),
-                     mask_uv_rect.width() / tex_rect.width(),
-                     mask_uv_rect.height() / tex_rect.height());
+      tex_to_mask.preTranslate(0, 1);
+      tex_to_mask.preScale(1, -1);
     }
 
+    gl_->Uniform2f(current_program_->mask_tex_coord_offset_location(),
+                   tex_to_mask.getTranslateX(), tex_to_mask.getTranslateY());
+    gl_->Uniform2f(current_program_->mask_tex_coord_scale_location(),
+                   tex_to_mask.getScaleX(), tex_to_mask.getScaleY());
     last_texture_unit = 1;
   }
 
   if (current_program_->edge_location() != -1)
     gl_->Uniform3fv(current_program_->edge_location(), 8, params->edge);
 
   if (current_program_->color_matrix_location() != -1) {
     float matrix[16];
     for (int i = 0; i < 4; ++i) {
       for (int j = 0; j < 4; ++j)
@@ skipping 2108 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