Add back convolver_unittest.cc and image_operations_unittest.cc....

skia/ext/vector_canvas_unittest.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "build/build_config.h"
+
+#include "webkit/tools/test_shell/image_decoder_unittest.h"
+
+#if !defined(OS_WIN)
+#include <unistd.h>
+#endif
+
 #include "skia/ext/vector_canvas.h"
 
-#include <vector>
+#include "PNGImageDecoder.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/gfx/gdi_util.h"
-#include "base/gfx/png_decoder.h"
 #include "base/gfx/png_encoder.h"
-#include "base/gfx/size.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
-#include "base/win_util.h"
+
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "SkDashPathEffect.h"
 
 namespace skia {
 
 namespace {
 
 const wchar_t* const kGenerateSwitch = L"vector-canvas-generate";
 
@@ skipping 38 matching lines @@
 
   DISALLOW_EVIL_CONSTRUCTORS(Bitmap);
 };
 
 // Lightweight raw-bitmap management. The image, once initialized, is immuable.
 // It is mainly used for comparison.
 class Image {
  public:
   // Creates the image from the given filename on disk.
   Image(const std::wstring& filename) : ignore_alpha_(true) {
-    std::string compressed;
-    file_util::ReadFileToString(filename, &compressed);
+    Vector<char> compressed;
+    ReadFileToVector(filename, &compressed);
     EXPECT_TRUE(compressed.size());
-
-    int w;
-    int h;
-    EXPECT_TRUE(PNGDecoder::Decode(
-        reinterpret_cast<const unsigned char*>(compressed.c_str()),
-        compressed.size(), PNGDecoder::FORMAT_BGRA, &data_, &w, &h));
-    size_.SetSize(w, h);
-    row_length_ = w * sizeof(uint32);
+    WebCore::PNGImageDecoder decoder;
+    decoder.setData(WebCore::SharedBuffer::adoptVector(compressed).get(), true);
+    SetSkBitmap(decoder.frameBufferAtIndex(0)->bitmap());
   }
 
   // Loads the image from a canvas.
   Image(const skia::PlatformCanvasWin& canvas) : ignore_alpha_(true) {
     // Use a different way to access the bitmap. The normal way would be to
     // query the SkBitmap.
     HDC context = canvas.getTopPlatformDevice().getBitmapDC();
     HGDIOBJ bitmap = GetCurrentObject(context, OBJ_BITMAP);
     EXPECT_TRUE(bitmap != NULL);
     // Initialize the clip region to the entire bitmap.
     BITMAP bitmap_data;
-    EXPECT_EQ(GetObject(bitmap, sizeof(BITMAP), &bitmap_data),
-              sizeof(BITMAP));
-    size_.SetSize(bitmap_data.bmWidth, bitmap_data.bmHeight);
+    EXPECT_EQ(GetObject(bitmap, sizeof(BITMAP), &bitmap_data), sizeof(BITMAP));
+    width_ = bitmap_data.bmWidth;
+    height_ = bitmap_data.bmHeight;
     row_length_ = bitmap_data.bmWidthBytes;
-    size_t size = row_length_ * size_.height();
+    size_t size = row_length_ * height_;
     data_.resize(size);
     memcpy(&*data_.begin(), bitmap_data.bmBits, size);
   }
 
   // Loads the image from a canvas.
   Image(const SkBitmap& bitmap) : ignore_alpha_(true) {
-    SkAutoLockPixels lock(bitmap);
-    size_.SetSize(bitmap.width(), bitmap.height());
-    row_length_ = static_cast<int>(bitmap.rowBytes());
-    size_t size = row_length_ * size_.height();
-    data_.resize(size);
-    memcpy(&*data_.begin(), bitmap.getAddr(0, 0), size);
+    SetSkBitmap(bitmap);
   }
 
-  const gfx::Size& size() const {
-    return size_;
-  }
-
-  int row_length() const {
-    return row_length_;
-  }
+  int width() const { return width_; }
+  int height() const { return height_; }
+  int row_length() const { return row_length_; }
 
   // Save the image to a png file. Used to create the initial test files.
   void SaveToFile(const std::wstring& filename) {
     std::vector<unsigned char> compressed;
     ASSERT_TRUE(PNGEncoder::Encode(&*data_.begin(),
                                    PNGEncoder::FORMAT_BGRA,
-                                   size_.width(),
-                                   size_.height(),
+                                   width_,
+                                   height_,
                                    row_length_,
                                    true,
                                    &compressed));
     ASSERT_TRUE(compressed.size());
     FILE* f = file_util::OpenFile(filename, "wb");
     ASSERT_TRUE(f);
     ASSERT_EQ(fwrite(&*compressed.begin(), 1, compressed.size(), f),
               compressed.size());
     file_util::CloseFile(f);
   }
 
   // Returns the percentage of the image that is different from the other,
   // between 0 and 100.
   double PercentageDifferent(const Image& rhs) const {
-    if (size_ != rhs.size_ || row_length_ != rhs.row_length_ ||
-        size_.width() == 0 || size_.height() == 0)
+    if (width_ != rhs.width_ ||
+        height_ != rhs.height_ ||
+        row_length_ != rhs.row_length_ ||
+        width_ == 0 ||
+        height_ == 0) {
       return 100.;  // When of different size or empty, they are 100% different.
-
+    }
     // Compute pixels different in the overlap
     int pixels_different = 0;
-    for (int y = 0; y < size_.height(); ++y) {
-      for (int x = 0; x < size_.width(); ++x) {
+    for (int y = 0; y < height_; ++y) {
+      for (int x = 0; x < width_; ++x) {
         uint32_t lhs_pixel = pixel_at(x, y);
         uint32_t rhs_pixel = rhs.pixel_at(x, y);
         if (lhs_pixel != rhs_pixel)
           ++pixels_different;
       }
     }
 
     // Like the WebKit ImageDiff tool, we define percentage different in terms
     // of the size of the 'actual' bitmap.
-    double total_pixels = static_cast<double>(size_.width()) *
-                          static_cast<double>(size_.height());
+    double total_pixels = static_cast<double>(width_) *
+                          static_cast<double>(height_);
     return static_cast<double>(pixels_different) / total_pixels * 100.;
   }
 
   // Returns the 0x0RGB or 0xARGB value of the pixel at the given location,
   // depending on ignore_alpha_.
   uint32 pixel_at(int x, int y) const {
-    EXPECT_TRUE(x >= 0 && x < size_.width());
-    EXPECT_TRUE(y >= 0 && y < size_.height());
+    EXPECT_TRUE(x >= 0 && x < width_);
+    EXPECT_TRUE(y >= 0 && y < height_);
     const uint32* data = reinterpret_cast<const uint32*>(&*data_.begin());
     const uint32* data_row = data + y * row_length_ / sizeof(uint32);
     if (ignore_alpha_)
       return data_row[x] & 0xFFFFFF;  // Strip out A.
     else
       return data_row[x];
   }
 
+ protected:
+  void SetSkBitmap(const SkBitmap& bitmap) {
+    SkAutoLockPixels lock(bitmap);
+    width_ = bitmap.width();
+    height_ = bitmap.height();
+    row_length_ = static_cast<int>(bitmap.rowBytes());
+    size_t size = row_length_ * height_;
+    data_.resize(size);
+    memcpy(&*data_.begin(), bitmap.getAddr(0, 0), size);
+  }
+
  private:
   // Pixel dimensions of the image.
-  gfx::Size size_;
+  int width_;
+  int height_;
 
   // Length of a line in bytes.
   int row_length_;
 
   // Actual bitmap data in arrays of RGBAs (so when loaded as uint32, it's
   // 0xABGR).
   std::vector<unsigned char> data_;
 
   // Flag to signal if the comparison functions should ignore the alpha channel.
   const bool ignore_alpha_;
@@ skipping 112 matching lines @@
         *pixel_addr = SkColorSetARGB(
             SkColorGetA(color),
             (SkColorGetR(color) * 255 + alpha_offset) / alpha,
             (SkColorGetG(color) * 255 + alpha_offset) / alpha,
             (SkColorGetB(color) * 255 + alpha_offset) / alpha);
       }
     }
   }
 }
 
-void LoadPngFileToSkBitmap(const std::wstring& file, SkBitmap* bitmap) {
-  std::string compressed;
-  file_util::ReadFileToString(file, &compressed);
+void LoadPngFileToSkBitmap(const std::wstring& filename, SkBitmap* bitmap) {
+  Vector<char> compressed;
+  ReadFileToVector(filename, &compressed);
   EXPECT_TRUE(compressed.size());
-  // Extra-lame. If you care, fix it.
-  std::vector<unsigned char> data;
-  data.assign(reinterpret_cast<const unsigned char*>(compressed.c_str()),
-              reinterpret_cast<const unsigned char*>(compressed.c_str() +
-                  compressed.size()));
-  EXPECT_TRUE(PNGDecoder::Decode(&data, bitmap));
+  WebCore::PNGImageDecoder decoder;
+  decoder.setData(WebCore::SharedBuffer::adoptVector(compressed).get(), true);
+  *bitmap = decoder.frameBufferAtIndex(0)->bitmap();
   EXPECT_FALSE(bitmap->isOpaque());
   Premultiply(*bitmap);
 }
 
 }  // namespace
 
 // Streams an image.
 inline std::ostream& operator<<(std::ostream& out, const Image& image) {
-  return out << "Image(" << image.size().width() << ", "
-             << image.size().height() << ", " << image.row_length() << ")";
+  return out << "Image(" << image.width() << ", "
+             << image.height() << ", " << image.row_length() << ")";
 }
 
 // Runs simultaneously the same drawing commands on VectorCanvas and
 // PlatformCanvas and compare the results.
 class VectorCanvasTest : public ImageTest {
  public:
   typedef ImageTest parent;
 
   VectorCanvasTest() : parent(CurrentMode()), compare_canvas_(true) {
   }
@@ skipping 437 matching lines @@
 
     SkPath path;
     path.addCircle(50, 75, 10);
     vcanvas_->drawPath(path, paint);
     pcanvas_->drawPath(path, paint);
     EXPECT_EQ(0., ProcessImage(L"circle"));
   }
 }
 
 TEST_F(VectorCanvasTest, Bitmaps) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   {
     SkBitmap bitmap;
     LoadPngFileToSkBitmap(test_file(L"bitmap_opaque.png"), &bitmap);
     vcanvas_->drawBitmap(bitmap, 13, 3, NULL);
     pcanvas_->drawBitmap(bitmap, 13, 3, NULL);
     EXPECT_EQ(0., ProcessImage(L"opaque"));
   }
 
   {
     SkBitmap bitmap;
     LoadPngFileToSkBitmap(test_file(L"bitmap_alpha.png"), &bitmap);
     vcanvas_->drawBitmap(bitmap, 5, 15, NULL);
     pcanvas_->drawBitmap(bitmap, 5, 15, NULL);
     EXPECT_EQ(0., ProcessImage(L"alpha"));
   }
 }
 
 TEST_F(VectorCanvasTest, ClippingRect) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
   SkRect rect;
   rect.fLeft = 2;
   rect.fTop = 2;
   rect.fRight = 30.5f;
   rect.fBottom = 30.5f;
   vcanvas_->clipRect(rect);
   pcanvas_->clipRect(rect);
 
   vcanvas_->drawBitmap(bitmap, 13, 3, NULL);
   pcanvas_->drawBitmap(bitmap, 13, 3, NULL);
   EXPECT_EQ(0., ProcessImage(L"rect"));
 }
 
 TEST_F(VectorCanvasTest, ClippingPath) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
   SkPath path;
   path.addCircle(20, 20, 10);
   vcanvas_->clipPath(path);
   pcanvas_->clipPath(path);
 
   vcanvas_->drawBitmap(bitmap, 14, 3, NULL);
   pcanvas_->drawBitmap(bitmap, 14, 3, NULL);
   EXPECT_EQ(0., ProcessImage(L"path"));
 }
 
 TEST_F(VectorCanvasTest, ClippingCombined) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
 
   SkRect rect;
   rect.fLeft = 2;
   rect.fTop = 2;
   rect.fRight = 30.5f;
   rect.fBottom = 30.5f;
   vcanvas_->clipRect(rect);
   pcanvas_->clipRect(rect);
   SkPath path;
   path.addCircle(20, 20, 10);
   vcanvas_->clipPath(path, SkRegion::kUnion_Op);
   pcanvas_->clipPath(path, SkRegion::kUnion_Op);
 
   vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
   pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
   EXPECT_EQ(0., ProcessImage(L"combined"));
 }
 
 TEST_F(VectorCanvasTest, ClippingIntersect) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
 
   SkRect rect;
   rect.fLeft = 2;
   rect.fTop = 2;
   rect.fRight = 30.5f;
   rect.fBottom = 30.5f;
   vcanvas_->clipRect(rect);
   pcanvas_->clipRect(rect);
   SkPath path;
   path.addCircle(23, 23, 15);
   vcanvas_->clipPath(path);
   pcanvas_->clipPath(path);
 
   vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
   pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
   EXPECT_EQ(0., ProcessImage(L"intersect"));
 }
 
 TEST_F(VectorCanvasTest, ClippingClean) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
   {
     SkRegion old_region(pcanvas_->getTotalClip());
     SkRect rect;
     rect.fLeft = 2;
     rect.fTop = 2;
     rect.fRight = 30.5f;
     rect.fBottom = 30.5f;
     vcanvas_->clipRect(rect);
     pcanvas_->clipRect(rect);
 
     vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
     pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
     EXPECT_EQ(0., ProcessImage(L"clipped"));
     vcanvas_->clipRegion(old_region, SkRegion::kReplace_Op);
     pcanvas_->clipRegion(old_region, SkRegion::kReplace_Op);
   }
   {
     // Verify that the clipping region has been fixed back.
     vcanvas_->drawBitmap(bitmap, 55, 3, NULL);
     pcanvas_->drawBitmap(bitmap, 55, 3, NULL);
     EXPECT_EQ(0., ProcessImage(L"unclipped"));
   }
 }
 
 TEST_F(VectorCanvasTest, Matrix) {
-  // ICM is enabled on VectorCanvas only on Windows 2000 so bitmap-based tests
-  // can't compare the pixels between PlatformCanvas and VectorCanvas. We don't
-  // really care about Windows 2000 pixel colors.
-  if (win_util::GetWinVersion() <= win_util::WINVERSION_2000)
-    return;
   SkBitmap bitmap;
   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap);
   {
     vcanvas_->translate(15, 3);
     pcanvas_->translate(15, 3);
     vcanvas_->drawBitmap(bitmap, 0, 0, NULL);
     pcanvas_->drawBitmap(bitmap, 0, 0, NULL);
     EXPECT_EQ(0., ProcessImage(L"translate1"));
   }
   {
@@ skipping 24 matching lines @@
   {
     vcanvas_->rotate(67);
     pcanvas_->rotate(67);
     vcanvas_->drawBitmap(bitmap, 20, -50, NULL);
     pcanvas_->drawBitmap(bitmap, 20, -50, NULL);
     EXPECT_EQ(0., ProcessImage(L"rotate"));
   }
 }
 
 }  // namespace skia