Style bikeshed - remove extraneous whitespace

tools/sk_tool_utils.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "sk_tool_utils.h"
 #include "sk_tool_utils_flags.h"
 
@@ skipping 73 matching lines @@
         tf->reset(SkTypeface::CreateFromName("Apple Color Emoji", SkTypeface::kNormal));
         return;
     }
     tf->reset(nullptr);
     return;
 }
 
 const char* emoji_sample_text() {
     if (!strcmp(sk_tool_utils::platform_os_emoji(), "CBDT")) {
         return "Hamburgefons";
-    } 
+    }
     if (!strcmp(sk_tool_utils::platform_os_emoji(), "SBIX")) {
         return "\xF0\x9F\x92\xB0" "\xF0\x9F\x8F\xA1" "\xF0\x9F\x8E\x85"  // 💰🏡🎅
                "\xF0\x9F\x8D\xAA" "\xF0\x9F\x8D\x95" "\xF0\x9F\x9A\x80"  // 🍪🍕🚀
                "\xF0\x9F\x9A\xBB" "\xF0\x9F\x92\xA9" "\xF0\x9F\x93\xB7" // 🚻💩📷
                "\xF0\x9F\x93\xA6" // 📦
                "\xF0\x9F\x87\xBA" "\xF0\x9F\x87\xB8" "\xF0\x9F\x87\xA6"; // 🇺🇸🇦
     }
     return "";
 }
 
@@ skipping 55 matching lines @@
 }
 
 SkTypeface* create_portable_typeface(const char* name, SkTypeface::Style style) {
     return create_font(name, style);
 }
 
 void set_portable_typeface(SkPaint* paint, const char* name, SkTypeface::Style style) {
     SkTypeface* face = create_font(name, style);
     SkSafeUnref(paint->setTypeface(face));
 }
-    
+
 void write_pixels(SkCanvas* canvas, const SkBitmap& bitmap, int x, int y,
                   SkColorType colorType, SkAlphaType alphaType) {
     SkBitmap tmp(bitmap);
     tmp.lockPixels();
 
     const SkImageInfo info = SkImageInfo::Make(tmp.width(), tmp.height(), colorType, alphaType);
 
     canvas->writePixels(info, tmp.getPixels(), tmp.rowBytes(), x, y);
 }
 
@@ skipping 68 matching lines @@
     const SkPoint center = SkPoint::Make(dst.fLeft + (dst.width() / 2.0f),
                                          dst.fTop + (dst.height() / 2.0f));
     const SkPoint halfSize = SkPoint::Make(dst.width() / 2.0f, dst.height() / 2.0f);
 
     SkVector3 norm;
 
     for (int y = dst.fTop; y < dst.fBottom; ++y) {
         for (int x = dst.fLeft; x < dst.fRight; ++x) {
             norm.fX = (x + 0.5f - center.fX) / halfSize.fX;
             norm.fY = (y + 0.5f - center.fY) / halfSize.fY;
-            
+
             SkScalar tmp = norm.fX * norm.fX + norm.fY * norm.fY;
             if (tmp >= 1.0f) {
                 norm.set(0.0f, 0.0f, 1.0f);
             } else {
                 norm.fZ = sqrtf(1.0f - tmp);
             }
 
             norm_to_rgb(bm, x, y, norm);
         }
     }
@@ skipping 18 matching lines @@
                 norm.set(0.0f, 0.0f, 1.0f);
             } else {
                 SkScalar locX = x + 0.5f - center.fX;
                 SkScalar locY = y + 0.5f - center.fY;
 
                 if (locX >= 0.0f) {
                     if (locY > 0.0f) {
                         norm = locX >= locY ? right : down;   // LR corner
                     } else {
                         norm = locX > -locY ? right : up;     // UR corner
-                    }    
+                    }
                 } else {
                     if (locY > 0.0f) {
                         norm = -locX > locY ? left : down;    // LL corner
                     } else {
                         norm = locX > locY ? up : left;       // UL corner
-                    }    
+                    }
                 }
             }
 
             norm_to_rgb(bm, x, y, norm);
         }
     }
 }
 
 void create_tetra_normal_map(SkBitmap* bm, const SkIRect& dst) {
     const SkPoint center = SkPoint::Make(dst.fLeft + (dst.width() / 2.0f),
                                          dst.fTop + (dst.height() / 2.0f));
 
     static const SkScalar k1OverRoot3 = 0.5773502692f;
 
     SkPoint3 norm;
     const SkPoint3 leftUp =  SkPoint3::Make(-k1OverRoot3, -k1OverRoot3, k1OverRoot3);
     const SkPoint3 rightUp = SkPoint3::Make(k1OverRoot3,  -k1OverRoot3, k1OverRoot3);
     const SkPoint3 down =  SkPoint3::Make(0.0f,  SK_ScalarRoot2Over2, SK_ScalarRoot2Over2);
 
     for (int y = dst.fTop; y < dst.fBottom; ++y) {
         for (int x = dst.fLeft; x < dst.fRight; ++x) {
             SkScalar locX = x + 0.5f - center.fX;
             SkScalar locY = y + 0.5f - center.fY;
 
             if (locX >= 0.0f) {
                 if (locY > 0.0f) {
                     norm = locX >= locY ? rightUp : down;   // LR corner
                 } else {
                     norm = rightUp;
-                }    
+                }
             } else {
                 if (locY > 0.0f) {
                     norm = -locX > locY ? leftUp : down;    // LL corner
                 } else {
                     norm = leftUp;
-                }    
+                }
             }
 
             norm_to_rgb(bm, x, y, norm);
         }
     }
 }
 
 void make_big_path(SkPath& path) {
     #include "BigPathBench.inc"
 }
@@ skipping 81 matching lines @@
     dst.allocN32Pixels(src.width(), src.height(), true);
 
     int wh;
     SkAutoTDeleteArray<float> kernel(create_2d_kernel(sigma, &wh));
 
     for (int y = 0; y < src.height(); ++y) {
         for (int x = 0; x < src.width(); ++x) {
             *dst.getAddr32(x, y) = blur_pixel(src, x, y, kernel.get(), wh);
         }
     }
- 
+
     return dst;
 }
 
 }  // namespace sk_tool_utils