Determine mask UVs based on texture size

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 <stddef.h>
 
 #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/paint/drawing_display_item.h"
 #include "cc/paint/paint_flags.h"
 #include "cc/paint/paint_image.h"
 #include "cc/paint/paint_recorder.h"
+#include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
 #include "cc/test/solid_color_content_layer_client.h"
 #include "third_party/skia/include/core/SkImage.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
@@ skipping 116 matching lines @@
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetLayerMaskType(mask_type_);
   green->SetMaskLayer(mask.get());
 
   RunPixelResourceTest(
       background,
       base::FilePath(FILE_PATH_LITERAL("mask_of_clipped_layer.png")));
 }
 
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfLargerLayer) {
+  scoped_refptr<SolidColorLayer> background =
+      CreateSolidColorLayer(gfx::Rect(100, 100), SK_ColorWHITE);
+
+  scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
+      gfx::Rect(0, 0, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
+  background->AddChild(green);
+
+  gfx::Size mask_bounds(50, 50);
+  MaskContentLayerClient client(mask_bounds);
+  scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
+  mask->SetBounds(mask_bounds);
+  mask->SetIsDrawable(true);
+  mask->SetLayerMaskType(mask_type_);
+  green->SetMaskLayer(mask.get());
+
+  if (raster_buffer_provider_type_ == RASTER_BUFFER_PROVIDER_TYPE_BITMAP) {
+    // Bitmap produces a sharper (but equivalent sized) mask.
+    float percentage_pixels_large_error = 40.0f;
+    float percentage_pixels_small_error = 0.0f;
+    float average_error_allowed_in_bad_pixels = 65.0f;
+    int large_error_allowed = 120;
+    int small_error_allowed = 0;
+    pixel_comparator_.reset(new FuzzyPixelComparator(
+        true,  // discard_alpha
+        percentage_pixels_large_error, percentage_pixels_small_error,
+        average_error_allowed_in_bad_pixels, large_error_allowed,
+        small_error_allowed));
+  }
+
+  RunPixelResourceTest(
+      background,
+      base::FilePath(FILE_PATH_LITERAL("mask_of_larger_layer.png")));
+}
+
+TEST_P(LayerTreeHostMasksPixelTest, MaskOfLayerNonExactTextureSize) {
+  // This test only makes sense in single texture mode.
+  if (mask_type_ != Layer::LayerMaskType::SINGLE_TEXTURE_MASK)
+    return;
+
+  scoped_refptr<SolidColorLayer> background =
+      CreateSolidColorLayer(gfx::Rect(100, 100), SK_ColorWHITE);
+
+  scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
+      gfx::Rect(0, 0, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
+  background->AddChild(green);
+
+  gfx::Size mask_bounds(100, 100);
+  MaskContentLayerClient client(mask_bounds);
+  scoped_refptr<FakePictureLayer> mask = FakePictureLayer::Create(&client);
+  mask->SetBounds(mask_bounds);
+  mask->SetIsDrawable(true);
+  mask->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);

[sunxd, 2017/05/04 19:43:49]

Nit: Could you also change this to mask_type_? Thanks!

[ericrk, 2017/05/04 19:51:38]

I don't think this test makes sense for tiled masks - see the early-out at line
189

[ericrk, 2017/05/04 19:55:06]

I guess it can't hurt though... ok, added

+  mask->set_fixed_tile_size(gfx::Size(173, 135));
+  green->SetMaskLayer(mask.get());
+
+  RunPixelResourceTest(background,
+                       base::FilePath(FILE_PATH_LITERAL(
+                           "mask_with_non_exact_texture_size.png")));
+}
+
 class CheckerContentLayerClient : public ContentLayerClient {
  public:
   CheckerContentLayerClient(const gfx::Size& bounds,
                            SkColor color,
                            bool vertical)
       : bounds_(bounds), color_(color), vertical_(vertical) {}
   ~CheckerContentLayerClient() override {}
   bool FillsBoundsCompletely() const override { return false; }
   size_t GetApproximateUnsharedMemoryUsage() const override { return 0; }
   gfx::Rect PaintableRegion() override { return gfx::Rect(bounds_); }
@@ skipping 177 matching lines @@
 
   RunPixelResourceTest(background,
                        base::FilePath(
                            FILE_PATH_LITERAL("mask_of_layer_with_blend.png")));
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // !defined(OS_ANDROID)