Retract GrRenderTarget a bit within 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 722 matching lines @@
 
     if (maxTileTotalTileSize > 2 * smallTotalTileSize) {
         return kBmpSmallTileSize;
     } else {
         return maxTileSize;
     }
 }
 
 // Given a bitmap, an optional src rect, and a context with a clip and matrix determine what
 // pixels from the bitmap are necessary.
-static void determine_clipped_src_rect(const GrRenderTarget* rt,
+static void determine_clipped_src_rect(int width, int height,
                                        const GrClip& clip,
                                        const SkMatrix& viewMatrix,
                                        const SkISize& imageSize,
                                        const SkRect* srcRectPtr,
                                        SkIRect* clippedSrcIRect) {
-    clip.getConservativeBounds(rt->width(), rt->height(), clippedSrcIRect, nullptr);
+    clip.getConservativeBounds(width, height, clippedSrcIRect, nullptr);
     SkMatrix inv;
     if (!viewMatrix.invert(&inv)) {
         clippedSrcIRect->setEmpty();
         return;
     }
     SkRect clippedSrcRect = SkRect::Make(*clippedSrcIRect);
     inv.mapRect(&clippedSrcRect);
     if (srcRectPtr) {
         // we've setup src space 0,0 to map to the top left of the src rect.
         clippedSrcRect.offset(srcRectPtr->fLeft, srcRectPtr->fTop);
@@ skipping 12 matching lines @@
 bool SkGpuDevice::shouldTileImageID(uint32_t imageID, const SkIRect& imageRect,
                                     const SkMatrix& viewMatrix,
                                     const GrTextureParams& params,
                                     const SkRect* srcRectPtr,
                                     int maxTileSize,
                                     int* tileSize,
                                     SkIRect* clippedSubset) const {
     ASSERT_SINGLE_OWNER
     // if it's larger than the max tile size, then we have no choice but tiling.
     if (imageRect.width() > maxTileSize || imageRect.height() > maxTileSize) {
-        determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, imageRect.size(),
+        determine_clipped_src_rect(fDrawContext->width(), fDrawContext->height(),
+                                   fClip, viewMatrix, imageRect.size(),
                                    srcRectPtr, clippedSubset);
         *tileSize = determine_tile_size(*clippedSubset, maxTileSize);
         return true;
     }
 
     // If the image would only produce 4 tiles of the smaller size, don't bother tiling it.
     const size_t area = imageRect.width() * imageRect.height();
     if (area < 4 * kBmpSmallTileSize * kBmpSmallTileSize) {
         return false;
     }
 
     // At this point we know we could do the draw by uploading the entire bitmap
     // as a texture. However, if the texture would be large compared to the
     // cache size and we don't require most of it for this draw then tile to
     // reduce the amount of upload and cache spill.
 
     // assumption here is that sw bitmap size is a good proxy for its size as
     // a texture
     size_t bmpSize = area * sizeof(SkPMColor);  // assume 32bit pixels
     size_t cacheSize;
     fContext->getResourceCacheLimits(nullptr, &cacheSize);
     if (bmpSize < cacheSize / 2) {
         return false;
     }
 
     // Figure out how much of the src we will need based on the src rect and clipping. Reject if
     // tiling memory savings would be < 50%.
-    determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, imageRect.size(), srcRectPtr,
+    determine_clipped_src_rect(fDrawContext->width(), fDrawContext->height(),
+                               fClip, viewMatrix, imageRect.size(), srcRectPtr,
                                clippedSubset);
     *tileSize = kBmpSmallTileSize; // already know whole bitmap fits in one max sized tile.
     size_t usedTileBytes = get_tile_count(*clippedSubset, kBmpSmallTileSize) *
                            kBmpSmallTileSize * kBmpSmallTileSize;
 
     return usedTileBytes < 2 * bmpSize;
 }
 
 bool SkGpuDevice::shouldTileBitmap(const SkBitmap& bitmap,
                                    const SkMatrix& viewMatrix,
@@ skipping 941 matching lines @@
                                     "---- failed to create gpu device texture [%d %d]\n",
                                     cinfo.fInfo.width(), cinfo.fInfo.height());
         return nullptr;
     }
 }
 
 sk_sp<SkSurface> SkGpuDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     ASSERT_SINGLE_OWNER
     // TODO: Change the signature of newSurface to take a budgeted parameter.
     static const SkBudgeted kBudgeted = SkBudgeted::kNo;
-    return SkSurface::MakeRenderTarget(fContext, kBudgeted, info, fRenderTarget->desc().fSampleCnt,
+    return SkSurface::MakeRenderTarget(fContext, kBudgeted, info, fDrawContext->desc().fSampleCnt,
                                        &props);
 }
 
 bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* mainPicture,
                                            const SkMatrix* matrix, const SkPaint* paint) {
     ASSERT_SINGLE_OWNER
 #ifndef SK_IGNORE_GPU_LAYER_HOISTING
     // todo: should handle this natively
     if (paint ||
         (kRGBA_8888_SkColorType != mainCanvas->imageInfo().colorType() &&
@@ skipping 24 matching lines @@
     SkRect clipBounds = SkRect::Make(iBounds);
 
     SkMatrix initialMatrix = mainCanvas->getTotalMatrix();
 
     GrLayerHoister::Begin(fContext);
 
     GrLayerHoister::FindLayersToAtlas(fContext, mainPicture,
                                       initialMatrix,
                                       clipBounds,
                                       &atlasedNeedRendering, &atlasedRecycled,
-                                      fRenderTarget->numColorSamples());
+                                      fDrawContext->numColorSamples());
 
     GrLayerHoister::DrawLayersToAtlas(fContext, atlasedNeedRendering);
 
     SkTDArray<GrHoistedLayer> needRendering, recycled;
 
     SkAutoCanvasMatrixPaint acmp(mainCanvas, matrix, paint, mainPicture->cullRect());
 
     GrLayerHoister::FindLayersToHoist(fContext, mainPicture,
                                       initialMatrix,
                                       clipBounds,
                                       &needRendering, &recycled,
-                                      fRenderTarget->numColorSamples());
+                                      fDrawContext->numColorSamples());
 
     GrLayerHoister::DrawLayers(fContext, needRendering);
 
     // Render the entire picture using new layers
     GrRecordReplaceDraw(mainPicture, mainCanvas, fContext->getLayerCache(),
                         initialMatrix, nullptr);
 
     GrLayerHoister::UnlockLayers(fContext, needRendering);
     GrLayerHoister::UnlockLayers(fContext, recycled);
     GrLayerHoister::UnlockLayers(fContext, atlasedNeedRendering);
     GrLayerHoister::UnlockLayers(fContext, atlasedRecycled);
     GrLayerHoister::End(fContext);
 
     return true;
 #else
     return false;
 #endif
 }
 
 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