cc: Add force anti-aliasing off option to SolidColorDrawQuad

When edge anti-aliasing is used, GL renderer forces blending to be used,
which causes hole punching logic to misbehave. Make force anti-aliasing
off option to SolidColorDrawQuad to avoid unwanted anti-aliasing.

TEST=cc_unittests ; content_unittests
BUG=236317
R=enne@chromium.org,danakj@chromium.org,jamesr@chromium.org

Review URL: https://chromiumcodereview.appspot.com/13842037

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@197931 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 142 insertions, 65 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index f845013..6c1afac 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/hash_tables.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/quad_sink.h"
@@ -312,22 +313,27 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
 
     if (!top.IsEmpty()) {
       scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
-      top_quad->SetNew(shared_quad_state, top, colors[i % kNumColors]);
+      top_quad->SetNew(shared_quad_state, top, colors[i % kNumColors], false);
       quad_sink->Append(top_quad.PassAs<DrawQuad>(), append_quads_data);
 
       scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
-      bottom_quad->SetNew(
-          shared_quad_state, bottom, colors[kNumColors - 1 - (i % kNumColors)]);
+      bottom_quad->SetNew(shared_quad_state,
+                          bottom,
+                          colors[kNumColors - 1 - (i % kNumColors)],
+                          false);
       quad_sink->Append(bottom_quad.PassAs<DrawQuad>(), append_quads_data);
     }
     if (!left.IsEmpty()) {
       scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
-      left_quad->SetNew(
-          shared_quad_state, left, colors[kNumColors - 1 - (i % kNumColors)]);
+      left_quad->SetNew(shared_quad_state,
+                        left,
+                        colors[kNumColors - 1 - (i % kNumColors)],
+                        false);
       quad_sink->Append(left_quad.PassAs<DrawQuad>(), append_quads_data);
 
       scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
-      right_quad->SetNew(shared_quad_state, right, colors[i % kNumColors]);
+      right_quad->SetNew(
+          shared_quad_state, right, colors[i % kNumColors], false);
       quad_sink->Append(right_quad.PassAs<DrawQuad>(), append_quads_data);
     }
   }
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 222dc43..12ba72c 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -508,11 +508,11 @@ class DelegatedRendererLayerImplTestTransform
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
+      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false);
       quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
       color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
+      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false);
       quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
     }
 
@@ -558,19 +558,19 @@ class DelegatedRendererLayerImplTestTransform
 
     scoped_ptr<SolidColorDrawQuad> color_quad;
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
@@ -905,11 +905,11 @@ class DelegatedRendererLayerImplTestClip
 
       scoped_ptr<SolidColorDrawQuad> color_quad;
       color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u);
+      color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false);
       quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
       color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u);
+      color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false);
       quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
     }
 
@@ -952,19 +952,19 @@ class DelegatedRendererLayerImplTestClip
 
     scoped_ptr<SolidColorDrawQuad> color_quad;
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     color_quad = SolidColorDrawQuad::Create();
-    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u);
+    color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false);
     quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data);
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f13499c..037ff78 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -181,7 +181,7 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
           DCHECK_EQ(SkColorGetA(color), 255u);
         }
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(shared_quad_state, geometry_rect, color);
+        quad->SetNew(shared_quad_state, geometry_rect, color, false);
         if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
           append_quads_data->num_missing_tiles++;
       }
@@ -233,7 +233,8 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
-                     drawing_info.get_solid_color());
+                     drawing_info.get_solid_color(),
+                     false);
         quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
diff --git a/cc/layers/scrollbar_layer_impl.cc b/cc/layers/scrollbar_layer_impl.cc
index c376449..012cd90 100644
--- a/cc/layers/scrollbar_layer_impl.cc
+++ b/cc/layers/scrollbar_layer_impl.cc
@@ -186,7 +186,8 @@ void ScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
     scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  quad_rect,
-                 layer_tree_impl()->settings().solid_color_scrollbar_color);
+                 layer_tree_impl()->settings().solid_color_scrollbar_color,
+                 false);
     quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
     return;
   }
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 7a796fa..bbaffc4 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -39,7 +39,8 @@ void SolidColorLayerImpl::AppendQuads(QuadSink* quad_sink,
                               std::min(width - x, tile_size_),
                               std::min(height - y, tile_size_));
       scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-      quad->SetNew(shared_quad_state, solid_tile_rect, background_color());
+      quad->SetNew(
+          shared_quad_state, solid_tile_rect, background_color(), false);
       quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
     }
   }
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 7f27695..2d159f2 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -260,11 +260,12 @@ void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
       DCHECK_EQ(frame_resources_.size(), 0u);
       scoped_ptr<SolidColorDrawQuad> solid_color_draw_quad =
           SolidColorDrawQuad::Create();
+
       // Create a solid color quad with transparent black and force no
-      // blending.
+      // blending / no anti-aliasing.
       solid_color_draw_quad->SetAll(
           shared_quad_state, quad_rect, quad_rect, quad_rect, false,
-          SK_ColorTRANSPARENT);
+          SK_ColorTRANSPARENT, true);
       quad_sink->Append(solid_color_draw_quad.PassAs<DrawQuad>(),
                         append_quads_data);
       break;
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 10eab09..5577aa4 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -1119,7 +1119,8 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
   float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
 
   // Early out if alpha is small enough that quad doesn't contribute to output.
-  if (alpha < std::numeric_limits<float>::epsilon())
+  if (alpha < std::numeric_limits<float>::epsilon() &&
+      quad->ShouldDrawWithBlending())
     return;
 
   gfx::Transform device_transform =
@@ -1130,7 +1131,7 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  bool use_aa = SetupQuadForAntialiasing(
+  bool use_aa = !quad->force_anti_aliasing_off && SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index a24a5b3..4776dbb 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -144,7 +144,7 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) {
       CreateTestSharedQuadState(content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
-  color_quad->SetNew(shared_state.get(), rect, SK_ColorGREEN);
+  color_quad->SetNew(shared_state.get(), rect, SK_ColorGREEN, false);
 
   pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
 
@@ -181,14 +181,16 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
                          0,
                          this->device_viewport_size_.width() / 2,
                          this->device_viewport_size_.height()),
-               SK_ColorBLUE);
+               SK_ColorBLUE,
+               false);
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
   yellow->SetNew(shared_state.get(),
                  gfx::Rect(this->device_viewport_size_.width() / 2,
                            0,
                            this->device_viewport_size_.width() / 2,
                            this->device_viewport_size_.height()),
-                 SK_ColorYELLOW);
+                 SK_ColorYELLOW,
+                 false);
 
   scoped_ptr<SharedQuadState> blank_state =
       CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
@@ -196,7 +198,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
   scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
   white->SetNew(blank_state.get(),
                 viewport_rect,
-                SK_ColorWHITE);
+                SK_ColorWHITE,
+                false);
 
   child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
   child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
@@ -277,14 +280,16 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
                          0,
                          this->device_viewport_size_.width() / 2,
                          this->device_viewport_size_.height()),
-               SK_ColorBLUE);
+               SK_ColorBLUE,
+               false);
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
   yellow->SetNew(shared_state.get(),
                  gfx::Rect(this->device_viewport_size_.width() / 2,
                            0,
                            this->device_viewport_size_.width() / 2,
                            this->device_viewport_size_.height()),
-                 SK_ColorYELLOW);
+                 SK_ColorYELLOW,
+                 false);
 
   scoped_ptr<SharedQuadState> blank_state =
       CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
@@ -292,7 +297,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
   scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
   white->SetNew(blank_state.get(),
                 viewport_rect,
-                SK_ColorWHITE);
+                SK_ColorWHITE,
+                false);
 
   child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
   child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
@@ -375,14 +381,16 @@ TYPED_TEST(RendererPixelTest, RenderPassChangesSize) {
                          0,
                          this->device_viewport_size_.width() / 2,
                          this->device_viewport_size_.height()),
-               SK_ColorBLUE);
+               SK_ColorBLUE,
+               false);
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
   yellow->SetNew(shared_state.get(),
                  gfx::Rect(this->device_viewport_size_.width() / 2,
                            0,
                            this->device_viewport_size_.width() / 2,
                            this->device_viewport_size_.height()),
-                 SK_ColorYELLOW);
+                 SK_ColorYELLOW,
+                 false);
 
   child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
   child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
@@ -435,7 +443,8 @@ class RendererPixelTestWithBackgroundFilter
       scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
       color_quad->SetNew(shared_state.get(),
                          filter_pass_content_rect_,
-                         SK_ColorTRANSPARENT);
+                         SK_ColorTRANSPARENT,
+                         false);
       filter_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
       filter_pass->shared_quad_state_list.push_back(shared_state.Pass());
     }
@@ -469,7 +478,7 @@ class RendererPixelTestWithBackgroundFilter
           CreateTestSharedQuadState(identity_content_to_target_transform,
                                     left_rect);
       scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_state.get(), left_rect, SK_ColorGREEN);
+      color_quad->SetNew(shared_state.get(), left_rect, SK_ColorGREEN, false);
       root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
       root_pass->shared_quad_state_list.push_back(shared_state.Pass());
       left_rect += gfx::Vector2d(0, left_rect.height() + 1);
@@ -481,7 +490,7 @@ class RendererPixelTestWithBackgroundFilter
           CreateTestSharedQuadState(identity_content_to_target_transform,
                                     middle_rect);
       scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_state.get(), middle_rect, SK_ColorRED);
+      color_quad->SetNew(shared_state.get(), middle_rect, SK_ColorRED, false);
       root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
       root_pass->shared_quad_state_list.push_back(shared_state.Pass());
       middle_rect += gfx::Vector2d(0, middle_rect.height() + 1);
@@ -493,7 +502,7 @@ class RendererPixelTestWithBackgroundFilter
           CreateTestSharedQuadState(identity_content_to_target_transform,
                                     right_rect);
       scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
-      color_quad->SetNew(shared_state.get(), right_rect, SK_ColorBLUE);
+      color_quad->SetNew(shared_state.get(), right_rect, SK_ColorBLUE, false);
       root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
       root_pass->shared_quad_state_list.push_back(shared_state.Pass());
       right_rect += gfx::Vector2d(0, right_rect.height() + 1);
@@ -506,7 +515,8 @@ class RendererPixelTestWithBackgroundFilter
         SolidColorDrawQuad::Create();
     background_quad->SetNew(shared_state.get(),
                             device_viewport_rect,
-                            SK_ColorWHITE);
+                            SK_ColorWHITE,
+                            false);
     root_pass->quad_list.push_back(background_quad.PassAs<DrawQuad>());
     root_pass->shared_quad_state_list.push_back(shared_state.Pass());
 
@@ -554,7 +564,7 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
       CreateTestSharedQuadState(red_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
-  red->SetNew(red_shared_state.get(), rect, SK_ColorRED);
+  red->SetNew(red_shared_state.get(), rect, SK_ColorRED, false);
 
   pass->quad_list.push_back(red.PassAs<DrawQuad>());
 
@@ -564,7 +574,7 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
       CreateTestSharedQuadState(yellow_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
-  yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW);
+  yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW, false);
 
   pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
 
@@ -573,7 +583,7 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
       CreateTestSharedQuadState(blue_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
-  blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE);
+  blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false);
 
   pass->quad_list.push_back(blue.PassAs<DrawQuad>());
 
@@ -605,7 +615,7 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
       CreateTestSharedQuadState(red_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
-  red->SetNew(red_shared_state.get(), rect, SK_ColorRED);
+  red->SetNew(red_shared_state.get(), rect, SK_ColorRED, false);
 
   pass->quad_list.push_back(red.PassAs<DrawQuad>());
 
@@ -616,7 +626,7 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
       CreateTestSharedQuadState(yellow_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
-  yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW);
+  yellow->SetNew(yellow_shared_state.get(), rect, SK_ColorYELLOW, false);
 
   pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
 
@@ -625,7 +635,7 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
       CreateTestSharedQuadState(blue_content_to_target_transform, rect);
 
   scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
-  blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE);
+  blue->SetNew(blue_shared_state.get(), rect, SK_ColorBLUE, false);
 
   pass->quad_list.push_back(blue.PassAs<DrawQuad>());
 
@@ -638,6 +648,47 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
       ExactPixelComparator(true)));
 }
 
+// This test tests that forcing anti-aliasing off works as expected.
+// Anti-aliasing is only supported in the gl renderer.
+TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
+  gfx::Rect rect(0, 0, 200, 200);
+
+  RenderPass::Id id(1, 1);
+  gfx::Transform transform_to_root;
+  scoped_ptr<RenderPass> pass =
+      CreateTestRenderPass(id, rect, transform_to_root);
+
+  gfx::Transform hole_content_to_target_transform;
+  hole_content_to_target_transform.Translate(50, 50);
+  hole_content_to_target_transform.Scale(
+      0.5f + 1.0f / (rect.width() * 2.0f),
+      0.5f + 1.0f / (rect.height() * 2.0f));
+  scoped_ptr<SharedQuadState> hole_shared_state =
+      CreateTestSharedQuadState(hole_content_to_target_transform, rect);
+
+  scoped_ptr<SolidColorDrawQuad> hole = SolidColorDrawQuad::Create();
+  hole->SetAll(hole_shared_state.get(), rect, rect, rect, false,
+               SK_ColorTRANSPARENT, true);
+  pass->quad_list.push_back(hole.PassAs<DrawQuad>());
+
+  gfx::Transform green_content_to_target_transform;
+  scoped_ptr<SharedQuadState> green_shared_state =
+      CreateTestSharedQuadState(green_content_to_target_transform, rect);
+
+  scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create();
+  green->SetNew(green_shared_state.get(), rect, SK_ColorGREEN, false);
+
+  pass->quad_list.push_back(green.PassAs<DrawQuad>());
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  EXPECT_TRUE(this->RunPixelTest(
+      &pass_list,
+      base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")),
+      ExactPixelComparator(false)));
+}
+
 static void SyncPointCallback(int* callback_count) {
   ++(*callback_count);
   base::MessageLoop::current()->QuitWhenIdle();
@@ -851,7 +902,7 @@ TEST_F(GLRendererPixelTest, PictureDrawQuadNonIdentityScale) {
   scoped_ptr<SolidColorDrawQuad> bottom_right_color_quad =
       SolidColorDrawQuad::Create();
   bottom_right_color_quad->SetNew(
-      bottom_right_green_shared_state.get(), viewport, SK_ColorGREEN);
+      bottom_right_green_shared_state.get(), viewport, SK_ColorGREEN, false);
   pass->quad_list.push_back(bottom_right_color_quad.PassAs<DrawQuad>());
 
   // Add two blue checkerboards taking up the bottom left and top right,
@@ -916,7 +967,7 @@ TEST_F(GLRendererPixelTest, PictureDrawQuadNonIdentityScale) {
                                 half_green_rect);
   scoped_ptr<SolidColorDrawQuad> half_color_quad = SolidColorDrawQuad::Create();
   half_color_quad->SetNew(
-      half_green_shared_state.get(), half_green_rect, SK_ColorGREEN);
+      half_green_shared_state.get(), half_green_rect, SK_ColorGREEN, false);
   pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>());
 
   RenderPassList pass_list;
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index 4584757..74eef53 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -100,9 +100,10 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) {
   root_render_pass->SetNew(
       root_render_pass_id, outer_rect, outer_rect, gfx::Transform());
   scoped_ptr<SolidColorDrawQuad> outer_quad = SolidColorDrawQuad::Create();
-  outer_quad->SetNew(shared_quad_state.get(), outer_rect, SK_ColorYELLOW);
+  outer_quad->SetNew(
+      shared_quad_state.get(), outer_rect, SK_ColorYELLOW, false);
   scoped_ptr<SolidColorDrawQuad> inner_quad = SolidColorDrawQuad::Create();
-  inner_quad->SetNew(shared_quad_state.get(), inner_rect, SK_ColorCYAN);
+  inner_quad->SetNew(shared_quad_state.get(), inner_rect, SK_ColorCYAN, false);
   root_render_pass->AppendQuad(inner_quad.PassAs<DrawQuad>());
   root_render_pass->AppendQuad(outer_quad.PassAs<DrawQuad>());
 
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 9b5c8fd..6c02b1a 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -417,15 +417,18 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
 
 TEST(DrawQuadTest, CopySolidColorDrawQuad) {
   SkColor color = 0x49494949;
+  bool force_anti_aliasing_off = false;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_1_NEW(SolidColorDrawQuad, color);
+  CREATE_QUAD_2_NEW(SolidColorDrawQuad, color, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::SOLID_COLOR, copy_quad->material);
   EXPECT_EQ(color, copy_quad->color);
+  EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 
-  CREATE_QUAD_1_ALL(SolidColorDrawQuad, color);
+  CREATE_QUAD_2_ALL(SolidColorDrawQuad, color, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::SOLID_COLOR, copy_quad->material);
   EXPECT_EQ(color, copy_quad->color);
+  EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 }
 
 TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
@@ -777,9 +780,10 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
 
 TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
   SkColor color = 0x49494949;
+  bool force_anti_aliasing_off = false;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_1_NEW(SolidColorDrawQuad, color);
+  CREATE_QUAD_2_NEW(SolidColorDrawQuad, color, force_anti_aliasing_off);
   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 }
 
diff --git a/cc/quads/solid_color_draw_quad.cc b/cc/quads/solid_color_draw_quad.cc
index 4d004cee..5575aaf 100644
--- a/cc/quads/solid_color_draw_quad.cc
+++ b/cc/quads/solid_color_draw_quad.cc
@@ -8,7 +8,8 @@
 
 namespace cc {
 
-SolidColorDrawQuad::SolidColorDrawQuad() : color(0) {}
+SolidColorDrawQuad::SolidColorDrawQuad()
+    : color(0), force_anti_aliasing_off(false) {}
 
 scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() {
   return make_scoped_ptr(new SolidColorDrawQuad);
@@ -16,13 +17,15 @@ scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() {
 
 void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                 gfx::Rect rect,
-                                SkColor color) {
+                                SkColor color,
+                                bool force_anti_aliasing_off) {
   gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect();
   gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
                    visible_rect, needs_blending);
   this->color = color;
+  this->force_anti_aliasing_off = force_anti_aliasing_off;
 }
 
 void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -30,10 +33,12 @@ void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                 gfx::Rect opaque_rect,
                                 gfx::Rect visible_rect,
                                 bool needs_blending,
-                                SkColor color) {
+                                SkColor color,
+                                bool force_anti_aliasing_off) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
                    visible_rect, needs_blending);
   this->color = color;
+  this->force_anti_aliasing_off = force_anti_aliasing_off;
 }
 
 void SolidColorDrawQuad::IterateResources(
diff --git a/cc/quads/solid_color_draw_quad.h b/cc/quads/solid_color_draw_quad.h
index 690f816..4d7ab9f 100644
--- a/cc/quads/solid_color_draw_quad.h
+++ b/cc/quads/solid_color_draw_quad.h
@@ -18,16 +18,19 @@ class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
 
   void SetNew(const SharedQuadState* shared_quad_state,
               gfx::Rect rect,
-              SkColor color);
+              SkColor color,
+              bool force_anti_aliasing_off);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               gfx::Rect rect,
               gfx::Rect opaque_rect,
               gfx::Rect visible_rect,
               bool needs_blending,
-              SkColor color);
+              SkColor color,
+              bool force_anti_aliasing_off);
 
   SkColor color;
+  bool force_anti_aliasing_off;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index c4f6310..9818603 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -143,7 +143,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
       cc::SolidColorDrawQuad::Create();
   solid_color_quad->SetNew(shared_state.get(),
                            rect,
-                           SK_ColorRED);
+                           SK_ColorRED,
+                           false);
   AppendQuad(solid_color_quad.PassAs<DrawQuad>());
 
   scoped_ptr<cc::StreamVideoDrawQuad> stream_video_quad =
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index 719be7f..a102de0 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -36,7 +36,7 @@ SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
       quad_sink.UseSharedQuadState(SharedQuadState::Create());
   shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-  quad->SetNew(shared_state, rect, color);
+  quad->SetNew(shared_state, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
   quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
   return quad_ptr;
@@ -51,7 +51,7 @@ SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
       quad_sink.UseSharedQuadState(SharedQuadState::Create());
   shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, true, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-  quad->SetNew(shared_state, rect, color);
+  quad->SetNew(shared_state, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
   quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
   return quad_ptr;
@@ -67,7 +67,7 @@ SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
       quad_sink.UseSharedQuadState(SharedQuadState::Create());
   shared_state->SetAll(transform, rect.size(), rect, rect, false, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-  quad->SetNew(shared_state, rect, color);
+  quad->SetNew(shared_state, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
   quad_sink.Append(quad.PassAs<DrawQuad>(), &data);
   return quad_ptr;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 511ea0a..b81c19b 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -504,7 +504,7 @@ static void AppendQuadsToFillScreen(
     // Skip the quad culler and just append the quads directly to avoid
     // occlusion checks.
     scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-    quad->SetNew(shared_quad_state, layer_rect, screen_background_color);
+    quad->SetNew(shared_quad_state, layer_rect, screen_background_color, false);
     quad_culler.Append(quad.PassAs<DrawQuad>(), &append_quads_data);
   }
 }
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 70173a1..0b541c4 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -2698,7 +2698,7 @@ class FakeLayerWithQuads : public LayerImpl {
     SkColor gray = SkColorSetRGB(100, 100, 100);
     gfx::Rect quad_rect(content_bounds());
     scoped_ptr<SolidColorDrawQuad> my_quad = SolidColorDrawQuad::Create();
-    my_quad->SetNew(shared_quad_state, quad_rect, gray);
+    my_quad->SetNew(shared_quad_state, quad_rect, gray, false);
     quad_sink->Append(my_quad.PassAs<DrawQuad>(), append_quads_data);
   }
 
@@ -4417,7 +4417,8 @@ static void ConfigureRenderPassTestData(const char* test_script,
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(test_data->shared_quad_state.get(),
                      gfx::Rect(0, 0, 10, 10),
-                     SK_ColorWHITE);
+                     SK_ColorWHITE,
+                     false);
 
         render_pass->AppendQuad(quad.PassAs<DrawQuad>());
         current_char++;