cc: Add test for AA quads due to precision loss

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1113 matching lines @@
 static void SolidColorUniformLocation(T program,
                                       SolidColorProgramUniforms* uniforms) {
   uniforms->program = program->program();
   uniforms->matrix_location = program->vertex_shader().matrix_location();
   uniforms->viewport_location = program->vertex_shader().viewport_location();
   uniforms->quad_location = program->vertex_shader().quad_location();
   uniforms->edge_location = program->vertex_shader().edge_location();
   uniforms->color_location = program->fragment_shader().color_location();
 }
 
+// static
 bool GLRenderer::SetupQuadForAntialiasing(
     const gfx::Transform& device_transform,
     const DrawQuad* quad,
     gfx::QuadF* local_quad,
-    float edge[24]) const {
+    float edge[24]) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   bool clipped = false;
   gfx::QuadF device_layer_quad = MathUtil::MapQuad(
       device_transform, gfx::QuadF(quad->visibleContentRect()), &clipped);
 
   bool is_axis_aligned_in_target = device_layer_quad.IsRectilinear();
   bool is_nearest_rect_within_epsilon = is_axis_aligned_in_target &&
       gfx::IsNearestRectWithinDistance(device_layer_quad.BoundingBox(),
                                        kAntiAliasingEpsilon);
-
-  bool use_aa = Settings().allow_antialiasing &&
-                !clipped &&  // code can't handle clipped quads
-                !is_nearest_rect_within_epsilon &&
-                quad->IsEdge();
+  // AAing clipped quads is not supported by the code yet.
+  bool use_aa = !clipped && !is_nearest_rect_within_epsilon && quad->IsEdge();
   if (!use_aa)
     return false;
 
   LayerQuad device_layer_bounds(gfx::QuadF(device_layer_quad.BoundingBox()));
   device_layer_bounds.InflateAntiAliasingDistance();
 
   LayerQuad device_layer_edges(device_layer_quad);
   device_layer_edges.InflateAntiAliasingDistance();
 
   device_layer_edges.ToFloatArray(edge);
@@ skipping 68 matching lines @@
     return;
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  bool use_aa = !quad->force_anti_aliasing_off && SetupQuadForAntialiasing(
-      device_transform, quad, &local_quad, edge);
+  bool use_aa =
+      Settings().allow_antialiasing && !quad->force_anti_aliasing_off &&

[epennerAtGoogle, 2013/09/07 00:00:33]

Nice short circuit.

+      SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa)
     SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);
   else
     SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);
   SetUseProgram(uniforms.program);
 
   GLC(Context(),
       Context()->uniform4f(uniforms.color_location,
@@ skipping 117 matching lines @@
   float fragment_tex_scale_y = clamp_tex_rect.height() / texture_size.height();
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  bool use_aa = SetupQuadForAntialiasing(
+  bool use_aa = Settings().allow_antialiasing && SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   TileProgramUniforms uniforms;
   if (use_aa) {
     if (quad->swizzle_contents) {
       TileUniformLocation(GetTileProgramSwizzleAA(tex_coord_precision),
                           &uniforms);
     } else {
       TileUniformLocation(GetTileProgramAA(tex_coord_precision), &uniforms);
     }
@@ skipping 1758 matching lines @@
   std::string unique_context_name = base::StringPrintf(
       "%s-Offscreen-%p",
       Settings().compositor_name.c_str(),
       context_);
   offscreen_context_provider->Context3d()->pushGroupMarkerEXT(
       unique_context_name.c_str());
 }
 
 
 }  // namespace cc