Allow SkGpuDevice::drawSprite to handle subset SkBitmaps

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 1124 matching lines @@
                              int left, int top, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     // drawSprite is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
     SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
     if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
         return;
     }
 
+    int offX = bitmap.pixelRefOrigin().fX;
+    int offY = bitmap.pixelRefOrigin().fY;
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite neither filters nor tiles.
     AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(), &texture);
     if (!texture) {
         return;
     }
 
     bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
 
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
     SkBitmap filteredBitmap;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
         SkIRect clipBounds = draw.fClip->getBounds().makeOffset(-left, -top);
         SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
         // This cache is transient, and is freed (along with all its contained
         // textures) when it goes out of scope.
         SkImageFilter::Context ctx(matrix, clipBounds, cache);
         if (this->filterTexture(fContext, texture, w, h, filter, ctx, &filteredBitmap,
                                 &offset)) {
             texture = (GrTexture*) filteredBitmap.getTexture();
+            offX = filteredBitmap.pixelRefOrigin().fX;
+            offY = filteredBitmap.pixelRefOrigin().fY;
             w = filteredBitmap.width();
             h = filteredBitmap.height();
             left += offset.x();
             top += offset.y();
         } else {
             return;
         }
         SkASSERT(!GrPixelConfigIsAlphaOnly(texture->config()));
         alphaOnly = false;
     }
@@ skipping 10 matching lines @@
         return;
     }
 
     fDrawContext->fillRectToRect(fClip,
                                  grPaint,
                                  SkMatrix::I(),
                                  SkRect::MakeXYWH(SkIntToScalar(left),
                                                   SkIntToScalar(top),
                                                   SkIntToScalar(w),
                                                   SkIntToScalar(h)),
-                                 SkRect::MakeXYWH(0,
-                                                  0,
-                                                  SK_Scalar1 * w / texture->width(),
-                                                  SK_Scalar1 * h / texture->height()));
+                                 SkRect::MakeXYWH(SkIntToScalar(offX) / texture->width(),
+                                                  SkIntToScalar(offY) / texture->height(),
+                                                  SkIntToScalar(w) / texture->width(),
+                                                  SkIntToScalar(h) / texture->height()));
 }
 
 void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& origDst,
                                  const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
     ASSERT_SINGLE_OWNER
     CHECK_SHOULD_DRAW(draw);
     if (bitmap.getTexture()) {
         GrBitmapTextureAdjuster adjuster(&bitmap);
         this->drawTextureProducer(&adjuster, src, &origDst, constraint, *draw.fMatrix, fClip,
@@ skipping 661 matching lines @@
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkGpuDevice::NewImageFilterCache();
 }
 
 #endif