Style bikeshed - remove extraneous whitespace

src/core/SkDevice.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 "SkColorFilter.h"
 #include "SkDevice.h"
 #include "SkDraw.h"
@@ skipping 70 matching lines @@
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     const SkMatrix* preMatrix = nullptr;
     const bool pathIsMutable = true;
     this->drawPath(draw, path, paint, preMatrix, pathIsMutable);
 }
 
 void SkBaseDevice::drawPatch(const SkDraw& draw, const SkPoint cubics[12], const SkColor colors[4],
                              const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
     SkPatchUtils::VertexData data;
-    
+
     SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, draw.fMatrix);
 
     // It automatically adjusts lodX and lodY in case it exceeds the number of indices.
-    // If it fails to generate the vertices, then we do not draw. 
+    // If it fails to generate the vertices, then we do not draw.
     if (SkPatchUtils::getVertexData(&data, cubics, colors, texCoords, lod.width(), lod.height())) {
         this->drawVertices(draw, SkCanvas::kTriangles_VertexMode, data.fVertexCount, data.fPoints,
                            data.fTexCoords, data.fColors, xmode, data.fIndices, data.fIndexCount,
                            paint);
     }
 }
 
 void SkBaseDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint &paint, SkDrawFilter* drawFilter) {
 
@@ skipping 63 matching lines @@
 
     SkRect srcR, dstR;
     while (iter.next(&srcR, &dstR)) {
         this->drawImageRect(draw, image, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 }
 
 void SkBaseDevice::drawBitmapNine(const SkDraw& draw, const SkBitmap& bitmap, const SkIRect& center,
                                   const SkRect& dst, const SkPaint& paint) {
     SkNinePatchIter iter(bitmap.width(), bitmap.height(), center, dst);
-    
+
     SkRect srcR, dstR;
     while (iter.next(&srcR, &dstR)) {
         this->drawBitmapRect(draw, bitmap, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 }
 
 void SkBaseDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRSXform xform[],
                              const SkRect tex[], const SkColor colors[], int count,
                              SkXfermode::Mode mode, const SkPaint& paint) {
     SkPath path;
     path.setIsVolatile(true);
 
     for (int i = 0; i < count; ++i) {
         SkPoint quad[4];
         xform[i].toQuad(tex[i].width(), tex[i].height(), quad);
-        
+
         SkMatrix localM;
         localM.setRSXform(xform[i]);
         localM.preTranslate(-tex[i].left(), -tex[i].top());
 
         SkPaint pnt(paint);
         sk_sp<SkShader> shader = atlas->makeShader(SkShader::kClamp_TileMode,
                                                    SkShader::kClamp_TileMode,
                                                    &localM);
         if (!shader) {
             break;
         }
         pnt.setShader(std::move(shader));
 
         if (colors) {
             pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], mode));
         }
-        
+
         path.rewind();
         path.addPoly(quad, 4, true);
         path.setConvexity(SkPath::kConvex_Convexity);
         this->drawPath(draw, path, pnt, nullptr, true);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
@@ skipping 53 matching lines @@
         pmap = &tempStorage;
     }
     return this->onPeekPixels(pmap);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 static void morphpoints(SkPoint dst[], const SkPoint src[], int count,
                         SkPathMeasure& meas, const SkMatrix& matrix) {
     SkMatrix::MapXYProc proc = matrix.getMapXYProc();
-    
+
     for (int i = 0; i < count; i++) {
         SkPoint pos;
         SkVector tangent;
-        
+
         proc(matrix, src[i].fX, src[i].fY, &pos);
         SkScalar sx = pos.fX;
         SkScalar sy = pos.fY;
-        
+
         if (!meas.getPosTan(sx, &pos, &tangent)) {
             // set to 0 if the measure failed, so that we just set dst == pos
             tangent.set(0, 0);
         }
-        
+
         /*  This is the old way (that explains our approach but is way too slow
          SkMatrix    matrix;
          SkPoint     pt;
-         
+
          pt.set(sx, sy);
          matrix.setSinCos(tangent.fY, tangent.fX);
          matrix.preTranslate(-sx, 0);
          matrix.postTranslate(pos.fX, pos.fY);
          matrix.mapPoints(&dst[i], &pt, 1);
          */
         dst[i].set(pos.fX - SkScalarMul(tangent.fY, sy),
                    pos.fY + SkScalarMul(tangent.fX, sy));
     }
 }
 
 /*  TODO
- 
+
  Need differentially more subdivisions when the follow-path is curvy. Not sure how to
  determine that, but we need it. I guess a cheap answer is let the caller tell us,
  but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
  */
 static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas,
                       const SkMatrix& matrix) {
     SkPath::Iter    iter(src, false);
     SkPoint         srcP[4], dstP[3];
     SkPath::Verb    verb;
-    
+
     while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kMove_Verb:
                 morphpoints(dstP, srcP, 1, meas, matrix);
                 dst->moveTo(dstP[0]);
                 break;
             case SkPath::kLine_Verb:
                 // turn lines into quads to look bendy
                 srcP[0].fX = SkScalarAve(srcP[0].fX, srcP[1].fX);
                 srcP[0].fY = SkScalarAve(srcP[0].fY, srcP[1].fY);
@@ skipping 15 matching lines @@
                 SkDEBUGFAIL("unknown verb");
                 break;
         }
     }
 }
 
 void SkBaseDevice::drawTextOnPath(const SkDraw& draw, const void* text, size_t byteLength,
                                   const SkPath& follow, const SkMatrix* matrix,
                                   const SkPaint& paint) {
     SkASSERT(byteLength == 0 || text != nullptr);
-    
+
     // nothing to draw
     if (text == nullptr || byteLength == 0 || draw.fRC->isEmpty()) {
         return;
     }
-    
+
     SkTextToPathIter    iter((const char*)text, byteLength, paint, true);
     SkPathMeasure       meas(follow, false);
     SkScalar            hOffset = 0;
-    
+
     // need to measure first
     if (paint.getTextAlign() != SkPaint::kLeft_Align) {
         SkScalar pathLen = meas.getLength();
         if (paint.getTextAlign() == SkPaint::kCenter_Align) {
             pathLen = SkScalarHalf(pathLen);
         }
         hOffset += pathLen;
     }
-    
+
     const SkPath*   iterPath;
     SkScalar        xpos;
     SkMatrix        scaledMatrix;
     SkScalar        scale = iter.getPathScale();
-    
+
     scaledMatrix.setScale(scale, scale);
-    
+
     while (iter.next(&iterPath, &xpos)) {
         if (iterPath) {
             SkPath      tmp;
             SkMatrix    m(scaledMatrix);
-            
+
             tmp.setIsVolatile(true);
             m.postTranslate(xpos + hOffset, 0);
             if (matrix) {
                 m.postConcat(*matrix);
             }
             morphpath(&tmp, *iterPath, meas, m);
             this->drawPath(draw, tmp, iter.getPaint(), nullptr, true);
         }
     }
 }
@@ skipping 48 matching lines @@
         flags &= ~SkPaint::kLCDRenderText_Flag;
         flags |= SkPaint::kGenA8FromLCD_Flag;
     }
 
     return flags;
 }
 
 sk_sp<SkSurface> SkBaseDevice::makeSurface(SkImageInfo const&, SkSurfaceProps const&) {
     return nullptr;
 }