Refactoring ImageBuffer to decouple it from Canvas2DLayerBridge

Source/web/tests/TransparencyWinTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/win/TransparencyWin.h"
 #include "platform/transforms/AffineTransform.h"
-#include "skia/ext/platform_canvas.h"
 
 #include <windows.h>
 #include <gtest/gtest.h>
 
 namespace WebCore {
 
 static FloatRect RECTToFloatRect(const RECT* rect)
 {
     return FloatRect(static_cast<float>(rect->left),
                      static_cast<float>(rect->top),
                      static_cast<float>(rect->right - rect->left),
                      static_cast<float>(rect->bottom - rect->top));
 }
 
-static void drawNativeRect(GraphicsContext* context,
-                           int x, int y, int w, int h)
-{
-    SkCanvas* canvas = context->canvas();
-    HDC dc = skia::BeginPlatformPaint(canvas);
-
-    RECT innerRc;
-    innerRc.left = x;
-    innerRc.top = y;
-    innerRc.right = x + w;
-    innerRc.bottom = y + h;
-    FillRect(dc, &innerRc,
-             reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
-
-    skia::EndPlatformPaint(canvas);
-}
-
 static Color getPixelAt(GraphicsContext* context, int x, int y)
 {
     const SkBitmap& bitmap = context->layerBitmap();
     return Color(*reinterpret_cast<const RGBA32*>(bitmap.getAddr32(x, y)));
 }
 
 // Resets the top layer's alpha channel to 0 for each pixel. This simulates
 // Windows messing it up.
 static void clearTopLayerAlphaChannel(GraphicsContext* context)
 {
@@ skipping 16 matching lines @@
 {
     std::ios_base::fmtflags oldFlags = out.flags(std::ios_base::hex |
                                                  std::ios_base::showbase);
     out << c.rgb();
     out.flags(oldFlags);
     return out;
 }
 
 TEST(TransparencyWin, NoLayer)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(17, 16)));
 
     // KeepTransform
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::NoLayer,
                     TransparencyWin::KeepTransform,
                     IntRect(1, 1, 14, 12));
 
         EXPECT_TRUE(src->context() == helper.context());
@@ skipping 18 matching lines @@
         // It should be post-transformed.
         EXPECT_TRUE(src->context() == helper.context());
         EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize);
         EXPECT_TRUE(IntRect(4, 1, 12, 3) == helper.drawRect());
     }
     src->context()->restore();
 }
 
 TEST(TransparencyWin, WhiteLayer)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // KeepTransform
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::WhiteLayer,
                     TransparencyWin::KeepTransform,
                     IntRect(1, 1, 14, 12));
         helper.composite();
 
@@ skipping 31 matching lines @@
         // It should be post-transformed.
         EXPECT_TRUE(src->context() != helper.context());
         EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize);
         EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect());
     }
     src->context()->restore();
 }
 
 TEST(TransparencyWin, TextComposite)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // KeepTransform is the only valid transform mode for TextComposite.
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::TextComposite,
                     TransparencyWin::KeepTransform,
                     IntRect(1, 1, 14, 12));
         helper.composite();
 
         EXPECT_TRUE(src->context() != helper.context());
         EXPECT_TRUE(IntSize(14, 12) == helper.m_layerSize);
         EXPECT_TRUE(IntRect(1, 1, 14, 12) == helper.drawRect());
     }
 }
 
 TEST(TransparencyWin, OpaqueCompositeLayer)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // KeepTransform
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::OpaqueCompositeLayer,
                     TransparencyWin::KeepTransform,
                     IntRect(1, 1, 14, 12));
         helper.composite();
 
@@ skipping 46 matching lines @@
 
         // The coordinate system should be based in the upper left of our box.
         // It should be post-transformed.
         EXPECT_TRUE(src->context() != helper.context());
         EXPECT_TRUE(IntSize(12, 3) == helper.m_layerSize);
         EXPECT_TRUE(IntRect(0, 0, 12, 3) == helper.drawRect());
     }
     src->context()->restore();
 }
 
-TEST(TransparencyWin, WhiteLayerPixelTest)
-{
-    // Make a total transparent buffer, and draw the white layer inset by 1 px.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
-
-    {
-        TransparencyWin helper;
-        helper.init(src->context(),
-                    TransparencyWin::WhiteLayer,
-                    TransparencyWin::KeepTransform,
-                    IntRect(1, 1, 14, 14));
-
-        // Coordinates should be in the original space, not the layer.
-        drawNativeRect(helper.context(), 3, 3, 1, 1);
-        clearTopLayerAlphaChannel(helper.context());
-        helper.composite();
-    }
-
-    // The final image should be transparent around the edges for 1 px, white
-    // in the middle, with (3,3) (what we drew above) being opaque black.
-    EXPECT_EQ(Color(Color::transparent), getPixelAt(src->context(), 0, 0));
-    EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2));
-    EXPECT_EQ(Color(Color::black), getPixelAt(src->context(), 3, 3));
-    EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 4, 4));
-}
-
 TEST(TransparencyWin, OpaqueCompositeLayerPixel)
 {
     Color red(0xFFFF0000), darkRed(0xFFBF0000);
     Color green(0xFF00FF00);
 
     // Make a red bottom layer, followed by a half green next layer @ 50%.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     FloatRect fullRect(0, 0, 16, 16);
     src->context()->fillRect(fullRect, red);
     src->context()->beginTransparencyLayer(0.5);
     FloatRect rightHalf(8, 0, 8, 16);
     src->context()->fillRect(rightHalf, green);
 
     // Make a transparency layer inset by one pixel, and fill it inset by
     // another pixel with 50% black.
     {
@@ skipping 32 matching lines @@
     // 50% green on top of red = FF808000 (rounded to what Skia will produce).
     Color greenRed(0xFF807F00);
     EXPECT_EQ(greenRed, getPixelAt(src->context(), 14, 14));
     EXPECT_EQ(greenRed, getPixelAt(src->context(), 15, 15));
 }
 
 // Tests that translations are properly handled when using KeepTransform.
 TEST(TransparencyWin, TranslateOpaqueCompositeLayer)
 {
     // Fill with white.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
     Color white(0xFFFFFFFF);
     FloatRect fullRect(0, 0, 16, 16);
     src->context()->fillRect(fullRect, white);
 
     // Scroll down by 8 (coordinate system goes up).
     src->context()->save();
     src->context()->translate(0, -8);
 
     Color red(0xFFFF0000);
     Color green(0xFF00FF00);
@@ skipping 15 matching lines @@
 
     src->context()->restore();
 
     // Check the pixel we wrote.
     EXPECT_EQ(green, getPixelAt(src->context(), 15, 7));
 }
 
 static void testClippedLayerKeepTransform(TransparencyWin::LayerMode layerMode)
 {
     // Fill with white.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
     Color white(0xFFFFFFFF);
     FloatRect fullRect(0, 0, 16, 16);
     src->context()->fillRect(fullRect, white);
 
     IntRect clipRect(IntPoint(11, 5), IntSize(1, 1));
     src->context()->clip(clipRect);
 
     // Scroll down by 6 (coordinate system goes up).
     src->context()->save();
     src->context()->translate(0, -6);
@@ skipping 40 matching lines @@
 
 TEST(TransparencyWin, ClippedKeepTransformWhiteLayer)
 {
     testClippedLayerKeepTransform(TransparencyWin::WhiteLayer);
 }
 
 // Same as OpaqueCompositeLayer, but the canvas has a rotation applied. This
 // tests that the propert transform is applied to the copied layer.
 TEST(TransparencyWin, RotateOpaqueCompositeLayer)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // The background is white.
     Color white(0xFFFFFFFF);
     FloatRect fullRect(0, 0, 16, 16);
     src->context()->fillRect(fullRect, white);
 
     // Rotate the image by 90 degrees. This matrix is the same as
     // cw90.rotate(90); but avoids rounding errors. Rounding errors can cause
     // Skia to think that !rectStaysRect() and it will fall through to path
     // drawing mode, which in turn gives us antialiasing. We want no
@@ skipping 58 matching lines @@
     EXPECT_EQ(redwhite, getPixelAt(src->context(), 9, 1));
     EXPECT_EQ(redwhite, getPixelAt(src->context(), 14, 1));
     EXPECT_EQ(white, getPixelAt(src->context(), 15, 1));
 
     // Complete the 50% transparent layer.
     src->context()->restore();
 }
 
 TEST(TransparencyWin, DISABLED_TranslateScaleOpaqueCompositeLayer)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // The background is white on top with red on bottom.
     Color white(0xFFFFFFFF);
     FloatRect topRect(0, 0, 16, 8);
     src->context()->fillRect(topRect, white);
     Color red(0xFFFF0000);
     FloatRect bottomRect(0, 8, 16, 8);
     src->context()->fillRect(bottomRect, red);
 
     src->context()->save();
@@ skipping 27 matching lines @@
         helper.context()->fillRect(helper.drawRect(), Color(0x7f7f0000));
         clearTopLayerAlphaChannel(helper.context());
         helper.composite();
     }
 }
 
 // Tests scale mode with no additional copy.
 TEST(TransparencyWin, Scale)
 {
     // Create an opaque white buffer.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
     FloatRect fullBuffer(0, 0, 16, 16);
     src->context()->fillRect(fullBuffer, Color::white);
 
     // Scale by 2x.
     src->context()->save();
     AffineTransform scale;
     scale.scale(2.0);
     src->context()->concatCTM(scale);
 
     // Start drawing a rectangle from 1->4. This should get scaled to 2->8.
@@ skipping 32 matching lines @@
     // EXPECT_EQ(Color(Color::white), getPixelAt(src->context(), 2, 2));
 }
 
 // Tests scale mode with an additional copy for transparency. This will happen
 // if we have a scaled textbox, for example. WebKit will create a new
 // transparency layer, draw the text field, then draw the text into it, then
 // composite this down with an opacity.
 TEST(TransparencyWin, ScaleTransparency)
 {
     // Create an opaque white buffer.
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
     FloatRect fullBuffer(0, 0, 16, 16);
     src->context()->fillRect(fullBuffer, Color::white);
 
     // Make another layer (which duplicates how WebKit will make this). We fill
     // the top half with red, and have the layer be 50% opaque.
     src->context()->beginTransparencyLayer(0.5);
     FloatRect topHalf(0, 0, 16, 8);
     src->context()->fillRect(topHalf, Color(0xFFFF0000));
 
     // Scale by 2x.
@@ skipping 37 matching lines @@
     EXPECT_EQ(darkWhite, getPixelAt(src->context(), 8, 8));
     EXPECT_EQ(darkWhite, getPixelAt(src->context(), 13, 13));
 
     Color white(0xFFFFFFFF); // Background in the lower-right.
     EXPECT_EQ(white, getPixelAt(src->context(), 14, 14));
     EXPECT_EQ(white, getPixelAt(src->context(), 15, 15));
 }
 
 TEST(TransparencyWin, Text)
 {
-    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), 1));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16)));
 
     // Our text should end up 50% transparent blue-green.
     Color fullResult(0x80008080);
 
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::TextComposite,
                     TransparencyWin::KeepTransform,
                     IntRect(0, 0, 16, 16));
@@ skipping 28 matching lines @@
     EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 1, 0));
     EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 2, 0));
     EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 3, 0));
     EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 4, 0));
     EXPECT_EQ(oneThirdResult, getPixelAt(src->context(), 5, 0));
     EXPECT_EQ(fullResult, getPixelAt(src->context(), 6, 0));
     EXPECT_EQ(Color::transparent, getPixelAt(src->context(), 7, 0));
 }
 
 } // namespace WebCore