cc/trees/layer_tree_host_pixeltest_masks.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "build/build_config.h"
   6 #include "cc/layers/content_layer.h"
   7 #include "cc/layers/content_layer_client.h"
   8 #include "cc/layers/image_layer.h"
   9 #include "cc/layers/solid_color_layer.h"
  10 #include "cc/test/layer_tree_pixel_test.h"
  11 #include "cc/test/pixel_comparator.h"
  12
  13 #if !defined(OS_ANDROID)
  14
  15 namespace cc {
  16 namespace {
  17
  18 class LayerTreeHostMasksPixelTest : public LayerTreePixelTest {};
  19
  20 class MaskContentLayerClient : public cc::ContentLayerClient {
  21  public:
  22   MaskContentLayerClient() {}
  23   virtual ~MaskContentLayerClient() {}
  24
  25   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
  26
  27   virtual void PaintContents(SkCanvas* canvas,
  28                              gfx::Rect rect,
  29                              gfx::RectF* opaque_rect) OVERRIDE {
  30     SkPaint paint;
  31     paint.setStyle(SkPaint::kStroke_Style);
  32     paint.setStrokeWidth(SkIntToScalar(2));
  33     paint.setColor(SK_ColorWHITE);
  34
  35     canvas->clear(SK_ColorTRANSPARENT);
  36     while (!rect.IsEmpty()) {
  37       rect.Inset(3, 3, 2, 2);
  38       canvas->drawRect(
  39           SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height()),
  40           paint);
  41       rect.Inset(3, 3, 2, 2);
  42     }
  43   }
  44 };
  45
  46 TEST_F(LayerTreeHostMasksPixelTest, MaskOfLayer) {
  47   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
  48       gfx::Rect(200, 200), SK_ColorWHITE);
  49
  50   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
  51       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
  52   background->AddChild(green);
  53
  54   MaskContentLayerClient client;
  55   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
  56   mask->SetBounds(gfx::Size(100, 100));
  57   mask->SetIsDrawable(true);
  58   mask->SetIsMask(true);
  59   green->SetMaskLayer(mask.get());
  60
  61   RunPixelTest(GL_WITH_BITMAP,
  62                background,
  63                base::FilePath(FILE_PATH_LITERAL("mask_of_layer.png")));
  64 }
  65
  66 TEST_F(LayerTreeHostMasksPixelTest, ImageMaskOfLayer) {
  67   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
  68       gfx::Rect(200, 200), SK_ColorWHITE);
  69
  70   scoped_refptr<ImageLayer> mask = ImageLayer::Create();
  71   mask->SetIsDrawable(true);
  72   mask->SetIsMask(true);
  73   mask->SetBounds(gfx::Size(100, 100));
  74
  75   SkBitmap bitmap;
  76   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 400, 400);
  77   bitmap.allocPixels();
  78   SkCanvas canvas(bitmap);
  79   canvas.scale(SkIntToScalar(4), SkIntToScalar(4));
  80   MaskContentLayerClient client;
  81   client.PaintContents(&canvas,
  82                        gfx::Rect(100, 100),
  83                        NULL);
  84   mask->SetBitmap(bitmap);
  85
  86   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
  87       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
  88   green->SetMaskLayer(mask.get());
  89   background->AddChild(green);
  90
  91   RunPixelTest(GL_WITH_BITMAP,
  92                background,
  93                base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")));
  94 }
  95
  96 TEST_F(LayerTreeHostMasksPixelTest, MaskOfClippedLayer) {
  97   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
  98       gfx::Rect(200, 200), SK_ColorWHITE);
  99
 100   // Clip to the top half of the green layer.
 101   scoped_refptr<Layer> clip = Layer::Create();
 102   clip->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 103   clip->SetPosition(gfx::Point(0, 0));
 104   clip->SetBounds(gfx::Size(200, 100));
 105   clip->SetMasksToBounds(true);
 106   background->AddChild(clip);
 107
 108   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
 109       gfx::Rect(50, 50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
 110   clip->AddChild(green);
 111
 112   MaskContentLayerClient client;
 113   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
 114   mask->SetBounds(gfx::Size(100, 100));
 115   mask->SetIsDrawable(true);
 116   mask->SetIsMask(true);
 117   green->SetMaskLayer(mask.get());
 118
 119   RunPixelTest(GL_WITH_BITMAP,
 120                background,
 121                base::FilePath(FILE_PATH_LITERAL("mask_of_clipped_layer.png")));
 122 }
 123
 124 TEST_F(LayerTreeHostMasksPixelTest, MaskWithReplica) {
 125   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
 126       gfx::Rect(200, 200), SK_ColorWHITE);
 127
 128   MaskContentLayerClient client;
 129   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
 130   mask->SetBounds(gfx::Size(100, 100));
 131   mask->SetIsDrawable(true);
 132   mask->SetIsMask(true);
 133
 134   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
 135       gfx::Rect(0, 0, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
 136   background->AddChild(green);
 137   green->SetMaskLayer(mask.get());
 138
 139   gfx::Transform replica_transform;
 140   replica_transform.Rotate(-90.0);
 141
 142   scoped_refptr<Layer> replica = Layer::Create();
 143   replica->SetAnchorPoint(gfx::PointF(0.5f, 0.5f));
 144   replica->SetPosition(gfx::Point(100, 100));
 145   replica->SetTransform(replica_transform);
 146   green->SetReplicaLayer(replica.get());
 147
 148   RunPixelTest(GL_WITH_BITMAP,
 149                background,
 150                base::FilePath(FILE_PATH_LITERAL("mask_with_replica.png")));
 151 }
 152
 153 TEST_F(LayerTreeHostMasksPixelTest, MaskWithReplicaOfClippedLayer) {
 154   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
 155       gfx::Rect(200, 200), SK_ColorWHITE);
 156
 157   MaskContentLayerClient client;
 158   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
 159   mask->SetBounds(gfx::Size(100, 100));
 160   mask->SetIsDrawable(true);
 161   mask->SetIsMask(true);
 162
 163   // Clip to the bottom half of the green layer, and the left half of the
 164   // replica.
 165   scoped_refptr<Layer> clip = Layer::Create();
 166   clip->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 167   clip->SetPosition(gfx::Point(0, 50));
 168   clip->SetBounds(gfx::Size(150, 150));
 169   clip->SetMasksToBounds(true);
 170   background->AddChild(clip);
 171
 172   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
 173       gfx::Rect(0, -50, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
 174   clip->AddChild(green);
 175   green->SetMaskLayer(mask.get());
 176
 177   gfx::Transform replica_transform;
 178   replica_transform.Rotate(-90.0);
 179
 180   scoped_refptr<Layer> replica = Layer::Create();
 181   replica->SetAnchorPoint(gfx::PointF(0.5f, 0.5f));
 182   replica->SetPosition(gfx::Point(100, 100));
 183   replica->SetTransform(replica_transform);
 184   green->SetReplicaLayer(replica.get());
 185
 186   RunPixelTest(GL_WITH_BITMAP,
 187                background,
 188                base::FilePath(FILE_PATH_LITERAL(
 189                    "mask_with_replica_of_clipped_layer.png")));
 190 }
 191
 192 TEST_F(LayerTreeHostMasksPixelTest, MaskOfReplica) {
 193   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
 194       gfx::Rect(200, 200), SK_ColorWHITE);
 195
 196   MaskContentLayerClient client;
 197   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
 198   mask->SetBounds(gfx::Size(100, 100));
 199   mask->SetIsDrawable(true);
 200   mask->SetIsMask(true);
 201
 202   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
 203       gfx::Rect(50, 0, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
 204   background->AddChild(green);
 205
 206   scoped_refptr<SolidColorLayer> orange = CreateSolidColorLayer(
 207       gfx::Rect(-50, 50, 50, 50), kCSSOrange);
 208   green->AddChild(orange);
 209
 210   gfx::Transform replica_transform;
 211   replica_transform.Rotate(180.0);
 212   replica_transform.Translate(100.0, 0.0);
 213
 214   scoped_refptr<Layer> replica = Layer::Create();
 215   replica->SetAnchorPoint(gfx::PointF(1.f, 1.f));
 216   replica->SetPosition(gfx::Point());
 217   replica->SetTransform(replica_transform);
 218   replica->SetMaskLayer(mask.get());
 219   green->SetReplicaLayer(replica.get());
 220
 221   RunPixelTest(GL_WITH_BITMAP,
 222                background,
 223                base::FilePath(FILE_PATH_LITERAL("mask_of_replica.png")));
 224 }
 225
 226 TEST_F(LayerTreeHostMasksPixelTest, MaskOfReplicaOfClippedLayer) {
 227   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
 228       gfx::Rect(200, 200), SK_ColorWHITE);
 229
 230   MaskContentLayerClient client;
 231   scoped_refptr<ContentLayer> mask = ContentLayer::Create(&client);
 232   mask->SetBounds(gfx::Size(100, 100));
 233   mask->SetIsDrawable(true);
 234   mask->SetIsMask(true);
 235
 236   // Clip to the bottom 3/4 of the green layer, and the top 3/4 of the replica.
 237   scoped_refptr<Layer> clip = Layer::Create();
 238   clip->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 239   clip->SetPosition(gfx::Point(0, 25));
 240   clip->SetBounds(gfx::Size(200, 150));
 241   clip->SetMasksToBounds(true);
 242   background->AddChild(clip);
 243
 244   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayerWithBorder(
 245       gfx::Rect(50, -25, 100, 100), kCSSGreen, 1, SK_ColorBLACK);
 246   clip->AddChild(green);
 247
 248   scoped_refptr<SolidColorLayer> orange = CreateSolidColorLayer(
 249       gfx::Rect(-50, 50, 50, 50), kCSSOrange);
 250   green->AddChild(orange);
 251
 252   gfx::Transform replica_transform;
 253   replica_transform.Rotate(180.0);
 254   replica_transform.Translate(100.0, 0.0);
 255
 256   scoped_refptr<Layer> replica = Layer::Create();
 257   replica->SetAnchorPoint(gfx::PointF(1.f, 1.f));
 258   replica->SetPosition(gfx::Point());
 259   replica->SetTransform(replica_transform);
 260   replica->SetMaskLayer(mask.get());
 261   green->SetReplicaLayer(replica.get());
 262
 263   RunPixelTest(GL_WITH_BITMAP,
 264                background,
 265                base::FilePath(FILE_PATH_LITERAL(
 266                    "mask_of_replica_of_clipped_layer.png")));
 267 }
 268
 269 }  // namespace
 270 }  // namespace cc
 271
 272 #endif  // OS_ANDROID