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

skia/ext/vector_platform_device_win.cc

 // Copyright (c) 2009 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 <windows.h>
 
 #include "skia/ext/vector_platform_device_win.h"
 
-#include "base/gfx/gdi_util.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkUtils.h"
 
 namespace skia {
 
+static void FillBitmapInfoHeader(int width, int height, BITMAPINFOHEADER* hdr) {
+  hdr->biSize = sizeof(BITMAPINFOHEADER);
+  hdr->biWidth = width;
+  hdr->biHeight = -height;  // 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;
+}
+
 VectorPlatformDevice* VectorPlatformDevice::create(HDC dc,
                                                    int width, int height) {
   InitializeDC(dc);
 
   // Link the SkBitmap to the current selected bitmap in the device context.
   SkBitmap bitmap;
   HGDIOBJ selected_bitmap = GetCurrentObject(dc, OBJ_BITMAP);
   bool succeeded = false;
   if (selected_bitmap != NULL) {
     BITMAP bitmap_data;
@@ skipping 530 matching lines @@
   } else {
     if (!ApplyPaint(paint))
       return;
     is_translucent = false;
   }
   int src_size_x = bitmap.width();
   int src_size_y = bitmap.height();
   if (!src_size_x || !src_size_y)
     return;
 
-  // Create a BMP v4 header that we can serialize.
+  // Create a BMP v4 header that we can serialize. We use the shared "V3"
+  // fillter to fill the stardard items, then add in the "V4" stuff we want.
   BITMAPV4HEADER bitmap_header;
-  gfx::CreateBitmapV4Header(src_size_x, src_size_y, &bitmap_header);
+  memset(&bitmap_header, 0, sizeof(BITMAPV4HEADER));
+  FillBitmapInfoHeader(src_size_x, src_size_y,
+                       reinterpret_cast<BITMAPINFOHEADER*>(&bitmap_header));
+  bitmap_header.bV4Size = sizeof(BITMAPV4HEADER);
+  bitmap_header.bV4RedMask   = 0x00ff0000;
+  bitmap_header.bV4GreenMask = 0x0000ff00;
+  bitmap_header.bV4BlueMask  = 0x000000ff;
+  bitmap_header.bV4AlphaMask = 0xff000000;
+
   HDC dc = getBitmapDC();
   SkAutoLockPixels lock(bitmap);
   SkASSERT(bitmap.getConfig() == SkBitmap::kARGB_8888_Config);
   const uint32_t* pixels = static_cast<const uint32_t*>(bitmap.getPixels());
   if (pixels == NULL) {
     SkASSERT(false);
     return;
   }
 
   if (!is_translucent) {
     int row_length = bitmap.rowBytesAsPixels();
     // There is no quick way to determine if an image is opaque.
     for (int y2 = 0; y2 < src_size_y; ++y2) {
       for (int x2 = 0; x2 < src_size_x; ++x2) {
         if (SkColorGetA(pixels[(y2 * row_length) + x2]) != 255) {
           is_translucent = true;
           y2 = src_size_y;
           break;
         }
       }
     }
   }
 
   BITMAPINFOHEADER hdr;
-  gfx::CreateBitmapHeader(src_size_x, src_size_y, &hdr);
+  FillBitmapInfoHeader(src_size_x, src_size_y, &hdr);
   if (is_translucent) {
     // The image must be loaded as a bitmap inside a device context.
     HDC bitmap_dc = ::CreateCompatibleDC(dc);
     void* bits = NULL;
     HBITMAP hbitmap = ::CreateDIBSection(
         bitmap_dc, reinterpret_cast<const BITMAPINFO*>(&hdr),
         DIB_RGB_COLORS, &bits, NULL, 0);
     memcpy(bits, pixels, bitmap.getSize());
     SkASSERT(hbitmap);
     HGDIOBJ old_bitmap = ::SelectObject(bitmap_dc, hbitmap);
@@ skipping 33 matching lines @@
                                 reinterpret_cast<const BITMAPINFO*>(&hdr),
                                 DIB_RGB_COLORS,
                                 SRCCOPY);
     SkASSERT(result);
   }
   Cleanup();
 }
 
 }  // namespace skia