Remove SkDevice, obsolete constructor

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 <stdint.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
-#include "skia/ext/bitmap_platform_device_mac.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/utils/mac/SkCGUtils.h"
 
 namespace {
 
 // Draws an NSImage or an NSImageRep with a given size into a SkBitmap.
 SkBitmap NSImageOrNSImageRepToSkBitmapWithColorSpace(
     NSImage* image,
     NSImageRep* image_rep,
     NSSize size,
@@ skipping 158 matching lines @@
                                 count:4];
 }
 
 SkBitmap CGImageToSkBitmap(CGImageRef image) {
   if (!image)
     return SkBitmap();
 
   int width = CGImageGetWidth(image);
   int height = CGImageGetHeight(image);
 
-  sk_sp<skia::BitmapPlatformDevice> device(
-      skia::BitmapPlatformDevice::Create(NULL, width, height, false));
-
-  sk_sp<SkCanvas> canvas(skia::CreateCanvas(device, RETURN_NULL_ON_FAILURE));
+  sk_sp<SkCanvas> canvas(skia::CreatePlatformCanvas(
+      nullptr, width, height, false, RETURN_NULL_ON_FAILURE));
   ScopedPlatformPaint p(canvas.get());
   CGContextRef context = p.GetPlatformSurface();
 
   // We need to invert the y-axis of the canvas so that Core Graphics drawing
   // happens right-side up. Skia has an upper-left origin and CG has a lower-
   // left one.
   CGContextScaleCTM(context, 1.0, -1.0);
   CGContextTranslateCTM(context, 0, -height);
 
   // We want to copy transparent pixels from |image|, instead of blending it
   // onto uninitialized pixels.
   CGContextSetBlendMode(context, kCGBlendModeCopy);
 
   CGRect rect = CGRectMake(0, 0, width, height);
   CGContextDrawImage(context, rect, image);
 
-  // Because |device| will be cleaned up and will take its pixels with it, we
-  // copy it to the stack and return it.
-  SkBitmap bitmap = device->accessBitmap(false);
-
-  return bitmap;
+  return skia::ReadPixels(canvas.get());
 }
 
 SkBitmap NSImageToSkBitmapWithColorSpace(
     NSImage* image, bool is_opaque, CGColorSpaceRef color_space) {
   return NSImageOrNSImageRepToSkBitmapWithColorSpace(
       image, nil, [image size], is_opaque, color_space);
 }
 
 SkBitmap NSImageRepToSkBitmapWithColorSpace(NSImageRep* image_rep,
                                             NSSize size,
@@ skipping 33 matching lines @@
   [image setSize:NSMakeSize(skiaBitmap.width(), skiaBitmap.height())];
   return [image.release() autorelease];
 }
 
 NSImage* SkBitmapToNSImage(const SkBitmap& skiaBitmap) {
   base::ScopedCFTypeRef<CGColorSpaceRef> colorSpace(
       CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
   return SkBitmapToNSImageWithColorSpace(skiaBitmap, colorSpace.get());
 }
 
-SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas)
-    : canvas_(canvas),
-      userClipRectSpecified_(false),
-      cgContext_(0),
-      bitmapScaleFactor_(1),
-      useDeviceBits_(false),
-      bitmapIsDummy_(false) {
-}
-
 SkiaBitLocker::SkiaBitLocker(SkCanvas* canvas,
                              const SkIRect& userClipRect,
                              SkScalar bitmapScaleFactor)
     : canvas_(canvas),
-      userClipRectSpecified_(true),
       cgContext_(0),
       bitmapScaleFactor_(bitmapScaleFactor),
       useDeviceBits_(false),
       bitmapIsDummy_(false) {
   canvas_->save();
   canvas_->clipRect(SkRect::MakeFromIRect(userClipRect));
 }
 
 SkiaBitLocker::~SkiaBitLocker() {
   releaseIfNeeded();
-  if (userClipRectSpecified_)
-    canvas_->restore();
+  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(offscreen_.width(), offscreen_.height());
-
-  // Find the bits that were drawn to.
-  SkAutoLockPixels lockedPixels(offscreen_);
-  const uint32_t* pixelBase
-      = reinterpret_cast<uint32_t*>(offscreen_.getPixels());
-  int rowPixels = offscreen_.rowBytesAsPixels();
-  int width = offscreen_.width();
-  int height = offscreen_.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;
+  return SkIRect::MakeWH(offscreen_.width(), offscreen_.height());
 }
 
 // This must be called to balance calls to cgContext
 void SkiaBitLocker::releaseIfNeeded() {
   if (!cgContext_)
     return;
   if (!useDeviceBits_ && !bitmapIsDummy_) {
     // Find the bits that were drawn to.
     SkIRect bounds = computeDirtyRect();
     SkBitmap subset;
@@ skipping 18 matching lines @@
 CGContextRef SkiaBitLocker::cgContext() {
   SkIRect clip_bounds;
   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());
+  if (!bitmapIsDummy_) {
+    canvas_->temporary_internal_describeTopLayer(nullptr, &clip_bounds);
+  }
 
   SkPixmap devicePixels;
   skia::GetWritablePixels(canvas_, &devicePixels);
 
   // 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_ = devicePixels.addr() &&
                    canvas_->isClipRect() &&
                    !bitmapIsDummy_;
@@ skipping 35 matching lines @@
   CGContextConcatCTM(cgContext_, SkMatrixToCGAffineTransform(matrix));
   
   return cgContext_;
 }
 
 bool SkiaBitLocker::hasEmptyClipRegion() const {
   return canvas_->isClipEmpty();
 }
 
 }  // namespace skia