| OLD | NEW |
|---|
| (Empty) |
| 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 "cc/layers/picture_image_layer.h" | |
| 6 #include "cc/layers/solid_color_layer.h" | |
| 7 #include "cc/test/layer_tree_pixel_resource_test.h" | |
| 8 #include "cc/test/pixel_comparator.h" | |
| 9 | |
| 10 #if !defined(OS_ANDROID) | |
| 11 | |
| 12 namespace cc { | |
| 13 namespace { | |
| 14 | |
| 15 SkXfermode::Mode const kBlendModes[] = { | |
| 16 SkXfermode::kSrcOver_Mode, SkXfermode::kScreen_Mode, | |
| 17 SkXfermode::kOverlay_Mode, SkXfermode::kDarken_Mode, | |
| 18 SkXfermode::kLighten_Mode, SkXfermode::kColorDodge_Mode, | |
| 19 SkXfermode::kColorBurn_Mode, SkXfermode::kHardLight_Mode, | |
| 20 SkXfermode::kSoftLight_Mode, SkXfermode::kDifference_Mode, | |
| 21 SkXfermode::kExclusion_Mode, SkXfermode::kMultiply_Mode, | |
| 22 SkXfermode::kHue_Mode, SkXfermode::kSaturation_Mode, | |
| 23 SkXfermode::kColor_Mode, SkXfermode::kLuminosity_Mode}; | |
| 24 | |
| 25 SkColor kCSSTestColors[] = { | |
| 26 0xffff0000, // red | |
| 27 0xff00ff00, // lime | |
| 28 0xff0000ff, // blue | |
| 29 0xff00ffff, // aqua | |
| 30 0xffff00ff, // fuchsia | |
| 31 0xffffff00, // yellow | |
| 32 0xff008000, // green | |
| 33 0xff800000, // maroon | |
| 34 0xff000080, // navy | |
| 35 0xff800080, // purple | |
| 36 0xff808000, // olive | |
| 37 0xff008080, // teal | |
| 38 0xfffa8072, // salmon | |
| 39 0xffc0c0c0, // silver | |
| 40 0xff000000, // black | |
| 41 0xff808080, // gray | |
| 42 0x80000000, // black with transparency | |
| 43 0xffffffff, // white | |
| 44 0x80ffffff, // white with transparency | |
| 45 0x00000000 // transparent | |
| 46 }; | |
| 47 | |
| 48 const int kBlendModesCount = arraysize(kBlendModes); | |
| 49 const int kCSSTestColorsCount = arraysize(kCSSTestColors); | |
| 50 | |
| 51 using RenderPassOptions = uint32; | |
| 52 const uint32 kUseMasks = 1 << 0; | |
| 53 const uint32 kUseAntialiasing = 1 << 1; | |
| 54 const uint32 kUseColorMatrix = 1 << 2; | |
| 55 const uint32 kForceShaders = 1 << 3; | |
| 56 | |
| 57 class LayerTreeHostBlendingPixelTest : public LayerTreeHostPixelResourceTest { | |
| 58 public: | |
| 59 LayerTreeHostBlendingPixelTest() | |
| 60 : force_antialiasing_(false), force_blending_with_shaders_(false) { | |
| 61 pixel_comparator_.reset(new FuzzyPixelOffByOneComparator(true)); | |
| 62 } | |
| 63 | |
| 64 void InitializeSettings(LayerTreeSettings* settings) override { | |
| 65 settings->renderer_settings.force_antialiasing = force_antialiasing_; | |
| 66 settings->renderer_settings.force_blending_with_shaders = | |
| 67 force_blending_with_shaders_; | |
| 68 } | |
| 69 | |
| 70 protected: | |
| 71 void RunBlendingWithRootPixelTestType(PixelResourceTestCase type) { | |
| 72 const int kLaneWidth = 2; | |
| 73 const int kLaneHeight = kLaneWidth; | |
| 74 const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth; | |
| 75 const int kRootHeight = 2 * kLaneWidth + kLaneHeight; | |
| 76 InitializeFromTestCase(type); | |
| 77 | |
| 78 scoped_refptr<SolidColorLayer> background = | |
| 79 CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange); | |
| 80 | |
| 81 // Orange child layers will blend with the green background | |
| 82 for (int i = 0; i < kBlendModesCount; ++i) { | |
| 83 gfx::Rect child_rect( | |
| 84 (i + 1) * kLaneWidth, kLaneWidth, kLaneWidth, kLaneHeight); | |
| 85 scoped_refptr<SolidColorLayer> green_lane = | |
| 86 CreateSolidColorLayer(child_rect, kCSSGreen); | |
| 87 background->AddChild(green_lane); | |
| 88 green_lane->SetBlendMode(kBlendModes[i]); | |
| 89 } | |
| 90 | |
| 91 RunPixelResourceTest( | |
| 92 background, | |
| 93 base::FilePath(FILE_PATH_LITERAL("blending_with_root.png"))); | |
| 94 } | |
| 95 | |
| 96 void RunBlendingWithTransparentPixelTestType(PixelResourceTestCase type) { | |
| 97 const int kLaneWidth = 2; | |
| 98 const int kLaneHeight = 3 * kLaneWidth; | |
| 99 const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth; | |
| 100 const int kRootHeight = 2 * kLaneWidth + kLaneHeight; | |
| 101 InitializeFromTestCase(type); | |
| 102 | |
| 103 scoped_refptr<SolidColorLayer> root = | |
| 104 CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSBrown); | |
| 105 | |
| 106 scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer( | |
| 107 gfx::Rect(0, kLaneWidth * 2, kRootWidth, kLaneWidth), kCSSOrange); | |
| 108 | |
| 109 root->AddChild(background); | |
| 110 background->SetIsRootForIsolatedGroup(true); | |
| 111 | |
| 112 // Orange child layers will blend with the green background | |
| 113 for (int i = 0; i < kBlendModesCount; ++i) { | |
| 114 gfx::Rect child_rect( | |
| 115 (i + 1) * kLaneWidth, -kLaneWidth, kLaneWidth, kLaneHeight); | |
| 116 scoped_refptr<SolidColorLayer> green_lane = | |
| 117 CreateSolidColorLayer(child_rect, kCSSGreen); | |
| 118 background->AddChild(green_lane); | |
| 119 green_lane->SetBlendMode(kBlendModes[i]); | |
| 120 } | |
| 121 | |
| 122 RunPixelResourceTest( | |
| 123 root, base::FilePath(FILE_PATH_LITERAL("blending_transparent.png"))); | |
| 124 } | |
| 125 | |
| 126 scoped_refptr<Layer> CreateColorfulBackdropLayer(int width, int height) { | |
| 127 // Draw the backdrop with horizontal lanes. | |
| 128 const int kLaneWidth = width; | |
| 129 const int kLaneHeight = height / kCSSTestColorsCount; | |
| 130 SkBitmap backing_store; | |
| 131 backing_store.allocN32Pixels(width, height); | |
| 132 SkCanvas canvas(backing_store); | |
| 133 canvas.clear(SK_ColorTRANSPARENT); | |
| 134 for (int i = 0; i < kCSSTestColorsCount; ++i) { | |
| 135 SkPaint paint; | |
| 136 paint.setColor(kCSSTestColors[i]); | |
| 137 canvas.drawRect( | |
| 138 SkRect::MakeXYWH(0, i * kLaneHeight, kLaneWidth, kLaneHeight), paint); | |
| 139 } | |
| 140 scoped_refptr<PictureImageLayer> layer = PictureImageLayer::Create(); | |
| 141 layer->SetIsDrawable(true); | |
| 142 layer->SetBounds(gfx::Size(width, height)); | |
| 143 layer->SetBitmap(backing_store); | |
| 144 return layer; | |
| 145 } | |
| 146 | |
| 147 void SetupMaskLayer(scoped_refptr<Layer> layer) { | |
| 148 const int kMaskOffset = 2; | |
| 149 gfx::Size bounds = layer->bounds(); | |
| 150 scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create(); | |
| 151 mask->SetIsDrawable(true); | |
| 152 mask->SetIsMask(true); | |
| 153 mask->SetBounds(bounds); | |
| 154 | |
| 155 SkBitmap bitmap; | |
| 156 bitmap.allocN32Pixels(bounds.width(), bounds.height()); | |
| 157 SkCanvas canvas(bitmap); | |
| 158 SkPaint paint; | |
| 159 paint.setColor(SK_ColorWHITE); | |
| 160 canvas.clear(SK_ColorTRANSPARENT); | |
| 161 canvas.drawRect(SkRect::MakeXYWH(kMaskOffset, | |
| 162 kMaskOffset, | |
| 163 bounds.width() - kMaskOffset * 2, | |
| 164 bounds.height() - kMaskOffset * 2), | |
| 165 paint); | |
| 166 mask->SetBitmap(bitmap); | |
| 167 layer->SetMaskLayer(mask.get()); | |
| 168 } | |
| 169 | |
| 170 void SetupColorMatrix(scoped_refptr<Layer> layer) { | |
| 171 FilterOperations filter_operations; | |
| 172 filter_operations.Append(FilterOperation::CreateSepiaFilter(.001f)); | |
| 173 layer->SetFilters(filter_operations); | |
| 174 } | |
| 175 | |
| 176 void CreateBlendingColorLayers(int lane_width, | |
| 177 int lane_height, | |
| 178 scoped_refptr<Layer> background, | |
| 179 RenderPassOptions flags) { | |
| 180 const int kLanesCount = kBlendModesCount + 4; | |
| 181 const SkColor kMiscOpaqueColor = 0xffc86464; | |
| 182 const SkColor kMiscTransparentColor = 0x80c86464; | |
| 183 const SkXfermode::Mode kCoeffBlendMode = SkXfermode::kScreen_Mode; | |
| 184 const SkXfermode::Mode kShaderBlendMode = SkXfermode::kColorBurn_Mode; | |
| 185 // add vertical lanes with each of the blend modes | |
| 186 for (int i = 0; i < kLanesCount; ++i) { | |
| 187 gfx::Rect child_rect(i * lane_width, 0, lane_width, lane_height); | |
| 188 SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; | |
| 189 float opacity = 1.f; | |
| 190 SkColor color = kMiscOpaqueColor; | |
| 191 | |
| 192 if (i < kBlendModesCount) { | |
| 193 blend_mode = kBlendModes[i]; | |
| 194 } else if (i == kBlendModesCount) { | |
| 195 blend_mode = kCoeffBlendMode; | |
| 196 opacity = 0.5f; | |
| 197 } else if (i == kBlendModesCount + 1) { | |
| 198 blend_mode = kCoeffBlendMode; | |
| 199 color = kMiscTransparentColor; | |
| 200 } else if (i == kBlendModesCount + 2) { | |
| 201 blend_mode = kShaderBlendMode; | |
| 202 opacity = 0.5f; | |
| 203 } else if (i == kBlendModesCount + 3) { | |
| 204 blend_mode = kShaderBlendMode; | |
| 205 color = kMiscTransparentColor; | |
| 206 } | |
| 207 | |
| 208 scoped_refptr<SolidColorLayer> lane = | |
| 209 CreateSolidColorLayer(child_rect, color); | |
| 210 lane->SetBlendMode(blend_mode); | |
| 211 lane->SetOpacity(opacity); | |
| 212 lane->SetForceRenderSurface(true); | |
| 213 if (flags & kUseMasks) | |
| 214 SetupMaskLayer(lane); | |
| 215 if (flags & kUseColorMatrix) { | |
| 216 SetupColorMatrix(lane); | |
| 217 } | |
| 218 background->AddChild(lane); | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 void RunBlendingWithRenderPass(PixelResourceTestCase type, | |
| 223 const base::FilePath::CharType* expected_path, | |
| 224 RenderPassOptions flags) { | |
| 225 const int kLaneWidth = 8; | |
| 226 const int kLaneHeight = kLaneWidth * kCSSTestColorsCount; | |
| 227 const int kRootSize = kLaneHeight; | |
| 228 InitializeFromTestCase(type); | |
| 229 | |
| 230 scoped_refptr<SolidColorLayer> root = | |
| 231 CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), SK_ColorWHITE); | |
| 232 scoped_refptr<Layer> background = | |
| 233 CreateColorfulBackdropLayer(kRootSize, kRootSize); | |
| 234 | |
| 235 background->SetIsRootForIsolatedGroup(true); | |
| 236 root->AddChild(background); | |
| 237 | |
| 238 CreateBlendingColorLayers(kLaneWidth, kLaneHeight, background.get(), flags); | |
| 239 | |
| 240 this->force_antialiasing_ = (flags & kUseAntialiasing); | |
| 241 this->force_blending_with_shaders_ = (flags & kForceShaders); | |
| 242 | |
| 243 if ((flags & kUseAntialiasing) && (test_type_ == PIXEL_TEST_GL)) { | |
| 244 // Anti aliasing causes differences up to 8 pixels at the edges. | |
| 245 int large_error_allowed = 8; | |
| 246 // Blending results might differ with one pixel. | |
| 247 int small_error_allowed = 1; | |
| 248 // Most of the errors are one pixel errors. | |
| 249 float percentage_pixels_small_error = 13.1f; | |
| 250 // Because of anti-aliasing, around 10% of pixels (at the edges) have | |
| 251 // bigger errors (from small_error_allowed + 1 to large_error_allowed). | |
| 252 float percentage_pixels_error = 22.5f; | |
| 253 // The average error is still close to 1. | |
| 254 float average_error_allowed_in_bad_pixels = 1.4f; | |
| 255 | |
| 256 pixel_comparator_.reset( | |
| 257 new FuzzyPixelComparator(false, // discard_alpha | |
| 258 percentage_pixels_error, | |
| 259 percentage_pixels_small_error, | |
| 260 average_error_allowed_in_bad_pixels, | |
| 261 large_error_allowed, | |
| 262 small_error_allowed)); | |
| 263 } | |
| 264 | |
| 265 RunPixelResourceTest(root, base::FilePath(expected_path)); | |
| 266 } | |
| 267 | |
| 268 bool force_antialiasing_; | |
| 269 bool force_blending_with_shaders_; | |
| 270 }; | |
| 271 | |
| 272 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) { | |
| 273 RunBlendingWithRootPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW); | |
| 274 } | |
| 275 | |
| 276 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) { | |
| 277 RunBlendingWithRootPixelTestType(SOFTWARE); | |
| 278 } | |
| 279 | |
| 280 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) { | |
| 281 const int kLaneWidth = 2; | |
| 282 const int kLaneHeight = kLaneWidth; | |
| 283 const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth; | |
| 284 const int kRootHeight = 2 * kLaneWidth + kLaneHeight; | |
| 285 InitializeFromTestCase(GL_ASYNC_UPLOAD_2D_DRAW); | |
| 286 | |
| 287 scoped_refptr<SolidColorLayer> background = | |
| 288 CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange); | |
| 289 | |
| 290 // Orange child layers have a background filter set and they will blend with | |
| 291 // the green background | |
| 292 for (int i = 0; i < kBlendModesCount; ++i) { | |
| 293 gfx::Rect child_rect( | |
| 294 (i + 1) * kLaneWidth, kLaneWidth, kLaneWidth, kLaneHeight); | |
| 295 scoped_refptr<SolidColorLayer> green_lane = | |
| 296 CreateSolidColorLayer(child_rect, kCSSGreen); | |
| 297 background->AddChild(green_lane); | |
| 298 | |
| 299 FilterOperations filters; | |
| 300 filters.Append(FilterOperation::CreateGrayscaleFilter(.75)); | |
| 301 green_lane->SetBackgroundFilters(filters); | |
| 302 green_lane->SetBlendMode(kBlendModes[i]); | |
| 303 } | |
| 304 | |
| 305 RunPixelResourceTest( | |
| 306 background, base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png"))); | |
| 307 } | |
| 308 | |
| 309 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) { | |
| 310 RunBlendingWithTransparentPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW); | |
| 311 } | |
| 312 | |
| 313 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) { | |
| 314 RunBlendingWithTransparentPixelTestType(SOFTWARE); | |
| 315 } | |
| 316 | |
| 317 // Tests for render passes | |
| 318 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_GL) { | |
| 319 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 320 FILE_PATH_LITERAL("blending_render_pass.png"), 0); | |
| 321 } | |
| 322 | |
| 323 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_Software) { | |
| 324 RunBlendingWithRenderPass(SOFTWARE, | |
| 325 FILE_PATH_LITERAL("blending_render_pass.png"), 0); | |
| 326 } | |
| 327 | |
| 328 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_GL) { | |
| 329 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 330 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 331 kUseAntialiasing); | |
| 332 } | |
| 333 | |
| 334 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_Software) { | |
| 335 RunBlendingWithRenderPass(SOFTWARE, | |
| 336 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 337 kUseAntialiasing); | |
| 338 } | |
| 339 | |
| 340 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_GL) { | |
| 341 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 342 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 343 kUseMasks); | |
| 344 } | |
| 345 | |
| 346 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 347 BlendingWithRenderPassWithMask_Software) { | |
| 348 RunBlendingWithRenderPass( | |
| 349 SOFTWARE, FILE_PATH_LITERAL("blending_render_pass_mask.png"), kUseMasks); | |
| 350 } | |
| 351 | |
| 352 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_GL) { | |
| 353 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 354 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 355 kUseMasks | kUseAntialiasing); | |
| 356 } | |
| 357 | |
| 358 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 359 BlendingWithRenderPassWithMaskAA_Software) { | |
| 360 RunBlendingWithRenderPass(SOFTWARE, | |
| 361 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 362 kUseMasks | kUseAntialiasing); | |
| 363 } | |
| 364 | |
| 365 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_GL) { | |
| 366 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 367 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 368 kUseColorMatrix); | |
| 369 } | |
| 370 | |
| 371 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 372 BlendingWithRenderPassColorMatrix_Software) { | |
| 373 RunBlendingWithRenderPass( | |
| 374 SOFTWARE, FILE_PATH_LITERAL("blending_render_pass.png"), kUseColorMatrix); | |
| 375 } | |
| 376 | |
| 377 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrixAA_GL) { | |
| 378 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 379 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 380 kUseAntialiasing | kUseColorMatrix); | |
| 381 } | |
| 382 | |
| 383 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 384 BlendingWithRenderPassColorMatrixAA_Software) { | |
| 385 RunBlendingWithRenderPass(SOFTWARE, | |
| 386 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 387 kUseAntialiasing | kUseColorMatrix); | |
| 388 } | |
| 389 | |
| 390 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 391 BlendingWithRenderPassWithMaskColorMatrix_GL) { | |
| 392 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 393 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 394 kUseMasks | kUseColorMatrix); | |
| 395 } | |
| 396 | |
| 397 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 398 BlendingWithRenderPassWithMaskColorMatrix_Software) { | |
| 399 RunBlendingWithRenderPass(SOFTWARE, | |
| 400 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 401 kUseMasks | kUseColorMatrix); | |
| 402 } | |
| 403 | |
| 404 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 405 BlendingWithRenderPassWithMaskColorMatrixAA_GL) { | |
| 406 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 407 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 408 kUseMasks | kUseAntialiasing | kUseColorMatrix); | |
| 409 } | |
| 410 | |
| 411 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 412 BlendingWithRenderPassWithMaskColorMatrixAA_Software) { | |
| 413 RunBlendingWithRenderPass(SOFTWARE, | |
| 414 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 415 kUseMasks | kUseAntialiasing | kUseColorMatrix); | |
| 416 } | |
| 417 | |
| 418 // Tests for render passes forcing shaders for all the blend modes. | |
| 419 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShaders_GL) { | |
| 420 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 421 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 422 kForceShaders); | |
| 423 } | |
| 424 | |
| 425 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShadersAA_GL) { | |
| 426 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 427 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 428 kUseAntialiasing | kForceShaders); | |
| 429 } | |
| 430 | |
| 431 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 432 BlendingWithRenderPassShadersWithMask_GL) { | |
| 433 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 434 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 435 kUseMasks | kForceShaders); | |
| 436 } | |
| 437 | |
| 438 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 439 BlendingWithRenderPassShadersWithMask_GL_TextureRect) { | |
| 440 RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW, | |
| 441 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 442 kUseMasks | kForceShaders); | |
| 443 } | |
| 444 | |
| 445 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 446 BlendingWithRenderPassShadersWithMaskAA_GL) { | |
| 447 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 448 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 449 kUseMasks | kUseAntialiasing | kForceShaders); | |
| 450 } | |
| 451 | |
| 452 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 453 BlendingWithRenderPassShadersWithMaskAA_GL_TextureRect) { | |
| 454 RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW, | |
| 455 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 456 kUseMasks | kUseAntialiasing | kForceShaders); | |
| 457 } | |
| 458 | |
| 459 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 460 BlendingWithRenderPassShadersColorMatrix_GL) { | |
| 461 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 462 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 463 kUseColorMatrix | kForceShaders); | |
| 464 } | |
| 465 | |
| 466 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 467 BlendingWithRenderPassShadersColorMatrixAA_GL) { | |
| 468 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 469 FILE_PATH_LITERAL("blending_render_pass.png"), | |
| 470 kUseAntialiasing | kUseColorMatrix | kForceShaders); | |
| 471 } | |
| 472 | |
| 473 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 474 BlendingWithRenderPassShadersWithMaskColorMatrix_GL) { | |
| 475 RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW, | |
| 476 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 477 kUseMasks | kUseColorMatrix | kForceShaders); | |
| 478 } | |
| 479 | |
| 480 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 481 BlendingWithRenderPassShadersWithMaskColorMatrix_GL_TextureRect) { | |
| 482 RunBlendingWithRenderPass(GL_ZERO_COPY_RECT_DRAW, | |
| 483 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 484 kUseMasks | kUseColorMatrix | kForceShaders); | |
| 485 } | |
| 486 | |
| 487 TEST_F(LayerTreeHostBlendingPixelTest, | |
| 488 BlendingWithRenderPassShadersWithMaskColorMatrixAA_GL) { | |
| 489 RunBlendingWithRenderPass( | |
| 490 GL_ASYNC_UPLOAD_2D_DRAW, | |
| 491 FILE_PATH_LITERAL("blending_render_pass_mask.png"), | |
| 492 kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders); | |
| 493 } | |
| 494 | |
| 495 } // namespace | |
| 496 } // namespace cc | |
| 497 | |
| 498 #endif // OS_ANDROID | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master