Move classes depending on Skia out of base/gfx and into app/gfx. Rename...

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 "PNGImageDecoder.h"
 
 #include "app/gfx/codec/png_codec.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
-#include "base/gfx/gdi_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "skia/ext/vector_canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
 
 namespace skia {
 
 namespace {
 
 const wchar_t* const kGenerateSwitch = L"vector-canvas-generate";
 
 // Lightweight HDC management.
 class Context {
  public:
   Context() : context_(CreateCompatibleDC(NULL)) {
     EXPECT_TRUE(context_);
   }
   ~Context() {
     DeleteDC(context_);
   }
 
   HDC context() const { return context_; }
 
  private:
   HDC context_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Context);
+  DISALLOW_COPY_AND_ASSIGN(Context);
 };
 
 // Lightweight HBITMAP management.
 class Bitmap {
  public:
   Bitmap(const Context& context, int x, int y) {
     BITMAPINFOHEADER hdr;
-    gfx::CreateBitmapHeader(x, y, &hdr);
+    hdr.biSize = sizeof(BITMAPINFOHEADER);
+    hdr.biWidth = x;
+    hdr.biHeight = -y;  // Minus means top-down bitmap.
+    hdr.biPlanes = 1;
+    hdr.biBitCount = 32;
+    hdr.biCompression = BI_RGB;  // No compression.
+    hdr.biSizeImage = 0;
+    hdr.biXPelsPerMeter = 1;
+    hdr.biYPelsPerMeter = 1;
+    hdr.biClrUsed = 0;
+    hdr.biClrImportant = 0;
     bitmap_ = CreateDIBSection(context.context(),
                                reinterpret_cast<BITMAPINFO*>(&hdr), 0,
                                &data_, NULL, 0);
     EXPECT_TRUE(bitmap_);
     EXPECT_TRUE(SelectObject(context.context(), bitmap_));
   }
   ~Bitmap() {
     EXPECT_TRUE(DeleteObject(bitmap_));
   }
 
  private:
   HBITMAP bitmap_;
 
   void* data_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Bitmap);
+  DISALLOW_COPY_AND_ASSIGN(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) {
     Vector<char> compressed;
     ReadFileToVector(filename, &compressed);
@@ skipping 110 matching lines @@
   // 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_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(Image);
+  DISALLOW_COPY_AND_ASSIGN(Image);
 };
 
 // Base for tests. Capability to process an image.
 class ImageTest : public testing::Test {
  public:
   // In what state is the test running.
   enum ProcessAction {
     GENERATE,
     COMPARE,
     NOOP,
@@ skipping 75 matching lines @@
   void SaveImage(const skia::PlatformCanvas& canvas,
                  const std::wstring& filename) const {
     Image(canvas).SaveToFile(test_file(filename));
   }
 
   ProcessAction action_;
 
   // Path to directory used to contain the test data.
   std::wstring test_dir_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(ImageTest);
+  DISALLOW_COPY_AND_ASSIGN(ImageTest);
 };
 
 // Premultiply the Alpha channel on the R, B and G channels.
 void Premultiply(SkBitmap bitmap) {
   SkAutoLockPixels lock(bitmap);
   for (int x = 0; x < bitmap.width(); ++x) {
     for (int y = 0; y < bitmap.height(); ++y) {
       uint32_t* pixel_addr = bitmap.getAddr32(x, y);
       uint32_t color = *pixel_addr;
       BYTE alpha = SkColorGetA(color);
@@ skipping 648 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