cc: Support texture rect targets for masks

cc/trees/layer_tree_host_pixeltest_masks.cc

 // Copyright 2013 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 "build/build_config.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_image_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_test.h"
 #include "cc/test/pixel_comparator.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
-class LayerTreeHostMasksPixelTest : public LayerTreePixelTest {};
+class LayerTreeHostMasksPixelTest : public LayerTreePixelTest,
+                                    public ::testing::WithParamInterface<
+                                        LayerTreeSettings::TextureTargetPrefs> {
+ public:
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->texture_target_prefs = GetParam();
+    LayerTreePixelTest::InitializeSettings(settings);
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(
+    MaskTests,
+    LayerTreeHostMasksPixelTest,
+    ::testing::Values(LayerTreeSettings::FORCE_TEXTURE_2D_TARGET,
+                      LayerTreeSettings::FORCE_TEXTURE_RECT_TARGET));

[reveman, 2014/10/22 12:40:39]

We should be testing EXTERNAL_OES target too.

 
 class MaskContentLayerClient : public ContentLayerClient {
  public:
   explicit MaskContentLayerClient(const gfx::Size& bounds) : bounds_(bounds) {}
   ~MaskContentLayerClient() override {}
 
   void DidChangeLayerCanUseLCDText() override {}
 
   bool FillsBoundsCompletely() const override { return false; }
 
@@ skipping 15 matching lines @@
                            inset_rect.width(), inset_rect.height()),
           paint);
       inset_rect.Inset(3, 3, 2, 2);
     }
   }
 
  private:
   gfx::Size bounds_;
 };
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskOfLayer) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
   background->AddChild(green);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
   green->SetMaskLayer(mask.get());
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("mask_of_layer.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, ImageMaskOfLayer) {
+TEST_P(LayerTreeHostMasksPixelTest, ImageMaskOfLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   gfx::Size mask_bounds(100, 100);
 
   scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create();
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
   mask->SetBounds(mask_bounds);
 
@@ skipping 10 matching lines @@
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
   green->SetMaskLayer(mask.get());
   background->AddChild(green);
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskOfClippedLayer) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfClippedLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   // Clip to the top half of the green layer.
   scoped_refptr<Layer> clip = Layer::Create();
   clip->SetPosition(gfx::Point(0, 0));
   clip->SetBounds(gfx::Size(200, 100));
   clip->SetMasksToBounds(true);
   background->AddChild(clip);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
   clip->AddChild(green);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
   green->SetMaskLayer(mask.get());
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("mask_of_clipped_layer.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskWithReplica) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskWithReplica) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
       gfx::Rect(0, 0, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
   background->AddChild(green);
   green->SetMaskLayer(mask.get());
 
   gfx::Transform replica_transform;
   replica_transform.Rotate(-90.0);
 
   scoped_refptr<Layer> replica = Layer::Create();
   replica->SetTransformOrigin(gfx::Point3F(50.f, 50.f, 0.f));
   replica->SetPosition(gfx::Point(100, 100));
   replica->SetTransform(replica_transform);
   green->SetReplicaLayer(replica.get());
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("mask_with_replica.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskWithReplicaOfClippedLayer) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskWithReplicaOfClippedLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
 
@@ skipping 18 matching lines @@
   replica->SetPosition(gfx::Point(100, 100));
   replica->SetTransform(replica_transform);
   green->SetReplicaLayer(replica.get());
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL(
                    "mask_with_replica_of_clipped_layer.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskOfReplica) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfReplica) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
 
@@ skipping 14 matching lines @@
   replica->SetPosition(gfx::Point());
   replica->SetTransform(replica_transform);
   replica->SetMaskLayer(mask.get());
   green->SetReplicaLayer(replica.get());
 
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("mask_of_replica.png")));
 }
 
-TEST_F(LayerTreeHostMasksPixelTest, MaskOfReplicaOfClippedLayer) {
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfReplicaOfClippedLayer) {
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   gfx::Size mask_bounds(100, 100);
   MaskContentLayerClient client(mask_bounds);
   scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetIsMask(true);
 
@@ skipping 26 matching lines @@
   RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(
                    FILE_PATH_LITERAL("mask_of_replica_of_clipped_layer.png")));
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID