Replace setMatrixClip() with BeginPlatformPaint() logic

skia/ext/bitmap_platform_device_cairo.cc

 // Copyright 2013 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 "skia/ext/bitmap_platform_device_cairo.h"
 #include "skia/ext/platform_canvas.h"
 
 #if defined(OS_OPENBSD)
 #include <cairo.h>
@@ skipping 42 matching lines @@
   cairo_matrix_init(&cairo_matrix,
                     SkScalarToFloat(matrix.getScaleX()),
                     SkScalarToFloat(matrix.getSkewY()),
                     SkScalarToFloat(matrix.getSkewX()),
                     SkScalarToFloat(matrix.getScaleY()),
                     SkScalarToFloat(matrix.getTranslateX()),
                     SkScalarToFloat(matrix.getTranslateY()));
   cairo_set_matrix(context, &cairo_matrix);
 }
 
-void LoadClipToContext(cairo_t* context, const SkRegion& clip) {
+void LoadClipToContext(cairo_t* context, const SkIRect& clip_bounds) {
   cairo_reset_clip(context);
 
-  // TODO(brettw) support non-rect clips.
-  SkIRect bounding = clip.getBounds();
-  cairo_rectangle(context, bounding.fLeft, bounding.fTop,
-                  bounding.fRight - bounding.fLeft,
-                  bounding.fBottom - bounding.fTop);
+  cairo_rectangle(context, clip_bounds.fLeft, clip_bounds.fTop,
+                  clip_bounds.width(), clip_bounds.height());
   cairo_clip(context);
 }
 
 }  // namespace
 
-void BitmapPlatformDevice::SetMatrixClip(
-    const SkMatrix& transform,
-    const SkRegion& region) {
-  transform_ = transform;
-  clip_region_ = region;
-  config_dirty_ = true;
-}
+void BitmapPlatformDevice::LoadConfig(const SkMatrix& transform,
+                                      const SkIRect& clip_bounds) {
+  if (!cairo_)
+    return;  // Nothing to do.
 
-void BitmapPlatformDevice::LoadConfig() {
-  if (!config_dirty_ || !cairo_)
-    return;  // Nothing to do.
-  config_dirty_ = false;
-
-  // Load the identity matrix since this is what our clip is relative to.
-  cairo_matrix_t cairo_matrix;
-  cairo_matrix_init_identity(&cairo_matrix);
-  cairo_set_matrix(cairo_, &cairo_matrix);
-
-  LoadClipToContext(cairo_, clip_region_);
-  LoadMatrixToContext(cairo_, transform_);
+  LoadClipToContext(cairo_, clip_bounds);
+  LoadMatrixToContext(cairo_, 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(int width, int height,
                                                    bool is_opaque,
                                                    cairo_surface_t* surface) {
   if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
@@ skipping 39 matching lines @@
       cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width));
 
   return Create(width, height, is_opaque, surface);
 }
 
 // Ownership of the cairo object is transferred.
 BitmapPlatformDevice::BitmapPlatformDevice(
     const SkBitmap& bitmap,
     cairo_t* cairo)
     : SkBitmapDevice(bitmap),
-      cairo_(cairo),
-      config_dirty_(true),
-      transform_(SkMatrix::I()) {  // Want to load the config next time.
+      cairo_(cairo) {
   SetPlatformDevice(this, this);
 }
 
 BitmapPlatformDevice::~BitmapPlatformDevice() {
   cairo_destroy(cairo_);
 }
 
 SkBaseDevice* BitmapPlatformDevice::onCreateDevice(const CreateInfo& info,
                                                    const SkPaint*) {
   SkASSERT(info.fInfo.colorType() == kN32_SkColorType);
   return BitmapPlatformDevice::Create(info.fInfo.width(), info.fInfo.height(),
                                       info.fInfo.isOpaque());
 }
 
-cairo_t* BitmapPlatformDevice::BeginPlatformPaint() {
-  LoadConfig();
+cairo_t* BitmapPlatformDevice::BeginPlatformPaint(
+      const SkMatrix& transform,
+      const SkIRect& clip_bounds) {
+  LoadConfig(transform, clip_bounds);
   cairo_surface_t* surface = cairo_get_target(cairo_);
   // Tell cairo to flush anything it has pending.
   cairo_surface_flush(surface);
   // Tell Cairo that we (probably) modified (actually, will modify) its pixel
   // buffer directly.
   cairo_surface_mark_dirty(surface);
   return cairo_;
 }
 
-void BitmapPlatformDevice::setMatrixClip(const SkMatrix& transform,
-                                         const SkRegion& region,
-                                         const SkClipStack&) {
-  SetMatrixClip(transform, region);
-}
-
 // PlatformCanvas impl
 
 SkCanvas* CreatePlatformCanvas(int width, int height, bool is_opaque,
                                uint8_t* data, OnFailureType failureType) {
   sk_sp<SkBaseDevice> dev(
       BitmapPlatformDevice::Create(width, height, is_opaque, data));
   return CreateCanvas(dev, failureType);
 }
 
 }  // namespace skia