Add prescale option to deferred params

gm/deferredtextureimagedata.cpp

Index: gm/deferredtextureimagedata.cpp
diff --git a/gm/deferredtextureimagedata.cpp b/gm/deferredtextureimagedata.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..450dfd701cef68be1c83cfba57e0d41a4755979d
--- /dev/null
+++ b/gm/deferredtextureimagedata.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include <vector>
+
+#include "gm.h"
+#include "GrContext.h"
+#include "Resources.h"
+#include "SkImage.h"
+
+#if SK_SUPPORT_GPU
+
+// Helper function that uploads the given SkImage using MakdeFromDeferredTextureImageData and then
+// draws the uploaded version at the specified coordinates.
+bool DrawDeferredTextureImageData(SkCanvas* canvas, SkImage* image,

[bsalomon, 2016/06/10 13:18:24]

nit, should be static bool draw_deferred_texture_image_data

+                                  SkImage::DeferredTextureImageUsageParams* params, int x, int y) {
+  size_t deferredSize = 
+      image->getDeferredTextureImageData(*canvas->getGrContext()->threadSafeProxy(), params, 1,
+                                         nullptr);
+  if (deferredSize == 0) {
+      SkDebugf("\nCould not create DeferredTextureImageData.\n");
+      return false;
+  }
+
+  std::vector<uint8_t> memory;
+  memory.resize(deferredSize);
+  image->getDeferredTextureImageData(*canvas->getGrContext()->threadSafeProxy(), params, 1,
+                                     memory.data());
+  sk_sp<SkImage> uploadedImage =
+      SkImage::MakeFromDeferredTextureImageData(canvas->getGrContext(), memory.data(),
+                                                SkBudgeted::kNo);
+  canvas->drawImage(uploadedImage, x, y);
+
+  return true;
+}
+
+DEF_SIMPLE_GM(deferred_texture_image_data, canvas, 60, 10) {
+    sk_sp<SkImage> encodedImage = GetResourceAsImage("randPixels.png");
+    if (!encodedImage) {
+        SkDebugf("\nCould not load resource.\n");
+        return;
+    }
+
+    SkBitmap bitmap;
+    if (!GetResourceAsBitmap("randPixels.png", &bitmap)) {
+        SkDebugf("\nCould not decode resource.\n");
+        return;
+    }
+
+    sk_sp<SkImage> decodedImage = SkImage::MakeFromBitmap(bitmap);
+
+    // Draw both encoded and decoded image via deferredTextureImageData.
+    SkImage::DeferredTextureImageUsageParams params;
+    DrawDeferredTextureImageData(canvas, encodedImage.get(), &params, 0, 0);
+    DrawDeferredTextureImageData(canvas, decodedImage.get(), &params, 10, 0);
+
+    // Draw 50% scaled versions of the encoded and decoded images at medium quality.
+    SkImage::DeferredTextureImageUsageParams mediumScaledParams;
+    mediumScaledParams.fPreScaleMipLevel = 1;
+    mediumScaledParams.fQuality = kMedium_SkFilterQuality;
+
+    DrawDeferredTextureImageData(canvas, encodedImage.get(), &mediumScaledParams, 20, 0);
+    DrawDeferredTextureImageData(canvas, decodedImage.get(), &mediumScaledParams, 30, 0);
+
+    // Draw 50% scaled versions of the encoded and decoded images at none quality.
+    SkImage::DeferredTextureImageUsageParams noneScaledParams;
+    noneScaledParams.fPreScaleMipLevel = 1;
+    noneScaledParams.fQuality = kNone_SkFilterQuality;
+
+    DrawDeferredTextureImageData(canvas, encodedImage.get(), &noneScaledParams, 40, 0);
+    DrawDeferredTextureImageData(canvas, decodedImage.get(), &noneScaledParams, 50, 0);
+}
+
+#endif