Allow user-specified clip region for SkiaBitLocker

skia/ext/skia_utils_mac.mm

 // 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/skia_utils_mac.h"
 
 #import <AppKit/AppKit.h>
 
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
@@ skipping 249 matching lines @@
 }
 
 NSImage* SkBitmapToNSImage(const SkBitmap& skiaBitmap) {
   base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
       CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
   return SkBitmapToNSImageWithColorSpace(skiaBitmap, colorSpace.get());
 }
 
 SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas)
     : canvas_(canvas),
-      cgContext_(0) {
+      userClipRectSpecified_(false),
+      cgContext_(0),
+      useDeviceBits_(false),
+      bitmapIsDummy_(false) {
+}
+
+SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas, const SkIRect& userClipRect)
+    : canvas_(canvas),
+      userClipRectSpecified_(true),
+      cgContext_(0),
+      useDeviceBits_(false),
+      bitmapIsDummy_(false) {
+  canvas_->save();
+  canvas_->clipRect(SkRect::MakeFromIRect(userClipRect));
 }
 
 SkiaBitLocker::~SkiaBitLocker() {
   releaseIfNeeded();
+  if (userClipRectSpecified_)
+    canvas_->restore();
+}
+
+SkIRect SkiaBitLocker::computeDirtyRect() {
+  // If the user specified a clip region, assume that it was tight and that the
+  // dirty rect is approximately the whole bitmap.
+  if (userClipRectSpecified_)
+    return SkIRect::MakeWH(bitmap_.width(), bitmap_.height());
+
+  // Find the bits that were drawn to.
+  SkAutoLockPixels lockedPixels(bitmap_);
+  const uint32_t* pixelBase
+      = reinterpret_cast<uint32_t*>(bitmap_.getPixels());
+  int rowPixels = bitmap_.rowBytesAsPixels();
+  int width = bitmap_.width();
+  int height = bitmap_.height();
+  SkIRect bounds;
+  bounds.fTop = 0;
+  int x;
+  int y = -1;
+  const uint32_t* pixels = pixelBase;
+  while (++y < height) {
+    for (x = 0; x < width; ++x) {
+      if (pixels[x]) {
+        bounds.fTop = y;
+        goto foundTop;
+      }
+    }
+    pixels += rowPixels;
+  }
+foundTop:
+  bounds.fBottom = height;
+  y = height;
+  pixels = pixelBase + rowPixels * (y - 1);
+  while (--y > bounds.fTop) {
+    for (x = 0; x < width; ++x) {
+      if (pixels[x]) {
+        bounds.fBottom = y + 1;
+        goto foundBottom;
+      }
+    }
+    pixels -= rowPixels;
+  }
+foundBottom:
+  bounds.fLeft = 0;
+  x = -1;
+  while (++x < width) {
+    pixels = pixelBase + rowPixels * bounds.fTop;
+    for (y = bounds.fTop; y < bounds.fBottom; ++y) {
+      if (pixels[x]) {
+        bounds.fLeft = x;
+        goto foundLeft;
+      }
+      pixels += rowPixels;
+    }
+  }
+foundLeft:
+  bounds.fRight = width;
+  x = width;
+  while (--x > bounds.fLeft) {
+    pixels = pixelBase + rowPixels * bounds.fTop;
+    for (y = bounds.fTop; y < bounds.fBottom; ++y) {
+      if (pixels[x]) {
+        bounds.fRight = x + 1;
+        goto foundRight;
+      }
+      pixels += rowPixels;
+    }
+  }
+foundRight:
+  return bounds;
 }
 
 // This must be called to balance calls to cgContext
 void SkiaBitLocker::releaseIfNeeded() {
   if (!cgContext_)
     return;
   if (useDeviceBits_) {
     bitmap_.unlockPixels();
-  } else {
+  } else if (!bitmapIsDummy_) {
     // Find the bits that were drawn to.
-    SkAutoLockPixels lockedPixels(bitmap_);
-    const uint32_t* pixelBase
-        = reinterpret_cast<uint32_t*>(bitmap_.getPixels());
-    int rowPixels = bitmap_.rowBytesAsPixels();
-    int width = bitmap_.width();
-    int height = bitmap_.height();
-    SkIRect bounds;
-    bounds.fTop = 0;
-    int x;
-    int y = -1;
-    const uint32_t* pixels = pixelBase;
-    while (++y < height) {
-      for (x = 0; x < width; ++x) {
-        if (pixels[x]) {
-          bounds.fTop = y;
-          goto foundTop;
-        }
-      }
-      pixels += rowPixels;
-    }
-foundTop:
-    bounds.fBottom = height;
-    y = height;
-    pixels = pixelBase + rowPixels * (y - 1);
-    while (--y > bounds.fTop) {
-      for (x = 0; x < width; ++x) {
-        if (pixels[x]) {
-          bounds.fBottom = y + 1;
-          goto foundBottom;
-        }
-      }
-      pixels -= rowPixels;
-    }
-foundBottom:
-    bounds.fLeft = 0;
-    x = -1;
-    while (++x < width) {
-      pixels = pixelBase + rowPixels * bounds.fTop;
-      for (y = bounds.fTop; y < bounds.fBottom; ++y) {
-        if (pixels[x]) {
-          bounds.fLeft = x;
-          goto foundLeft;
-        }
-        pixels += rowPixels;
-      }
-    }
-foundLeft:
-    bounds.fRight = width;
-    x = width;
-    while (--x > bounds.fLeft) {
-      pixels = pixelBase + rowPixels * bounds.fTop;
-      for (y = bounds.fTop; y < bounds.fBottom; ++y) {
-        if (pixels[x]) {
-          bounds.fRight = x + 1;
-          goto foundRight;
-        }
-        pixels += rowPixels;
-      }
-    }
-foundRight:
+    SkIRect bounds = computeDirtyRect();
     SkBitmap subset;
     if (!bitmap_.extractSubset(&subset, bounds)) {
         return;
     }
     // Neutralize the global matrix by concatenating the inverse. In the
     // future, Skia may provide some mechanism to set the device portion of
     // the matrix to identity without clobbering any hosting matrix (e.g., the
     // picture's matrix).
     const SkMatrix& skMatrix = canvas_->getTotalMatrix();
     SkMatrix inverse;
     if (!skMatrix.invert(&inverse))
       return;
     canvas_->save();
     canvas_->concat(inverse);
     canvas_->drawBitmap(subset, bounds.x() + bitmapOffset_.x(),
                                 bounds.y() + bitmapOffset_.y());
     canvas_->restore();
   }
   CGContextRelease(cgContext_);
   cgContext_ = 0;
+  useDeviceBits_ = false;
+  bitmapIsDummy_ = false;
 }
 
 CGContextRef SkiaBitLocker::cgContext() {
   SkIRect clip_bounds;
-  if (!canvas_->getClipDeviceBounds(&clip_bounds))
-    return 0;  // the clip is empty, nothing to draw
+  if (!canvas_->getClipDeviceBounds(&clip_bounds)) {
+    // If the clip is empty, then there is nothing to draw. The caller may
+    // attempt to draw (to-be-clipped) results, so ensure there is a dummy
+    // non-NULL CGContext to use.
+    bitmapIsDummy_ = true;
+    clip_bounds = SkIRect::MakeXYWH(0, 0, 1, 1);
+  }
 
   SkBaseDevice* device = canvas_->getTopDevice();
   DCHECK(device);
   if (!device)
     return 0;
 
   releaseIfNeeded(); // This flushes any prior bitmap use
 
   // remember the top/left, in case we need to compose this later
   bitmapOffset_.set(clip_bounds.x(), clip_bounds.y());
 
   // Now make clip_bounds be relative to the current layer/device
   clip_bounds.offset(-device->getOrigin());
 
   const SkBitmap& deviceBits = device->accessBitmap(true);
 
   // Only draw directly if we have pixels, and we're only rect-clipped.
   // If not, we allocate an offscreen and draw into that, relying on the
   // compositing step to apply skia's clip.
-  useDeviceBits_ = deviceBits.getPixels() && canvas_->isClipRect();
+  useDeviceBits_ = deviceBits.getPixels() &&
+                   canvas_->isClipRect() &&
+                   !bitmapIsDummy_;
   if (useDeviceBits_) {
-    if (!deviceBits.extractSubset(&bitmap_, clip_bounds))
+    bool result = deviceBits.extractSubset(&bitmap_, clip_bounds);
+    DCHECK(result);
+    if (!result)
       return 0;
     bitmap_.lockPixels();
   } else {
-    if (!bitmap_.allocN32Pixels(clip_bounds.width(), clip_bounds.height()))
+    bool result = bitmap_.allocN32Pixels(
+        clip_bounds.width(), clip_bounds.height());
+    DCHECK(result);
+    if (!result)
       return 0;
     bitmap_.eraseColor(0);
   }
   base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
       CGColorSpaceCreateDeviceRGB());
   cgContext_ = CGBitmapContextCreate(bitmap_.getPixels(), bitmap_.width(),
     bitmap_.height(), 8, bitmap_.rowBytes(), colorSpace, 
     kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);
+  DCHECK(cgContext_);
 
   SkMatrix matrix = canvas_->getTotalMatrix();
   matrix.postTranslate(-SkIntToScalar(bitmapOffset_.x()),
                        -SkIntToScalar(bitmapOffset_.y()));
   matrix.postScale(1, -1);
   matrix.postTranslate(0, SkIntToScalar(bitmap_.height()));
 
   CGContextConcatCTM(cgContext_, SkMatrixToCGAffineTransform(matrix));
   
   return cgContext_;
 }
 
+bool SkiaBitLocker::hasEmptyClipRegion() const {
+  return canvas_->isClipEmpty();
+}
+
 }  // namespace gfx