Style bikeshed - remove extraneous whitespace

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLBuffer.h"
 #include "GrGLGLSL.h"
@@ skipping 279 matching lines @@
 void GrGLGpu::createPLSSetupProgram() {
     const GrGLSLCaps* glslCaps = this->glCaps().glslCaps();
     const char* version = glslCaps->versionDeclString();
 
     GrGLSLShaderVar aVertex("a_vertex", kVec2f_GrSLType, GrShaderVar::kAttribute_TypeModifier);
     GrGLSLShaderVar uTexCoordXform("u_texCoordXform", kVec4f_GrSLType,
                                    GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uPosXform("u_posXform", kVec4f_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar uTexture("u_texture", kSampler2D_GrSLType, GrShaderVar::kUniform_TypeModifier);
     GrGLSLShaderVar vTexCoord("v_texCoord", kVec2f_GrSLType, GrShaderVar::kVaryingOut_TypeModifier);
-    
+
     SkString vshaderTxt(version);
     if (glslCaps->noperspectiveInterpolationSupport()) {
         if (const char* extension = glslCaps->noperspectiveInterpolationExtensionString()) {
             vshaderTxt.appendf("#extension %s : require\n", extension);
         }
         vTexCoord.addModifier("noperspective");
     }
     aVertex.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
     uTexCoordXform.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
     uPosXform.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
     vTexCoord.appendDecl(glslCaps, &vshaderTxt);
     vshaderTxt.append(";");
-    
+
     vshaderTxt.append(
         "// PLS Setup Program VS\n"
         "void main() {"
         "  gl_Position.xy = a_vertex * u_posXform.xy + u_posXform.zw;"
         "  gl_Position.zw = vec2(0, 1);"
         "}"
     );
 
     SkString fshaderTxt(version);
     if (glslCaps->noperspectiveInterpolationSupport()) {
@@ skipping 2287 matching lines @@
             } else {
                 dst -= rowBytes;
             }
         }
     }
     return true;
 }
 
 void GrGLGpu::finishDrawTarget() {
     if (fPLSHasBeenUsed) {
-        /* There is an ARM driver bug where if we use PLS, and then draw a frame which does not 
-         * use PLS, it leaves garbage all over the place. As a workaround, we use PLS in a 
+        /* There is an ARM driver bug where if we use PLS, and then draw a frame which does not
+         * use PLS, it leaves garbage all over the place. As a workaround, we use PLS in a
          * trivial way every frame. And since we use it every frame, there's never a point at which
          * it becomes safe to stop using this workaround once we start.
          */
         this->disableScissor();
         // using PLS in the presence of MSAA results in GL_INVALID_OPERATION
         this->flushHWAAState(nullptr, false, false);
         SkASSERT(!fHWPLSEnabled);
         SkASSERT(fMSAAEnabled != kYes_TriState);
         GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        this->stampRectUsingProgram(fPLSSetupProgram.fProgram, 
-                                    SkRect::MakeXYWH(-100.0f, -100.0f, 0.01f, 0.01f), 
-                                    fPLSSetupProgram.fPosXformUniform, 
+        this->stampRectUsingProgram(fPLSSetupProgram.fProgram,
+                                    SkRect::MakeXYWH(-100.0f, -100.0f, 0.01f, 0.01f),
+                                    fPLSSetupProgram.fPosXformUniform,
                                     fPLSSetupProgram.fArrayBuffer);
         GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
     }
 }
 
 void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bounds, bool disableSRGB) {
     SkASSERT(target);
 
     uint32_t rtID = target->getUniqueID();
     if (fHWBoundRenderTargetUniqueID != rtID) {
@@ skipping 148 matching lines @@
         int set_a_break_pt_here = 9;
         aglSwapBuffers(aglGetCurrentContext());
     #elif defined(SK_BUILD_FOR_WIN32)
         SwapBuf();
         int set_a_break_pt_here = 9;
         SwapBuf();
     #endif
 #endif
 }
 
-void GrGLGpu::stampRectUsingProgram(GrGLuint program, const SkRect& bounds, GrGLint posXformUniform, 
+void GrGLGpu::stampRectUsingProgram(GrGLuint program, const SkRect& bounds, GrGLint posXformUniform,
                                     GrGLuint arrayBuffer) {
     GL_CALL(UseProgram(program));
     this->fHWGeometryState.setVertexArrayID(this, 0);
 
     GrGLAttribArrayState* attribs =
             this->fHWGeometryState.bindArrayAndBufferToDraw(this, arrayBuffer);
     attribs->set(this, 0, arrayBuffer, kVec2f_GrVertexAttribType, 2 * sizeof(GrGLfloat), 0);
     attribs->disableUnusedArrays(this, 0x1);
 
-    GL_CALL(Uniform4f(posXformUniform, bounds.width(), bounds.height(), bounds.left(), 
+    GL_CALL(Uniform4f(posXformUniform, bounds.width(), bounds.height(), bounds.left(),
                       bounds.top()));
 
     GrXferProcessor::BlendInfo blendInfo;
     blendInfo.reset();
     this->flushBlend(blendInfo, GrSwizzle());
     this->flushColorWrite(true);
     this->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
     if (!fHWStencilSettings.isDisabled()) {
         GL_CALL(Disable(GR_GL_STENCIL_TEST));
     }
     GL_CALL(DrawArrays(GR_GL_TRIANGLE_STRIP, 0, 4));
     GL_CALL(UseProgram(fHWProgramID));
     if (!fHWStencilSettings.isDisabled()) {
         GL_CALL(Enable(GR_GL_STENCIL_TEST));
     }
 }
 
 void GrGLGpu::setupPixelLocalStorage(const GrPipeline& pipeline,
                                      const GrPrimitiveProcessor& primProc) {
     fPLSHasBeenUsed = true;
-    const SkRect& bounds = 
+    const SkRect& bounds =
             static_cast<const GrPLSGeometryProcessor&>(primProc).getBounds();
     // setup pixel local storage -- this means capturing and storing the current framebuffer color
     // and initializing the winding counts to zero
     GrRenderTarget* rt = pipeline.getRenderTarget();
     SkScalar width = SkIntToScalar(rt->width());
     SkScalar height = SkIntToScalar(rt->height());
     // dst rect edges in NDC (-1 to 1)
     // having some issues with rounding, just expand the bounds by 1 and trust the scissor to keep
     // it contained properly
     GrGLfloat dx0 = 2.0f * (bounds.left() - 1) / width - 1.0f;
     GrGLfloat dx1 = 2.0f * (bounds.right() + 1) / width - 1.0f;
     GrGLfloat dy0 = -2.0f * (bounds.top() - 1) / height + 1.0f;
     GrGLfloat dy1 = -2.0f * (bounds.bottom() + 1) / height + 1.0f;
     SkRect deviceBounds = SkRect::MakeXYWH(dx0, dy0, dx1 - dx0, dy1 - dy0);
-    
+
     GL_CALL(Enable(GR_GL_FETCH_PER_SAMPLE_ARM));
-    this->stampRectUsingProgram(fPLSSetupProgram.fProgram, deviceBounds, 
+    this->stampRectUsingProgram(fPLSSetupProgram.fProgram, deviceBounds,
                                 fPLSSetupProgram.fPosXformUniform, fPLSSetupProgram.fArrayBuffer);
 }
 
 void GrGLGpu::onResolveRenderTarget(GrRenderTarget* target) {
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
     if (rt->needsResolve()) {
         // Some extensions automatically resolves the texture when it is read.
         if (this->glCaps().usesMSAARenderBuffers()) {
             SkASSERT(rt->textureFBOID() != rt->renderFBOID());
             fStats.incRenderTargetBinds();
@@ skipping 1359 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }