Style bikeshed - remove extraneous whitespace

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 99 matching lines @@
         fTextureBarrierSupport = ctxInfo.hasExtension("GL_NV_texture_barrier");
     }
 
     if (kGL_GrGLStandard == standard) {
         fSampleLocationsSupport = version >= GR_GL_VER(3,2) ||
                                   ctxInfo.hasExtension("GL_ARB_texture_multisample");
     } else {
         fSampleLocationsSupport = version >= GR_GL_VER(3,1);
     }
 
-    // ARB_texture_rg is part of OpenGL 3.0, but mesa doesn't support GL_RED 
+    // ARB_texture_rg is part of OpenGL 3.0, but mesa doesn't support GL_RED
     // and GL_RG on FBO textures.
     if (kMesa_GrGLDriver != ctxInfo.driver()) {
         if (kGL_GrGLStandard == standard) {
             fTextureRedSupport = version >= GR_GL_VER(3,0) ||
                                  ctxInfo.hasExtension("GL_ARB_texture_rg");
         } else {
             fTextureRedSupport =  version >= GR_GL_VER(3,0) ||
                                   ctxInfo.hasExtension("GL_EXT_texture_rg");
         }
     }
@@ skipping 107 matching lines @@
     } else if (kGLES_GrGLStandard == standard) {
         if (version >= GR_GL_VER(3,0)) {
             fMipMapLevelAndLodControlSupport = true;
         }
     }
 
 #ifdef SK_BUILD_FOR_WIN
     // We're assuming that on Windows Chromium we're using ANGLE.
     bool isANGLE = kANGLE_GrGLDriver == ctxInfo.driver() ||
                    kChromium_GrGLDriver == ctxInfo.driver();
-    // Angle has slow read/write pixel paths for 32bit RGBA (but fast for BGRA). 
+    // Angle has slow read/write pixel paths for 32bit RGBA (but fast for BGRA).
     fRGBA8888PixelsOpsAreSlow = isANGLE;
     // On DX9 ANGLE reading a partial FBO is slow. TODO: Check whether this is still true and
     // check DX11 ANGLE.
     fPartialFBOReadIsSlow = isANGLE;
 #endif
 
     bool isMESA = kMesa_GrGLDriver == ctxInfo.driver();
     bool isMAC = false;
 #ifdef SK_BUILD_FOR_MAC
     isMAC = true;
@@ skipping 34 matching lines @@
 
         glslCaps->fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) ||
             ctxInfo.hasExtension("GL_OES_standard_derivatives");
 
         glslCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) &&
             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
     }
 
     if (ctxInfo.hasExtension("GL_EXT_shader_pixel_local_storage")) {
         #define GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT 0x8F63
-        GR_GL_GetIntegerv(gli, GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT, 
+        GR_GL_GetIntegerv(gli, GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT,
                           &glslCaps->fPixelLocalStorageSize);
         glslCaps->fPLSPathRenderingSupport = glslCaps->fFBFetchSupport;
     }
     else {
         glslCaps->fPixelLocalStorageSize = 0;
         glslCaps->fPLSPathRenderingSupport = false;
     }
 
     // Protect ourselves against tracking huge amounts of texture state.
     static const uint8_t kMaxSaneSamplers = 32;
@@ skipping 67 matching lines @@
             fMapBufferType = kMapBufferRange_MapBufferType;
         } else if (ctxInfo.hasExtension("GL_OES_mapbuffer")) {
             fMapBufferFlags = kCanMap_MapFlag;
             fMapBufferType = kMapBuffer_MapBufferType;
         }
     }
 
     if (kGL_GrGLStandard == standard) {
         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_pixel_buffer_object")) {
             fTransferBufferType = kPBO_TransferBufferType;
-        } 
+        }
     } else {
         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_NV_pixel_buffer_object")) {
             fTransferBufferType = kPBO_TransferBufferType;
         } else if (ctxInfo.hasExtension("GL_CHROMIUM_pixel_transfer_buffer_object")) {
             fTransferBufferType = kChromium_TransferBufferType;
         }
     }
 
     // On many GPUs, map memory is very expensive, so we effectively disable it here by setting the
     // threshold to the maximum unless the client gives us a hint that map memory is cheap.
@@ skipping 683 matching lines @@
     r.appendf("Draw indirect support: %s\n", (fDrawIndirectSupport ? "YES" : "NO"));
     r.appendf("Multi draw indirect support: %s\n", (fMultiDrawIndirectSupport ? "YES" : "NO"));
     r.appendf("Base instance support: %s\n", (fBaseInstanceSupport ? "YES" : "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("RGBA 8888 pixel ops are slow: %s\n", (fRGBA8888PixelsOpsAreSlow ? "YES" : "NO"));
     r.appendf("Partial FBO read is slow: %s\n", (fPartialFBOReadIsSlow ? "YES" : "NO"));
     r.appendf("Bind uniform location support: %s\n", (fBindUniformLocationSupport ? "YES" : "NO"));
     r.appendf("Rectangle texture support: %s\n", (fRectangleTextureSupport? "YES" : "NO"));
     r.appendf("Texture swizzle support: %s\n", (fTextureSwizzleSupport ? "YES" : "NO"));
-    r.appendf("BGRA to RGBA readback conversions are slow: %s\n", 
+    r.appendf("BGRA to RGBA readback conversions are slow: %s\n",
               (fRGBAToBGRAReadbackConversionsAreSlow ? "YES" : "NO"));
 
     r.append("Configs\n-------\n");
     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
         r.appendf("  cfg: %d flags: 0x%04x, b_internal: 0x%08x s_internal: 0x%08x, e_format: "
                   "0x%08x, e_format_teximage: 0x%08x, e_type: 0x%08x, i_for_teximage: 0x%08x, "
                   "i_for_renderbuffer: 0x%08x\n",
                   i,
                   fConfigTable[i].fFlags,
                   fConfigTable[i].fFormats.fBaseInternalFormat,
@@ skipping 28 matching lines @@
     case kGeometry_GrShaderType:
         return GR_GL_GEOMETRY_SHADER;
     case kFragment_GrShaderType:
         return GR_GL_FRAGMENT_SHADER;
     }
     SkFAIL("Unknown shader type.");
     return -1;
 }
 
 void GrGLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,
-                                        const GrGLInterface* intf, 
+                                        const GrGLInterface* intf,
                                         GrGLSLCaps* glslCaps) {
     if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4, 1) ||
         ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
         for (int s = 0; s < kGrShaderTypeCount; ++s) {
             if (kGeometry_GrShaderType != s) {
                 GrShaderType shaderType = static_cast<GrShaderType>(s);
                 GrGLenum glShader = shader_type_to_gl_shader(shaderType);
                 GrShaderCaps::PrecisionInfo* first = nullptr;
                 glslCaps->fShaderPrecisionVaries = false;
                 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
                     GrSLPrecision precision = static_cast<GrSLPrecision>(p);
                     GrGLenum glPrecision = precision_to_gl_float_type(precision);
                     GrGLint range[2];
                     GrGLint bits;
                     GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits);
                     if (bits) {
                         glslCaps->fFloatPrecisions[s][p].fLogRangeLow = range[0];
                         glslCaps->fFloatPrecisions[s][p].fLogRangeHigh = range[1];
                         glslCaps->fFloatPrecisions[s][p].fBits = bits;
                         if (!first) {
                             first = &glslCaps->fFloatPrecisions[s][p];
                         }
                         else if (!glslCaps->fShaderPrecisionVaries) {
-                            glslCaps->fShaderPrecisionVaries = 
+                            glslCaps->fShaderPrecisionVaries =
                                                      (*first != glslCaps->fFloatPrecisions[s][p]);
                         }
                     }
                 }
             }
         }
     }
     else {
         // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.
         glslCaps->fShaderPrecisionVaries = false;
         for (int s = 0; s < kGrShaderTypeCount; ++s) {
             if (kGeometry_GrShaderType != s) {
                 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
                     glslCaps->fFloatPrecisions[s][p].fLogRangeLow = 127;
                     glslCaps->fFloatPrecisions[s][p].fLogRangeHigh = 127;
                     glslCaps->fFloatPrecisions[s][p].fBits = 23;
                 }
             }
         }
     }
     // GetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Assume they're
     // the same as the vertex shader. Only fragment shaders were ever allowed to omit support for
     // highp. GS was added after GetShaderPrecisionFormat was added to the list of features that
     // are recommended against.
     if (glslCaps->fGeometryShaderSupport) {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
-            glslCaps->fFloatPrecisions[kGeometry_GrShaderType][p] = 
+            glslCaps->fFloatPrecisions[kGeometry_GrShaderType][p] =
                                                glslCaps->fFloatPrecisions[kVertex_GrShaderType][p];
         }
     }
 }
 
 bool GrGLCaps::bgraIsInternalFormat() const {
     return fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat == GR_GL_BGRA;
 }
 
 bool GrGLCaps::getTexImageFormats(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig,
@@ skipping 620 matching lines @@
         // unsupported. (If we have no sRGB support at all, this will get overwritten below).
         fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = 0;
     }
 
     // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image
     // as a base format.
     // GL_EXT_texture_format_BGRA8888:
     //      This extension GL_BGRA as an unsized internal format. However, it is written against ES
     //      2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal
     //      formats.
-    // GL_APPLE_texture_format_BGRA8888: 
+    // GL_APPLE_texture_format_BGRA8888:
     //     ES 2.0: the extension makes BGRA an external format but not an internal format.
     //     ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for
     //             glTexImage (just for glTexStorage).
     if (useSizedTexFormats && this->bgraIsInternalFormat())  {
         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fInternalFormatTexImage = GR_GL_BGRA;
     }
 
     // If we don't have texture swizzle support then the shader generator must insert the
     // swizzle into shader code.
     if (!this->textureSwizzleSupport()) {
@@ skipping 26 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) {}