Add ability to query read pixels support without a render target.

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 624 matching lines @@
     if (nullptr == gli->fFunctions.fStencilThenCoverFillPath ||
         nullptr == gli->fFunctions.fStencilThenCoverStrokePath ||
         nullptr == gli->fFunctions.fStencilThenCoverFillPathInstanced ||
         nullptr == gli->fFunctions.fStencilThenCoverStrokePathInstanced ||
         nullptr == gli->fFunctions.fProgramPathFragmentInputGen) {
         return false;
     }
     return true;
 }
 
-bool GrGLCaps::readPixelsSupported(GrGLRenderTarget* target,
+bool GrGLCaps::readPixelsSupported(GrPixelConfig rtConfig,
                                    GrPixelConfig readConfig,
                                    std::function<void (GrGLenum, GrGLint*)> getIntegerv,
-                                   std::function<void (GrGLRenderTarget*)> bindRenderTarget) const {
-    GrPixelConfig rtConfig = target->config();
+                                   std::function<bool ()> bindRenderTarget) const {
     SkASSERT(this->isConfigRenderable(rtConfig, false));
 
     GrGLenum readFormat;
     GrGLenum readType;
     if (!this->getReadPixelsFormat(rtConfig, readConfig, &readFormat, &readType)) {
         return false;
     }
 
     if (kGL_GrGLStandard == fStandard) {
         // All of our renderable configs can be converted to each other by glReadPixels in OpenGL.
@@ skipping 10 matching lines @@
         SkASSERT(kFloat_FormatType == fConfigTable[rtConfig].fFormatType);
         if (GR_GL_RGBA == readFormat && GR_GL_FLOAT == readType) {
             return true;
         }
     }
 
     if (0 == fConfigTable[rtConfig].fSecondReadPixelsFormat.fFormat) {
         ReadPixelsFormat* rpFormat =
             const_cast<ReadPixelsFormat*>(&fConfigTable[rtConfig].fSecondReadPixelsFormat);
         GrGLint format = 0, type = 0;
-        bindRenderTarget(target);
+        if (!bindRenderTarget()) {
+            return false;
+        }
         getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT, &format);
         getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);
         rpFormat->fFormat = format;
         rpFormat->fType = type;
     }
 
     return fConfigTable[rtConfig].fSecondReadPixelsFormat.fFormat == readFormat &&
            fConfigTable[rtConfig].fSecondReadPixelsFormat.fType == readType;
 }
 
@@ skipping 902 matching lines @@
         for (int j = 0; j < kExternalFormatUsageCnt; ++j) {
             SkASSERT(defaultEntry.fFormats.fExternalFormat[j] !=
                      fConfigTable[i].fFormats.fExternalFormat[j]);
         }
         SkASSERT(defaultEntry.fFormats.fExternalType != fConfigTable[i].fFormats.fExternalType);
     }
 #endif
 }
 
 void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) {}