Replace setMatrixClip() with BeginPlatformPaint() logic

skia/ext/bitmap_platform_device_win.cc

 // Copyright (c) 2012 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 <psapi.h>
 #include <stddef.h>
 
 #include "base/debug/gdi_debug_util_win.h"
 #include "base/logging.h"
 #include "base/win/win_util.h"
 #include "skia/ext/bitmap_platform_device_win.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
-#include "third_party/skia/include/core/SkRegion.h"
+#include "third_party/skia/include/core/SkRect.h"
 
 namespace {
 
 HBITMAP CreateHBitmap(int width, int height, bool is_opaque,
                              HANDLE shared_section, void** data) {
   // CreateDIBSection appears to get unhappy if we create an empty bitmap, so
   // just create a minimal bitmap
   if ((width == 0) || (height == 0)) {
     width = 1;
     height = 1;
@@ skipping 30 matching lines @@
   xf.eM11 = matrix[SkMatrix::kMScaleX];
   xf.eM21 = matrix[SkMatrix::kMSkewX];
   xf.eDx = matrix[SkMatrix::kMTransX];
   xf.eM12 = matrix[SkMatrix::kMSkewY];
   xf.eM22 = matrix[SkMatrix::kMScaleY];
   xf.eDy = matrix[SkMatrix::kMTransY];
   SetWorldTransform(dc, &xf);
 }
 
 void LoadClippingRegionToDC(HDC context,
-                            const SkRegion& region,
+                            const SkIRect& clip_bounds,
                             const SkMatrix& transformation) {
-  HRGN hrgn;
-  if (region.isEmpty()) {
-    // region can be empty, in which case everything will be clipped.
-    hrgn = CreateRectRgn(0, 0, 0, 0);
-  } else if (region.isRect()) {
-    // We don't apply transformation, because the translation is already applied
-    // to the region.
-    hrgn = CreateRectRgnIndirect(&skia::SkIRectToRECT(region.getBounds()));
-  } else {
-    hrgn = CreateRectRgnIndirect(&skia::SkIRectToRECT(region.getBounds()));
-    SkASSERT(!"Region clipping is being deprecated; this shouldn't fire.");
-  }
+  HRGN hrgn = CreateRectRgnIndirect(&skia::SkIRectToRECT(clip_bounds));
   int result = SelectClipRgn(context, hrgn);
   SkASSERT(result != ERROR);
   result = DeleteObject(hrgn);
   SkASSERT(result != 0);
 }
 
 }  // namespace
 
 namespace skia {
 
-void DrawToNativeContext(SkCanvas* canvas, HDC hdc, int x, int y,
+void DrawToNativeContext(SkCanvas* canvas, HDC destination_hdc, int x, int y,
                          const RECT* src_rect) {
+  ScopedPlatformPaint p(canvas);
   PlatformDevice* platform_device = GetPlatformDevice(GetTopDevice(*canvas));
   if (platform_device)
-    platform_device->DrawToHDC(hdc, x, y, src_rect);
+    platform_device->DrawToHDC(p.GetPlatformSurface(), destination_hdc, x, y,
+                               src_rect, canvas->getTotalMatrix());
+
 }
 
-void PlatformDevice::DrawToHDC(HDC, int x, int y, const RECT* src_rect) {}
+void PlatformDevice::DrawToHDC(HDC, HDC, int x, int y, const RECT* src_rect,
+                               const SkMatrix& transform) {}
 
-HDC BitmapPlatformDevice::GetBitmapDC() {
+HDC BitmapPlatformDevice::GetBitmapDC(const SkMatrix& transform,
+                                      const SkIRect& clip_bounds) {
   if (!hdc_) {
     hdc_ = CreateCompatibleDC(NULL);
     InitializeDC(hdc_);
     old_hbitmap_ = static_cast<HBITMAP>(SelectObject(hdc_, hbitmap_));
   }
 
-  LoadConfig();
+  LoadConfig(transform, clip_bounds);
   return hdc_;
 }
 
 void BitmapPlatformDevice::ReleaseBitmapDC() {
   SkASSERT(hdc_);
   SelectObject(hdc_, old_hbitmap_);
   DeleteDC(hdc_);
   hdc_ = NULL;
   old_hbitmap_ = NULL;
 }
 
 bool BitmapPlatformDevice::IsBitmapDCCreated()
     const {
   return hdc_ != NULL;
 }
 
-
-void BitmapPlatformDevice::SetMatrixClip(
-    const SkMatrix& transform,
-    const SkRegion& region) {
-  transform_ = transform;
-  clip_region_ = region;
-  config_dirty_ = true;
-}
-
-void BitmapPlatformDevice::LoadConfig() {
-  if (!config_dirty_ || !hdc_)
+void BitmapPlatformDevice::LoadConfig(const SkMatrix& transform,
+                                      const SkIRect& clip_bounds) {
+  if (!hdc_)
     return;  // Nothing to do.
-  config_dirty_ = false;
 
   // Transform.
-  LoadTransformToDC(hdc_, transform_);
-  LoadClippingRegionToDC(hdc_, clip_region_, transform_);
+  LoadTransformToDC(hdc_, transform);
+  LoadClippingRegionToDC(hdc_, clip_bounds, transform);
 }
 
 static void DeleteHBitmapCallback(void* addr, void* context) {
   // If context is not NULL then it's a valid HBITMAP to delete.
   // Otherwise we just unmap the pixel memory.
   if (context)
     DeleteObject(static_cast<HBITMAP>(context));
   else
     UnmapViewOfFile(addr);
 }
@@ skipping 69 matching lines @@
 }
 
 // The device will own the HBITMAP, which corresponds to also owning the pixel
 // data. Therefore, we do not transfer ownership to the SkBitmapDevice's bitmap.
 BitmapPlatformDevice::BitmapPlatformDevice(
     HBITMAP hbitmap,
     const SkBitmap& bitmap)
     : SkBitmapDevice(bitmap),
       hbitmap_(hbitmap),
       old_hbitmap_(NULL),
-      hdc_(NULL),
-      config_dirty_(true),  // Want to load the config next time.
-      transform_(SkMatrix::I()) {
+      hdc_(NULL) {
   // The data object is already ref'ed for us by create().
   if (hbitmap) {
     SetPlatformDevice(this, this);
-    // Initialize the clip region to the entire bitmap.
     BITMAP bitmap_data;
-    if (GetObject(hbitmap_, sizeof(BITMAP), &bitmap_data)) {
-      SkIRect rect;
-      rect.set(0, 0, bitmap_data.bmWidth, bitmap_data.bmHeight);
-      clip_region_ = SkRegion(rect);
-    }
+    GetObject(hbitmap_, sizeof(BITMAP), &bitmap_data);
   }
 }
 
 BitmapPlatformDevice::~BitmapPlatformDevice() {
   if (hdc_)
     ReleaseBitmapDC();
 }
 
-HDC BitmapPlatformDevice::BeginPlatformPaint() {
-  return GetBitmapDC();
+HDC BitmapPlatformDevice::BeginPlatformPaint(const SkMatrix& transform,
+                                             const SkIRect& clip_bounds) {
+  return GetBitmapDC(transform, clip_bounds);
 }
 
-void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
-                                         const SkRegion& region,
-                                         const SkClipStack&) {
-  SetMatrixClip(transform, region);
-}
-
-void BitmapPlatformDevice::DrawToHDC(HDC dc, int x, int y,
-                                     const RECT* src_rect) {
+void BitmapPlatformDevice::DrawToHDC(HDC source_dc, HDC destination_dc,
+                                     int x, int y,
+                                     const RECT* src_rect,
+                                     const SkMatrix& transform) {
   bool created_dc = !IsBitmapDCCreated();
-  HDC source_dc = BeginPlatformPaint();
 
   RECT temp_rect;
   if (!src_rect) {
     temp_rect.left = 0;
     temp_rect.right = width();
     temp_rect.top = 0;
     temp_rect.bottom = height();
     src_rect = &temp_rect;
   }
 
   int copy_width = src_rect->right - src_rect->left;
   int copy_height = src_rect->bottom - src_rect->top;
 
   // We need to reset the translation for our bitmap or (0,0) won't be in the
   // upper left anymore
   SkMatrix identity;
   identity.reset();
 
   LoadTransformToDC(source_dc, identity);
   if (isOpaque()) {
-    BitBlt(dc,
+    BitBlt(destination_dc,
            x,
            y,
            copy_width,
            copy_height,
            source_dc,
            src_rect->left,
            src_rect->top,
            SRCCOPY);
   } else {
     SkASSERT(copy_width != 0 && copy_height != 0);
     BLENDFUNCTION blend_function = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
-    GdiAlphaBlend(dc,
+    GdiAlphaBlend(destination_dc,
                   x,
                   y,
                   copy_width,
                   copy_height,
                   source_dc,
                   src_rect->left,
                   src_rect->top,
                   copy_width,
                   copy_height,
                   blend_function);
   }
-  LoadTransformToDC(source_dc, transform_);
+  LoadTransformToDC(source_dc, transform);
 
   if (created_dc)
     ReleaseBitmapDC();
 }
 
 const SkBitmap& BitmapPlatformDevice::onAccessBitmap() {
   // FIXME(brettw) OPTIMIZATION: We should only flush if we know a GDI
   // operation has occurred on our DC.
   if (IsBitmapDCCreated())
     GdiFlush();
@@ skipping 14 matching lines @@
                                int height,
                                bool is_opaque,
                                HANDLE shared_section,
                                OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(width, height, is_opaque, shared_section));
   return CreateCanvas(dev, failureType);
 }
 
 }  // namespace skia