Add flag for drawing layers to screen with Ganesh

cc/output/renderer_pixeltest.cc

Index: cc/output/renderer_pixeltest.cc
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 672f64b2f3c7f4b8d98b4754cb937611e5279646..2a5ccf2170fa92f1e1dcc53a42b0b695391c24f1 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -97,6 +97,13 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
 typedef ::testing::Types<GLRenderer, SoftwareRenderer> RendererTypes;
 TYPED_TEST_CASE(RendererPixelTest, RendererTypes);
 
+typedef ::testing::Types<GLRenderer, GLRendererWithGanesh, SoftwareRenderer>
+    RendererTypesWithGanesh;
+template <typename RendererType>
+class RendererPixelTestWithGanesh : public RendererPixelTest<RendererType> {
+};
+TYPED_TEST_CASE(RendererPixelTestWithGanesh, RendererTypesWithGanesh);
+
 // All pixels can be off by one, but any more than that is an error.
 class FuzzyPixelOffByOneComparator : public FuzzyPixelComparator {
  public:
@@ -119,17 +126,17 @@ class FuzzyForSoftwareOnlyPixelComparator : public PixelComparator {
 };
 
 template<>
-bool FuzzyForSoftwareOnlyPixelComparator<GLRenderer>::Compare(
+bool FuzzyForSoftwareOnlyPixelComparator<SoftwareRenderer>::Compare(
     const SkBitmap& actual_bmp,
     const SkBitmap& expected_bmp) const {
-  return exact_.Compare(actual_bmp, expected_bmp);
+  return fuzzy_.Compare(actual_bmp, expected_bmp);
 }
 
-template<>
-bool FuzzyForSoftwareOnlyPixelComparator<SoftwareRenderer>::Compare(
+template<typename RendererType>
+bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare(
     const SkBitmap& actual_bmp,
     const SkBitmap& expected_bmp) const {
-  return fuzzy_.Compare(actual_bmp, expected_bmp);
+  return exact_.Compare(actual_bmp, expected_bmp);
 }
 
 #if !defined(OS_ANDROID)
@@ -570,8 +577,10 @@ class RendererPixelTestWithBackgroundFilter
   gfx::Rect filter_pass_content_rect_;
 };
 
-typedef ::testing::Types<GLRenderer, SoftwareRenderer> RendererTypes;
-TYPED_TEST_CASE(RendererPixelTestWithBackgroundFilter, RendererTypes);
+typedef ::testing::Types<GLRenderer, SoftwareRenderer>
+    BackgroundFilterRendererTypes;
+TYPED_TEST_CASE(RendererPixelTestWithBackgroundFilter,
+                BackgroundFilterRendererTypes);
 
 typedef RendererPixelTestWithBackgroundFilter<GLRenderer>
 GLRendererPixelTestWithBackgroundFilter;
@@ -729,9 +738,10 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
       ExactPixelComparator(false)));
 }
 
-TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
+TYPED_TEST(RendererPixelTestWithGanesh, PictureDrawQuadIdentityScale) {
   gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
+  bool use_ganesh = this->UseGanesh();
   // TODO(enne): the renderer should figure this out on its own.
   bool contents_swizzled = !PlatformColor::SameComponentOrder(GL_RGBA);
 
@@ -774,6 +784,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
                     contents_swizzled,
                     viewport,
                     1.f,
+                    use_ganesh,
                     blue_pile);
   pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());
 
@@ -798,6 +809,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
                      contents_swizzled,
                      viewport,
                      1.f,
+                     use_ganesh,
                      green_pile);
   pass->quad_list.push_back(green_quad.PassAs<DrawQuad>());
 
@@ -810,9 +822,10 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
       ExactPixelComparator(true)));
 }
 
-TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
+TYPED_TEST(RendererPixelTestWithGanesh, PictureDrawQuadNonIdentityScale) {
   gfx::Size pile_tile_size(1000, 1000);
   gfx::Rect viewport(this->device_viewport_size_);
+  bool use_ganesh = this->UseGanesh();
   // TODO(enne): the renderer should figure this out on its own.
   bool contents_swizzled = !PlatformColor::SameComponentOrder(GL_RGBA);
 
@@ -851,6 +864,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
                       contents_swizzled,
                       green_rect1,
                       1.f,
+                      use_ganesh,
                       green_pile);
   pass->quad_list.push_back(green_quad1.PassAs<DrawQuad>());
 
@@ -863,6 +877,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
                       contents_swizzled,
                       green_rect2,
                       1.f,
+                      use_ganesh,
                       green_pile);
   pass->quad_list.push_back(green_quad2.PassAs<DrawQuad>());
 
@@ -899,10 +914,13 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_rect.size());
-  pile->add_draw_rect_with_paint(layer_rect, red_paint);
-  SkPaint transparent_paint;
-  transparent_paint.setXfermodeMode(SkXfermode::kClear_Mode);
-  pile->add_draw_rect_with_paint(union_layer_rect, transparent_paint);
+
+  Region outside(layer_rect);

[enne (OOO), 2013/05/13 19:33:10]

This change is because drawing directly with Ganesh would draw this with
"kClearMode" previously, clobbering the old backbuffer.  This changes to only
drawing red outside the area we care about and leaving the union_layer_rect
unchanged.

+  outside.Subtract(gfx::ToEnclosingRect(union_layer_rect));
+  for (Region::Iterator iter(outside); iter.has_rect(); iter.next()) {
+    pile->add_draw_rect_with_paint(iter.rect(), red_paint);
+  }
+
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   pile->add_draw_rect_with_paint(blue_layer_rect1, blue_paint);
@@ -931,6 +949,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
                     contents_swizzled,
                     content_union_rect,
                     contents_scale,
+                    use_ganesh,
                     pile);
   pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());