Some tests around surface creation and snapshotting with color space

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 50 matching lines @@
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
             this->prepareDraw(draw);                            \
         } while (0)
 #else
     #define CHECK_SHOULD_DRAW(draw) this->prepareDraw(draw)
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/** Checks that the alpha type is legal and gets constructor flags. Returns false if device creation
-    should fail. */
-bool SkGpuDevice::CheckAlphaTypeAndGetFlags(
+/** Checks that the alpha type, color space, etc... is legal and gets constructor flags.
+    Returns false if device creation should fail. */
+bool SkGpuDevice::CheckInfoAndGetFlags(
                         const SkImageInfo* info, SkGpuDevice::InitContents init, unsigned* flags) {
+    if (info) {
+        switch (info->colorType()) {
+            case kRGBA_F16_SkColorType:
+                if (!info->colorSpace() ||
+                    SkColorSpace::kLinear_GammaNamed != info->colorSpace()->gammaNamed()) {
+                    return false;
+                }
+                break;
+            case kRGBA_8888_SkColorType:
+            case kBGRA_8888_SkColorType:
+                if (info->colorSpace() && !info->colorSpace()->gammaCloseToSRGB()) {
+                    return false;
+                }
+                break;
+            default:
+                if (info->colorSpace()) {
+                    return false;
+                }
+        }
+    }
+
     *flags = 0;
     if (info) {
         switch (info->alphaType()) {
             case kPremul_SkAlphaType:
                 break;
             case kOpaque_SkAlphaType:
                 *flags |= SkGpuDevice::kIsOpaque_Flag;
                 break;
             default: // If it is unpremul or unknown don't try to render
                 return false;
         }
     }
     if (kClear_InitContents == init) {
         *flags |= kNeedClear_Flag;
     }
     return true;
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(sk_sp<GrDrawContext> drawContext,
                                      int width, int height,
                                      InitContents init) {
     if (!drawContext || drawContext->wasAbandoned()) {
         return nullptr;
     }
     unsigned flags;
-    if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
+    if (!CheckInfoAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
     return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context, SkBudgeted budgeted,
                                      const SkImageInfo& info, int sampleCount,
                                      GrSurfaceOrigin origin,
                                      const SkSurfaceProps* props, InitContents init) {
     unsigned flags;
-    if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
+    if (!CheckInfoAndGetFlags(&info, init, &flags)) {
         return nullptr;
     }
 
     sk_sp<GrDrawContext> drawContext(MakeDrawContext(context, budgeted, info,
                                                      sampleCount, origin, props));
     if (!drawContext) {
         return nullptr;
     }
 
     return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext),
@@ skipping 1685 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