skia/ext/vector_canvas_unittest.cc

   1 // Copyright (c) 2012 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 "build/build_config.h"
   6
   7 #if !defined(OS_WIN)
   8 #include <unistd.h>
   9 #endif
  10
  11 #include "base/command_line.h"
  12 #include "base/files/file_util.h"
  13 #include "base/path_service.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "skia/ext/vector_canvas.h"
  18 #include "skia/ext/vector_platform_device_emf_win.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/skia/include/effects/SkDashPathEffect.h"
  21 #include "ui/gfx/codec/png_codec.h"
  22 #include "ui/gfx/size.h"
  23
  24 namespace skia {
  25
  26 namespace {
  27
  28 const char kGenerateSwitch[] = "vector-canvas-generate";
  29
  30 // Lightweight HDC management.
  31 class Context {
  32  public:
  33   Context() : context_(CreateCompatibleDC(NULL)) {
  34     EXPECT_TRUE(context_);
  35   }
  36   ~Context() {
  37     DeleteDC(context_);
  38   }
  39
  40   HDC context() const { return context_; }
  41
  42  private:
  43   HDC context_;
  44
  45   DISALLOW_COPY_AND_ASSIGN(Context);
  46 };
  47
  48 // Lightweight HBITMAP management.
  49 class Bitmap {
  50  public:
  51   Bitmap(const Context& context, int x, int y) {
  52     BITMAPINFOHEADER hdr;
  53     hdr.biSize = sizeof(BITMAPINFOHEADER);
  54     hdr.biWidth = x;
  55     hdr.biHeight = -y;  // Minus means top-down bitmap.
  56     hdr.biPlanes = 1;
  57     hdr.biBitCount = 32;
  58     hdr.biCompression = BI_RGB;  // No compression.
  59     hdr.biSizeImage = 0;
  60     hdr.biXPelsPerMeter = 1;
  61     hdr.biYPelsPerMeter = 1;
  62     hdr.biClrUsed = 0;
  63     hdr.biClrImportant = 0;
  64     bitmap_ = CreateDIBSection(context.context(),
  65                                reinterpret_cast<BITMAPINFO*>(&hdr), 0,
  66                                &data_, NULL, 0);
  67     EXPECT_TRUE(bitmap_);
  68     EXPECT_TRUE(SelectObject(context.context(), bitmap_));
  69   }
  70   ~Bitmap() {
  71     EXPECT_TRUE(DeleteObject(bitmap_));
  72   }
  73
  74  private:
  75   HBITMAP bitmap_;
  76
  77   void* data_;
  78
  79   DISALLOW_COPY_AND_ASSIGN(Bitmap);
  80 };
  81
  82 // Lightweight raw-bitmap management. The image, once initialized, is immuable.
  83 // It is mainly used for comparison.
  84 class Image {
  85  public:
  86   // Creates the image from the given filename on disk.
  87   explicit Image(const base::FilePath& filename) : ignore_alpha_(true) {
  88     std::string compressed;
  89     base::ReadFileToString(filename, &compressed);
  90     EXPECT_TRUE(compressed.size());
  91
  92     SkBitmap bitmap;
  93     EXPECT_TRUE(gfx::PNGCodec::Decode(
  94         reinterpret_cast<const unsigned char*>(compressed.data()),
  95         compressed.size(), &bitmap));
  96     SetSkBitmap(bitmap);
  97   }
  98
  99   // Loads the image from a canvas.
 100   Image(skia::PlatformCanvas& canvas) : ignore_alpha_(true) {
 101     // Use a different way to access the bitmap. The normal way would be to
 102     // query the SkBitmap.
 103     skia::ScopedPlatformPaint scoped_platform_paint(&canvas);
 104     HDC context = scoped_platform_paint.GetPlatformSurface();
 105     HGDIOBJ bitmap = GetCurrentObject(context, OBJ_BITMAP);
 106     EXPECT_TRUE(bitmap != NULL);
 107     // Initialize the clip region to the entire bitmap.
 108     BITMAP bitmap_data;
 109     EXPECT_EQ(GetObject(bitmap, sizeof(BITMAP), &bitmap_data), sizeof(BITMAP));
 110     width_ = bitmap_data.bmWidth;
 111     height_ = bitmap_data.bmHeight;
 112     row_length_ = bitmap_data.bmWidthBytes;
 113     size_t size = row_length_ * height_;
 114     data_.resize(size);
 115     memcpy(&*data_.begin(), bitmap_data.bmBits, size);
 116   }
 117
 118   // Loads the image from a canvas.
 119   Image(const SkBitmap& bitmap) : ignore_alpha_(true) {
 120     SetSkBitmap(bitmap);
 121   }
 122
 123   int width() const { return width_; }
 124   int height() const { return height_; }
 125   int row_length() const { return row_length_; }
 126
 127   // Save the image to a png file. Used to create the initial test files.
 128   void SaveToFile(const base::FilePath& filename) {
 129     std::vector<unsigned char> compressed;
 130     ASSERT_TRUE(gfx::PNGCodec::Encode(&*data_.begin(),
 131                                       gfx::PNGCodec::FORMAT_BGRA,
 132                                       gfx::Size(width_, height_),
 133                                       row_length_,
 134                                       true,
 135                                       std::vector<gfx::PNGCodec::Comment>(),
 136                                       &compressed));
 137     ASSERT_TRUE(compressed.size());
 138     FILE* f = base::OpenFile(filename, "wb");
 139     ASSERT_TRUE(f);
 140     ASSERT_EQ(fwrite(&*compressed.begin(), 1, compressed.size(), f),
 141               compressed.size());
 142     base::CloseFile(f);
 143   }
 144
 145   // Returns the percentage of the image that is different from the other,
 146   // between 0 and 100.
 147   double PercentageDifferent(const Image& rhs) const {
 148     if (width_ != rhs.width_ ||
 149         height_ != rhs.height_ ||
 150         row_length_ != rhs.row_length_ ||
 151         width_ == 0 ||
 152         height_ == 0) {
 153       return 100.;  // When of different size or empty, they are 100% different.
 154     }
 155     // Compute pixels different in the overlap
 156     int pixels_different = 0;
 157     for (int y = 0; y < height_; ++y) {
 158       for (int x = 0; x < width_; ++x) {
 159         uint32_t lhs_pixel = pixel_at(x, y);
 160         uint32_t rhs_pixel = rhs.pixel_at(x, y);
 161         if (lhs_pixel != rhs_pixel)
 162           ++pixels_different;
 163       }
 164     }
 165
 166     // Like the WebKit ImageDiff tool, we define percentage different in terms
 167     // of the size of the 'actual' bitmap.
 168     double total_pixels = static_cast<double>(width_) *
 169                           static_cast<double>(height_);
 170     return static_cast<double>(pixels_different) / total_pixels * 100.;
 171   }
 172
 173   // Returns the 0x0RGB or 0xARGB value of the pixel at the given location,
 174   // depending on ignore_alpha_.
 175   uint32 pixel_at(int x, int y) const {
 176     EXPECT_TRUE(x >= 0 && x < width_);
 177     EXPECT_TRUE(y >= 0 && y < height_);
 178     const uint32* data = reinterpret_cast<const uint32*>(&*data_.begin());
 179     const uint32* data_row = data + y * row_length_ / sizeof(uint32);
 180     if (ignore_alpha_)
 181       return data_row[x] & 0xFFFFFF;  // Strip out A.
 182     else
 183       return data_row[x];
 184   }
 185
 186  protected:
 187   void SetSkBitmap(const SkBitmap& bitmap) {
 188     SkAutoLockPixels lock(bitmap);
 189     width_ = bitmap.width();
 190     height_ = bitmap.height();
 191     row_length_ = static_cast<int>(bitmap.rowBytes());
 192     size_t size = row_length_ * height_;
 193     data_.resize(size);
 194     memcpy(&*data_.begin(), bitmap.getAddr(0, 0), size);
 195   }
 196
 197  private:
 198   // Pixel dimensions of the image.
 199   int width_;
 200   int height_;
 201
 202   // Length of a line in bytes.
 203   int row_length_;
 204
 205   // Actual bitmap data in arrays of RGBAs (so when loaded as uint32, it's
 206   // 0xABGR).
 207   std::vector<unsigned char> data_;
 208
 209   // Flag to signal if the comparison functions should ignore the alpha channel.
 210   const bool ignore_alpha_;
 211
 212   DISALLOW_COPY_AND_ASSIGN(Image);
 213 };
 214
 215 // Base for tests. Capability to process an image.
 216 class ImageTest : public testing::Test {
 217  public:
 218   // In what state is the test running.
 219   enum ProcessAction {
 220     GENERATE,
 221     COMPARE,
 222     NOOP,
 223   };
 224
 225   ImageTest(ProcessAction default_action)
 226       : action_(default_action) {
 227   }
 228
 229  protected:
 230   virtual void SetUp() {
 231     const testing::TestInfo& test_info =
 232         *testing::UnitTest::GetInstance()->current_test_info();
 233     PathService::Get(base::DIR_SOURCE_ROOT, &test_dir_);
 234     test_dir_ = test_dir_.AppendASCII("skia").
 235                           AppendASCII("ext").
 236                           AppendASCII("data").
 237                           AppendASCII(test_info.test_case_name()).
 238                           AppendASCII(test_info.name());
 239
 240     // Hack for a quick lowercase. We assume all the tests names are ASCII.
 241     base::FilePath::StringType tmp(test_dir_.value());
 242     for (size_t i = 0; i < tmp.size(); ++i)
 243       tmp[i] = base::ToLowerASCII(tmp[i]);
 244     test_dir_ = base::FilePath(tmp);
 245
 246     if (action_ == GENERATE) {
 247       // Make sure the directory exist.
 248       base::CreateDirectory(test_dir_);
 249     }
 250   }
 251
 252   // Returns the fully qualified path of a data file.
 253   base::FilePath test_file(const base::FilePath::StringType& filename) const {
 254     // Hack for a quick lowercase. We assume all the test data file names are
 255     // ASCII.
 256 #if defined(OS_WIN)
 257     std::string tmp = base::UTF16ToASCII(filename);
 258 #else
 259     std::string tmp(filename);
 260 #endif
 261     for (size_t i = 0; i < tmp.size(); ++i)
 262       tmp[i] = base::ToLowerASCII(tmp[i]);
 263
 264     return test_dir_.AppendASCII(tmp);
 265   }
 266
 267   // Compares or saves the bitmap currently loaded in the context, depending on
 268   // kGenerating value. Returns 0 on success or any positive value between ]0,
 269   // 100] on failure. The return value is the percentage of difference between
 270   // the image in the file and the image in the canvas.
 271   double ProcessCanvas(skia::PlatformCanvas& canvas,
 272                        base::FilePath::StringType filename) const {
 273     filename = filename + FILE_PATH_LITERAL(".png");
 274     switch (action_) {
 275       case GENERATE:
 276         SaveImage(canvas, filename);
 277         return 0.;
 278       case COMPARE:
 279         return CompareImage(canvas, filename);
 280       case NOOP:
 281         return 0;
 282       default:
 283         // Invalid state, returns that the image is 100 different.
 284         return 100.;
 285     }
 286   }
 287
 288   // Compares the bitmap currently loaded in the context with the file. Returns
 289   // the percentage of pixel difference between both images, between 0 and 100.
 290   double CompareImage(skia::PlatformCanvas& canvas,
 291                       const base::FilePath::StringType& filename) const {
 292     Image image1(canvas);
 293     Image image2(test_file(filename));
 294     double diff = image1.PercentageDifferent(image2);
 295     return diff;
 296   }
 297
 298   // Saves the bitmap currently loaded in the context into the file.
 299   void SaveImage(skia::PlatformCanvas& canvas,
 300                  const base::FilePath::StringType& filename) const {
 301     Image(canvas).SaveToFile(test_file(filename));
 302   }
 303
 304   ProcessAction action_;
 305
 306   // Path to directory used to contain the test data.
 307   base::FilePath test_dir_;
 308
 309   DISALLOW_COPY_AND_ASSIGN(ImageTest);
 310 };
 311
 312 // Premultiply the Alpha channel on the R, B and G channels.
 313 void Premultiply(SkBitmap bitmap) {
 314   SkAutoLockPixels lock(bitmap);
 315   for (int x = 0; x < bitmap.width(); ++x) {
 316     for (int y = 0; y < bitmap.height(); ++y) {
 317       uint32_t* pixel_addr = bitmap.getAddr32(x, y);
 318       uint32_t color = *pixel_addr;
 319       BYTE alpha = SkColorGetA(color);
 320       if (!alpha) {
 321         *pixel_addr = 0;
 322       } else {
 323         BYTE alpha_offset = alpha / 2;
 324         *pixel_addr = SkColorSetARGB(
 325             SkColorGetA(color),
 326             (SkColorGetR(color) * 255 + alpha_offset) / alpha,
 327             (SkColorGetG(color) * 255 + alpha_offset) / alpha,
 328             (SkColorGetB(color) * 255 + alpha_offset) / alpha);
 329       }
 330     }
 331   }
 332 }
 333
 334 void LoadPngFileToSkBitmap(const base::FilePath& filename,
 335                            SkBitmap* bitmap,
 336                            bool is_opaque) {
 337   std::string compressed;
 338   base::ReadFileToString(base::MakeAbsoluteFilePath(filename), &compressed);
 339   ASSERT_TRUE(compressed.size());
 340
 341   ASSERT_TRUE(gfx::PNGCodec::Decode(
 342       reinterpret_cast<const unsigned char*>(compressed.data()),
 343       compressed.size(), bitmap));
 344
 345   EXPECT_EQ(is_opaque, bitmap->isOpaque());
 346   Premultiply(*bitmap);
 347 }
 348
 349 }  // namespace
 350
 351 // Streams an image.
 352 inline std::ostream& operator<<(std::ostream& out, const Image& image) {
 353   return out << "Image(" << image.width() << ", "
 354              << image.height() << ", " << image.row_length() << ")";
 355 }
 356
 357 // Runs simultaneously the same drawing commands on VectorCanvas and
 358 // PlatformCanvas and compare the results.
 359 class VectorCanvasTest : public ImageTest {
 360  public:
 361   typedef ImageTest parent;
 362
 363   VectorCanvasTest() : parent(CurrentMode()), compare_canvas_(true) {
 364   }
 365
 366  protected:
 367   virtual void SetUp() {
 368     parent::SetUp();
 369     Init(100);
 370     number_ = 0;
 371   }
 372
 373   virtual void TearDown() {
 374     delete pcanvas_;
 375     pcanvas_ = NULL;
 376
 377     delete vcanvas_;
 378     vcanvas_ = NULL;
 379
 380     delete bitmap_;
 381     bitmap_ = NULL;
 382
 383     delete context_;
 384     context_ = NULL;
 385
 386     parent::TearDown();
 387   }
 388
 389   void Init(int size) {
 390     size_ = size;
 391     context_ = new Context();
 392     bitmap_ = new Bitmap(*context_, size_, size_);
 393     vcanvas_ = new VectorCanvas(
 394         VectorPlatformDeviceEmf::CreateDevice(
 395             size_, size_, true, context_->context()));
 396     pcanvas_ = CreatePlatformCanvas(size_, size_, false);
 397
 398     // Clear white.
 399     vcanvas_->drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
 400     pcanvas_->drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
 401   }
 402
 403   // Compares both canvas and returns the pixel difference in percentage between
 404   // both images. 0 on success and ]0, 100] on failure.
 405   double ProcessImage(const base::FilePath::StringType& filename) {
 406     std::wstring number(base::StringPrintf(L"%02d_", number_++));
 407     double diff1 = parent::ProcessCanvas(*vcanvas_, number + L"vc_" + filename);
 408     double diff2 = parent::ProcessCanvas(*pcanvas_, number + L"pc_" + filename);
 409     if (!compare_canvas_)
 410       return std::max(diff1, diff2);
 411
 412     Image image1(*vcanvas_);
 413     Image image2(*pcanvas_);
 414     double diff = image1.PercentageDifferent(image2);
 415     return std::max(std::max(diff1, diff2), diff);
 416   }
 417
 418   // Returns COMPARE, which is the default. If kGenerateSwitch command
 419   // line argument is used to start this process, GENERATE is returned instead.
 420   static ProcessAction CurrentMode() {
 421     return CommandLine::ForCurrentProcess()->HasSwitch(kGenerateSwitch) ?
 422                GENERATE : COMPARE;
 423   }
 424
 425   // Length in x and y of the square canvas.
 426   int size_;
 427
 428   // Current image number in the current test. Used to number of test files.
 429   int number_;
 430
 431   // A temporary HDC to draw into.
 432   Context* context_;
 433
 434   // Bitmap created inside context_.
 435   Bitmap* bitmap_;
 436
 437   // Vector based canvas.
 438   VectorCanvas* vcanvas_;
 439
 440   // Pixel based canvas.
 441   PlatformCanvas* pcanvas_;
 442
 443   // When true (default), vcanvas_ and pcanvas_ contents are compared and
 444   // verified to be identical.
 445   bool compare_canvas_;
 446 };
 447
 448
 449 ////////////////////////////////////////////////////////////////////////////////
 450 // Actual tests
 451
 452 #if !defined(USE_AURA)  // http://crbug.com/154358
 453
 454 TEST_F(VectorCanvasTest, BasicDrawing) {
 455   EXPECT_EQ(Image(*vcanvas_).PercentageDifferent(Image(*pcanvas_)), 0.)
 456       << L"clean";
 457   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("clean")));
 458
 459   // Clear white.
 460   {
 461     vcanvas_->drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
 462     pcanvas_->drawARGB(255, 255, 255, 255, SkXfermode::kSrc_Mode);
 463   }
 464   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawARGB")));
 465
 466   // Diagonal line top-left to bottom-right.
 467   {
 468     SkPaint paint;
 469     // Default color is black.
 470     vcanvas_->drawLine(10, 10, 90, 90, paint);
 471     pcanvas_->drawLine(10, 10, 90, 90, paint);
 472   }
 473   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawLine_black")));
 474
 475   // Rect.
 476   {
 477     SkPaint paint;
 478     paint.setColor(SK_ColorGREEN);
 479     vcanvas_->drawRectCoords(25, 25, 75, 75, paint);
 480     pcanvas_->drawRectCoords(25, 25, 75, 75, paint);
 481   }
 482   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawRect_green")));
 483
 484   // A single-point rect doesn't leave any mark.
 485   {
 486     SkPaint paint;
 487     paint.setColor(SK_ColorBLUE);
 488     vcanvas_->drawRectCoords(5, 5, 5, 5, paint);
 489     pcanvas_->drawRectCoords(5, 5, 5, 5, paint);
 490   }
 491   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawRect_noop")));
 492
 493   // Rect.
 494   {
 495     SkPaint paint;
 496     paint.setColor(SK_ColorBLUE);
 497     vcanvas_->drawRectCoords(75, 50, 80, 55, paint);
 498     pcanvas_->drawRectCoords(75, 50, 80, 55, paint);
 499   }
 500   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawRect_noop")));
 501
 502   // Empty again
 503   {
 504     vcanvas_->drawPaint(SkPaint());
 505     pcanvas_->drawPaint(SkPaint());
 506   }
 507   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawPaint_black")));
 508
 509   // Horizontal line left to right.
 510   {
 511     SkPaint paint;
 512     paint.setColor(SK_ColorRED);
 513     vcanvas_->drawLine(10, 20, 90, 20, paint);
 514     pcanvas_->drawLine(10, 20, 90, 20, paint);
 515   }
 516   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawLine_left_to_right")));
 517
 518   // Vertical line downward.
 519   {
 520     SkPaint paint;
 521     paint.setColor(SK_ColorRED);
 522     vcanvas_->drawLine(30, 10, 30, 90, paint);
 523     pcanvas_->drawLine(30, 10, 30, 90, paint);
 524   }
 525   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawLine_red")));
 526 }
 527
 528 TEST_F(VectorCanvasTest, Circles) {
 529   // There is NO WAY to make them agree. At least verify that the output doesn't
 530   // change across versions. This test is disabled. See bug 1060231.
 531   compare_canvas_ = false;
 532
 533   // Stroked Circle.
 534   {
 535     SkPaint paint;
 536     SkPath path;
 537     path.addCircle(50, 75, 10);
 538     paint.setStyle(SkPaint::kStroke_Style);
 539     paint.setColor(SK_ColorMAGENTA);
 540     vcanvas_->drawPath(path, paint);
 541     pcanvas_->drawPath(path, paint);
 542   }
 543   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("circle_stroke")));
 544
 545   // Filled Circle.
 546   {
 547     SkPaint paint;
 548     SkPath path;
 549     path.addCircle(50, 25, 10);
 550     paint.setStyle(SkPaint::kFill_Style);
 551     vcanvas_->drawPath(path, paint);
 552     pcanvas_->drawPath(path, paint);
 553   }
 554   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("circle_fill")));
 555
 556   // Stroked Circle over.
 557   {
 558     SkPaint paint;
 559     SkPath path;
 560     path.addCircle(50, 25, 10);
 561     paint.setStyle(SkPaint::kStroke_Style);
 562     paint.setColor(SK_ColorBLUE);
 563     vcanvas_->drawPath(path, paint);
 564     pcanvas_->drawPath(path, paint);
 565   }
 566   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("circle_over_strike")));
 567
 568   // Stroke and Fill Circle.
 569   {
 570     SkPaint paint;
 571     SkPath path;
 572     path.addCircle(12, 50, 10);
 573     paint.setStyle(SkPaint::kStrokeAndFill_Style);
 574     paint.setColor(SK_ColorRED);
 575     vcanvas_->drawPath(path, paint);
 576     pcanvas_->drawPath(path, paint);
 577   }
 578   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("circle_stroke_and_fill")));
 579
 580   // Line + Quad + Cubic.
 581   {
 582     SkPaint paint;
 583     SkPath path;
 584     paint.setStyle(SkPaint::kStroke_Style);
 585     paint.setColor(SK_ColorGREEN);
 586     path.moveTo(1, 1);
 587     path.lineTo(60, 40);
 588     path.lineTo(80, 80);
 589     path.quadTo(20, 50, 10, 90);
 590     path.quadTo(50, 20, 90, 10);
 591     path.cubicTo(20, 40, 50, 50, 10, 10);
 592     path.cubicTo(30, 20, 50, 50, 90, 10);
 593     path.addRect(90, 90, 95, 96);
 594     vcanvas_->drawPath(path, paint);
 595     pcanvas_->drawPath(path, paint);
 596   }
 597   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("mixed_stroke")));
 598 }
 599
 600 TEST_F(VectorCanvasTest, LineOrientation) {
 601   // There is NO WAY to make them agree. At least verify that the output doesn't
 602   // change across versions. This test is disabled. See bug 1060231.
 603   compare_canvas_ = false;
 604
 605   // Horizontal lines.
 606   {
 607     SkPaint paint;
 608     paint.setColor(SK_ColorRED);
 609     // Left to right.
 610     vcanvas_->drawLine(10, 20, 90, 20, paint);
 611     pcanvas_->drawLine(10, 20, 90, 20, paint);
 612     // Right to left.
 613     vcanvas_->drawLine(90, 30, 10, 30, paint);
 614     pcanvas_->drawLine(90, 30, 10, 30, paint);
 615   }
 616   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("horizontal")));
 617
 618   // Vertical lines.
 619   {
 620     SkPaint paint;
 621     paint.setColor(SK_ColorRED);
 622     // Top down.
 623     vcanvas_->drawLine(20, 10, 20, 90, paint);
 624     pcanvas_->drawLine(20, 10, 20, 90, paint);
 625     // Bottom up.
 626     vcanvas_->drawLine(30, 90, 30, 10, paint);
 627     pcanvas_->drawLine(30, 90, 30, 10, paint);
 628   }
 629   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("vertical")));
 630
 631   // Try again with a 180 degres rotation.
 632   vcanvas_->rotate(180);
 633   pcanvas_->rotate(180);
 634
 635   // Horizontal lines (rotated).
 636   {
 637     SkPaint paint;
 638     paint.setColor(SK_ColorRED);
 639     vcanvas_->drawLine(-10, -25, -90, -25, paint);
 640     pcanvas_->drawLine(-10, -25, -90, -25, paint);
 641     vcanvas_->drawLine(-90, -35, -10, -35, paint);
 642     pcanvas_->drawLine(-90, -35, -10, -35, paint);
 643   }
 644   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("horizontal_180")));
 645
 646   // Vertical lines (rotated).
 647   {
 648     SkPaint paint;
 649     paint.setColor(SK_ColorRED);
 650     vcanvas_->drawLine(-25, -10, -25, -90, paint);
 651     pcanvas_->drawLine(-25, -10, -25, -90, paint);
 652     vcanvas_->drawLine(-35, -90, -35, -10, paint);
 653     pcanvas_->drawLine(-35, -90, -35, -10, paint);
 654   }
 655   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("vertical_180")));
 656 }
 657
 658 TEST_F(VectorCanvasTest, PathOrientation) {
 659   // There is NO WAY to make them agree. At least verify that the output doesn't
 660   // change across versions. This test is disabled. See bug 1060231.
 661   compare_canvas_ = false;
 662
 663   // Horizontal lines.
 664   {
 665     SkPaint paint;
 666     paint.setStyle(SkPaint::kStroke_Style);
 667     paint.setColor(SK_ColorRED);
 668     SkPath path;
 669     SkPoint start;
 670     start.set(10, 20);
 671     SkPoint end;
 672     end.set(90, 20);
 673     path.moveTo(start);
 674     path.lineTo(end);
 675     vcanvas_->drawPath(path, paint);
 676     pcanvas_->drawPath(path, paint);
 677   }
 678   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawPath_ltr")));
 679
 680   // Horizontal lines.
 681   {
 682     SkPaint paint;
 683     paint.setStyle(SkPaint::kStroke_Style);
 684     paint.setColor(SK_ColorRED);
 685     SkPath path;
 686     SkPoint start;
 687     start.set(90, 30);
 688     SkPoint end;
 689     end.set(10, 30);
 690     path.moveTo(start);
 691     path.lineTo(end);
 692     vcanvas_->drawPath(path, paint);
 693     pcanvas_->drawPath(path, paint);
 694   }
 695   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("drawPath_rtl")));
 696 }
 697
 698 TEST_F(VectorCanvasTest, DiagonalLines) {
 699   SkPaint paint;
 700   paint.setColor(SK_ColorRED);
 701
 702   vcanvas_->drawLine(10, 10, 90, 90, paint);
 703   pcanvas_->drawLine(10, 10, 90, 90, paint);
 704   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("nw-se")));
 705
 706   // Starting here, there is NO WAY to make them agree. At least verify that the
 707   // output doesn't change across versions. This test is disabled. See bug
 708   // 1060231.
 709   compare_canvas_ = false;
 710
 711   vcanvas_->drawLine(10, 95, 90, 15, paint);
 712   pcanvas_->drawLine(10, 95, 90, 15, paint);
 713   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("sw-ne")));
 714
 715   vcanvas_->drawLine(90, 10, 10, 90, paint);
 716   pcanvas_->drawLine(90, 10, 10, 90, paint);
 717   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("ne-sw")));
 718
 719   vcanvas_->drawLine(95, 90, 15, 10, paint);
 720   pcanvas_->drawLine(95, 90, 15, 10, paint);
 721   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("se-nw")));
 722 }
 723
 724 #if defined(OS_WIN)
 725 #define MAYBE_PathEffects DISABLED_PathEffects
 726 #else
 727 #define MAYBE_PathEffects PathEffects
 728 #endif
 729 TEST_F(VectorCanvasTest, MAYBE_PathEffects) {
 730   {
 731     SkPaint paint;
 732     SkScalar intervals[] = { 1, 1 };
 733     skia::RefPtr<SkPathEffect> effect = skia::AdoptRef(
 734         new SkDashPathEffect(intervals, arraysize(intervals), 0));
 735     paint.setPathEffect(effect.get());
 736     paint.setColor(SK_ColorMAGENTA);
 737     paint.setStyle(SkPaint::kStroke_Style);
 738
 739     vcanvas_->drawLine(10, 10, 90, 10, paint);
 740     pcanvas_->drawLine(10, 10, 90, 10, paint);
 741   }
 742   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("dash_line")));
 743
 744
 745   // Starting here, there is NO WAY to make them agree. At least verify that the
 746   // output doesn't change across versions. This test is disabled. See bug
 747   // 1060231.
 748   compare_canvas_ = false;
 749
 750   {
 751     SkPaint paint;
 752     SkScalar intervals[] = { 3, 5 };
 753     skia::RefPtr<SkPathEffect> effect = skia::AdoptRef(
 754         new SkDashPathEffect(intervals, arraysize(intervals), 0));
 755     paint.setPathEffect(effect.get());
 756     paint.setColor(SK_ColorMAGENTA);
 757     paint.setStyle(SkPaint::kStroke_Style);
 758
 759     SkPath path;
 760     path.moveTo(10, 15);
 761     path.lineTo(90, 15);
 762     path.lineTo(90, 90);
 763     vcanvas_->drawPath(path, paint);
 764     pcanvas_->drawPath(path, paint);
 765   }
 766   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("dash_path")));
 767
 768   {
 769     SkPaint paint;
 770     SkScalar intervals[] = { 2, 1 };
 771     skia::RefPtr<SkPathEffect> effect = skia::AdoptRef(
 772         new SkDashPathEffect(intervals, arraysize(intervals), 0));
 773     paint.setPathEffect(effect.get());
 774     paint.setColor(SK_ColorMAGENTA);
 775     paint.setStyle(SkPaint::kStroke_Style);
 776
 777     vcanvas_->drawRectCoords(20, 20, 30, 30, paint);
 778     pcanvas_->drawRectCoords(20, 20, 30, 30, paint);
 779   }
 780   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("dash_rect")));
 781
 782   // This thing looks like it has been drawn by a 3 years old kid. I haven't
 783   // filed a bug on this since I guess nobody is expecting this to look nice.
 784   {
 785     SkPaint paint;
 786     SkScalar intervals[] = { 1, 1 };
 787     skia::RefPtr<SkPathEffect> effect = skia::AdoptRef(
 788         new SkDashPathEffect(intervals, arraysize(intervals), 0));
 789     paint.setPathEffect(effect.get());
 790     paint.setColor(SK_ColorMAGENTA);
 791     paint.setStyle(SkPaint::kStroke_Style);
 792
 793     SkPath path;
 794     path.addCircle(50, 75, 10);
 795     vcanvas_->drawPath(path, paint);
 796     pcanvas_->drawPath(path, paint);
 797     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("circle")));
 798   }
 799 }
 800
 801 TEST_F(VectorCanvasTest, Bitmaps) {
 802   {
 803     SkBitmap bitmap;
 804     LoadPngFileToSkBitmap(test_file(L"bitmap_opaque.png"), &bitmap, true);
 805     vcanvas_->drawBitmap(bitmap, 13, 3, NULL);
 806     pcanvas_->drawBitmap(bitmap, 13, 3, NULL);
 807     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("opaque")));
 808   }
 809
 810   {
 811     SkBitmap bitmap;
 812     LoadPngFileToSkBitmap(test_file(L"bitmap_alpha.png"), &bitmap, false);
 813     vcanvas_->drawBitmap(bitmap, 5, 15, NULL);
 814     pcanvas_->drawBitmap(bitmap, 5, 15, NULL);
 815     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("alpha")));
 816   }
 817 }
 818
 819 TEST_F(VectorCanvasTest, ClippingRect) {
 820   SkBitmap bitmap;
 821   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 822                         true);
 823   SkRect rect;
 824   rect.fLeft = 2;
 825   rect.fTop = 2;
 826   rect.fRight = 30.5f;
 827   rect.fBottom = 30.5f;
 828   vcanvas_->clipRect(rect);
 829   pcanvas_->clipRect(rect);
 830
 831   vcanvas_->drawBitmap(bitmap, 13, 3, NULL);
 832   pcanvas_->drawBitmap(bitmap, 13, 3, NULL);
 833   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("rect")));
 834 }
 835
 836 TEST_F(VectorCanvasTest, ClippingPath) {
 837   SkBitmap bitmap;
 838   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 839                         true);
 840   SkPath path;
 841   path.addCircle(20, 20, 10);
 842   vcanvas_->clipPath(path);
 843   pcanvas_->clipPath(path);
 844
 845   vcanvas_->drawBitmap(bitmap, 14, 3, NULL);
 846   pcanvas_->drawBitmap(bitmap, 14, 3, NULL);
 847   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("path")));
 848 }
 849
 850 TEST_F(VectorCanvasTest, ClippingCombined) {
 851   SkBitmap bitmap;
 852   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 853                         true);
 854
 855   SkRect rect;
 856   rect.fLeft = 2;
 857   rect.fTop = 2;
 858   rect.fRight = 30.5f;
 859   rect.fBottom = 30.5f;
 860   vcanvas_->clipRect(rect);
 861   pcanvas_->clipRect(rect);
 862   SkPath path;
 863   path.addCircle(20, 20, 10);
 864   vcanvas_->clipPath(path, SkRegion::kUnion_Op);
 865   pcanvas_->clipPath(path, SkRegion::kUnion_Op);
 866
 867   vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 868   pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 869   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("combined")));
 870 }
 871
 872 TEST_F(VectorCanvasTest, ClippingIntersect) {
 873   SkBitmap bitmap;
 874   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 875                         true);
 876
 877   SkRect rect;
 878   rect.fLeft = 2;
 879   rect.fTop = 2;
 880   rect.fRight = 30.5f;
 881   rect.fBottom = 30.5f;
 882   vcanvas_->clipRect(rect);
 883   pcanvas_->clipRect(rect);
 884   SkPath path;
 885   path.addCircle(23, 23, 15);
 886   vcanvas_->clipPath(path);
 887   pcanvas_->clipPath(path);
 888
 889   vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 890   pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 891   EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("intersect")));
 892 }
 893
 894 TEST_F(VectorCanvasTest, ClippingClean) {
 895   SkBitmap bitmap;
 896   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 897                         true);
 898   {
 899     SkAutoCanvasRestore acrv(vcanvas_, true);
 900     SkAutoCanvasRestore acrp(pcanvas_, true);
 901     SkRect rect;
 902     rect.fLeft = 2;
 903     rect.fTop = 2;
 904     rect.fRight = 30.5f;
 905     rect.fBottom = 30.5f;
 906     vcanvas_->clipRect(rect);
 907     pcanvas_->clipRect(rect);
 908
 909     vcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 910     pcanvas_->drawBitmap(bitmap, 15, 3, NULL);
 911     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("clipped")));
 912   }
 913   {
 914     // Verify that the clipping region has been fixed back.
 915     vcanvas_->drawBitmap(bitmap, 55, 3, NULL);
 916     pcanvas_->drawBitmap(bitmap, 55, 3, NULL);
 917     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("unclipped")));
 918   }
 919 }
 920
 921 // See http://crbug.com/26938
 922 TEST_F(VectorCanvasTest, DISABLED_Matrix) {
 923   SkBitmap bitmap;
 924   LoadPngFileToSkBitmap(test_file(L"..\\bitmaps\\bitmap_opaque.png"), &bitmap,
 925                         true);
 926   {
 927     vcanvas_->translate(15, 3);
 928     pcanvas_->translate(15, 3);
 929     vcanvas_->drawBitmap(bitmap, 0, 0, NULL);
 930     pcanvas_->drawBitmap(bitmap, 0, 0, NULL);
 931     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("translate1")));
 932   }
 933   {
 934     vcanvas_->translate(-30, -23);
 935     pcanvas_->translate(-30, -23);
 936     vcanvas_->drawBitmap(bitmap, 0, 0, NULL);
 937     pcanvas_->drawBitmap(bitmap, 0, 0, NULL);
 938     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("translate2")));
 939   }
 940   vcanvas_->resetMatrix();
 941   pcanvas_->resetMatrix();
 942
 943   // For scaling and rotation, they use a different algorithm (nearest
 944   // neighborhood vs smoothing). At least verify that the output doesn't change
 945   // across versions.
 946   compare_canvas_ = false;
 947
 948   {
 949     vcanvas_->scale(SkDoubleToScalar(1.9), SkDoubleToScalar(1.5));
 950     pcanvas_->scale(SkDoubleToScalar(1.9), SkDoubleToScalar(1.5));
 951     vcanvas_->drawBitmap(bitmap, 1, 1, NULL);
 952     pcanvas_->drawBitmap(bitmap, 1, 1, NULL);
 953     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("scale")));
 954   }
 955   vcanvas_->resetMatrix();
 956   pcanvas_->resetMatrix();
 957
 958   {
 959     vcanvas_->rotate(67);
 960     pcanvas_->rotate(67);
 961     vcanvas_->drawBitmap(bitmap, 20, -50, NULL);
 962     pcanvas_->drawBitmap(bitmap, 20, -50, NULL);
 963     EXPECT_EQ(0., ProcessImage(FILE_PATH_LITERAL("rotate")));
 964   }
 965 }
 966
 967 #endif  // !defined(USE_AURA)
 968
 969 }  // namespace skia