rename getBitmapDC to beginPlatformPaint and add calls to endPlatformPaint

skia/ext/vector_platform_device_emf_win.cc

 // Copyright (c) 2011 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_emf_win.h"
 
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/skia_utils_win.h"
@@ skipping 176 matching lines @@
     SkSafeUnref(paint_no_effet.setPathEffect(NULL));
 
     // Draw the calculated path.
     drawPath(draw, path_modified, paint_no_effet);
     return;
   }
 
   if (!ApplyPaint(paint)) {
     return;
   }
-  HDC dc = getBitmapDC();
+  HDC dc = beginPlatformPaint();
   if (!Rectangle(dc, SkScalarRound(rect.fLeft),
                  SkScalarRound(rect.fTop),
                  SkScalarRound(rect.fRight),
                  SkScalarRound(rect.fBottom))) {
     SkASSERT(false);
   }
+  endPlatformPaint();
   Cleanup();
 }
 
 void VectorPlatformDeviceEmf::drawPath(const SkDraw& draw,
                                        const SkPath& path,
                                        const SkPaint& paint,
                                        const SkMatrix* prePathMatrix,
                                        bool pathIsMutable) {
   if (paint.getPathEffect()) {
     // Apply the path effect forehand.
     SkPath path_modified;
     paint.getFillPath(path, &path_modified);
 
     // Removes the path effect from the temporary SkPaint object.
     SkPaint paint_no_effet(paint);
     SkSafeUnref(paint_no_effet.setPathEffect(NULL));
 
     // Draw the calculated path.
     drawPath(draw, path_modified, paint_no_effet);
     return;
   }
 
   if (!ApplyPaint(paint)) {
     return;
   }
-  HDC dc = getBitmapDC();
+  HDC dc = beginPlatformPaint();
   PlatformDevice::LoadPathToDC(dc, path);
   switch (paint.getStyle()) {
     case SkPaint::kFill_Style: {
       BOOL res = StrokeAndFillPath(dc);
       SkASSERT(res != 0);
       break;
     }
     case SkPaint::kStroke_Style: {
       BOOL res = StrokePath(dc);
       SkASSERT(res != 0);
       break;
     }
     case SkPaint::kStrokeAndFill_Style: {
       BOOL res = StrokeAndFillPath(dc);
       SkASSERT(res != 0);
       break;
     }
     default:
       SkASSERT(false);
       break;
   }
+  endPlatformPaint();
   Cleanup();
 }
 
 void VectorPlatformDeviceEmf::drawBitmap(const SkDraw& draw,
                                          const SkBitmap& bitmap,
                                          const SkIRect* srcRectOrNull,
                                          const SkMatrix& matrix,
                                          const SkPaint& paint) {
   // Load the temporary matrix. This is what will translate, rotate and resize
   // the bitmap.
@@ skipping 364 matching lines @@
   BITMAPV4HEADER 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;
         }
       }
     }
   }
 
+  HDC dc = beginPlatformPaint();
   BITMAPINFOHEADER 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);
 
@@ skipping 45 matching lines @@
                                 x, y,  // Destination origin.
                                 src_size_x, src_size_y,
                                 0, 0,  // Source origin.
                                 src_size_x, src_size_y,  // Source size.
                                 pixels,
                                 reinterpret_cast<const BITMAPINFO*>(&hdr),
                                 DIB_RGB_COLORS,
                                 SRCCOPY);
     SkASSERT(result);
   }
+  endPlatformPaint();
   Cleanup();
 }
 
 }  // namespace skia