Style bikeshed - remove extraneous whitespace

src/gpu/GrDrawContext.cpp

-
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
@@ skipping 24 matching lines @@
     SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fSingleOwner);)
 #define ASSERT_SINGLE_OWNER_PRIV \
     SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fDrawContext->fSingleOwner);)
 #define RETURN_IF_ABANDONED        if (fDrawingManager->abandoned()) { return; }
 #define RETURN_FALSE_IF_ABANDONED  if (fDrawingManager->abandoned()) { return false; }
 #define RETURN_FALSE_IF_ABANDONED_PRIV  if (fDrawContext->fDrawingManager->abandoned()) { return false; }
 #define RETURN_NULL_IF_ABANDONED   if (fDrawingManager->abandoned()) { return nullptr; }
 
 class AutoCheckFlush {
 public:
-    AutoCheckFlush(GrDrawingManager* drawingManager) : fDrawingManager(drawingManager) { 
+    AutoCheckFlush(GrDrawingManager* drawingManager) : fDrawingManager(drawingManager) {
         SkASSERT(fDrawingManager);
     }
     ~AutoCheckFlush() { fDrawingManager->getContext()->flushIfNecessary(); }
 
 private:
     GrDrawingManager* fDrawingManager;
 };
 
 // In MDB mode the reffing of the 'getLastDrawTarget' call's result allows in-progress
 // drawTargets to be picked up and added to by drawContexts lower in the call
@@ skipping 206 matching lines @@
         // The fill path can handle rotation but not skew.
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
             viewMatrix.mapRect(&devBoundRect, rect);
             batch = GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix,
                                                      rect, devBoundRect);
         }
     } else {
         // filled BW rect
         batch = GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                    nullptr, nullptr);        
+                                                    nullptr, nullptr);
     }
 
     return batch;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStrokeInfo* strokeInfo) {
@@ skipping 57 matching lines @@
                                                                *strokeInfo));
             }
         } else {
             // Non-AA hairlines are snapped to pixel centers to make which pixels are hit
             // deterministic
             snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
             batch.reset(GrRectBatchFactory::CreateNonAAStroke(color, viewMatrix, rect,
                                                               width, snapToPixelCenters));
 
             // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
-            // hairline rects. We jam all the vertices to pixel centers to avoid this, but not 
+            // hairline rects. We jam all the vertices to pixel centers to avoid this, but not
             // when MSAA is enabled because it can cause ugly artifacts.
         }
     }
 
     if (batch) {
         GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
 
         if (snapToPixelCenters) {
             pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                      snapToPixelCenters);
         }
 
         this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
         return;
     }
-    
+
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     this->internalDrawPath(clip, paint, viewMatrix, path,
                            strokeInfo ? *strokeInfo : GrStrokeInfo::FillInfo());
 }
 
 bool GrDrawContextPriv::drawAndStencilRect(const SkIRect* scissorRect,
                                            const GrStencilSettings& ss,
                                            SkRegion::Op op,
@@ skipping 134 matching lines @@
                               int spriteCount,
                               const SkRSXform xform[],
                               const SkRect texRect[],
                               const SkColor colors[]) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawAtlas");
 
     AutoCheckFlush acf(fDrawingManager);
-        
+
     GrDrawAtlasBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrDrawBatch> batch(GrDrawAtlasBatch::Create(geometry, viewMatrix, spriteCount,
                                                              xform, texRect, colors));
-    
+
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawRRect(const GrClip& clip,
                               const GrPaint& paint,
                               const SkMatrix& viewMatrix,
                               const SkRRect& rrect,
@@ skipping 54 matching lines @@
             return false;
         }
         if (!origOuter.transform(viewMatrix, outer.writable())) {
             return false;
         }
         if (!viewMatrix.invert(&inverseVM)) {
             return false;
         }
     } else {
         inverseVM.reset();
-    }         
+    }
 
     GrPaint grPaint(paintIn);
     grPaint.setAntiAlias(false);
 
     // TODO these need to be a geometry processors
     SkAutoTUnref<GrFragmentProcessor> innerEffect(GrRRectEffect::Create(innerEdgeType, *inner));
     if (!innerEffect) {
         return false;
     }
 
     SkAutoTUnref<GrFragmentProcessor> outerEffect(GrRRectEffect::Create(outerEdgeType, *outer));
     if (!outerEffect) {
         return false;
     }
 
     grPaint.addCoverageFragmentProcessor(innerEffect);
     grPaint.addCoverageFragmentProcessor(outerEffect);
 
     SkRect bounds = outer->getBounds();
     if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
-  
+
     this->fillRectWithLocalMatrix(clip, grPaint, SkMatrix::I(), bounds, inverseVM);
     return true;
 }
 
 void GrDrawContext::drawDRRect(const GrClip& clip,
                                const GrPaint& paint,
                                const SkMatrix& viewMatrix,
                                const SkRRect& outer,
                                const SkRRect& inner) {
     ASSERT_SINGLE_OWNER
@@ skipping 223 matching lines @@
                                            bool invert,
                                            bool doAA,
                                            const SkMatrix& viewMatrix,
                                            const SkPath& path) {
     ASSERT_SINGLE_OWNER_PRIV
     RETURN_FALSE_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::drawPath");
 
     if (path.isEmpty() && path.isInverseFillType()) {
-        this->drawAndStencilRect(scissorRect, ss, op, invert, false, SkMatrix::I(), 
-                                 SkRect::MakeIWH(fDrawContext->fRenderTarget->width(), 
+        this->drawAndStencilRect(scissorRect, ss, op, invert, false, SkMatrix::I(),
+                                 SkRect::MakeIWH(fDrawContext->fRenderTarget->width(),
                                                  fDrawContext->fRenderTarget->height()));
         return true;
     }
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
@@ skipping 149 matching lines @@
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }