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"
@@ skipping 130 matching lines @@
   mask->SetBounds(mask_bounds);
   mask->SetIsDrawable(true);
   mask->SetLayerMaskType(Layer::LayerMaskType::MULTI_TEXTURE_MASK);
   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(40, 40);

[enne (OOO), 2017/05/02 21:31:37]

Feel free to take or leave this suggestion, but if you made the mask bounds 50,
50, would that make it stretch but line up on pixel boundaries, so all tests
ended with the same result?

[ericrk, 2017/05/04 19:23:53]

Per discussion, doesn't quite work. Added fuzzy comparison for BITMAP provider.

+  MaskContentLayerClient client(mask_bounds);
+  scoped_refptr<PictureLayer> mask = PictureLayer::Create(&client);
+  mask->SetBounds(mask_bounds);
+  mask->SetIsDrawable(true);
+  mask->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);

[sunxd, 2017/05/03 15:14:13]

I made a recent change that makes pixeltest tests both SINGLE_TEXTURE_MASK and
MULTI_TEXTURE_MASK.

Can you change this line to:

mask->SetLayerMaskType(mask_type_);

[ericrk, 2017/05/04 19:23:53]

done. Thanks!

+  green->SetMaskLayer(mask.get());
+
+  if (raster_buffer_provider_type_ == RASTER_BUFFER_PROVIDER_TYPE_BITMAP) {
+    // Bitmap produces a sharper (but equivalent sized) mask.
+    RunPixelResourceTest(
+        background,
+        base::FilePath(FILE_PATH_LITERAL("mask_of_larger_layer_bitmap.png")));
+  } else {
+    RunPixelResourceTest(
+        background,
+        base::FilePath(FILE_PATH_LITERAL("mask_of_larger_layer.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 173 matching lines @@
 
   RunPixelResourceTest(background,
                        base::FilePath(
                            FILE_PATH_LITERAL("mask_of_layer_with_blend.png")));
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // !defined(OS_ANDROID)