1 /* 2 * Copyright (C) 2010 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include "config.h" 32 #include "TransparencyWin.h" 33 34 #include "AffineTransform.h" 35 #include "ImageBuffer.h" 36 37 #include <gtest/gtest.h> 38 #include <windows.h> 39 40 namespace WebCore { 41 42 static FloatRect RECTToFloatRect(const RECT* rect) 43 { 44 return FloatRect(static_cast<float>(rect->left), 45 static_cast<float>(rect->top), 46 static_cast<float>(rect->right - rect->left), 47 static_cast<float>(rect->bottom - rect->top)); 48 } 49 50 static void drawNativeRect(GraphicsContext* context, 51 int x, int y, int w, int h) 52 { 53 skia::PlatformCanvas* canvas = context->platformContext()->canvas(); 54 HDC dc = canvas->beginPlatformPaint(); 55 56 RECT innerRc; 57 innerRc.left = x; 58 innerRc.top = y; 59 innerRc.right = x + w; 60 innerRc.bottom = y + h; 61 FillRect(dc, &innerRc, 62 reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH))); 63 64 canvas->endPlatformPaint(); 65 } 66 67 static Color getPixelAt(GraphicsContext* context, int x, int y) 68 { 69 const SkBitmap& bitmap = context->platformContext()->canvas()-> 70 getTopPlatformDevice().accessBitmap(false); 71 return Color(*reinterpret_cast<const RGBA32*>(bitmap.getAddr32(x, y))); 72 } 73 74 // Resets the top layer's alpha channel to 0 for each pixel. This simulates 75 // Windows messing it up. 76 static void clearTopLayerAlphaChannel(GraphicsContext* context) 77 { 78 SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> 79 canvas()->getTopPlatformDevice().accessBitmap(false)); 80 for (int y = 0; y < bitmap.height(); y++) { 81 uint32_t* row = bitmap.getAddr32(0, y); 82 for (int x = 0; x < bitmap.width(); x++) 83 row[x] &= 0x00FFFFFF; 84 } 85 } 86 87 // Clears the alpha channel on the specified pixel. 88 static void clearTopLayerAlphaPixel(GraphicsContext* context, int x, int y) 89 { 90 SkBitmap& bitmap = const_cast<SkBitmap&>(context->platformContext()-> 91 canvas()->getTopPlatformDevice().accessBitmap(false)); 92 *bitmap.getAddr32(x, y) &= 0x00FFFFFF; 93 } 94 95 static std::ostream& operator<<(std::ostream& out, const Color& c) 96 { 97 std::ios_base::fmtflags oldFlags = out.flags(std::ios_base::hex | 98 std::ios_base::showbase); 99 out << c.rgb(); 100 out.flags(oldFlags); 101 return out; 102 } 103 104 TEST(TransparencyWin, NoLayer) 105 { 106 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), DeviceRGB)); 107 108 // KeepTransform 109 { 110 TransparencyWin helper; 111 helper.init(src->context(), 112 TransparencyWin::NoLayer, 113 TransparencyWin::KeepTransform, 114 IntRect(1, 1, 14, 12)); 115 116 EXPECT_TRUE(src->context() == helper.context()); 117 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 118 EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); 119 } 120 121 // Untransform is not allowed for NoLayer. 122 123 // ScaleTransform 124 src->context()->save(); 125 src->context()->scale(FloatSize(2.0, 0.5)); 126 { 127 TransparencyWin helper; 128 helper.init(src->context(), 129 TransparencyWin::NoLayer, 130 TransparencyWin::ScaleTransform, 131 IntRect(2, 2, 6, 6)); 132 helper.composite(); 133 134 // The coordinate system should be based in the upper left of our box. 135 // It should be post-transformed. 136 EXPECT_TRUE(src->context() == helper.context()); 137 EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); 138 EXPECT_TRUE(IntRect(4, 1, 12, 3) == helper.drawRect()); 139 } 140 src->context()->restore(); 141 } 142 143 TEST(TransparencyWin, WhiteLayer) 144 { 145 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 146 147 // KeepTransform 148 { 149 TransparencyWin helper; 150 helper.init(src->context(), 151 TransparencyWin::WhiteLayer, 152 TransparencyWin::KeepTransform, 153 IntRect(1, 1, 14, 12)); 154 helper.composite(); 155 156 EXPECT_TRUE(src->context() != helper.context()); 157 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 158 EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); 159 } 160 161 // Untransform 162 { 163 TransparencyWin helper; 164 helper.init(src->context(), 165 TransparencyWin::WhiteLayer, 166 TransparencyWin::Untransform, 167 IntRect(1, 1, 14, 12)); 168 helper.composite(); 169 170 EXPECT_TRUE(src->context() != helper.context()); 171 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 172 EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); 173 } 174 175 // ScaleTransform 176 src->context()->save(); 177 src->context()->scale(FloatSize(2.0, 0.5)); 178 { 179 TransparencyWin helper; 180 helper.init(src->context(), 181 TransparencyWin::WhiteLayer, 182 TransparencyWin::ScaleTransform, 183 IntRect(2, 2, 6, 6)); 184 helper.composite(); 185 186 // The coordinate system should be based in the upper left of our box. 187 // It should be post-transformed. 188 EXPECT_TRUE(src->context() != helper.context()); 189 EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); 190 EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); 191 } 192 src->context()->restore(); 193 } 194 195 TEST(TransparencyWin, TextComposite) 196 { 197 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 198 199 // KeepTransform is the only valid transform mode for TextComposite. 200 { 201 TransparencyWin helper; 202 helper.init(src->context(), 203 TransparencyWin::TextComposite, 204 TransparencyWin::KeepTransform, 205 IntRect(1, 1, 14, 12)); 206 helper.composite(); 207 208 EXPECT_TRUE(src->context() != helper.context()); 209 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 210 EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); 211 } 212 } 213 214 TEST(TransparencyWin, OpaqueCompositeLayer) 215 { 216 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 217 218 // KeepTransform 219 { 220 TransparencyWin helper; 221 helper.init(src->context(), 222 TransparencyWin::OpaqueCompositeLayer, 223 TransparencyWin::KeepTransform, 224 IntRect(1, 1, 14, 12)); 225 helper.composite(); 226 227 EXPECT_TRUE(src->context() != helper.context()); 228 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 229 EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect()); 230 } 231 232 // KeepTransform with scroll applied. 233 src->context()->save(); 234 src->context()->translate(0, -1); 235 { 236 TransparencyWin helper; 237 helper.init(src->context(), 238 TransparencyWin::OpaqueCompositeLayer, 239 TransparencyWin::KeepTransform, 240 IntRect(1, 1, 14, 14)); 241 helper.composite(); 242 243 EXPECT_TRUE(src->context() != helper.context()); 244 EXPECT_TRUE(IntSize(14, 14) == helper.m_layerSize); 245 EXPECT_TRUE(IntRect(1, 1, 14, 14) == helper.drawRect()); 246 } 247 src->context()->restore(); 248 249 // Untransform 250 { 251 TransparencyWin helper; 252 helper.init(src->context(), 253 TransparencyWin::OpaqueCompositeLayer, 254 TransparencyWin::Untransform, 255 IntRect(1, 1, 14, 12)); 256 helper.composite(); 257 258 EXPECT_TRUE(src->context() != helper.context()); 259 EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize); 260 EXPECT_TRUE(IntRect(0, 0, 14, 12) == helper.drawRect()); 261 } 262 263 // ScaleTransform 264 src->context()->save(); 265 src->context()->scale(FloatSize(2.0, 0.5)); 266 { 267 TransparencyWin helper; 268 helper.init(src->context(), 269 TransparencyWin::OpaqueCompositeLayer, 270 TransparencyWin::ScaleTransform, 271 IntRect(2, 2, 6, 6)); 272 helper.composite(); 273 274 // The coordinate system should be based in the upper left of our box. 275 // It should be post-transformed. 276 EXPECT_TRUE(src->context() != helper.context()); 277 EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize); 278 EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect()); 279 } 280 src->context()->restore(); 281 } 282 283 TEST(TransparencyWin, WhiteLayerPixelTest) 284 { 285 // Make a total transparent buffer, and draw the white layer inset by 1 px. 286 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 287 288 { 289 TransparencyWin helper; 290 helper.init(src->context(), 291 TransparencyWin::WhiteLayer, 292 TransparencyWin::KeepTransform, 293 IntRect(1, 1, 14, 14)); 294 295 // Coordinates should be in the original space, not the layer. 296 drawNativeRect(helper.context(), 3, 3, 1, 1); 297 clearTopLayerAlphaChannel(helper.context()); 298 helper.composite(); 299 } 300 301 // The final image should be transparent around the edges for 1 px, white 302 // in the middle, with (3,3) (what we drew above) being opaque black. 303 EXPECT_EQ(Color(Color::transparent), getPixelAt(src->context(), 0, 0)); 304 EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); 305 EXPECT_EQ(Color(Color::black), getPixelAt(src->context(), 3, 3)); 306 EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 4, 4)); 307 } 308 309 TEST(TransparencyWin, OpaqueCompositeLayerPixel) 310 { 311 Color red(0xFFFF0000), darkRed(0xFFBF0000); 312 Color green(0xFF00FF00); 313 314 // Make a red bottom layer, followed by a half green next layer @ 50%. 315 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 316 317 FloatRect fullRect(0, 0, 16, 16); 318 src->context()->fillRect(fullRect, red, DeviceColorSpace); 319 src->context()->beginTransparencyLayer(0.5); 320 FloatRect rightHalf(8, 0, 8, 16); 321 src->context()->fillRect(rightHalf, green, DeviceColorSpace); 322 323 // Make a transparency layer inset by one pixel, and fill it inset by 324 // another pixel with 50% black. 325 { 326 TransparencyWin helper; 327 helper.init(src->context(), 328 TransparencyWin::OpaqueCompositeLayer, 329 TransparencyWin::KeepTransform, 330 IntRect(1, 1, 14, 14)); 331 332 FloatRect inner(2, 2, 12, 12); 333 helper.context()->fillRect(inner, Color(0x7f000000), DeviceColorSpace); 334 // These coordinates are relative to the layer, whish is inset by 1x1 335 // pixels from the top left. So we're actually clearing (2, 2) and 336 // (13,13), which are the extreme corners of the black area (and which 337 // we check below). 338 clearTopLayerAlphaPixel(helper.context(), 1, 1); 339 clearTopLayerAlphaPixel(helper.context(), 12, 12); 340 helper.composite(); 341 } 342 343 // Finish the compositing. 344 src->context()->endTransparencyLayer(); 345 346 // Check that we got the right values, it should be like the rectangle was 347 // drawn with half opacity even though the alpha channel got messed up. 348 EXPECT_EQ(red, getPixelAt(src->context(), 0, 0)); 349 EXPECT_EQ(red, getPixelAt(src->context(), 1, 1)); 350 EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); 351 352 // The dark result is: 353 // (black @ 50% atop green) @ 50% atop red = 0xFF804000 354 // which is 0xFFA02000 (Skia computes 0xFFA11F00 due to rounding). 355 Color darkGreenRed(0xFF803f00); 356 EXPECT_EQ(darkGreenRed, getPixelAt(src->context(), 13, 13)); 357 358 // 50% green on top of red = FF808000 (rounded to what Skia will produce). 359 Color greenRed(0xFF807F00); 360 EXPECT_EQ(greenRed, getPixelAt(src->context(), 14, 14)); 361 EXPECT_EQ(greenRed, getPixelAt(src->context(), 15, 15)); 362 } 363 364 // Tests that translations are properly handled when using KeepTransform. 365 TEST(TransparencyWin, TranslateOpaqueCompositeLayer) 366 { 367 // Fill with white. 368 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 369 Color white(0xFFFFFFFF); 370 FloatRect fullRect(0, 0, 16, 16); 371 src->context()->fillRect(fullRect, white, DeviceColorSpace); 372 373 // Scroll down by 8 (coordinate system goes up). 374 src->context()->save(); 375 src->context()->translate(0, -8); 376 377 Color red(0xFFFF0000); 378 Color green(0xFF00FF00); 379 { 380 // Make the transparency layer after translation will be @ (0, -8) with 381 // size 16x16. 382 TransparencyWin helper; 383 helper.init(src->context(), 384 TransparencyWin::OpaqueCompositeLayer, 385 TransparencyWin::KeepTransform, 386 IntRect(0, 0, 16, 16)); 387 388 // Draw a red pixel at (15, 15). This should be the at (15, 7) after 389 // the transform. 390 FloatRect bottomRight(15, 15, 1, 1); 391 helper.context()->fillRect(bottomRight, green, DeviceColorSpace); 392 helper.composite(); 393 } 394 395 src->context()->restore(); 396 397 // Check the pixel we wrote. 398 EXPECT_EQ(green, getPixelAt(src->context(), 15, 7)); 399 } 400 401 // Same as OpaqueCompositeLayer, but the canvas has a rotation applied. This 402 // tests that the propert transform is applied to the copied layer. 403 TEST(TransparencyWin, RotateOpaqueCompositeLayer) 404 { 405 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 406 407 // The background is white. 408 Color white(0xFFFFFFFF); 409 FloatRect fullRect(0, 0, 16, 16); 410 src->context()->fillRect(fullRect, white, DeviceColorSpace); 411 412 // Rotate the image by 90 degrees. This matrix is the same as 413 // cw90.rotate(90); but avoids rounding errors. Rounding errors can cause 414 // Skia to think that !rectStaysRect() and it will fall through to path 415 // drawing mode, which in turn gives us antialiasing. We want no 416 // antialiasing or other rounding problems since we're testing exact pixel 417 // values. 418 src->context()->save(); 419 AffineTransform cw90(0, 1, -1, 0, 0, 0); 420 src->context()->concatCTM(cw90); 421 422 // Make a transparency layer consisting of a horizontal line of 50% black. 423 // Since the rotation is applied, this will actually be a vertical line 424 // down the middle of the image. 425 src->context()->beginTransparencyLayer(0.5); 426 FloatRect blackRect(0, -9, 16, 2); 427 Color black(0xFF000000); 428 src->context()->fillRect(blackRect, black, DeviceColorSpace); 429 430 // Now draw 50% red square. 431 { 432 // Create a transparency helper inset one pixel in the buffer. The 433 // coordinates are before transforming into this space, and maps to 434 // IntRect(1, 1, 14, 14). 435 TransparencyWin helper; 436 helper.init(src->context(), 437 TransparencyWin::OpaqueCompositeLayer, 438 TransparencyWin::Untransform, 439 IntRect(1, -15, 14, 14)); 440 441 // Fill with red. 442 helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); 443 clearTopLayerAlphaChannel(helper.context()); 444 helper.composite(); 445 } 446 447 // Finish the compositing. 448 src->context()->endTransparencyLayer(); 449 450 // Top corner should be the original background. 451 EXPECT_EQ(white, getPixelAt(src->context(), 0, 0)); 452 453 // Check the stripe down the middle, first at the top... 454 Color gray(0xFF808080); 455 EXPECT_EQ(white, getPixelAt(src->context(), 6, 0)); 456 EXPECT_EQ(gray, getPixelAt(src->context(), 7, 0)); 457 EXPECT_EQ(gray, getPixelAt(src->context(), 8, 0)); 458 EXPECT_EQ(white, getPixelAt(src->context(), 9, 0)); 459 460 // ...now at the bottom. 461 EXPECT_EQ(white, getPixelAt(src->context(), 6, 15)); 462 EXPECT_EQ(gray, getPixelAt(src->context(), 7, 15)); 463 EXPECT_EQ(gray, getPixelAt(src->context(), 8, 15)); 464 EXPECT_EQ(white, getPixelAt(src->context(), 9, 15)); 465 466 // Our red square should be 25% red over the top of those two. 467 Color redwhite(0xFFdfbfbf); 468 Color redgray(0xFF9f8080); 469 EXPECT_EQ(white, getPixelAt(src->context(), 0, 1)); 470 EXPECT_EQ(redwhite, getPixelAt(src->context(), 1, 1)); 471 EXPECT_EQ(redwhite, getPixelAt(src->context(), 6, 1)); 472 EXPECT_EQ(redgray, getPixelAt(src->context(), 7, 1)); 473 EXPECT_EQ(redgray, getPixelAt(src->context(), 8, 1)); 474 EXPECT_EQ(redwhite, getPixelAt(src->context(), 9, 1)); 475 EXPECT_EQ(redwhite, getPixelAt(src->context(), 14, 1)); 476 EXPECT_EQ(white, getPixelAt(src->context(), 15, 1)); 477 478 // Complete the 50% transparent layer. 479 src->context()->restore(); 480 } 481 482 TEST(TransparencyWin, TranslateScaleOpaqueCompositeLayer) 483 { 484 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 485 486 // The background is white on top with red on bottom. 487 Color white(0xFFFFFFFF); 488 FloatRect topRect(0, 0, 16, 8); 489 src->context()->fillRect(topRect, white, DeviceColorSpace); 490 Color red(0xFFFF0000); 491 FloatRect bottomRect(0, 8, 16, 8); 492 src->context()->fillRect(bottomRect, red, DeviceColorSpace); 493 494 src->context()->save(); 495 496 // Translate left by one pixel. 497 AffineTransform left; 498 left.translate(-1, 0); 499 500 // Scale by 2x. 501 AffineTransform scale; 502 scale.scale(2.0); 503 src->context()->concatCTM(scale); 504 505 // Then translate up by one pixel (which will actually be 2 due to scaling). 506 AffineTransform up; 507 up.translate(0, -1); 508 src->context()->concatCTM(up); 509 510 // Now draw 50% red square. 511 { 512 // Create a transparency helper inset one pixel in the buffer. The 513 // coordinates are before transforming into this space, and maps to 514 // IntRect(1, 1, 14, 14). 515 TransparencyWin helper; 516 helper.init(src->context(), 517 TransparencyWin::OpaqueCompositeLayer, 518 TransparencyWin::KeepTransform, 519 IntRect(1, -15, 14, 14)); 520 521 // Fill with red. 522 helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000), DeviceColorSpace); 523 clearTopLayerAlphaChannel(helper.context()); 524 helper.composite(); 525 } 526 } 527 528 // Tests scale mode with no additional copy. 529 TEST(TransparencyWin, Scale) 530 { 531 // Create an opaque white buffer. 532 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 533 FloatRect fullBuffer(0, 0, 16, 16); 534 src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); 535 536 // Scale by 2x. 537 src->context()->save(); 538 AffineTransform scale; 539 scale.scale(2.0); 540 src->context()->concatCTM(scale); 541 542 // Start drawing a rectangle from 1->4. This should get scaled to 2->8. 543 { 544 TransparencyWin helper; 545 helper.init(src->context(), 546 TransparencyWin::NoLayer, 547 TransparencyWin::ScaleTransform, 548 IntRect(1, 1, 3, 3)); 549 550 // The context should now have the identity transform and the returned 551 // rect should be scaled. 552 EXPECT_TRUE(helper.context()->getCTM().isIdentity()); 553 EXPECT_EQ(2, helper.drawRect().x()); 554 EXPECT_EQ(2, helper.drawRect().y()); 555 EXPECT_EQ(8, helper.drawRect().right()); 556 EXPECT_EQ(8, helper.drawRect().bottom()); 557 558 // Set the pixel at (2, 2) to be transparent. This should be fixed when 559 // the helper goes out of scope. We don't want to call 560 // clearTopLayerAlphaChannel because that will actually clear the whole 561 // canvas (since we have no extra layer!). 562 SkBitmap& bitmap = const_cast<SkBitmap&>(helper.context()-> 563 platformContext()->canvas()->getTopPlatformDevice(). 564 accessBitmap(false)); 565 *bitmap.getAddr32(2, 2) &= 0x00FFFFFF; 566 helper.composite(); 567 } 568 569 src->context()->restore(); 570 571 // Check the pixel we previously made transparent, it should have gotten 572 // fixed back up to white. 573 574 // The current version doesn't fixup transparency when there is no layer. 575 // This seems not to be necessary, so we don't bother, but if it becomes 576 // necessary, this line should be uncommented. 577 // EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2)); 578 } 579 580 // Tests scale mode with an additional copy for transparency. This will happen 581 // if we have a scaled textbox, for example. WebKit will create a new 582 // transparency layer, draw the text field, then draw the text into it, then 583 // composite this down with an opacity. 584 TEST(TransparencyWin, ScaleTransparency) 585 { 586 // Create an opaque white buffer. 587 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 588 FloatRect fullBuffer(0, 0, 16, 16); 589 src->context()->fillRect(fullBuffer, Color::white, DeviceColorSpace); 590 591 // Make another layer (which duplicates how WebKit will make this). We fill 592 // the top half with red, and have the layer be 50% opaque. 593 src->context()->beginTransparencyLayer(0.5); 594 FloatRect topHalf(0, 0, 16, 8); 595 src->context()->fillRect(topHalf, Color(0xFFFF0000), DeviceColorSpace); 596 597 // Scale by 2x. 598 src->context()->save(); 599 AffineTransform scale; 600 scale.scale(2.0); 601 src->context()->concatCTM(scale); 602 603 // Make a layer inset two pixels (because of scaling, this is 2->14). And 604 // will it with 50% black. 605 { 606 TransparencyWin helper; 607 helper.init(src->context(), 608 TransparencyWin::OpaqueCompositeLayer, 609 TransparencyWin::ScaleTransform, 610 IntRect(1, 1, 6, 6)); 611 612 helper.context()->fillRect(helper.drawRect(), Color(0x7f000000), DeviceColorSpace); 613 clearTopLayerAlphaChannel(helper.context()); 614 helper.composite(); 615 } 616 617 // Finish the layer. 618 src->context()->restore(); 619 src->context()->endTransparencyLayer(); 620 621 Color redBackground(0xFFFF8080); // 50% red composited on white. 622 EXPECT_EQ(redBackground, getPixelAt(src->context(), 0, 0)); 623 EXPECT_EQ(redBackground, getPixelAt(src->context(), 1, 1)); 624 625 // Top half (minus two pixel border) should be 50% gray atop opaque 626 // red = 0xFF804141. Then that's composited with 50% transparency on solid 627 // white = 0xFFC0A1A1. 628 Color darkRed(0xFFBF8080); 629 EXPECT_EQ(darkRed, getPixelAt(src->context(), 2, 2)); 630 EXPECT_EQ(darkRed, getPixelAt(src->context(), 7, 7)); 631 632 // Bottom half (minus a two pixel border) should be a layer with 5% gray 633 // with another 50% opacity composited atop white. 634 Color darkWhite(0xFFBFBFBF); 635 EXPECT_EQ(darkWhite, getPixelAt(src->context(), 8, 8)); 636 EXPECT_EQ(darkWhite, getPixelAt(src->context(), 13, 13)); 637 638 Color white(0xFFFFFFFF); // Background in the lower-right. 639 EXPECT_EQ(white, getPixelAt(src->context(), 14, 14)); 640 EXPECT_EQ(white, getPixelAt(src->context(), 15, 15)); 641 } 642 643 TEST(TransparencyWin, Text) 644 { 645 OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), DeviceRGB)); 646 647 // Our text should end up 50% transparent blue-green. 648 Color fullResult(0x80008080); 649 650 { 651 TransparencyWin helper; 652 helper.init(src->context(), 653 TransparencyWin::TextComposite, 654 TransparencyWin::KeepTransform, 655 IntRect(0, 0, 16, 16)); 656 helper.setTextCompositeColor(fullResult); 657 658 // Write several different squares to simulate ClearType. These should 659 // all reduce to 2/3 coverage. 660 FloatRect pixel(0, 0, 1, 1); 661 helper.context()->fillRect(pixel, 0xFFFF0000, DeviceColorSpace); 662 pixel.move(1.0f, 0.0f); 663 helper.context()->fillRect(pixel, 0xFF00FF00, DeviceColorSpace); 664 pixel.move(1.0f, 0.0f); 665 helper.context()->fillRect(pixel, 0xFF0000FF, DeviceColorSpace); 666 pixel.move(1.0f, 0.0f); 667 helper.context()->fillRect(pixel, 0xFF008080, DeviceColorSpace); 668 pixel.move(1.0f, 0.0f); 669 helper.context()->fillRect(pixel, 0xFF800080, DeviceColorSpace); 670 pixel.move(1.0f, 0.0f); 671 helper.context()->fillRect(pixel, 0xFF808000, DeviceColorSpace); 672 673 // Try one with 100% coverage (opaque black). 674 pixel.move(1.0f, 0.0f); 675 helper.context()->fillRect(pixel, 0xFF000000, DeviceColorSpace); 676 677 // Now mess with the alpha channel. 678 clearTopLayerAlphaChannel(helper.context()); 679 helper.composite(); 680 } 681 682 Color oneThirdResult(0x55005555); // = fullResult * 2 / 3 683 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 0, 0)); 684 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 1, 0)); 685 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 2, 0)); 686 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 3, 0)); 687 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 4, 0)); 688 EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 5, 0)); 689 EXPECT_EQ(fullResult, getPixelAt(src->context(), 6, 0)); 690 EXPECT_EQ(Color::transparent, getPixelAt(src->context(), 7, 0)); 691 } 692 693 } // namespace WebCore 694
