Replace setMatrixClip() with BeginPlatformPaint() logic

skia/ext/bitmap_platform_device_mac.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 "skia/ext/bitmap_platform_device_mac.h"
 
 #import <ApplicationServices/ApplicationServices.h>
 #include <stddef.h>
 #include <time.h>
 
 #include "base/mac/mac_util.h"
 #include "base/memory/ref_counted.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/skia_utils_mac.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPath.h"
-#include "third_party/skia/include/core/SkRegion.h"
+#include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkTypes.h"
 
 namespace skia {
 
 namespace {
 
 // Returns true if it is unsafe to attempt to allocate an offscreen buffer
 // given these dimensions.
 bool RasterDeviceTooBigToAllocate(int width, int height) {
 
@@ skipping 41 matching lines @@
 }
 
 }  // namespace
 
 void BitmapPlatformDevice::ReleaseBitmapContext() {
   SkASSERT(bitmap_context_);
   CGContextRelease(bitmap_context_);
   bitmap_context_ = NULL;
 }
 
-void BitmapPlatformDevice::SetMatrixClip(
-    const SkMatrix& transform,
-    const SkRegion& region) {
-  transform_ = transform;
-  clip_region_ = region;
-  config_dirty_ = true;
-}
-
 // Loads the specified Skia transform into the device context
 static void LoadTransformToCGContext(CGContextRef context,
                                      const SkMatrix& matrix) {
   // CoreGraphics can concatenate transforms, but not reset the current one.
   // So in order to get the required behavior here, we need to first make
   // the current transformation matrix identity and only then load the new one.
 
   // Reset matrix to identity.
   CGAffineTransform orig_cg_matrix = CGContextGetCTM(context);
   CGAffineTransform orig_cg_matrix_inv =
@@ skipping 13 matching lines @@
   SkScalar ty = -matrix.getTranslateY();  // y axis is flipped.
   transformed_matrix.setTranslateY(ty + (SkScalar)height);
 
   CGAffineTransform cg_matrix =
       skia::SkMatrixToCGAffineTransform(transformed_matrix);
 
   // Load final transform into context.
   CGContextConcatCTM(context, cg_matrix);
 }
 
-// Loads a SkRegion into the CG context.
 static void LoadClippingRegionToCGContext(CGContextRef context,
-                                          const SkRegion& region,
+                                          const SkIRect& clip_bounds,
                                           const SkMatrix& transformation) {
-  if (region.isEmpty()) {
-    // region can be empty, in which case everything will be clipped.
-    SkRect rect;
-    rect.setEmpty();
-    CGContextClipToRect(context, skia::SkRectToCGRect(rect));
-  } else if (region.isRect()) {
-    // CoreGraphics applies the current transform to clip rects, which is
-    // unwanted. Inverse-transform the rect before sending it to CG. This only
-    // works for translations and scaling, but not for rotations (but the
-    // viewport is never rotated anyway).
-    SkMatrix t;
-    bool did_invert = transformation.invert(&t);
-    if (!did_invert)
-      t.reset();
-    // Do the transformation.
-    SkRect rect;
-    rect.set(region.getBounds());
-    t.mapRect(&rect);
-    SkIRect irect;
-    rect.round(&irect);
-    CGContextClipToRect(context, skia::SkIRectToCGRect(irect));
-  } else {
-    // It is complex.
-    SkPath path;
-    region.getBoundaryPath(&path);
-    // Clip. Note that windows clipping regions are not affected by the
-    // transform so apply it manually.
-    path.transform(transformation);
-    // TODO(playmobil): Implement.
-    SkASSERT(false);
-    // LoadPathToDC(context, path);
-    // hrgn = PathToRegion(context);
-  }
+  // CoreGraphics applies the current transform to clip rects, which is
+  // unwanted. Inverse-transform the rect before sending it to CG. This only
+  // works for translations and scaling, but not for rotations (but the
+  // viewport is never rotated anyway).
+  SkMatrix t;
+  bool did_invert = transformation.invert(&t);
+  if (!did_invert)
+    t.reset();
+
+  SkRect rect = SkRect::Make(clip_bounds);
+  t.mapRect(&rect);
+  SkIRect irect;
+  rect.round(&irect);
+  CGContextClipToRect(context, skia::SkIRectToCGRect(irect));
 }
 
-void BitmapPlatformDevice::LoadConfig() {
-  if (!config_dirty_ || !bitmap_context_)
+void BitmapPlatformDevice::LoadConfig(const SkMatrix& transform,
+                                      const SkIRect& clip_bounds) {
+  if (!bitmap_context_)
     return;  // Nothing to do.
-  config_dirty_ = false;
 
   // We must restore and then save the state of the graphics context since the
   // calls to Load the clipping region to the context are strictly cummulative,
   // i.e., you can't replace a clip rect, other than with a save/restore.
   // But this implies that no other changes to the state are done elsewhere.
   // If we ever get to need to change this, then we must replace the clip rect
   // calls in LoadClippingRegionToCGContext() with an image mask instead.
   CGContextRestoreGState(bitmap_context_);
   CGContextSaveGState(bitmap_context_);
-  LoadTransformToCGContext(bitmap_context_, transform_);
-  LoadClippingRegionToCGContext(bitmap_context_, clip_region_, transform_);
+  LoadTransformToCGContext(bitmap_context_, transform);
+  LoadClippingRegionToCGContext(bitmap_context_, clip_bounds, transform);
 }
 
 
 // We use this static factory function instead of the regular constructor so
 // that we can create the pixel data before calling the constructor. This is
 // required so that we can call the base class' constructor with the pixel
 // data.
 BitmapPlatformDevice* BitmapPlatformDevice::Create(CGContextRef context,
                                                    int width,
                                                    int height,
@@ skipping 60 matching lines @@
     CGContextRelease(context);
 
   return rv;
 }
 
 // The device will own the bitmap, which corresponds to also owning the pixel
 // data. Therefore, we do not transfer ownership to the SkBitmapDevice's bitmap.
 BitmapPlatformDevice::BitmapPlatformDevice(
     CGContextRef context, const SkBitmap& bitmap)
     : SkBitmapDevice(bitmap),
-      bitmap_context_(context),
-      config_dirty_(true),  // Want to load the config next time.
-      transform_(SkMatrix::I()) {
+      bitmap_context_(context) {
   SetPlatformDevice(this, this);
   SkASSERT(bitmap_context_);
   // Initialize the clip region to the entire bitmap.
 
   SkIRect rect;
   rect.set(0, 0,
            CGBitmapContextGetWidth(bitmap_context_),
            CGBitmapContextGetHeight(bitmap_context_));
-  clip_region_ = SkRegion(rect);
   CGContextRetain(bitmap_context_);
   // We must save the state once so that we can use the restore/save trick
   // in LoadConfig().
   CGContextSaveGState(bitmap_context_);
 }
 
 BitmapPlatformDevice::~BitmapPlatformDevice() {
   if (bitmap_context_)
     CGContextRelease(bitmap_context_);
 }
 
-CGContextRef BitmapPlatformDevice::GetBitmapContext() {
-  LoadConfig();
+CGContextRef BitmapPlatformDevice::GetBitmapContext(const SkMatrix& transform,
+                                                    const SkIRect& clip_bounds) {
+  LoadConfig(transform, clip_bounds);
   return bitmap_context_;
 }
 
-void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
-                                         const SkRegion& region,
-                                         const SkClipStack&) {
-  SetMatrixClip(transform, region);
-}
-
 SkBaseDevice* BitmapPlatformDevice::onCreateDevice(const CreateInfo& cinfo,
                                                    const SkPaint*) {
   const SkImageInfo& info = cinfo.fInfo;
   const bool do_clear = !info.isOpaque();
   SkASSERT(info.colorType() == kN32_SkColorType);
   return Create(NULL, info.width(), info.height(), info.isOpaque(), do_clear);
 }
 
 // PlatformCanvas impl
 
 SkCanvas* CreatePlatformCanvas(CGContextRef ctx, int width, int height,
                                bool is_opaque, OnFailureType failureType) {
   const bool do_clear = false;
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(ctx, width, height, is_opaque, do_clear));
   return CreateCanvas(dev, failureType);
 }
 
 SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
                                uint8_t* data, OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::CreateWithData(data, width, height, is_opaque));
   return CreateCanvas(dev, failureType);
 }
 
 }  // namespace skia