Add bleed GM variants for bmp backed by an oversized texture

gm/bleed.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextOptions.h"
+#include "SkGr.h"
 #endif
 
 static void draw_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkImage*,
                              const SkRect& src, const SkRect& dst,
                              const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     canvas->drawBitmapRect(bitmap, src, dst, paint, constraint);
 }
 
 static void draw_image_rect(SkCanvas* canvas, const SkBitmap&, const SkImage* image,
                             const SkRect& src, const SkRect& dst,
                             const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     canvas->drawImageRect(image, src, dst, paint, constraint);
 }
 

[robertphillips, 2015/11/02 19:37:59]

// Upload the tight-fitting sw-backed bitmap to a loose-fitting gpu-backed
texture before drawing 

?

[bsalomon, 2015/11/02 20:17:30]

Done.

+static void draw_texture_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkImage*,
+                                     const SkRect& src, const SkRect& dst,
+                                     const SkPaint* paint,
+                                     SkCanvas::SrcRectConstraint constraint) {
+    GrContext* context = canvas->getGrContext();
+    if (!context) {
+        // For non-GPU canvases fallback to drawing the bitmap directly.
+        canvas->drawBitmapRect(bitmap, src, dst, paint, constraint);
+        return;
+    }

[robertphillips, 2015/11/02 19:37:59]

mv textureBmp to right before the GrWrapTextureInBitmap call ?

[bsalomon, 2015/11/02 20:17:30]

Done.

+    SkBitmap textureBmp;
+    GrSurfaceDesc desc;
+    desc.fConfig = kAlpha_8_SkColorType == bitmap.colorType() ? kAlpha_8_GrPixelConfig :
+                                                                kSkia8888_GrPixelConfig;
+    // Add some padding to the right and beneath the bitmap contents to exercise the case where
+    // the texture is larger than the bitmap.
+    desc.fWidth = bitmap.width() + 16;

[robertphillips, 2015/11/02 19:37:59]

22 ?

[bsalomon, 2015/11/02 20:17:30]

Just wanted a weird number... Added comment.

+    desc.fHeight = bitmap.height() + 22;
+    SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, true));
+    if (!texture) {
+        return;
+    }
+    SkAutoLockPixels al(bitmap);

[robertphillips, 2015/11/02 19:37:59]

Can we clear the texture to green first ?

[bsalomon, 2015/11/02 20:17:30]

Done.

+    texture->writePixels(0, 0, bitmap.width(), bitmap.height(), desc.fConfig, bitmap.getPixels(),
+                         bitmap.rowBytes());
+    GrWrapTextureInBitmap(texture, bitmap.width(), bitmap.height(), true, &textureBmp);
+    canvas->drawBitmapRect(textureBmp, src, dst, paint, constraint);
+}
+
 // Create a black&white checked texture with 2 1-pixel rings
 // around the outside edge. The inner ring is red and the outer ring is blue.
 static void make_ringed_color_bitmap(SkBitmap* result, int width, int height) {
     SkASSERT(0 == width % 2 && 0 == height % 2);
 
     static const SkPMColor kRed = SkPreMultiplyColor(SK_ColorRED);
     static const SkPMColor kBlue = SkPreMultiplyColor(SK_ColorBLUE);
     static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
     static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
 
@@ skipping 123 matching lines @@
 static SkShader* make_shader() {
     static const SkPoint pts[] = { {0, 0}, {20, 20} };
     static const SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
     return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
 }
 
 static SkShader* make_null_shader() { return nullptr; }
 
 enum BleedTest {
     kUseBitmap_BleedTest,
+    kUseTextureBitmap_BleedTest,
     kUseImage_BleedTest,
     kUseAlphaBitmap_BleedTest,
+    kUseAlphaTextureBitmap_BleedTest,
     kUseAlphaImage_BleedTest,
     kUseAlphaBitmapShader_BleedTest,
+    kUseAlphaTextureBitmapShader_BleedTest,
     kUseAlphaImageShader_BleedTest,
 };
 
 const struct {
     const char* fName;
     void(*fBmpMaker)(SkBitmap* result, int width, int height);
     SkShader*(*fShaderMaker)();
     void(*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect&, const SkRect&,
                  const SkPaint*, SkCanvas::SrcRectConstraint);
 } gBleedRec[] = {
-    { "bleed",                     make_ringed_color_bitmap, make_null_shader,  draw_bitmap_rect },
-    { "bleed_image",               make_ringed_color_bitmap, make_null_shader,  draw_image_rect  },
-    { "bleed_alpha_bmp",           make_ringed_alpha_bitmap, make_null_shader,  draw_bitmap_rect },
-    { "bleed_alpha_image",         make_ringed_alpha_bitmap, make_null_shader,  draw_image_rect  },
-    { "bleed_alpha_bmp_shader",    make_ringed_alpha_bitmap, make_shader,       draw_bitmap_rect },
-    { "bleed_alpha_image_shader",  make_ringed_alpha_bitmap, make_shader,       draw_image_rect  },
+    { "bleed",                          make_ringed_color_bitmap, make_null_shader,  draw_bitmap_rect         },
+    { "bleed_texture_bmp",              make_ringed_color_bitmap, make_null_shader,  draw_texture_bitmap_rect },
+    { "bleed_image",                    make_ringed_color_bitmap, make_null_shader,  draw_image_rect          },
+    { "bleed_alpha_bmp",                make_ringed_alpha_bitmap, make_null_shader,  draw_bitmap_rect         },
+    { "bleed_alpha_texture_bmp",        make_ringed_alpha_bitmap, make_null_shader,  draw_texture_bitmap_rect },
+    { "bleed_alpha_image",              make_ringed_alpha_bitmap, make_null_shader,  draw_image_rect          },
+    { "bleed_alpha_bmp_shader",         make_ringed_alpha_bitmap, make_shader,       draw_bitmap_rect         },
+    { "bleed_alpha_texture_bmp_shader", make_ringed_alpha_bitmap, make_shader,       draw_texture_bitmap_rect },
+    { "bleed_alpha_image_shader",       make_ringed_alpha_bitmap, make_shader,       draw_image_rect          },
 };
 
 // This GM exercises the drawBitmapRect constraints
 class BleedGM : public skiagm::GM {
 public:
     BleedGM(BleedTest bt) : fBT(bt) {}
 
 protected:
 
     SkString onShortName() override {
@@ skipping 202 matching lines @@
     SkAutoTUnref<SkImage> fImageSmall;
     SkAutoTUnref<SkImage> fImageBig;
 
     SkAutoTUnref<SkShader> fShader;
 
     const BleedTest fBT;
 
     typedef GM INHERITED;
 };
 
+
 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseImage_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
-DEF_GM(return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
-DEF_GM(return new BleedGM(kUseAlphaImageShader_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaTextureBitmapShader_BleedTest); )
+DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )