Enable sRGB on iOS, make sRGB decode support optional

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 
@@ skipping 33 matching lines @@
     fBaseInstanceSupport = false;
     fIsCoreProfile = false;
     fBindFragDataLocationSupport = false;
     fRectangleTextureSupport = false;
     fTextureSwizzleSupport = false;
     fRGBA8888PixelsOpsAreSlow = false;
     fPartialFBOReadIsSlow = false;
     fMipMapLevelAndLodControlSupport = false;
     fRGBAToBGRAReadbackConversionsAreSlow = false;
     fDoManualMipmapping = false;
+    fSRGBDecodeSupport = false;
+    fRequireDecodeForSRGB = true;
 
     fBlitFramebufferFlags = kNoSupport_BlitFramebufferFlag;
 
     fShaderCaps.reset(new GrShaderCaps(contextOptions));
 
     this->init(contextOptions, ctxInfo, glInterface);
 }
 
 void GrGLCaps::init(const GrContextOptions& contextOptions,
                     const GrGLContextInfo& ctxInfo,
@@ skipping 536 matching lines @@
     // glGenerateMipmap. Our implementation requires mip-level sampling control. Additionally,
     // it can be much slower (especially on mobile GPUs), so we opt-in only when necessary:
     if (fMipMapLevelAndLodControlSupport &&
         (contextOptions.fDoManualMipmapping ||
          (kIntel_GrGLVendor == ctxInfo.vendor()) ||
          (kNVIDIA_GrGLDriver == ctxInfo.driver() && isMAC) ||
          (kATI_GrGLVendor == ctxInfo.vendor()))) {
         fDoManualMipmapping = true;
     }
 
+    fSRGBDecodeSupport = ctxInfo.hasExtension("GL_EXT_texture_sRGB_decode");
+    fRequireDecodeForSRGB = contextOptions.fRequireDecodeForSRGB;
+
     // Requires fTextureRedSupport, fTextureSwizzleSupport, msaa support, ES compatibility have
     // already been detected.
     this->initConfigTable(ctxInfo, gli, shaderCaps);
 
     this->applyOptionsOverrides(contextOptions);
     shaderCaps->applyOptionsOverrides(contextOptions);
 }
 
 const char* get_glsl_version_decl_string(GrGLStandard standard, GrGLSLGeneration generation,
                                          bool isCoreProfile) {
@@ skipping 948 matching lines @@
             if (ctxInfo.hasExtension("GL_ARB_framebuffer_sRGB") ||
                 ctxInfo.hasExtension("GL_EXT_framebuffer_sRGB")) {
                 fSRGBSupport = true;
             }
         }
         // All the above srgb extensions support toggling srgb writes
         if (fSRGBSupport) {
             fSRGBWriteControl = true;
         }
     } else {
-        // See https://bug.skia.org/4148 for PowerVR issue.
-        fSRGBSupport = kPowerVRRogue_GrGLRenderer != ctxInfo.renderer() &&
-            (ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_sRGB"));
+        fSRGBSupport = ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_sRGB");
         // ES through 3.1 requires EXT_srgb_write_control to support toggling
         // sRGB writing for destinations.
         // See https://bug.skia.org/5329 for Adreno4xx issue.
         fSRGBWriteControl = kAdreno4xx_GrGLRenderer != ctxInfo.renderer() &&
             ctxInfo.hasExtension("GL_EXT_sRGB_write_control");
     }
-    if (!ctxInfo.hasExtension("GL_EXT_texture_sRGB_decode")) {
-        // To support "legacy" L32 mode, we require the ability to turn off sRGB decode:
+    if (fRequireDecodeForSRGB && !fSRGBDecodeSupport) {

[bsalomon, 2016/11/30 17:00:21]

Should we just pass the options here rather than having this fRequire member?

+        // To support "legacy" L32 mode, we require the ability to turn off sRGB decode. Clients
+        // can opt-out of that requirement, if they intend to always do linear blending.
         fSRGBSupport = false;
     }
     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA;
     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
     // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
     // external format is GL_RGBA. See below for note about ES2.0 and glTex[Sub]Image.
     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
         GR_GL_RGBA;
     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
@@ skipping 476 matching lines @@
 void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) {
     if (options.fEnableInstancedRendering) {
         fInstancedSupport = gr_instanced::GLInstancedRendering::CheckSupport(*this);
 #ifndef SK_BUILD_FOR_MAC
         // OS X doesn't seem to write correctly to floating point textures when using
         // glDraw*Indirect, regardless of the underlying GPU.
         fAvoidInstancedDrawsToFPTargets = true;
 #endif
     }
 }