Add makeSpecial calls to SkGpuDevice

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 1381 matching lines @@
                                    maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
             this->drawTiledBitmap(bitmap, viewMatrix, *src, clippedSrcRect, params, paint,
                                   constraint, tileSize, doBicubic);
             return;
         }
     }
     GrBitmapTextureMaker maker(fContext, bitmap);
     this->drawTextureProducer(&maker, src, dst, constraint, *draw.fMatrix, fClip, paint);
 }
 
-sk_sp<SkSpecialImage> SkGpuDevice::asSpecial() {
+sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(const SkBitmap& bitmap) {
+    SkASSERT(!bitmap.getTexture());
+
+    SkAutoLockPixels alp(bitmap, true);
+    if (!bitmap.readyToDraw()) {
+        return nullptr;
+    }
+
+    GrTexture* texture;
+    AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(),   
+                          SkSourceGammaTreatment::kRespect, &texture);
+    if (!texture) {
+        return nullptr;
+    }
+
+    return SkSpecialImage::MakeFromGpu(bitmap.bounds(),
+                                       bitmap.getGenerationID(),
+                                       sk_ref_sp(texture), 
+                                       &this->surfaceProps());
+}
+
+sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(SkImage* image) {
+    SkPixmap pm;
+    if (image->isTextureBacked()) {
+        GrTexture* texture = as_IB(image)->peekTexture();
+
+        return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(image->width(), image->height()),
+                                           image->uniqueID(),
+                                           sk_ref_sp(texture), 
+                                           &this->surfaceProps());
+    } else if (image->peekPixels(&pm)) {
+        SkBitmap bm;
+
+        bm.installPixels(pm);
+        return this->makeSpecial(bm);
+    } else {
+        return nullptr;
+    }
+}
+
+sk_sp<SkSpecialImage> SkGpuDevice::snapSpecial() {
     sk_sp<GrTexture> texture(this->accessDrawContext()->asTexture());
     if (!texture) {
         return nullptr;
     }
 
     const SkImageInfo ii = this->imageInfo();
     const SkIRect srcRect = SkIRect::MakeWH(ii.width(), ii.height());
 
     return SkSpecialImage::MakeFromGpu(srcRect,
                                        kNeedNewImageUniqueID_SpecialImage,
                                        std::move(texture), 
                                        &this->surfaceProps());
 }
 
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
                              int left, int top, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext);
 
     // drawDevice is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
     SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
-    sk_sp<SkSpecialImage> srcImg(dev->asSpecial());
+    sk_sp<SkSpecialImage> srcImg(dev->snapSpecial());
     if (!srcImg) {
         return;
     }
 
     this->drawSpecial(draw, srcImg.get(), left, top, paint);
 }
 
 void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
@@ skipping 410 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif