code style

git-svn-id: http://skia.googlecode.com/svn/trunk@1160 2bbb7eff-a529-9590-31e7-b0007b416f81

13 files changed, 363 insertions, 351 deletions

diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp
index 27d765f07a..158cefaf5e 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -28,8 +28,8 @@ SkCornerPathEffect::~SkCornerPathEffect()
 {
 }
 
-static bool ComputeStep(const SkPoint& a, const SkPoint& b, SkScalar radius, SkPoint* step)
-{
+static bool ComputeStep(const SkPoint& a, const SkPoint& b, SkScalar radius,
+                        SkPoint* step) {
     SkScalar dist = SkPoint::Distance(a, b);
 
     step->set(b.fX - a.fX, b.fY - a.fY);
@@ -37,17 +37,17 @@ static bool ComputeStep(const SkPoint& a, const SkPoint& b, SkScalar radius, SkP
     if (dist <= radius * 2) {
         step->scale(SK_ScalarHalf);
         return false;
-    }
-    else {
+    } else {
         step->scale(SkScalarDiv(radius, dist));
         return true;
     }
 }
 
-bool SkCornerPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
-{
-    if (fRadius == 0)
+bool SkCornerPathEffect::filterPath(SkPath* dst, const SkPath& src,
+                                    SkScalar* width) {
+    if (fRadius == 0) {
         return false;
+    }
 
     SkPath::Iter    iter(src, false);
     SkPath::Verb    verb, prevVerb = (SkPath::Verb)-1;
@@ -65,97 +65,91 @@ bool SkCornerPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* wi
 
     for (;;) {
         switch (verb = iter.next(pts)) {
-        case SkPath::kMove_Verb:
-                // close out the previous (open) contour
-            if (SkPath::kLine_Verb == prevVerb) {
-                dst->lineTo(lastCorner);
-            }
-            closed = iter.isClosedContour();
-            if (closed) {
-                moveTo = pts[0];
-                prevIsValid = false;
-            }
-            else {
-                dst->moveTo(pts[0]);
-                prevIsValid = true;
-            }
-            break;
-        case SkPath::kLine_Verb:
-            {
+            case SkPath::kMove_Verb:
+                    // close out the previous (open) contour
+                if (SkPath::kLine_Verb == prevVerb) {
+                    dst->lineTo(lastCorner);
+                }
+                closed = iter.isClosedContour();
+                if (closed) {
+                    moveTo = pts[0];
+                    prevIsValid = false;
+                } else {
+                    dst->moveTo(pts[0]);
+                    prevIsValid = true;
+                }
+                break;
+            case SkPath::kLine_Verb: {
                 bool drawSegment = ComputeStep(pts[0], pts[1], fRadius, &step);
                 // prev corner
                 if (!prevIsValid) {
                     dst->moveTo(moveTo + step);
                     prevIsValid = true;
-                }
-                else {
-                    dst->quadTo(pts[0].fX, pts[0].fY, pts[0].fX + step.fX, pts[0].fY + step.fY);
+                } else {
+                    dst->quadTo(pts[0].fX, pts[0].fY, pts[0].fX + step.fX,
+                                pts[0].fY + step.fY);
                 }
                 if (drawSegment) {
                     dst->lineTo(pts[1].fX - step.fX, pts[1].fY - step.fY);
                 }
                 lastCorner = pts[1];
                 prevIsValid = true;
+                break;
             }
-            break;
-        case SkPath::kQuad_Verb:
-            // TBD - just replicate the curve for now
-            if (!prevIsValid)
-            {
-                dst->moveTo(pts[0]);
-                prevIsValid = true;
-            }
-            dst->quadTo(pts[1], pts[2]);
-            lastCorner = pts[2];
-            firstStep.set(0, 0);
-            break;
-        case SkPath::kCubic_Verb:
-            if (!prevIsValid)
-            {
-                dst->moveTo(pts[0]);
-                prevIsValid = true;
-            }
-            // TBD - just replicate the curve for now
-            dst->cubicTo(pts[1], pts[2], pts[3]);
-            lastCorner = pts[3];
-            firstStep.set(0, 0);
-            break;
-        case SkPath::kClose_Verb:
-            if (firstStep.fX || firstStep.fY)
-                dst->quadTo(lastCorner.fX, lastCorner.fY,
-                            lastCorner.fX + firstStep.fX,
-                            lastCorner.fY + firstStep.fY);
-            dst->close();
-            break;
-        case SkPath::kDone_Verb:
-            goto DONE;
+            case SkPath::kQuad_Verb:
+                // TBD - just replicate the curve for now
+                if (!prevIsValid) {
+                    dst->moveTo(pts[0]);
+                    prevIsValid = true;
+                }
+                dst->quadTo(pts[1], pts[2]);
+                lastCorner = pts[2];
+                firstStep.set(0, 0);
+                break;
+            case SkPath::kCubic_Verb:
+                if (!prevIsValid) {
+                    dst->moveTo(pts[0]);
+                    prevIsValid = true;
+                }
+                // TBD - just replicate the curve for now
+                dst->cubicTo(pts[1], pts[2], pts[3]);
+                lastCorner = pts[3];
+                firstStep.set(0, 0);
+                break;
+            case SkPath::kClose_Verb:
+                if (firstStep.fX || firstStep.fY) {
+                    dst->quadTo(lastCorner.fX, lastCorner.fY,
+                                lastCorner.fX + firstStep.fX,
+                                lastCorner.fY + firstStep.fY);
+                    }
+                dst->close();
+                break;
+            case SkPath::kDone_Verb:
+                goto DONE;
         }
 
-        if (SkPath::kMove_Verb == prevVerb)
+        if (SkPath::kMove_Verb == prevVerb) {
             firstStep = step;
+        }
         prevVerb = verb;
     }
 DONE:
     return true;
 }
 
-SkFlattenable::Factory SkCornerPathEffect::getFactory()
-{
+SkFlattenable::Factory SkCornerPathEffect::getFactory() {
     return CreateProc;
 }
 
-void SkCornerPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkCornerPathEffect::flatten(SkFlattenableWriteBuffer& buffer) {
     buffer.writeScalar(fRadius);
 }
 
-SkFlattenable* SkCornerPathEffect::CreateProc(SkFlattenableReadBuffer& buffer)
-{
+SkFlattenable* SkCornerPathEffect::CreateProc(SkFlattenableReadBuffer& buffer) {
     return SkNEW_ARGS(SkCornerPathEffect, (buffer));
 }
 
-SkCornerPathEffect::SkCornerPathEffect(SkFlattenableReadBuffer& buffer)
-{
+SkCornerPathEffect::SkCornerPathEffect(SkFlattenableReadBuffer& buffer) {
     fRadius = buffer.readScalar();
 }
 
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 48581b54b9..82f357c7c5 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -19,24 +19,24 @@
 #include "SkBuffer.h"
 #include "SkPathMeasure.h"
 
-static inline int is_even(int x)
-{
+static inline int is_even(int x) {
     return (~x) << 31;
 }
 
-static SkScalar FindFirstInterval(const SkScalar intervals[], SkScalar phase, int32_t* index)
-{
+static SkScalar FindFirstInterval(const SkScalar intervals[], SkScalar phase,
+                                  int32_t* index) {
     int i;
 
-    for (i = 0; phase > intervals[i]; i++)
+    for (i = 0; phase > intervals[i]; i++) {
         phase -= intervals[i];
+    }
     *index = i;
     return intervals[i] - phase;
 }
 
-SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count, SkScalar phase, bool scaleToFit)
-    : fScaleToFit(scaleToFit)
-{
+SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count,
+                                   SkScalar phase, bool scaleToFit)
+        : fScaleToFit(scaleToFit) {
     SkASSERT(intervals);
     SkASSERT(count > 1 && SkAlign2(count) == count);
 
@@ -44,46 +44,44 @@ SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count, SkScal
     fCount = count;
 
     SkScalar len = 0;
-    for (int i = 0; i < count; i++)
-    {
+    for (int i = 0; i < count; i++) {
         SkASSERT(intervals[i] >= 0);
         fIntervals[i] = intervals[i];
         len += intervals[i];
     }
     fIntervalLength = len;
 
-    if (len > 0)    // we don't handle 0 length dash arrays
-    {
-        if (phase < 0)
-        {
+    if (len > 0) {  // we don't handle 0 length dash arrays
+        if (phase < 0) {
             phase = -phase;
-            if (phase > len)
+            if (phase > len) {
                 phase = SkScalarMod(phase, len);
+            }
             phase = len - phase;
-        }
-        else if (phase >= len)
+        } else if (phase >= len) {
             phase = SkScalarMod(phase, len);
+        }
 
         SkASSERT(phase >= 0 && phase < len);
         fInitialDashLength = FindFirstInterval(intervals, phase, &fInitialDashIndex);
 
         SkASSERT(fInitialDashLength >= 0);
         SkASSERT(fInitialDashIndex >= 0 && fInitialDashIndex < fCount);
-    }
-    else
+    } else {
         fInitialDashLength = -1;    // signal bad dash intervals
+    }
 }
 
-SkDashPathEffect::~SkDashPathEffect()
-{
+SkDashPathEffect::~SkDashPathEffect() {
     sk_free(fIntervals);
 }
 
-bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
-{
+bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
+                                  SkScalar* width) {
     // we do nothing if the src wants to be filled, or if our dashlength is 0
-    if (*width < 0 || fInitialDashLength < 0)
+    if (*width < 0 || fInitialDashLength < 0) {
         return false;
+    }
 
     SkPathMeasure   meas(src, false);
     const SkScalar* intervals = fIntervals;
@@ -95,12 +93,10 @@ bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* widt
         int         index = fInitialDashIndex;
         SkScalar    scale = SK_Scalar1;
 
-        if (fScaleToFit)
-        {
-            if (fIntervalLength >= length)
+        if (fScaleToFit) {
+            if (fIntervalLength >= length) {
                 scale = SkScalarDiv(length, fIntervalLength);
-            else
-            {
+            } else {
                 SkScalar div = SkScalarDiv(length, fIntervalLength);
                 int n = SkScalarFloor(div);
                 scale = SkScalarDiv(length, n * fIntervalLength);
@@ -110,12 +106,10 @@ bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* widt
         SkScalar    distance = 0;
         SkScalar    dlen = SkScalarMul(fInitialDashLength, scale);
 
-        while (distance < length)
-        {
+        while (distance < length) {
             SkASSERT(dlen >= 0);
             addedSegment = false;
-            if (is_even(index) && dlen > 0 && !skipFirstSegment)
-            {
+            if (is_even(index) && dlen > 0 && !skipFirstSegment) {
                 addedSegment = true;
                 meas.getSegment(distance, distance + dlen, dst, true);
             }
@@ -127,27 +121,28 @@ bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* widt
             // wrap around our intervals array if necessary
             index += 1;
             SkASSERT(index <= fCount);
-            if (index == fCount)
+            if (index == fCount) {
                 index = 0;
+            }
 
             // fetch our next dlen
             dlen = SkScalarMul(intervals[index], scale);
         }
 
         // extend if we ended on a segment and we need to join up with the (skipped) initial segment
-        if (meas.isClosed() && is_even(fInitialDashIndex) && fInitialDashLength > 0)
+        if (meas.isClosed() && is_even(fInitialDashIndex) &&
+                fInitialDashLength > 0) {
             meas.getSegment(0, SkScalarMul(fInitialDashLength, scale), dst, !addedSegment);
+        }
     } while (meas.nextContour());
     return true;
 }
 
-SkFlattenable::Factory SkDashPathEffect::getFactory()
-{
+SkFlattenable::Factory SkDashPathEffect::getFactory() {
     return fInitialDashLength < 0 ? NULL : CreateProc;
 }
 
-void SkDashPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkDashPathEffect::flatten(SkFlattenableWriteBuffer& buffer) {
     SkASSERT(fInitialDashLength >= 0);
 
     buffer.write32(fCount);
@@ -158,13 +153,11 @@ void SkDashPathEffect::flatten(SkFlattenableWriteBuffer& buffer)
     buffer.writeMul4(fIntervals, fCount * sizeof(fIntervals[0]));
 }
 
-SkFlattenable* SkDashPathEffect::CreateProc(SkFlattenableReadBuffer& buffer)
-{
+SkFlattenable* SkDashPathEffect::CreateProc(SkFlattenableReadBuffer& buffer) {
     return SkNEW_ARGS(SkDashPathEffect, (buffer));
 }
 
-SkDashPathEffect::SkDashPathEffect(SkFlattenableReadBuffer& buffer)
-{
+SkDashPathEffect::SkDashPathEffect(SkFlattenableReadBuffer& buffer) {
     fCount = buffer.readS32();
     fInitialDashIndex = buffer.readS32();
     fInitialDashLength = buffer.readScalar();
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index 62860455a3..3b8d48e7b5 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -20,8 +20,7 @@
 #include "SkPathMeasure.h"
 #include "SkRandom.h"
 
-static void Perterb(SkPoint* p, const SkVector& tangent, SkScalar scale)
-{
+static void Perterb(SkPoint* p, const SkVector& tangent, SkScalar scale) {
     SkVector normal = tangent;
     normal.rotateCCW();
     normal.setLength(scale);
@@ -34,8 +33,8 @@ SkDiscretePathEffect::SkDiscretePathEffect(SkScalar segLength, SkScalar deviatio
 {
 }
 
-bool SkDiscretePathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar* width)
-{
+bool SkDiscretePathEffect::filterPath(SkPath* dst, const SkPath& src,
+                                      SkScalar* width) {
     bool doFill = *width < 0;
 
     SkPathMeasure   meas(src, doFill);
@@ -48,58 +47,49 @@ bool SkDiscretePathEffect::filterPath(SkPath* dst, const SkPath& src, SkScalar*
     do {
         SkScalar    length = meas.getLength();
 
-        if (fSegLength * (2 + doFill) > length)
-        {
+        if (fSegLength * (2 + doFill) > length) {
             meas.getSegment(0, length, dst, true);  // to short for us to mangle
-        }
-        else
-        {
+        } else {
             int         n = SkScalarRound(SkScalarDiv(length, fSegLength));
             SkScalar    delta = length / n;
             SkScalar    distance = 0;
 
-            if (meas.isClosed())
-            {
+            if (meas.isClosed()) {
                 n -= 1;
                 distance += delta/2;
             }
             meas.getPosTan(distance, &p, &v);
             Perterb(&p, v, SkScalarMul(rand.nextSScalar1(), scale));
             dst->moveTo(p);
-            while (--n >= 0)
-            {
+            while (--n >= 0) {
                 distance += delta;
                 meas.getPosTan(distance, &p, &v);
                 Perterb(&p, v, SkScalarMul(rand.nextSScalar1(), scale));
                 dst->lineTo(p);
             }
-            if (meas.isClosed())
+            if (meas.isClosed()) {
                 dst->close();
+            }
         }
     } while (meas.nextContour());
     return true;
 }
 
-SkFlattenable::Factory SkDiscretePathEffect::getFactory()
-{
+SkFlattenable::Factory SkDiscretePathEffect::getFactory() {
     return CreateProc;
 }
 
-SkFlattenable* SkDiscretePathEffect::CreateProc(SkFlattenableReadBuffer& buffer)
-{
+SkFlattenable* SkDiscretePathEffect::CreateProc(SkFlattenableReadBuffer& buffer) {
     return SkNEW_ARGS(SkDiscretePathEffect, (buffer));
 }
 
-void SkDiscretePathEffect::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkDiscretePathEffect::flatten(SkFlattenableWriteBuffer& buffer) {
     buffer.writeScalar(fSegLength);
     buffer.writeScalar(fPerterb);
 }
 
-SkDiscretePathEffect::SkDiscretePathEffect(SkFlattenableReadBuffer& buffer)
-{
+SkDiscretePathEffect::SkDiscretePathEffect(SkFlattenableReadBuffer& buffer) {
     fSegLength = buffer.readScalar();
     fPerterb = buffer.readScalar();
 }
 
-
diff --git a/src/effects/SkEmbossMask.cpp b/src/effects/SkEmbossMask.cpp
index fd11f543b0..742ccd23d6 100644
--- a/src/effects/SkEmbossMask.cpp
+++ b/src/effects/SkEmbossMask.cpp
@@ -17,8 +17,7 @@
 
 #include "SkEmbossMask.h"
 
-static inline int nonzero_to_one(int x)
-{
+static inline int nonzero_to_one(int x) {
 #if 0
     return x != 0;
 #else
@@ -26,8 +25,7 @@ static inline int nonzero_to_one(int x)
 #endif
 }
 
-static inline int neq_to_one(int x, int max)
-{
+static inline int neq_to_one(int x, int max) {
 #if 0
     return x != max;
 #else
@@ -36,8 +34,7 @@ static inline int neq_to_one(int x, int max)
 #endif
 }
 
-static inline int neq_to_mask(int x, int max)
-{
+static inline int neq_to_mask(int x, int max) {
 #if 0
     return -(x != max);
 #else
@@ -46,8 +43,7 @@ static inline int neq_to_mask(int x, int max)
 #endif
 }
 
-static inline unsigned div255(unsigned x)
-{
+static inline unsigned div255(unsigned x) {
     SkASSERT(x <= (255*255));
     return x * ((1 << 24) / 255) >> 24;
 }
@@ -60,28 +56,27 @@ static inline unsigned div255(unsigned x)
 
 #include <stdio.h>
 
-void SkEmbossMask_BuildTable()
-{
+void SkEmbossMask_BuildTable() {
     // build it 0..127 x 0..127, so we use 2^15 - 1 in the numerator for our "fixed" table
 
     FILE* file = ::fopen("SkEmbossMask_Table.h", "w");
     SkASSERT(file);
     ::fprintf(file, "#include \"SkTypes.h\"\n\n");
     ::fprintf(file, "static const U16 gInvSqrtTable[128 * 128] = {\n");
-    for (int dx = 0; dx <= 255/2; dx++)
-    {
-        for (int dy = 0; dy <= 255/2; dy++)
-        {
+    for (int dx = 0; dx <= 255/2; dx++) {
+        for (int dy = 0; dy <= 255/2; dy++) {
             if ((dy & 15) == 0)
                 ::fprintf(file, "\t");
 
             uint16_t value = SkToU16((1 << 15) / SkSqrt32(dx * dx + dy * dy + kDelta*kDelta/4));
 
             ::fprintf(file, "0x%04X", value);
-            if (dx * 128 + dy < 128*128-1)
+            if (dx * 128 + dy < 128*128-1) {
                 ::fprintf(file, ", ");
-            if ((dy & 15) == 15)
+            }
+            if ((dy & 15) == 15) {
                 ::fprintf(file, "\n");
+            }
         }
     }
     ::fprintf(file, "};\n#define kDeltaUsedToBuildTable\t%d\n", kDelta);
@@ -90,8 +85,7 @@ void SkEmbossMask_BuildTable()
 
 #endif
 
-void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
-{
+void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light) {
     SkASSERT(kDelta == kDeltaUsedToBuildTable);
 
     SkASSERT(mask->fFormat == SkMask::k3D_Format);
@@ -114,14 +108,11 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
     int maxx = mask->fBounds.width() - 1;
 
     int prev_row = 0;
-    for (int y = 0; y <= maxy; y++)
-    {
+    for (int y = 0; y <= maxy; y++) {
         int next_row = neq_to_mask(y, maxy) & rowBytes;
 
-        for (int x = 0; x <= maxx; x++)
-        {
-            if (alpha[x])
-            {
+        for (int x = 0; x <= maxx; x++) {
+            if (alpha[x]) {
                 int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
                 int ny = alpha[x + next_row] - alpha[x - prev_row];
 
@@ -129,8 +120,7 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
                 int     mul = ambient;
                 int     add = 0;
 
-                if (numer > 0)  // preflight when numer/denom will be <= 0
-                {
+                if (numer > 0) {  // preflight when numer/denom will be <= 0
 #if 0
                     int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
                     SkFixed dot = numer / denom;
@@ -150,8 +140,7 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
                     //  hilite = R * Eye(0, 0, 1)
 
                     int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
-                    if (hilite > 0)
-                    {
+                    if (hilite > 0) {
                         // pin hilite to 255, since our fast math is also a little sloppy
                         hilite = SkClampMax(hilite, 255);
 
@@ -160,8 +149,9 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
                         // and then possibly cache a 256 table for a given specular
                         // value in the light, and just pass that in to this function.
                         add = hilite;
-                        for (int i = specular >> 4; i > 0; --i)
+                        for (int i = specular >> 4; i > 0; --i) {
                             add = div255(add * hilite);
+                        }
                     }
                 }
                 multiply[x] = SkToU8(mul);
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index 9d585ff3a7..51c19b24a7 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -21,22 +21,27 @@
 #include "SkEmbossMask.h"
 #include "SkBuffer.h"
 
+static inline int pin2byte(int n) {
+    if (n < 0) {
+        n = 0;
+    } else if (n > 0xFF) {
+        n = 0xFF;
+    }
+    return n;
+}
+
 SkMaskFilter* SkBlurMaskFilter::CreateEmboss(const SkScalar direction[3],
                                              SkScalar ambient, SkScalar specular,
-                                             SkScalar blurRadius)
-{
-    if (direction == NULL)
+                                             SkScalar blurRadius) {
+    if (direction == NULL) {
         return NULL;
+    }
 
     // ambient should be 0...1 as a scalar
-    int am = SkScalarToFixed(ambient) >> 8;
-    if (am < 0) am = 0;
-    else if (am > 0xFF) am = 0xFF;
+    int am = pin2byte(SkScalarToFixed(ambient) >> 8);
 
     // specular should be 0..15.99 as a scalar
-    int sp = SkScalarToFixed(specular) >> 12;
-    if (sp < 0) sp = 0;
-    else if (sp > 0xFF) sp = 0xFF;
+    int sp = pin2byte(SkScalarToFixed(specular) >> 12);
 
     SkEmbossMaskFilter::Light   light;
     
@@ -47,41 +52,43 @@ SkMaskFilter* SkBlurMaskFilter::CreateEmboss(const SkScalar direction[3],
     return SkNEW_ARGS(SkEmbossMaskFilter, (light, blurRadius));
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
-static void normalize(SkScalar v[3])
-{
+static void normalize(SkScalar v[3]) {
     SkScalar mag = SkScalarSquare(v[0]) + SkScalarSquare(v[1]) + SkScalarSquare(v[2]);
     mag = SkScalarSqrt(mag);
 
-    for (int i = 0; i < 3; i++)
+    for (int i = 0; i < 3; i++) {
         v[i] = SkScalarDiv(v[i], mag);
+    }
 }
 
 SkEmbossMaskFilter::SkEmbossMaskFilter(const Light& light, SkScalar blurRadius)
-        : fLight(light), fBlurRadius(blurRadius)
-{
+        : fLight(light), fBlurRadius(blurRadius) {
     normalize(fLight.fDirection);
 }
 
-SkMask::Format SkEmbossMaskFilter::getFormat()
-{
+SkMask::Format SkEmbossMaskFilter::getFormat() {
     return SkMask::k3D_Format;
 }
 
-bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatrix& matrix, SkIPoint* margin)
-{
+bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src,
+                                    const SkMatrix& matrix, SkIPoint* margin) {
     SkScalar radius = matrix.mapRadius(fBlurRadius);
 
-    if (!SkBlurMask::Blur(dst, src, radius, SkBlurMask::kInner_Style, SkBlurMask::kLow_Quality))
+    if (!SkBlurMask::Blur(dst, src, radius, SkBlurMask::kInner_Style,
+                          SkBlurMask::kLow_Quality)) {
         return false;
+    }
 
     dst->fFormat = SkMask::k3D_Format;
-    if (margin)
+    if (margin) {
         margin->set(SkScalarCeil(radius), SkScalarCeil(radius));
+    }
 
-    if (src.fImage == NULL)
+    if (src.fImage == NULL) {
         return true;
+    }
 
     // create a larger buffer for the other two channels (should force fBlur to do this for us)
 
@@ -98,7 +105,8 @@ bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatr
 
     // run the light direction through the matrix...
     Light   light = fLight;
-    matrix.mapVectors((SkVector*)(void*)light.fDirection, (SkVector*)(void*)fLight.fDirection, 1);
+    matrix.mapVectors((SkVector*)(void*)light.fDirection,
+                      (SkVector*)(void*)fLight.fDirection, 1);
 
     // now restore the length of the XY component
     // cast to SkVector so we can call setLength (this double cast silences alias warnings)
@@ -115,25 +123,22 @@ bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatr
     return true;
 }
 
-SkFlattenable* SkEmbossMaskFilter::CreateProc(SkFlattenableReadBuffer& buffer)
-{
+SkFlattenable* SkEmbossMaskFilter::CreateProc(SkFlattenableReadBuffer& buffer) {
     return SkNEW_ARGS(SkEmbossMaskFilter, (buffer));
 }
 
-SkFlattenable::Factory SkEmbossMaskFilter::getFactory()
-{
+SkFlattenable::Factory SkEmbossMaskFilter::getFactory() {
     return CreateProc;
 }
 
-SkEmbossMaskFilter::SkEmbossMaskFilter(SkFlattenableReadBuffer& buffer) : SkMaskFilter(buffer)
-{
+SkEmbossMaskFilter::SkEmbossMaskFilter(SkFlattenableReadBuffer& buffer)
+        : SkMaskFilter(buffer) {
     buffer.read(&fLight, sizeof(fLight));
     SkASSERT(fLight.fPad == 0); // for the font-cache lookup to be clean
     fBlurRadius = buffer.readScalar();
 }
 
-void SkEmbossMaskFilter::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkEmbossMaskFilter::flatten(SkFlattenableWriteBuffer& buffer) {
     this->INHERITED::flatten(buffer);
 
     fLight.fPad = 0;    // for the font-cache lookup to be clean
diff --git a/src/effects/SkKernel33MaskFilter.cpp b/src/effects/SkKernel33MaskFilter.cpp
index 429e1207be..5051f71305 100644
--- a/src/effects/SkKernel33MaskFilter.cpp
+++ b/src/effects/SkKernel33MaskFilter.cpp
@@ -1,21 +1,21 @@
 #include "SkKernel33MaskFilter.h"
 #include "SkColorPriv.h"
 
-SkMask::Format SkKernel33ProcMaskFilter::getFormat()
-{
+SkMask::Format SkKernel33ProcMaskFilter::getFormat() {
     return SkMask::kA8_Format;
 }
 
-bool SkKernel33ProcMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, SkIPoint* margin)
-{
+bool SkKernel33ProcMaskFilter::filterMask(SkMask* dst, const SkMask& src,
+                                          const SkMatrix&, SkIPoint* margin) {
     // margin???
     dst->fImage = NULL;
     dst->fBounds = src.fBounds;
     dst->fBounds.inset(-1, -1);
     dst->fFormat = SkMask::kA8_Format;
     
-    if (NULL == src.fImage)
+    if (NULL == src.fImage) {
         return true;
+    }
     
     dst->fRowBytes = dst->fBounds.width();
     size_t size = dst->computeImageSize();
@@ -39,28 +39,26 @@ bool SkKernel33ProcMaskFilter::filterMask(SkMask* dst, const SkMask& src, const
 
     unsigned scale = fPercent256;
     
-    for (int y = -1; y <= h; y++)
-    {
+    for (int y = -1; y <= h; y++) {
         uint8_t* dstRow = dstImage;
-        for (int x = -1; x <= w; x++)
-        {
+        for (int x = -1; x <= w; x++) {
             memset(storage, 0, sizeof(storage));
             uint8_t* storagePtr = &storage[0][0];
 
-            for (int ky = y - 1; ky <= y + 1; ky++)
-            {
+            for (int ky = y - 1; ky <= y + 1; ky++) {
                 const uint8_t* srcRow = srcImage + ky * srcRB;  // may be out-of-range
-                for (int kx = x - 1; kx <= x + 1; kx++)
-                {
-                    if ((unsigned)ky < (unsigned)h && (unsigned)kx < (unsigned)w)
+                for (int kx = x - 1; kx <= x + 1; kx++) {
+                    if ((unsigned)ky < (unsigned)h && (unsigned)kx < (unsigned)w) {
                         *storagePtr = srcRow[kx];
+                    }
                     storagePtr++;
                 }
             }            
             int value = this->computeValue(srcRows);
             
-            if (scale < 256)
+            if (scale < 256) {
                 value = SkAlphaBlend(value, srcRows[1][1], scale);
+            }
             *dstRow++ = SkToU8(value);
         }
         dstImage += dst->fRowBytes;
@@ -68,57 +66,53 @@ bool SkKernel33ProcMaskFilter::filterMask(SkMask* dst, const SkMask& src, const
     return true;
 }
 
-void SkKernel33ProcMaskFilter::flatten(SkFlattenableWriteBuffer& wb)
-{
+void SkKernel33ProcMaskFilter::flatten(SkFlattenableWriteBuffer& wb) {
     this->INHERITED::flatten(wb);
     wb.write32(fPercent256);
 }
 
 SkKernel33ProcMaskFilter::SkKernel33ProcMaskFilter(SkFlattenableReadBuffer& rb)
-    : SkMaskFilter(rb)
-{
+        : SkMaskFilter(rb) {
     fPercent256 = rb.readS32();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-uint8_t SkKernel33MaskFilter::computeValue(uint8_t* const* srcRows)
-{
+uint8_t SkKernel33MaskFilter::computeValue(uint8_t* const* srcRows) {
     int value = 0;
 
-    for (int i = 0; i < 3; i++)
-        for (int j = 0; j < 3; j++)
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
             value += fKernel[i][j] * srcRows[i][j];
+        }
+    }
     
     value >>= fShift;
 
-    if (value < 0)
+    if (value < 0) {
         value = 0;
-    else if (value > 255)
+    } else if (value > 255) {
         value = 255;
+    }
     return (uint8_t)value;
 }
 
-void SkKernel33MaskFilter::flatten(SkFlattenableWriteBuffer& wb)
-{
+void SkKernel33MaskFilter::flatten(SkFlattenableWriteBuffer& wb) {
     this->INHERITED::flatten(wb);
     wb.writeMul4(fKernel, 9 * sizeof(int));
     wb.write32(fShift);
 }
 
-SkFlattenable::Factory SkKernel33MaskFilter::getFactory()
-{
+SkFlattenable::Factory SkKernel33MaskFilter::getFactory() {
     return Create;
 }
 
-SkFlattenable* SkKernel33MaskFilter::Create(SkFlattenableReadBuffer& rb)
-{
+SkFlattenable* SkKernel33MaskFilter::Create(SkFlattenableReadBuffer& rb) {
     return new SkKernel33MaskFilter(rb);
 }
 
 SkKernel33MaskFilter::SkKernel33MaskFilter(SkFlattenableReadBuffer& rb)
-    : SkKernel33ProcMaskFilter(rb)
-{
+        : SkKernel33ProcMaskFilter(rb) {
     rb.read(fKernel, 9 * sizeof(int));
     fShift = rb.readS32();
 }
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index 851f418d26..27683ef787 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -35,8 +35,7 @@ SkLayerRasterizer::SkLayerRasterizer() : fLayers(sizeof(SkLayerRasterizer_Rec))
 {
 }
 
-SkLayerRasterizer::~SkLayerRasterizer()
-{
+SkLayerRasterizer::~SkLayerRasterizer() {
     SkDeque::F2BIter        iter(fLayers);
     SkLayerRasterizer_Rec*  rec;
 
@@ -44,35 +43,34 @@ SkLayerRasterizer::~SkLayerRasterizer()
         rec->fPaint.~SkPaint();
 }
 
-void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx, SkScalar dy)
-{
+void SkLayerRasterizer::addLayer(const SkPaint& paint, SkScalar dx,
+                                 SkScalar dy) {
     SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
 
     new (&rec->fPaint) SkPaint(paint);
     rec->fOffset.set(dx, dy);
 }
 
-static bool compute_bounds(const SkDeque& layers, const SkPath& path, const SkMatrix& matrix,
-                           const SkIRect* clipBounds, SkIRect* bounds)
-{
+static bool compute_bounds(const SkDeque& layers, const SkPath& path,
+                           const SkMatrix& matrix,
+                           const SkIRect* clipBounds, SkIRect* bounds) {
     SkDeque::F2BIter        iter(layers);
     SkLayerRasterizer_Rec*  rec;
 
     bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
 
-    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
-    {
+    while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) {
         const SkPaint&  paint = rec->fPaint;
         SkPath          fillPath, devPath;
         const SkPath*   p = &path;
 
-        if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style)
-        {
+        if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
             paint.getFillPath(path, &fillPath);
             p = &fillPath;
         }
-        if (p->isEmpty())
+        if (p->isEmpty()) {
             continue;
+        }
 
         // apply the matrix and offset
         {
@@ -82,9 +80,11 @@ static bool compute_bounds(const SkDeque& layers, const SkPath& path, const SkMa
         }
 
         SkMask  mask;
-        if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(), &matrix,
-                                &mask, SkMask::kJustComputeBounds_CreateMode))
+        if (!SkDraw::DrawToMask(devPath, clipBounds, paint.getMaskFilter(),
+                                &matrix, &mask,
+                                SkMask::kJustComputeBounds_CreateMode)) {
             return false;
+        }
 
         bounds->join(mask.fBounds);
     }
@@ -93,19 +93,17 @@ static bool compute_bounds(const SkDeque& layers, const SkPath& path, const SkMa
 
 bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
                                     const SkIRect* clipBounds,
-                                    SkMask* mask, SkMask::CreateMode mode)
-{
-    if (fLayers.empty())
+                                    SkMask* mask, SkMask::CreateMode mode) {
+    if (fLayers.empty()) {
         return false;
+    }
 
-    if (SkMask::kJustRenderImage_CreateMode != mode)
-    {
+    if (SkMask::kJustRenderImage_CreateMode != mode) {
         if (!compute_bounds(fLayers, path, matrix, clipBounds, &mask->fBounds))
             return false;
     }
 
-    if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode)
-    {
+    if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
         mask->fFormat   = SkMask::kA8_Format;
         mask->fRowBytes = mask->fBounds.width();
         size_t size = mask->computeImageSize();
@@ -116,8 +114,7 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
         memset(mask->fImage, 0, size);
     }
 
-    if (SkMask::kJustComputeBounds_CreateMode != mode)
-    {
+    if (SkMask::kJustComputeBounds_CreateMode != mode) {
         SkBitmap device;
         SkDraw   draw;
         SkMatrix translatedMatrix;  // this translates us to our local pixels
@@ -153,14 +150,12 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix,
 
 /////////// Routines for flattening /////////////////
 
-static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer)
-{
+static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer) {
     paint->setAntiAlias(buffer.readBool());
     paint->setStyle((SkPaint::Style)buffer.readU8());
     paint->setAlpha(buffer.readU8());
 
-    if (paint->getStyle() != SkPaint::kFill_Style)
-    {
+    if (paint->getStyle() != SkPaint::kFill_Style) {
         paint->setStrokeWidth(buffer.readScalar());
         paint->setStrokeMiter(buffer.readScalar());
         paint->setStrokeCap((SkPaint::Cap)buffer.readU8());
@@ -173,14 +168,12 @@ static void paint_read(SkPaint* paint, SkFlattenableReadBuffer& buffer)
     SkSafeUnref(paint->setXfermode((SkXfermode*)buffer.readFlattenable()));
 }
 
-static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer)
-{
+static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer) {
     buffer.writeBool(paint.isAntiAlias());
     buffer.write8(paint.getStyle());
     buffer.write8(paint.getAlpha());
 
-    if (paint.getStyle() != SkPaint::kFill_Style)
-    {
+    if (paint.getStyle() != SkPaint::kFill_Style) {
         buffer.writeScalar(paint.getStrokeWidth());
         buffer.writeScalar(paint.getStrokeMiter());
         buffer.write8(paint.getStrokeCap());
@@ -194,12 +187,10 @@ static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer)
 }
 
 SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
-    : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec))
-{
+    : SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) {
     int count = buffer.readS32();
 
-    for (int i = 0; i < count; i++)
-    {
+    for (int i = 0; i < count; i++) {
         SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
 
 #if 0
@@ -213,8 +204,7 @@ SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
     }
 }
 
-void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) {
     this->INHERITED::flatten(buffer);
 
     buffer.write32(fLayers.count());
@@ -222,8 +212,7 @@ void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer)
     SkDeque::F2BIter                iter(fLayers);
     const SkLayerRasterizer_Rec*    rec;
 
-    while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL)
-    {
+    while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) {
 #if 0
         rec->fPaint.flatten(buffer);
 #else
@@ -234,13 +223,11 @@ void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer)
     }
 }
 
-SkFlattenable* SkLayerRasterizer::CreateProc(SkFlattenableReadBuffer& buffer)
-{
+SkFlattenable* SkLayerRasterizer::CreateProc(SkFlattenableReadBuffer& buffer) {
     return SkNEW_ARGS(SkLayerRasterizer, (buffer));
 }
 
-SkFlattenable::Factory SkLayerRasterizer::getFactory()
-{
+SkFlattenable::Factory SkLayerRasterizer::getFactory() {
     return CreateProc;
 }
 
diff --git a/src/effects/SkPaintFlagsDrawFilter.cpp b/src/effects/SkPaintFlagsDrawFilter.cpp
index 62eb53a13d..9b7cff1cf6 100644
--- a/src/effects/SkPaintFlagsDrawFilter.cpp
+++ b/src/effects/SkPaintFlagsDrawFilter.cpp
@@ -1,3 +1,19 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
 #include "SkPaintFlagsDrawFilter.h"
 #include "SkPaint.h"
 
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index a5599e2217..0fb0494d5a 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -1,36 +1,45 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
 #include "SkPixelXorXfermode.h"
 #include "SkColorPriv.h"
 
 // we always return an opaque color, 'cause I don't know what to do with
 // the alpha-component and still return a valid premultiplied color.
-SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst)
-{
+SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst) {
     SkPMColor res = src ^ dst ^ fOpColor;
     res |= (SK_A32_MASK << SK_A32_SHIFT);   // force it to be opaque
     return res;
 }
 
-void SkPixelXorXfermode::flatten(SkFlattenableWriteBuffer& wb)
-{
+void SkPixelXorXfermode::flatten(SkFlattenableWriteBuffer& wb) {
     this->INHERITED::flatten(wb);
     wb.write32(fOpColor);
 }
 
 SkPixelXorXfermode::SkPixelXorXfermode(SkFlattenableReadBuffer& rb)
-    : SkXfermode(rb)
-{
+        : SkXfermode(rb) {
     fOpColor = rb.readU32();
 }
 
-SkFlattenable::Factory SkPixelXorXfermode::getFactory()
-{
+SkFlattenable::Factory SkPixelXorXfermode::getFactory() {
     return Create;
 }
 
-SkFlattenable* SkPixelXorXfermode::Create(SkFlattenableReadBuffer& rb)
-{
+SkFlattenable* SkPixelXorXfermode::Create(SkFlattenableReadBuffer& rb) {
     return SkNEW_ARGS(SkPixelXorXfermode, (rb));
 }
 
-
-
diff --git a/src/effects/SkPorterDuff.cpp b/src/effects/SkPorterDuff.cpp
index 980ce29d23..fd3e1c02cd 100644
--- a/src/effects/SkPorterDuff.cpp
+++ b/src/effects/SkPorterDuff.cpp
@@ -1,3 +1,19 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
 #include "SkPorterDuff.h"
 #include "SkXfermode.h"
 
diff --git a/src/effects/SkRectShape.cpp b/src/effects/SkRectShape.cpp
index 8a38a1ebe8..47520f03ee 100644
--- a/src/effects/SkRectShape.cpp
+++ b/src/effects/SkRectShape.cpp
@@ -1,3 +1,19 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
 #include "SkRectShape.h"
 #include "SkCanvas.h"
 
diff --git a/src/effects/SkTableMaskFilter.cpp b/src/effects/SkTableMaskFilter.cpp
index aea939f1c9..8edbf7e401 100644
--- a/src/effects/SkTableMaskFilter.cpp
+++ b/src/effects/SkTableMaskFilter.cpp
@@ -1,3 +1,19 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
 #include "SkTableMaskFilter.h"
 
 SkTableMaskFilter::SkTableMaskFilter() {
diff --git a/src/effects/SkTransparentShader.cpp b/src/effects/SkTransparentShader.cpp
index 6b79839fe6..c6caba3165 100644
--- a/src/effects/SkTransparentShader.cpp
+++ b/src/effects/SkTransparentShader.cpp
@@ -20,63 +20,56 @@
 
 bool SkTransparentShader::setContext(const SkBitmap& device,
                                      const SkPaint& paint,
-                                     const SkMatrix& matrix)
-{
+                                     const SkMatrix& matrix) {
     fDevice = &device;
     fAlpha = paint.getAlpha();
 
     return this->INHERITED::setContext(device, paint, matrix);
 }
 
-uint32_t SkTransparentShader::getFlags()
-{
+uint32_t SkTransparentShader::getFlags() {
     uint32_t flags = this->INHERITED::getFlags();
 
     switch (fDevice->getConfig()) {
-    case SkBitmap::kRGB_565_Config:
-        flags |= kHasSpan16_Flag;
-        if (fAlpha == 255)
-            flags |= kOpaqueAlpha_Flag;
-        break;
-    case SkBitmap::kARGB_8888_Config:
-    case SkBitmap::kARGB_4444_Config:
-        if (fAlpha == 255 && fDevice->isOpaque())
-            flags |= kOpaqueAlpha_Flag;
-        break;
-    default:
-        break;
+        case SkBitmap::kRGB_565_Config:
+            flags |= kHasSpan16_Flag;
+            if (fAlpha == 255)
+                flags |= kOpaqueAlpha_Flag;
+            break;
+        case SkBitmap::kARGB_8888_Config:
+        case SkBitmap::kARGB_4444_Config:
+            if (fAlpha == 255 && fDevice->isOpaque())
+                flags |= kOpaqueAlpha_Flag;
+            break;
+        default:
+            break;
     }
     return flags;
 }
 
-void SkTransparentShader::shadeSpan(int x, int y, SkPMColor span[], int count)
-{
+void SkTransparentShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
     unsigned scale = SkAlpha255To256(fAlpha);
 
     switch (fDevice->getConfig()) {
-    case SkBitmap::kARGB_8888_Config:
-        if (scale == 256)
-            memcpy(span, fDevice->getAddr32(x, y), count * sizeof(SkPMColor));
-        else
-        {
-            const SkPMColor* src = fDevice->getAddr32(x, y);
-            for (int i = count - 1; i >= 0; --i)
-                span[i] = SkAlphaMulQ(src[i], scale);
-        }
-        break;
-    case SkBitmap::kRGB_565_Config:
-        {
+        case SkBitmap::kARGB_8888_Config:
+            if (scale == 256) {
+                memcpy(span, fDevice->getAddr32(x, y), count * sizeof(SkPMColor));
+            } else {
+                const SkPMColor* src = fDevice->getAddr32(x, y);
+                for (int i = count - 1; i >= 0; --i) {
+                    span[i] = SkAlphaMulQ(src[i], scale);
+                }
+            }
+            break;
+        case SkBitmap::kRGB_565_Config: {
             const uint16_t* src = fDevice->getAddr16(x, y);
-            if (scale == 256)
-            {
-                for (int i = count - 1; i >= 0; --i)
+            if (scale == 256) {
+                for (int i = count - 1; i >= 0; --i) {
                     span[i] = SkPixel16ToPixel32(src[i]);
-            }
-            else
-            {
+                }
+            } else {
                 unsigned alpha = fAlpha;
-                for (int i = count - 1; i >= 0; --i)
-                {
+                for (int i = count - 1; i >= 0; --i) {
                     uint16_t c = src[i];
                     unsigned r = SkPacked16ToR32(c);
                     unsigned g = SkPacked16ToG32(c);
@@ -88,55 +81,48 @@ void SkTransparentShader::shadeSpan(int x, int y, SkPMColor span[], int count)
                                             SkAlphaMul(b, scale));
                 }
             }
+            break;
         }
-        break;
-    case SkBitmap::kARGB_4444_Config:
-        {
+        case SkBitmap::kARGB_4444_Config: {
             const uint16_t* src = fDevice->getAddr16(x, y);
-            if (scale == 256)
-            {
-                for (int i = count - 1; i >= 0; --i)
+            if (scale == 256) {
+                for (int i = count - 1; i >= 0; --i) {
                     span[i] = SkPixel4444ToPixel32(src[i]);
-            }
-            else
-            {
+                }
+            } else {
                 unsigned scale16 = scale >> 4;
-                for (int i = count - 1; i >= 0; --i)
-                {
+                for (int i = count - 1; i >= 0; --i) {
                     uint32_t c = SkExpand_4444(src[i]) * scale16;
                     span[i] = SkCompact_8888(c);
                 }
             }
+            break;
         }
+        case SkBitmap::kIndex8_Config:
+            SkASSERT(!"index8 not supported as a destination device");
             break;
-            case SkBitmap::kIndex8_Config:
-        SkASSERT(!"index8 not supported as a destination device");
-        break;
-    case SkBitmap::kA8_Config:
-        {
+        case SkBitmap::kA8_Config: {
             const uint8_t* src = fDevice->getAddr8(x, y);
-            if (scale == 256)
-            {
-                for (int i = count - 1; i >= 0; --i)
+            if (scale == 256) {
+                for (int i = count - 1; i >= 0; --i) {
                     span[i] = SkPackARGB32(src[i], 0, 0, 0);
-            }
-            else
-            {
-                for (int i = count - 1; i >= 0; --i)
+                }
+            } else {
+                for (int i = count - 1; i >= 0; --i) {
                     span[i] = SkPackARGB32(SkAlphaMul(src[i], scale), 0, 0, 0);
+                }
             }
+            break;
         }
-        break;
-    case SkBitmap::kA1_Config:
-        SkASSERT(!"kA1_Config umimplemented at this time");
-        break;
-    default:    // to avoid warnings
-        break;
+        case SkBitmap::kA1_Config:
+            SkASSERT(!"kA1_Config umimplemented at this time");
+            break;
+        default:    // to avoid warnings
+            break;
     }
 }
 
-void SkTransparentShader::shadeSpan16(int x, int y, uint16_t span[], int count)
-{
+void SkTransparentShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
     SkASSERT(fDevice->getConfig() == SkBitmap::kRGB_565_Config);
 
     memcpy(span, fDevice->getAddr16(x, y), count << 1);