Add flag for drawing layers to screen with Ganesh

cc/output/renderer_pixeltest.cc

 // Copyright 2012 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 "base/message_loop.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/resources/platform_color.h"
@@ skipping 79 matching lines @@
                WebKit::WebFilterOperations(),   // foreground filters
                skia::RefPtr<SkImageFilter>(),   // foreground filter
                WebKit::WebFilterOperations());  // background filters
 
   return quad.PassAs<DrawQuad>();
 }
 
 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:
   explicit FuzzyPixelOffByOneComparator(bool discard_alpha)
     : FuzzyPixelComparator(discard_alpha, 100.f, 0.f, 1.f, 1, 0) {}
 };
 
 template <typename RendererType>
 class FuzzyForSoftwareOnlyPixelComparator : public PixelComparator {
  public:
   explicit FuzzyForSoftwareOnlyPixelComparator(bool discard_alpha)
       : fuzzy_(discard_alpha), exact_(discard_alpha) {}
 
   virtual bool Compare(const SkBitmap& actual_bmp,
                        const SkBitmap& expected_bmp) const;
 
  private:
   FuzzyPixelOffByOneComparator fuzzy_;
   ExactPixelComparator exact_;
 };
 
 template<>
-bool FuzzyForSoftwareOnlyPixelComparator<GLRenderer>::Compare(
-    const SkBitmap& actual_bmp,
-    const SkBitmap& expected_bmp) const {
-  return exact_.Compare(actual_bmp, expected_bmp);
-}
-
-template<>
 bool FuzzyForSoftwareOnlyPixelComparator<SoftwareRenderer>::Compare(
     const SkBitmap& actual_bmp,
     const SkBitmap& expected_bmp) const {
   return fuzzy_.Compare(actual_bmp, expected_bmp);
 }
 
+template<typename RendererType>
+bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare(
+    const SkBitmap& actual_bmp,
+    const SkBitmap& expected_bmp) const {
+  return exact_.Compare(actual_bmp, expected_bmp);
+}
+
 #if !defined(OS_ANDROID)
 TYPED_TEST(RendererPixelTest, SimpleGreenRect) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPass::Id id(1, 1);
   scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   scoped_ptr<SharedQuadState> shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect);
 
@@ skipping 418 matching lines @@
     pass_list_.push_back(filter_pass.Pass());
     pass_list_.push_back(root_pass.Pass());
   }
 
   RenderPassList pass_list_;
   WebKit::WebFilterOperations background_filters_;
   gfx::Transform filter_pass_to_target_transform_;
   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;
 
 // TODO(skaslev): The software renderer does not support filters yet.
 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {
   this->background_filters_.append(
       WebKit::WebFilterOperation::createInvertFilter(1.f));
 
   this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_);
@@ skipping 137 matching lines @@
 
   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)));
 }
 
-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);
 
   RenderPass::Id id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // One clipped blue quad in the lower right corner.  Outside the clip
   // is red, which should not appear.
@@ skipping 22 matching lines @@
   scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create();
 
   blue_quad->SetNew(blue_shared_state.get(),
                     viewport,  // Intentionally bigger than clip.
                     gfx::Rect(),
                     viewport,
                     viewport.size(),
                     contents_swizzled,
                     viewport,
                     1.f,
+                    use_ganesh,
                     blue_pile);
   pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());
 
   // One viewport-filling green quad.
   scoped_refptr<FakePicturePileImpl> green_pile =
       FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_pile->add_draw_rect_with_paint(viewport, green_paint);
   green_pile->RerecordPile();
 
   gfx::Transform green_content_to_target_transform;
   scoped_ptr<SharedQuadState> green_shared_state =
       CreateTestSharedQuadState(green_content_to_target_transform, viewport);
 
   scoped_ptr<PictureDrawQuad> green_quad = PictureDrawQuad::Create();
   green_quad->SetNew(green_shared_state.get(),
                      viewport,
                      gfx::Rect(),
                      gfx::RectF(0.f, 0.f, 1.f, 1.f),
                      viewport.size(),
                      contents_swizzled,
                      viewport,
                      1.f,
+                     use_ganesh,
                      green_pile);
   pass->quad_list.push_back(green_quad.PassAs<DrawQuad>());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")),
       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);
 
   RenderPass::Id id(1, 1);
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   // As scaling up the blue checkerboards will cause sampling on the GPU,
   // a few extra "cleanup rects" need to be added to clobber the blending
@@ skipping 18 matching lines @@
 
   scoped_ptr<PictureDrawQuad> green_quad1 = PictureDrawQuad::Create();
   green_quad1->SetNew(top_right_green_shared_quad_state.get(),
                       green_rect1,
                       gfx::Rect(),
                       gfx::RectF(green_rect1.size()),
                       green_rect1.size(),
                       contents_swizzled,
                       green_rect1,
                       1.f,
+                      use_ganesh,
                       green_pile);
   pass->quad_list.push_back(green_quad1.PassAs<DrawQuad>());
 
   scoped_ptr<PictureDrawQuad> green_quad2 = PictureDrawQuad::Create();
   green_quad2->SetNew(top_right_green_shared_quad_state.get(),
                       green_rect2,
                       gfx::Rect(),
                       gfx::RectF(green_rect2.size()),
                       green_rect2.size(),
                       contents_swizzled,
                       green_rect2,
                       1.f,
+                      use_ganesh,
                       green_pile);
   pass->quad_list.push_back(green_quad2.PassAs<DrawQuad>());
 
   // Add a green clipped checkerboard in the bottom right to help test
   // interleaving picture quad content and solid color content.
   gfx::Rect bottom_right_rect(
       gfx::Point(viewport.width() / 2, viewport.height() / 2),
       gfx::Size(viewport.width() / 2, viewport.height() / 2));
   scoped_ptr<SharedQuadState> bottom_right_green_shared_state =
       CreateTestSharedQuadStateClipped(
@@ skipping 16 matching lines @@
   union_layer_rect.Union(blue_layer_rect2);
 
   // Because scaling up will cause sampling outside the rects, add one extra
   // pixel of buffer at the final content scale.
   float inset = -1.f / contents_scale;
   blue_layer_rect1.Inset(inset, inset, inset, inset);
   blue_layer_rect2.Inset(inset, inset, inset, inset);
 
   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);
   pile->add_draw_rect_with_paint(blue_layer_rect2, blue_paint);
   pile->RerecordPile();
 
   gfx::Rect content_rect(
       gfx::ToEnclosingRect(gfx::ScaleRect(layer_rect, contents_scale)));
   gfx::Rect content_union_rect(
       gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale)));
 
   // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,
   // so scale an additional 10x to make them 100x100.
   gfx::Transform content_to_target_transform;
   content_to_target_transform.Scale(10.0, 10.0);
   gfx::Rect quad_content_rect(gfx::Size(20, 20));
   scoped_ptr<SharedQuadState> blue_shared_state =
       CreateTestSharedQuadState(content_to_target_transform, quad_content_rect);
 
   scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create();
   blue_quad->SetNew(blue_shared_state.get(),
                     quad_content_rect,
                     gfx::Rect(),
                     quad_content_rect,
                     content_union_rect.size(),
                     contents_swizzled,
                     content_union_rect,
                     contents_scale,
+                    use_ganesh,
                     pile);
   pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());
 
   // Fill left half of viewport with green.
   gfx::Transform half_green_content_to_target_transform;
   gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));
   scoped_ptr<SharedQuadState> half_green_shared_state =
       CreateTestSharedQuadState(half_green_content_to_target_transform,
                                 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, false);
   pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
       ExactPixelComparator(true)));
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc