Update webkit to r44122...

webkit/tools/webcore_unit_tests/TransparencyWin_unittest.cpp

 /*
  * Copyright (C) 2009 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 85 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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // KeepTransform
     {
         TransparencyWin helper;
         helper.init(src->context(),
                     TransparencyWin::OpaqueCompositeLayer,
                     TransparencyWin::KeepTransform,
                     IntRect(1, 1, 14, 12));
         helper.composite();
 
@@ skipping 49 matching lines @@
         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.
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     {
         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(0xFFC00000);
     Color green(0xFF00FF00);
 
     // Make a red bottom layer, followed by a half green next layer @ 50%.
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     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(0xFF817E00);
     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.
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
     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 16 matching lines @@
     src->context()->restore();
 
     // Check the pixel we wrote.
     EXPECT_EQ(green, getPixelAt(src->context(), 15, 7));
 }
 
 // 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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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 61 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, TranslateScaleOpaqueCompositeLayer)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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.
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
     FloatRect fullBuffer(0, 0, 16, 16);
     src->context()->fillRect(fullBuffer, Color::white);
 
     // Scale by 2x.
     src->context()->save();
     TransformationMatrix scale;
     scale.scale(2.0);
     src->context()->concatCTM(scale);
 
     // Start drawing a rectangle from 1->4. This should get scaled to 2->8.
@@ skipping 34 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.
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
     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)
 {
-    std::auto_ptr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
+    OwnPtr<ImageBuffer> src(ImageBuffer::create(IntSize(16, 16), false));
 
     // 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