diff --git a/src/animator/SkAnimateActive.cpp b/src/animator/SkAnimateActive.cpp
index 4177aa0..00ee9df 100644
--- a/src/animator/SkAnimateActive.cpp
+++ b/src/animator/SkAnimateActive.cpp
@@ -22,7 +22,7 @@
     fMaxTime(0), fMaker(maker), fDrawIndex(0), fDrawMax(0) {
 }
 
-void SkActive::init() 
+void SkActive::init()
 {
     fAnimators = fApply.fAnimators;
     int animators = fAnimators.count();
@@ -98,7 +98,7 @@
                         saveIndex -= oldCount;
                         delete[] fSaveRestore[saveIndex];
                         fSaveRestore.remove(saveIndex);
-                        delete[] fSaveInterpolators[saveIndex]; 
+                        delete[] fSaveInterpolators[saveIndex];
                         fSaveInterpolators.remove(saveIndex);
                     } while (saveIndex > 0);
                 }
@@ -127,17 +127,17 @@
         SkASSERT(saveIndex >= 0);
         SkASSERT(newTotal >= 0);
         memmove(&fSaveRestore[newTotal], &fSaveRestore[saveIndex], oldCount);
-        memset(&fSaveRestore[newTotal + oldCount], 0, 
+        memset(&fSaveRestore[newTotal + oldCount], 0,
             sizeof(fSaveRestore[0]) * (newCount - oldCount));
-        memmove(&fSaveInterpolators[newTotal], 
+        memmove(&fSaveInterpolators[newTotal],
             &fSaveInterpolators[saveIndex], oldCount);
-        memset(&fSaveInterpolators[newTotal + oldCount], 0, 
+        memset(&fSaveInterpolators[newTotal + oldCount], 0,
             sizeof(fSaveRestore[0]) * (newCount - oldCount));
     } while (saveIndex > 0);
     SkASSERT(newTotal == 0);
 }
 
-void SkActive::calcDurations(int index) 
+void SkActive::calcDurations(int index)
 {
     SkAnimateBase* animate = fAnimators[index];
     SkMSec duration = animate->dur;
@@ -174,7 +174,7 @@
         if (animate->formula.size() > 0) {
             SkTDOperandArray values;
             values.setCount(count);
-            bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL, 
+            bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
                 animate->getValuesType(), animate->formula);
             SkASSERT(success);
             fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
@@ -212,7 +212,7 @@
             if (animate->formula.size() > 0) {
                 SkTDOperandArray values;
                 values.setCount(count);
-                bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL, 
+                bool success = animate->fFieldInfo->setValue(fMaker, &values, 0, 0, NULL,
                     animate->getValuesType(), animate->formula);
                 SkASSERT(success);
                 fApply.applyValues(index, values.begin(), count, animate->getValuesType(), time);
@@ -259,7 +259,7 @@
         memset(&fSaveRestore[oldCount], 0, sizeof(fSaveRestore[0]) * (activeTotal - oldCount));
         SkASSERT(fSaveInterpolators.count() == oldCount);
         fSaveInterpolators.setCount(activeTotal);
-        memset(&fSaveInterpolators[oldCount], 0, 
+        memset(&fSaveInterpolators[oldCount], 0,
             sizeof(fSaveInterpolators[0]) * (activeTotal - oldCount));
         return true;
     }
@@ -287,7 +287,7 @@
         state.fStarted = false;
         state.fSteps = apply->steps;
         state.fTicks = 0;
-        state.fUnpostedEndEvent = (SkBool8) animate->fHasEndEvent; 
+        state.fUnpostedEndEvent = (SkBool8) animate->fHasEndEvent;
         calcDurations(index);
         setInterpolator(index, from);
     }
@@ -317,7 +317,7 @@
         if (workingSum < originalSum) {
             SkScalar originalDistance = SkScalarSqrt(originalSum);
             SkScalar workingDistance = SkScalarSqrt(workingSum);
-            existing->fState[index].fDuration = (SkMSec) SkScalarMulDiv(fState[index].fDuration, 
+            existing->fState[index].fDuration = (SkMSec) SkScalarMulDiv(fState[index].fDuration,
                 workingDistance, originalDistance);
         }
         fInterpolators[index]->reset(components, 2, SkType_Float);
@@ -376,7 +376,7 @@
     SkMSec duration = fState[index].fDuration;
     int components = animate->components();
     SkOperandInterpolator& interpolator = *fInterpolators[index];
-    interpolator.reset(components, entries == 1 ? 2 : entries, animate->getValuesType()); 
+    interpolator.reset(components, entries == 1 ? 2 : entries, animate->getValuesType());
     interpolator.setMirror(SkToBool(animate->fMirror));
     interpolator.setReset(SkToBool(animate->fReset));
     interpolator.setRepeatCount(animate->repeat);
@@ -387,7 +387,7 @@
     }
     for (int entry = 0; entry < entries; entry++) {
         int blendIndex = SkMin32(animate->blend.count() - 1, entry);
-        interpolator.setKeyFrame(entry, entry * duration / (entries - 1), from, 
+        interpolator.setKeyFrame(entry, entry * duration / (entries - 1), from,
             animate->blend[blendIndex]);
         from += components;
     }
@@ -475,12 +475,12 @@
 // the code below should only be bumping fSave, and there shouldn't be anything
 // it needs to be synchronized with
 
-// however, if there are two animates both operating on the same field, then 
-// when one replaces the other, it may make sense to pick up the old value as a starting 
+// however, if there are two animates both operating on the same field, then
+// when one replaces the other, it may make sense to pick up the old value as a starting
 // value for the new one somehow.
 
 //void SkActive::SkState::bumpSave() {
-//  if (fMode != SkApply::kMode_hold) 
+//  if (fMode != SkApply::kMode_hold)
 //      return;
 //  if (fTransition == SkApply::kTransition_reverse) {
 //      if (fSave > 0)
diff --git a/src/animator/SkAnimateBase.cpp b/src/animator/SkAnimateBase.cpp
index fe3815d..0e56faa 100644
--- a/src/animator/SkAnimateBase.cpp
+++ b/src/animator/SkAnimateBase.cpp
@@ -39,8 +39,8 @@
 DEFINE_GET_MEMBER(SkAnimateBase);
 
 SkAnimateBase::SkAnimateBase() : begin(0), dur(1), repeat(SK_Scalar1),
-        fApply(NULL), fFieldInfo(NULL), fFieldOffset(0), fStart((SkMSec) -1), fTarget(NULL), 
-        fChanged(0), fDelayed(0), fDynamic(0), fHasEndEvent(0), fHasValues(0), 
+        fApply(NULL), fFieldInfo(NULL), fFieldOffset(0), fStart((SkMSec) -1), fTarget(NULL),
+        fChanged(0), fDelayed(0), fDynamic(0), fHasEndEvent(0), fHasValues(0),
         fMirror(0), fReset(0), fResetPending(0), fTargetIsScope(0) {
     blend.setCount(1);
     blend[0] = SK_Scalar1;
@@ -54,8 +54,8 @@
     }
 }
 
-int SkAnimateBase::components() { 
-    return 1; 
+int SkAnimateBase::components() {
+    return 1;
 }
 
 SkDisplayable* SkAnimateBase::deepCopy(SkAnimateMaker* maker) {
@@ -131,9 +131,9 @@
     return true;
 }
 
-bool SkAnimateBase::hasExecute() const 
+bool SkAnimateBase::hasExecute() const
 {
-    return false; 
+    return false;
 }
 
 void SkAnimateBase::onEndElement(SkAnimateMaker& maker) {
@@ -159,11 +159,11 @@
     }
 }
 
-void SkAnimateBase::packARGB(SkScalar array[], int count, SkTDOperandArray* converted) 
-{ 
+void SkAnimateBase::packARGB(SkScalar array[], int count, SkTDOperandArray* converted)
+{
     SkASSERT(count == 4);
     converted->setCount(1);
-    SkColor color = SkColorSetARGB(SkScalarRound(array[0]), SkScalarRound(array[1]), 
+    SkColor color = SkColorSetARGB(SkScalarRound(array[0]), SkScalarRound(array[1]),
         SkScalarRound(array[2]), SkScalarRound(array[3]));
     (*converted)[0].fS32 = color;
 }
@@ -228,8 +228,8 @@
     }
 }
 
-bool SkAnimateBase::targetNeedsInitialization() const { 
-    return false; 
+bool SkAnimateBase::targetNeedsInitialization() const {
+    return false;
 }
 
 
diff --git a/src/animator/SkAnimateField.cpp b/src/animator/SkAnimateField.cpp
index 65e084a..43f510e 100644
--- a/src/animator/SkAnimateField.cpp
+++ b/src/animator/SkAnimateField.cpp
@@ -28,8 +28,8 @@
 SkAnimate::~SkAnimate() {
 }
 
-int SkAnimate::components() { 
-    return fComponents; 
+int SkAnimate::components() {
+    return fComponents;
 }
 
 #ifdef SK_DUMP_ENABLED
@@ -50,7 +50,7 @@
             SkDebugf("blend=\"[");
             bool firstElem = true;
             for (int i = 0; i < blend.count(); i++) {
-                if (!firstElem) 
+                if (!firstElem)
                     SkDebugf(",");
                 firstElem = false;
                 SkDebugf("%g", SkScalarToFloat(blend[i]));
@@ -82,7 +82,7 @@
         SkASSERT(to.size() > 0);
         fFieldInfo->setValue(maker, &fValues, 0, 0, NULL, outType, to);
         SkASSERT(0);
-        // !!! this needs to set fComponents 
+        // !!! this needs to set fComponents
         return;
     }
     fComponents = fFieldInfo->getCount();
diff --git a/src/animator/SkAnimateMaker.cpp b/src/animator/SkAnimateMaker.cpp
index 414e728..ddde2eb 100644
--- a/src/animator/SkAnimateMaker.cpp
+++ b/src/animator/SkAnimateMaker.cpp
@@ -28,7 +28,7 @@
 } gDefaultTimeline;
 
 SkAnimateMaker::SkAnimateMaker(SkAnimator* animator, SkCanvas* canvas, SkPaint* paint)
-    : fActiveEvent(NULL), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0), 
+    : fActiveEvent(NULL), fAdjustedStart(0), fCanvas(canvas), fEnableTime(0),
         fHostEventSinkID(0), fMinimumInterval((SkMSec) -1), fPaint(paint), fParentMaker(NULL),
         fTimeline(&gDefaultTimeline), fInInclude(false), fInMovie(false),
         fFirstScriptError(false), fLoaded(false), fIDs(256), fAnimator(animator)
@@ -82,7 +82,7 @@
 
 SkDisplayable* SkAnimateMaker::createInstance(const char name[], size_t len) {
     SkDisplayTypes type = SkDisplayType::GetType(this, name, len );
-    if ((int)type >= 0) 
+    if ((int)type >= 0)
         return SkDisplayType::CreateInstance(this, type);
     return NULL;
 }
@@ -124,7 +124,7 @@
     if (index < 0) {
         *fDelayed.append() = apply;
     }
-    
+
     (new SkEvent(SK_EventType_Delay, fAnimator->getSinkID()))->postTime(time);
 }
 
@@ -302,7 +302,7 @@
 #if defined SK_DEBUG
         SkDebugf("%s\n", fErrorString.c_str());
 #endif
-    } 
+    }
 }
 
 void SkAnimateMaker::setEnableTime(SkMSec appTime, SkMSec expectedTime) {
@@ -330,7 +330,7 @@
     }
 }
 
-void SkAnimateMaker::setExtraPropertyCallBack(SkDisplayTypes type, 
+void SkAnimateMaker::setExtraPropertyCallBack(SkDisplayTypes type,
         SkScriptEngine::_propertyCallBack callBack, void* userStorage) {
     SkExtras** end = fExtras.end();
     for (SkExtras** extraPtr = fExtras.begin(); extraPtr < end; extraPtr++) {
diff --git a/src/animator/SkAnimateMaker.h b/src/animator/SkAnimateMaker.h
index f20a7d4..53a5521 100644
--- a/src/animator/SkAnimateMaker.h
+++ b/src/animator/SkAnimateMaker.h
@@ -57,16 +57,16 @@
     void dump(const char* match);
 #endif
     int dynamicProperty(SkString& nameStr, SkDisplayable**  );
-    bool find(const char* str, SkDisplayable** displayablePtr) const { 
+    bool find(const char* str, SkDisplayable** displayablePtr) const {
         return fIDs.find(str, displayablePtr);
     }
-    bool find(const char* str, size_t len, SkDisplayable** displayablePtr) const { 
+    bool find(const char* str, size_t len, SkDisplayable** displayablePtr) const {
         return fIDs.find(str, len, displayablePtr);
     }
     bool findKey(SkDisplayable* displayable, const char** string) const {
         return fIDs.findKey(displayable, string);
     }
-//  bool find(SkString& string, SkDisplayable** displayablePtr) { 
+//  bool find(SkString& string, SkDisplayable** displayablePtr) {
 //      return fIDs.find(string.c_str(), displayablePtr);
 //  }
     SkAnimator* getAnimator() { return fAnimator; }
@@ -80,7 +80,7 @@
     bool hasError() { return fError.hasError(); }
     void helperAdd(SkDisplayable* trackMe);
     void helperRemove(SkDisplayable* alreadyTracked);
-    void idsSet(const char* attrValue, size_t len, SkDisplayable* displayable) { 
+    void idsSet(const char* attrValue, size_t len, SkDisplayable* displayable) {
         fIDs.set(attrValue, len, displayable); }
 //  void loadMovies();
     void notifyInval();
diff --git a/src/animator/SkAnimateSet.cpp b/src/animator/SkAnimateSet.cpp
index 3dd9648..f153b16 100644
--- a/src/animator/SkAnimateSet.cpp
+++ b/src/animator/SkAnimateSet.cpp
@@ -32,7 +32,7 @@
 DEFINE_GET_MEMBER(SkSet);
 
 SkSet::SkSet() {
-    dur = 1; 
+    dur = 1;
 }
 
 #ifdef SK_DUMP_ENABLED
@@ -48,7 +48,7 @@
 #endif
 
 void SkSet::refresh(SkAnimateMaker& maker) {
-    fFieldInfo->setValue(maker, &fValues, 0, fFieldInfo->fCount, NULL, 
+    fFieldInfo->setValue(maker, &fValues, 0, fFieldInfo->fCount, NULL,
         fFieldInfo->getType(), to);
 }
 
diff --git a/src/animator/SkAnimator.cpp b/src/animator/SkAnimator.cpp
index c1fba65..5d1f220 100644
--- a/src/animator/SkAnimator.cpp
+++ b/src/animator/SkAnimator.cpp
@@ -34,7 +34,7 @@
     #define _static static
 #endif
 
-_static const char gMathPrimerText[] = 
+_static const char gMathPrimerText[] =
 "<screenplay>"
     "<Math id=\"Math\"/>"
     "<Number id=\"Number\"/>"
@@ -108,9 +108,9 @@
     state.fX = x;
     state.fY = y;
     fMaker->fEnableTime = fMaker->getAppTime();
-    bool result = fMaker->fEvents.doEvent(*fMaker, 
-        clickState == 0 ? SkDisplayEvent::kMouseDown : 
-        clickState == 1 ? SkDisplayEvent::kMouseDrag : 
+    bool result = fMaker->fEvents.doEvent(*fMaker,
+        clickState == 0 ? SkDisplayEvent::kMouseDown :
+        clickState == 1 ? SkDisplayEvent::kMouseDrag :
         SkDisplayEvent::kMouseUp, &state);
     fMaker->notifyInval();
     return result;
@@ -160,7 +160,7 @@
     SkPaint paint;
     return draw(canvas, &paint, time);
 }
-    
+
 #ifdef SK_DEBUG
 void SkAnimator::eventDone(const SkEvent& ) {
 }
@@ -231,7 +231,7 @@
     return info->getArrayValue(element, index, operand);
 }
 
-int32_t SkAnimator::getArrayInt(const SkDisplayable* ae, 
+int32_t SkAnimator::getArrayInt(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand, SkType_Int);
@@ -248,7 +248,7 @@
     return getArrayInt(element, field, index);
 }
 
-SkScalar SkAnimator::getArrayScalar(const SkDisplayable* ae, 
+SkScalar SkAnimator::getArrayScalar(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand, SkType_Float);
@@ -265,7 +265,7 @@
     return getArrayScalar(element, field, index);
 }
 
-const char* SkAnimator::getArrayString(const SkDisplayable* ae, 
+const char* SkAnimator::getArrayString(const SkDisplayable* ae,
         const SkMemberInfo* ai, int index) {
     SkOperand operand;
     bool result = getArrayCommon(ae, ai, index, &operand, SkType_String);
@@ -360,7 +360,7 @@
     return getScalar(element, field);
 }
 
-const char* SkAnimator::getString(const SkDisplayable* ae, 
+const char* SkAnimator::getString(const SkDisplayable* ae,
         const SkMemberInfo* ai) {
     const SkDisplayable* element = (const SkDisplayable*) ae;
     const SkMemberInfo* info = (const SkMemberInfo*) ai;
@@ -501,11 +501,11 @@
 }
 
 SkEventSinkID SkAnimator::getHostEventSinkID() const {
-    return fMaker->fHostEventSinkID; 
+    return fMaker->fHostEventSinkID;
 }
 
 void SkAnimator::setHostEventSinkID(SkEventSinkID target) {
-    fMaker->fHostEventSinkID = target; 
+    fMaker->fHostEventSinkID = target;
 }
 
 void SkAnimator::onSetHostHandler(Handler ) {
@@ -530,7 +530,7 @@
     SkTypedArray tArray(SkType_Int);
     tArray.setCount(num);
     for (int i = 0; i < num; i++) {
-        SkOperand op;   
+        SkOperand op;
         op.fS32 = array[i];
         tArray[i] = op;
     }
@@ -546,7 +546,7 @@
     SkDisplayTypes type = element->getType();
     if (type == SkType_Array) {
         SkDisplayArray* dispArray = (SkDisplayArray*) element;
-        dispArray->values = array;  
+        dispArray->values = array;
         return true;
     }
     else
@@ -614,9 +614,9 @@
     return setScalar(element, field, scalar);
 }
 
-bool SkAnimator::setString(SkDisplayable* element, 
+bool SkAnimator::setString(SkDisplayable* element,
         const SkMemberInfo* info, const char* str) {
-    // !!! until this is fixed, can't call script with global references from here 
+    // !!! until this is fixed, can't call script with global references from here
     info->setValue(*fMaker, NULL, 0, info->fCount, element, info->getType(), str, strlen(str));
     return true;
 }
diff --git a/src/animator/SkAnimatorScript.cpp b/src/animator/SkAnimatorScript.cpp
index 6aae006..0e639f2 100644
--- a/src/animator/SkAnimatorScript.cpp
+++ b/src/animator/SkAnimatorScript.cpp
@@ -64,8 +64,8 @@
     if (SkDisplayType::IsEnum(&maker, type)) {
         // !!! for SpiderMonkey, iterate through the enum values, and map them to globals
         const SkDisplayEnumMap& map = GetEnumValues(type);
-        propertyCallBack(EvalEnum, (void*) map.fValues); 
-    } 
+        propertyCallBack(EvalEnum, (void*) map.fValues);
+    }
     for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
         SkExtras* extra = *extraPtr;
         if (extra->fExtraCallBack)
@@ -116,7 +116,7 @@
             SkDisplayString* boxedValue = new SkDisplayString(*scriptValue->fOperand.fString);
             displayable = boxedValue;
             } break;
-        case SkType_Displayable: 
+        case SkType_Displayable:
             scriptValue->fOperand.fObject = scriptValue->fOperand.fDisplayable;
             scriptValue->fType = SkType_Displayable;
             return true;
@@ -130,7 +130,7 @@
     return true;
 }
 
-bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+bool SkAnimatorScript::Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* eng, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL("eval", function, len) == false)
         return false;
@@ -152,7 +152,7 @@
     const char* tokens = (const char*) callBack;
     value->fType = SkType_Int;
     if (MapEnums(tokens, token, len, (int*)&value->fOperand.fS32))
-        return true; 
+        return true;
     return false;
 }
 
@@ -160,7 +160,7 @@
     SkAnimatorScript* engine = (SkAnimatorScript*) user;
     SkTDict<SkDisplayable*>* ids = &engine->fMaker.fIDs;
     SkDisplayable* displayable;
-    bool success = ids->find(token, len, &displayable); 
+    bool success = ids->find(token, len, &displayable);
     if (success == false) {
         displayable = engine->fWorking;
         if (SK_LITERAL_STR_EQUAL("parent", token, len)) {
@@ -176,7 +176,7 @@
         if (displayable && EvalMember(token, len, displayable, engine, value))
             return true;
         value->fOperand.fString = NULL;
-        value->fType = SkType_String;   
+        value->fType = SkType_String;
     } else {
         SkDisplayable* working = engine->fWorking;
         value->fOperand.fDisplayable = displayable;
@@ -199,7 +199,7 @@
     return false;
 }
 
-bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+bool SkAnimatorScript::EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* eng, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL("rgb", function, len) == false)
         return false;
@@ -218,7 +218,7 @@
     return true;
 }
 
-bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info, 
+bool SkAnimatorScript::EvalMemberCommon(SkScriptEngine* engine, const SkMemberInfo* info,
         SkDisplayable* displayable, SkScriptValue* value) {
     SkDisplayTypes original;
     SkDisplayTypes type = original = (SkDisplayTypes) info->getType();
@@ -232,10 +232,10 @@
         case SkType_MSec:
         case SkType_Float:
             SkASSERT(info->getCount() == 1);
-            if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) 
+            if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction)
                 value->fOperand.fS32 = *(int32_t*) info->memberData(displayable);   // OK for SkScalar too
             if (type == SkType_MSec) {
-                value->fOperand.fScalar = SkScalarDiv((SkScalar) value->fOperand.fS32, 1000); // dividing two ints is the same as dividing two scalars 
+                value->fOperand.fScalar = SkScalarDiv((SkScalar) value->fOperand.fS32, 1000); // dividing two ints is the same as dividing two scalars
                 type = SkType_Float;
             }
             break;
@@ -269,7 +269,7 @@
     return true;
 }
 
-bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng, 
+bool SkAnimatorScript::EvalMember(const char* member, size_t len, void* object, void* eng,
         SkScriptValue* value) {
     SkScriptEngine* engine = (SkScriptEngine*) eng;
     SkDisplayable* displayable = (SkDisplayable*) object;
@@ -292,7 +292,7 @@
     return EvalMemberCommon(engine, info, displayable, value);
 }
 
-bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object, 
+bool SkAnimatorScript::EvalMemberFunction(const char* member, size_t len, void* object,
         SkTDArray<SkScriptValue>& params, void* eng, SkScriptValue* value) {
     SkScriptEngine* engine = (SkScriptEngine*) eng;
     SkDisplayable* displayable = (SkDisplayable*) object;
@@ -303,7 +303,7 @@
         SkASSERT(0);
         return false;
     }
-    displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(), 
+    displayable->executeFunction(displayable, info->functionIndex(), params, info->getType(),
         value);
     return EvalMemberCommon(engine, info, displayable, value);
 }
@@ -355,7 +355,7 @@
 }
 
 const SkDisplayEnumMap& SkAnimatorScript::GetEnumValues(SkDisplayTypes type) {
-    int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type, 
+    int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
         sizeof(SkDisplayEnumMap));
     SkASSERT(index >= 0);
     return gEnumMaps[index];
@@ -369,7 +369,7 @@
     return true;
 }
 
-bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+bool SkAnimatorScript::IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* eng, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL(function, "isFinite", len) == false)
         return false;
@@ -379,12 +379,12 @@
     SkDisplayTypes type = scriptValue->fType;
     SkScalar scalar = scriptValue->fOperand.fScalar;
     value->fType = SkType_Int;
-    value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false && 
+    value->fOperand.fS32 = type == SkType_Float ? SkScalarIsNaN(scalar) == false &&
         SkScalarAbs(scalar) != SK_ScalarInfinity    : type == SkType_Int;
     return true;
 }
 
-bool SkAnimatorScript::IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+bool SkAnimatorScript::IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* eng, SkScriptValue* value) {
     if (SK_LITERAL_STR_EQUAL("isNaN", function, len) == false)
         return false;
@@ -429,7 +429,7 @@
     SkTDict<SkDisplayable*>* ids = (SkTDict<SkDisplayable*>*) user;
     SkDisplayable* displayable = (SkDisplayable*) object;
     const char* key;
-    bool success = ids->findKey(displayable, &key); 
+    bool success = ids->findKey(displayable, &key);
     if (success == false)
         return false;
     value->fOperand.fString =   new SkString(key);
@@ -480,7 +480,7 @@
 
 #include "SkAnimator.h"
 
-static const char scriptTestSetup[]  = 
+static const char scriptTestSetup[]  =
 "<screenplay>\n"
     "<text id='label' text='defg'/>\n"
     "<add id='addLabel' use='label'/>\n"
diff --git a/src/animator/SkAnimatorScript.h b/src/animator/SkAnimatorScript.h
index a23f90d..c8802a3 100644
--- a/src/animator/SkAnimatorScript.h
+++ b/src/animator/SkAnimatorScript.h
@@ -27,8 +27,8 @@
     SkAnimatorScript(SkAnimateMaker& , SkDisplayable* , SkDisplayTypes type);
     ~SkAnimatorScript();
     bool evaluate(const char* script, SkScriptValue* , SkDisplayTypes type);
-    void track(SkDisplayable* displayable) { 
-        SkASSERT(fTrackDisplayable.find(displayable) < 0);  
+    void track(SkDisplayable* displayable) {
+        SkASSERT(fTrackDisplayable.find(displayable) < 0);
         *fTrackDisplayable.append() = displayable; }
     static bool EvaluateDisplayable(SkAnimateMaker& , SkDisplayable* , const char* script, SkDisplayable** );
     static bool EvaluateFloat(SkAnimateMaker& , SkDisplayable* , const char* script, SkScalar* );
@@ -38,24 +38,24 @@
     static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
 protected:
     static bool Box(void* user, SkScriptValue* );
-    static bool Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+    static bool Eval(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* callBack, SkScriptValue* );
     static bool EvalEnum(const char* token, size_t len, void* callBack, SkScriptValue* );
     static bool EvalID(const char* token, size_t len, void* callBack, SkScriptValue* );
-    static bool EvalMember(const char* member, size_t len, void* object, void* eng, 
+    static bool EvalMember(const char* member, size_t len, void* object, void* eng,
         SkScriptValue* value);
-    static bool EvalMemberCommon(SkScriptEngine* , const SkMemberInfo* info, 
+    static bool EvalMemberCommon(SkScriptEngine* , const SkMemberInfo* info,
         SkDisplayable* displayable, SkScriptValue* value);
-    static bool EvalMemberFunction(const char* member, size_t len, void* object, 
+    static bool EvalMemberFunction(const char* member, size_t len, void* object,
         SkTDArray<SkScriptValue>& params, void* user, SkScriptValue* value);
     static bool EvalNamedColor(const char* token, size_t len, void* callBack, SkScriptValue* );
-    static bool EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+    static bool EvalRGB(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* callBack, SkScriptValue* );
-    static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type); 
+    static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
     static bool Infinity(const char* token, size_t len, void* callBack, SkScriptValue* );
-    static bool IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+    static bool IsFinite(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* callBack, SkScriptValue* );
-    static bool IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params, 
+    static bool IsNaN(const char* function, size_t len, SkTDArray<SkScriptValue>& params,
         void* callBack, SkScriptValue* );
     static bool NaN(const char* token, size_t len, void* callBack, SkScriptValue* );
     static bool Unbox(void* , SkScriptValue* scriptValue);
diff --git a/src/animator/SkAnimatorScript2.cpp b/src/animator/SkAnimatorScript2.cpp
index ae51fdc..45ce3ce 100644
--- a/src/animator/SkAnimatorScript2.cpp
+++ b/src/animator/SkAnimatorScript2.cpp
@@ -17,29 +17,29 @@
 #include "SkScriptCallBack.h"
 
 static const SkDisplayEnumMap gEnumMaps[] = {
-	{ SkType_AddMode, "indirect|immediate" },
-	{ SkType_Align, "left|center|right" },
-	{ SkType_ApplyMode, "immediate|once" },
-	{ SkType_ApplyTransition, "reverse" },
-	{ SkType_BitmapEncoding, "jpeg|png" },
-	{ SkType_BitmapFormat, "none|A1|A8|Index8|RGB16|RGB32" },
-	{ SkType_Boolean, "false|true" },
-	{ SkType_Cap, "butt|round|square" },
-	{ SkType_EventCode, "none|up|down|left|right|back|end|OK|send|leftSoftKey|rightSoftKey|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash" },
-	{ SkType_EventKind, "none|keyChar|keyPress|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" },
-	{ SkType_EventMode, "deferred|immediate" },
-	{ SkType_FillType, "winding|evenOdd" },
-	{ SkType_FilterType, "none|bilinear" },
-	{ SkType_FromPathMode, "normal|angle|position" },
-	{ SkType_Join, "miter|round|blunt" },
-	{ SkType_MaskFilterBlurStyle, "normal|solid|outer|inner" },
-	{ SkType_PathDirection, "cw|ccw" },
-	{ SkType_Style, "fill|stroke|strokeAndFill" },
-	{ SkType_TextBoxAlign, "start|center|end" },
-	{ SkType_TextBoxMode, "oneLine|lineBreak" },
-	{ SkType_TileMode, "clamp|repeat|mirror" },
-	{ SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|"
-		"srcATop|dstATop|xor|darken|lighten" },
+    { SkType_AddMode, "indirect|immediate" },
+    { SkType_Align, "left|center|right" },
+    { SkType_ApplyMode, "immediate|once" },
+    { SkType_ApplyTransition, "reverse" },
+    { SkType_BitmapEncoding, "jpeg|png" },
+    { SkType_BitmapFormat, "none|A1|A8|Index8|RGB16|RGB32" },
+    { SkType_Boolean, "false|true" },
+    { SkType_Cap, "butt|round|square" },
+    { SkType_EventCode, "none|up|down|left|right|back|end|OK|send|leftSoftKey|rightSoftKey|key0|key1|key2|key3|key4|key5|key6|key7|key8|key9|star|hash" },
+    { SkType_EventKind, "none|keyChar|keyPress|mouseDown|mouseDrag|mouseMove|mouseUp|onEnd|onLoad|user" },
+    { SkType_EventMode, "deferred|immediate" },
+    { SkType_FillType, "winding|evenOdd" },
+    { SkType_FilterType, "none|bilinear" },
+    { SkType_FromPathMode, "normal|angle|position" },
+    { SkType_Join, "miter|round|blunt" },
+    { SkType_MaskFilterBlurStyle, "normal|solid|outer|inner" },
+    { SkType_PathDirection, "cw|ccw" },
+    { SkType_Style, "fill|stroke|strokeAndFill" },
+    { SkType_TextBoxAlign, "start|center|end" },
+    { SkType_TextBoxMode, "oneLine|lineBreak" },
+    { SkType_TileMode, "clamp|repeat|mirror" },
+    { SkType_Xfermode, "clear|src|dst|srcOver|dstOver|srcIn|dstIn|srcOut|dstOut|"
+        "srcATop|dstATop|xor|darken|lighten" },
 };
 
 static int gEnumMapCount = SK_ARRAY_COUNT(gEnumMaps);
@@ -47,575 +47,575 @@
 
 class SkAnimatorScript_Box : public SkScriptCallBackConvert {
 public:
-	SkAnimatorScript_Box() {}
+    SkAnimatorScript_Box() {}
 
-	~SkAnimatorScript_Box() {
-		for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++)
-			delete *dispPtr;
-	}
+    ~SkAnimatorScript_Box() {
+        for (SkDisplayable** dispPtr = fTrackDisplayable.begin(); dispPtr < fTrackDisplayable.end(); dispPtr++)
+            delete *dispPtr;
+    }
 
-	virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
-		SkDisplayable* displayable;
-		switch (type) {
-			case SkOperand2::kArray: {
-				SkDisplayArray* boxedValue = new SkDisplayArray(*operand->fArray);
-				displayable = boxedValue;
-				} break;
-			case SkOperand2::kS32: {
-				SkDisplayInt* boxedValue = new SkDisplayInt;
-				displayable = boxedValue;
-				boxedValue->value = operand->fS32;
-				} break;
-			case SkOperand2::kScalar: {
-				SkDisplayFloat* boxedValue = new SkDisplayFloat;
-				displayable = boxedValue;
-				boxedValue->value = operand->fScalar;
-				} break;
-			case SkOperand2::kString: {
-				SkDisplayString* boxedValue = new SkDisplayString(*operand->fString);
-				displayable = boxedValue;
-				} break;
-			case SkOperand2::kObject: 
-				return true;
-			default:
-				SkASSERT(0);
-				return false;
-		}
-		track(displayable);
-		operand->fObject = (void*) displayable;
-		return true;
-	}
+    virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
+        SkDisplayable* displayable;
+        switch (type) {
+            case SkOperand2::kArray: {
+                SkDisplayArray* boxedValue = new SkDisplayArray(*operand->fArray);
+                displayable = boxedValue;
+                } break;
+            case SkOperand2::kS32: {
+                SkDisplayInt* boxedValue = new SkDisplayInt;
+                displayable = boxedValue;
+                boxedValue->value = operand->fS32;
+                } break;
+            case SkOperand2::kScalar: {
+                SkDisplayFloat* boxedValue = new SkDisplayFloat;
+                displayable = boxedValue;
+                boxedValue->value = operand->fScalar;
+                } break;
+            case SkOperand2::kString: {
+                SkDisplayString* boxedValue = new SkDisplayString(*operand->fString);
+                displayable = boxedValue;
+                } break;
+            case SkOperand2::kObject:
+                return true;
+            default:
+                SkASSERT(0);
+                return false;
+        }
+        track(displayable);
+        operand->fObject = (void*) displayable;
+        return true;
+    }
 
-	virtual SkOperand2::OpType getReturnType(int index) { 
-		return SkOperand2::kObject; 
-	}
+    virtual SkOperand2::OpType getReturnType(int index) {
+        return SkOperand2::kObject;
+    }
 
-	virtual Type getType() const { 
-		return kBox; 
-	}
+    virtual Type getType() const {
+        return kBox;
+    }
 
-	void track(SkDisplayable* displayable) { 
-		SkASSERT(fTrackDisplayable.find(displayable) < 0);  
-		*fTrackDisplayable.append() = displayable; 
-	}
+    void track(SkDisplayable* displayable) {
+        SkASSERT(fTrackDisplayable.find(displayable) < 0);
+        *fTrackDisplayable.append() = displayable;
+    }
 
-	SkTDDisplayableArray fTrackDisplayable;
+    SkTDDisplayableArray fTrackDisplayable;
 };
 
 
 class SkAnimatorScript_Enum : public SkScriptCallBackProperty {
 public:
-	SkAnimatorScript_Enum(const char* tokens) : fTokens(tokens) {}
+    SkAnimatorScript_Enum(const char* tokens) : fTokens(tokens) {}
 
-	virtual bool getConstValue(const char* name, int len, SkOperand2* value) { 
-		return SkAnimatorScript2::MapEnums(fTokens, name, len, &value->fS32);
-	}
+    virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
+        return SkAnimatorScript2::MapEnums(fTokens, name, len, &value->fS32);
+    }
 
 private:
-	const char* fTokens;
+    const char* fTokens;
 };
 
-	// !!! if type is string, call invoke
-	// if any other type, return original value
-		// distinction is undone: could do this by returning index == 0 only if param is string
-		// still, caller of getParamTypes will attempt to convert param to string (I guess)
+    // !!! if type is string, call invoke
+    // if any other type, return original value
+        // distinction is undone: could do this by returning index == 0 only if param is string
+        // still, caller of getParamTypes will attempt to convert param to string (I guess)
 class SkAnimatorScript_Eval : public SkScriptCallBackFunction {
 public:
-	SkAnimatorScript_Eval(SkAnimatorScript2* engine) : fEngine(engine) {}
+    SkAnimatorScript_Eval(SkAnimatorScript2* engine) : fEngine(engine) {}
 
-	virtual bool getIndex(const char* name, int len, size_t* result) {
-		if (SK_LITERAL_STR_EQUAL("eval", name, len) != 0)
-			return false;
-		*result = 0;
-		return true;
-	}
-	
-	virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
-		types->setCount(1);
-		SkOperand2::OpType* type = types->begin();
-		type[0] = SkOperand2::kString;
-	}
+    virtual bool getIndex(const char* name, int len, size_t* result) {
+        if (SK_LITERAL_STR_EQUAL("eval", name, len) != 0)
+            return false;
+        *result = 0;
+        return true;
+    }
 
-	virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
-		SkAnimatorScript2 engine(fEngine->getMaker(), fEngine->getWorking(), 
-			SkAnimatorScript2::ToDisplayType(fEngine->getReturnType()));
-		SkOperand2* op = params->begin();
-		const char* script = op->fString->c_str();
-		SkScriptValue2 value;
-		return engine.evaluateScript(&script, &value);
-		SkASSERT(value.fType == fEngine->getReturnType());
-		*answer = value.fOperand;
-		// !!! incomplete ?
-		return true;
-	}
+    virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+        types->setCount(1);
+        SkOperand2::OpType* type = types->begin();
+        type[0] = SkOperand2::kString;
+    }
+
+    virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
+        SkAnimatorScript2 engine(fEngine->getMaker(), fEngine->getWorking(),
+            SkAnimatorScript2::ToDisplayType(fEngine->getReturnType()));
+        SkOperand2* op = params->begin();
+        const char* script = op->fString->c_str();
+        SkScriptValue2 value;
+        return engine.evaluateScript(&script, &value);
+        SkASSERT(value.fType == fEngine->getReturnType());
+        *answer = value.fOperand;
+        // !!! incomplete ?
+        return true;
+    }
 
 private:
-	SkAnimatorScript2* fEngine;
+    SkAnimatorScript2* fEngine;
 };
 
 class SkAnimatorScript_ID : public SkScriptCallBackProperty {
 public:
-	SkAnimatorScript_ID(SkAnimatorScript2* engine) : fEngine(engine) {}
+    SkAnimatorScript_ID(SkAnimatorScript2* engine) : fEngine(engine) {}
 
-	virtual bool getIndex(const char* token, int len, size_t* result) {  
-		SkDisplayable* displayable;
-		bool success = fEngine->getMaker().find(token, len, &displayable);
-		if (success == false) {
-			*result = 0;
-		} else {
-			*result = (size_t) displayable;
-			SkDisplayable* working = fEngine->getWorking();
-			if (displayable->canContainDependents() && working && working->isAnimate()) {
-				SkAnimateBase* animator = (SkAnimateBase*) working;
-				if (animator->isDynamic()) {
-					SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;
-					depend->addDependent(working);
-				}
-			}
-		}
-		return true; 
-	}
+    virtual bool getIndex(const char* token, int len, size_t* result) {
+        SkDisplayable* displayable;
+        bool success = fEngine->getMaker().find(token, len, &displayable);
+        if (success == false) {
+            *result = 0;
+        } else {
+            *result = (size_t) displayable;
+            SkDisplayable* working = fEngine->getWorking();
+            if (displayable->canContainDependents() && working && working->isAnimate()) {
+                SkAnimateBase* animator = (SkAnimateBase*) working;
+                if (animator->isDynamic()) {
+                    SkDisplayDepend* depend = (SkDisplayDepend* ) displayable;
+                    depend->addDependent(working);
+                }
+            }
+        }
+        return true;
+    }
 
-	virtual bool getResult(size_t ref, SkOperand2* answer) {
-		answer->fObject = (void*) ref;
-		return true;
-	}
+    virtual bool getResult(size_t ref, SkOperand2* answer) {
+        answer->fObject = (void*) ref;
+        return true;
+    }
 
-	virtual SkOperand2::OpType getReturnType(size_t index) {
-		return index == 0 ? SkOperand2::kString : SkOperand2::kObject;
-	}
+    virtual SkOperand2::OpType getReturnType(size_t index) {
+        return index == 0 ? SkOperand2::kString : SkOperand2::kObject;
+    }
 
 private:
-	SkAnimatorScript2* fEngine;
+    SkAnimatorScript2* fEngine;
 };
 
 
 class SkAnimatorScript_Member : public SkScriptCallBackMember {
 public:
 
-	SkAnimatorScript_Member(SkAnimatorScript2* engine) : fEngine(engine) {}
+    SkAnimatorScript_Member(SkAnimatorScript2* engine) : fEngine(engine) {}
 
-	bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
-		SkDisplayable* displayable = (SkDisplayable*) object;
-		SkString name(member, len);
-		SkDisplayable* named = displayable->contains(name);
-		if (named) {
-			ref->fType = SkOperand2::kObject;
-			ref->fOperand.fObject = named;
-			return true;
-		}
-		const SkMemberInfo* info = displayable->getMember(name.c_str());
-		if (info == NULL)
-			return false;	// !!! add additional error info?
-		ref->fType = SkAnimatorScript2::ToOpType(info->getType());
-		ref->fOperand.fObject = (void*) info;
-		return true;
-	}
+    bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
+        SkDisplayable* displayable = (SkDisplayable*) object;
+        SkString name(member, len);
+        SkDisplayable* named = displayable->contains(name);
+        if (named) {
+            ref->fType = SkOperand2::kObject;
+            ref->fOperand.fObject = named;
+            return true;
+        }
+        const SkMemberInfo* info = displayable->getMember(name.c_str());
+        if (info == NULL)
+            return false;    // !!! add additional error info?
+        ref->fType = SkAnimatorScript2::ToOpType(info->getType());
+        ref->fOperand.fObject = (void*) info;
+        return true;
+    }
 
-	bool invoke(size_t ref, void* object, SkOperand2* value) {
-		const SkMemberInfo* info = (const SkMemberInfo* ) ref;
-		SkDisplayable* displayable = (SkDisplayable*) object;
-		if (info->fType == SkType_MemberProperty) {
-			if (displayable->getProperty2(info->propertyIndex(), value) == false) {
-				return false;
-			}
-		}
-		return fEngine->evalMemberCommon(info, displayable, value);
-	}
+    bool invoke(size_t ref, void* object, SkOperand2* value) {
+        const SkMemberInfo* info = (const SkMemberInfo* ) ref;
+        SkDisplayable* displayable = (SkDisplayable*) object;
+        if (info->fType == SkType_MemberProperty) {
+            if (displayable->getProperty2(info->propertyIndex(), value) == false) {
+                return false;
+            }
+        }
+        return fEngine->evalMemberCommon(info, displayable, value);
+    }
 
-	SkAnimatorScript2* fEngine;
+    SkAnimatorScript2* fEngine;
 };
 
 
 class SkAnimatorScript_MemberFunction : public SkScriptCallBackMemberFunction {
 public:
-	SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {}
+    SkAnimatorScript_MemberFunction(SkAnimatorScript2* engine) : fEngine(engine) {}
 
-	bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
-		SkDisplayable* displayable = (SkDisplayable*) object;
-		SkString name(member, len);
-		const SkMemberInfo* info = displayable->getMember(name.c_str());
-		if (info == NULL || info->fType != SkType_MemberFunction)
-			return false;	// !!! add additional error info?
-		ref->fType = SkAnimatorScript2::ToOpType(info->getType());
-		ref->fOperand.fObject = (void*) info;
-		return true;
-	}
+    bool getMemberReference(const char* member, size_t len, void* object, SkScriptValue2* ref) {
+        SkDisplayable* displayable = (SkDisplayable*) object;
+        SkString name(member, len);
+        const SkMemberInfo* info = displayable->getMember(name.c_str());
+        if (info == NULL || info->fType != SkType_MemberFunction)
+            return false;    // !!! add additional error info?
+        ref->fType = SkAnimatorScript2::ToOpType(info->getType());
+        ref->fOperand.fObject = (void*) info;
+        return true;
+    }
 
-	virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
-		types->setCount(3);
-		SkOperand2::OpType* type = types->begin();
-		type[0] = type[1] = type[2] = SkOperand2::kS32;
-	}
+    virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+        types->setCount(3);
+        SkOperand2::OpType* type = types->begin();
+        type[0] = type[1] = type[2] = SkOperand2::kS32;
+    }
 
-	bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value)
-	{
-		const SkMemberInfo* info = (const SkMemberInfo* ) ref;
-		SkDisplayable* displayable = (SkDisplayable*) object;
-		displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(), 
-			value);
-		return fEngine->evalMemberCommon(info, displayable, value);
-	}
+    bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value)
+    {
+        const SkMemberInfo* info = (const SkMemberInfo* ) ref;
+        SkDisplayable* displayable = (SkDisplayable*) object;
+        displayable->executeFunction2(displayable, info->functionIndex(), params, info->getType(),
+            value);
+        return fEngine->evalMemberCommon(info, displayable, value);
+    }
 
-	SkAnimatorScript2* fEngine;
+    SkAnimatorScript2* fEngine;
 };
 
 
 class SkAnimatorScript_NamedColor : public SkScriptCallBackProperty {
 public:
-	virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
-		return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL;
-	}
+    virtual bool getConstValue(const char* name, int len, SkOperand2* value) {
+        return SkParse::FindNamedColor(name, len, (SkColor*) &value->fS32) != NULL;
+    }
 };
 
 
 class SkAnimatorScript_RGB : public SkScriptCallBackFunction {
 public:
-	virtual bool getIndex(const char* name, int len, size_t* result) {
-		if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0)
-			return false;
-		*result = 0;
-		return true;
-	}
+    virtual bool getIndex(const char* name, int len, size_t* result) {
+        if (SK_LITERAL_STR_EQUAL("rgb", name, len) != 0)
+            return false;
+        *result = 0;
+        return true;
+    }
 
-	virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
-		types->setCount(3);
-		SkOperand2::OpType* type = types->begin();
-		type[0] = type[1] = type[2] = SkOperand2::kS32;
-	}
+    virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) {
+        types->setCount(3);
+        SkOperand2::OpType* type = types->begin();
+        type[0] = type[1] = type[2] = SkOperand2::kS32;
+    }
 
-	virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
-		SkASSERT(index == 0);
-		unsigned result = 0xFF000000;
-		int shift = 16;
-		for (int index = 0; index < 3; index++) {
-			result |= SkClampMax(params->begin()[index].fS32, 255) << shift;
-			shift -= 8;
-		}
-		answer->fS32 = result;
-		return true;
-	}
+    virtual bool invoke(size_t index, SkOpArray* params, SkOperand2* answer) {
+        SkASSERT(index == 0);
+        unsigned result = 0xFF000000;
+        int shift = 16;
+        for (int index = 0; index < 3; index++) {
+            result |= SkClampMax(params->begin()[index].fS32, 255) << shift;
+            shift -= 8;
+        }
+        answer->fS32 = result;
+        return true;
+    }
 
 };
 
 
 class SkAnimatorScript_Unbox : public SkScriptCallBackConvert {
 public:
-	SkAnimatorScript_Unbox(SkAnimatorScript2* engine) : fEngine(engine) {}
+    SkAnimatorScript_Unbox(SkAnimatorScript2* engine) : fEngine(engine) {}
 
-	virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
-		SkASSERT(type == SkOperand2::kObject);
-		SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
-		switch (displayable->getType()) {
-			case SkType_Array: {
-				SkDisplayArray* boxedValue = (SkDisplayArray*) displayable;
-				operand->fArray = new SkOpArray(SkAnimatorScript2::ToOpType(boxedValue->values.getType()));
-				int count = boxedValue->values.count();
-				operand->fArray->setCount(count);
-				memcpy(operand->fArray->begin(), boxedValue->values.begin(), count * sizeof(SkOperand2));
-				fEngine->track(operand->fArray);
-				} break;
-			case SkType_Boolean: {
-				SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable;
-				operand->fS32 = boxedValue->value;
-				} break;
-			case SkType_Int: {
-				SkDisplayInt* boxedValue = (SkDisplayInt*) displayable;
-				operand->fS32 = boxedValue->value;
-				} break;
-			case SkType_Float: {
-				SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;
-				operand->fScalar = boxedValue->value;
-				} break;
-			case SkType_String: {
-				SkDisplayString* boxedValue = (SkDisplayString*) displayable;
-				operand->fString = SkNEW_ARGS(SkString, (boxedValue->value));
-				} break;
-			default: {
-				const char* id;
-				bool success = fEngine->getMaker().findKey(displayable, &id);
-				SkASSERT(success);
-				operand->fString = SkNEW_ARGS(SkString, (id));
-			}
-		}
-		return true;
-	}
+    virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) {
+        SkASSERT(type == SkOperand2::kObject);
+        SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
+        switch (displayable->getType()) {
+            case SkType_Array: {
+                SkDisplayArray* boxedValue = (SkDisplayArray*) displayable;
+                operand->fArray = new SkOpArray(SkAnimatorScript2::ToOpType(boxedValue->values.getType()));
+                int count = boxedValue->values.count();
+                operand->fArray->setCount(count);
+                memcpy(operand->fArray->begin(), boxedValue->values.begin(), count * sizeof(SkOperand2));
+                fEngine->track(operand->fArray);
+                } break;
+            case SkType_Boolean: {
+                SkDisplayBoolean* boxedValue = (SkDisplayBoolean*) displayable;
+                operand->fS32 = boxedValue->value;
+                } break;
+            case SkType_Int: {
+                SkDisplayInt* boxedValue = (SkDisplayInt*) displayable;
+                operand->fS32 = boxedValue->value;
+                } break;
+            case SkType_Float: {
+                SkDisplayFloat* boxedValue = (SkDisplayFloat*) displayable;
+                operand->fScalar = boxedValue->value;
+                } break;
+            case SkType_String: {
+                SkDisplayString* boxedValue = (SkDisplayString*) displayable;
+                operand->fString = SkNEW_ARGS(SkString, (boxedValue->value));
+                } break;
+            default: {
+                const char* id;
+                bool success = fEngine->getMaker().findKey(displayable, &id);
+                SkASSERT(success);
+                operand->fString = SkNEW_ARGS(SkString, (id));
+            }
+        }
+        return true;
+    }
 
-	virtual SkOperand2::OpType getReturnType(int /*index*/, SkOperand2* operand) { 
-		SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
-		switch (displayable->getType()) {
-			case SkType_Array:
-				return SkOperand2::kArray;
-			case SkType_Int:
-				return SkOperand2::kS32;
-			case SkType_Float:
-				return SkOperand2::kScalar;
-			case SkType_String:
-			default:
-				return SkOperand2::kString;
-		}
-	}
+    virtual SkOperand2::OpType getReturnType(int /*index*/, SkOperand2* operand) {
+        SkDisplayable* displayable = (SkDisplayable*) operand->fObject;
+        switch (displayable->getType()) {
+            case SkType_Array:
+                return SkOperand2::kArray;
+            case SkType_Int:
+                return SkOperand2::kS32;
+            case SkType_Float:
+                return SkOperand2::kScalar;
+            case SkType_String:
+            default:
+                return SkOperand2::kString;
+        }
+    }
 
-	virtual Type getType() const { 
-		return kUnbox; 
-	}
+    virtual Type getType() const {
+        return kUnbox;
+    }
 
-	SkAnimatorScript2* fEngine;
+    SkAnimatorScript2* fEngine;
 };
 
-SkAnimatorScript2::SkAnimatorScript2(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) : 
-		SkScriptEngine2(ToOpType(type)), fMaker(maker), fWorking(working) {
-	*fCallBackArray.append() = new SkAnimatorScript_Member(this);
-	*fCallBackArray.append() = new SkAnimatorScript_MemberFunction(this);
-	*fCallBackArray.append() = new SkAnimatorScript_Box();
-	*fCallBackArray.append() = new SkAnimatorScript_Unbox(this);
-	*fCallBackArray.append() = new SkAnimatorScript_ID(this);
-	if (type == SkType_ARGB) {
-		*fCallBackArray.append() = new SkAnimatorScript_RGB();
-		*fCallBackArray.append() = new SkAnimatorScript_NamedColor();
-	}
-	if (SkDisplayType::IsEnum(&maker, type)) {
-		// !!! for SpiderMonkey, iterate through the enum values, and map them to globals
-		const SkDisplayEnumMap& map = GetEnumValues(type);
-		*fCallBackArray.append() = new SkAnimatorScript_Enum(map.fValues); 
-	}
-	*fCallBackArray.append() = new SkAnimatorScript_Eval(this);
-#if 0		// !!! no extra support for now
-	for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
-		SkExtras* extra = *extraPtr;
-		if (extra->fExtraCallBack)
-			*fCallBackArray.append() = new propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage);
-	}
+SkAnimatorScript2::SkAnimatorScript2(SkAnimateMaker& maker, SkDisplayable* working, SkDisplayTypes type) :
+        SkScriptEngine2(ToOpType(type)), fMaker(maker), fWorking(working) {
+    *fCallBackArray.append() = new SkAnimatorScript_Member(this);
+    *fCallBackArray.append() = new SkAnimatorScript_MemberFunction(this);
+    *fCallBackArray.append() = new SkAnimatorScript_Box();
+    *fCallBackArray.append() = new SkAnimatorScript_Unbox(this);
+    *fCallBackArray.append() = new SkAnimatorScript_ID(this);
+    if (type == SkType_ARGB) {
+        *fCallBackArray.append() = new SkAnimatorScript_RGB();
+        *fCallBackArray.append() = new SkAnimatorScript_NamedColor();
+    }
+    if (SkDisplayType::IsEnum(&maker, type)) {
+        // !!! for SpiderMonkey, iterate through the enum values, and map them to globals
+        const SkDisplayEnumMap& map = GetEnumValues(type);
+        *fCallBackArray.append() = new SkAnimatorScript_Enum(map.fValues);
+    }
+    *fCallBackArray.append() = new SkAnimatorScript_Eval(this);
+#if 0        // !!! no extra support for now
+    for (SkExtras** extraPtr = maker.fExtras.begin(); extraPtr < maker.fExtras.end(); extraPtr++) {
+        SkExtras* extra = *extraPtr;
+        if (extra->fExtraCallBack)
+            *fCallBackArray.append() = new propertyCallBack(extra->fExtraCallBack, extra->fExtraStorage);
+    }
 #endif
 }
 
 SkAnimatorScript2::~SkAnimatorScript2() {
-	SkScriptCallBack** end = fCallBackArray.end();
-	for (SkScriptCallBack** ptr = fCallBackArray.begin(); ptr < end; ptr++)
-		delete *ptr;
+    SkScriptCallBack** end = fCallBackArray.end();
+    for (SkScriptCallBack** ptr = fCallBackArray.begin(); ptr < end; ptr++)
+        delete *ptr;
 }
 
-bool SkAnimatorScript2::evalMemberCommon(const SkMemberInfo* info, 
-		SkDisplayable* displayable, SkOperand2* value) {
-	SkDisplayTypes original;
-	SkDisplayTypes type = original = (SkDisplayTypes) info->getType();
-	if (info->fType == SkType_Array)
-		type = SkType_Array;
-	switch (type) {
-		case SkType_ARGB:
-			type = SkType_Int;
-		case SkType_Boolean:
-		case SkType_Int:
-		case SkType_MSec:
-		case SkType_Float:
-			SkASSERT(info->getCount() == 1);
-			if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) 
-				value->fS32 = *(int32_t*) info->memberData(displayable);	// OK for SkScalar too
-			if (type == SkType_MSec) {
-				value->fScalar = SkScalarDiv((SkScalar) value->fS32, 1000); // dividing two ints is the same as dividing two scalars 
-				type = SkType_Float;
-			}
-			break;
-		case SkType_String: {
-			SkString* displayableString;
-			if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) {
-				info->getString(displayable, &displayableString);
-				value->fString = new SkString(*displayableString);
-			}
-			} break;
-		case SkType_Array: {
-			SkASSERT(info->fType != SkType_MemberProperty); // !!! incomplete
-			SkTDOperandArray* displayableArray = (SkTDOperandArray*) info->memberData(displayable);
-			if (displayable->getType() == SkType_Array) {
-				SkDisplayArray* typedArray = (SkDisplayArray*) displayable;
-				original = typedArray->values.getType();
-			}
-			SkASSERT(original != SkType_Unknown);
-			SkOpArray* array = value->fArray = new SkOpArray(ToOpType(original));
-			track(array);
-			int count = displayableArray->count();
-			if (count > 0) {
-				array->setCount(count);
-				memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand2));
-			}
-			} break;
-		default:
-			SkASSERT(0); // unimplemented
-	}
-	return true;
+bool SkAnimatorScript2::evalMemberCommon(const SkMemberInfo* info,
+        SkDisplayable* displayable, SkOperand2* value) {
+    SkDisplayTypes original;
+    SkDisplayTypes type = original = (SkDisplayTypes) info->getType();
+    if (info->fType == SkType_Array)
+        type = SkType_Array;
+    switch (type) {
+        case SkType_ARGB:
+            type = SkType_Int;
+        case SkType_Boolean:
+        case SkType_Int:
+        case SkType_MSec:
+        case SkType_Float:
+            SkASSERT(info->getCount() == 1);
+            if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction)
+                value->fS32 = *(int32_t*) info->memberData(displayable);    // OK for SkScalar too
+            if (type == SkType_MSec) {
+                value->fScalar = SkScalarDiv((SkScalar) value->fS32, 1000); // dividing two ints is the same as dividing two scalars
+                type = SkType_Float;
+            }
+            break;
+        case SkType_String: {
+            SkString* displayableString;
+            if (info->fType != SkType_MemberProperty && info->fType != SkType_MemberFunction) {
+                info->getString(displayable, &displayableString);
+                value->fString = new SkString(*displayableString);
+            }
+            } break;
+        case SkType_Array: {
+            SkASSERT(info->fType != SkType_MemberProperty); // !!! incomplete
+            SkTDOperandArray* displayableArray = (SkTDOperandArray*) info->memberData(displayable);
+            if (displayable->getType() == SkType_Array) {
+                SkDisplayArray* typedArray = (SkDisplayArray*) displayable;
+                original = typedArray->values.getType();
+            }
+            SkASSERT(original != SkType_Unknown);
+            SkOpArray* array = value->fArray = new SkOpArray(ToOpType(original));
+            track(array);
+            int count = displayableArray->count();
+            if (count > 0) {
+                array->setCount(count);
+                memcpy(array->begin(), displayableArray->begin(), count * sizeof(SkOperand2));
+            }
+            } break;
+        default:
+            SkASSERT(0); // unimplemented
+    }
+    return true;
 }
 
 const SkDisplayEnumMap& SkAnimatorScript2::GetEnumValues(SkDisplayTypes type) {
-	int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type, 
-		sizeof(SkDisplayEnumMap));
-	SkASSERT(index >= 0);
-	return gEnumMaps[index];
+    int index = SkTSearch<SkDisplayTypes>(&gEnumMaps[0].fType, gEnumMapCount, type,
+        sizeof(SkDisplayEnumMap));
+    SkASSERT(index >= 0);
+    return gEnumMaps[index];
 }
 
 SkDisplayTypes SkAnimatorScript2::ToDisplayType(SkOperand2::OpType type) {
-	int val = type;
-	switch (val) {
-		case SkOperand2::kNoType:
-			return SkType_Unknown;
-		case SkOperand2::kS32:
-			return SkType_Int;
-		case SkOperand2::kScalar:
-			return SkType_Float;
-		case SkOperand2::kString:
-			return SkType_String;
-		case SkOperand2::kArray:
-			return SkType_Array;
-		case SkOperand2::kObject:
-			return SkType_Displayable;
-		default:
-			SkASSERT(0);
-			return SkType_Unknown;
-	}
+    int val = type;
+    switch (val) {
+        case SkOperand2::kNoType:
+            return SkType_Unknown;
+        case SkOperand2::kS32:
+            return SkType_Int;
+        case SkOperand2::kScalar:
+            return SkType_Float;
+        case SkOperand2::kString:
+            return SkType_String;
+        case SkOperand2::kArray:
+            return SkType_Array;
+        case SkOperand2::kObject:
+            return SkType_Displayable;
+        default:
+            SkASSERT(0);
+            return SkType_Unknown;
+    }
 }
 
 SkOperand2::OpType SkAnimatorScript2::ToOpType(SkDisplayTypes type) {
-	if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
-		return SkOperand2::kObject;
-	if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
-		return SkOperand2::kS32;
-	switch (type) {
-		case SkType_ARGB:
-		case SkType_MSec:
-		case SkType_Int:
-			return SkOperand2::kS32;
-		case SkType_Float:
-		case SkType_Point:
-		case SkType_3D_Point:
-			return SkOperand2::kScalar;
-		case SkType_Base64:
-		case SkType_DynamicString:
-		case SkType_String:
-			return SkOperand2::kString;
-		case SkType_Array:
-			return SkOperand2::kArray;
-		case SkType_Unknown:
-			return SkOperand2::kNoType;
-		default:
-			SkASSERT(0);
-			return SkOperand2::kNoType;
-	}
+    if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
+        return SkOperand2::kObject;
+    if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
+        return SkOperand2::kS32;
+    switch (type) {
+        case SkType_ARGB:
+        case SkType_MSec:
+        case SkType_Int:
+            return SkOperand2::kS32;
+        case SkType_Float:
+        case SkType_Point:
+        case SkType_3D_Point:
+            return SkOperand2::kScalar;
+        case SkType_Base64:
+        case SkType_DynamicString:
+        case SkType_String:
+            return SkOperand2::kString;
+        case SkType_Array:
+            return SkOperand2::kArray;
+        case SkType_Unknown:
+            return SkOperand2::kNoType;
+        default:
+            SkASSERT(0);
+            return SkOperand2::kNoType;
+    }
 }
 
 bool SkAnimatorScript2::MapEnums(const char* ptr, const char* match, size_t len, int* value) {
-	int index = 0;
-	bool more = true;
-	do {
-		const char* last = strchr(ptr, '|');
-		if (last == NULL) {
-			last = &ptr[strlen(ptr)];
-			more = false;
-		}
-		size_t length = last - ptr;
-		if (len == length && strncmp(ptr, match, length) == 0) {
-			*value = index;
-			return true;
-		}
-		index++;
-		ptr = last + 1;
-	} while (more);
-	return false;
+    int index = 0;
+    bool more = true;
+    do {
+        const char* last = strchr(ptr, '|');
+        if (last == NULL) {
+            last = &ptr[strlen(ptr)];
+            more = false;
+        }
+        size_t length = last - ptr;
+        if (len == length && strncmp(ptr, match, length) == 0) {
+            *value = index;
+            return true;
+        }
+        index++;
+        ptr = last + 1;
+    } while (more);
+    return false;
 }
 
 #if defined SK_DEBUG
 
 #include "SkAnimator.h"
 
-static const char scriptTestSetup[]  = 
+static const char scriptTestSetup[]  =
 "<screenplay>"
-	"<apply>"
-		"<paint>"
-			"<emboss id='emboss' direction='[1,1,1]'  />"
-		"</paint>"
-		"<animateField id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>"
-		"<set lval='direction[0]' target='emboss' to='-1' />"
-	"</apply>"
-	"<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />"
-	"<color id='xColor' color='rgb(12,34,56)' />"
-	"<typedArray id='emptyArray' />"
-	"<typedArray id='intArray' values='[1, 4, 6]' />"
-	"<s32 id='idx' value='2' />"
-	"<s32 id='idy' value='2' />"
-	"<string id='alpha' value='abc' />"
-	"<rectangle id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />"
-	"<event id='evt'>"
-		"<input name='x' />"
-		"<apply scope='idy'>"
-			"<set field='value' to='evt.x.s32' />"
-		"</apply>"
-	"</event>"
+    "<apply>"
+        "<paint>"
+            "<emboss id='emboss' direction='[1,1,1]'  />"
+        "</paint>"
+        "<animateField id='animation' field='direction' target='emboss' from='[1,1,1]' to='[-1,1,1]' dur='1'/>"
+        "<set lval='direction[0]' target='emboss' to='-1' />"
+    "</apply>"
+    "<color id='testColor' color='0 ? rgb(0,0,0) : rgb(255,255,255)' />"
+    "<color id='xColor' color='rgb(12,34,56)' />"
+    "<typedArray id='emptyArray' />"
+    "<typedArray id='intArray' values='[1, 4, 6]' />"
+    "<s32 id='idx' value='2' />"
+    "<s32 id='idy' value='2' />"
+    "<string id='alpha' value='abc' />"
+    "<rectangle id='testRect' left='Math.cos(0)' top='2' right='12' bottom='5' />"
+    "<event id='evt'>"
+        "<input name='x' />"
+        "<apply scope='idy'>"
+            "<set field='value' to='evt.x.s32' />"
+        "</apply>"
+    "</event>"
 "</screenplay>";
 
 static const SkScriptNAnswer scriptTests[]  = {
-	{	"alpha+alpha", SkType_String, 0, 0, "abcabc" },
-	{	"0 ? Math.sin(0) : 1", SkType_Int, 1 },
-	{	"intArray[4]", SkType_Unknown },
-	{	"emptyArray[4]", SkType_Unknown },
-	{	"idx", SkType_Int, 2 },
-	{	"intArray.length", SkType_Int, 3 },
-	{	"intArray.values[0]", SkType_Int, 1 },
-	{	"intArray[0]", SkType_Int, 1 },
-	{	"idx.value", SkType_Int, 2 },
-	{	"alpha.value", SkType_String, 0, 0, "abc" },
-	{	"alpha", SkType_String, 0, 0, "abc" },
-	{	"alpha.value+alpha.value", SkType_String, 0, 0, "abcabc" },
-	{	"alpha+idx", SkType_String, 0, 0, "abc2" },
-	{	"idx+alpha", SkType_String, 0, 0, "2abc" },
-	{	"intArray[idx]", SkType_Int, 6 },
-	{	"alpha.slice(1,2)", SkType_String, 0, 0, "b" },
-	{	"alpha.value.slice(1,2)", SkType_String, 0, 0, "b" },
-	{	"Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) },
-	{	"testRect.left+2", SkType_Float, 0, SkIntToScalar(3) },
-	{	"0 ? intArray[0] : 1", SkType_Int, 1 },
-	{	"0 ? intArray.values[0] : 1", SkType_Int, 1 },
-	{	"0 ? idx : 1", SkType_Int, 1 },
-	{	"0 ? idx.value : 1", SkType_Int, 1 },
-	{	"0 ? alpha.slice(1,2) : 1", SkType_Int, 1 },
-	{	"0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 },
-	{ "idy", SkType_Int, 3 }
+    {    "alpha+alpha", SkType_String, 0, 0, "abcabc" },
+    {    "0 ? Math.sin(0) : 1", SkType_Int, 1 },
+    {    "intArray[4]", SkType_Unknown },
+    {    "emptyArray[4]", SkType_Unknown },
+    {    "idx", SkType_Int, 2 },
+    {    "intArray.length", SkType_Int, 3 },
+    {    "intArray.values[0]", SkType_Int, 1 },
+    {    "intArray[0]", SkType_Int, 1 },
+    {    "idx.value", SkType_Int, 2 },
+    {    "alpha.value", SkType_String, 0, 0, "abc" },
+    {    "alpha", SkType_String, 0, 0, "abc" },
+    {    "alpha.value+alpha.value", SkType_String, 0, 0, "abcabc" },
+    {    "alpha+idx", SkType_String, 0, 0, "abc2" },
+    {    "idx+alpha", SkType_String, 0, 0, "2abc" },
+    {    "intArray[idx]", SkType_Int, 6 },
+    {    "alpha.slice(1,2)", SkType_String, 0, 0, "b" },
+    {    "alpha.value.slice(1,2)", SkType_String, 0, 0, "b" },
+    {    "Math.sin(0)", SkType_Float, 0, SkIntToScalar(0) },
+    {    "testRect.left+2", SkType_Float, 0, SkIntToScalar(3) },
+    {    "0 ? intArray[0] : 1", SkType_Int, 1 },
+    {    "0 ? intArray.values[0] : 1", SkType_Int, 1 },
+    {    "0 ? idx : 1", SkType_Int, 1 },
+    {    "0 ? idx.value : 1", SkType_Int, 1 },
+    {    "0 ? alpha.slice(1,2) : 1", SkType_Int, 1 },
+    {    "0 ? alpha.value.slice(1,2) : 1", SkType_Int, 1 },
+    { "idy", SkType_Int, 3 }
 };
 
-#define SkScriptNAnswer_testCount	SK_ARRAY_COUNT(scriptTests)
+#define SkScriptNAnswer_testCount    SK_ARRAY_COUNT(scriptTests)
 
 void SkAnimatorScript2::UnitTest() {
 #if defined(SK_SUPPORT_UNITTEST)
-	SkAnimator animator;
-	SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1));
-	SkEvent evt;
-	evt.setString("id", "evt");
-	evt.setS32("x", 3);
-	animator.doUserEvent(evt);
-	// set up animator with memory script above, then run value tests
-	for (int index = 0; index < SkScriptNAnswer_testCount; index++) {
-		SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType);
-		SkScriptValue2 value;
-		const char* script = scriptTests[index].fScript;
-		bool success = engine.evaluateScript(&script, &value);
-		if (success == false) {
-			SkASSERT(scriptTests[index].fType == SkType_Unknown);
-			continue;
-		}
-		SkASSERT(value.fType == ToOpType(scriptTests[index].fType));
-		SkScalar error;
-		switch (value.fType) {
-			case SkOperand2::kS32:
-				SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
-				break;
-			case SkOperand2::kScalar:
-				error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
-				SkASSERT(error < SK_Scalar1 / 10000);
-				break;
-			case SkOperand2::kString:
-				SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
-				break;
-			default:
-				SkASSERT(0);
-		}
-	}
+    SkAnimator animator;
+    SkASSERT(animator.decodeMemory(scriptTestSetup, sizeof(scriptTestSetup)-1));
+    SkEvent evt;
+    evt.setString("id", "evt");
+    evt.setS32("x", 3);
+    animator.doUserEvent(evt);
+    // set up animator with memory script above, then run value tests
+    for (int index = 0; index < SkScriptNAnswer_testCount; index++) {
+        SkAnimatorScript2 engine(*animator.fMaker, NULL, scriptTests[index].fType);
+        SkScriptValue2 value;
+        const char* script = scriptTests[index].fScript;
+        bool success = engine.evaluateScript(&script, &value);
+        if (success == false) {
+            SkASSERT(scriptTests[index].fType == SkType_Unknown);
+            continue;
+        }
+        SkASSERT(value.fType == ToOpType(scriptTests[index].fType));
+        SkScalar error;
+        switch (value.fType) {
+            case SkOperand2::kS32:
+                SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
+                break;
+            case SkOperand2::kScalar:
+                error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
+                SkASSERT(error < SK_Scalar1 / 10000);
+                break;
+            case SkOperand2::kString:
+                SkASSERT(value.fOperand.fString->equals(scriptTests[index].fStringAnswer));
+                break;
+            default:
+                SkASSERT(0);
+        }
+    }
 #endif
 }
 
diff --git a/src/animator/SkAnimatorScript2.h b/src/animator/SkAnimatorScript2.h
index e6bf58e..c3995f6 100644
--- a/src/animator/SkAnimatorScript2.h
+++ b/src/animator/SkAnimatorScript2.h
@@ -17,33 +17,33 @@
 
 #ifndef SkAnimatorScript_DEFINED
 struct SkDisplayEnumMap {
-	SkDisplayTypes fType;
-	const char* fValues;
+    SkDisplayTypes fType;
+    const char* fValues;
 };
 #endif
 
 class SkAnimatorScript2 : public SkScriptEngine2 {
 public:
-	SkAnimatorScript2(SkAnimateMaker& , SkDisplayable* working, SkDisplayTypes type);
-	~SkAnimatorScript2();
-	bool evalMemberCommon(const SkMemberInfo* info, 
-		SkDisplayable* displayable, SkOperand2* value);
-	SkAnimateMaker& getMaker() { return fMaker; }
-	SkDisplayable* getWorking() { return fWorking; }
-	static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
-	static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type); 
-	static SkDisplayTypes ToDisplayType(SkOperand2::OpType type);
-	static SkOperand2::OpType ToOpType(SkDisplayTypes type);
+    SkAnimatorScript2(SkAnimateMaker& , SkDisplayable* working, SkDisplayTypes type);
+    ~SkAnimatorScript2();
+    bool evalMemberCommon(const SkMemberInfo* info,
+        SkDisplayable* displayable, SkOperand2* value);
+    SkAnimateMaker& getMaker() { return fMaker; }
+    SkDisplayable* getWorking() { return fWorking; }
+    static bool MapEnums(const char* ptr, const char* match, size_t len, int* value);
+    static const SkDisplayEnumMap& GetEnumValues(SkDisplayTypes type);
+    static SkDisplayTypes ToDisplayType(SkOperand2::OpType type);
+    static SkOperand2::OpType ToOpType(SkDisplayTypes type);
 private:
-	SkAnimateMaker& fMaker;
-	SkDisplayable* fWorking;
-	friend class SkDump;
-	friend struct SkScriptNAnswer;
-	// illegal
-	SkAnimatorScript2& operator=(const SkAnimatorScript2&);
+    SkAnimateMaker& fMaker;
+    SkDisplayable* fWorking;
+    friend class SkDump;
+    friend struct SkScriptNAnswer;
+    // illegal
+    SkAnimatorScript2& operator=(const SkAnimatorScript2&);
 #ifdef SK_DEBUG
 public:
-	static void UnitTest();
+    static void UnitTest();
 #endif
 };
 
diff --git a/src/animator/SkBoundable.cpp b/src/animator/SkBoundable.cpp
index 017b6b8..7f36218 100644
--- a/src/animator/SkBoundable.cpp
+++ b/src/animator/SkBoundable.cpp
@@ -39,7 +39,7 @@
 }
 
 
-SkBoundableAuto::SkBoundableAuto(SkBoundable* boundable, 
+SkBoundableAuto::SkBoundableAuto(SkBoundable* boundable,
         SkAnimateMaker& maker) : fBoundable(boundable), fMaker(maker) {
     if (fBoundable->hasBounds()) {
         fMaker.fCanvas->setBounder(&maker.fDisplayList);
diff --git a/src/animator/SkBuildCondensedInfo.cpp b/src/animator/SkBuildCondensedInfo.cpp
index 30da67e..8fb82c7 100644
--- a/src/animator/SkBuildCondensedInfo.cpp
+++ b/src/animator/SkBuildCondensedInfo.cpp
@@ -10,7 +10,7 @@
 #include "SkTypes.h"
 #if defined SK_BUILD_CONDENSED
 #include "SkMemberInfo.h"
-#if SK_USE_CONDENSED_INFO == 1 
+#if SK_USE_CONDENSED_INFO == 1
 #error "SK_USE_CONDENSED_INFO must be zero to build condensed info"
 #endif
 #if !defined SK_BUILD_FOR_WIN32
@@ -115,7 +115,7 @@
             continue;
         AddInfo(gTypeNames[index].fType, info, infoCount);
     }
-    const SkMemberInfo* extraInfo = 
+    const SkMemberInfo* extraInfo =
         SkDisplayType::GetMembers(maker, SkType_3D_Point, &infoCount);
     AddInfo(SkType_Point, extraInfo, infoCount);
     AddInfo(SkType_3D_Point, extraInfo, infoCount);
@@ -239,7 +239,7 @@
             Get3DName(scratch, gTypeNames[typeNameIndex].fName);
         } else
             sprintf(scratch, "Unknown%d", unknown++);
-        fprintf(condensed, "%d%c // %s\n\t", index, 
+        fprintf(condensed, "%d%c // %s\n\t", index,
             index < gInfosCounts.count() ? ',' : ' ', scratch);
     }
     fprintf(condensed, "\n};\n\n");
diff --git a/src/animator/SkCondensedDebug.cpp b/src/animator/SkCondensedDebug.cpp
index c1c7007..08764b6 100644
--- a/src/animator/SkCondensedDebug.cpp
+++ b/src/animator/SkCondensedDebug.cpp
@@ -14,7 +14,7 @@
 // To change it, edit the file with the matching debug info.
 // Then execute SkDisplayType::BuildCondensedInfo() to regenerate this file.
 
-static const char gMathStrings[] = 
+static const char gMathStrings[] =
     "E\0"
     "LN10\0"
     "LN2\0"
@@ -72,7 +72,7 @@
     {123, -18, 66, 98}
 };
 
-static const char gAddStrings[] = 
+static const char gAddStrings[] =
     "inPlace\0"
     "offset\0"
     "use\0"
@@ -86,7 +86,7 @@
     {19, 28, 37, 1}
 };
 
-static const char gAddCircleStrings[] = 
+static const char gAddCircleStrings[] =
     "\0"
     "radius\0"
     "x\0"
@@ -100,7 +100,7 @@
     {10, 32, 98, 1}
 };
 
-static const char gUnknown1Strings[] = 
+static const char gUnknown1Strings[] =
     "direction"
 ;
 
@@ -108,7 +108,7 @@
     {0, 20, 75, 1}
 };
 
-static const char gAddOvalStrings[] = 
+static const char gAddOvalStrings[] =
     ""
 ;
 
@@ -116,7 +116,7 @@
     {0, 6, 18, 5}
 };
 
-static const char gAddPathStrings[] = 
+static const char gAddPathStrings[] =
     "matrix\0"
     "path"
 ;
@@ -126,7 +126,7 @@
     {7, 24, 74, 1}
 };
 
-static const char gAddRectangleStrings[] = 
+static const char gAddRectangleStrings[] =
     "\0"
     "bottom\0"
     "left\0"
@@ -142,7 +142,7 @@
     {19, 28, 98, 1}
 };
 
-static const char gAddRoundRectStrings[] = 
+static const char gAddRoundRectStrings[] =
     "\0"
     "rx\0"
     "ry"
@@ -154,7 +154,7 @@
     {4, 44, 98, 1}
 };
 
-static const char gUnknown2Strings[] = 
+static const char gUnknown2Strings[] =
     "begin\0"
     "blend\0"
     "dur\0"
@@ -186,7 +186,7 @@
     {73, -4, 67, 40}
 };
 
-static const char gAnimateFieldStrings[] = 
+static const char gAnimateFieldStrings[] =
     ""
 ;
 
@@ -194,7 +194,7 @@
     {0, 8, 18, 13}
 };
 
-static const char gApplyStrings[] = 
+static const char gApplyStrings[] =
     "animator\0"
     "begin\0"
     "dontDraw\0"
@@ -226,7 +226,7 @@
     {88, 56, 14, 1}
 };
 
-static const char gUnknown3Strings[] = 
+static const char gUnknown3Strings[] =
     "x\0"
     "y"
 ;
@@ -236,7 +236,7 @@
     {2, 52, 98, 1}
 };
 
-static const char gBitmapStrings[] = 
+static const char gBitmapStrings[] =
     "\0"
     "erase\0"
     "format\0"
@@ -254,7 +254,7 @@
     {30, 68, 96, 1}
 };
 
-static const char gBitmapShaderStrings[] = 
+static const char gBitmapShaderStrings[] =
     "\0"
     "filterType\0"
     "image"
@@ -266,7 +266,7 @@
     {12, 32, 17, 1}
 };
 
-static const char gBlurStrings[] = 
+static const char gBlurStrings[] =
     "blurStyle\0"
     "radius"
 ;
@@ -276,7 +276,7 @@
     {10, 20, 98, 1}
 };
 
-static const char gBoundsStrings[] = 
+static const char gBoundsStrings[] =
     "\0"
     "inval"
 ;
@@ -286,7 +286,7 @@
     {1, 44, 26, 1}
 };
 
-static const char gClipStrings[] = 
+static const char gClipStrings[] =
     "path\0"
     "rectangle"
 ;
@@ -296,7 +296,7 @@
     {5, 16, 91, 1}
 };
 
-static const char gColorStrings[] = 
+static const char gColorStrings[] =
     "alpha\0"
     "blue\0"
     "color\0"
@@ -318,7 +318,7 @@
     {42, -7, 67, 98}
 };
 
-static const char gCubicToStrings[] = 
+static const char gCubicToStrings[] =
     "x1\0"
     "x2\0"
     "x3\0"
@@ -336,7 +336,7 @@
     {15, 40, 98, 1}
 };
 
-static const char gDashStrings[] = 
+static const char gDashStrings[] =
     "intervals\0"
     "phase"
 ;
@@ -346,7 +346,7 @@
     {10, 36, 98, 1}
 };
 
-static const char gDataStrings[] = 
+static const char gDataStrings[] =
     "\0"
     "name"
 ;
@@ -356,7 +356,7 @@
     {1, 32, 108, 2}
 };
 
-static const char gDiscreteStrings[] = 
+static const char gDiscreteStrings[] =
     "deviation\0"
     "segLength"
 ;
@@ -366,7 +366,7 @@
     {10, 24, 98, 1}
 };
 
-static const char gDrawToStrings[] = 
+static const char gDrawToStrings[] =
     "drawOnce\0"
     "use"
 ;
@@ -376,7 +376,7 @@
     {9, 76, 19, 1}
 };
 
-static const char gDumpStrings[] = 
+static const char gDumpStrings[] =
     "displayList\0"
     "eventList\0"
     "events\0"
@@ -394,7 +394,7 @@
     {41, 40, 26, 1}
 };
 
-static const char gEmbossStrings[] = 
+static const char gEmbossStrings[] =
     "ambient\0"
     "direction\0"
     "radius\0"
@@ -408,7 +408,7 @@
     {25, -2, 67, 98}
 };
 
-static const char gEventStrings[] = 
+static const char gEventStrings[] =
     "code\0"
     "disable\0"
     "key\0"
@@ -430,7 +430,7 @@
     {36, 40, 98, 1}
 };
 
-static const char gFromPathStrings[] = 
+static const char gFromPathStrings[] =
     "mode\0"
     "offset\0"
     "path"
@@ -442,7 +442,7 @@
     {12, 28, 74, 1}
 };
 
-static const char gUnknown4Strings[] = 
+static const char gUnknown4Strings[] =
     "\0"
     "offsets\0"
     "unitMapper"
@@ -454,7 +454,7 @@
     {9, 44, 108, 2}
 };
 
-static const char gGStrings[] = 
+static const char gGStrings[] =
     "condition\0"
     "enableCondition"
 ;
@@ -464,7 +464,7 @@
     {10, 24, 40, 2}
 };
 
-static const char gHitClearStrings[] = 
+static const char gHitClearStrings[] =
     "targets"
 ;
 
@@ -472,7 +472,7 @@
     {0, 16, 119, 36}
 };
 
-static const char gHitTestStrings[] = 
+static const char gHitTestStrings[] =
     "bullets\0"
     "hits\0"
     "targets\0"
@@ -486,7 +486,7 @@
     {21, 64, 26, 1}
 };
 
-static const char gImageStrings[] = 
+static const char gImageStrings[] =
     "\0"
     "base64\0"
     "src"
@@ -498,7 +498,7 @@
     {8, 64, 108, 2}
 };
 
-static const char gIncludeStrings[] = 
+static const char gIncludeStrings[] =
     "src"
 ;
 
@@ -506,7 +506,7 @@
     {0, 16, 108, 2}
 };
 
-static const char gInputStrings[] = 
+static const char gInputStrings[] =
     "s32\0"
     "scalar\0"
     "string"
@@ -518,7 +518,7 @@
     {11, 24, 108, 2}
 };
 
-static const char gLineStrings[] = 
+static const char gLineStrings[] =
     "x1\0"
     "x2\0"
     "y1\0"
@@ -532,7 +532,7 @@
     {9, 36, 98, 1}
 };
 
-static const char gLineToStrings[] = 
+static const char gLineToStrings[] =
     "x\0"
     "y"
 ;
@@ -542,7 +542,7 @@
     {2, 24, 98, 1}
 };
 
-static const char gLinearGradientStrings[] = 
+static const char gLinearGradientStrings[] =
     "\0"
     "points"
 ;
@@ -552,7 +552,7 @@
     {1, 88, 77, 4}
 };
 
-static const char gMatrixStrings[] = 
+static const char gMatrixStrings[] =
     "matrix\0"
     "perspectX\0"
     "perspectY\0"
@@ -582,7 +582,7 @@
     {87, -11, 67, 98}
 };
 
-static const char gMoveStrings[] = 
+static const char gMoveStrings[] =
     ""
 ;
 
@@ -590,7 +590,7 @@
     {0, 1, 18, 4}
 };
 
-static const char gMoveToStrings[] = 
+static const char gMoveToStrings[] =
     "x\0"
     "y"
 ;
@@ -600,7 +600,7 @@
     {2, 24, 98, 1}
 };
 
-static const char gMovieStrings[] = 
+static const char gMovieStrings[] =
     "src"
 ;
 
@@ -608,7 +608,7 @@
     {0, 16, 108, 2}
 };
 
-static const char gOvalStrings[] = 
+static const char gOvalStrings[] =
     ""
 ;
 
@@ -616,7 +616,7 @@
     {0, 58, 18, 7}
 };
 
-static const char gPaintStrings[] = 
+static const char gPaintStrings[] =
     "antiAlias\0"
     "ascent\0"
     "color\0"
@@ -672,7 +672,7 @@
     {235, 100, 121, 1}
 };
 
-static const char gPathStrings[] = 
+static const char gPathStrings[] =
     "d\0"
     "fillType\0"
     "length"
@@ -684,7 +684,7 @@
     {11, -2, 67, 98}
 };
 
-static const char gUnknown5Strings[] = 
+static const char gUnknown5Strings[] =
     "x\0"
     "y\0"
     "z"
@@ -696,7 +696,7 @@
     {4, 8, 98, 1}
 };
 
-static const char gPointStrings[] = 
+static const char gPointStrings[] =
     "x\0"
     "y"
 ;
@@ -706,7 +706,7 @@
     {2, 20, 98, 1}
 };
 
-static const char gPolyToPolyStrings[] = 
+static const char gPolyToPolyStrings[] =
     "destination\0"
     "source"
 ;
@@ -716,7 +716,7 @@
     {12, 20, 80, 1}
 };
 
-static const char gPolygonStrings[] = 
+static const char gPolygonStrings[] =
     ""
 ;
 
@@ -724,7 +724,7 @@
     {0, 48, 18, 1}
 };
 
-static const char gPolylineStrings[] = 
+static const char gPolylineStrings[] =
     "points"
 ;
 
@@ -732,7 +732,7 @@
     {0, 88, 119, 98}
 };
 
-static const char gPostStrings[] = 
+static const char gPostStrings[] =
     "delay\0"
     "initialized\0"
     "mode\0"
@@ -750,7 +750,7 @@
     {35, -3, 67, 108}
 };
 
-static const char gQuadToStrings[] = 
+static const char gQuadToStrings[] =
     "x1\0"
     "x2\0"
     "y1\0"
@@ -764,7 +764,7 @@
     {9, 32, 98, 1}
 };
 
-static const char gRCubicToStrings[] = 
+static const char gRCubicToStrings[] =
     ""
 ;
 
@@ -772,7 +772,7 @@
     {0, 18, 18, 6}
 };
 
-static const char gRLineToStrings[] = 
+static const char gRLineToStrings[] =
     ""
 ;
 
@@ -780,7 +780,7 @@
     {0, 35, 18, 2}
 };
 
-static const char gRMoveToStrings[] = 
+static const char gRMoveToStrings[] =
     ""
 ;
 
@@ -788,7 +788,7 @@
     {0, 39, 18, 2}
 };
 
-static const char gRQuadToStrings[] = 
+static const char gRQuadToStrings[] =
     ""
 ;
 
@@ -796,7 +796,7 @@
     {0, 50, 18, 4}
 };
 
-static const char gRadialGradientStrings[] = 
+static const char gRadialGradientStrings[] =
     "\0"
     "center\0"
     "radius"
@@ -808,7 +808,7 @@
     {8, 96, 98, 1}
 };
 
-static const char gRandomStrings[] = 
+static const char gRandomStrings[] =
     "blend\0"
     "max\0"
     "min\0"
@@ -824,7 +824,7 @@
     {21, -2, 67, 96}
 };
 
-static const char gRectToRectStrings[] = 
+static const char gRectToRectStrings[] =
     "destination\0"
     "source"
 ;
@@ -834,7 +834,7 @@
     {12, 20, 91, 1}
 };
 
-static const char gRectangleStrings[] = 
+static const char gRectangleStrings[] =
     "bottom\0"
     "height\0"
     "left\0"
@@ -854,7 +854,7 @@
     {41, -3, 67, 98}
 };
 
-static const char gRemoveStrings[] = 
+static const char gRemoveStrings[] =
     "offset\0"
     "where"
 ;
@@ -864,7 +864,7 @@
     {7, 28, 37, 1}
 };
 
-static const char gReplaceStrings[] = 
+static const char gReplaceStrings[] =
     ""
 ;
 
@@ -872,7 +872,7 @@
     {0, 1, 18, 4}
 };
 
-static const char gRotateStrings[] = 
+static const char gRotateStrings[] =
     "center\0"
     "degrees"
 ;
@@ -882,7 +882,7 @@
     {7, 20, 98, 1}
 };
 
-static const char gRoundRectStrings[] = 
+static const char gRoundRectStrings[] =
     "\0"
     "rx\0"
     "ry"
@@ -894,7 +894,7 @@
     {4, 48, 98, 1}
 };
 
-static const char gS32Strings[] = 
+static const char gS32Strings[] =
     "value"
 ;
 
@@ -902,7 +902,7 @@
     {0, 16, 96, 1}
 };
 
-static const char gScalarStrings[] = 
+static const char gScalarStrings[] =
     "value"
 ;
 
@@ -910,7 +910,7 @@
     {0, 16, 98, 1}
 };
 
-static const char gScaleStrings[] = 
+static const char gScaleStrings[] =
     "center\0"
     "x\0"
     "y"
@@ -922,7 +922,7 @@
     {9, 24, 98, 1}
 };
 
-static const char gSetStrings[] = 
+static const char gSetStrings[] =
     "begin\0"
     "dur\0"
     "dynamic\0"
@@ -944,7 +944,7 @@
     {45, 76, 40, 2}
 };
 
-static const char gShaderStrings[] = 
+static const char gShaderStrings[] =
     "matrix\0"
     "tileMode"
 ;
@@ -954,7 +954,7 @@
     {7, 24, 116, 1}
 };
 
-static const char gSkewStrings[] = 
+static const char gSkewStrings[] =
     "center\0"
     "x\0"
     "y"
@@ -966,7 +966,7 @@
     {9, 24, 98, 1}
 };
 
-static const char g3D_CameraStrings[] = 
+static const char g3D_CameraStrings[] =
     "axis\0"
     "hackHeight\0"
     "hackWidth\0"
@@ -986,7 +986,7 @@
     {50, 48, 106, 3}
 };
 
-static const char g3D_PatchStrings[] = 
+static const char g3D_PatchStrings[] =
     "origin\0"
     "rotateDegrees\0"
     "u\0"
@@ -1000,7 +1000,7 @@
     {23, 28, 106, 3}
 };
 
-static const char gUnknown6Strings[] = 
+static const char gUnknown6Strings[] =
     "x\0"
     "y\0"
     "z"
@@ -1012,7 +1012,7 @@
     {4, 8, 98, 1}
 };
 
-static const char gSnapshotStrings[] = 
+static const char gSnapshotStrings[] =
     "filename\0"
     "quality\0"
     "sequence\0"
@@ -1026,7 +1026,7 @@
     {26, 32, 20, 1}
 };
 
-static const char gStringStrings[] = 
+static const char gStringStrings[] =
     "length\0"
     "slice\0"
     "value"
@@ -1038,7 +1038,7 @@
     {13, 16, 108, 2}
 };
 
-static const char gTextStrings[] = 
+static const char gTextStrings[] =
     "length\0"
     "text\0"
     "x\0"
@@ -1052,7 +1052,7 @@
     {14, 36, 98, 1}
 };
 
-static const char gTextBoxStrings[] = 
+static const char gTextBoxStrings[] =
     "\0"
     "mode\0"
     "spacingAdd\0"
@@ -1070,7 +1070,7 @@
     {41, 44, 108, 2}
 };
 
-static const char gTextOnPathStrings[] = 
+static const char gTextOnPathStrings[] =
     "offset\0"
     "path\0"
     "text"
@@ -1082,7 +1082,7 @@
     {12, 32, 110, 1}
 };
 
-static const char gTextToPathStrings[] = 
+static const char gTextToPathStrings[] =
     "path\0"
     "text"
 ;
@@ -1092,7 +1092,7 @@
     {5, 20, 110, 1}
 };
 
-static const char gTranslateStrings[] = 
+static const char gTranslateStrings[] =
     "x\0"
     "y"
 ;
@@ -1102,7 +1102,7 @@
     {2, 24, 98, 1}
 };
 
-static const char gTypedArrayStrings[] = 
+static const char gTypedArrayStrings[] =
     "length\0"
     "values"
 ;
@@ -1112,7 +1112,7 @@
     {7, 16, 119, 0}
 };
 
-static const char gTypefaceStrings[] = 
+static const char gTypefaceStrings[] =
     "fontName"
 ;
 
@@ -1294,7 +1294,7 @@
     117, // Translate
     119, // TypedArray
     120, // Typeface
-    
+
 };
 
 static const int kTypeIDs = 81;
diff --git a/src/animator/SkCondensedRelease.cpp b/src/animator/SkCondensedRelease.cpp
index 234e67e..60fa991 100644
--- a/src/animator/SkCondensedRelease.cpp
+++ b/src/animator/SkCondensedRelease.cpp
@@ -14,7 +14,7 @@
 // To change it, edit the file with the matching debug info.
 // Then execute SkDisplayType::BuildCondensedInfo() to regenerate this file.
 
-static const char gMathStrings[] = 
+static const char gMathStrings[] =
     "E\0"
     "LN10\0"
     "LN2\0"
@@ -72,7 +72,7 @@
     {123, -18, 66, 98}
 };
 
-static const char gAddStrings[] = 
+static const char gAddStrings[] =
     "inPlace\0"
     "offset\0"
     "use\0"
@@ -86,7 +86,7 @@
     {19, 16, 37, 1}
 };
 
-static const char gAddCircleStrings[] = 
+static const char gAddCircleStrings[] =
     "\0"
     "radius\0"
     "x\0"
@@ -100,7 +100,7 @@
     {10, 20, 98, 1}
 };
 
-static const char gUnknown1Strings[] = 
+static const char gUnknown1Strings[] =
     "direction"
 ;
 
@@ -108,7 +108,7 @@
     {0, 8, 75, 1}
 };
 
-static const char gAddOvalStrings[] = 
+static const char gAddOvalStrings[] =
     ""
 ;
 
@@ -116,7 +116,7 @@
     {0, 6, 18, 5}
 };
 
-static const char gAddPathStrings[] = 
+static const char gAddPathStrings[] =
     "matrix\0"
     "path"
 ;
@@ -126,7 +126,7 @@
     {7, 12, 74, 1}
 };
 
-static const char gAddRectangleStrings[] = 
+static const char gAddRectangleStrings[] =
     "\0"
     "bottom\0"
     "left\0"
@@ -142,7 +142,7 @@
     {19, 16, 98, 1}
 };
 
-static const char gAddRoundRectStrings[] = 
+static const char gAddRoundRectStrings[] =
     "\0"
     "rx\0"
     "ry"
@@ -154,7 +154,7 @@
     {4, 32, 98, 1}
 };
 
-static const char gUnknown2Strings[] = 
+static const char gUnknown2Strings[] =
     "begin\0"
     "blend\0"
     "dur\0"
@@ -186,7 +186,7 @@
     {73, -4, 67, 40}
 };
 
-static const char gAnimateFieldStrings[] = 
+static const char gAnimateFieldStrings[] =
     ""
 ;
 
@@ -194,7 +194,7 @@
     {0, 8, 18, 13}
 };
 
-static const char gApplyStrings[] = 
+static const char gApplyStrings[] =
     "animator\0"
     "begin\0"
     "dontDraw\0"
@@ -226,7 +226,7 @@
     {88, 40, 14, 1}
 };
 
-static const char gUnknown3Strings[] = 
+static const char gUnknown3Strings[] =
     "x\0"
     "y"
 ;
@@ -236,7 +236,7 @@
     {2, 40, 98, 1}
 };
 
-static const char gBitmapStrings[] = 
+static const char gBitmapStrings[] =
     "\0"
     "erase\0"
     "format\0"
@@ -254,7 +254,7 @@
     {30, 56, 96, 1}
 };
 
-static const char gBitmapShaderStrings[] = 
+static const char gBitmapShaderStrings[] =
     "\0"
     "filterType\0"
     "image"
@@ -266,7 +266,7 @@
     {12, 20, 17, 1}
 };
 
-static const char gBlurStrings[] = 
+static const char gBlurStrings[] =
     "blurStyle\0"
     "radius"
 ;
@@ -276,7 +276,7 @@
     {10, 8, 98, 1}
 };
 
-static const char gBoundsStrings[] = 
+static const char gBoundsStrings[] =
     "\0"
     "inval"
 ;
@@ -286,7 +286,7 @@
     {1, 32, 26, 1}
 };
 
-static const char gClipStrings[] = 
+static const char gClipStrings[] =
     "path\0"
     "rectangle"
 ;
@@ -296,7 +296,7 @@
     {5, 4, 91, 1}
 };
 
-static const char gColorStrings[] = 
+static const char gColorStrings[] =
     "alpha\0"
     "blue\0"
     "color\0"
@@ -318,7 +318,7 @@
     {42, -7, 67, 98}
 };
 
-static const char gCubicToStrings[] = 
+static const char gCubicToStrings[] =
     "x1\0"
     "x2\0"
     "x3\0"
@@ -336,7 +336,7 @@
     {15, 28, 98, 1}
 };
 
-static const char gDashStrings[] = 
+static const char gDashStrings[] =
     "intervals\0"
     "phase"
 ;
@@ -346,7 +346,7 @@
     {10, 16, 98, 1}
 };
 
-static const char gDataStrings[] = 
+static const char gDataStrings[] =
     "\0"
     "name"
 ;
@@ -356,7 +356,7 @@
     {1, 16, 108, 1}
 };
 
-static const char gDiscreteStrings[] = 
+static const char gDiscreteStrings[] =
     "deviation\0"
     "segLength"
 ;
@@ -366,7 +366,7 @@
     {10, 12, 98, 1}
 };
 
-static const char gDrawToStrings[] = 
+static const char gDrawToStrings[] =
     "drawOnce\0"
     "use"
 ;
@@ -376,7 +376,7 @@
     {9, 40, 19, 1}
 };
 
-static const char gEmbossStrings[] = 
+static const char gEmbossStrings[] =
     "ambient\0"
     "direction\0"
     "radius\0"
@@ -390,7 +390,7 @@
     {25, -2, 67, 98}
 };
 
-static const char gEventStrings[] = 
+static const char gEventStrings[] =
     "code\0"
     "disable\0"
     "key\0"
@@ -412,7 +412,7 @@
     {36, 24, 98, 1}
 };
 
-static const char gFromPathStrings[] = 
+static const char gFromPathStrings[] =
     "mode\0"
     "offset\0"
     "path"
@@ -424,7 +424,7 @@
     {12, 16, 74, 1}
 };
 
-static const char gUnknown4Strings[] = 
+static const char gUnknown4Strings[] =
     "\0"
     "offsets\0"
     "unitMapper"
@@ -436,7 +436,7 @@
     {9, 24, 108, 1}
 };
 
-static const char gGStrings[] = 
+static const char gGStrings[] =
     "condition\0"
     "enableCondition"
 ;
@@ -446,7 +446,7 @@
     {10, 8, 40, 1}
 };
 
-static const char gHitClearStrings[] = 
+static const char gHitClearStrings[] =
     "targets"
 ;
 
@@ -454,7 +454,7 @@
     {0, 4, 119, 36}
 };
 
-static const char gHitTestStrings[] = 
+static const char gHitTestStrings[] =
     "bullets\0"
     "hits\0"
     "targets\0"
@@ -468,7 +468,7 @@
     {21, 28, 26, 1}
 };
 
-static const char gImageStrings[] = 
+static const char gImageStrings[] =
     "\0"
     "base64\0"
     "src"
@@ -480,7 +480,7 @@
     {8, 52, 108, 1}
 };
 
-static const char gIncludeStrings[] = 
+static const char gIncludeStrings[] =
     "src"
 ;
 
@@ -488,7 +488,7 @@
     {0, 4, 108, 1}
 };
 
-static const char gInputStrings[] = 
+static const char gInputStrings[] =
     "s32\0"
     "scalar\0"
     "string"
@@ -500,7 +500,7 @@
     {11, 12, 108, 1}
 };
 
-static const char gLineStrings[] = 
+static const char gLineStrings[] =
     "x1\0"
     "x2\0"
     "y1\0"
@@ -514,7 +514,7 @@
     {9, 24, 98, 1}
 };
 
-static const char gLineToStrings[] = 
+static const char gLineToStrings[] =
     "x\0"
     "y"
 ;
@@ -524,7 +524,7 @@
     {2, 12, 98, 1}
 };
 
-static const char gLinearGradientStrings[] = 
+static const char gLinearGradientStrings[] =
     "\0"
     "points"
 ;
@@ -534,7 +534,7 @@
     {1, 48, 77, 4}
 };
 
-static const char gMatrixStrings[] = 
+static const char gMatrixStrings[] =
     "matrix\0"
     "perspectX\0"
     "perspectY\0"
@@ -564,7 +564,7 @@
     {87, -11, 67, 98}
 };
 
-static const char gMoveStrings[] = 
+static const char gMoveStrings[] =
     ""
 ;
 
@@ -572,7 +572,7 @@
     {0, 1, 18, 4}
 };
 
-static const char gMoveToStrings[] = 
+static const char gMoveToStrings[] =
     "x\0"
     "y"
 ;
@@ -582,7 +582,7 @@
     {2, 12, 98, 1}
 };
 
-static const char gMovieStrings[] = 
+static const char gMovieStrings[] =
     "src"
 ;
 
@@ -590,7 +590,7 @@
     {0, 4, 108, 1}
 };
 
-static const char gOvalStrings[] = 
+static const char gOvalStrings[] =
     ""
 ;
 
@@ -598,7 +598,7 @@
     {0, 57, 18, 7}
 };
 
-static const char gPaintStrings[] = 
+static const char gPaintStrings[] =
     "antiAlias\0"
     "ascent\0"
     "color\0"
@@ -654,7 +654,7 @@
     {235, 88, 121, 1}
 };
 
-static const char gPathStrings[] = 
+static const char gPathStrings[] =
     "d\0"
     "fillType\0"
     "length"
@@ -666,7 +666,7 @@
     {11, -2, 67, 98}
 };
 
-static const char gUnknown5Strings[] = 
+static const char gUnknown5Strings[] =
     "x\0"
     "y\0"
     "z"
@@ -678,7 +678,7 @@
     {4, 8, 98, 1}
 };
 
-static const char gPointStrings[] = 
+static const char gPointStrings[] =
     "x\0"
     "y"
 ;
@@ -688,7 +688,7 @@
     {2, 8, 98, 1}
 };
 
-static const char gPolyToPolyStrings[] = 
+static const char gPolyToPolyStrings[] =
     "destination\0"
     "source"
 ;
@@ -698,7 +698,7 @@
     {12, 8, 80, 1}
 };
 
-static const char gPolygonStrings[] = 
+static const char gPolygonStrings[] =
     ""
 ;
 
@@ -706,7 +706,7 @@
     {0, 47, 18, 1}
 };
 
-static const char gPolylineStrings[] = 
+static const char gPolylineStrings[] =
     "points"
 ;
 
@@ -714,7 +714,7 @@
     {0, 56, 119, 98}
 };
 
-static const char gPostStrings[] = 
+static const char gPostStrings[] =
     "delay\0"
     "initialized\0"
     "mode\0"
@@ -732,7 +732,7 @@
     {35, -3, 67, 108}
 };
 
-static const char gQuadToStrings[] = 
+static const char gQuadToStrings[] =
     "x1\0"
     "x2\0"
     "y1\0"
@@ -746,7 +746,7 @@
     {9, 20, 98, 1}
 };
 
-static const char gRCubicToStrings[] = 
+static const char gRCubicToStrings[] =
     ""
 ;
 
@@ -754,7 +754,7 @@
     {0, 18, 18, 6}
 };
 
-static const char gRLineToStrings[] = 
+static const char gRLineToStrings[] =
     ""
 ;
 
@@ -762,7 +762,7 @@
     {0, 34, 18, 2}
 };
 
-static const char gRMoveToStrings[] = 
+static const char gRMoveToStrings[] =
     ""
 ;
 
@@ -770,7 +770,7 @@
     {0, 38, 18, 2}
 };
 
-static const char gRQuadToStrings[] = 
+static const char gRQuadToStrings[] =
     ""
 ;
 
@@ -778,7 +778,7 @@
     {0, 49, 18, 4}
 };
 
-static const char gRadialGradientStrings[] = 
+static const char gRadialGradientStrings[] =
     "\0"
     "center\0"
     "radius"
@@ -790,7 +790,7 @@
     {8, 56, 98, 1}
 };
 
-static const char gRandomStrings[] = 
+static const char gRandomStrings[] =
     "blend\0"
     "max\0"
     "min\0"
@@ -806,7 +806,7 @@
     {21, -2, 67, 96}
 };
 
-static const char gRectToRectStrings[] = 
+static const char gRectToRectStrings[] =
     "destination\0"
     "source"
 ;
@@ -816,7 +816,7 @@
     {12, 8, 91, 1}
 };
 
-static const char gRectangleStrings[] = 
+static const char gRectangleStrings[] =
     "bottom\0"
     "height\0"
     "left\0"
@@ -836,7 +836,7 @@
     {41, -3, 67, 98}
 };
 
-static const char gRemoveStrings[] = 
+static const char gRemoveStrings[] =
     "offset\0"
     "where"
 ;
@@ -846,7 +846,7 @@
     {7, 16, 37, 1}
 };
 
-static const char gReplaceStrings[] = 
+static const char gReplaceStrings[] =
     ""
 ;
 
@@ -854,7 +854,7 @@
     {0, 1, 18, 4}
 };
 
-static const char gRotateStrings[] = 
+static const char gRotateStrings[] =
     "center\0"
     "degrees"
 ;
@@ -864,7 +864,7 @@
     {7, 8, 98, 1}
 };
 
-static const char gRoundRectStrings[] = 
+static const char gRoundRectStrings[] =
     "\0"
     "rx\0"
     "ry"
@@ -876,7 +876,7 @@
     {4, 36, 98, 1}
 };
 
-static const char gS32Strings[] = 
+static const char gS32Strings[] =
     "value"
 ;
 
@@ -884,7 +884,7 @@
     {0, 4, 96, 1}
 };
 
-static const char gScalarStrings[] = 
+static const char gScalarStrings[] =
     "value"
 ;
 
@@ -892,7 +892,7 @@
     {0, 4, 98, 1}
 };
 
-static const char gScaleStrings[] = 
+static const char gScaleStrings[] =
     "center\0"
     "x\0"
     "y"
@@ -904,7 +904,7 @@
     {9, 12, 98, 1}
 };
 
-static const char gSetStrings[] = 
+static const char gSetStrings[] =
     "begin\0"
     "dur\0"
     "dynamic\0"
@@ -926,7 +926,7 @@
     {45, 40, 40, 1}
 };
 
-static const char gShaderStrings[] = 
+static const char gShaderStrings[] =
     "matrix\0"
     "tileMode"
 ;
@@ -936,7 +936,7 @@
     {7, 12, 116, 1}
 };
 
-static const char gSkewStrings[] = 
+static const char gSkewStrings[] =
     "center\0"
     "x\0"
     "y"
@@ -948,7 +948,7 @@
     {9, 12, 98, 1}
 };
 
-static const char g3D_CameraStrings[] = 
+static const char g3D_CameraStrings[] =
     "axis\0"
     "hackHeight\0"
     "hackWidth\0"
@@ -968,7 +968,7 @@
     {50, 36, 106, 3}
 };
 
-static const char g3D_PatchStrings[] = 
+static const char g3D_PatchStrings[] =
     "origin\0"
     "rotateDegrees\0"
     "u\0"
@@ -982,7 +982,7 @@
     {23, 16, 106, 3}
 };
 
-static const char gUnknown6Strings[] = 
+static const char gUnknown6Strings[] =
     "x\0"
     "y\0"
     "z"
@@ -994,7 +994,7 @@
     {4, 8, 98, 1}
 };
 
-static const char gSnapshotStrings[] = 
+static const char gSnapshotStrings[] =
     "filename\0"
     "quality\0"
     "sequence\0"
@@ -1008,7 +1008,7 @@
     {26, 16, 20, 1}
 };
 
-static const char gStringStrings[] = 
+static const char gStringStrings[] =
     "length\0"
     "slice\0"
     "value"
@@ -1020,7 +1020,7 @@
     {13, 4, 108, 1}
 };
 
-static const char gTextStrings[] = 
+static const char gTextStrings[] =
     "length\0"
     "text\0"
     "x\0"
@@ -1034,7 +1034,7 @@
     {14, 20, 98, 1}
 };
 
-static const char gTextBoxStrings[] = 
+static const char gTextBoxStrings[] =
     "\0"
     "mode\0"
     "spacingAdd\0"
@@ -1052,7 +1052,7 @@
     {41, 32, 108, 1}
 };
 
-static const char gTextOnPathStrings[] = 
+static const char gTextOnPathStrings[] =
     "offset\0"
     "path\0"
     "text"
@@ -1064,7 +1064,7 @@
     {12, 20, 110, 1}
 };
 
-static const char gTextToPathStrings[] = 
+static const char gTextToPathStrings[] =
     "path\0"
     "text"
 ;
@@ -1074,7 +1074,7 @@
     {5, 8, 110, 1}
 };
 
-static const char gTranslateStrings[] = 
+static const char gTranslateStrings[] =
     "x\0"
     "y"
 ;
@@ -1084,7 +1084,7 @@
     {2, 12, 98, 1}
 };
 
-static const char gTypedArrayStrings[] = 
+static const char gTypedArrayStrings[] =
     "length\0"
     "values"
 ;
@@ -1094,7 +1094,7 @@
     {7, 4, 119, 0}
 };
 
-static const char gTypefaceStrings[] = 
+static const char gTypefaceStrings[] =
     "fontName"
 ;
 
@@ -1274,7 +1274,7 @@
     117, // Translate
     119, // TypedArray
     120, // Typeface
-    
+
 };
 
 static const int kTypeIDs = 80;
diff --git a/src/animator/SkDisplayAdd.cpp b/src/animator/SkDisplayAdd.cpp
index 1cf89a1..7fd5026 100644
--- a/src/animator/SkDisplayAdd.cpp
+++ b/src/animator/SkDisplayAdd.cpp
@@ -33,7 +33,7 @@
 
 DEFINE_GET_MEMBER(SkAdd);
 
-SkAdd::SkAdd() : mode(kMode_indirect), 
+SkAdd::SkAdd() : mode(kMode_indirect),
     offset(SK_MaxS32), use(NULL), where(NULL) {
 }
 
@@ -119,7 +119,7 @@
                                 parentGroup->markCopySet(index);
                                 useParentList->begin()[index] = use;
                                 break;
-                            }                               
+                            }
                         }
                         *parentList->append() = use;
                     }
diff --git a/src/animator/SkDisplayAdd.h b/src/animator/SkDisplayAdd.h
index 47948fb..5883963 100644
--- a/src/animator/SkDisplayAdd.h
+++ b/src/animator/SkDisplayAdd.h
@@ -16,12 +16,12 @@
 class SkAdd : public SkDrawable {
     DECLARE_MEMBER_INFO(Add);
     SkAdd();
-    
+
     enum Mode {
         kMode_indirect,
         kMode_immediate
     };
-    
+
     virtual SkDisplayable* deepCopy(SkAnimateMaker* );
     virtual bool draw(SkAnimateMaker& );
 #ifdef SK_DUMP_ENABLED
diff --git a/src/animator/SkDisplayApply.cpp b/src/animator/SkDisplayApply.cpp
index d54ee26..baa10e7 100644
--- a/src/animator/SkDisplayApply.cpp
+++ b/src/animator/SkDisplayApply.cpp
@@ -51,13 +51,13 @@
     SK_MEMBER(transition, ApplyTransition)
 };
 
-#endif 
+#endif
 
 DEFINE_GET_MEMBER(SkApply);
 
 SkApply::SkApply() : begin(0), dontDraw(false), interval((SkMSec) -1), mode((Mode) -1), /*pickup(false), */
     restore(false), scope(NULL), steps(-1), transition((Transition) -1), fActive(NULL), /*fCurrentScope(NULL),*/
-    fLastTime(0), fAppended(false), fContainsScope(false), fDeleteScope(false), fEmbedded(false), 
+    fLastTime(0), fAppended(false), fContainsScope(false), fDeleteScope(false), fEmbedded(false),
     fEnabled(false), fEnabling(false) {
 }
 
@@ -105,7 +105,7 @@
 }
 
 void SkApply::applyValues(int animatorIndex, SkOperand* values, int count,
-     SkDisplayTypes valuesType, SkMSec time) 
+     SkDisplayTypes valuesType, SkMSec time)
 {
     SkAnimateBase* animator = fActive->fAnimators[animatorIndex];
     const SkMemberInfo * info = animator->fFieldInfo;
@@ -149,7 +149,7 @@
             target->setReference(info, values->fDisplayable);
         else
             info->setValue(target, values, count);
-    } 
+    }
 }
 
 bool SkApply::contains(SkDisplayable* child) {
@@ -178,7 +178,7 @@
     //!!! this is the right thing to do, but has bad side effects because of other problems
     // currently, if an apply is in a g and scopes a statement in another g, it ends up as members
     // of both containers. The disabling here incorrectly disables both instances
-    // maybe the fEnabled flag needs to be moved to the fActive data so that both 
+    // maybe the fEnabled flag needs to be moved to the fActive data so that both
     // instances are not affected.
 //  fEnabled = false;
 }
@@ -265,7 +265,7 @@
     bool initialized = fActive != NULL;
     if (dynamicScope.size() > 0)
         enableDynamic(maker);
-    if (maker.fError.hasError()) 
+    if (maker.fError.hasError())
         return false;
     int animators = fAnimators.count();
     int index;
@@ -333,7 +333,7 @@
     }
 #endif
 //  start here;
-    // now that one apply might embed another, only the parent apply should replace the scope 
+    // now that one apply might embed another, only the parent apply should replace the scope
     // or get appended to the display list
     // similarly, an apply added by an add immediate has already been located in the display list
     // and should not get moved or added again here
@@ -408,7 +408,7 @@
             step = steps; // quit
             goto next; // resolveIDs failed
         }
-        if (newID.size() > 0) 
+        if (newID.size() > 0)
             maker.setID(copyScope, newID);
         if (copy->resolveIDs(maker, this, this)) { // fix up all fields, including target
             step = steps; // quit
@@ -517,7 +517,7 @@
     SkAnimateBase** animEnd = fAnimators.end();
     for (SkAnimateBase** animPtr = fAnimators.begin(); animPtr < animEnd; animPtr++) {
         SkAnimateBase* animator = *animPtr;
-        if (animator->fDelayed) 
+        if (animator->fDelayed)
             return true;
     }
     return false;
@@ -548,7 +548,7 @@
     SkMSec time = maker.getAppTime();
     if (lastTime == (SkMSec) -1)
         lastTime = rawTime - 1;
-    if (fActive != NULL && 
+    if (fActive != NULL &&
         strcmp(id, "a3") == 0 && rawTime > lastTime) {
         lastTime += 1000;
         SkString debugOut;
@@ -593,7 +593,7 @@
         } else
             animate->fDelayed = false;
         SkMSec innerTime = fLastTime = state.getRelativeTime(time);
-        if (restore) 
+        if (restore)
             fActive->restoreInterpolatorValues(inner);
         if (animate->fReset) {
             if (transition != SkApply::kTransition_reverse) {
@@ -629,7 +629,7 @@
                 fLastTime = animate->dur;
             SkTypedArray formulaValues;
             formulaValues.setCount(count);
-            bool success = animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL, 
+            bool success = animate->fFieldInfo->setValue(maker, &formulaValues, 0, 0, NULL,
                 animate->getValuesType(), animate->formula);
             SkASSERT(success);
             if (restore)
@@ -652,7 +652,7 @@
     scope->initialize();
 }
 
-void SkApply::onEndElement(SkAnimateMaker& maker) 
+void SkApply::onEndElement(SkAnimateMaker& maker)
 {
     SkDrawable* scopePtr = scope;
     while (scopePtr && scopePtr->isApply()) {
@@ -781,7 +781,7 @@
             SkAnimateBase* animate = (SkAnimateBase*) scriptValue.fOperand.fDisplayable;
             SkASSERT(animate->isAnimate());
             *fAnimators.append() = animate;
-            return true; 
+            return true;
         }
         case SK_PROPERTY(steps):
             steps = scriptValue.fOperand.fS32;
@@ -792,8 +792,8 @@
     return false;
 }
 
-void SkApply::setSteps(int _steps) { 
-    steps = _steps; 
+void SkApply::setSteps(int _steps) {
+    steps = _steps;
 }
 
 #ifdef SK_DEBUG
diff --git a/src/animator/SkDisplayApply.h b/src/animator/SkDisplayApply.h
index 018b894..3a066a4 100644
--- a/src/animator/SkDisplayApply.h
+++ b/src/animator/SkDisplayApply.h
@@ -27,7 +27,7 @@
         kTransition_normal,
         kTransition_reverse
     };
-    
+
     enum Mode {
         kMode_create,
         kMode_immediate,
@@ -58,7 +58,7 @@
     bool hasDelayedAnimator() const;
     virtual bool hasEnable() const;
     bool inactivate(SkAnimateMaker& maker);
-    virtual void initialize(); 
+    virtual void initialize();
     bool interpolate(SkAnimateMaker& , SkMSec time);
     virtual void onEndElement(SkAnimateMaker& );
     virtual const SkMemberInfo* preferredChild(SkDisplayTypes type);
diff --git a/src/animator/SkDisplayBounds.cpp b/src/animator/SkDisplayBounds.cpp
index 69ec47e..4c89481b9 100644
--- a/src/animator/SkDisplayBounds.cpp
+++ b/src/animator/SkDisplayBounds.cpp
@@ -36,7 +36,7 @@
         maker.fDisplayList.fHasUnion = true;
         if (rect.isEmpty())
             rect = fBounds;
-        else 
+        else
             rect.join(fBounds);
     }
     return result;
diff --git a/src/animator/SkDisplayEvent.cpp b/src/animator/SkDisplayEvent.cpp
index 0eb956a..303e42c 100644
--- a/src/animator/SkDisplayEvent.cpp
+++ b/src/animator/SkDisplayEvent.cpp
@@ -52,9 +52,9 @@
     deleteMembers();
 }
 
-bool SkDisplayEvent::add(SkAnimateMaker& , SkDisplayable* child) { 
-    *fChildren.append() = child; 
-    return true; 
+bool SkDisplayEvent::add(SkAnimateMaker& , SkDisplayable* child) {
+    *fChildren.append() = child;
+    return true;
 }
 
 bool SkDisplayEvent::contains(SkDisplayable* match) {
@@ -112,7 +112,7 @@
 }
 #endif
 
-bool SkDisplayEvent::enableEvent(SkAnimateMaker& maker) 
+bool SkDisplayEvent::enableEvent(SkAnimateMaker& maker)
 {
     maker.fActiveEvent = this;
     if (fChildren.count() == 0)
@@ -134,7 +134,7 @@
         }
         if (displayable->enable(maker))
             continue;
-        if (maker.hasError()) 
+        if (maker.hasError())
             return true;
         if (displayable->isDrawable() == false)
             return true;    // error
diff --git a/src/animator/SkDisplayEvents.cpp b/src/animator/SkDisplayEvents.cpp
index 38f82a0..c42fbdf 100644
--- a/src/animator/SkDisplayEvents.cpp
+++ b/src/animator/SkDisplayEvents.cpp
@@ -83,7 +83,7 @@
     int count = drawArray.count();
     for (index = 0; index < count; index++) {
         SkDrawable* drawable = drawArray[index];
-        drawable->dumpEvents(); 
+        drawable->dumpEvents();
     }
     count = fEvents.count();
     for (index = 0; index < count; index++) {
diff --git a/src/animator/SkDisplayInput.cpp b/src/animator/SkDisplayInput.cpp
index 77bc5de..7061aa8 100644
--- a/src/animator/SkDisplayInput.cpp
+++ b/src/animator/SkDisplayInput.cpp
@@ -49,7 +49,7 @@
     }
     return true;
 }
- 
+
 bool SkInput::hasEnable() const {
     return true;
 }
diff --git a/src/animator/SkDisplayList.cpp b/src/animator/SkDisplayList.cpp
index 8424b12..39465f1 100644
--- a/src/animator/SkDisplayList.cpp
+++ b/src/animator/SkDisplayList.cpp
@@ -51,7 +51,7 @@
 }
 
 int SkDisplayList::findGroup(SkDrawable* match, SkTDDrawableArray** list,
-        SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) { 
+        SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
     *parent = NULL;
     *list = &fDrawList;
     *grandList = &fDrawList;
@@ -69,7 +69,7 @@
 }
 
 int SkDisplayList::SearchForMatch(SkDrawable* match, SkTDDrawableArray** list,
-        SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) { 
+        SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList) {
     *found = NULL;
     for (int index = 0; index < (*list)->count(); index++) {
         SkDrawable* draw = (**list)[index];
@@ -88,11 +88,11 @@
                         return index;
                     //perhaps should call SearchGroupForMatch here as well (on scope)
                 }
-            } 
+            }
         }
-        if (draw->isGroup() && SearchGroupForMatch(draw, match, list, parent, found, grandList, index)) 
+        if (draw->isGroup() && SearchGroupForMatch(draw, match, list, parent, found, grandList, index))
             return index;
-        
+
     }
     return -1;
 }
@@ -120,7 +120,7 @@
             continue;
         SkApply* apply = (SkApply*) draw;
         apply->reset();
-    }           
+    }
 }
 
 void SkDisplayList::remove(SkActive* active) {
diff --git a/src/animator/SkDisplayList.h b/src/animator/SkDisplayList.h
index f520b55..af98aef 100644
--- a/src/animator/SkDisplayList.h
+++ b/src/animator/SkDisplayList.h
@@ -35,8 +35,8 @@
     static int fIndent;
     static int fDumpIndex;
 #endif
-    int findGroup(SkDrawable* match, SkTDDrawableArray** list, 
-        SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList); 
+    int findGroup(SkDrawable* match, SkTDDrawableArray** list,
+        SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList);
     SkDrawable* get(int index) { return fDrawList[index]; }
     SkMSec getTime() { return fInTime; }
     SkTDDrawableArray* getDrawList() { return &fDrawList; }
@@ -51,8 +51,8 @@
 #endif
     static int SearchForMatch(SkDrawable* match, SkTDDrawableArray** list,
         SkGroup** parent, SkGroup** found, SkTDDrawableArray**grandList);
-    static bool SearchGroupForMatch(SkDrawable* draw, SkDrawable* match, 
-        SkTDDrawableArray** list, SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList, 
+    static bool SearchGroupForMatch(SkDrawable* draw, SkDrawable* match,
+        SkTDDrawableArray** list, SkGroup** parent, SkGroup** found, SkTDDrawableArray** grandList,
         int &index);
 public:
     SkIRect fBounds;
diff --git a/src/animator/SkDisplayMath.cpp b/src/animator/SkDisplayMath.cpp
index c4d496d..bdf377b 100644
--- a/src/animator/SkDisplayMath.cpp
+++ b/src/animator/SkDisplayMath.cpp
@@ -29,7 +29,7 @@
     1.442695041f,   // LOG2E
     3.141592654f,   // PI
     0.707106781f,   // SQRT1_2
-    1.414213562f        // SQRT2 
+    1.414213562f        // SQRT2
 #else
     0x2B7E1,    // E
     0x24D76,    // LN10
@@ -139,7 +139,7 @@
 
 DEFINE_GET_MEMBER(SkDisplayMath);
 
-void SkDisplayMath::executeFunction(SkDisplayable* target, int index, 
+void SkDisplayMath::executeFunction(SkDisplayable* target, int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* scriptValue) {
     if (scriptValue == NULL)
@@ -151,7 +151,7 @@
     SkScalar scalarResult;
     switch (index) {
         case SK_FUNCTION(abs):
-            scalarResult = SkScalarAbs(input); 
+            scalarResult = SkScalarAbs(input);
             break;
         case SK_FUNCTION(acos):
             scalarResult = SkScalarACos(input);
@@ -166,7 +166,7 @@
             scalarResult = SkScalarATan2(input, parameters[1].fOperand.fScalar);
             break;
         case SK_FUNCTION(ceil):
-            scalarResult = SkIntToScalar(SkScalarCeil(input)); 
+            scalarResult = SkIntToScalar(SkScalarCeil(input));
             break;
         case SK_FUNCTION(cos):
             scalarResult = SkScalarCos(input);
@@ -175,7 +175,7 @@
             scalarResult = SkScalarExp(input);
             break;
         case SK_FUNCTION(floor):
-            scalarResult = SkIntToScalar(SkScalarFloor(input)); 
+            scalarResult = SkIntToScalar(SkScalarFloor(input));
             break;
         case SK_FUNCTION(log):
             scalarResult = SkScalarLog(input);
@@ -204,7 +204,7 @@
             scalarResult = fRandom.nextUScalar1();
             break;
         case SK_FUNCTION(round):
-            scalarResult = SkIntToScalar(SkScalarRound(input)); 
+            scalarResult = SkIntToScalar(SkScalarRound(input));
             break;
         case SK_FUNCTION(sin):
             scalarResult = SkScalarSin(input);
@@ -212,7 +212,7 @@
         case SK_FUNCTION(sqrt): {
             SkASSERT(parameters.count() == 1);
             SkASSERT(type == SkType_Float);
-            scalarResult = SkScalarSqrt(input); 
+            scalarResult = SkScalarSqrt(input);
             } break;
         case SK_FUNCTION(tan):
             scalarResult = SkScalarTan(input);
diff --git a/src/animator/SkDisplayMath.h b/src/animator/SkDisplayMath.h
index e21d03f..faa929e 100644
--- a/src/animator/SkDisplayMath.h
+++ b/src/animator/SkDisplayMath.h
@@ -16,7 +16,7 @@
 
 class SkDisplayMath : public SkDisplayable {
     DECLARE_DISPLAY_MEMBER_INFO(Math);
-    virtual void executeFunction(SkDisplayable* , int index, 
+    virtual void executeFunction(SkDisplayable* , int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* );
     virtual const SkFunctionParamType* getFunctionsParameters();
@@ -27,6 +27,6 @@
     static const SkFunctionParamType fFunctionParameters[];
 
 };
-    
+
 #endif // SkDisplayMath_DEFINED
 
diff --git a/src/animator/SkDisplayMovie.cpp b/src/animator/SkDisplayMovie.cpp
index 4fbf3f3..33123cb 100644
--- a/src/animator/SkDisplayMovie.cpp
+++ b/src/animator/SkDisplayMovie.cpp
@@ -78,7 +78,7 @@
         enable(maker);
     maker.fCanvas->save();
     SkPaint local = SkPaint(*maker.fPaint);
-    bool result = fMovie.draw(maker.fCanvas, &local, 
+    bool result = fMovie.draw(maker.fCanvas, &local,
         maker.fDisplayList.getTime()) != SkAnimator::kNotDifferent;
     maker.fDisplayList.fInvalBounds.join(fMovie.fMaker->fDisplayList.fInvalBounds);
     maker.fCanvas->restore();
diff --git a/src/animator/SkDisplayNumber.h b/src/animator/SkDisplayNumber.h
index 7092e21..16c6f4f 100644
--- a/src/animator/SkDisplayNumber.h
+++ b/src/animator/SkDisplayNumber.h
@@ -18,5 +18,5 @@
     virtual bool getProperty(int index, SkScriptValue* value) const;
 private:
 };
-    
+
 #endif // SkDisplayNumber_DEFINED
diff --git a/src/animator/SkDisplayPost.cpp b/src/animator/SkDisplayPost.cpp
index bf89055..3c9fa19 100644
--- a/src/animator/SkDisplayPost.cpp
+++ b/src/animator/SkDisplayPost.cpp
@@ -54,12 +54,12 @@
     return true;
 }
 
-bool SkPost::childrenNeedDisposing() const { 
-    return false; 
+bool SkPost::childrenNeedDisposing() const {
+    return false;
 }
 
-void SkPost::dirty() { 
-    fDirty = true; 
+void SkPost::dirty() {
+    fDirty = true;
 }
 
 #ifdef SK_DUMP_ENABLED
@@ -74,7 +74,7 @@
     else
         SkDebugf("type=\"%s\" ", eventType->c_str());
     delete eventType;
-    
+
     if (delay > 0) {
         SkDebugf("delay=\"%g\" ", SkScalarToFloat(SkScalarDiv(delay, 1000)));
     }
@@ -99,7 +99,7 @@
     SkDisplayList::fIndent += 4;
     //this seems to work, but kinda hacky
     //for some reason the last part is id, which i don't want
-    //and the parts seem to be in the reverse order from the one in which we find the 
+    //and the parts seem to be in the reverse order from the one in which we find the
     //data itself
     //SkDataInput** ptr = fParts.end();
     //SkDataInput* data;
@@ -211,7 +211,7 @@
     SkAnimator* anim = maker.getAnimator();
     if (targetID == 0) {
         isAnimatorEvent = fEvent.findString("id") != NULL;
-        if (isAnimatorEvent) 
+        if (isAnimatorEvent)
             targetID = anim->getSinkID();
         else if (maker.fHostEventSinkID)
             targetID = maker.fHostEventSinkID;
@@ -260,7 +260,7 @@
     SkAnimator* anim = fTargetMaker->getAnimator();
     fSinkID = anim->getSinkID();
 }
- 
+
 bool SkPost::hasEnable() const {
     return true;
 }
@@ -274,8 +274,8 @@
     }
 }
 
-void SkPost::setChildHasID() { 
-    fChildHasID = true; 
+void SkPost::setChildHasID() {
+    fChildHasID = true;
 }
 
 bool SkPost::setProperty(int index, SkScriptValue& value) {
diff --git a/src/animator/SkDisplayRandom.cpp b/src/animator/SkDisplayRandom.cpp
index 3f77fcb..31a20b5 100644
--- a/src/animator/SkDisplayRandom.cpp
+++ b/src/animator/SkDisplayRandom.cpp
@@ -37,7 +37,7 @@
     dumpBase(maker);
     SkDebugf("min=\"%g\" ", SkScalarToFloat(min));
     SkDebugf("max=\"%g\" ", SkScalarToFloat(max));
-    SkDebugf("blend=\"%g\" ", SkScalarToFloat(blend));    
+    SkDebugf("blend=\"%g\" ", SkScalarToFloat(blend));
     SkDebugf("/>\n");
 }
 #endif
diff --git a/src/animator/SkDisplayType.cpp b/src/animator/SkDisplayType.cpp
index 3527517..dc52f0c 100644
--- a/src/animator/SkDisplayType.cpp
+++ b/src/animator/SkDisplayType.cpp
@@ -67,7 +67,7 @@
 #else
     #define CASE_DEBUG_RETURN_NIL(_class)
 #endif
-    
+
 
 SkDisplayTypes SkDisplayType::gNewTypes = kNumberOfTypes;
 
@@ -224,7 +224,7 @@
     info = SkDisplay##_class::fInfo; infoCount = SkDisplay##_class::fInfoCount; \
     break
 
-const SkMemberInfo* SkDisplayType::GetMembers(SkAnimateMaker* maker, 
+const SkMemberInfo* SkDisplayType::GetMembers(SkAnimateMaker* maker,
         SkDisplayTypes type, int* infoCountPtr) {
     const SkMemberInfo* info = NULL;
     int infoCount = 0;
@@ -355,7 +355,7 @@
         CASE_GET_DRAW_INFO(Typeface);
         // xfermode
         // knumberoftypes
-        default: 
+        default:
             if (maker) {
                 SkExtras** end = maker->fExtras.end();
                 for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
@@ -370,7 +370,7 @@
     return info;
 }
 
-const SkMemberInfo* SkDisplayType::GetMember(SkAnimateMaker* maker, 
+const SkMemberInfo* SkDisplayType::GetMember(SkAnimateMaker* maker,
         SkDisplayTypes type, const char** matchPtr ) {
     int infoCount;
     const SkMemberInfo* info = GetMembers(maker, type, &infoCount);
@@ -546,7 +546,7 @@
     SkASSERT(info);
     if (info->fType != SkType_BaseClassInfo)
         return SkType_Unknown; // if no base, done
-    // !!! could change SK_MEMBER_INHERITED macro to take type, stuff in offset, so that 
+    // !!! could change SK_MEMBER_INHERITED macro to take type, stuff in offset, so that
     // this (and table builder) could know type without the following steps:
     const SkMemberInfo* inherited = info->getInherited();
     SkDisplayTypes result = (SkDisplayTypes) (SkType_Unknown + 1);
@@ -560,7 +560,7 @@
 }
 
 SkDisplayTypes SkDisplayType::GetType(SkAnimateMaker* maker, const char match[], size_t len ) {
-    int index = SkStrSearch(&gTypeNames[0].fName, kTypeNamesSize, match, 
+    int index = SkStrSearch(&gTypeNames[0].fName, kTypeNamesSize, match,
         len, sizeof(gTypeNames[0]));
     if (index >= 0 && index < kTypeNamesSize)
         return gTypeNames[index].fType;
diff --git a/src/animator/SkDisplayType.h b/src/animator/SkDisplayType.h
index 7abde23..474a65e 100644
--- a/src/animator/SkDisplayType.h
+++ b/src/animator/SkDisplayType.h
@@ -187,7 +187,7 @@
     static SkDisplayTypes RegisterNewType();
     static SkDisplayTypes Resolve(const char[] , const SkMemberInfo** );
 #ifdef SK_DEBUG
-    static bool IsAnimate(SkDisplayTypes type ) { return type == SkType_Animate || 
+    static bool IsAnimate(SkDisplayTypes type ) { return type == SkType_Animate ||
         type == SkType_Set; }
     static const char* GetName(SkAnimateMaker* , SkDisplayTypes );
 #endif
diff --git a/src/animator/SkDisplayTypes.cpp b/src/animator/SkDisplayTypes.cpp
index d3bfa10..d320fc0 100644
--- a/src/animator/SkDisplayTypes.cpp
+++ b/src/animator/SkDisplayTypes.cpp
@@ -11,7 +11,7 @@
 #include "SkAnimateBase.h"
 
 bool SkDisplayDepend::canContainDependents() const {
-    return true; 
+    return true;
 }
 
 void SkDisplayDepend::dirty() {
@@ -118,7 +118,7 @@
 SkDisplayString::SkDisplayString(SkString& copyFrom) : value(copyFrom) {
 }
 
-void SkDisplayString::executeFunction(SkDisplayable* target, int index, 
+void SkDisplayString::executeFunction(SkDisplayable* target, int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* scriptValue) {
     if (scriptValue == NULL)
@@ -150,7 +150,7 @@
 }
 
 bool SkDisplayString::getProperty(int index, SkScriptValue* scriptValue) const {
-    switch (index) { 
+    switch (index) {
         case SK_PROPERTY(length):
             scriptValue->fType = SkType_Int;
             scriptValue->fOperand.fS32 = (int32_t) value.size();
@@ -201,7 +201,7 @@
 }
 
 bool SkDisplayArray::getProperty(int index, SkScriptValue* value) const {
-    switch (index) { 
+    switch (index) {
         case SK_PROPERTY(length):
             value->fType = SkType_Int;
             value->fOperand.fS32 = values.count();
diff --git a/src/animator/SkDisplayTypes.h b/src/animator/SkDisplayTypes.h
index 75cace6..614018f 100644
--- a/src/animator/SkDisplayTypes.h
+++ b/src/animator/SkDisplayTypes.h
@@ -75,7 +75,7 @@
     DECLARE_DISPLAY_MEMBER_INFO(String);
     SkDisplayString();
     SkDisplayString(SkString& );
-    virtual void executeFunction(SkDisplayable* , int index, 
+    virtual void executeFunction(SkDisplayable* , int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* );
     virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDisplayXMLParser.cpp b/src/animator/SkDisplayXMLParser.cpp
index 68dc259..31be3da 100644
--- a/src/animator/SkDisplayXMLParser.cpp
+++ b/src/animator/SkDisplayXMLParser.cpp
@@ -34,7 +34,7 @@
     "last offset in gradient must be one",
     "offsets in gradient must be increasing",
     "first offset in gradient must be zero",
-    "gradient attribute \"points\" must have length of four", 
+    "gradient attribute \"points\" must have length of four",
     "in include ",
     "in movie ",
     "include name unknown or missing ",
@@ -70,7 +70,7 @@
 
 
 SkDisplayXMLParser::SkDisplayXMLParser(SkAnimateMaker& maker)
-    : INHERITED(&maker.fError), fMaker(maker), fInInclude(maker.fInInclude), 
+    : INHERITED(&maker.fError), fMaker(maker), fInInclude(maker.fInInclude),
         fInSkia(maker.fInInclude), fCurrDisplayable(NULL)
 {
 }
@@ -94,7 +94,7 @@
     return onAddAttributeLen(name, value, strlen(value));
 }
 
-bool SkDisplayXMLParser::onAddAttributeLen(const char attrName[], const char attrValue[], 
+bool SkDisplayXMLParser::onAddAttributeLen(const char attrName[], const char attrValue[],
                                         size_t attrValueLen)
 {
     if (fCurrDisplayable == NULL)    // this signals we should ignore attributes for this element
@@ -172,16 +172,16 @@
         SkDisplayable* displayable = container.fDisplayable;
         fMaker.fEndDepth = parentIndex;
         displayable->onEndElement(fMaker);
-        if (fMaker.fError.hasError()) 
+        if (fMaker.fError.hasError())
             return true;
         if (parentIndex > 0) {
             SkDisplayable* parent = fParents[parentIndex - 1].fDisplayable;
             bool result = parent->add(fMaker, displayable);
-            if (fMaker.hasError()) 
+            if (fMaker.hasError())
                 return true;
             if (result == false) {
                 int infoCount;
-                const SkMemberInfo* info = 
+                const SkMemberInfo* info =
                     SkDisplayType::GetMembers(&fMaker, fParents[parentIndex - 1].fType, &infoCount);
                 const SkMemberInfo* foundInfo;
                 if ((foundInfo = searchContainer(info, infoCount)) != NULL) {
@@ -213,7 +213,7 @@
             SkDebugf("%s\n", debugOut.c_str());
 #endif
             fMaker.fEvents.doEvent(fMaker, SkDisplayEvent::kOnload, NULL);
-            if (fMaker.fError.hasError()) 
+            if (fMaker.fError.hasError())
                 return true;
             fMaker.fEvents.removeEvent(SkDisplayEvent::kOnload, NULL);
 
@@ -281,7 +281,7 @@
         }
         Parent* container = fParents.end() - 1;
         SkDisplayTypes type = (SkDisplayTypes) info->fType;
-        if (type == SkType_MemberProperty) 
+        if (type == SkType_MemberProperty)
             type = info->propertyType();
         SkDisplayTypes containerType = container->fType;
         if (type == containerType && (type == SkType_Rect || type == SkType_Polygon ||
@@ -296,7 +296,7 @@
         }
         return info;
 next:
-        if (type == SkType_Drawable || (type == SkType_Displayable && 
+        if (type == SkType_Drawable || (type == SkType_Displayable &&
             container->fDisplayable->isDrawable())) {
 rectNext:
             if (fParents.count() > 1) {
diff --git a/src/animator/SkDisplayable.cpp b/src/animator/SkDisplayable.cpp
index 396ce6b..753764b 100644
--- a/src/animator/SkDisplayable.cpp
+++ b/src/animator/SkDisplayable.cpp
@@ -21,7 +21,7 @@
 #endif
 
 #ifdef SK_DEBUG
-SkDisplayable::SkDisplayable() { 
+SkDisplayable::SkDisplayable() {
     id = _id.c_str();
 #ifdef SK_FIND_LEAKS
     // fAllocationCount++;
@@ -40,20 +40,20 @@
 }
 
 bool SkDisplayable::add(SkAnimateMaker& , SkDisplayable* child) {
-    return false; 
+    return false;
 }
 
-//void SkDisplayable::apply(SkAnimateMaker& , const SkMemberInfo* , 
-//      SkDisplayable* , SkScalar [], int count) { 
-//  SkASSERT(0); 
+//void SkDisplayable::apply(SkAnimateMaker& , const SkMemberInfo* ,
+//      SkDisplayable* , SkScalar [], int count) {
+//  SkASSERT(0);
 //}
 
 bool SkDisplayable::canContainDependents() const {
-    return false; 
+    return false;
 }
- 
-bool SkDisplayable::childrenNeedDisposing() const { 
-    return false; 
+
+bool SkDisplayable::childrenNeedDisposing() const {
+    return false;
 }
 
 void SkDisplayable::clearBounder() {
@@ -170,18 +170,18 @@
                 //last two are dummies
                 dumpValues(info, value.fType, value.fOperand, blankValue.fOperand, value.fOperand, blankValue.fOperand);
                 }
-            
+
             propIndex++;
             continue;
         }
         if (SkDisplayType::IsDisplayable(maker, info->fType)) {
             continue;
         }
-        
+
         if (info->fType == SkType_MemberFunction)
             continue;
-            
-            
+
+
         if (info->fType == SkType_Array) {
             SkTDOperandArray* array = (SkTDOperandArray*) info->memberData(this);
             int arrayCount;
@@ -201,14 +201,14 @@
                         case SkType_Displayable:
                             SkDebugf("%s", op->fDisplayable->id);
                             break;
-                        case SkType_Int:                            
+                        case SkType_Int:
                             SkDebugf("%d", op->fS32);
                             break;
                         case SkType_Float:
                             SkDebugf("%g", SkScalarToFloat(op->fScalar));
                             break;
                         case SkType_String:
-                        case SkType_DynamicString:    
+                        case SkType_DynamicString:
                             SkDebugf("%s", op->fString->c_str());
                             break;
                         default:
@@ -219,16 +219,16 @@
             SkDebugf("]\" ");
             continue;
         }
-        
+
         if (info->fType == SkType_String || info->fType == SkType_DynamicString) {
             SkString* string;
             info->getString(this, &string);
             if (string->isEmpty() == false)
-                SkDebugf("%s=\"%s\"\t", info->fName, string->c_str()); 
+                SkDebugf("%s=\"%s\"\t", info->fName, string->c_str());
             continue;
         }
-        
-        
+
+
         blankInfo = blankCopy->getMember(index);
         int i = info->fCount;
         info->getValue(this, values, i);
@@ -252,7 +252,7 @@
 }
 
 void SkDisplayable::dumpChildren(SkAnimateMaker* maker, bool closedAngle) {
-    
+
     int index = -1;
     const SkMemberInfo* info;
     index = -1;
@@ -354,7 +354,7 @@
         break;
     case SkType_TileMode:
         //correct to look at the S32?
-        if (op.fS32 != blankOp.fS32) 
+        if (op.fS32 != blankOp.fS32)
             SkDebugf("%s=\"%s\" ", info->fName, op.fS32 == 0 ? "clamp" : op.fS32 == 1 ? "repeat" : "mirror");
         break;
     case SkType_Boolean:
@@ -372,7 +372,7 @@
         break;
     case SkType_String:
     case SkType_DynamicString:
-        if (op.fString->size() > 0) 
+        if (op.fString->size() > 0)
             SkDebugf("%s=\"%s\" ", info->fName, op.fString->c_str());
         break;
     case SkType_MSec:
@@ -381,24 +381,24 @@
         }
     default:
         SkDebugf("");
-    }    
+    }
 }
 
 #endif
 
-bool SkDisplayable::enable( SkAnimateMaker& ) { 
+bool SkDisplayable::enable( SkAnimateMaker& ) {
     return false;
 }
 
 void SkDisplayable::enableBounder() {
 }
 
-void SkDisplayable::executeFunction(SkDisplayable* , int index, 
+void SkDisplayable::executeFunction(SkDisplayable* , int index,
         SkTDArray<SkScriptValue>& , SkDisplayTypes, SkScriptValue*  ) {
-    SkASSERT(0); 
+    SkASSERT(0);
 }
 
-void SkDisplayable::executeFunction(SkDisplayable* target, 
+void SkDisplayable::executeFunction(SkDisplayable* target,
         const SkMemberInfo* info, SkTypedArray* values, SkScriptValue* value) {
     SkTDArray<SkScriptValue> typedValues;
     for (SkOperand* op = values->begin(); op < values->end(); op++) {
@@ -410,9 +410,9 @@
     executeFunction(target, info->functionIndex(), typedValues, info->getType(), value);
 }
 
-void SkDisplayable::executeFunction2(SkDisplayable* , int index, 
+void SkDisplayable::executeFunction2(SkDisplayable* , int index,
         SkOpArray* params, SkDisplayTypes, SkOperand2*  ) {
-    SkASSERT(0); 
+    SkASSERT(0);
 }
 
 void SkDisplayable::getBounds(SkRect* rect) {
@@ -425,15 +425,15 @@
     return NULL;
 }
 
-const SkMemberInfo* SkDisplayable::getMember(int index) { 
-    return NULL; 
+const SkMemberInfo* SkDisplayable::getMember(int index) {
+    return NULL;
 }
 
-const SkMemberInfo* SkDisplayable::getMember(const char name[]) { 
-    return NULL; 
+const SkMemberInfo* SkDisplayable::getMember(const char name[]) {
+    return NULL;
 }
 
-const SkFunctionParamType* SkDisplayable::getParameters(const SkMemberInfo* info, 
+const SkFunctionParamType* SkDisplayable::getParameters(const SkMemberInfo* info,
         int* paramCount) {
     const SkFunctionParamType* params = getFunctionsParameters();
     SkASSERT(params != NULL);
@@ -460,17 +460,17 @@
 }
 
 bool SkDisplayable::getProperty(int index, SkScriptValue* ) const {
-//  SkASSERT(0); 
-    return false; 
+//  SkASSERT(0);
+    return false;
 }
 
 bool SkDisplayable::getProperty2(int index, SkOperand2* value) const {
-    SkASSERT(0); 
-    return false; 
+    SkASSERT(0);
+    return false;
 }
 
-SkDisplayTypes SkDisplayable::getType() const { 
-    return SkType_Unknown; 
+SkDisplayTypes SkDisplayable::getType() const {
+    return SkType_Unknown;
 }
 
 bool SkDisplayable::hasEnable() const {
@@ -478,7 +478,7 @@
 }
 
 bool SkDisplayable::isDrawable() const {
-    return false; 
+    return false;
 }
 
 void SkDisplayable::onEndElement(SkAnimateMaker& ) {}
@@ -491,8 +491,8 @@
     return false;
 }
 
-//SkDisplayable* SkDisplayable::resolveTarget(SkAnimateMaker& ) { 
-//  return this; 
+//SkDisplayable* SkDisplayable::resolveTarget(SkAnimateMaker& ) {
+//  return this;
 //}
 
 void SkDisplayable::setChildHasID() {
@@ -503,8 +503,8 @@
 }
 
 bool SkDisplayable::setProperty(int index, SkScriptValue& ) {
-    //SkASSERT(0); 
-    return false; 
+    //SkASSERT(0);
+    return false;
 }
 
 void SkDisplayable::setReference(const SkMemberInfo* info, SkDisplayable* displayable) {
diff --git a/src/animator/SkDisplayable.h b/src/animator/SkDisplayable.h
index a3db002..5fc2d3e 100644
--- a/src/animator/SkDisplayable.h
+++ b/src/animator/SkDisplayable.h
@@ -50,30 +50,30 @@
 #endif
     virtual bool enable( SkAnimateMaker& );
     virtual void enableBounder();
-    virtual void executeFunction(SkDisplayable* , int functionIndex, 
-        SkTDArray<SkScriptValue>& , SkDisplayTypes , SkScriptValue* ); 
-    void executeFunction(SkDisplayable* , const SkMemberInfo* , 
-        SkTypedArray* , SkScriptValue* ); 
-    virtual void executeFunction2(SkDisplayable* , int functionIndex, 
+    virtual void executeFunction(SkDisplayable* , int functionIndex,
+        SkTDArray<SkScriptValue>& , SkDisplayTypes , SkScriptValue* );
+    void executeFunction(SkDisplayable* , const SkMemberInfo* ,
+        SkTypedArray* , SkScriptValue* );
+    virtual void executeFunction2(SkDisplayable* , int functionIndex,
         SkOpArray* params , SkDisplayTypes , SkOperand2* ); // compiled scripting experiment
     virtual void getBounds(SkRect* );
     virtual const SkFunctionParamType* getFunctionsParameters();
     virtual const SkMemberInfo* getMember(int index);
     virtual const SkMemberInfo* getMember(const char name[]);
-    const SkFunctionParamType* getParameters(const SkMemberInfo* info, 
+    const SkFunctionParamType* getParameters(const SkMemberInfo* info,
         int* paramCount);
     virtual SkDisplayable* getParent() const;
     virtual bool getProperty(int index, SkScriptValue* value) const;
     virtual bool getProperty2(int index, SkOperand2* value) const;    // compiled scripting experiment
     virtual SkDisplayTypes getType() const;
     virtual bool hasEnable() const;
-    bool isAnimate() const { 
-        SkDisplayTypes type = getType(); 
+    bool isAnimate() const {
+        SkDisplayTypes type = getType();
         return type == SkType_Animate || type == SkType_Set; }
     bool isApply() const { return getType() == SkType_Apply; }
     bool isColor() const { return getType() == SkType_Color; }
     virtual bool isDrawable() const;
-    bool isGroup() const { return getType() == SkType_Group || 
+    bool isGroup() const { return getType() == SkType_Group ||
         getType() == SkType_Save || getType() == SkType_DrawTo ||
         getType() == SkType_SaveLayer; }
     bool isMatrix() const { return getType() == SkType_Matrix; }
diff --git a/src/animator/SkDraw3D.cpp b/src/animator/SkDraw3D.cpp
index ce2bec4..6ec178f 100644
--- a/src/animator/SkDraw3D.cpp
+++ b/src/animator/SkDraw3D.cpp
@@ -25,7 +25,7 @@
 DEFINE_NO_VIRTUALS_GET_MEMBER(Sk3D_Point);
 
 Sk3D_Point::Sk3D_Point() {
-    fPoint.set(0, 0, 0);    
+    fPoint.set(0, 0, 0);
 }
 
 #if SK_USE_CONDENSED_INFO == 0
@@ -85,7 +85,7 @@
 
 DEFINE_GET_MEMBER(Sk3D_Patch);
 
-void Sk3D_Patch::executeFunction(SkDisplayable* target, int index, 
+void Sk3D_Patch::executeFunction(SkDisplayable* target, int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* ) {
     SkASSERT(target == this);
@@ -93,7 +93,7 @@
         case SK_FUNCTION(rotateDegrees):
             SkASSERT(parameters.count() == 3);
             SkASSERT(type == SkType_Float);
-            fPatch.rotateDegrees(parameters[0].fOperand.fScalar, 
+            fPatch.rotateDegrees(parameters[0].fOperand.fScalar,
                 parameters[1].fOperand.fScalar, parameters[2].fOperand.fScalar);
             break;
         default:
diff --git a/src/animator/SkDraw3D.h b/src/animator/SkDraw3D.h
index e6549ea..f4bd82b 100644
--- a/src/animator/SkDraw3D.h
+++ b/src/animator/SkDraw3D.h
@@ -38,7 +38,7 @@
 class Sk3D_Patch : public SkDisplayable {
     DECLARE_MEMBER_INFO(3D_Patch);
 private:
-    virtual void executeFunction(SkDisplayable* , int index, 
+    virtual void executeFunction(SkDisplayable* , int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* );
     virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDrawBitmap.cpp b/src/animator/SkDrawBitmap.cpp
index 420045a..4604a71 100644
--- a/src/animator/SkDrawBitmap.cpp
+++ b/src/animator/SkDrawBitmap.cpp
@@ -56,7 +56,7 @@
 
 DEFINE_GET_MEMBER(SkDrawBitmap);
 
-SkDrawBitmap::SkDrawBitmap() : format((SkBitmap::Config) -1), height(-1), 
+SkDrawBitmap::SkDrawBitmap() : format((SkBitmap::Config) -1), height(-1),
     rowBytes(0),    width(-1), fColor(0), fColorSet(false) {
 }
 
@@ -137,7 +137,7 @@
 }
 
 SkImageBaseBitmap::~SkImageBaseBitmap() {
-    delete[] base64.fData; 
+    delete[] base64.fData;
 }
 
 SkDisplayable* SkImageBaseBitmap::deepCopy(SkAnimateMaker* maker) {
@@ -151,13 +151,13 @@
 }
 
 bool SkImageBaseBitmap::draw(SkAnimateMaker& maker) {
-    if (fDirty) 
+    if (fDirty)
         resolve();
     return INHERITED::draw(maker);
 }
 
 bool SkImageBaseBitmap::getProperty(int index, SkScriptValue* value) const {
-    if (fDirty) 
+    if (fDirty)
         resolve();
     switch (index) {
         case SK_PROPERTY(height):
@@ -188,11 +188,11 @@
             return;
         fLast.set(src);
         fBitmap.reset();
-        
+
         //SkStream* stream = SkStream::GetURIStream(fUriBase, src.c_str());
         SkStream* stream = new SkFILEStream(src.c_str());
 
         SkAutoTDelete<SkStream> autoDel(stream);
         SkImageDecoder::DecodeStream(stream, &fBitmap);
-    }   
+    }
 }
diff --git a/src/animator/SkDrawBitmap.h b/src/animator/SkDrawBitmap.h
index 927c33b..f9a9212 100644
--- a/src/animator/SkDrawBitmap.h
+++ b/src/animator/SkDrawBitmap.h
@@ -65,7 +65,7 @@
 protected:
     SkBase64 base64;
     SkString src;
-    SkString fLast; // cache of src so that stream isn't unnecessarily decoded 
+    SkString fLast; // cache of src so that stream isn't unnecessarily decoded
     SkBool fDirty;
     const char* fUriBase;
     typedef SkBaseBitmap INHERITED;
diff --git a/src/animator/SkDrawBlur.cpp b/src/animator/SkDrawBlur.cpp
index 57e8e20..68996bc 100644
--- a/src/animator/SkDrawBlur.cpp
+++ b/src/animator/SkDrawBlur.cpp
@@ -20,7 +20,7 @@
 
 DEFINE_GET_MEMBER(SkDrawBlur);
 
-SkDrawBlur::SkDrawBlur() : radius(-1), 
+SkDrawBlur::SkDrawBlur() : radius(-1),
     blurStyle(SkBlurMaskFilter::kNormal_BlurStyle) {
 }
 
diff --git a/src/animator/SkDrawColor.cpp b/src/animator/SkDrawColor.cpp
index 9abc8d0..dfe0622 100644
--- a/src/animator/SkDrawColor.cpp
+++ b/src/animator/SkDrawColor.cpp
@@ -73,7 +73,7 @@
         SkScalar fraction = hue / 60 - SkIntToScalar(sextant);
         SkScalar p = SkScalarMul(value , SK_Scalar1 - saturation);
         SkScalar q = SkScalarMul(value, SK_Scalar1 - SkScalarMul(saturation, fraction));
-        SkScalar t = SkScalarMul(value, SK_Scalar1 - 
+        SkScalar t = SkScalarMul(value, SK_Scalar1 -
             SkScalarMul(saturation, SK_Scalar1 - fraction));
         switch (sextant % 6) {
             case 0: red = value; green = t; blue = p; break;
@@ -85,11 +85,11 @@
         }
     }
     //used to say SkToU8((U8CPU) red) etc
-    return SkColorSetARGB(SkColorGetA(color), SkScalarRound(red), 
+    return SkColorSetARGB(SkColorGetA(color), SkScalarRound(red),
         SkScalarRound(green), SkScalarRound(blue));
 }
 
-#if defined _WIN32 && _MSC_VER >= 1300  
+#if defined _WIN32 && _MSC_VER >= 1300
 #pragma warning ( pop )
 #endif
 
@@ -120,8 +120,8 @@
 
 DEFINE_GET_MEMBER(SkDrawColor);
 
-SkDrawColor::SkDrawColor() : fDirty(false) { 
-    color = SK_ColorBLACK; 
+SkDrawColor::SkDrawColor() : fDirty(false) {
+    color = SK_ColorBLACK;
     fHue = fSaturation = fValue = SK_ScalarNaN;
 }
 
@@ -150,13 +150,13 @@
 #ifdef SK_DUMP_ENABLED
 void SkDrawColor::dump(SkAnimateMaker* maker) {
     dumpBase(maker);
-    SkDebugf("alpha=\"%d\" red=\"%d\" green=\"%d\" blue=\"%d\" />\n",  
+    SkDebugf("alpha=\"%d\" red=\"%d\" green=\"%d\" blue=\"%d\" />\n",
         SkColorGetA(color)/255, SkColorGetR(color),
         SkColorGetG(color), SkColorGetB(color));
 }
 #endif
 
-SkColor SkDrawColor::getColor() { 
+SkColor SkDrawColor::getColor() {
     if (fDirty) {
         if (SkScalarIsNaN(fValue) == false)
             color = HSV_to_RGB(color, kGetValue, fValue);
@@ -166,7 +166,7 @@
             color = HSV_to_RGB(color, kGetHue, fHue);
         fDirty = false;
     }
-    return color; 
+    return color;
 }
 
 SkDisplayable* SkDrawColor::getParent() const {
@@ -231,17 +231,17 @@
         #else
             alpha = SkToU8((scalar - (scalar >= SK_ScalarHalf)) >> 8);
         #endif
-            color = SkColorSetARGB(alpha, SkColorGetR(color), 
+            color = SkColorSetARGB(alpha, SkColorGetR(color),
                 SkColorGetG(color), SkColorGetB(color));
             break;
         case SK_PROPERTY(blue):
             scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
-            color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color), 
+            color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
                 SkColorGetG(color), SkToU8((U8CPU) scalar));
             break;
         case SK_PROPERTY(green):
             scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
-            color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color), 
+            color = SkColorSetARGB(SkColorGetA(color), SkColorGetR(color),
                 SkToU8((U8CPU) scalar), SkColorGetB(color));
             break;
         case SK_PROPERTY(hue):
@@ -250,7 +250,7 @@
             break;
         case SK_PROPERTY(red):
             scalar = SkScalarClampMax(scalar, 255 * SK_Scalar1);
-            color = SkColorSetARGB(SkColorGetA(color), SkToU8((U8CPU) scalar), 
+            color = SkColorSetARGB(SkColorGetA(color), SkToU8((U8CPU) scalar),
                 SkColorGetG(color), SkColorGetB(color));
         break;
         case SK_PROPERTY(saturation):
diff --git a/src/animator/SkDrawEmboss.cpp b/src/animator/SkDrawEmboss.cpp
index 2284504..7e47ec2 100644
--- a/src/animator/SkDrawEmboss.cpp
+++ b/src/animator/SkDrawEmboss.cpp
@@ -22,7 +22,7 @@
 
 DEFINE_GET_MEMBER(SkDrawEmboss);
 
-SkDrawEmboss::SkDrawEmboss() : radius(-1) { 
+SkDrawEmboss::SkDrawEmboss() : radius(-1) {
     direction.setCount(3);
 }
 
diff --git a/src/animator/SkDrawGradient.cpp b/src/animator/SkDrawGradient.cpp
index 9e29074..2e751ca 100644
--- a/src/animator/SkDrawGradient.cpp
+++ b/src/animator/SkDrawGradient.cpp
@@ -34,16 +34,16 @@
 public:
     SkDrawGradientUnitMapper(SkAnimateMaker* maker, const char* script) : fMaker(maker), fScript(script) {
     }
-    
+
     SK_DECLARE_UNFLATTENABLE_OBJECT()
-    
+
 protected:
     virtual uint16_t mapUnit16(uint16_t x) {
         fUnit = SkUnitToScalar(x);
         SkScriptValue value;
         SkAnimatorScript engine(*fMaker, NULL, SkType_Float);
         engine.propertyCallBack(GetUnitValue, &fUnit);
-        if (engine.evaluate(fScript, &value, SkType_Float)) 
+        if (engine.evaluate(fScript, &value, SkType_Float))
             x = SkScalarToUnit(value.fOperand.fScalar);
         return x;
     }
@@ -79,7 +79,7 @@
 }
 
 SkDrawGradient::~SkDrawGradient() {
-    for (int index = 0; index < fDrawColors.count(); index++) 
+    for (int index = 0; index < fDrawColors.count(); index++)
         delete fDrawColors[index];
     delete fUnitMapper;
 }
@@ -97,7 +97,7 @@
 int SkDrawGradient::addPrelude() {
     int count = fDrawColors.count();
     fColors.setCount(count);
-    for (int index = 0; index < count; index++) 
+    for (int index = 0; index < count; index++)
         fColors[index] = fDrawColors[index]->color;
     return count;
 }
@@ -116,7 +116,7 @@
         SkDrawColor* color = *ptr;
         color->dump(maker);
     }
-    SkDisplayList::fIndent -= 4;    
+    SkDisplayList::fIndent -= 4;
     dumpChildren(maker, closedYet); //dumps the matrix if it has one
 }
 #endif
@@ -146,7 +146,7 @@
             }
         }
     }
-    if (unitMapper.size() > 0) 
+    if (unitMapper.size() > 0)
         fUnitMapper = new SkDrawGradientUnitMapper(&maker, unitMapper.c_str());
     INHERITED::onEndElement(maker);
 }
@@ -162,7 +162,7 @@
 
 DEFINE_GET_MEMBER(SkDrawLinearGradient);
 
-SkDrawLinearGradient::SkDrawLinearGradient() { 
+SkDrawLinearGradient::SkDrawLinearGradient() {
 }
 
 void SkDrawLinearGradient::onEndElement(SkAnimateMaker& maker)
@@ -203,8 +203,8 @@
 
 DEFINE_GET_MEMBER(SkDrawRadialGradient);
 
-SkDrawRadialGradient::SkDrawRadialGradient() : radius(0) { 
-    center.set(0, 0); 
+SkDrawRadialGradient::SkDrawRadialGradient() : radius(0) {
+    center.set(0, 0);
 }
 
 #ifdef SK_DUMP_ENABLED
diff --git a/src/animator/SkDrawGradient.h b/src/animator/SkDrawGradient.h
index 09eb405..d01ee70 100644
--- a/src/animator/SkDrawGradient.h
+++ b/src/animator/SkDrawGradient.h
@@ -23,7 +23,7 @@
     virtual bool add(SkAnimateMaker& , SkDisplayable* child);
 #ifdef SK_DUMP_ENABLED
     virtual void dumpRest(SkAnimateMaker*);
-#endif    
+#endif
     virtual void onEndElement(SkAnimateMaker& );
 protected:
     SkTDScalarArray offsets;
@@ -55,7 +55,7 @@
     SkDrawRadialGradient();
 #ifdef SK_DUMP_ENABLED
     virtual void dump(SkAnimateMaker*);
-#endif    
+#endif
     virtual SkShader* getShader();
 protected:
     SkPoint center;
diff --git a/src/animator/SkDrawGroup.cpp b/src/animator/SkDrawGroup.cpp
index 939bd9f..806da5e 100644
--- a/src/animator/SkDrawGroup.cpp
+++ b/src/animator/SkDrawGroup.cpp
@@ -50,7 +50,7 @@
 }
 
 bool SkGroup::add(SkAnimateMaker& , SkDisplayable* child) {
-    SkASSERT(child); 
+    SkASSERT(child);
 //  SkASSERT(child->isDrawable());
     *fChildren.append() = (SkDrawable*) child;
     if (child->isGroup()) {
diff --git a/src/animator/SkDrawLine.cpp b/src/animator/SkDrawLine.cpp
index fe93c4e..d0ae7d9 100644
--- a/src/animator/SkDrawLine.cpp
+++ b/src/animator/SkDrawLine.cpp
@@ -25,7 +25,7 @@
 
 DEFINE_GET_MEMBER(SkLine);
 
-SkLine::SkLine() : x1(0), x2(0), y1(0), y2(0) { 
+SkLine::SkLine() : x1(0), x2(0), y1(0), y2(0) {
 }
 
 bool SkLine::draw(SkAnimateMaker& maker) {
diff --git a/src/animator/SkDrawMatrix.cpp b/src/animator/SkDrawMatrix.cpp
index 96e8292..1d7b3e0 100644
--- a/src/animator/SkDrawMatrix.cpp
+++ b/src/animator/SkDrawMatrix.cpp
@@ -51,9 +51,9 @@
 
 DEFINE_GET_MEMBER(SkDrawMatrix);
 
-SkDrawMatrix::SkDrawMatrix() : fChildHasID(false), fDirty(false) { 
+SkDrawMatrix::SkDrawMatrix() : fChildHasID(false), fDirty(false) {
     fConcat.reset();
-    fMatrix.reset(); 
+    fMatrix.reset();
 }
 
 SkDrawMatrix::~SkDrawMatrix() {
@@ -66,11 +66,11 @@
     SkMatrixPart* part = (SkMatrixPart*) child;
     *fParts.append() = part;
     if (part->add())
-        maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToMatrix); 
+        maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToMatrix);
     return true;
 }
 
-bool SkDrawMatrix::childrenNeedDisposing() const { 
+bool SkDrawMatrix::childrenNeedDisposing() const {
     return false;
 }
 
@@ -83,8 +83,8 @@
     return copy;
 }
 
-void SkDrawMatrix::dirty() { 
-    fDirty = true; 
+void SkDrawMatrix::dirty() {
+    fDirty = true;
 }
 
 bool SkDrawMatrix::draw(SkAnimateMaker& maker) {
@@ -207,8 +207,8 @@
     }
 }
 
-void SkDrawMatrix::setChildHasID() { 
-    fChildHasID = true; 
+void SkDrawMatrix::setChildHasID() {
+    fChildHasID = true;
 }
 
 bool SkDrawMatrix::setProperty(int index, SkScriptValue& scriptValue) {
diff --git a/src/animator/SkDrawPaint.h b/src/animator/SkDrawPaint.h
index a2a893e..db95d34 100644
--- a/src/animator/SkDrawPaint.h
+++ b/src/animator/SkDrawPaint.h
@@ -32,7 +32,7 @@
 #ifdef SK_DUMP_ENABLED
     virtual void dump(SkAnimateMaker* );
 #endif
-    virtual void executeFunction(SkDisplayable* target, int index, 
+    virtual void executeFunction(SkDisplayable* target, int index,
         SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
         SkScriptValue* );
     virtual const SkFunctionParamType* getFunctionsParameters();
diff --git a/src/animator/SkDrawPath.cpp b/src/animator/SkDrawPath.cpp
index 10e9203..81cbdb1 100644
--- a/src/animator/SkDrawPath.cpp
+++ b/src/animator/SkDrawPath.cpp
@@ -50,17 +50,17 @@
     SkPathPart* part = (SkPathPart*) child;
     *fParts.append() = part;
     if (part->add())
-        maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPath); 
+        maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPath);
     fDirty = false;
     return true;
 }
 
-bool SkDrawPath::childrenNeedDisposing() const { 
-    return false; 
+bool SkDrawPath::childrenNeedDisposing() const {
+    return false;
 }
 
-void SkDrawPath::dirty() { 
-    fDirty = true; 
+void SkDrawPath::dirty() {
+    fDirty = true;
     fLength = SK_ScalarNaN;
     if (fParent)
         fParent->dirty();
@@ -115,7 +115,7 @@
     fDirty = false;
     return fPath;
 }
-    
+
 void SkDrawPath::onEndElement(SkAnimateMaker& ) {
     if (d.size() > 0) {
         parseSVG();
@@ -153,8 +153,8 @@
     return true;
 }
 
-void SkDrawPath::setChildHasID() { 
-    fChildHasID = true; 
+void SkDrawPath::setChildHasID() {
+    fChildHasID = true;
 }
 
 bool SkDrawPath::setParent(SkDisplayable* parent) {
@@ -189,7 +189,7 @@
 DEFINE_GET_MEMBER(SkPolyline);
 
 bool SkPolyline::add(SkAnimateMaker& , SkDisplayable*) const {
-    return false; 
+    return false;
 }
 
 void SkPolyline::onEndElement(SkAnimateMaker& maker) {
diff --git a/src/animator/SkDrawPoint.cpp b/src/animator/SkDrawPoint.cpp
index 94fe4d2..66d2b4e 100644
--- a/src/animator/SkDrawPoint.cpp
+++ b/src/animator/SkDrawPoint.cpp
@@ -34,8 +34,8 @@
 
 DEFINE_GET_MEMBER(SkDrawPoint);
 
-SkDrawPoint::SkDrawPoint() { 
-    fPoint.set(0, 0);   
+SkDrawPoint::SkDrawPoint() {
+    fPoint.set(0, 0);
 }
 
 void SkDrawPoint::getBounds(SkRect* rect ) {
diff --git a/src/animator/SkDrawRectangle.cpp b/src/animator/SkDrawRectangle.cpp
index 19edf50..7587e4b 100644
--- a/src/animator/SkDrawRectangle.cpp
+++ b/src/animator/SkDrawRectangle.cpp
@@ -36,8 +36,8 @@
 
 DEFINE_GET_MEMBER(SkDrawRect);
 
-SkDrawRect::SkDrawRect() : fParent(NULL) { 
-    fRect.setEmpty(); 
+SkDrawRect::SkDrawRect() : fParent(NULL) {
+    fRect.setEmpty();
 }
 
 void SkDrawRect::dirty() {
diff --git a/src/animator/SkDrawRectangle.h b/src/animator/SkDrawRectangle.h
index 49c9cf4..321c4ee 100644
--- a/src/animator/SkDrawRectangle.h
+++ b/src/animator/SkDrawRectangle.h
@@ -44,7 +44,7 @@
     virtual bool draw(SkAnimateMaker& );
 #ifdef SK_DUMP_ENABLED
     virtual void dump(SkAnimateMaker* );
-#endif    
+#endif
 protected:
     SkScalar rx;
     SkScalar ry;
diff --git a/src/animator/SkDrawSaveLayer.cpp b/src/animator/SkDrawSaveLayer.cpp
index a7592db..43ec5c1 100644
--- a/src/animator/SkDrawSaveLayer.cpp
+++ b/src/animator/SkDrawSaveLayer.cpp
@@ -35,7 +35,7 @@
     if (!bounds) {
         return false;
     }
-    SkPaint* save = maker.fPaint;   
+    SkPaint* save = maker.fPaint;
     //paint is an SkDrawPaint
     if (paint)
     {
diff --git a/src/animator/SkDrawShader.cpp b/src/animator/SkDrawShader.cpp
index 5019622..e3aa4da 100644
--- a/src/animator/SkDrawShader.cpp
+++ b/src/animator/SkDrawShader.cpp
@@ -24,7 +24,7 @@
 
 DEFINE_GET_MEMBER(SkDrawShader);
 
-SkDrawShader::SkDrawShader() : matrix(NULL), 
+SkDrawShader::SkDrawShader() : matrix(NULL),
     tileMode(SkShader::kClamp_TileMode) {
 }
 
@@ -66,14 +66,14 @@
 SkShader* SkDrawBitmapShader::getShader() {
     if (image == NULL)
         return NULL;
-    
+
     // note: bitmap shader now supports independent tile modes for X and Y
     // we pass the same to both, but later we should extend this flexibility
     // to the xml (e.g. tileModeX="repeat" tileModeY="clmap")
-    // 
+    //
     // oops, bitmapshader no longer takes filterBitmap, but deduces it at
-    // draw-time from the paint 
-    SkShader* shader  = SkShader::CreateBitmapShader(image->fBitmap, 
+    // draw-time from the paint
+    SkShader* shader  = SkShader::CreateBitmapShader(image->fBitmap,
                                                     (SkShader::TileMode) tileMode,
                                                     (SkShader::TileMode) tileMode);
     SkAutoTDelete<SkShader> autoDel(shader);
diff --git a/src/animator/SkDrawText.h b/src/animator/SkDrawText.h
index 7dd2e26..3ac2479 100644
--- a/src/animator/SkDrawText.h
+++ b/src/animator/SkDrawText.h
@@ -21,7 +21,7 @@
 #ifdef SK_DUMP_ENABLED
     virtual void dump(SkAnimateMaker* );
 #endif
-    virtual bool getProperty(int index, SkScriptValue* value) const ; 
+    virtual bool getProperty(int index, SkScriptValue* value) const ;
     const char* getText() { return text.c_str(); }
     size_t getSize() { return text.size(); }
 protected:
diff --git a/src/animator/SkDrawTextBox.cpp b/src/animator/SkDrawTextBox.cpp
index d97dc5c..f920e8e 100644
--- a/src/animator/SkDrawTextBox.cpp
+++ b/src/animator/SkDrawTextBox.cpp
@@ -47,7 +47,7 @@
 {
     dumpBase(maker);
     dumpAttrs(maker);
-    if (mode == 0) 
+    if (mode == 0)
         SkDebugf("mode=\"oneLine\" ");
     if (spacingAlign == 1)
         SkDebugf("spacingAlign=\"center\" ");
diff --git a/src/animator/SkDrawable.cpp b/src/animator/SkDrawable.cpp
index 8db0333..9e80c9d 100644
--- a/src/animator/SkDrawable.cpp
+++ b/src/animator/SkDrawable.cpp
@@ -13,8 +13,8 @@
     return false;
 }
 
-bool SkDrawable::isDrawable() const { 
-    return true; 
+bool SkDrawable::isDrawable() const {
+    return true;
 }
 
 void SkDrawable::initialize() {
diff --git a/src/animator/SkDrawable.h b/src/animator/SkDrawable.h
index 139ce85..6bb9608 100644
--- a/src/animator/SkDrawable.h
+++ b/src/animator/SkDrawable.h
@@ -19,7 +19,7 @@
 class SkDrawable :  public SkDisplayable {
 public:
     virtual bool doEvent(SkDisplayEvent::Kind , SkEventState* state );
-    virtual bool draw(SkAnimateMaker& ) = 0; 
+    virtual bool draw(SkAnimateMaker& ) = 0;
     virtual void initialize();
     virtual bool isDrawable() const;
     virtual void setSteps(int steps);
diff --git a/src/animator/SkDump.cpp b/src/animator/SkDump.cpp
index bd91277..563b0e1 100644
--- a/src/animator/SkDump.cpp
+++ b/src/animator/SkDump.cpp
@@ -144,7 +144,7 @@
 }
 
 bool SkDump::setProperty(int index, SkScriptValue& ) {
-    return index <= SK_PROPERTY(posts); 
+    return index <= SK_PROPERTY(posts);
 }
 
 #endif
diff --git a/src/animator/SkGetCondensedInfo.cpp b/src/animator/SkGetCondensedInfo.cpp
index a583cef..6d83b1d 100644
--- a/src/animator/SkGetCondensedInfo.cpp
+++ b/src/animator/SkGetCondensedInfo.cpp
@@ -26,7 +26,7 @@
         int mid = (hi + lo) >> 1;
         if (strcmp(&strings[lengths[mid << 2]], target) < 0)
             lo = mid + 1;
-        else 
+        else
             hi = mid;
     }
     if (strcmp(&strings[lengths[hi << 2]], target) != 0)
diff --git a/src/animator/SkIntArray.h b/src/animator/SkIntArray.h
index 6769a9e..4dac75a 100644
--- a/src/animator/SkIntArray.h
+++ b/src/animator/SkIntArray.h
@@ -36,21 +36,21 @@
 typedef SkIntArray(SkMSec) SkTDMSecArray;
 typedef SkIntArray(SkScalar) SkTDScalarArray;
 
-typedef SkLongArray(SkActive*) SkTDActiveArray; 
-typedef SkLongArray(SkAnimateBase*) SkTDAnimateArray; 
-typedef SkLongArray(SkDataInput*) SkTDDataArray; 
-typedef SkLongArray(SkDisplayable*) SkTDDisplayableArray; 
-typedef SkLongArray(SkDisplayEvent*) SkTDDisplayEventArray; 
-typedef SkLongArray(SkDrawable*) SkTDDrawableArray; 
-typedef SkLongArray(SkDrawColor*) SkTDDrawColorArray; 
-typedef SkLongArray(SkMatrixPart*) SkTDMatrixPartArray; 
+typedef SkLongArray(SkActive*) SkTDActiveArray;
+typedef SkLongArray(SkAnimateBase*) SkTDAnimateArray;
+typedef SkLongArray(SkDataInput*) SkTDDataArray;
+typedef SkLongArray(SkDisplayable*) SkTDDisplayableArray;
+typedef SkLongArray(SkDisplayEvent*) SkTDDisplayEventArray;
+typedef SkLongArray(SkDrawable*) SkTDDrawableArray;
+typedef SkLongArray(SkDrawColor*) SkTDDrawColorArray;
+typedef SkLongArray(SkMatrixPart*) SkTDMatrixPartArray;
 typedef SkLongArray(const SkMemberInfo*) SkTDMemberInfoArray;
-typedef SkLongArray(SkPaintPart*) SkTDPaintPartArray; 
-typedef SkLongArray(SkPathPart*) SkTDPathPartArray; 
-typedef SkLongArray(SkTypedArray*) SkTDTypedArrayArray; 
-typedef SkLongArray(SkString*) SkTDStringArray; 
-typedef SkLongArray(SkOperand) SkTDOperandArray; 
-typedef SkLongArray(SkOperand*) SkTDOperandPtrArray; 
+typedef SkLongArray(SkPaintPart*) SkTDPaintPartArray;
+typedef SkLongArray(SkPathPart*) SkTDPathPartArray;
+typedef SkLongArray(SkTypedArray*) SkTDTypedArrayArray;
+typedef SkLongArray(SkString*) SkTDStringArray;
+typedef SkLongArray(SkOperand) SkTDOperandArray;
+typedef SkLongArray(SkOperand*) SkTDOperandPtrArray;
 
 #endif // SkIntArray_DEFINED
 
diff --git a/src/animator/SkMatrixParts.cpp b/src/animator/SkMatrixParts.cpp
index f00bb8e..221ac0a 100644
--- a/src/animator/SkMatrixParts.cpp
+++ b/src/animator/SkMatrixParts.cpp
@@ -16,8 +16,8 @@
 SkMatrixPart::SkMatrixPart() : fMatrix(NULL) {
 }
 
-void SkMatrixPart::dirty() { 
-    fMatrix->dirty(); 
+void SkMatrixPart::dirty() {
+    fMatrix->dirty();
 }
 
 SkDisplayable* SkMatrixPart::getParent() const {
@@ -44,8 +44,8 @@
 
 DEFINE_GET_MEMBER(SkRotate);
 
-SkRotate::SkRotate() : degrees(0) { 
-    center.fX = center.fY = 0; 
+SkRotate::SkRotate() : degrees(0) {
+    center.fX = center.fY = 0;
 }
 
 bool SkRotate::add() {
@@ -66,12 +66,12 @@
 
 DEFINE_GET_MEMBER(SkScale);
 
-SkScale::SkScale() : x(SK_Scalar1), y(SK_Scalar1) { 
-    center.fX = center.fY = 0; 
+SkScale::SkScale() : x(SK_Scalar1), y(SK_Scalar1) {
+    center.fX = center.fY = 0;
 }
 
 bool SkScale::add() {
-    fMatrix->scale(x, y, center);   
+    fMatrix->scale(x, y, center);
     return false;
 }
 
@@ -88,12 +88,12 @@
 
 DEFINE_GET_MEMBER(SkSkew);
 
-SkSkew::SkSkew() : x(0), y(0) { 
-    center.fX = center.fY = 0; 
+SkSkew::SkSkew() : x(0), y(0) {
+    center.fX = center.fY = 0;
 }
 
 bool SkSkew::add() {
-    fMatrix->skew(x, y, center);    
+    fMatrix->skew(x, y, center);
     return false;
 }
 
@@ -113,7 +113,7 @@
 }
 
 bool SkTranslate::add() {
-    fMatrix->translate(x, y);   
+    fMatrix->translate(x, y);
     return false;
 }
 
@@ -130,7 +130,7 @@
 
 DEFINE_GET_MEMBER(SkFromPath);
 
-SkFromPath::SkFromPath() : 
+SkFromPath::SkFromPath() :
     mode(0), offset(0), path(NULL) {
 }
 
@@ -166,7 +166,7 @@
 
 DEFINE_GET_MEMBER(SkRectToRect);
 
-SkRectToRect::SkRectToRect() : 
+SkRectToRect::SkRectToRect() :
     source(NULL), destination(NULL) {
 }
 
@@ -200,7 +200,7 @@
         SkDisplayList::fIndent += 4;
         destination->dump(maker);
         SkDisplayList::fIndent -= 4;
-        SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");        
+        SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
     }
     SkDisplayList::fIndent -= 4;
     dumpEnd(maker);
@@ -268,7 +268,7 @@
         SkDisplayList::fIndent += 4;
         destination->dump(maker);
         SkDisplayList::fIndent -= 4;
-        SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");        
+        SkDebugf("%*s</destination>\n", SkDisplayList::fIndent, "");
     }
     SkDisplayList::fIndent -= 4;
     dumpEnd(maker);
diff --git a/src/animator/SkMatrixParts.h b/src/animator/SkMatrixParts.h
index 5f6cd54..51c9559 100644
--- a/src/animator/SkMatrixParts.h
+++ b/src/animator/SkMatrixParts.h
@@ -114,6 +114,6 @@
     SkPolygon* destination;
 };
 
-// !!! add concat matrix ? 
+// !!! add concat matrix ?
 
 #endif // SkMatrixParts_DEFINED
diff --git a/src/animator/SkMemberInfo.cpp b/src/animator/SkMemberInfo.cpp
index 7fae503..582b29a 100644
--- a/src/animator/SkMemberInfo.cpp
+++ b/src/animator/SkMemberInfo.cpp
@@ -52,7 +52,7 @@
         case SkType_Displayable:
         case SkType_Drawable:
         case SkType_Matrix:
-            byteSize = sizeof(void*); 
+            byteSize = sizeof(void*);
             break;
         case SkType_MSec:
             byteSize = sizeof(SkMSec);
@@ -137,7 +137,7 @@
 
 void SkMemberInfo::getValue(const SkDisplayable* displayable, SkOperand value[], int count) const {
     SkASSERT(fType != SkType_String && fType != SkType_MemberProperty);
-    SkASSERT(count == fCount);  
+    SkASSERT(count == fCount);
     void* valuePtr = memberData(displayable);
     size_t byteSize = getSize(displayable);
     SkASSERT(sizeof(value[0].fScalar) == sizeof(value[0])); // no support for 64 bit pointers, yet
@@ -150,7 +150,7 @@
     displayable->dirty();
 }
 
-void SkMemberInfo::setValue(SkDisplayable* displayable, const SkOperand values[], 
+void SkMemberInfo::setValue(SkDisplayable* displayable, const SkOperand values[],
                             int count) const {
     SkASSERT(sizeof(values[0].fScalar) == sizeof(values[0]));   // no support for 64 bit pointers, yet
     char* dst = (char*) memberData(displayable);
@@ -163,7 +163,7 @@
     displayable->dirty();
 }
 
-                            
+
 static inline bool is_between(int c, int min, int max)
 {
     return (unsigned)(c - min) <= (unsigned)(max - min);
@@ -180,9 +180,9 @@
 }
 
 
-bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage, 
+bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
     int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
-    const char rawValue[], size_t rawValueLen) const 
+    const char rawValue[], size_t rawValueLen) const
 {
     SkString valueStr(rawValue, rawValueLen);
     SkScriptValue scriptValue;
@@ -218,7 +218,7 @@
             }
             *(char*) poundPos = '0'; // overwrite '#'
             valueStr.insert(offset + 1, "xFF");
-        } 
+        }
     }
     if (SkDisplayType::IsDisplayable(&maker, type) || SkDisplayType::IsEnum(&maker, type) || type == SkType_ARGB)
         goto scriptCommon;
@@ -226,22 +226,22 @@
         case SkType_String:
 #if 0
             if (displayable && displayable->isAnimate()) {
-                
+
                 goto noScriptString;
-            } 
+            }
             if (strncmp(rawValue, "#string:", sizeof("#string:") - 1) == 0) {
                 SkASSERT(sizeof("string") == sizeof("script"));
                 char* stringHeader = valueStr.writable_str();
                 memcpy(&stringHeader[1], "script", sizeof("script") - 1);
                 rawValue = valueStr.c_str();
                 goto noScriptString;
-            } else 
+            } else
 #endif
             if (strncmp(rawValue, "#script:", sizeof("#script:") - 1) != 0)
                 goto noScriptString;
             valueStr.remove(0, 8);
         case SkType_Unknown:
-        case SkType_Int: 
+        case SkType_Int:
         case SkType_MSec:  // for the purposes of script, MSec is treated as a Scalar
         case SkType_Point:
         case SkType_3D_Point:
@@ -331,10 +331,10 @@
             SkASSERT(0);
             break;
     }
-//  if (SkDisplayType::IsStruct(type) == false) 
+//  if (SkDisplayType::IsStruct(type) == false)
     {
 writeStruct:
-        if (writeValue(displayable, arrayStorage, storageOffset, maxStorage, 
+        if (writeValue(displayable, arrayStorage, storageOffset, maxStorage,
                 untypedStorage, outType, scriptValue)) {
                     maker.setErrorCode(SkDisplayXMLParserError::kUnexpectedType);
             return false;
@@ -346,18 +346,18 @@
     return true;
 }
 
-bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage, 
+bool SkMemberInfo::setValue(SkAnimateMaker& maker, SkTDOperandArray* arrayStorage,
         int storageOffset, int maxStorage, SkDisplayable* displayable, SkDisplayTypes outType,
         SkString& raw) const {
     return setValue(maker, arrayStorage, storageOffset, maxStorage, displayable, outType, raw.c_str(),
         raw.size());
 }
 
-bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage, 
-    int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType, 
+bool SkMemberInfo::writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
+    int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
     SkScriptValue& scriptValue) const
 {
-    SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ? 
+    SkOperand* storage = untypedStorage ? (SkOperand*) untypedStorage : arrayStorage ?
         arrayStorage->begin() : NULL;
     if (storage)
         storage += storageOffset;
@@ -424,7 +424,7 @@
         string->set(*scriptValue.fOperand.fString);
     } else if (type == SkType_ARGB && outType == SkType_Float) {
         SkTypedArray* array = scriptValue.fOperand.fArray;
-        SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB || 
+        SkASSERT(scriptValue.fType == SkType_Int || scriptValue.fType == SkType_ARGB ||
             scriptValue.fType == SkType_Array);
         SkASSERT(scriptValue.fType != SkType_Array || (array != NULL &&
             array->getType() == SkType_Int));
@@ -434,7 +434,7 @@
         if (maxStorage == 0)
             arrayStorage->setCount(numberOfComponents);
         for (int index = 0; index < numberOfColors; index++) {
-            SkColor color = scriptValue.fType == SkType_Array ? 
+            SkColor color = scriptValue.fType == SkType_Array ?
                 (SkColor) array->begin()[index].fS32 : (SkColor) scriptValue.fOperand.fS32;
             storage[0].fScalar = SkIntToScalar(SkColorGetA(color));
             storage[1].fScalar = SkIntToScalar(SkColorGetR(color));
@@ -528,11 +528,11 @@
 #endif // SK_USE_CONDENSED_INFO == 0
 
 #if 0
-bool SkMemberInfo::SetValue(void* valuePtr, const char value[], SkDisplayTypes type, 
+bool SkMemberInfo::SetValue(void* valuePtr, const char value[], SkDisplayTypes type,
                             int count) {
     switch (type) {
         case SkType_Animate:
-        case SkType_BaseBitmap: 
+        case SkType_BaseBitmap:
         case SkType_Bitmap:
         case SkType_Dash:
         case SkType_Displayable:
@@ -548,7 +548,7 @@
         case SkType_3D_Point:
         case SkType_Point:
     //  case SkType_PointArray:
-        case SkType_ScalarArray: 
+        case SkType_ScalarArray:
             SkParse::FindScalars(value, (SkScalar*) valuePtr, count);
             break;
         default:
diff --git a/src/animator/SkMemberInfo.h b/src/animator/SkMemberInfo.h
index f2e690c..007df60 100644
--- a/src/animator/SkMemberInfo.h
+++ b/src/animator/SkMemberInfo.h
@@ -83,15 +83,15 @@
     }
     void setString(SkDisplayable* , SkString* ) const;
     void setValue(SkDisplayable* , const SkOperand values[], int count) const;
-    bool setValue(SkAnimateMaker& , SkTDOperandArray* storage, 
-        int storageOffset, int maxStorage, SkDisplayable* , 
+    bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
+        int storageOffset, int maxStorage, SkDisplayable* ,
         SkDisplayTypes outType, const char value[], size_t len) const;
-    bool setValue(SkAnimateMaker& , SkTDOperandArray* storage, 
-        int storageOffset, int maxStorage, SkDisplayable* , 
+    bool setValue(SkAnimateMaker& , SkTDOperandArray* storage,
+        int storageOffset, int maxStorage, SkDisplayable* ,
         SkDisplayTypes outType, SkString& str) const;
 //  void setValue(SkDisplayable* , const char value[], const char name[]) const;
-    bool writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage, 
-        int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType, 
+    bool writeValue(SkDisplayable* displayable, SkTDOperandArray* arrayStorage,
+        int storageOffset, int maxStorage, void* untypedStorage, SkDisplayTypes outType,
         SkScriptValue& scriptValue) const;
 #if SK_USE_CONDENSED_INFO == 0
     static const SkMemberInfo* Find(const SkMemberInfo [], int count, int* index);
@@ -119,7 +119,7 @@
 #define SK_MEMBER_INHERITED \
     { (const char*) INHERITED::fInfo, 0, SkType_BaseClassInfo, INHERITED::fInfoCount }
 
-// #define SK_MEMBER_KEY_TYPE(_member, _type) 
+// #define SK_MEMBER_KEY_TYPE(_member, _type)
 //  {#_member, (size_t) -1, SkType_##_type, 0}
 
 #define SK_FUNCTION(_member) \
@@ -184,7 +184,7 @@
 #define DECLARE_EMPTY_MEMBER_INFO(_type) \
 public: \
     virtual SkDisplayTypes getType() const { return SkType_##_type; }
-    
+
 #define DECLARE_EXTRAS_MEMBER_INFO(_type) \
 public: \
     static const SkMemberInfo fInfo[]; \
diff --git a/src/animator/SkOpArray.cpp b/src/animator/SkOpArray.cpp
index 1f14476..94298cc 100644
--- a/src/animator/SkOpArray.cpp
+++ b/src/animator/SkOpArray.cpp
@@ -14,10 +14,10 @@
 }
 
 bool SkOpArray::getIndex(int index, SkOperand2* operand) {
-	if (index >= count()) {
-		SkASSERT(0);
-		return false;
-	}
-	*operand = begin()[index];
-	return true;
+    if (index >= count()) {
+        SkASSERT(0);
+        return false;
+    }
+    *operand = begin()[index];
+    return true;
 }
diff --git a/src/animator/SkOpArray.h b/src/animator/SkOpArray.h
index d5b9fe7..260bf78 100644
--- a/src/animator/SkOpArray.h
+++ b/src/animator/SkOpArray.h
@@ -11,19 +11,19 @@
 #include "SkOperand2.h"
 #include "SkTDArray_Experimental.h"
 
-typedef SkLongArray(SkOperand2) SkTDOperand2Array; 
+typedef SkLongArray(SkOperand2) SkTDOperand2Array;
 
 class SkOpArray : public SkTDOperand2Array {
 public:
-	SkOpArray();
-	SkOpArray(SkOperand2::OpType type);
-	bool getIndex(int index, SkOperand2* operand);
-	SkOperand2::OpType getType() { return fType; }
-	void setType(SkOperand2::OpType type) { 
-		fType = type;
-	}
+    SkOpArray();
+    SkOpArray(SkOperand2::OpType type);
+    bool getIndex(int index, SkOperand2* operand);
+    SkOperand2::OpType getType() { return fType; }
+    void setType(SkOperand2::OpType type) {
+        fType = type;
+    }
 protected:
-	SkOperand2::OpType fType;
+    SkOperand2::OpType fType;
 };
 
 #endif // SkOpArray_DEFINED
diff --git a/src/animator/SkOperand2.h b/src/animator/SkOperand2.h
index 4f09a01..f844b6b 100644
--- a/src/animator/SkOperand2.h
+++ b/src/animator/SkOperand2.h
@@ -14,40 +14,40 @@
 class SkString;
 
 union SkOperand2 {
-	enum OpType {
-		kNoType,
-		kS32 = 1,
-		kScalar = 2,
-		kString = 4,
-		kArray = 8,
-		kObject = 16
-	};
-	SkOpArray* fArray;
-	void* fObject;
-	size_t fReference;
-	int32_t fS32;
-	SkScalar fScalar;
-	SkString* fString;
+    enum OpType {
+        kNoType,
+        kS32 = 1,
+        kScalar = 2,
+        kString = 4,
+        kArray = 8,
+        kObject = 16
+    };
+    SkOpArray* fArray;
+    void* fObject;
+    size_t fReference;
+    int32_t fS32;
+    SkScalar fScalar;
+    SkString* fString;
 };
 
 struct SkScriptValue2 {
-	enum IsConstant {
-		kConstant,
-		kVariable
-	};
-	enum IsWritten {
-		kUnwritten,
-		kWritten
-	};
-	SkOperand2 fOperand;
-	SkOperand2::OpType fType : 8;
-	IsConstant fIsConstant : 8;
-	IsWritten fIsWritten : 8;
-	SkOpArray* getArray() { SkASSERT(fType == SkOperand2::kArray); return fOperand.fArray; }
-	void* getObject() { SkASSERT(fType == SkOperand2::kObject); return fOperand.fObject; }
-	int32_t getS32() { SkASSERT(fType == SkOperand2::kS32); return fOperand.fS32; }
-	SkScalar getScalar() { SkASSERT(fType == SkOperand2::kScalar); return fOperand.fScalar; }
-	SkString* getString() { SkASSERT(fType == SkOperand2::kString); return fOperand.fString; }
+    enum IsConstant {
+        kConstant,
+        kVariable
+    };
+    enum IsWritten {
+        kUnwritten,
+        kWritten
+    };
+    SkOperand2 fOperand;
+    SkOperand2::OpType fType : 8;
+    IsConstant fIsConstant : 8;
+    IsWritten fIsWritten : 8;
+    SkOpArray* getArray() { SkASSERT(fType == SkOperand2::kArray); return fOperand.fArray; }
+    void* getObject() { SkASSERT(fType == SkOperand2::kObject); return fOperand.fObject; }
+    int32_t getS32() { SkASSERT(fType == SkOperand2::kS32); return fOperand.fS32; }
+    SkScalar getScalar() { SkASSERT(fType == SkOperand2::kScalar); return fOperand.fScalar; }
+    SkString* getString() { SkASSERT(fType == SkOperand2::kString); return fOperand.fString; }
         bool isConstant() const { return fIsConstant == kConstant; }
 };
 
diff --git a/src/animator/SkOperandIterpolator.cpp b/src/animator/SkOperandIterpolator.cpp
index dcc454d..bc7d46b 100644
--- a/src/animator/SkOperandIterpolator.cpp
+++ b/src/animator/SkOperandIterpolator.cpp
@@ -15,7 +15,7 @@
     fType = SkType_Unknown;
 }
 
-SkOperandInterpolator::SkOperandInterpolator(int elemCount, int frameCount, 
+SkOperandInterpolator::SkOperandInterpolator(int elemCount, int frameCount,
                                              SkDisplayTypes type)
 {
     this->reset(elemCount, frameCount, type);
diff --git a/src/animator/SkParseSVGPath.cpp b/src/animator/SkParseSVGPath.cpp
index 1b375aa..f020e2e 100644
--- a/src/animator/SkParseSVGPath.cpp
+++ b/src/animator/SkParseSVGPath.cpp
@@ -101,7 +101,7 @@
     return str;
 }
 
-static const char* find_scalar(const char str[], SkScalar* value, 
+static const char* find_scalar(const char str[], SkScalar* value,
     bool isRelative, SkScalar relative)
 {
     str = SkParse::FindScalar(str, value);
@@ -146,7 +146,7 @@
                 op = 'L';
                 c = points[0];
                 break;
-            case 'L': 
+            case 'L':
                 data = find_points(data, points, 1, relative, &c);
                 fPath.lineTo(points[0]);
                 c = points[0];
@@ -165,10 +165,10 @@
                 c.fY = y;
             }
                 break;
-            case 'C': 
+            case 'C':
                 data = find_points(data, points, 3, relative, &c);
                 goto cubicCommon;
-            case 'S': 
+            case 'S':
                 data = find_points(data, &points[1], 2, relative, &c);
                 points[0] = c;
                 if (previousOp == 'C' || previousOp == 'S') {
diff --git a/src/animator/SkPathParts.cpp b/src/animator/SkPathParts.cpp
index 5af8150..3060bd4 100644
--- a/src/animator/SkPathParts.cpp
+++ b/src/animator/SkPathParts.cpp
@@ -16,8 +16,8 @@
 SkPathPart::SkPathPart() : fPath(NULL) {
 }
 
-void SkPathPart::dirty() { 
-    fPath->dirty(); 
+void SkPathPart::dirty() {
+    fPath->dirty();
 }
 
 SkDisplayable* SkPathPart::getParent() const {
@@ -86,7 +86,7 @@
 }
 
 bool SkLineTo::add() {
-    fPath->fPath.lineTo(x, y);  
+    fPath->fPath.lineTo(x, y);
     return false;
 }
 
@@ -103,7 +103,7 @@
 DEFINE_GET_MEMBER(SkRLineTo);
 
 bool SkRLineTo::add() {
-    fPath->fPath.rLineTo(x, y); 
+    fPath->fPath.rLineTo(x, y);
     return false;
 }
 
@@ -225,8 +225,8 @@
 
 DEFINE_GET_MEMBER(SkAddRect);
 
-SkAddRect::SkAddRect() { 
-    fRect.setEmpty(); 
+SkAddRect::SkAddRect() {
+    fRect.setEmpty();
 }
 
 bool SkAddRect::add() {
@@ -309,7 +309,7 @@
 }
 
 bool SkAddPath::add() {
-    SkASSERT (path != NULL); 
+    SkASSERT (path != NULL);
     if (matrix)
         fPath->fPath.addPath(path->fPath, matrix->getMatrix());
     else
diff --git a/src/animator/SkPostParts.cpp b/src/animator/SkPostParts.cpp
index 4b776a8..b6549a2 100644
--- a/src/animator/SkPostParts.cpp
+++ b/src/animator/SkPostParts.cpp
@@ -29,7 +29,7 @@
         fParent->fEvent.setS32(dataName, fInt);
     else if (SkScalarIsNaN(fFloat) == false)
         fParent->fEvent.setScalar(dataName, fFloat);
-    else if (string.size() > 0) 
+    else if (string.size() > 0)
         fParent->fEvent.setString(dataName, string);
 //  else
 //      SkASSERT(0);
diff --git a/src/animator/SkScript.cpp b/src/animator/SkScript.cpp
index 3b498fa..92e8f3c 100644
--- a/src/animator/SkScript.cpp
+++ b/src/animator/SkScript.cpp
@@ -16,7 +16,7 @@
 /* things to do
     ? re-enable support for struct literals (e.g., for initializing points or rects)
         {x:1, y:2}
-    ? use standard XML / script notation like document.getElementById("canvas");  
+    ? use standard XML / script notation like document.getElementById("canvas");
     finish support for typed arrays
         ? allow indexing arrays by string
             this could map to the 'name' attribute of a given child of an array
@@ -224,7 +224,7 @@
             if (nextChar == '>') {
                 op = kShiftRight;
                 goto twoChar;
-            } 
+            }
             op = kGreaterEqual;
             if (nextChar == '=')
                 goto twoChar;
@@ -253,7 +253,7 @@
 twoChar:
                 advance++;
                 break;
-            } 
+            }
             op = kLogicalNot;
             break;
         case '?':
@@ -298,7 +298,7 @@
             } while (true);
             signed char topPrecedence = gPrecedence[compare];
             SkASSERT(topPrecedence != -1);
-            if (topPrecedence > precedence || (topPrecedence == precedence && 
+            if (topPrecedence > precedence || (topPrecedence == precedence &&
                     gOpAttributes[op].fLeftType == kNoType)) {
                 break;
             }
@@ -327,7 +327,7 @@
     *fUserCallBacks.prepend() = callBack;
 }
 
-bool SkScriptEngine::convertParams(SkTDArray<SkScriptValue>& params, 
+bool SkScriptEngine::convertParams(SkTDArray<SkScriptValue>& params,
         const SkFunctionParamType* paramTypes, int paramCount) {
     if (params.count() > paramCount) {
         fError = kTooManyParameters;
@@ -366,7 +366,7 @@
     return ConvertTo(this, toType, value);
 }
 
-bool SkScriptEngine::evaluateDot(const char*& script, bool suppressed) { 
+bool SkScriptEngine::evaluateDot(const char*& script, bool suppressed) {
     size_t fieldLength = token_length(++script);        // skip dot
     if (fieldLength == 0) {
         fError = kExpectedFieldName;
@@ -382,8 +382,8 @@
     return evaluateDotParam(script, suppressed, field, fieldLength);
 }
 
-bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed, 
-        const char* field, size_t fieldLength) { 
+bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed,
+        const char* field, size_t fieldLength) {
     void* object;
     if (suppressed)
         object = NULL;
@@ -397,7 +397,7 @@
         fOperandStack.pop();
     }
     char ch; // see if it is a simple member or a function
-    while (is_ws(ch = script[0])) 
+    while (is_ws(ch = script[0]))
         script++;
     bool success = true;
     if (ch != '(') {
@@ -410,10 +410,10 @@
         *fBraceStack.push() = kFunctionBrace;
         success = functionParams(&script, params);
         if (success && suppressed == false &&
-                (success = handleMemberFunction(field, fieldLength, object, params)) == false) 
-            fError = kHandleMemberFunctionFailed;       
+                (success = handleMemberFunction(field, fieldLength, object, params)) == false)
+            fError = kHandleMemberFunctionFailed;
     }
-    return success; 
+    return success;
 }
 
 bool SkScriptEngine::evaluateScript(const char** scriptPtr, SkScriptValue* value) {
@@ -559,15 +559,15 @@
                             if (convertTo(tokenInfo->getType(), &tokenValue) == false)
                                 return false;
                         }
-                        tokenInfo->writeValue(fDisplayable, NULL, 0, 0, 
+                        tokenInfo->writeValue(fDisplayable, NULL, 0, 0,
                             (void*) ((char*) fInfo->memberData(fDisplayable) + tokenInfo->fOffset + fArrayOffset),
                             tokenInfo->getType(), tokenValue);
                     }
                 }
                 lastPush = false;
                 continue;
-            } else 
-#endif              
+            } else
+#endif
             if (fBraceStack.top() == kArrayBrace) {
                 SkScriptValue tokenValue;
                 success = innerScript(&script, &tokenValue);    // terminate and return on comma, close brace
@@ -579,12 +579,12 @@
 #if 0 // no support for structures for now
                     if (tokenValue.fType == SkType_Structure) {
                         fArrayOffset += (int) fInfo->getSize(fDisplayable);
-                    } else 
+                    } else
 #endif
                     {
                         SkDisplayTypes type = ToDisplayType(fReturnType);
                         if (fReturnType == kNoType) {
-                            // !!! short sighted; in the future, allow each returned array component to carry 
+                            // !!! short sighted; in the future, allow each returned array component to carry
                             // its own type, and let caller do any needed conversions
                             if (value->fOperand.fArray->count() == 0)
                                 value->fOperand.fArray->setType(type = tokenValue.fType);
@@ -730,11 +730,11 @@
                 if (success == false)
                     return false;
                 lastPush = true;
-                continue; 
+                continue;
             }
             // get next token, and evaluate immediately
             success = evaluateDot(script, SkToBool(suppressed));
-            if (success == false)               
+            if (success == false)
                 return false;
             lastPush = true;
             continue;
@@ -772,7 +772,7 @@
         }
 #endif
         if (ch == ')' && fBraceStack.count() > 0) {
-            SkBraceStyle braceStyle = fBraceStack.top(); 
+            SkBraceStyle braceStyle = fBraceStack.top();
             if (braceStyle == kFunctionBrace) {
                 fBraceStack.pop();
                 break;
@@ -795,7 +795,7 @@
         int advance = logicalOp(ch, nextChar);
         if (advance < 0)     // error
             return false;
-        if (advance == 0) 
+        if (advance == 0)
             advance = arithmeticOp(ch, nextChar, lastPush);
         if (advance == 0) // unknown token
             return false;
@@ -814,7 +814,7 @@
             return false;
         if (processOp() == false)
             return false;
-    }   
+    }
     SkOpType topType = fTypeStack.count() > 0 ? fTypeStack.top() : kNoType;
     if (suppressed == false && topType != fReturnType &&
             topType == kString && fReturnType != kNoType) { // if result is a string, give handle property a chance to convert it to the property value
@@ -945,7 +945,7 @@
         for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
             if (callBack->fCallBackType != kFunction)
                 continue;
-            success = (*callBack->fFunctionCallBack)(functionName.c_str(), functionName.size(), params, 
+            success = (*callBack->fFunctionCallBack)(functionName.c_str(), functionName.size(), params,
                 callBack->fUserStorage, &callbackResult);
             if (success) {
                 fOperandStack.push(callbackResult.fOperand);
@@ -986,7 +986,7 @@
     for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
         if (callBack->fCallBackType != kMemberFunction)
             continue;
-        success = (*callBack->fMemberFunctionCallBack)(field, len, object, params, 
+        success = (*callBack->fMemberFunctionCallBack)(field, len, object, params,
             callBack->fUserStorage, &callbackResult);
         if (success) {
             if (callbackResult.fType == SkType_String)
@@ -1008,7 +1008,7 @@
     for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
         if (callBack->fCallBackType != kObjectToString)
             continue;
-        success = (*callBack->fObjectToStringCallBack)(object, 
+        success = (*callBack->fObjectToStringCallBack)(object,
             callBack->fUserStorage, &callbackResult);
         if (success) {
             if (callbackResult.fType == SkType_String)
@@ -1027,14 +1027,14 @@
 bool SkScriptEngine::handleProperty(bool suppressed) {
     SkScriptValue callbackResult;
     bool success = true;
-    if (suppressed) 
+    if (suppressed)
         goto done;
     success = false; // note that with standard animator-script plugins, callback never returns false
     {
         for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
             if (callBack->fCallBackType != kProperty)
                 continue;
-            success = (*callBack->fPropertyCallBack)(fToken, fTokenLength, 
+            success = (*callBack->fPropertyCallBack)(fToken, fTokenLength,
                 callBack->fUserStorage, &callbackResult);
             if (success) {
                 if (callbackResult.fType == SkType_String && callbackResult.fOperand.fString == NULL) {
@@ -1146,7 +1146,7 @@
                 fError = kMismatchedBrackets;
                 return -1;
             }
-            if (match == kParen) 
+            if (match == kParen)
                 fOpStack.pop();
             else {
                 SkOpType indexType;
@@ -1157,7 +1157,7 @@
                 }
                 SkOperand indexOperand;
                 fOperandStack.pop(&indexOperand);
-                int index = indexType == kScalar ? SkScalarFloor(indexOperand.fScalar) : 
+                int index = indexType == kScalar ? SkScalarFloor(indexOperand.fScalar) :
                     indexOperand.fS32;
                 SkOpType arrayType;
                 fTypeStack.pop(&arrayType);
@@ -1192,7 +1192,7 @@
             }
             suppress.fSuppress = ifValue.fOperand.fS32 == 0;
             suppress.fOperator = kIf;
-            suppress.fOpStackDepth = fOpStack.count(); 
+            suppress.fOpStackDepth = fOpStack.count();
             suppress.fElse = false;
             fSuppressStack.push(suppress);
             // if left is true, do only up to colon
@@ -1218,7 +1218,7 @@
             if (match == kLogicalOr ? topInt != 0 : topInt == 0) {
                 suppress.fSuppress = true;
                 suppress.fOperator = match;
-                suppress.fOpStackDepth = fOpStack.count(); 
+                suppress.fOpStackDepth = fOpStack.count();
                 suppress.fElse = false;
                 fSuppressStack.push(suppress);
             } else {
@@ -1467,16 +1467,16 @@
     commonCallBack(kProperty, callBack, userStorage);
 }
 
-void SkScriptEngine::track(SkTypedArray* array) { 
-    SkASSERT(fTrackArray.find(array) < 0);  
-    *(fTrackArray.end() - 1) = array; 
-    fTrackArray.appendClear(); 
+void SkScriptEngine::track(SkTypedArray* array) {
+    SkASSERT(fTrackArray.find(array) < 0);
+    *(fTrackArray.end() - 1) = array;
+    fTrackArray.appendClear();
 }
 
-void SkScriptEngine::track(SkString* string) { 
-    SkASSERT(fTrackString.find(string) < 0);  
-    *(fTrackString.end() - 1) = string; 
-    fTrackString.appendClear(); 
+void SkScriptEngine::track(SkString* string) {
+    SkASSERT(fTrackString.find(string) < 0);
+    *(fTrackString.end() - 1) = string;
+    fTrackString.appendClear();
 }
 
 void SkScriptEngine::unboxCallBack(_unboxCallBack func, void* userStorage) {
@@ -1494,7 +1494,7 @@
     if (toType == SkType_Drawable)
         toType = SkType_Displayable;
     SkDisplayTypes type = value->fType;
-    if (type == toType) 
+    if (type == toType)
         return true;
     SkOperand& operand = value->fOperand;
     bool success = true;
@@ -1534,7 +1534,7 @@
             engine->track(strPtr);
             if (type == SkType_Int)
                 strPtr->appendS32(operand.fS32);
-            else if (type == SkType_Displayable) 
+            else if (type == SkType_Displayable)
                 SkASSERT(0); // must call through instance version instead of static version
             else {
                 if (type != SkType_Float) {
@@ -1665,17 +1665,17 @@
     testInt((6+7)*8),
     testInt(0&&1?2:3),
     testInt(3*(4+5)),
-    testScalar(1.0+2.0), 
-    testScalar(1.0+5), 
-    testScalar(3.0-1.0), 
-    testScalar(6-1.0), 
-    testScalar(- -5.5- -1.5), 
-    testScalar(2.5*6.), 
-    testScalar(0.5*4), 
-    testScalar(4.5/.5), 
-    testScalar(9.5/19), 
-    testRemainder(9.5, 0.5), 
-    testRemainder(9.,2), 
+    testScalar(1.0+2.0),
+    testScalar(1.0+5),
+    testScalar(3.0-1.0),
+    testScalar(6-1.0),
+    testScalar(- -5.5- -1.5),
+    testScalar(2.5*6.),
+    testScalar(0.5*4),
+    testScalar(4.5/.5),
+    testScalar(9.5/19),
+    testRemainder(9.5, 0.5),
+    testRemainder(9.,2),
     testRemainder(9,2.5),
     testRemainder(-9,2.5),
     testTrue(-9==-9.0),
@@ -1854,7 +1854,7 @@
     testInt(0?2?3:4:5),
     testInt(1?0?3:4:5),
     testInt(0?0?3:4:5),
-    
+
     testInt(1?2:(3?4:5)),
     testInt(0?2:(3?4:5)),
     testInt(1?0:(3?4:5)),
diff --git a/src/animator/SkScript.h b/src/animator/SkScript.h
index 95930e8..aa8d9a3 100644
--- a/src/animator/SkScript.h
+++ b/src/animator/SkScript.h
@@ -63,9 +63,9 @@
     typedef bool (*_boxCallBack)(void* userStorage, SkScriptValue* result);
     typedef bool (*_functionCallBack)(const char* func, size_t len, SkTDArray<SkScriptValue>& params,
         void* userStorage, SkScriptValue* result);
-    typedef bool (*_memberCallBack)(const char* member, size_t len, void* object, 
+    typedef bool (*_memberCallBack)(const char* member, size_t len, void* object,
         void* userStorage, SkScriptValue* result);
-    typedef bool (*_memberFunctionCallBack)(const char* member, size_t len, void* object, 
+    typedef bool (*_memberFunctionCallBack)(const char* member, size_t len, void* object,
         SkTDArray<SkScriptValue>& params, void* userStorage, SkScriptValue* result);
 //  typedef bool (*_objectToStringCallBack)(void* object, void* userStorage, SkScriptValue* result);
     typedef bool (*_propertyCallBack)(const char* prop, size_t len, void* userStorage, SkScriptValue* result);
@@ -169,7 +169,7 @@
         kTowardsNumber = 0,
         kTowardsString
     };
-    
+
 protected:
 
     struct SkOperatorAttributes {
diff --git a/src/animator/SkScript2.h b/src/animator/SkScript2.h
index 05073e4..03eb92c 100644
--- a/src/animator/SkScript2.h
+++ b/src/animator/SkScript2.h
@@ -15,274 +15,274 @@
 #include "SkTDict.h"
 #include "SkTDStack.h"
 
-typedef SkLongArray(SkString*) SkTDStringArray; 
+typedef SkLongArray(SkString*) SkTDStringArray;
 
 class SkAnimateMaker;
 class SkScriptCallBack;
 
 class SkScriptEngine2 {
 public:
-	enum Error {
-		kNoError,
-		kArrayIndexOutOfBounds,
-		kCouldNotFindReferencedID,
-		kFunctionCallFailed,
-		kMemberOpFailed,
-		kPropertyOpFailed
-	};
+    enum Error {
+        kNoError,
+        kArrayIndexOutOfBounds,
+        kCouldNotFindReferencedID,
+        kFunctionCallFailed,
+        kMemberOpFailed,
+        kPropertyOpFailed
+    };
 
-	enum Attrs {
-		kConstant,
-		kVariable
-	};
+    enum Attrs {
+        kConstant,
+        kVariable
+    };
 
-	SkScriptEngine2(SkOperand2::OpType returnType);
-	~SkScriptEngine2();
-	bool convertTo(SkOperand2::OpType , SkScriptValue2* );
-	bool evaluateScript(const char** script, SkScriptValue2* value);
-	void forget(SkOpArray* array);
-	Error getError() { return fError; }
-	SkOperand2::OpType getReturnType() { return fReturnType; }
-	void track(SkOpArray* array) { 
-		SkASSERT(fTrackArray.find(array) < 0);  
-		*fTrackArray.append() = array; }
-	void track(SkString* string) { 
-		SkASSERT(fTrackString.find(string) < 0);  
-		*fTrackString.append() = string; 
-	}
-	static bool ConvertTo(SkScriptEngine2* , SkOperand2::OpType toType, SkScriptValue2* value);
-	static SkScalar IntToScalar(int32_t );
-	static bool ValueToString(const SkScriptValue2& value, SkString* string);
+    SkScriptEngine2(SkOperand2::OpType returnType);
+    ~SkScriptEngine2();
+    bool convertTo(SkOperand2::OpType , SkScriptValue2* );
+    bool evaluateScript(const char** script, SkScriptValue2* value);
+    void forget(SkOpArray* array);
+    Error getError() { return fError; }
+    SkOperand2::OpType getReturnType() { return fReturnType; }
+    void track(SkOpArray* array) {
+        SkASSERT(fTrackArray.find(array) < 0);
+        *fTrackArray.append() = array; }
+    void track(SkString* string) {
+        SkASSERT(fTrackString.find(string) < 0);
+        *fTrackString.append() = string;
+    }
+    static bool ConvertTo(SkScriptEngine2* , SkOperand2::OpType toType, SkScriptValue2* value);
+    static SkScalar IntToScalar(int32_t );
+    static bool ValueToString(const SkScriptValue2& value, SkString* string);
 
-	enum Op {		// used by tokenizer attribute table
-		kUnassigned,
-		kAdd,
-		kBitAnd,
-		kBitNot,
-		kBitOr,
-		kDivide,
-		kEqual,
-		kFlipOps,
-		kGreaterEqual,
-		kLogicalAnd,
-		kLogicalNot,
-		kLogicalOr,
-		kMinus,
-		kModulo,
-		kMultiply,
-		kShiftLeft,
-		kShiftRight,	// signed
-		kSubtract,
-		kXor,
+    enum Op {        // used by tokenizer attribute table
+        kUnassigned,
+        kAdd,
+        kBitAnd,
+        kBitNot,
+        kBitOr,
+        kDivide,
+        kEqual,
+        kFlipOps,
+        kGreaterEqual,
+        kLogicalAnd,
+        kLogicalNot,
+        kLogicalOr,
+        kMinus,
+        kModulo,
+        kMultiply,
+        kShiftLeft,
+        kShiftRight,    // signed
+        kSubtract,
+        kXor,
 // following not in attribute table
-		kArrayOp,
-		kElse,
-		kIf,
-		kParen,
-		kLastLogicalOp,
-		kArtificialOp = 0x20
-	};
+        kArrayOp,
+        kElse,
+        kIf,
+        kParen,
+        kLastLogicalOp,
+        kArtificialOp = 0x20
+    };
 
-	enum TypeOp {	// generated by tokenizer
-		kNop, // should never get generated
-		kAccumulatorPop,
-		kAccumulatorPush,
-		kAddInt,
-		kAddScalar,
-		kAddString,	// string concat
-		kArrayIndex,
-		kArrayParam,
-		kArrayToken,
-		kBitAndInt,
-		kBitNotInt,
-		kBitOrInt,
-		kBoxToken,
-		kCallback,
-		kDivideInt,
-		kDivideScalar,
-		kDotOperator,
-		kElseOp,
-		kEnd,
-		kEqualInt,
-		kEqualScalar,
-		kEqualString,
-		kFunctionCall,
-		kFlipOpsOp,
-		kFunctionToken,
-		kGreaterEqualInt,
-		kGreaterEqualScalar,
-		kGreaterEqualString,
-		kIfOp,
-		kIntToScalar,
-		kIntToScalar2,
-		kIntToString,
-		kIntToString2,
-		kIntegerAccumulator,
-		kIntegerOperand,
-		kLogicalAndInt,
-		kLogicalNotInt,
-		kLogicalOrInt,
-		kMemberOp,
-		kMinusInt,
-		kMinusScalar,
-		kModuloInt,
-		kModuloScalar,
-		kMultiplyInt,
-		kMultiplyScalar,
-		kPropertyOp,
-		kScalarAccumulator,
-		kScalarOperand,
-		kScalarToInt,
-		kScalarToInt2,
-		kScalarToString,
-		kScalarToString2,
-		kShiftLeftInt,
-		kShiftRightInt,	// signed
-		kStringAccumulator,
-		kStringOperand,
-		kStringToInt,
-		kStringToScalar,
-		kStringToScalar2,
-		kStringTrack,
-		kSubtractInt,
-		kSubtractScalar,
-		kToBool,
-		kUnboxToken,
-		kUnboxToken2,
-		kXorInt,
-		kLastTypeOp
-	};
+    enum TypeOp {    // generated by tokenizer
+        kNop, // should never get generated
+        kAccumulatorPop,
+        kAccumulatorPush,
+        kAddInt,
+        kAddScalar,
+        kAddString,    // string concat
+        kArrayIndex,
+        kArrayParam,
+        kArrayToken,
+        kBitAndInt,
+        kBitNotInt,
+        kBitOrInt,
+        kBoxToken,
+        kCallback,
+        kDivideInt,
+        kDivideScalar,
+        kDotOperator,
+        kElseOp,
+        kEnd,
+        kEqualInt,
+        kEqualScalar,
+        kEqualString,
+        kFunctionCall,
+        kFlipOpsOp,
+        kFunctionToken,
+        kGreaterEqualInt,
+        kGreaterEqualScalar,
+        kGreaterEqualString,
+        kIfOp,
+        kIntToScalar,
+        kIntToScalar2,
+        kIntToString,
+        kIntToString2,
+        kIntegerAccumulator,
+        kIntegerOperand,
+        kLogicalAndInt,
+        kLogicalNotInt,
+        kLogicalOrInt,
+        kMemberOp,
+        kMinusInt,
+        kMinusScalar,
+        kModuloInt,
+        kModuloScalar,
+        kMultiplyInt,
+        kMultiplyScalar,
+        kPropertyOp,
+        kScalarAccumulator,
+        kScalarOperand,
+        kScalarToInt,
+        kScalarToInt2,
+        kScalarToString,
+        kScalarToString2,
+        kShiftLeftInt,
+        kShiftRightInt,    // signed
+        kStringAccumulator,
+        kStringOperand,
+        kStringToInt,
+        kStringToScalar,
+        kStringToScalar2,
+        kStringTrack,
+        kSubtractInt,
+        kSubtractScalar,
+        kToBool,
+        kUnboxToken,
+        kUnboxToken2,
+        kXorInt,
+        kLastTypeOp
+    };
 
-	enum OpBias {
-		kNoBias,
-		kTowardsNumber = 0,
-		kTowardsString
-	};
+    enum OpBias {
+        kNoBias,
+        kTowardsNumber = 0,
+        kTowardsString
+    };
 
 protected:
 
-	enum BraceStyle {
-	//	kStructBrace,
-		kArrayBrace,
-		kFunctionBrace
-	};
+    enum BraceStyle {
+    //    kStructBrace,
+        kArrayBrace,
+        kFunctionBrace
+    };
 
-	enum AddTokenRegister {
-		kAccumulator,
-		kOperand
-	};
-	
-	enum ResultIsBoolean {
-		kResultIsNotBoolean,
-		kResultIsBoolean
-	};
+    enum AddTokenRegister {
+        kAccumulator,
+        kOperand
+    };
 
-	struct OperatorAttributes {
-		unsigned int fLeftType : 3;	// SkOpType union, but only lower values
-		unsigned int fRightType : 3;	 // SkOpType union, but only lower values
-		OpBias fBias : 1;
-		ResultIsBoolean fResultIsBoolean : 1;
-	};
-	
-	struct Branch {
-		Branch() {
-		}
-		
-		Branch(Op op, int depth, unsigned offset) : fOffset(offset), fOpStackDepth(depth), fOperator(op),
-			fPrimed(kIsNotPrimed), fDone(kIsNotDone) {
-		}
+    enum ResultIsBoolean {
+        kResultIsNotBoolean,
+        kResultIsBoolean
+    };
 
-		enum Primed {
-			kIsNotPrimed,
-			kIsPrimed
-		};
+    struct OperatorAttributes {
+        unsigned int fLeftType : 3;    // SkOpType union, but only lower values
+        unsigned int fRightType : 3;     // SkOpType union, but only lower values
+        OpBias fBias : 1;
+        ResultIsBoolean fResultIsBoolean : 1;
+    };
 
-		enum Done {
-			kIsNotDone,
-			kIsDone,
-		};
+    struct Branch {
+        Branch() {
+        }
 
-		unsigned fOffset : 16; // offset in generated stream where branch needs to go
-		int fOpStackDepth : 7; // depth when operator was found
-		Op fOperator : 6; // operand which generated branch
-		mutable Primed fPrimed : 1;	// mark when next instruction generates branch
-		Done fDone : 1;	// mark when branch is complete
-		void prime() { fPrimed = kIsPrimed; }
-		void resolve(SkDynamicMemoryWStream* , size_t offset);
-	};
+        Branch(Op op, int depth, unsigned offset) : fOffset(offset), fOpStackDepth(depth), fOperator(op),
+            fPrimed(kIsNotPrimed), fDone(kIsNotDone) {
+        }
 
-	static const OperatorAttributes gOpAttributes[];
-	static const signed char gPrecedence[];
-	static const TypeOp gTokens[];
-	void addToken(TypeOp );
-	void addTokenConst(SkScriptValue2* , AddTokenRegister , SkOperand2::OpType , TypeOp );
-	void addTokenInt(int );
-	void addTokenScalar(SkScalar );
-	void addTokenString(const SkString& );
-	void addTokenValue(const SkScriptValue2& , AddTokenRegister );
-	int arithmeticOp(char ch, char nextChar, bool lastPush);
-	bool convertParams(SkTDArray<SkScriptValue2>* ,
-		const SkOperand2::OpType* paramTypes, int paramTypeCount);
-	void convertToString(SkOperand2* operand, SkOperand2::OpType type) {
-		SkScriptValue2 scriptValue;
-		scriptValue.fOperand = *operand;
-		scriptValue.fType = type;
-		convertTo(SkOperand2::kString, &scriptValue);
-		*operand = scriptValue.fOperand;
-	}
-	bool evaluateDot(const char*& script);
-	bool evaluateDotParam(const char*& script, const char* field, size_t fieldLength);
-	bool functionParams(const char** scriptPtr, SkTDArray<SkScriptValue2>* params);
-	size_t getTokenOffset();
-	SkOperand2::OpType getUnboxType(SkOperand2 scriptValue);
-	bool handleArrayIndexer(const char** scriptPtr);
-	bool handleFunction(const char** scriptPtr);
-	bool handleMember(const char* field, size_t len, void* object);
-	bool handleMemberFunction(const char* field, size_t len, void* object, 
-		SkTDArray<SkScriptValue2>* params);
-	bool handleProperty();
-	bool handleUnbox(SkScriptValue2* scriptValue);
-	bool innerScript(const char** scriptPtr, SkScriptValue2* value);
-	int logicalOp(char ch, char nextChar);
-	void processLogicalOp(Op op);
-	bool processOp();
-	void resolveBranch(Branch& );
-//	void setAnimateMaker(SkAnimateMaker* maker) { fMaker = maker; }
-	SkDynamicMemoryWStream fStream;
-	SkDynamicMemoryWStream* fActiveStream;
-	SkTDStack<BraceStyle> fBraceStack;		// curly, square, function paren
-	SkTDStack<Branch> fBranchStack;  // logical operators, slot to store forward branch
-	SkLongArray(SkScriptCallBack*) fCallBackArray;
-	SkTDStack<Op> fOpStack;
-	SkTDStack<SkScriptValue2> fValueStack;
-//	SkAnimateMaker* fMaker;
-	SkLongArray(SkOpArray*) fTrackArray;
-	SkTDStringArray fTrackString;
-	const char* fToken; // one-deep stack
-	size_t fTokenLength;
-	SkOperand2::OpType fReturnType;
-	Error fError;
-	SkOperand2::OpType fAccumulatorType;	// tracking for code generation
-	SkBool fBranchPopAllowed;
-	SkBool fConstExpression;
-	SkBool fOperandInUse;
+        enum Primed {
+            kIsNotPrimed,
+            kIsPrimed
+        };
+
+        enum Done {
+            kIsNotDone,
+            kIsDone,
+        };
+
+        unsigned fOffset : 16; // offset in generated stream where branch needs to go
+        int fOpStackDepth : 7; // depth when operator was found
+        Op fOperator : 6; // operand which generated branch
+        mutable Primed fPrimed : 1;    // mark when next instruction generates branch
+        Done fDone : 1;    // mark when branch is complete
+        void prime() { fPrimed = kIsPrimed; }
+        void resolve(SkDynamicMemoryWStream* , size_t offset);
+    };
+
+    static const OperatorAttributes gOpAttributes[];
+    static const signed char gPrecedence[];
+    static const TypeOp gTokens[];
+    void addToken(TypeOp );
+    void addTokenConst(SkScriptValue2* , AddTokenRegister , SkOperand2::OpType , TypeOp );
+    void addTokenInt(int );
+    void addTokenScalar(SkScalar );
+    void addTokenString(const SkString& );
+    void addTokenValue(const SkScriptValue2& , AddTokenRegister );
+    int arithmeticOp(char ch, char nextChar, bool lastPush);
+    bool convertParams(SkTDArray<SkScriptValue2>* ,
+        const SkOperand2::OpType* paramTypes, int paramTypeCount);
+    void convertToString(SkOperand2* operand, SkOperand2::OpType type) {
+        SkScriptValue2 scriptValue;
+        scriptValue.fOperand = *operand;
+        scriptValue.fType = type;
+        convertTo(SkOperand2::kString, &scriptValue);
+        *operand = scriptValue.fOperand;
+    }
+    bool evaluateDot(const char*& script);
+    bool evaluateDotParam(const char*& script, const char* field, size_t fieldLength);
+    bool functionParams(const char** scriptPtr, SkTDArray<SkScriptValue2>* params);
+    size_t getTokenOffset();
+    SkOperand2::OpType getUnboxType(SkOperand2 scriptValue);
+    bool handleArrayIndexer(const char** scriptPtr);
+    bool handleFunction(const char** scriptPtr);
+    bool handleMember(const char* field, size_t len, void* object);
+    bool handleMemberFunction(const char* field, size_t len, void* object,
+        SkTDArray<SkScriptValue2>* params);
+    bool handleProperty();
+    bool handleUnbox(SkScriptValue2* scriptValue);
+    bool innerScript(const char** scriptPtr, SkScriptValue2* value);
+    int logicalOp(char ch, char nextChar);
+    void processLogicalOp(Op op);
+    bool processOp();
+    void resolveBranch(Branch& );
+//    void setAnimateMaker(SkAnimateMaker* maker) { fMaker = maker; }
+    SkDynamicMemoryWStream fStream;
+    SkDynamicMemoryWStream* fActiveStream;
+    SkTDStack<BraceStyle> fBraceStack;        // curly, square, function paren
+    SkTDStack<Branch> fBranchStack;  // logical operators, slot to store forward branch
+    SkLongArray(SkScriptCallBack*) fCallBackArray;
+    SkTDStack<Op> fOpStack;
+    SkTDStack<SkScriptValue2> fValueStack;
+//    SkAnimateMaker* fMaker;
+    SkLongArray(SkOpArray*) fTrackArray;
+    SkTDStringArray fTrackString;
+    const char* fToken; // one-deep stack
+    size_t fTokenLength;
+    SkOperand2::OpType fReturnType;
+    Error fError;
+    SkOperand2::OpType fAccumulatorType;    // tracking for code generation
+    SkBool fBranchPopAllowed;
+    SkBool fConstExpression;
+    SkBool fOperandInUse;
 private:
 #ifdef SK_DEBUG
 public:
-	void decompile(const unsigned char* , size_t );
-	static void UnitTest();
-	static void ValidateDecompileTable();
+    void decompile(const unsigned char* , size_t );
+    static void UnitTest();
+    static void ValidateDecompileTable();
 #endif
 };
 
 #ifdef SK_DEBUG
 
 struct SkScriptNAnswer2 {
-	const char* fScript;
-	SkOperand2::OpType fType;
-	int32_t fIntAnswer;
-	SkScalar fScalarAnswer;
-	const char* fStringAnswer;
+    const char* fScript;
+    SkOperand2::OpType fType;
+    int32_t fIntAnswer;
+    SkScalar fScalarAnswer;
+    const char* fStringAnswer;
 };
 
 #endif
diff --git a/src/animator/SkScriptCallBack.h b/src/animator/SkScriptCallBack.h
index b2a1958..dcbaf11 100644
--- a/src/animator/SkScriptCallBack.h
+++ b/src/animator/SkScriptCallBack.h
@@ -13,53 +13,53 @@
 
 class SkScriptCallBack {
 public:
-	enum Type {
-		kBox,
-		kFunction,
-		kMember,
-		kMemberFunction,
-		kProperty,
-		kUnbox
-	};
+    enum Type {
+        kBox,
+        kFunction,
+        kMember,
+        kMemberFunction,
+        kProperty,
+        kUnbox
+    };
 
-	virtual bool getReference(const char* , size_t len, SkScriptValue2* result) {  return false; }
-	virtual SkOperand2::OpType getReturnType(size_t ref, SkOperand2*) { 
-		return SkOperand2::kS32; }
-	virtual Type getType() const = 0;
+    virtual bool getReference(const char* , size_t len, SkScriptValue2* result) {  return false; }
+    virtual SkOperand2::OpType getReturnType(size_t ref, SkOperand2*) {
+        return SkOperand2::kS32; }
+    virtual Type getType() const = 0;
 };
 
 class SkScriptCallBackConvert : public SkScriptCallBack {
 public:
-	virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) = 0;
+    virtual bool convert(SkOperand2::OpType type, SkOperand2* operand) = 0;
 };
 
 class SkScriptCallBackFunction : public SkScriptCallBack {
 public:
-	virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
-	virtual Type getType() const { return kFunction; }
-	virtual bool invoke(size_t ref, SkOpArray* params, SkOperand2* value) = 0;
+    virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
+    virtual Type getType() const { return kFunction; }
+    virtual bool invoke(size_t ref, SkOpArray* params, SkOperand2* value) = 0;
 };
 
 class SkScriptCallBackMember: public SkScriptCallBack {
 public:
-	bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
-	virtual Type getType() const { return kMember; }
-	virtual bool invoke(size_t ref, void* object, SkOperand2* value) = 0;
+    bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
+    virtual Type getType() const { return kMember; }
+    virtual bool invoke(size_t ref, void* object, SkOperand2* value) = 0;
 };
 
 class SkScriptCallBackMemberFunction : public SkScriptCallBack {
 public:
-	bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
-	virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
-	virtual Type getType() const { return kMemberFunction; }
-	virtual bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value) = 0;
+    bool getMemberReference(const char* , size_t len, void* object, SkScriptValue2* ref);
+    virtual void getParamTypes(SkIntArray(SkOperand2::OpType)* types) = 0;
+    virtual Type getType() const { return kMemberFunction; }
+    virtual bool invoke(size_t ref, void* object, SkOpArray* params, SkOperand2* value) = 0;
 };
 
 class SkScriptCallBackProperty : public SkScriptCallBack {
 public:
-	virtual bool getConstValue(const char* name, size_t len, SkOperand2* value) { return false; }
-	virtual bool getResult(size_t ref, SkOperand2* answer) { return false; }
-	virtual Type getType() const { return kProperty; }
+    virtual bool getConstValue(const char* name, size_t len, SkOperand2* value) { return false; }
+    virtual bool getResult(size_t ref, SkOperand2* answer) { return false; }
+    virtual Type getType() const { return kProperty; }
 };
 
 #endif // SkScriptCallBack_DEFINED
diff --git a/src/animator/SkScriptDecompile.cpp b/src/animator/SkScriptDecompile.cpp
index 26b678c..995da87 100644
--- a/src/animator/SkScriptDecompile.cpp
+++ b/src/animator/SkScriptDecompile.cpp
@@ -99,7 +99,7 @@
     OperandName(kString),
     OperandName(kArray),
     OperandName(kObject)
-};  
+};
 
 static size_t gOperandNamesSize = sizeof(gOperandNames) / sizeof(gOperandNames[0]);
 
@@ -135,7 +135,7 @@
             opCode += sizeof(index);
             SkDebugf(" index: %d", index);
             } break;
-        case SkScriptEngine2::kFunctionCall: 
+        case SkScriptEngine2::kFunctionCall:
         case SkScriptEngine2::kMemberOp:
         case SkScriptEngine2::kPropertyOp: {
             size_t ref;
diff --git a/src/animator/SkScriptRuntime.cpp b/src/animator/SkScriptRuntime.cpp
index 6a96633..b211a71 100644
--- a/src/animator/SkScriptRuntime.cpp
+++ b/src/animator/SkScriptRuntime.cpp
@@ -27,326 +27,326 @@
 // replace script string with script tokens preceeded by special value
 
 // need second version of script plugins that return private index of found value?
-	// then would need in script index of plugin, private index
+    // then would need in script index of plugin, private index
 
 // encode brace stack push/pop as opcodes
 
 // should token script enocde type where possible?
 
 // current flow:
-	// strip whitespace
-	// if in array brace [ recurse, continue
-	// if token, handle function, or array, or property (continue)
-	// parse number, continue
-	// parse token, continue
-	// parse string literal, continue
-	// if dot operator, handle dot, continue
-	// if [ , handle array literal or accessor, continue
-	// if ), pop (if function, break)
-	// if ], pop ; if ',' break
-	// handle logical ops
-	// or, handle arithmetic ops
-	// loop
+    // strip whitespace
+    // if in array brace [ recurse, continue
+    // if token, handle function, or array, or property (continue)
+    // parse number, continue
+    // parse token, continue
+    // parse string literal, continue
+    // if dot operator, handle dot, continue
+    // if [ , handle array literal or accessor, continue
+    // if ), pop (if function, break)
+    // if ], pop ; if ',' break
+    // handle logical ops
+    // or, handle arithmetic ops
+    // loop
 
 // !!! things to do
-	// add separate processing loop to advance while suppressed
-	// or, include jump offset to skip suppressed code?
+    // add separate processing loop to advance while suppressed
+    // or, include jump offset to skip suppressed code?
 
 SkScriptRuntime::~SkScriptRuntime() {
-	for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++)
-		delete *stringPtr;
-	for (SkOpArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++)
-		delete *arrayPtr;
+    for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++)
+        delete *stringPtr;
+    for (SkOpArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++)
+        delete *arrayPtr;
 }
 
 bool SkScriptRuntime::executeTokens(unsigned char* opCode) {
-	SkOperand2 operand[2];	// 1=accumulator and 2=operand
-	SkScriptEngine2::TypeOp op;
-	size_t ref;
-	int index, size;
-	int registerLoad;
-	SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING;
-	do {
-	switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) {
-		case SkScriptEngine2::kArrayToken:	// create an array
-			operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/);
-			break;
-		case SkScriptEngine2::kArrayIndex:	// array accessor
-			index = operand[1].fS32;
-			if (index >= operand[0].fArray->count()) {
-				fError = kArrayIndexOutOfBounds;
-				return false;
-			}
-			operand[0] = operand[0].fArray->begin()[index];
-			break;
-		case SkScriptEngine2::kArrayParam:	// array initializer, or function param
-			*operand[0].fArray->append() = operand[1];
-			break;
-		case SkScriptEngine2::kCallback:
-			memcpy(&index, opCode, sizeof(index));
-			opCode += sizeof(index);
-			callBack = fCallBackArray[index];
-			break;
-		case SkScriptEngine2::kFunctionCall: {
-			memcpy(&ref, opCode, sizeof(ref));
-			opCode += sizeof(ref);
-			SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack;
-			if (callBackFunction->invoke(ref, operand[0].fArray, /* params */
-					&operand[0] /* result */) == false) {
-				fError = kFunctionCallFailed;
-				return false;
-			}
-			} break;
-		case SkScriptEngine2::kMemberOp: {
-			memcpy(&ref, opCode, sizeof(ref));
-			opCode += sizeof(ref);
-			SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack;
-			if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) {
-				fError = kMemberOpFailed;
-				return false;
-			}
-			} break;
-		case SkScriptEngine2::kPropertyOp: {
-			memcpy(&ref, opCode, sizeof(ref));
-			opCode += sizeof(ref);
-			SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack;
-			if (callBackProperty->getResult(ref, &operand[0])== false) {
-				fError = kPropertyOpFailed;
-				return false;
-			}
-			} break;
-		case SkScriptEngine2::kAccumulatorPop:
-			fRunStack.pop(&operand[0]);
-			break;
-		case SkScriptEngine2::kAccumulatorPush:
-			*fRunStack.push() = operand[0];
-			break;
-		case SkScriptEngine2::kIntegerAccumulator:
-		case SkScriptEngine2::kIntegerOperand:
-			registerLoad = op - SkScriptEngine2::kIntegerAccumulator;
-			memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t));
-			opCode += sizeof(int32_t);
-			break;
-		case SkScriptEngine2::kScalarAccumulator:
-		case SkScriptEngine2::kScalarOperand:
-			registerLoad = op - SkScriptEngine2::kScalarAccumulator;
-			memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar));
-			opCode += sizeof(SkScalar);
-			break;
-		case SkScriptEngine2::kStringAccumulator:
-		case SkScriptEngine2::kStringOperand: {
-			SkString* strPtr = new SkString();
-			track(strPtr);
-			registerLoad = op - SkScriptEngine2::kStringAccumulator;
-			memcpy(&size, opCode, sizeof(size));
-			opCode += sizeof(size);
-			strPtr->set((char*) opCode, size);
-			opCode += size;
-			operand[registerLoad].fString = strPtr;
-			} break;
-		case SkScriptEngine2::kStringTrack: // call after kObjectToValue
-			track(operand[0].fString);
-			break;
-		case SkScriptEngine2::kBoxToken: {
-			SkOperand2::OpType type;
-			memcpy(&type, opCode, sizeof(type));
-			opCode += sizeof(type);
-			SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack;
-			if (callBackBox->convert(type, &operand[0]) == false)
-				return false;
-			} break;
-		case SkScriptEngine2::kUnboxToken:
-		case SkScriptEngine2::kUnboxToken2: {
-			SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack;
-			if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false)
-				return false;
-			} break;
-		case SkScriptEngine2::kIfOp:
-		case SkScriptEngine2::kLogicalAndInt:
-			memcpy(&size, opCode, sizeof(size));
-			opCode += sizeof(size);
-			if (operand[0].fS32 == 0)
-				opCode += size; // skip to else (or end of if predicate)
-			break;
-		case SkScriptEngine2::kElseOp:
-			memcpy(&size, opCode, sizeof(size));
-			opCode += sizeof(size);
-			opCode += size; // if true: after predicate, always skip to end of else
-			break;
-		case SkScriptEngine2::kLogicalOrInt:
-			memcpy(&size, opCode, sizeof(size));
-			opCode += sizeof(size);
-			if (operand[0].fS32 != 0)
-				opCode += size; // skip to kToBool opcode after || predicate
-			break;
-		// arithmetic conversion ops
-		case SkScriptEngine2::kFlipOpsOp:
-			SkTSwap(operand[0], operand[1]);
-			break;
-		case SkScriptEngine2::kIntToString: 
-		case SkScriptEngine2::kIntToString2: 
-		case SkScriptEngine2::kScalarToString:
-		case SkScriptEngine2::kScalarToString2:{
-			SkString* strPtr = new SkString();
-			track(strPtr);
-			if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2)
-				strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32);
-			else
-				strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar);
-			operand[0].fString = strPtr;
-			} break;
-		case SkScriptEngine2::kIntToScalar:
-		case SkScriptEngine2::kIntToScalar2:
-			operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32);
-			break;
-		case SkScriptEngine2::kStringToInt:
-			if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == false)
-				return false; 
-			break;
-		case SkScriptEngine2::kStringToScalar:
-		case SkScriptEngine2::kStringToScalar2:
-			if (SkParse::FindScalar(operand[0].fString->c_str(), 
-					&operand[op - SkScriptEngine2::kStringToScalar].fScalar) == false) 
-				return false; 
-			break;
-		case SkScriptEngine2::kScalarToInt:
-			operand[0].fS32 = SkScalarFloor(operand[0].fScalar);
-			break;
-		// arithmetic ops
-		case SkScriptEngine2::kAddInt:
-			operand[0].fS32 += operand[1].fS32;
-			break;
-		case SkScriptEngine2::kAddScalar:
-			operand[0].fScalar += operand[1].fScalar;
-			break;
-		case SkScriptEngine2::kAddString:
-//			if (fTrackString.find(operand[1].fString) < 0) {
-//				operand[1].fString = SkNEW_ARGS(SkString, (*operand[1].fString));
-//				track(operand[1].fString);
-//			}
-			operand[0].fString->append(*operand[1].fString);
-			break;
-		case SkScriptEngine2::kBitAndInt:
-			operand[0].fS32 &= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kBitNotInt:
-			operand[0].fS32 = ~operand[0].fS32;
-			break;
-		case SkScriptEngine2::kBitOrInt:
-			operand[0].fS32 |= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kDivideInt:
-			SkASSERT(operand[1].fS32 != 0);
-			if (operand[1].fS32 == 0)
-				operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 : 
-					operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
-			else
-			if (operand[1].fS32 != 0) // throw error on divide by zero?
-				operand[0].fS32 /= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kDivideScalar:
-			if (operand[1].fScalar == 0)
-				operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN : 
-					operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
-			else
-				operand[0].fScalar = SkScalarDiv(operand[0].fScalar, operand[1].fScalar);
-			break;
-		case SkScriptEngine2::kEqualInt:
-			operand[0].fS32 = operand[0].fS32 == operand[1].fS32;
-			break;
-		case SkScriptEngine2::kEqualScalar:
-			operand[0].fS32 = operand[0].fScalar == operand[1].fScalar;
-			break;
-		case SkScriptEngine2::kEqualString:
-			operand[0].fS32 = *operand[0].fString == *operand[1].fString;
-			break;
-		case SkScriptEngine2::kGreaterEqualInt:
-			operand[0].fS32 = operand[0].fS32 >= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kGreaterEqualScalar:
-			operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar;
-			break;
-		case SkScriptEngine2::kGreaterEqualString:
-			operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0;
-			break;
-		case SkScriptEngine2::kToBool:
-			operand[0].fS32 = !! operand[0].fS32;
-			break;
-		case SkScriptEngine2::kLogicalNotInt:
-			operand[0].fS32 = ! operand[0].fS32;
-			break;
-		case SkScriptEngine2::kMinusInt:
-			operand[0].fS32 = -operand[0].fS32;
-			break;
-		case SkScriptEngine2::kMinusScalar:
-			operand[0].fScalar = -operand[0].fScalar;
-			break;
-		case SkScriptEngine2::kModuloInt:
-			operand[0].fS32 %= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kModuloScalar:
-			operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar);
-			break;
-		case SkScriptEngine2::kMultiplyInt:
-			operand[0].fS32 *= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kMultiplyScalar:
-			operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar);
-			break;
-		case SkScriptEngine2::kShiftLeftInt:
-			operand[0].fS32 <<= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kShiftRightInt:
-			operand[0].fS32 >>= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kSubtractInt:
-			operand[0].fS32 -= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kSubtractScalar:
-			operand[0].fScalar -= operand[1].fScalar;
-			break;
-		case SkScriptEngine2::kXorInt:
-			operand[0].fS32 ^= operand[1].fS32;
-			break;
-		case SkScriptEngine2::kEnd:
-			goto done;
-		case SkScriptEngine2::kNop:
-				SkASSERT(0);
+    SkOperand2 operand[2];    // 1=accumulator and 2=operand
+    SkScriptEngine2::TypeOp op;
+    size_t ref;
+    int index, size;
+    int registerLoad;
+    SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING;
+    do {
+    switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) {
+        case SkScriptEngine2::kArrayToken:    // create an array
+            operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/);
+            break;
+        case SkScriptEngine2::kArrayIndex:    // array accessor
+            index = operand[1].fS32;
+            if (index >= operand[0].fArray->count()) {
+                fError = kArrayIndexOutOfBounds;
+                return false;
+            }
+            operand[0] = operand[0].fArray->begin()[index];
+            break;
+        case SkScriptEngine2::kArrayParam:    // array initializer, or function param
+            *operand[0].fArray->append() = operand[1];
+            break;
+        case SkScriptEngine2::kCallback:
+            memcpy(&index, opCode, sizeof(index));
+            opCode += sizeof(index);
+            callBack = fCallBackArray[index];
+            break;
+        case SkScriptEngine2::kFunctionCall: {
+            memcpy(&ref, opCode, sizeof(ref));
+            opCode += sizeof(ref);
+            SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack;
+            if (callBackFunction->invoke(ref, operand[0].fArray, /* params */
+                    &operand[0] /* result */) == false) {
+                fError = kFunctionCallFailed;
+                return false;
+            }
+            } break;
+        case SkScriptEngine2::kMemberOp: {
+            memcpy(&ref, opCode, sizeof(ref));
+            opCode += sizeof(ref);
+            SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack;
+            if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) {
+                fError = kMemberOpFailed;
+                return false;
+            }
+            } break;
+        case SkScriptEngine2::kPropertyOp: {
+            memcpy(&ref, opCode, sizeof(ref));
+            opCode += sizeof(ref);
+            SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack;
+            if (callBackProperty->getResult(ref, &operand[0])== false) {
+                fError = kPropertyOpFailed;
+                return false;
+            }
+            } break;
+        case SkScriptEngine2::kAccumulatorPop:
+            fRunStack.pop(&operand[0]);
+            break;
+        case SkScriptEngine2::kAccumulatorPush:
+            *fRunStack.push() = operand[0];
+            break;
+        case SkScriptEngine2::kIntegerAccumulator:
+        case SkScriptEngine2::kIntegerOperand:
+            registerLoad = op - SkScriptEngine2::kIntegerAccumulator;
+            memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t));
+            opCode += sizeof(int32_t);
+            break;
+        case SkScriptEngine2::kScalarAccumulator:
+        case SkScriptEngine2::kScalarOperand:
+            registerLoad = op - SkScriptEngine2::kScalarAccumulator;
+            memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar));
+            opCode += sizeof(SkScalar);
+            break;
+        case SkScriptEngine2::kStringAccumulator:
+        case SkScriptEngine2::kStringOperand: {
+            SkString* strPtr = new SkString();
+            track(strPtr);
+            registerLoad = op - SkScriptEngine2::kStringAccumulator;
+            memcpy(&size, opCode, sizeof(size));
+            opCode += sizeof(size);
+            strPtr->set((char*) opCode, size);
+            opCode += size;
+            operand[registerLoad].fString = strPtr;
+            } break;
+        case SkScriptEngine2::kStringTrack: // call after kObjectToValue
+            track(operand[0].fString);
+            break;
+        case SkScriptEngine2::kBoxToken: {
+            SkOperand2::OpType type;
+            memcpy(&type, opCode, sizeof(type));
+            opCode += sizeof(type);
+            SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack;
+            if (callBackBox->convert(type, &operand[0]) == false)
+                return false;
+            } break;
+        case SkScriptEngine2::kUnboxToken:
+        case SkScriptEngine2::kUnboxToken2: {
+            SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack;
+            if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false)
+                return false;
+            } break;
+        case SkScriptEngine2::kIfOp:
+        case SkScriptEngine2::kLogicalAndInt:
+            memcpy(&size, opCode, sizeof(size));
+            opCode += sizeof(size);
+            if (operand[0].fS32 == 0)
+                opCode += size; // skip to else (or end of if predicate)
+            break;
+        case SkScriptEngine2::kElseOp:
+            memcpy(&size, opCode, sizeof(size));
+            opCode += sizeof(size);
+            opCode += size; // if true: after predicate, always skip to end of else
+            break;
+        case SkScriptEngine2::kLogicalOrInt:
+            memcpy(&size, opCode, sizeof(size));
+            opCode += sizeof(size);
+            if (operand[0].fS32 != 0)
+                opCode += size; // skip to kToBool opcode after || predicate
+            break;
+        // arithmetic conversion ops
+        case SkScriptEngine2::kFlipOpsOp:
+            SkTSwap(operand[0], operand[1]);
+            break;
+        case SkScriptEngine2::kIntToString:
+        case SkScriptEngine2::kIntToString2:
+        case SkScriptEngine2::kScalarToString:
+        case SkScriptEngine2::kScalarToString2:{
+            SkString* strPtr = new SkString();
+            track(strPtr);
+            if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2)
+                strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32);
+            else
+                strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar);
+            operand[0].fString = strPtr;
+            } break;
+        case SkScriptEngine2::kIntToScalar:
+        case SkScriptEngine2::kIntToScalar2:
+            operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32);
+            break;
+        case SkScriptEngine2::kStringToInt:
+            if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == false)
+                return false;
+            break;
+        case SkScriptEngine2::kStringToScalar:
+        case SkScriptEngine2::kStringToScalar2:
+            if (SkParse::FindScalar(operand[0].fString->c_str(),
+                    &operand[op - SkScriptEngine2::kStringToScalar].fScalar) == false)
+                return false;
+            break;
+        case SkScriptEngine2::kScalarToInt:
+            operand[0].fS32 = SkScalarFloor(operand[0].fScalar);
+            break;
+        // arithmetic ops
+        case SkScriptEngine2::kAddInt:
+            operand[0].fS32 += operand[1].fS32;
+            break;
+        case SkScriptEngine2::kAddScalar:
+            operand[0].fScalar += operand[1].fScalar;
+            break;
+        case SkScriptEngine2::kAddString:
+//            if (fTrackString.find(operand[1].fString) < 0) {
+//                operand[1].fString = SkNEW_ARGS(SkString, (*operand[1].fString));
+//                track(operand[1].fString);
+//            }
+            operand[0].fString->append(*operand[1].fString);
+            break;
+        case SkScriptEngine2::kBitAndInt:
+            operand[0].fS32 &= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kBitNotInt:
+            operand[0].fS32 = ~operand[0].fS32;
+            break;
+        case SkScriptEngine2::kBitOrInt:
+            operand[0].fS32 |= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kDivideInt:
+            SkASSERT(operand[1].fS32 != 0);
+            if (operand[1].fS32 == 0)
+                operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 :
+                    operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
+            else
+            if (operand[1].fS32 != 0) // throw error on divide by zero?
+                operand[0].fS32 /= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kDivideScalar:
+            if (operand[1].fScalar == 0)
+                operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN :
+                    operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
+            else
+                operand[0].fScalar = SkScalarDiv(operand[0].fScalar, operand[1].fScalar);
+            break;
+        case SkScriptEngine2::kEqualInt:
+            operand[0].fS32 = operand[0].fS32 == operand[1].fS32;
+            break;
+        case SkScriptEngine2::kEqualScalar:
+            operand[0].fS32 = operand[0].fScalar == operand[1].fScalar;
+            break;
+        case SkScriptEngine2::kEqualString:
+            operand[0].fS32 = *operand[0].fString == *operand[1].fString;
+            break;
+        case SkScriptEngine2::kGreaterEqualInt:
+            operand[0].fS32 = operand[0].fS32 >= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kGreaterEqualScalar:
+            operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar;
+            break;
+        case SkScriptEngine2::kGreaterEqualString:
+            operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0;
+            break;
+        case SkScriptEngine2::kToBool:
+            operand[0].fS32 = !! operand[0].fS32;
+            break;
+        case SkScriptEngine2::kLogicalNotInt:
+            operand[0].fS32 = ! operand[0].fS32;
+            break;
+        case SkScriptEngine2::kMinusInt:
+            operand[0].fS32 = -operand[0].fS32;
+            break;
+        case SkScriptEngine2::kMinusScalar:
+            operand[0].fScalar = -operand[0].fScalar;
+            break;
+        case SkScriptEngine2::kModuloInt:
+            operand[0].fS32 %= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kModuloScalar:
+            operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar);
+            break;
+        case SkScriptEngine2::kMultiplyInt:
+            operand[0].fS32 *= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kMultiplyScalar:
+            operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar);
+            break;
+        case SkScriptEngine2::kShiftLeftInt:
+            operand[0].fS32 <<= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kShiftRightInt:
+            operand[0].fS32 >>= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kSubtractInt:
+            operand[0].fS32 -= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kSubtractScalar:
+            operand[0].fScalar -= operand[1].fScalar;
+            break;
+        case SkScriptEngine2::kXorInt:
+            operand[0].fS32 ^= operand[1].fS32;
+            break;
+        case SkScriptEngine2::kEnd:
+            goto done;
+        case SkScriptEngine2::kNop:
+                SkASSERT(0);
     default:
         break;
-	}
-	} while (true);
+    }
+    } while (true);
 done:
-	fRunStack.push(operand[0]);
-	return true;
+    fRunStack.push(operand[0]);
+    return true;
 }
 
 bool SkScriptRuntime::getResult(SkOperand2* result) {
-	if (fRunStack.count() == 0)
-		return false;
-	fRunStack.pop(result);
-	return true;
+    if (fRunStack.count() == 0)
+        return false;
+    fRunStack.pop(result);
+    return true;
 }
 
-void SkScriptRuntime::track(SkOpArray* array) { 
-	SkASSERT(fTrackArray.find(array) < 0);  
-	*fTrackArray.append() = array; 
+void SkScriptRuntime::track(SkOpArray* array) {
+    SkASSERT(fTrackArray.find(array) < 0);
+    *fTrackArray.append() = array;
 }
 
-void SkScriptRuntime::track(SkString* string) { 
-	SkASSERT(fTrackString.find(string) < 0);  
-	*fTrackString.append() = string; 
+void SkScriptRuntime::track(SkString* string) {
+    SkASSERT(fTrackString.find(string) < 0);
+    *fTrackString.append() = string;
 }
 
 void SkScriptRuntime::untrack(SkOpArray* array) {
-	int index = fTrackArray.find(array);
-	SkASSERT(index >= 0);
-	fTrackArray.begin()[index] = NULL;
+    int index = fTrackArray.find(array);
+    SkASSERT(index >= 0);
+    fTrackArray.begin()[index] = NULL;
 }
 
 void SkScriptRuntime::untrack(SkString* string) {
-	int index = fTrackString.find(string);
-	SkASSERT(index >= 0);
-	fTrackString.begin()[index] = NULL;
+    int index = fTrackString.find(string);
+    SkASSERT(index >= 0);
+    fTrackString.begin()[index] = NULL;
 }
 
diff --git a/src/animator/SkScriptRuntime.h b/src/animator/SkScriptRuntime.h
index 7721bd2..3e73801 100644
--- a/src/animator/SkScriptRuntime.h
+++ b/src/animator/SkScriptRuntime.h
@@ -14,37 +14,37 @@
 
 class SkScriptCallBack;
 
-typedef SkLongArray(SkString*) SkTDStringArray; 
-typedef SkLongArray(SkScriptCallBack*) SkTDScriptCallBackArray; 
+typedef SkLongArray(SkString*) SkTDStringArray;
+typedef SkLongArray(SkScriptCallBack*) SkTDScriptCallBackArray;
 
 class SkScriptRuntime {
 public:
-	enum SkError {
-		kNoError,
-		kArrayIndexOutOfBounds,
-		kCouldNotFindReferencedID,
-		kFunctionCallFailed,
-		kMemberOpFailed,
-		kPropertyOpFailed
-	};
+    enum SkError {
+        kNoError,
+        kArrayIndexOutOfBounds,
+        kCouldNotFindReferencedID,
+        kFunctionCallFailed,
+        kMemberOpFailed,
+        kPropertyOpFailed
+    };
 
-	SkScriptRuntime(SkTDScriptCallBackArray& callBackArray) : fCallBackArray(callBackArray)
-		{  }
-	~SkScriptRuntime();
-	bool executeTokens(unsigned char* opCode);
-	bool getResult(SkOperand2* result);
-	void untrack(SkOpArray* array);
-	void untrack(SkString* string);
+    SkScriptRuntime(SkTDScriptCallBackArray& callBackArray) : fCallBackArray(callBackArray)
+        {  }
+    ~SkScriptRuntime();
+    bool executeTokens(unsigned char* opCode);
+    bool getResult(SkOperand2* result);
+    void untrack(SkOpArray* array);
+    void untrack(SkString* string);
 private:
-	void track(SkOpArray* array);
-	void track(SkString* string);
-	SkTDScriptCallBackArray& fCallBackArray;
-	SkError fError;
-	SkTDStack<SkOperand2> fRunStack;
-	SkLongArray(SkOpArray*) fTrackArray;
-	SkTDStringArray fTrackString;
-	// illegal
-	SkScriptRuntime& operator=(const SkScriptRuntime&);
+    void track(SkOpArray* array);
+    void track(SkString* string);
+    SkTDScriptCallBackArray& fCallBackArray;
+    SkError fError;
+    SkTDStack<SkOperand2> fRunStack;
+    SkLongArray(SkOpArray*) fTrackArray;
+    SkTDStringArray fTrackString;
+    // illegal
+    SkScriptRuntime& operator=(const SkScriptRuntime&);
 };
 
 #endif // SkScriptRuntime_DEFINED
diff --git a/src/animator/SkScriptTokenizer.cpp b/src/animator/SkScriptTokenizer.cpp
index 90a50b6..9547a98 100644
--- a/src/animator/SkScriptTokenizer.cpp
+++ b/src/animator/SkScriptTokenizer.cpp
@@ -17,31 +17,31 @@
 
 const SkScriptEngine2::OperatorAttributes SkScriptEngine2::gOpAttributes[] = {
 { SkOperand2::kNoType, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean },
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
     SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsString, kResultIsNotBoolean },    // kAdd
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitAnd
 { SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitNot
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kBitOr
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
     SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kDivide
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), 
-    SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar |SkOperand2:: kString), kTowardsNumber, 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
+    SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar |SkOperand2:: kString), kTowardsNumber,
     kResultIsBoolean }, // kEqual
 { SkOperand2::kS32, SkOperand2::kNoType, kNoBias, kResultIsNotBoolean },     // kFlipOps
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString),
     SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar | SkOperand2::kString), kTowardsNumber,
     kResultIsBoolean }, // kGreaterEqual
 { SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalAnd    (really, ToBool)
 { SkOperand2::kNoType, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalNot
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kLogicalOr
 { SkOperand2::kNoType, SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMinus
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
     SkOperand2::OpType(SkOperand2::kS32 |SkOperand2:: kScalar), kNoBias, kResultIsNotBoolean }, // kModulo
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
     SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kMultiply
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftLeft
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean }, // kShiftRight
-{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), 
+{ SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar),
     SkOperand2::OpType(SkOperand2::kS32 | SkOperand2::kScalar), kNoBias, kResultIsNotBoolean }, // kSubtract
 { SkOperand2::kS32, SkOperand2::kS32, kNoBias, kResultIsNotBoolean } // kXor
 };
@@ -120,7 +120,7 @@
 }
 
 SkScriptEngine2::SkScriptEngine2(SkOperand2::OpType returnType) : fActiveStream(&fStream),
-fTokenLength(0), fReturnType(returnType), fError(kNoError), 
+fTokenLength(0), fReturnType(returnType), fError(kNoError),
 fAccumulatorType(SkOperand2::kNoType),
 fBranchPopAllowed(true), fConstExpression(true), fOperandInUse(false)
 {
@@ -151,7 +151,7 @@
     fActiveStream->write(&charOp, sizeof(charOp));
 }
 
-void SkScriptEngine2::addTokenConst(SkScriptValue2* value, AddTokenRegister reg, 
+void SkScriptEngine2::addTokenConst(SkScriptValue2* value, AddTokenRegister reg,
                                     SkOperand2::OpType toType, SkScriptEngine2::TypeOp op) {
     if (value->fIsConstant == SkScriptValue2::kConstant && convertTo(toType, value))
         return;
@@ -243,7 +243,7 @@
             if (nextChar == '>') {
                 op = kShiftRight;
                 goto twoChar;
-            } 
+            }
             op = kGreaterEqual;
             if (nextChar == '=')
                 goto twoChar;
@@ -272,7 +272,7 @@
 twoChar:
                     advance++;
                 break;
-            } 
+            }
             op = kLogicalNot;
             break;
         case '?':
@@ -316,7 +316,7 @@
         } while (true);
         signed char topPrecedence = gPrecedence[compare];
         SkASSERT(topPrecedence != -1);
-        if (topPrecedence > precedence || (topPrecedence == precedence && 
+        if (topPrecedence > precedence || (topPrecedence == precedence &&
             gOpAttributes[op].fLeftType == SkOperand2::kNoType)) {
             break;
         }
@@ -331,14 +331,14 @@
     return advance;
 }
 
-bool SkScriptEngine2::convertParams(SkTDArray<SkScriptValue2>* params, 
+bool SkScriptEngine2::convertParams(SkTDArray<SkScriptValue2>* params,
                                     const SkOperand2::OpType* paramTypes, int paramCount) {
     int count = params->count();
     if (count > paramCount) {
         SkASSERT(0);
         return false;    // too many parameters passed
     }
-    for (int index = 0; index < count; index++) 
+    for (int index = 0; index < count; index++)
         convertTo(paramTypes[index], &(*params)[index]);
     return true;
 }
@@ -355,7 +355,7 @@
     return ConvertTo(this, toType, value);
 }
 
-bool SkScriptEngine2::evaluateDot(const char*& script) { 
+bool SkScriptEngine2::evaluateDot(const char*& script) {
     size_t fieldLength = token_length(++script);        // skip dot
     SkASSERT(fieldLength > 0); // !!! add error handling
     const char* field = script;
@@ -370,14 +370,14 @@
         return false;
 }
 
-bool SkScriptEngine2::evaluateDotParam(const char*& script, const char* field, size_t fieldLength) { 
+bool SkScriptEngine2::evaluateDotParam(const char*& script, const char* field, size_t fieldLength) {
     SkScriptValue2& top = fValueStack.top();
     if (top.fType != SkOperand2::kObject)
         return false;
     void* object = top.fOperand.fObject;
     fValueStack.pop();
     char ch; // see if it is a simple member or a function
-    while (is_ws(ch = script[0])) 
+    while (is_ws(ch = script[0]))
         script++;
     bool success = true;
     if (ch != '(')
@@ -389,7 +389,7 @@
         if (success)
             success = handleMemberFunction(field, fieldLength, object, &params);
     }
-    return success; 
+    return success;
 }
 
 bool SkScriptEngine2::evaluateScript(const char** scriptPtr, SkScriptValue2* value) {
@@ -492,7 +492,7 @@
                 {
                     SkOperand2::OpType type = fReturnType;
                     if (fReturnType == SkOperand2::kNoType) {
-                        // !!! short sighted; in the future, allow each returned array component to carry 
+                        // !!! short sighted; in the future, allow each returned array component to carry
                         // its own type, and let caller do any needed conversions
                         if (value->fOperand.fArray->count() == 0)
                             value->fOperand.fArray->setType(type = tokenValue.fType);
@@ -513,7 +513,7 @@
             if (ch == '(') {
                 *fBraceStack.push() = kFunctionBrace;
                 SkString functionName(fToken, fTokenLength);
-                
+
                 if (handleFunction(&script) == false)
                     return false;
                 lastPush = true;
@@ -611,7 +611,7 @@
                 SkASSERT(fValueStack.count() > 0); // !!! add error handling
                 SkScriptValue2 top;
                 fValueStack.pop(&top);
-                
+
                 addTokenInt(top.fType);
                 addToken(kBoxToken);
                 top.fType = SkOperand2::kObject;
@@ -621,7 +621,7 @@
                 success = evaluateDotParam(script, token, tokenLength);
                 SkASSERT(success);
                 lastPush = true;
-                continue; 
+                continue;
             }
             // get next token, and evaluate immediately
             success = evaluateDot(script);
@@ -638,7 +638,7 @@
                 *fBraceStack.push() = kArrayBrace;
                 operand.fOperand.fArray = value->fOperand.fArray = new SkOpArray(fReturnType);
                 track(value->fOperand.fArray);
-                
+
                 operand.fType = SkOperand2::kArray;
                 operand.fIsConstant = SkScriptValue2::kVariable;
                 fValueStack.push(operand);
@@ -663,7 +663,7 @@
         }
 #endif
         if (ch == ')' && fBraceStack.count() > 0) {
-            BraceStyle braceStyle = fBraceStack.top(); 
+            BraceStyle braceStyle = fBraceStack.top();
             if (braceStyle == kFunctionBrace) {
                 fBraceStack.pop();
                 break;
@@ -681,7 +681,7 @@
         }
         char nextChar = script[1];
         int advance = logicalOp(ch, nextChar);
-        if (advance == 0) 
+        if (advance == 0)
             advance = arithmeticOp(ch, nextChar, lastPush);
         if (advance == 0) // unknown token
             return false;
@@ -760,7 +760,7 @@
         if (fValueStack.count() == 0)
             return false;
         fValueStack.pop(value);
-        if (value->fType != fReturnType && value->fType == SkOperand2::kObject && 
+        if (value->fType != fReturnType && value->fType == SkOperand2::kObject &&
             fReturnType != SkOperand2::kNoType)
             convertTo(fReturnType, value);
     }
@@ -850,7 +850,7 @@
         return success;
 }
 
-bool SkScriptEngine2::handleMemberFunction(const char* field, size_t len, void* object, 
+bool SkScriptEngine2::handleMemberFunction(const char* field, size_t len, void* object,
                                            SkTDArray<SkScriptValue2>* params) {
     bool success = true;
     for (SkScriptCallBack** callBack = fCallBackArray.begin(); callBack < fCallBackArray.end(); callBack++) {
@@ -980,13 +980,13 @@
         case kParen:
         case kArrayOp:
             SkASSERT(fOpStack.count() > 1 && fOpStack.top() == op);    // !!! add error handling
-            if (op == kParen) 
+            if (op == kParen)
                 fOpStack.pop();
             else {
                 SkScriptValue2 value;
                 fValueStack.pop(&value);
                 SkASSERT(value.fType == SkOperand2::kS32 || value.fType == SkOperand2::kScalar); // !!! add error handling (although, could permit strings eventually)
-                int index = value.fType == SkOperand2::kScalar ? SkScalarFloor(value.fOperand.fScalar) : 
+                int index = value.fType == SkOperand2::kScalar ? SkScalarFloor(value.fOperand.fScalar) :
                     value.fOperand.fS32;
                 SkScriptValue2 arrayValue;
                 fValueStack.pop(&arrayValue);
@@ -1046,7 +1046,7 @@
             // if 'or', write bne goto to bool
             addToken(op == kLogicalAnd ? kLogicalAndInt : kLogicalOrInt);
             Branch branch(op, fOpStack.count(), getTokenOffset());
-            addTokenInt(0); // placeholder for future branch            
+            addTokenInt(0); // placeholder for future branch
             oldTop.fPrimed = wasPrime;
             oldTop.fDone = wasDone;
             *fBranchStack.push() = branch;
@@ -1073,7 +1073,7 @@
     bool constantOperands = value2.fIsConstant == SkScriptValue2::kConstant;
     if (attributes->fLeftType != SkOperand2::kNoType) {
         fValueStack.pop(&value1);
-        constantOperands &= value1.fIsConstant == SkScriptValue2::kConstant; 
+        constantOperands &= value1.fIsConstant == SkScriptValue2::kConstant;
         value1.fIsWritten = SkScriptValue2::kUnwritten;
         if (op == kFlipOps) {
             SkTSwap(value1, value2);
@@ -1094,17 +1094,17 @@
     }
     if (attributes->fLeftType != SkOperand2::kNoType) {
         if (value1.fType != value2.fType) {
-            if ((attributes->fLeftType & SkOperand2::kString) && attributes->fBias & kTowardsString && 
+            if ((attributes->fLeftType & SkOperand2::kString) && attributes->fBias & kTowardsString &&
                 ((value1.fType | value2.fType) & SkOperand2::kString)) {
                 if (value1.fType == SkOperand2::kS32 || value1.fType == SkOperand2::kScalar) {
-                    addTokenConst(&value1, kAccumulator, SkOperand2::kString, 
+                    addTokenConst(&value1, kAccumulator, SkOperand2::kString,
                                   value1.fType == SkOperand2::kS32 ? kIntToString : kScalarToString);
                 }
                 if (value2.fType == SkOperand2::kS32 || value2.fType == SkOperand2::kScalar) {
-                    addTokenConst(&value2, kOperand, SkOperand2::kString, 
+                    addTokenConst(&value2, kOperand, SkOperand2::kString,
                                   value2.fType == SkOperand2::kS32 ? kIntToString2 : kScalarToString2);
                 }
-            } else if (attributes->fLeftType & SkOperand2::kScalar && ((value1.fType | value2.fType) & 
+            } else if (attributes->fLeftType & SkOperand2::kScalar && ((value1.fType | value2.fType) &
                                                                        SkOperand2::kScalar)) {
                 if (value1.fType == SkOperand2::kS32)
                     addTokenConst(&value1, kAccumulator, SkOperand2::kScalar, kIntToScalar);
@@ -1115,7 +1115,7 @@
         if ((value1.fType & attributes->fLeftType) == 0 || value1.fType != value2.fType) {
             if (value1.fType == SkOperand2::kString)
                 addTokenConst(&value1, kAccumulator, SkOperand2::kScalar, kStringToScalar);
-            if (value1.fType == SkOperand2::kScalar && (attributes->fLeftType == SkOperand2::kS32 || 
+            if (value1.fType == SkOperand2::kScalar && (attributes->fLeftType == SkOperand2::kS32 ||
                                                         value2.fType == SkOperand2::kS32))
                 addTokenConst(&value1, kAccumulator, SkOperand2::kS32, kScalarToInt);
         }
@@ -1125,7 +1125,7 @@
     if ((value2.fType & attributes->fRightType) == 0 || value1.fType != value2.fType) {
         if (value2.fType == SkOperand2::kString)
             addTokenConst(&value2, rhRegister, SkOperand2::kScalar, kStringToScalar2);
-        if (value2.fType == SkOperand2::kScalar && (attributes->fRightType == SkOperand2::kS32 || 
+        if (value2.fType == SkOperand2::kScalar && (attributes->fRightType == SkOperand2::kS32 ||
                                                     value1.fType == SkOperand2::kS32))
             addTokenConst(&value2, rhRegister, SkOperand2::kS32, kScalarToInt2);
     }
@@ -1154,7 +1154,7 @@
     if (constantOperands) {
         addToken(kEnd);
         SkAutoDataUnref data(fStream.copyToData());
-#ifdef SK_DEBUG        
+#ifdef SK_DEBUG
         decompile(data->bytes(), data->size());
 #endif
         SkScriptRuntime runtime(fCallBackArray);
@@ -1195,7 +1195,7 @@
 bool SkScriptEngine2::ConvertTo(SkScriptEngine2* engine, SkOperand2::OpType toType, SkScriptValue2* value ) {
     SkASSERT(value);
     SkOperand2::OpType type = value->fType;
-    if (type == toType) 
+    if (type == toType)
         return true;
     SkOperand2& operand = value->fOperand;
     bool success = true;
@@ -1288,18 +1288,18 @@
 static const SkScriptNAnswer2 scriptTests[]  = {
     testInt(1||(0&&3)),
     testScalar(- -5.5- -1.5),
-    testScalar(1.0+5), 
+    testScalar(1.0+5),
     testInt((6+7)*8),
     testInt(3*(4+5)),
     testScalar(1.0+2.0),
-    testScalar(3.0-1.0), 
-    testScalar(6-1.0), 
-    testScalar(2.5*6.), 
-    testScalar(0.5*4), 
-    testScalar(4.5/.5), 
-    testScalar(9.5/19), 
-    testRemainder(9.5, 0.5), 
-    testRemainder(9.,2), 
+    testScalar(3.0-1.0),
+    testScalar(6-1.0),
+    testScalar(2.5*6.),
+    testScalar(0.5*4),
+    testScalar(4.5/.5),
+    testScalar(9.5/19),
+    testRemainder(9.5, 0.5),
+    testRemainder(9.,2),
     testRemainder(9,2.5),
     testRemainder(-9,2.5),
     testTrue(-9==-9.0),
diff --git a/src/animator/SkTDArray_Experimental.h b/src/animator/SkTDArray_Experimental.h
index e598a6d..094d106 100644
--- a/src/animator/SkTDArray_Experimental.h
+++ b/src/animator/SkTDArray_Experimental.h
@@ -38,9 +38,9 @@
     int32_t* append() { return this->append(1, NULL); }
     int32_t* append(U16CPU count, const int32_t* src = NULL);
 
-    int32_t* appendClear() 
-    { 
-        int32_t* result = this->append(); 
+    int32_t* appendClear()
+    {
+        int32_t* result = this->append();
         *result = 0;
         return result;
     }
@@ -108,9 +108,9 @@
     SkTDS32Array(const SkTDS32Array<T>& src) : SkDS32Array(src) {}
     ~SkTDS32Array() { sk_free(fArray); }
     T&  operator[](int index) const { SYNC(); SkASSERT((unsigned)index < fCount); return ((T*) fArray)[index]; }
-    SkTDS32Array<T>& operator=(const SkTDS32Array<T>& src) { 
+    SkTDS32Array<T>& operator=(const SkTDS32Array<T>& src) {
         return (SkTDS32Array<T>&) SkDS32Array::operator=(src); }
-    friend int operator==(const SkTDS32Array<T>& a, const SkTDS32Array<T>& b) { 
+    friend int operator==(const SkTDS32Array<T>& a, const SkTDS32Array<T>& b) {
         return operator==((const SkDS32Array&) a, (const SkDS32Array&) b); }
     T* append() { return (T*) SkDS32Array::append(); }
     T* appendClear() { return (T*) SkDS32Array::appendClear(); }
diff --git a/src/animator/SkTextOnPath.cpp b/src/animator/SkTextOnPath.cpp
index e7f7651..7bdb7fd 100644
--- a/src/animator/SkTextOnPath.cpp
+++ b/src/animator/SkTextOnPath.cpp
@@ -33,7 +33,7 @@
     SkASSERT(text);
     SkASSERT(path);
     SkBoundableAuto boundable(this, maker);
-    maker.fCanvas->drawTextOnPathHV(text->getText(), text->getSize(), 
+    maker.fCanvas->drawTextOnPathHV(text->getText(), text->getSize(),
                                     path->getPath(), offset, 0, *maker.fPaint);
     return false;
 }
diff --git a/src/animator/SkTextToPath.cpp b/src/animator/SkTextToPath.cpp
index cf78ff5..b38daff 100644
--- a/src/animator/SkTextToPath.cpp
+++ b/src/animator/SkTextToPath.cpp
@@ -42,7 +42,7 @@
     }
     SkPaint realPaint;
     paint->setupPaint(&realPaint);
-    realPaint.getTextPath(text->getText(), text->getSize(), text->x, 
+    realPaint.getTextPath(text->getText(), text->getSize(), text->x,
         text->y, &path->getPath());
 }
 
diff --git a/src/animator/SkTime.cpp b/src/animator/SkTime.cpp
index 35c7eb8..06ad9bd 100644
--- a/src/animator/SkTime.cpp
+++ b/src/animator/SkTime.cpp
@@ -51,7 +51,7 @@
     {
         tm      syst;
         time_t  tm;
-        
+
         time(&tm);
         localtime_r(&tm, &syst);
         t->fYear        = SkToU16(syst.tm_year);
diff --git a/src/animator/SkTypedArray.h b/src/animator/SkTypedArray.h
index 222c8df..e93b106 100644
--- a/src/animator/SkTypedArray.h
+++ b/src/animator/SkTypedArray.h
@@ -20,7 +20,7 @@
     bool getIndex(int index, SkOperand* operand);
     SkDisplayTypes getType() { return fType; }
     SkScriptEngine::SkOpType getOpType() { return SkScriptEngine::ToOpType(fType); }
-    void setType(SkDisplayTypes type) { 
+    void setType(SkDisplayTypes type) {
     //  SkASSERT(count() == 0);
         fType = type;
     }
diff --git a/src/gpu/GrAAHairLinePathRenderer.h b/src/gpu/GrAAHairLinePathRenderer.h
index cf8b8d3..c04d062 100644
--- a/src/gpu/GrAAHairLinePathRenderer.h
+++ b/src/gpu/GrAAHairLinePathRenderer.h
@@ -28,7 +28,7 @@
                             const GrVec* translate,
                             GrDrawTarget* target,
                             bool antiAlias) SK_OVERRIDE;
- 
+
 private:
 
     GrAAHairLinePathRenderer(const GrContext* context,
diff --git a/src/gpu/GrAARectRenderer.cpp b/src/gpu/GrAARectRenderer.cpp
index 652adcb..36f37ab 100644
--- a/src/gpu/GrAARectRenderer.cpp
+++ b/src/gpu/GrAARectRenderer.cpp
@@ -88,7 +88,7 @@
 
 GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(GrGpu* gpu) {
     if (NULL == fAAStrokeRectIndexBuffer) {
-        fAAStrokeRectIndexBuffer = 
+        fAAStrokeRectIndexBuffer =
                   gpu->createIndexBuffer(sizeof(gStrokeAARectIdx), false);
         if (NULL != fAAStrokeRectIndexBuffer) {
 #if GR_DEBUG
diff --git a/src/gpu/GrAllocator.h b/src/gpu/GrAllocator.h
index ae456cd..dc4c3de 100755
--- a/src/gpu/GrAllocator.h
+++ b/src/gpu/GrAllocator.h
@@ -55,8 +55,8 @@
             } else if (fOwnFirstBlock) {
                 fBlocks[0] = GrMalloc(fBlockSize);
             }
-        }        
-        void* ret = (char*)fBlocks[fCount/fItemsPerBlock] + 
+        }
+        void* ret = (char*)fBlocks[fCount/fItemsPerBlock] +
                     fItemSize * indexInBlock;
         ++fCount;
         return ret;
@@ -65,8 +65,8 @@
     /**
      * removes all added items
      */
-    void reset() {        
-        int blockCount = GrMax((unsigned)1, 
+    void reset() {
+        int blockCount = GrMax((unsigned)1,
                                GrUIDivRoundUp(fCount, fItemsPerBlock));
         for (int i = 1; i < blockCount; ++i) {
             GrFree(fBlocks[i]);
@@ -85,12 +85,12 @@
     int count() const {
         return fCount;
     }
-    
+
     /**
      * is the count 0
      */
     bool empty() const { return fCount == 0; }
-    
+
     /**
      * access last item, only call if count() != 0
      */
@@ -98,7 +98,7 @@
         GrAssert(fCount);
         return (*this)[fCount-1];
     }
-    
+
     /**
      * access last item, only call if count() != 0
      */
@@ -106,28 +106,28 @@
         GrAssert(fCount);
         return (*this)[fCount-1];
     }
-    
+
     /**
      * access item by index.
-     */    
+     */
     void* operator[] (int i) {
         GrAssert(i >= 0 && i < fCount);
-        return (char*)fBlocks[i / fItemsPerBlock] + 
+        return (char*)fBlocks[i / fItemsPerBlock] +
                fItemSize * (i % fItemsPerBlock);
     }
 
     /**
      * access item by index.
-     */  
+     */
     const void* operator[] (int i) const {
         GrAssert(i >= 0 && i < fCount);
-        return (const char*)fBlocks[i / fItemsPerBlock] + 
+        return (const char*)fBlocks[i / fItemsPerBlock] +
                fItemSize * (i % fItemsPerBlock);
     }
 
 private:
     static const int NUM_INIT_BLOCK_PTRS = 8;
-    
+
     SkSTArray<NUM_INIT_BLOCK_PTRS, void*>   fBlocks;
     size_t                                  fBlockSize;
     size_t                                  fItemSize;
@@ -184,19 +184,19 @@
         }
         fAllocator.reset();
     }
-    
+
     /**
      * count of items
      */
     int count() const {
         return fAllocator.count();
     }
-    
+
     /**
      * is the count 0
      */
     bool empty() const { return fAllocator.empty(); }
-    
+
     /**
      * access last item, only call if count() != 0
      */
@@ -213,11 +213,11 @@
 
     /**
      * access item by index.
-     */  
+     */
     T& operator[] (int i) {
         return *(T*)(fAllocator[i]);
     }
-    
+
     /**
      * access item by index.
      */
diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h
index 1187a08..fe56ded 100644
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipMaskManager.h
@@ -216,7 +216,7 @@
         }
 
         void acquireMask(GrContext* context,
-                         const SkClipStack& clip, 
+                         const SkClipStack& clip,
                          const GrTextureDesc& desc,
                          const GrIRect& bound) {
 
@@ -237,11 +237,11 @@
         }
 
         SkClipStack             fLastClip;
-        // The mask's width & height values are used in setupDrawStateAAClip to 
+        // The mask's width & height values are used in setupDrawStateAAClip to
         // correctly scale the uvs for geometry drawn with this mask
         GrAutoScratchTexture    fLastMask;
-        // fLastBound stores the bounding box of the clip mask in canvas 
-        // space. The left and top fields are used to offset the uvs for 
+        // fLastBound stores the bounding box of the clip mask in canvas
+        // space. The left and top fields are used to offset the uvs for
         // geometry drawn with this mask (in setupDrawStateAAClip)
         GrIRect                 fLastBound;
     };
@@ -253,9 +253,9 @@
 };
 
 /**
- * The clip mask creator handles the generation of the clip mask. If anti 
- * aliasing is requested it will (in the future) generate a single channel 
- * (8bit) mask. If no anti aliasing is requested it will generate a 1-bit 
+ * The clip mask creator handles the generation of the clip mask. If anti
+ * aliasing is requested it will (in the future) generate a single channel
+ * (8bit) mask. If no anti aliasing is requested it will generate a 1-bit
  * mask in the stencil buffer. In the non anti-aliasing case, if the clip
  * mask can be represented as a rectangle then scissoring is used. In all
  * cases scissoring is used to bound the range of the clip mask.
@@ -299,7 +299,7 @@
         return fAACache.getContext();
     }
 
-    void setGpu(GrGpu* gpu) { 
+    void setGpu(GrGpu* gpu) {
         fGpu = gpu;
     }
 
@@ -330,7 +330,7 @@
         kStencil_ClipMaskType,
         kAlpha_ClipMaskType,
     } fCurrClipMaskType;
-    
+
     GrClipMaskCache fAACache;       // cache for the AA path
 
     bool createStencilClipMask(const GrClipData& clipDataIn,
@@ -356,7 +356,7 @@
 
     void getTemp(const GrIRect& bounds, GrAutoScratchTexture* temp);
 
-    void setupCache(const SkClipStack& clip, 
+    void setupCache(const SkClipStack& clip,
                     const GrIRect& bounds);
 
     /**
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index cc68aed..1db2e4a 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -24,7 +24,7 @@
 class GrDrawState : public GrRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
-    
+
     /**
      * Number of texture stages. Each stage takes as input a color and
      * 2D texture coordinates. The color input to the first enabled stage is the
@@ -40,8 +40,8 @@
      * or not.
      *
      * Stages 0 through GrPaint::kTotalStages-1 are reserved for setting up
-     * the draw (i.e., textures and filter masks). Stages GrPaint::kTotalStages 
-     * through kNumStages-1 are earmarked for use by GrTextContext and 
+     * the draw (i.e., textures and filter masks). Stages GrPaint::kTotalStages
+     * through kNumStages-1 are earmarked for use by GrTextContext and
      * GrPathRenderer-derived classes.
      */
     enum {
@@ -49,13 +49,13 @@
         kMaxTexCoords = kNumStages
     };
 
-    GrDrawState() 
+    GrDrawState()
         : fRenderTarget(NULL) {
 
         this->reset();
     }
 
-    GrDrawState(const GrDrawState& state) 
+    GrDrawState(const GrDrawState& state)
         : fRenderTarget(NULL) {
 
         *this = state;
@@ -70,7 +70,7 @@
      * Resets to the default state.
      * Sampler states *will* be modified: textures or CustomStage objects
      * will be released.
-     */ 
+     */
     void reset() {
 
         this->disableStages();
@@ -147,7 +147,7 @@
     ////
 
     /**
-     * Sets a constant fractional coverage to be applied to the draw. The 
+     * Sets a constant fractional coverage to be applied to the draw. The
      * initial value (after construction or reset()) is 0xff. The constant
      * coverage is ignored when per-vertex coverage is provided.
      */
@@ -280,22 +280,22 @@
     /**
      * A common pattern is to compute a color with the initial stages and then
      * modulate that color by a coverage value in later stage(s) (AA, mask-
-     * filters, glyph mask, etc). Color-filters, xfermodes, etc should be 
-     * computed based on the pre-coverage-modulated color. The division of 
-     * stages between color-computing and coverage-computing is specified by 
+     * filters, glyph mask, etc). Color-filters, xfermodes, etc should be
+     * computed based on the pre-coverage-modulated color. The division of
+     * stages between color-computing and coverage-computing is specified by
      * this method. Initially this is kNumStages (all stages
      * are color-computing).
      */
     void setFirstCoverageStage(int firstCoverageStage) {
         GrAssert((unsigned)firstCoverageStage <= kNumStages);
-        fFirstCoverageStage = firstCoverageStage; 
+        fFirstCoverageStage = firstCoverageStage;
     }
 
     /**
      * Gets the index of the first coverage-computing stage.
      */
     int getFirstCoverageStage() const {
-        return fFirstCoverageStage; 
+        return fFirstCoverageStage;
     }
 
     ///@}
@@ -495,7 +495,7 @@
      *
      * @param target  The render target to set.
      */
-    void setRenderTarget(GrRenderTarget* target) { 
+    void setRenderTarget(GrRenderTarget* target) {
         GrSafeAssign(fRenderTarget, target);
     }
 
@@ -607,7 +607,7 @@
         /* 1-pixel wide line
            2D implicit line eq (a*x + b*y +c = 0). 4th component unused */
         kHairLine_EdgeType,
-        /* Quadratic specified by u^2-v canonical coords (only 2 
+        /* Quadratic specified by u^2-v canonical coords (only 2
            components used). Coverage based on signed distance with negative
            being inside, positive outside. Edge specified in window space
            (y-down) */
@@ -623,7 +623,7 @@
     };
 
     /**
-     * Determines the interpretation per-vertex edge data when the 
+     * Determines the interpretation per-vertex edge data when the
      * kEdge_VertexLayoutBit is set (see GrDrawTarget). When per-vertex edges
      * are not specified the value of this setting has no effect.
      */
@@ -753,7 +753,7 @@
      * @return the current draw face(s).
      */
     DrawFace getDrawFace() const { return fDrawFace; }
-    
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
@@ -795,7 +795,7 @@
     }
     bool operator !=(const GrDrawState& s) const { return !(*this == s); }
 
-    // Most stages are usually not used, so conditionals here 
+    // Most stages are usually not used, so conditionals here
     // reduce the expected number of bytes touched by 50%.
     GrDrawState& operator =(const GrDrawState& s) {
         memcpy(this->podStart(), s.podStart(), this->podSize());
@@ -843,7 +843,7 @@
         GrColor             fPodStartMarker;
     };
     GrColor             fColorFilterColor;
-    DrawFace            fDrawFace; 
+    DrawFace            fDrawFace;
     VertexEdgeType      fVertexEdgeType;
     GrStencilSettings   fStencilSettings;
     union {
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index 5b90480..a567699 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -26,7 +26,7 @@
  * generate the new masks. (We attempted to force the compiler to generate the
  * masks using recursive templates but always wound up with static initializers
  * under gcc, even if they were just a series of immediate->memory moves.)
- * 
+ *
  */
 void gen_mask_arrays(GrVertexLayout* stageTexCoordMasks,
                      GrVertexLayout* texCoordMasks) {
@@ -44,14 +44,14 @@
     }
 }
 
-/** 
+/**
  * Run this function to generate the code that declares the global masks.
  */
 void gen_globals() {
     GrVertexLayout stageTexCoordMasks[GrDrawState::kNumStages];
     GrVertexLayout texCoordMasks[GrDrawState::kMaxTexCoords];
     gen_mask_arrays(stageTexCoordMasks, texCoordMasks);
-    
+
     GrPrintf("const GrVertexLayout gStageTexCoordMasks[] = {\n");
     for (int s = 0; s < GrDrawState::kNumStages; ++s) {
         GrPrintf("    0x%x,\n", stageTexCoordMasks[s]);
@@ -136,7 +136,7 @@
 /**
  * Functions for computing offsets of various components from the layout
  * bitfield.
- * 
+ *
  * Order of vertex components:
  * Position
  * Tex Coord 0
@@ -529,7 +529,7 @@
         GrAssert(NULL != indices);
         this->releasePreviousIndexSource();
         geoSrc.fIndexSrc = kNone_GeometrySrcType;
-        
+
         acquired = this->onReserveIndexSpace(indexCount, indices);
     }
     if (acquired) {
@@ -539,7 +539,7 @@
         *indices = NULL;
     }
     return acquired;
-    
+
 }
 
 bool GrDrawTarget::StageUsesTexCoords(GrVertexLayout layout, int stage) {
@@ -695,7 +695,7 @@
 void GrDrawTarget::popGeometrySource() {
     // if popping last element then pops are unbalanced with pushes
     GrAssert(fGeoSrcStateStack.count() > 1);
-    
+
     this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
     this->releasePreviousVertexSource();
     this->releasePreviousIndexSource();
@@ -902,7 +902,7 @@
     // stenciling is enabled. Having color writes disabled is effectively
     // (0,1). The same applies when coverage is known to be 0.
     if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne) ||
-        (!(layout & kCoverage_VertexLayoutBit) && 
+        (!(layout & kCoverage_VertexLayoutBit) &&
          0 == drawState.getCoverage())) {
         if (drawState.getStencil().doesWrite()) {
             return kDisableBlend_BlendOptFlag |
@@ -915,7 +915,7 @@
     // check for coverage due to constant coverage, per-vertex coverage,
     // edge aa or coverage texture stage
     bool hasCoverage = forceCoverage ||
-                       0xffffffff != drawState.getCoverage() || 
+                       0xffffffff != drawState.getCoverage() ||
                        (layout & kCoverage_VertexLayoutBit) ||
                        (layout & kEdge_VertexLayoutBit);
     for (int s = drawState.getFirstCoverageStage();
@@ -959,7 +959,7 @@
             } else if (srcAIsOne) {
                 // the dst coeff is effectively zero so blend works out to:
                 // cS + (c)(0)D + (1-c)D = cS + (1-c)D.
-                // If Sa is 1 then we can replace Sa with c 
+                // If Sa is 1 then we can replace Sa with c
                 // and set dst coeff to 1-Sa.
                 *dstCoeff = kISA_GrBlendCoeff;
                 return  kCoverageAsAlpha_BlendOptFlag;
@@ -1026,7 +1026,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrDrawTarget::drawRect(const GrRect& rect, 
+void GrDrawTarget::drawRect(const GrRect& rect,
                             const GrMatrix* matrix,
                             const GrRect* srcRects[],
                             const GrMatrix* srcMatrices[]) {
@@ -1038,7 +1038,7 @@
         return;
     }
 
-    SetRectVertices(rect, matrix, srcRects, 
+    SetRectVertices(rect, matrix, srcRects,
                     srcMatrices, layout, geo.vertices());
 
     drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
@@ -1061,10 +1061,10 @@
 }
 
 void GrDrawTarget::SetRectVertices(const GrRect& rect,
-                                   const GrMatrix* matrix, 
-                                   const GrRect* srcRects[], 
+                                   const GrMatrix* matrix,
+                                   const GrRect* srcRects[],
                                    const GrMatrix* srcMatrices[],
-                                   GrVertexLayout layout, 
+                                   GrVertexLayout layout,
                                    void* vertices) {
 #if GR_DEBUG
     // check that the layout and srcRects agree
@@ -1189,7 +1189,7 @@
     fTarget = NULL;
     this->set(target, vertexLayout, vertexCount, indexCount);
 }
-    
+
 GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry() {
     fTarget = NULL;
 }
diff --git a/src/gpu/GrDrawTarget.h b/src/gpu/GrDrawTarget.h
index 030b092..5f241a6 100644
--- a/src/gpu/GrDrawTarget.h
+++ b/src/gpu/GrDrawTarget.h
@@ -114,7 +114,7 @@
      *    1. The caller intends to somehow specify coverage. This can be
      *       specified either by enabling a coverage stage on the GrDrawState or
      *       via the vertex layout.
-     *    2. Other than enabling coverage stages, the current configuration of 
+     *    2. Other than enabling coverage stages, the current configuration of
      *       the target's GrDrawState is as it will be at draw time.
      *    3. If a vertex source has not yet been specified then all stages with
      *       non-NULL textures will be referenced by the vertex layout.
@@ -131,7 +131,7 @@
     bool canTweakAlphaForCoverage() const;
 
     /**
-     * Given the current draw state and hw support, will HW AA lines be used 
+     * Given the current draw state and hw support, will HW AA lines be used
      * (if line primitive type is drawn)? If a vertex source has not yet been
      * specified then  the function assumes that all stages with non-NULL
      * textures will be referenced by the vertex layout.
@@ -143,7 +143,7 @@
      * Flags that indicate the layout of vertex data. Vertices always contain
      * positions and may also contain up to GrDrawState::kMaxTexCoords sets
      * of 2D texture coordinates, per-vertex colors, and per-vertex coverage.
-     * Each stage can 
+     * Each stage can
      * use any of the texture coordinates as its input texture coordinates or it
      * may use the positions as texture coordinates.
      *
@@ -154,8 +154,8 @@
      * example StageTexCoordVertexLayoutBit(0, 2) and
      * StagePosAsTexCoordVertexLayoutBit(0) cannot both be specified.
      *
-     * The order in memory is always (position, texture coord 0, ..., color, 
-     * coverage) with any unused fields omitted. Note that this means that if 
+     * The order in memory is always (position, texture coord 0, ..., color,
+     * coverage) with any unused fields omitted. Note that this means that if
      * only texture coordinates 1 is referenced then there is no texture
      * coordinates 0 and the order would be (position, texture coordinate 1
      * [, color][, coverage]).
@@ -238,7 +238,7 @@
      *    that the draw target make room for some amount of vertex and/or index
      *    data. The target provides ptrs to hold the vertex and/or index data.
      *
-     *    The data is writable up until the next drawIndexed, drawNonIndexed, 
+     *    The data is writable up until the next drawIndexed, drawNonIndexed,
      *    drawIndexedInstances, or pushGeometrySource. At this point the data is
      *    frozen and the ptrs are no longer valid.
      *
@@ -247,7 +247,7 @@
      *
      * 3. Vertex and Index Buffers. This is most useful for geometry that will
      *    is long-lived. When the data in the buffer is consumed depends on the
-     *    GrDrawTarget subclass. For deferred subclasses the caller has to 
+     *    GrDrawTarget subclass. For deferred subclasses the caller has to
      *    guarantee that the data is still available in the buffers at playback.
      *    (TODO: Make this more automatic as we have done for read/write pixels)
      */
@@ -255,7 +255,7 @@
     /**
      * Reserves space for vertices and/or indices. Zero can be specifed as
      * either the vertex or index count if the caller desires to only reserve
-     * space for only indices or only vertices. If zero is specifed for 
+     * space for only indices or only vertices. If zero is specifed for
      * vertexCount then the vertex source will be unmodified and likewise for
      * indexCount.
      *
@@ -276,7 +276,7 @@
      *                     0.
      * @param indexCount   the number of indices to reserve space for. Can be 0.
      * @param vertices     will point to reserved vertex space if vertexCount is
-     *                     non-zero. Illegal to pass NULL if vertexCount > 0.    
+     *                     non-zero. Illegal to pass NULL if vertexCount > 0.
      * @param indices      will point to reserved index space if indexCount is
      *                     non-zero. Illegal to pass NULL if indexCount > 0.
      */
@@ -352,7 +352,7 @@
      *               before indexed draw call.
      */
     void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
-    
+
     /**
      * Resets vertex source. Drawing from reset vertices is illegal. Set vertex
      * source to reserved, array, or buffer before next draw. May be able to free
@@ -360,7 +360,7 @@
      * reserveVertexSpace.
      */
     void resetVertexSource();
-    
+
     /**
      * Resets index source. Indexed Drawing from reset indices is illegal. Set
      * index source to reserved, array, or buffer before next indexed draw. May
@@ -368,7 +368,7 @@
      * or reserveIndexSpace.
      */
     void resetIndexSource();
-    
+
     /**
      * Query to find out if the vertex or index source is reserved.
      */
@@ -497,11 +497,11 @@
     }
 
     /**
-     * Clear the current render target if one isn't passed in. Ignores the 
-     * clip and all other draw state (blend mode, stages, etc). Clears the 
+     * Clear the current render target if one isn't passed in. Ignores the
+     * clip and all other draw state (blend mode, stages, etc). Clears the
      * whole thing if rect is NULL, otherwise just the rect.
      */
-    virtual void clear(const GrIRect* rect, 
+    virtual void clear(const GrIRect* rect,
                        GrColor color,
                        GrRenderTarget* renderTarget = NULL) = 0;
 
@@ -534,7 +534,7 @@
      *                             // Therefore, rt is set on the GrDrawState
      *                             // that will be restored after asr's
      *                             // destructor rather than target's current
-     *                             // GrDrawState. 
+     *                             // GrDrawState.
      */
     class AutoStateRestore : ::GrNoncopyable {
     public:
@@ -573,7 +573,7 @@
 
     ////////////////////////////////////////////////////////////////////////////
 
-    /** 
+    /**
      * Sets the view matrix to I and preconcats all stage matrices enabled in
      * mask by the view inverse. Destructor undoes these changes.
      */
@@ -622,7 +622,7 @@
 
     private:
         void reset();
-        
+
         GrDrawTarget* fTarget;
         void*         fVertices;
         void*         fIndices;
@@ -644,9 +644,9 @@
         GrDrawTarget*      fTarget;
         const GrClipData*  fClip;
     };
-    
+
     ////////////////////////////////////////////////////////////////////////////
-    
+
     class AutoGeometryPush : ::GrNoncopyable {
     public:
         AutoGeometryPush(GrDrawTarget* target) {
@@ -906,7 +906,7 @@
         kArray_GeometrySrcType,    //<! src was set using set*SourceToArray
         kBuffer_GeometrySrcType    //<! src was set using set*SourceToBuffer
     };
-    
+
     struct GeometrySrcState {
         GeometrySrcType         fVertexSrc;
         union {
@@ -915,7 +915,7 @@
             // valid if src type is reserved or array
             int                     fVertexCount;
         };
-        
+
         GeometrySrcType         fIndexSrc;
         union {
             // valid if src type is buffer
@@ -923,7 +923,7 @@
             // valid if src type is reserved or array
             int                     fIndexCount;
         };
-        
+
         GrVertexLayout          fVertexLayout;
     };
 
@@ -952,7 +952,7 @@
     virtual void willReserveVertexAndIndexSpace(GrVertexLayout vertexLayout,
                                                 int vertexCount,
                                                 int indexCount) {}
-    
+
 
     // implemented by subclass to allocate space for reserved geom
     virtual bool onReserveVertexSpace(GrVertexLayout vertexLayout,
@@ -1021,7 +1021,7 @@
     Caps fCaps;
 
     // subclasses must call this in their destructors to ensure all vertex
-    // and index sources have been released (including those held by 
+    // and index sources have been released (including those held by
     // pushGeometrySource())
     void releaseGeometry();
 
@@ -1031,7 +1031,7 @@
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
-    
+
     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
     // indicate non-indexed drawing.
     bool checkDraw(GrPrimitiveType type, int startVertex,
@@ -1040,11 +1040,11 @@
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
     void releasePreviousIndexSource();
-    
+
     enum {
         kPreallocGeoSrcStateStackCnt = 4,
     };
-    SkSTArray<kPreallocGeoSrcStateStackCnt, 
+    SkSTArray<kPreallocGeoSrcStateStackCnt,
               GeometrySrcState, true>           fGeoSrcStateStack;
 
     typedef GrRefCnt INHERITED;
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index 923f711..f38b819 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -147,7 +147,7 @@
                                 const void* srcData, size_t rowBytes) {
     this->handleDirtyContext();
     GrTexture* tex = this->onCreateTexture(desc, srcData, rowBytes);
-    if (NULL != tex && 
+    if (NULL != tex &&
         (kRenderTarget_GrTextureFlagBit & desc.fFlags) &&
         !(kNoStencil_GrTextureFlagBit & desc.fFlags)) {
         GrAssert(NULL != tex->asRenderTarget());
@@ -162,7 +162,7 @@
 
 bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) {
     GrAssert(NULL == rt->getStencilBuffer());
-    GrStencilBuffer* sb = 
+    GrStencilBuffer* sb =
         this->getContext()->findStencilBuffer(rt->width(),
                                               rt->height(),
                                               rt->numSamples());
@@ -233,11 +233,11 @@
     return this->onCreatePath(path);
 }
 
-void GrGpu::clear(const GrIRect* rect, 
-                  GrColor color, 
+void GrGpu::clear(const GrIRect* rect,
+                  GrColor color,
                   GrRenderTarget* renderTarget) {
     GrRenderTarget* oldRT = NULL;
-    if (NULL != renderTarget && 
+    if (NULL != renderTarget &&
         renderTarget != this->drawState()->getRenderTarget()) {
         oldRT = this->drawState()->getRenderTarget();
         this->drawState()->setRenderTarget(renderTarget);
@@ -489,12 +489,12 @@
                                  int vertexCount,
                                  void** vertices) {
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
-    
+
     GrAssert(vertexCount > 0);
     GrAssert(NULL != vertices);
-    
+
     this->prepareVertexPool();
-    
+
     *vertices = fVertexPool->makeSpace(vertexLayout,
                                        vertexCount,
                                        &geomPoolState.fPoolVertexBuffer,
@@ -508,7 +508,7 @@
 
 bool GrGpu::onReserveIndexSpace(int indexCount, void** indices) {
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
-    
+
     GrAssert(indexCount > 0);
     GrAssert(NULL != indices);
 
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index f502dba2..d700de5 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -57,7 +57,7 @@
 
     // The GrContext sets itself as the owner of this Gpu object
     void setContext(GrContext* context) {
-        GrAssert(NULL == fContext); 
+        GrAssert(NULL == fContext);
         fContext = context;
         fClipMaskManager.setContext(context);
     }
@@ -197,7 +197,7 @@
      * However, the caller (GrContext) may have transformations to apply and can
      * simply fold in the y-flip for free. On the other hand, the subclass may
      * be able to do it for free itself. For example, the subclass may have to
-     * do memcpys to handle rowBytes that aren't tight. It could do the y-flip 
+     * do memcpys to handle rowBytes that aren't tight. It could do the y-flip
      * concurrently.
      *
      * This function returns true if a y-flip is required to put the pixels in
@@ -290,7 +290,7 @@
     void removeResource(GrResource* resource);
 
     // GrDrawTarget overrides
-    virtual void clear(const GrIRect* rect, 
+    virtual void clear(const GrIRect* rect,
                        GrColor color,
                        GrRenderTarget* renderTarget = NULL) SK_OVERRIDE;
 
@@ -321,7 +321,7 @@
      * Can the provided configuration act as a color render target?
      */
     bool isConfigRenderable(GrPixelConfig config) const {
-        GrAssert(kGrPixelConfigCount > config); 
+        GrAssert(kGrPixelConfigCount > config);
         return fConfigRenderSupport[config];
     }
 
@@ -406,12 +406,12 @@
     struct GeometryPoolState {
         const GrVertexBuffer* fPoolVertexBuffer;
         int                   fPoolStartVertex;
-        
+
         const GrIndexBuffer*  fPoolIndexBuffer;
         int                   fPoolStartIndex;
     };
-    const GeometryPoolState& getGeomPoolState() { 
-        return fGeomPoolStateStack.back(); 
+    const GeometryPoolState& getGeomPoolState() {
+        return fGeomPoolStateStack.back();
     }
 
     // The state of the scissor is controlled by the clip manager
@@ -453,7 +453,7 @@
     // assumed 3D context state and dirty any state cache.
     virtual void onResetContext() = 0;
 
-    
+
     // overridden by API-specific derived class to create objects.
     virtual GrTexture* onCreateTexture(const GrTextureDesc& desc,
                                        const void* srcData,
@@ -466,7 +466,7 @@
                                                bool dynamic) = 0;
     virtual GrPath* onCreatePath(const SkPath& path) = 0;
 
-    // overridden by API-specific derivated class to perform the clear and 
+    // overridden by API-specific derivated class to perform the clear and
     // clearRect. NULL rect means clear whole target.
     virtual void onClear(const GrIRect* rect, GrColor color) = 0;
 
@@ -522,7 +522,7 @@
     // Should attach the SB to the RT. Returns false if compatible sb could
     // not be created.
     virtual bool createStencilBufferForRenderTarget(GrRenderTarget* rt,
-                                                    int width, 
+                                                    int width,
                                                     int height) = 0;
 
     // attaches an existing SB to an existing RT.
@@ -540,23 +540,23 @@
 
 private:
     GrContext*                  fContext; // not reffed (context refs gpu)
-    
+
     ResetTimestamp              fResetTimestamp;
 
     GrVertexBufferAllocPool*    fVertexPool;
 
     GrIndexBufferAllocPool*     fIndexPool;
-    
+
     // counts number of uses of vertex/index pool in the geometry stack
     int                         fVertexPoolUseCnt;
     int                         fIndexPoolUseCnt;
-    
+
     enum {
         kPreallocGeomPoolStateStackCnt = 4,
     };
     SkSTArray<kPreallocGeomPoolStateStackCnt,
               GeometryPoolState, true>              fGeomPoolStateStack;
-    
+
     mutable GrIndexBuffer*      fQuadIndexBuffer; // mutable so it can be
                                                   // created on-demand
 
diff --git a/src/gpu/GrGpuVertex.h b/src/gpu/GrGpuVertex.h
index d093e2d..570a77c 100644
--- a/src/gpu/GrGpuVertex.h
+++ b/src/gpu/GrGpuVertex.h
@@ -15,7 +15,7 @@
 #include "GrPoint.h"
 
 #if GR_TEXT_SCALAR_IS_USHORT
-    typedef uint16_t                GrTextScalar;  
+    typedef uint16_t                GrTextScalar;
     #define GrIntToTextScalar(x)    ((uint16_t)x)
     #define GrFixedToTextScalar(x)  (x)
 #elif GR_TEXT_SCALAR_IS_FIXED
@@ -23,7 +23,7 @@
     #define GrIntToTextScalar(x)    GrIntToFixed(x)
     #define GrFixedToTextScalar(x)  (x)
 #elif GR_TEXT_SCALAR_IS_FLOAT
-    typedef float                   GrTextScalar;    
+    typedef float                   GrTextScalar;
     #define GrIntToTextScalar(x)    ((GrTextScalar)x)
     #define GrFixedToTextScalar(x)  GrFixedToFloat(x)
 #else
@@ -45,12 +45,12 @@
         fX = GrIntToTextScalar(x);
         fY = GrIntToTextScalar(y);
     }
-    
+
     void setX(GrFixed x, GrFixed y) {
         fX = GrFixedToTextScalar(x);
         fY = GrFixedToTextScalar(y);
     }
-    
+
     // rect fan is counter-clockwise
 
     void setRectFan(GrTextScalar l, GrTextScalar t, GrTextScalar r,
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index de7f253..5cbaab1 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -22,7 +22,7 @@
 /**
  *  Base class for drawing paths into a GrDrawTarget.
  *
- *  Derived classes can use stages GrPaint::kTotalStages through 
+ *  Derived classes can use stages GrPaint::kTotalStages through
  *  GrDrawState::kNumStages-1. The stages before GrPaint::kTotalStages
  *  are reserved for setting up the draw (i.e., textures and filter masks).
  */
@@ -75,7 +75,7 @@
 
     /**
      * Returns true if this path renderer is able to render the path.
-     * Returning false allows the caller to fallback to another path renderer 
+     * Returning false allows the caller to fallback to another path renderer
      * This function is called when searching for a path renderer capable of
      * rendering a path.
      *
@@ -92,7 +92,7 @@
                              bool antiAlias) const = 0;
     /**
      * Draws the path into the draw target. If requiresStencilBuffer returned
-     * false then the target may be setup for stencil rendering (since the 
+     * false then the target may be setup for stencil rendering (since the
      * path renderer didn't claim that it needs to use the stencil internally).
      *
      * @param path                  the path to draw.
diff --git a/src/gpu/GrPathUtils.cpp b/src/gpu/GrPathUtils.cpp
index 2d4abe0..e0ddea8 100644
--- a/src/gpu/GrPathUtils.cpp
+++ b/src/gpu/GrPathUtils.cpp
@@ -201,13 +201,13 @@
     // We invert the control pt matrix and post concat to both sides to get M.
     UVpts.setAll(0,   GR_ScalarHalf,  GR_Scalar1,
                  0,               0,  GR_Scalar1,
-                 SkScalarToPersp(GR_Scalar1), 
-                 SkScalarToPersp(GR_Scalar1), 
+                 SkScalarToPersp(GR_Scalar1),
+                 SkScalarToPersp(GR_Scalar1),
                  SkScalarToPersp(GR_Scalar1));
     m.setAll(qPts[0].fX, qPts[1].fX, qPts[2].fX,
              qPts[0].fY, qPts[1].fY, qPts[2].fY,
-             SkScalarToPersp(GR_Scalar1), 
-             SkScalarToPersp(GR_Scalar1), 
+             SkScalarToPersp(GR_Scalar1),
+             SkScalarToPersp(GR_Scalar1),
              SkScalarToPersp(GR_Scalar1));
     if (!m.invert(&m)) {
         // The quad is degenerate. Hopefully this is rare. Find the pts that are
@@ -348,7 +348,7 @@
     // When the ab and cd tangents are nearly parallel with vector from d to a the constraint that
     // the quad point falls between the tangents becomes hard to enforce and we are likely to hit
     // the max subdivision count. However, in this case the cubic is approaching a line and the
-    // accuracy of the quad point isn't so important. We check if the two middle cubic control 
+    // accuracy of the quad point isn't so important. We check if the two middle cubic control
     // points are very close to the baseline vector. If so then we just pick quadratic points on the
     // control polygon.
 
diff --git a/src/gpu/GrPlotMgr.h b/src/gpu/GrPlotMgr.h
index 38589f3..6dd7114 100644
--- a/src/gpu/GrPlotMgr.h
+++ b/src/gpu/GrPlotMgr.h
@@ -32,7 +32,7 @@
             delete[] fBusy;
         }
     }
-    
+
     void reset() {
         Gr_bzero(fBusy, fDim.fX * fDim.fY);
     }
diff --git a/src/gpu/GrRectanizer.cpp b/src/gpu/GrRectanizer.cpp
index 8df3b05..87ea92e 100644
--- a/src/gpu/GrRectanizer.cpp
+++ b/src/gpu/GrRectanizer.cpp
@@ -38,7 +38,7 @@
     struct Row {
         GrIPoint16  fLoc;
         int         fRowHeight;
-        
+
         bool canAddWidth(int width, int containerWidth) const {
             return fLoc.fX + width <= containerWidth;
         }
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index 44b15e2..c780769 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -39,22 +39,22 @@
  */
 class GrSWMaskHelper : public GrNoncopyable {
 public:
-    GrSWMaskHelper(GrContext* context) 
+    GrSWMaskHelper(GrContext* context)
     : fContext(context) {
     }
 
     // set up the internal state in preparation for draws. Since many masks
-    // may be accumulated in the helper during creation, "resultBounds" 
-    // allows the caller to specify the region of interest - to limit the 
+    // may be accumulated in the helper during creation, "resultBounds"
+    // allows the caller to specify the region of interest - to limit the
     // amount of work.
     bool init(const GrIRect& resultBounds, const GrMatrix* matrix);
 
     // Draw a single rect into the accumulation bitmap using the specified op
-    void draw(const GrRect& rect, SkRegion::Op op, 
+    void draw(const GrRect& rect, SkRegion::Op op,
               bool antiAlias, uint8_t alpha);
 
     // Draw a single path into the accumuation bitmap using the specified op
-    void draw(const SkPath& path, SkRegion::Op op, 
+    void draw(const SkPath& path, SkRegion::Op op,
               GrPathFill fill, bool antiAlias, uint8_t alpha);
 
     // Helper function to get a scratch texture suitable for capturing the
@@ -80,14 +80,14 @@
                                             GrMatrix* matrix);
 
     // This utility routine is used to add a path's mask to some other draw.
-    // The ClipMaskManager uses it to accumulate clip masks while the 
+    // The ClipMaskManager uses it to accumulate clip masks while the
     // GrSoftwarePathRenderer uses it to fulfill a drawPath call.
-    // It draws with "texture" as a path mask into "target" using "rect" as 
+    // It draws with "texture" as a path mask into "target" using "rect" as
     // geometry and the current drawState. The current drawState is altered to
     // accommodate the mask.
-    // Note that this method assumes that the GrPaint::kTotalStages slot in 
+    // Note that this method assumes that the GrPaint::kTotalStages slot in
     // the draw state can be used to hold the mask texture stage.
-    // This method is really only intended to be used with the 
+    // This method is really only intended to be used with the
     // output of DrawPathMaskToTexture.
     static void DrawToTargetWithPathMask(GrTexture* texture,
                                          GrDrawTarget* target,
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 16b859f..edac161 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -19,7 +19,7 @@
         // TODO: We could allow the SW path to also handle non-AA paths but
         // this would mean that GrDefaultPathRenderer would never be called
         // (since it appears after the SW renderer in the path renderer
-        // chain). Some testing would need to be done r.e. performance 
+        // chain). Some testing would need to be done r.e. performance
         // and consistency of the resulting images before removing
         // the "!antiAlias" clause from the above test
         return false;
@@ -32,7 +32,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // gets device coord bounds of path (not considering the fill) and clip. The
-// path bounds will be a subset of the clip bounds. returns false if 
+// path bounds will be a subset of the clip bounds. returns false if
 // path bounds would be empty.
 bool get_path_and_clip_bounds(const GrDrawTarget* target,
                               const SkPath& path,
@@ -48,7 +48,7 @@
 
     target->getClip()->getConservativeBounds(rt, devClipBounds);
 
-    // TODO: getConservativeBounds already intersects with the 
+    // TODO: getConservativeBounds already intersects with the
     // render target's bounding box. Remove this next line
     if (!devPathBounds->intersect(*devClipBounds)) {
         return false;
@@ -81,22 +81,22 @@
     }
     GrRect rect;
     if (devClipBounds.fTop < devPathBounds.fTop) {
-        rect.iset(devClipBounds.fLeft, devClipBounds.fTop, 
+        rect.iset(devClipBounds.fLeft, devClipBounds.fTop,
                   devClipBounds.fRight, devPathBounds.fTop);
         target->drawSimpleRect(rect, NULL);
     }
     if (devClipBounds.fLeft < devPathBounds.fLeft) {
-        rect.iset(devClipBounds.fLeft, devPathBounds.fTop, 
+        rect.iset(devClipBounds.fLeft, devPathBounds.fTop,
                   devPathBounds.fLeft, devPathBounds.fBottom);
         target->drawSimpleRect(rect, NULL);
     }
     if (devClipBounds.fRight > devPathBounds.fRight) {
-        rect.iset(devPathBounds.fRight, devPathBounds.fTop, 
+        rect.iset(devPathBounds.fRight, devPathBounds.fTop,
                   devClipBounds.fRight, devPathBounds.fBottom);
         target->drawSimpleRect(rect, NULL);
     }
     if (devClipBounds.fBottom > devPathBounds.fBottom) {
-        rect.iset(devClipBounds.fLeft, devPathBounds.fBottom, 
+        rect.iset(devClipBounds.fLeft, devPathBounds.fBottom,
                   devClipBounds.fRight, devClipBounds.fBottom);
         target->drawSimpleRect(rect, NULL);
     }
@@ -133,8 +133,8 @@
     }
 
     SkAutoTUnref<GrTexture> texture(
-            GrSWMaskHelper::DrawPathMaskToTexture(fContext, path, 
-                                                  devPathBounds, fill, 
+            GrSWMaskHelper::DrawPathMaskToTexture(fContext, path,
+                                                  devPathBounds, fill,
                                                   antiAlias, &vm));
     if (NULL == texture) {
         return false;
diff --git a/src/gpu/GrSoftwarePathRenderer.h b/src/gpu/GrSoftwarePathRenderer.h
index 6e18b59..7884cbb 100644
--- a/src/gpu/GrSoftwarePathRenderer.h
+++ b/src/gpu/GrSoftwarePathRenderer.h
@@ -20,7 +20,7 @@
  */
 class GrSoftwarePathRenderer : public GrPathRenderer {
 public:
-    GrSoftwarePathRenderer(GrContext* context) 
+    GrSoftwarePathRenderer(GrContext* context)
         : fContext(context) {
     }
 
@@ -34,7 +34,7 @@
                             const GrVec* translate,
                             GrDrawTarget* target,
                             bool antiAlias) SK_OVERRIDE;
- 
+
 private:
     GrContext*     fContext;
 
diff --git a/src/gpu/GrStencil.h b/src/gpu/GrStencil.h
index b4aa70e..1af98e6 100644
--- a/src/gpu/GrStencil.h
+++ b/src/gpu/GrStencil.h
@@ -274,7 +274,7 @@
         fFlags |= writes ? kDoesWrite_StencilFlag : kDoesNotWrite_StencilFlag;
         return writes;
     }
-    
+
     void invalidate()  {
         // write an illegal value to the first member
         fPassOps[0] = (GrStencilOp)(uint8_t)-1;
@@ -284,18 +284,18 @@
     bool operator == (const GrStencilSettings& s) const {
         static const size_t gCompareSize = sizeof(GrStencilSettings) -
                                            sizeof(fFlags);
-        GrAssert((const char*)&fFlags + sizeof(fFlags) == 
+        GrAssert((const char*)&fFlags + sizeof(fFlags) ==
                  (const char*)this + sizeof(GrStencilSettings));
         if (this->isDisabled() & s.isDisabled()) { // using & not &&
             return true;
         }
         return 0 == memcmp(this, &s, gCompareSize);
     }
-    
+
     bool operator != (const GrStencilSettings& s) const {
         return !(*this == s);
     }
-    
+
     GrStencilSettings& operator =(const GrStencilSettings& s) {
         memcpy(this, &s, sizeof(GrStencilSettings));
         return *this;
@@ -305,7 +305,7 @@
     friend class GrClipMaskManager;
 
     enum {
-        kMaxStencilClipPasses = 2  // maximum number of passes to add a clip 
+        kMaxStencilClipPasses = 2  // maximum number of passes to add a clip
                                    // element to the stencil buffer.
     };
 
@@ -316,15 +316,15 @@
      *      needs to be drawn to the client portion of the stencil first.
      *      2. How many passes are needed.
      *      3. What those passes are.
-     *      4. The fill rule that should actually be used to render (will 
+     *      4. The fill rule that should actually be used to render (will
      *         always be non-inverted).
      *
-     * @param op                the set op to combine this element with the 
+     * @param op                the set op to combine this element with the
      *                          existing clip
      * @param stencilClipMask   mask with just the stencil bit used for clipping
      *                          enabled.
      * @param invertedFill      is this path inverted
-     * @param numPasses         out: the number of passes needed to add the 
+     * @param numPasses         out: the number of passes needed to add the
      *                               element to the clip.
      * @param settings          out: the stencil settings to use for each pass
      *
@@ -332,7 +332,7 @@
      *         stencil clip bit. Will only be true if canBeDirect is true.
      *         numPasses will be 1 if return value is true.
      */
-    static bool GetClipPasses(SkRegion::Op op, 
+    static bool GetClipPasses(SkRegion::Op op,
                               bool canBeDirect,
                               unsigned int stencilClipMask,
                               bool invertedFill,
diff --git a/src/gpu/GrStencilBuffer.cpp b/src/gpu/GrStencilBuffer.cpp
index 7f733f4..bf14f48 100644
--- a/src/gpu/GrStencilBuffer.cpp
+++ b/src/gpu/GrStencilBuffer.cpp
@@ -62,7 +62,7 @@
 namespace {
 // we should never have more than one stencil buffer with same combo of
 // (width,height,samplecount)
-void gen_stencil_key_values(int width, 
+void gen_stencil_key_values(int width,
                             int height,
                             int sampleCnt,
                             GrCacheID* cacheID) {
@@ -77,8 +77,8 @@
 }
 }
 
-GrResourceKey GrStencilBuffer::ComputeKey(int width, 
-                                          int height, 
+GrResourceKey GrStencilBuffer::ComputeKey(int width,
+                                          int height,
                                           int sampleCnt) {
     GrCacheID id(GrStencilBuffer::GetResourceType());
     gen_stencil_key_values(width, height, sampleCnt, &id);
diff --git a/src/gpu/GrTBSearch.h b/src/gpu/GrTBSearch.h
index 2697f37..1d77c95 100644
--- a/src/gpu/GrTBSearch.h
+++ b/src/gpu/GrTBSearch.h
@@ -18,7 +18,7 @@
         // we should insert it at 0
         return ~0;
     }
-    
+
     int high = count - 1;
     int low = 0;
     while (high > low) {
@@ -29,12 +29,12 @@
             high = index;
         }
     }
-    
+
     // check if we found it
     if (EQ(array[high], target)) {
         return high;
     }
-    
+
     // now return the ~ of where we should insert it
     if (LT(array[high], target)) {
         high += 1;
diff --git a/src/gpu/GrTDArray.h b/src/gpu/GrTDArray.h
index 731001a..0e5b6bb 100644
--- a/src/gpu/GrTDArray.h
+++ b/src/gpu/GrTDArray.h
@@ -72,7 +72,7 @@
 
     T* begin() const { return fArray; }
     T* end() const { return fArray + fCount; }
-    T* back() const { GrAssert(fCount); return fArray + (fCount - 1); } 
+    T* back() const { GrAssert(fCount); return fArray + (fCount - 1); }
 
     T* prepend() {
         this->growAt(0);
diff --git a/src/gpu/GrTLList.h b/src/gpu/GrTLList.h
index ea310ac..e875118 100644
--- a/src/gpu/GrTLList.h
+++ b/src/gpu/GrTLList.h
@@ -30,7 +30,7 @@
 
     T*  head() const { return fHead; }
     T*  tail() const { return fTail; }
-    
+
     void addToHead(T*);
     void addToTail(T*);
     void removeFromList(T*);
diff --git a/src/gpu/GrTemplates.h b/src/gpu/GrTemplates.h
index 4378d70..69720dc 100644
--- a/src/gpu/GrTemplates.h
+++ b/src/gpu/GrTemplates.h
@@ -40,20 +40,20 @@
 template <typename T> class GrAutoTRestore : public GrNoncopyable {
 public:
     GrAutoTRestore() : fPtr(NULL), fVal() {}
-    
+
     GrAutoTRestore(T* ptr) {
         fPtr = ptr;
         if (NULL != ptr) {
             fVal = *ptr;
         }
     }
-    
+
     ~GrAutoTRestore() {
         if (NULL != fPtr) {
             *fPtr = fVal;
         }
     }
-    
+
     // restores previously saved value (if any) and saves value for passed T*
     void reset(T* ptr) {
         if (NULL != fPtr) {
diff --git a/src/gpu/GrTextContext.cpp b/src/gpu/GrTextContext.cpp
index 23b16dd..edd92db 100644
--- a/src/gpu/GrTextContext.cpp
+++ b/src/gpu/GrTextContext.cpp
@@ -111,10 +111,10 @@
 
     /*
      We need to call preConcatMatrix with our viewmatrix's inverse, for each
-     texture and mask in the paint. However, computing the inverse can be 
+     texture and mask in the paint. However, computing the inverse can be
      expensive, and its possible we may not have any textures or masks, so these
      two loops are written such that we only compute the inverse (once) if we
-     need it. We do this on our copy of the paint rather than directly on the 
+     need it. We do this on our copy of the paint rather than directly on the
      draw target because we re-provide the paint to the context when we have
      to flush our glyphs or draw a glyph as a path midstream.
     */
@@ -142,7 +142,7 @@
     fVertices = NULL;
     fMaxVertices = 0;
 
-    fVertexLayout = 
+    fVertexLayout =
         GrDrawTarget::kTextFormat_VertexLayoutBit |
         GrDrawTarget::StageTexCoordVertexLayoutBit(kGlyphMaskStage, 0);
 }
@@ -272,7 +272,7 @@
             fMaxVertices = maxQuadVertices;
         }
         bool success = fDrawTarget->reserveVertexAndIndexSpace(
-                                                   fVertexLayout, 
+                                                   fVertexLayout,
                                                    fMaxVertices,
                                                    0,
                                                    GrTCast<void**>(&fVertices),
diff --git a/src/gpu/GrTextStrike_impl.h b/src/gpu/GrTextStrike_impl.h
index 1b6392c..a3f37b3 100644
--- a/src/gpu/GrTextStrike_impl.h
+++ b/src/gpu/GrTextStrike_impl.h
@@ -16,16 +16,16 @@
     Key(GrFontScaler* scaler) {
         fFontScalerKey = scaler->getKey();
     }
-    
+
     uint32_t getHash() const { return fFontScalerKey->getHash(); }
-    
+
     static bool LT(const GrTextStrike& strike, const Key& key) {
         return *strike.getFontScalerKey() < *key.fFontScalerKey;
     }
     static bool EQ(const GrTextStrike& strike, const Key& key) {
         return *strike.getFontScalerKey() == *key.fFontScalerKey;
     }
-    
+
 private:
     const GrKey* fFontScalerKey;
 };
@@ -50,7 +50,7 @@
 
 GrTextStrike* GrFontCache::getStrike(GrFontScaler* scaler) {
     this->validate();
-    
+
     Key key(scaler);
     GrTextStrike* strike = fCache.find(key);
     if (NULL == strike) {
@@ -79,16 +79,16 @@
 class GrTextStrike::Key {
 public:
     Key(GrGlyph::PackedID id) : fPackedID(id) {}
-    
+
     uint32_t getHash() const { return fPackedID; }
-    
+
     static bool LT(const GrGlyph& glyph, const Key& key) {
         return glyph.fPackedID < key.fPackedID;
     }
     static bool EQ(const GrGlyph& glyph, const Key& key) {
         return glyph.fPackedID == key.fPackedID;
     }
-    
+
 private:
     GrGlyph::PackedID fPackedID;
 };
diff --git a/src/gpu/GrTexture.cpp b/src/gpu/GrTexture.cpp
index 182c90e..ce6109b 100644
--- a/src/gpu/GrTexture.cpp
+++ b/src/gpu/GrTexture.cpp
@@ -17,7 +17,7 @@
 SK_DEFINE_INST_COUNT(GrTexture)
 GR_DEFINE_RESOURCE_CACHE_TYPE(GrTexture)
 
-/** 
+/**
  * This method allows us to interrupt the normal deletion process and place
  * textures back in the texture cache when their ref count goes to zero.
  */
@@ -31,7 +31,7 @@
         nonConstThis->resetFlag((GrTextureFlags) kReturnToCache_FlagBit);
         nonConstThis->INHERITED::getContext()->addExistingTextureToCache(nonConstThis);
 
-        // Note: "this" texture might be freed inside addExistingTextureToCache 
+        // Note: "this" texture might be freed inside addExistingTextureToCache
         // if it is purged.
         return;
     }
@@ -117,7 +117,7 @@
 enum TextureBits {
     /*
      * The kNPOT bit is set when the texture is NPOT and is being repeated
-     * but the hardware doesn't support that feature. 
+     * but the hardware doesn't support that feature.
      */
     kNPOT_TextureBit            = 0x1,
     /*
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index f7e5152..5566086 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -59,7 +59,7 @@
 // all the blur tests.
 #define BLUR_SIGMA_SCALE 0.6f
 // This constant represents the screen alignment criterion in texels for
-// requiring texture domain clamping to prevent color bleeding when drawing 
+// requiring texture domain clamping to prevent color bleeding when drawing
 // a sub region of a larger source image.
 #define COLOR_BLEED_TOLERANCE SkFloatToScalar(0.001f)
 
@@ -84,7 +84,7 @@
     SkAutoCachedTexture()
         : fDevice(NULL)
         , fTexture(NULL) {
-    }    
+    }
 
     SkAutoCachedTexture(SkGpuDevice* device,
                         const SkBitmap& bitmap,
@@ -118,7 +118,7 @@
         }
         return result;
     }
-    
+
 private:
     SkGpuDevice* fDevice;
     GrTexture*   fTexture;
@@ -199,7 +199,7 @@
     // if this RT is also a texture, hold a ref on it
     fTexture = fRenderTarget->asTexture();
     SkSafeRef(fTexture);
-    
+
     // Create a pixel ref for the underlying SkBitmap. We prefer a texture pixel
     // ref to a render target pixel reft. The pixel ref may get ref'ed outside
     // the device via accessBitmap. This external ref may outlive the device.
@@ -267,7 +267,7 @@
     }
 
     // The SkGpuDevice gives the context the render target (e.g., in gainFocus)
-    // This call gives the context a chance to relinquish it 
+    // This call gives the context a chance to relinquish it
     fContext->setRenderTarget(NULL);
 
     SkSafeUnref(fTexture);
@@ -599,7 +599,7 @@
                                        constantColor,
                                        &textures[kColorFilterTextureIdx],
                                        grPaint);
-    } else if (!skPaint2GrPaintNoShader(dev, skPaint, true, false, 
+    } else if (!skPaint2GrPaintNoShader(dev, skPaint, true, false,
                                         &textures[kColorFilterTextureIdx], grPaint)) {
         return false;
     }
@@ -1120,7 +1120,7 @@
         if (!drawWithGPUMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
                                    *draw.fMatrix, *draw.fClip, draw.fBounder,
                                    &grPaint, pathFillType)) {
-            SkPaint::Style style = doFill ? SkPaint::kFill_Style : 
+            SkPaint::Style style = doFill ? SkPaint::kFill_Style :
                 SkPaint::kStroke_Style;
             drawWithMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
                                *draw.fMatrix, *draw.fClip, draw.fBounder,
@@ -1371,7 +1371,7 @@
     // detect pixel disalignment
     if (SkScalarAbs(SkScalarRoundToScalar(transformedRect.left()) -
             transformedRect.left()) < COLOR_BLEED_TOLERANCE &&
-        SkScalarAbs(SkScalarRoundToScalar(transformedRect.top()) - 
+        SkScalarAbs(SkScalarRoundToScalar(transformedRect.top()) -
             transformedRect.top()) < COLOR_BLEED_TOLERANCE &&
         SkScalarAbs(transformedRect.width() - srcRect.width()) <
             COLOR_BLEED_TOLERANCE &&
@@ -1387,7 +1387,7 @@
     // Only gets called if hasAlignedSamples returned false.
     // So we can assume that sampling is axis aligned but not texel aligned.
     GrAssert(!hasAlignedSamples(srcRect, transformedRect));
-    SkRect innerSrcRect(srcRect), innerTransformedRect, 
+    SkRect innerSrcRect(srcRect), innerTransformedRect,
         outerTransformedRect(transformedRect);
     innerSrcRect.inset(SK_ScalarHalf, SK_ScalarHalf);
     m.mapRect(&innerTransformedRect, innerSrcRect);
@@ -1453,7 +1453,7 @@
                       SkFloatToScalar(srcRect.fRight * wInv),
                       SkFloatToScalar(srcRect.fBottom * hInv));
 
-    bool needsTextureDomain = false; 
+    bool needsTextureDomain = false;
     if (sampler->textureParams()->isBilerp()) {
         // Need texture domain if drawing a sub rect.
         needsTextureDomain = srcRect.width() < bitmap.width() || srcRect.height() < bitmap.height();
@@ -1464,7 +1464,7 @@
             SkMatrix srcToDeviceMatrix(m);
             srcToDeviceMatrix.postConcat(*draw.fMatrix);
             srcToDeviceMatrix.mapRect(&transformedRect, floatSrcRect);
-            
+
             if (hasAlignedSamples(floatSrcRect, transformedRect)) {
                 // Samples are texel-aligned, so filtering is futile
                 sampler->textureParams()->setBilerp(false);
@@ -1474,7 +1474,7 @@
                     mayColorBleed(floatSrcRect, transformedRect, m);
             }
         }
-    } 
+    }
 
     GrRect textureDomain = GrRect::MakeEmpty();
 
@@ -1495,7 +1495,7 @@
         } else {
             top = bottom = GrScalarHalf(paintRect.top() + paintRect.bottom());
         }
-        textureDomain.setLTRB(left, top, right, bottom);  
+        textureDomain.setLTRB(left, top, right, bottom);
         sampler->setCustomStage(SkNEW_ARGS(GrTextureDomainEffect,
                      (texture,
                       textureDomain)))->unref();
@@ -1589,7 +1589,7 @@
             filteredTexture->unref();
         }
     }
-    
+
     fContext->drawRectToRect(grPaint,
                             GrRect::MakeXYWH(GrIntToScalar(left),
                                             GrIntToScalar(top),
@@ -1633,7 +1633,7 @@
             filteredTexture->unref();
         }
     }
-    
+
     const SkBitmap& bm = dev->accessBitmap(false);
     int w = bm.width();
     int h = bm.height();
@@ -1682,7 +1682,7 @@
     SkAutoCachedTexture act(this, src, sampler->textureParams(), &texture);
 
     result->setConfig(src.config(), src.width(), src.height());
-    GrRect rect = GrRect::MakeWH(SkIntToScalar(src.width()), 
+    GrRect rect = GrRect::MakeWH(SkIntToScalar(src.width()),
                                  SkIntToScalar(src.height()));
     GrTexture* resultTexture = filter_texture(fContext, texture, filter, rect);
     if (resultTexture) {
diff --git a/src/gpu/gl/GrGLPath.h b/src/gpu/gl/GrGLPath.h
index f9febb4..dfe3405 100644
--- a/src/gpu/gl/GrGLPath.h
+++ b/src/gpu/gl/GrGLPath.h
@@ -26,7 +26,7 @@
     GrGLPath(GrGpuGL* gpu, const SkPath& path);
     virtual ~GrGLPath();
     GrGLuint pathID() const { return fPathID; }
-    // TODO: Figure out how to get an approximate size of the path in Gpu 
+    // TODO: Figure out how to get an approximate size of the path in Gpu
     // memory.
     virtual size_t sizeInBytes() const SK_OVERRIDE { return 100; }
 
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index 989b7c6..b755f75 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -127,17 +127,17 @@
 
                 /**
                  Smear alpha across all four channels. This is incompatible with
-                 kSwapRAndB, kMulRGBByAlpha* and kSmearRed. It is prefereable 
-                 to perform the smear outside the shader using 
-                 GL_ARB_texture_swizzle if possible rather than setting this 
+                 kSwapRAndB, kMulRGBByAlpha* and kSmearRed. It is prefereable
+                 to perform the smear outside the shader using
+                 GL_ARB_texture_swizzle if possible rather than setting this
                  flag.
                 */
                 kSmearAlpha_InConfigFlag                = 0x02,
 
                 /**
-                 Smear the red channel across all four channels. This flag is 
-                 incompatible with kSwapRAndB, kMulRGBByAlpha*and kSmearAlpha. 
-                 It is preferable to use GL_ARB_texture_swizzle instead of this 
+                 Smear the red channel across all four channels. This flag is
+                 incompatible with kSwapRAndB, kMulRGBByAlpha*and kSmearAlpha.
+                 It is preferable to use GL_ARB_texture_swizzle instead of this
                  flag.
                 */
                 kSmearRed_InConfigFlag                  = 0x04,
diff --git a/src/gpu/gl/GrGLTexture.h b/src/gpu/gl/GrGLTexture.h
index 1095d53..2e9ee17 100644
--- a/src/gpu/gl/GrGLTexture.h
+++ b/src/gpu/gl/GrGLTexture.h
@@ -83,7 +83,7 @@
 
     virtual void invalidateCachedState() SK_OVERRIDE { fTexParams.invalidate(); }
 
-    // these functions 
+    // these functions
     const TexParams& getCachedTexParams(GrGpu::ResetTimestamp* timestamp) const {
         *timestamp = fTexParamsTimestamp;
         return fTexParams;
diff --git a/src/gpu/gl/GrGpuGL.h b/src/gpu/gl/GrGpuGL.h
index ae19b2e..2cfdd0d 100644
--- a/src/gpu/gl/GrGpuGL.h
+++ b/src/gpu/gl/GrGpuGL.h
@@ -27,7 +27,7 @@
     GrGpuGL(const GrGLContextInfo& ctxInfo);
     virtual ~GrGpuGL();
 
-    const GrGLInterface* glInterface() const { 
+    const GrGLInterface* glInterface() const {
         return fGLContextInfo.interface();
     }
     GrGLBinding glBinding() const { return fGLContextInfo.binding(); }
@@ -84,9 +84,9 @@
     virtual void onForceRenderTargetFlush() SK_OVERRIDE;
 
     virtual bool onReadPixels(GrRenderTarget* target,
-                              int left, int top, 
+                              int left, int top,
                               int width, int height,
-                              GrPixelConfig, 
+                              GrPixelConfig,
                               void* buffer,
                               size_t rowBytes,
                               bool invertY) SK_OVERRIDE;
diff --git a/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp b/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
index 4b55a5d..ef8eccc 100644
--- a/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
+++ b/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
@@ -25,7 +25,7 @@
 const GrGLInterface* GrGLCreateNativeInterface() {
     // wglGetProcAddress requires a context.
     // GL Function pointers retrieved in one context may not be valid in another
-    // context. For that reason we create a new GrGLInterface each time we're 
+    // context. For that reason we create a new GrGLInterface each time we're
     // called.
     if (NULL != wglGetCurrentContext()) {
         const char* versionString = (const char*) glGetString(GL_VERSION);
@@ -118,7 +118,7 @@
         GR_GL_GET_PROC(GetQueryiv);
         GR_GL_GET_PROC(GetQueryObjectiv);
         GR_GL_GET_PROC(GetQueryObjectuiv);
-        if (glVer > GR_GL_VER(3,3) || 
+        if (glVer > GR_GL_VER(3,3) ||
             GrGLHasExtensionFromString("GL_ARB_timer_query", extString)) {
             GR_GL_GET_PROC(GetQueryObjecti64v);
             GR_GL_GET_PROC(GetQueryObjectui64v);
@@ -166,7 +166,7 @@
 
         // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
         // GL_ARB_framebuffer_object doesn't use ARB suffix.)
-        if (glVer > GR_GL_VER(3,0) || 
+        if (glVer > GR_GL_VER(3,0) ||
             GrGLHasExtensionFromString("GL_ARB_framebuffer_object", extString)) {
             GR_GL_GET_PROC(GenFramebuffers);
             GR_GL_GET_PROC(GetFramebufferAttachmentParameteriv);
diff --git a/src/gpu/gl/win/SkNativeGLContext_win.cpp b/src/gpu/gl/win/SkNativeGLContext_win.cpp
index 9650bc1..0082920 100644
--- a/src/gpu/gl/win/SkNativeGLContext_win.cpp
+++ b/src/gpu/gl/win/SkNativeGLContext_win.cpp
@@ -84,7 +84,7 @@
         this->destroyGLContext();
         return NULL;
     }
-    
+
     PIXELFORMATDESCRIPTOR pfd;
     ZeroMemory(&pfd, sizeof(pfd));
     pfd.nSize = sizeof(pfd);
@@ -95,20 +95,20 @@
     pfd.cDepthBits = 0;
     pfd.cStencilBits = 0;
     pfd.iLayerType = PFD_MAIN_PLANE;
-    
+
     int pixelFormat = 0;
     if (!(pixelFormat = ChoosePixelFormat(fDeviceContext, &pfd))) {
         SkDebugf("No matching pixel format descriptor.\n");
         this->destroyGLContext();
         return NULL;
     }
-    
+
     if (!SetPixelFormat(fDeviceContext, pixelFormat, &pfd)) {
         SkDebugf("Could not set the pixel format %d.\n", pixelFormat);
         this->destroyGLContext();
         return NULL;
     }
-    
+
     if (!(fGlRenderContext = wglCreateContext(fDeviceContext))) {
         SkDebugf("Could not create rendering context.\n");
         this->destroyGLContext();
diff --git a/src/gpu/gr_unittests.cpp b/src/gpu/gr_unittests.cpp
index 4d11721..a0f0c18 100644
--- a/src/gpu/gr_unittests.cpp
+++ b/src/gpu/gr_unittests.cpp
@@ -101,7 +101,7 @@
     GrTBinHashKey<BogusEntry, kDataLenUsedForKey> keyB;
     keyB.setKeyData(testStringB);
     GrAssert(keyA.compare(keyB) < 0);
-    GrAssert(keyA.getHash() != keyB.getHash());    
+    GrAssert(keyA.getHash() != keyB.getHash());
 }
 
 
diff --git a/src/gpu/ios/GrGLDefaultInterface_iOS.cpp b/src/gpu/ios/GrGLDefaultInterface_iOS.cpp
index 19d7ae0..ae43d98 100644
--- a/src/gpu/ios/GrGLDefaultInterface_iOS.cpp
+++ b/src/gpu/ios/GrGLDefaultInterface_iOS.cpp
@@ -123,18 +123,18 @@
         interface->fDeleteRenderbuffers = glDeleteRenderbuffers;
         interface->fFramebufferRenderbuffer = glFramebufferRenderbuffer;
         interface->fBindRenderbuffer = glBindRenderbuffer;
-       
+
     #if GL_OES_mapbuffer
         interface->fMapBuffer = glMapBufferOES;
         interface->fUnmapBuffer = glUnmapBufferOES;
     #endif
-        
+
     #if GL_APPLE_framebuffer_multisample
         interface->fRenderbufferStorageMultisample = glRenderbufferStorageMultisampleAPPLE;
         interface->fResolveMultisampleFramebuffer = glResolveMultisampleFramebufferAPPLE;
     #endif
         interface->fBindFragDataLocationIndexed = NULL;
-        
+
         interface->fBindingsExported = kES2_GrGLBinding;
     }
     glInterface.get()->ref();
diff --git a/src/images/SkFlipPixelRef.cpp b/src/images/SkFlipPixelRef.cpp
index 4e42d6c..f3f54e8 100644
--- a/src/images/SkFlipPixelRef.cpp
+++ b/src/images/SkFlipPixelRef.cpp
@@ -86,7 +86,7 @@
     const char* srcP = static_cast<const char*>(srcAddr) + offset;
     const size_t rb = dst.rowBytes();
     const size_t bytes = rect.width() << shift;
-    
+
     int height = rect.height();
     while (--height >= 0) {
         memcpy(dstP, srcP, bytes);
@@ -116,10 +116,10 @@
     if (shift < 0) {
         return;
     }
-    
+
     const SkIRect bounds = {0, 0, dst.width(), dst.height()};
     SkRegion::Cliperator iter(clip, bounds);
-    
+
     while (!iter.done()) {
         copyRect(dst, iter.rect(), srcAddr, shift);
         iter.next();
diff --git a/src/images/SkImageDecoder_libbmp.cpp b/src/images/SkImageDecoder_libbmp.cpp
index d3bb871..2cbdcc3 100644
--- a/src/images/SkImageDecoder_libbmp.cpp
+++ b/src/images/SkImageDecoder_libbmp.cpp
@@ -6,7 +6,7 @@
  * found in the LICENSE file.
  */
 
- 
+
 #include "bmpdecoderhelper.h"
 #include "SkImageDecoder.h"
 #include "SkScaledBitmapSampler.h"
@@ -18,7 +18,7 @@
 class SkBMPImageDecoder : public SkImageDecoder {
 public:
     SkBMPImageDecoder() {}
-    
+
     virtual Format getFormat() const {
         return kBMP_Format;
     }
@@ -33,10 +33,10 @@
 
 static SkImageDecoder* sk_libbmp_dfactory(SkStream* stream) {
     static const char kBmpMagic[] = { 'B', 'M' };
-    
+
     size_t len = stream->getLength();
     char buffer[sizeof(kBmpMagic)];
-    
+
     if (len > sizeof(kBmpMagic) &&
             stream->read(buffer, sizeof(kBmpMagic)) == sizeof(kBmpMagic) &&
             !memcmp(buffer, kBmpMagic, sizeof(kBmpMagic))) {
@@ -61,7 +61,7 @@
         if (fJustBounds) {
             return NULL;
         }
-        
+
         fRGB.setCount(width * height * 3);  // 3 == r, g, b
         return fRGB.begin();
     }
@@ -81,11 +81,11 @@
 
     size_t length = stream->getLength();
     SkAutoMalloc storage(length);
-    
+
     if (stream->read(storage.get(), length) != length) {
         return false;
     }
-    
+
     const bool justBounds = SkImageDecoder::kDecodeBounds_Mode == mode;
     SkBmpDecoderCallback callback(justBounds);
 
@@ -98,11 +98,11 @@
             return false;
         }
     }
-    
+
     // we don't need this anymore, so free it now (before we try to allocate
     // the bitmap's pixels) rather than waiting for its destructor
     storage.free();
-    
+
     int width = callback.width();
     int height = callback.height();
     SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, false);
@@ -124,9 +124,9 @@
     if (!this->allocPixelRef(bm, NULL)) {
         return false;
     }
-    
+
     SkAutoLockPixels alp(*bm);
-    
+
     if (!sampler.begin(bm, SkScaledBitmapSampler::kRGB, getDitherImage())) {
         return false;
     }
@@ -134,7 +134,7 @@
     const int srcRowBytes = width * 3;
     const int dstHeight = sampler.scaledHeight();
     const uint8_t* srcRow = callback.rgb();
-    
+
     srcRow += sampler.srcY0() * srcRowBytes;
     for (int y = 0; y < dstHeight; y++) {
         sampler.next(srcRow);
diff --git a/src/images/SkImageDecoder_libgif.cpp b/src/images/SkImageDecoder_libgif.cpp
index cd4ee22..3008130 100644
--- a/src/images/SkImageDecoder_libgif.cpp
+++ b/src/images/SkImageDecoder_libgif.cpp
@@ -21,7 +21,7 @@
     virtual Format getFormat() const {
         return kGIF_Format;
     }
-    
+
 protected:
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode mode);
 };
@@ -48,7 +48,7 @@
         fCurrY = *fStartYPtr++;
         fDeltaY = *fDeltaYPtr++;
     }
-    
+
     int currY() const {
         SkASSERT(fStartYPtr);
         SkASSERT(fDeltaYPtr);
@@ -77,7 +77,7 @@
         }
         fCurrY = y;
     }
-    
+
 private:
     const int fHeight;
     int fCurrY;
@@ -167,22 +167,22 @@
     GifRecordType recType;
     GifByteType *extData;
     int transpIndex = -1;   // -1 means we don't have it (yet)
-    
+
     do {
         if (DGifGetRecordType(gif, &recType) == GIF_ERROR) {
             return error_return(gif, *bm, "DGifGetRecordType");
         }
-        
+
         switch (recType) {
         case IMAGE_DESC_RECORD_TYPE: {
             if (DGifGetImageDesc(gif) == GIF_ERROR) {
                 return error_return(gif, *bm, "IMAGE_DESC_RECORD_TYPE");
             }
-            
+
             if (gif->ImageCount < 1) {    // sanity check
                 return error_return(gif, *bm, "ImageCount < 1");
             }
-                
+
             width = gif->SWidth;
             height = gif->SHeight;
             if (width <= 0 || height <= 0 ||
@@ -190,21 +190,21 @@
                                            width, height)) {
                 return error_return(gif, *bm, "chooseFromOneChoice");
             }
-            
+
             bm->setConfig(SkBitmap::kIndex8_Config, width, height);
             if (SkImageDecoder::kDecodeBounds_Mode == mode)
                 return true;
 
             SavedImage* image = &gif->SavedImages[gif->ImageCount-1];
             const GifImageDesc& desc = image->ImageDesc;
-            
+
             // check for valid descriptor
             if (   (desc.Top | desc.Left) < 0 ||
                     desc.Left + desc.Width > width ||
                     desc.Top + desc.Height > height) {
                 return error_return(gif, *bm, "TopLeft");
             }
-            
+
             // now we decode the colortable
             int colorCount = 0;
             {
@@ -218,7 +218,7 @@
                 SkPMColor* colorPtr = ctable->lockColors();
                 for (int index = 0; index < colorCount; index++)
                     colorPtr[index] = SkPackARGB32(0xFF,
-                                                   cmap->Colors[index].Red, 
+                                                   cmap->Colors[index].Red,
                                                    cmap->Colors[index].Green,
                                                    cmap->Colors[index].Blue);
 
@@ -234,7 +234,7 @@
                     return error_return(gif, *bm, "allocPixelRef");
                 }
             }
-            
+
             SkAutoLockPixels alp(*bm);
 
             // time to decode the scanlines
@@ -268,7 +268,7 @@
                 // bump our starting address
                 scanline += desc.Top * rowBytes + desc.Left;
             }
-            
+
             // now decode each scanline
             if (gif->Image.Interlace)
             {
@@ -294,7 +294,7 @@
             }
             goto DONE;
             } break;
-            
+
         case EXTENSION_RECORD_TYPE:
             if (DGifGetExtension(gif, &temp_save.Function,
                                  &extData) == GIF_ERROR) {
@@ -313,11 +313,11 @@
                 temp_save.Function = 0;
             }
             break;
-            
+
         case TERMINATE_RECORD_TYPE:
             break;
-            
-        default:	/* Should be trapped by DGifGetRecordType */
+
+        default:    /* Should be trapped by DGifGetRecordType */
             break;
         }
     } while (recType != TERMINATE_RECORD_TYPE);
diff --git a/src/images/SkImageDecoder_libico.cpp b/src/images/SkImageDecoder_libico.cpp
index 30611cb..5167fe1 100644
--- a/src/images/SkImageDecoder_libico.cpp
+++ b/src/images/SkImageDecoder_libico.cpp
@@ -15,7 +15,7 @@
 class SkICOImageDecoder : public SkImageDecoder {
 public:
     SkICOImageDecoder();
-    
+
     virtual Format getFormat() const {
         return kICO_Format;
     }
@@ -46,23 +46,23 @@
 }
 
 //helpers - my function pointer will call one of these, depending on the bitCount, each time through the inner loop
-static void editPixelBit1(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit1(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
-static void editPixelBit4(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit4(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
-static void editPixelBit8(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit8(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
-static void editPixelBit24(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit24(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
-static void editPixelBit32(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit32(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors);
-            
-            
+
+
 static int calculateRowBytesFor8888(int w, int bitCount)
 {
     //  Default rowBytes is w << 2 for kARGB_8888
@@ -84,7 +84,7 @@
     if (stream->read((void*)buf, length) != length) {
         return false;
     }
-    
+
     //these should always be the same - should i use for error checking? - what about files that have some
     //incorrect values, but still decode properly?
     int reserved = read2Bytes(buf, 0);    // 0
@@ -92,11 +92,11 @@
     if (reserved != 0 || type != 1)
         return false;
     int count = read2Bytes(buf, 4);
-    
+
     //need to at least have enough space to hold the initial table of info
     if (length < (size_t)(6 + count*16))
         return false;
-        
+
     int choice;
     Chooser* chooser = this->getChooser();
     //FIXME:if no chooser, consider providing the largest color image
@@ -120,7 +120,7 @@
                 case 1:
                 case 4:
                     // In reality, at least for the moment, these will be decoded into kARGB_8888 bitmaps.
-                    // However, this will be used to distinguish between the lower quality 1bpp and 4 bpp 
+                    // However, this will be used to distinguish between the lower quality 1bpp and 4 bpp
                     // images and the higher quality images.
                     c = SkBitmap::kIndex8_Config;
                     break;
@@ -137,11 +137,11 @@
         }
         choice = chooser->choose();
     }
-    
+
     //you never know what the chooser is going to supply
-    if (choice >= count || choice < 0)       
+    if (choice >= count || choice < 0)
         return false;
-    
+
     //skip ahead to the correct header
     //commented out lines are not used, but if i switch to other read method, need to know how many to skip
     //otherwise, they could be used for error checking
@@ -160,9 +160,9 @@
     //int height = read4Bytes(buf, offset+8);             //should == 2*h
     //int planesToo = read2Bytes(buf, offset+12);         //should == 1 (does it?)
     int bitCount = read2Bytes(buf, offset+14);
-    
-    void (*placePixel)(const int pixelNo, const unsigned char* buf, 
-        const int xorOffset, int& x, int y, const int w, 
+
+    void (*placePixel)(const int pixelNo, const unsigned char* buf,
+        const int xorOffset, int& x, int y, const int w,
         SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = NULL;
     switch (bitCount)
     {
@@ -190,7 +190,7 @@
             SkDEBUGF(("Decoding %ibpp is unimplemented\n", bitCount));
             return false;
     }
-        
+
     //these should all be zero, but perhaps are not - need to check
     //int compression = read4Bytes(buf, offset+16);       //0
     //int imageSize = read4Bytes(buf, offset+20);         //0 - sometimes has a value
@@ -198,13 +198,13 @@
     //int yPixels = read4Bytes(buf, offset+28);           //0
     //int colorsUsed = read4Bytes(buf, offset+32)         //0 - might have an actual value though
     //int colorsImportant = read4Bytes(buf, offset+36);   //0
-        
+
     int begin = offset + 40;
     //this array represents the colortable
     //if i allow other types of bitmaps, it may actually be used as a part of the bitmap
     SkPMColor* colors = NULL;
     int blue, green, red;
-    if (colorCount) 
+    if (colorCount)
     {
         colors = new SkPMColor[colorCount];
         for (int j = 0; j < colorCount; j++)
@@ -221,11 +221,11 @@
     int mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1);    //either 0xFFFFFFFF or 0
     int lineBitWidth = (bitWidth & 0xFFFFFFE0) + (0x20 & mask);
     int lineWidth = lineBitWidth/bitCount;
-    
+
     int xorOffset = begin + colorCount*4;   //beginning of the color bitmap
                                             //other read method means we will just be here already
     int andOffset = xorOffset + ((lineWidth*h*bitCount) >> 3);
-    
+
     /*int */test = w & 0x1F;   //the low 5 bits - we are rounding up to the next 32 (2^5)
     /*int */mask = -(((test >> 4) | (test >> 3) | (test >> 2) | (test >> 1) | test) & 0x1);    //either 0xFFFFFFFF or 0
     int andLineWidth = (w & 0xFFFFFFE0) + (0x20 & mask);
@@ -236,7 +236,7 @@
     //however, with small images with large colortables, maybe it's better to still do argb_8888
 
     bm->setConfig(SkBitmap::kARGB_8888_Config, w, h, calculateRowBytesFor8888(w, bitCount));
-    
+
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         delete[] colors;
         return true;
@@ -247,7 +247,7 @@
         delete[] colors;
         return false;
     }
-    
+
     SkAutoLockPixels alp(*bm);
 
     for (int y = 0; y < h; y++)
@@ -255,7 +255,7 @@
         for (int x = 0; x < w; x++)
         {
             //U32* address = bm->getAddr32(x, y);
-            
+
             //check the alpha bit first, but pass it along to the function to figure out how to deal with it
             int andPixelNo = andLineWidth*(h-y-1)+x;
             //only need to get a new alphaByte when x %8 == 0
@@ -264,7 +264,7 @@
             int alphaByte = readByte(buf, andOffset + (andPixelNo >> 3));
             int shift = 7 - (andPixelNo & 0x7);
             int m = 1 << shift;
-            
+
             int pixelNo = lineWidth*(h-y-1)+x;
             placePixel(pixelNo, buf, xorOffset, x, y, w, bm, alphaByte, m, shift, colors);
 
@@ -279,8 +279,8 @@
 }   //onDecode
 
 //function to place the pixel, determined by the bitCount
-static void editPixelBit1(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit1(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
 {
     // note that this should be the same as/similar to the AND bitmap
@@ -288,15 +288,15 @@
     int byte = readByte(buf, xorOffset + (pixelNo >> 3));
     int colorBit;
     int alphaBit;
-    // Read all of the bits in this byte.  
+    // Read all of the bits in this byte.
     int i = x + 8;
-    // Pin to the width so we do not write outside the bounds of 
+    // Pin to the width so we do not write outside the bounds of
     // our color table.
     i = i > w ? w : i;
     // While loop to check all 8 bits individually.
     while (x < i)
     {
-        
+
         colorBit = (byte & m) >> shift;
         alphaBit = (alphaByte & m) >> shift;
         *address = (alphaBit-1)&(colors[colorBit]);
@@ -308,8 +308,8 @@
     }
     x--;
 }
-static void editPixelBit4(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit4(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
 {
     SkPMColor* address = bm->getAddr32(x, y);
@@ -328,18 +328,18 @@
     *address = (alphaBit-1)&(colors[pixel]);
 }
 
-static void editPixelBit8(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit8(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
 {
     SkPMColor* address = bm->getAddr32(x, y);
     int pixel = readByte(buf, xorOffset + pixelNo);
     int alphaBit = (alphaByte & m) >> shift;
     *address = (alphaBit-1)&(colors[pixel]);
-}            
+}
 
-static void editPixelBit24(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit24(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
 {
     SkPMColor* address = bm->getAddr32(x, y);
@@ -349,11 +349,11 @@
     int alphaBit = (alphaByte & m) >> shift;
     //alphaBit == 1 => alpha = 0
     int alpha = (alphaBit-1) & 0xFF;
-    *address = SkPreMultiplyARGB(alpha, red, green, blue);    
+    *address = SkPreMultiplyARGB(alpha, red, green, blue);
 }
 
-static void editPixelBit32(const int pixelNo, const unsigned char* buf, 
-            const int xorOffset, int& x, int y, const int w, 
+static void editPixelBit32(const int pixelNo, const unsigned char* buf,
+            const int xorOffset, int& x, int y, const int w,
             SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors)
 {
     SkPMColor* address = bm->getAddr32(x, y);
diff --git a/src/images/SkImageDecoder_libjpeg.cpp b/src/images/SkImageDecoder_libjpeg.cpp
index 8989d35..6bae965 100644
--- a/src/images/SkImageDecoder_libjpeg.cpp
+++ b/src/images/SkImageDecoder_libjpeg.cpp
@@ -147,7 +147,7 @@
 // method moves the "scanline" pointer in its processing
 static void convert_CMYK_to_RGB(uint8_t* scanline, unsigned int width) {
     // At this point we've received CMYK pixels from libjpeg. We
-    // perform a crude conversion to RGB (based on the formulae 
+    // perform a crude conversion to RGB (based on the formulae
     // from easyrgb.com):
     //  CMYK -> CMY
     //    C = ( C * (1 - K) + K )      // for each CMY component
@@ -294,9 +294,9 @@
        a significant performance boost.
     */
     if (sampleSize == 1 &&
-        ((config == SkBitmap::kARGB_8888_Config && 
+        ((config == SkBitmap::kARGB_8888_Config &&
                 cinfo.out_color_space == JCS_RGBA_8888) ||
-        (config == SkBitmap::kRGB_565_Config && 
+        (config == SkBitmap::kRGB_565_Config &&
                 cinfo.out_color_space == JCS_RGB_565)))
     {
         bm->setConfig(config, cinfo.output_width, cinfo.output_height);
@@ -310,7 +310,7 @@
         SkAutoLockPixels alp(*bm);
         JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels();
         INT32 const bpr =  bm->rowBytes();
-        
+
         while (cinfo.output_scanline < cinfo.output_height) {
             int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
             // if row_count == 0, then we didn't get a scanline, so abort.
diff --git a/src/images/SkImageDecoder_libpng.cpp b/src/images/SkImageDecoder_libpng.cpp
index 8fe3423..d48bce5 100644
--- a/src/images/SkImageDecoder_libpng.cpp
+++ b/src/images/SkImageDecoder_libpng.cpp
@@ -27,7 +27,7 @@
     virtual Format getFormat() const {
         return kPNG_Format;
     }
-    
+
 protected:
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
 };
@@ -85,7 +85,7 @@
 
 static bool substituteTranspColor(SkBitmap* bm, SkPMColor match) {
     SkASSERT(bm->config() == SkBitmap::kARGB_8888_Config);
-    
+
     bool reallyHasAlpha = false;
 
     for (int y = bm->height() - 1; y >= 0; --y) {
@@ -195,18 +195,18 @@
     if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
         png_set_expand_gray_1_2_4_to_8(png_ptr);
     }
-    
+
     /* Make a grayscale image into RGB. */
     if (color_type == PNG_COLOR_TYPE_GRAY ||
         color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
         png_set_gray_to_rgb(png_ptr);
     }
-        
+
     SkBitmap::Config    config;
     bool                hasAlpha = false;
     bool                doDither = this->getDitherImage();
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
-    
+
     // check for sBIT chunk data, in case we should disable dithering because
     // our data is not truely 8bits per component
     if (doDither) {
@@ -226,7 +226,7 @@
             doDither = false;
         }
     }
-    
+
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
         config = this->getPrefConfig(kIndex_SrcDepth, paletteHasAlpha);
@@ -237,11 +237,11 @@
     } else {
         png_color_16p   transpColor = NULL;
         int             numTransp = 0;
-        
+
         png_get_tRNS(png_ptr, info_ptr, NULL, &numTransp, &transpColor);
-        
+
         bool valid = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS);
-        
+
         if (valid && numTransp == 1 && transpColor != NULL) {
             /*  Compute our transparent color, which we'll match against later.
                 We don't really handle 16bit components properly here, since we
@@ -304,7 +304,7 @@
     if (!this->chooseFromOneChoice(config, origWidth, origHeight)) {
         return false;
     }
-    
+
     const int sampleSize = this->getSampleSize();
     SkScaledBitmapSampler sampler(origWidth, origHeight, sampleSize);
 
@@ -313,7 +313,7 @@
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
-    
+
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
@@ -329,9 +329,9 @@
         int num_trans;
 
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
-        
+
         /*  BUGGY IMAGE WORKAROUND
-            
+
             We hit some images (e.g. fruit_.png) who contain bytes that are == colortable_count
             which is a problem since we use the byte as an index. To work around this we grow
             the colortable by 1 (if its < 256) and duplicate the last color into that slot.
@@ -347,7 +347,7 @@
         } else {
             num_trans = 0;
             colorTable->setFlags(colorTable->getFlags() | SkColorTable::kColorsAreOpaque_Flag);
-        }        
+        }
         // check for bad images that might make us crash
         if (num_trans > num_palette) {
             num_trans = num_palette;
@@ -374,7 +374,7 @@
         }
         colorTable->unlockColors(true);
     }
-    
+
     SkAutoUnref aur(colorTable);
 
     if (!this->allocPixelRef(decodedBitmap,
@@ -382,7 +382,7 @@
                                 colorTable : NULL)) {
         return false;
     }
-    
+
     SkAutoLockPixels alp(*decodedBitmap);
 
     /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
@@ -401,7 +401,7 @@
     * png_read_image().  To see how to handle interlacing passes,
     * see the png_read_row() method below:
     */
-    const int number_passes = interlace_type != PNG_INTERLACE_NONE ? 
+    const int number_passes = interlace_type != PNG_INTERLACE_NONE ?
                         png_set_interlace_handling(png_ptr) : 1;
 
     /* Optional call to gamma correct and add the background to the palette
@@ -420,7 +420,7 @@
     } else {
         SkScaledBitmapSampler::SrcConfig sc;
         int srcBytesPerPixel = 4;
-        
+
         if (colorTable != NULL) {
             sc = SkScaledBitmapSampler::kIndex;
             srcBytesPerPixel = 1;
@@ -508,7 +508,7 @@
 
 static void transform_scanline_565(const char* SK_RESTRICT src, int width,
                                    char* SK_RESTRICT dst) {
-    const uint16_t* SK_RESTRICT srcP = (const uint16_t*)src;    
+    const uint16_t* SK_RESTRICT srcP = (const uint16_t*)src;
     for (int i = 0; i < width; i++) {
         unsigned c = *srcP++;
         *dst++ = SkPacked16ToR32(c);
@@ -519,7 +519,7 @@
 
 static void transform_scanline_888(const char* SK_RESTRICT src, int width,
                                    char* SK_RESTRICT dst) {
-    const SkPMColor* SK_RESTRICT srcP = (const SkPMColor*)src;    
+    const SkPMColor* SK_RESTRICT srcP = (const SkPMColor*)src;
     for (int i = 0; i < width; i++) {
         SkPMColor c = *srcP++;
         *dst++ = SkGetPackedR32(c);
@@ -530,7 +530,7 @@
 
 static void transform_scanline_444(const char* SK_RESTRICT src, int width,
                                    char* SK_RESTRICT dst) {
-    const SkPMColor16* SK_RESTRICT srcP = (const SkPMColor16*)src;    
+    const SkPMColor16* SK_RESTRICT srcP = (const SkPMColor16*)src;
     for (int i = 0; i < width; i++) {
         SkPMColor16 c = *srcP++;
         *dst++ = SkPacked4444ToR32(c);
@@ -542,7 +542,7 @@
 static void transform_scanline_8888(const char* SK_RESTRICT src, int width,
                                     char* SK_RESTRICT dst) {
     const SkPMColor* SK_RESTRICT srcP = (const SkPMColor*)src;
-    const SkUnPreMultiply::Scale* SK_RESTRICT table = 
+    const SkUnPreMultiply::Scale* SK_RESTRICT table =
                                               SkUnPreMultiply::GetScaleTable();
 
     for (int i = 0; i < width; i++) {
@@ -568,7 +568,7 @@
 static void transform_scanline_4444(const char* SK_RESTRICT src, int width,
                                     char* SK_RESTRICT dst) {
     const SkPMColor16* SK_RESTRICT srcP = (const SkPMColor16*)src;
-    const SkUnPreMultiply::Scale* SK_RESTRICT table = 
+    const SkUnPreMultiply::Scale* SK_RESTRICT table =
                                               SkUnPreMultiply::GetScaleTable();
 
     for (int i = 0; i < width; i++) {
@@ -603,7 +603,7 @@
     if (SkBitmap::kIndex8_Config == config) {
         hasAlpha = false;   // we store false in the table entries for kIndex8
     }
-    
+
     static const struct {
         SkBitmap::Config        fConfig;
         bool                    fHasAlpha;
@@ -644,7 +644,7 @@
 /*  Pack palette[] with the corresponding colors, and if hasAlpha is true, also
     pack trans[] and return the number of trans[] entries written. If hasAlpha
     is false, the return value will always be 0.
- 
+
     Note: this routine takes care of unpremultiplying the RGB values when we
     have alpha in the colortable, since png doesn't support premul colors
 */
@@ -672,7 +672,7 @@
             }
             num_trans -= 1;
         }
-        
+
         const SkUnPreMultiply::Scale* SK_RESTRICT table =
                                             SkUnPreMultiply::GetScaleTable();
 
@@ -684,11 +684,11 @@
             palette[i].red = SkUnPreMultiply::ApplyScale(s, SkGetPackedR32(c));
             palette[i].green = SkUnPreMultiply::ApplyScale(s,SkGetPackedG32(c));
             palette[i].blue = SkUnPreMultiply::ApplyScale(s, SkGetPackedB32(c));
-        }        
+        }
         // now fall out of this if-block to use common code for the trailing
         // opaque entries
     }
-    
+
     // these (remaining) entries are opaque
     for (i = num_trans; i < ctCount; i++) {
         SkPMColor c = *colors++;
@@ -743,7 +743,7 @@
         default:
             return false;
     }
-    
+
     if (hasAlpha) {
         // don't specify alpha if we're a palette, even if our ctable has alpha
         if (!(colorType & PNG_COLOR_MASK_PALETTE)) {
@@ -752,7 +752,7 @@
     } else {
         sig_bit.alpha = 0;
     }
-    
+
     SkAutoLockPixels alp(bitmap);
     // readyToDraw checks for pixels (and colortable if that is required)
     if (!bitmap.readyToDraw()) {
diff --git a/src/images/SkImageDecoder_wbmp.cpp b/src/images/SkImageDecoder_wbmp.cpp
index fedeedb..175a444 100644
--- a/src/images/SkImageDecoder_wbmp.cpp
+++ b/src/images/SkImageDecoder_wbmp.cpp
@@ -20,7 +20,7 @@
     virtual Format getFormat() const {
         return kWBMP_Format;
     }
-    
+
 protected:
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
 };
@@ -40,7 +40,7 @@
         }
         n = (n << 7) | (data & 0x7F);
     } while (data & 0x80);
-    
+
     *value = n;
     return true;
 }
@@ -48,11 +48,11 @@
 struct wbmp_head {
     int fWidth;
     int fHeight;
-    
+
     bool init(SkStream* stream)
     {
         uint8_t data;
-        
+
         if (!read_byte(stream, &data) || data != 0) { // unknown type
             return false;
         }
@@ -68,11 +68,11 @@
         return fWidth != 0 && fHeight != 0;
     }
 };
-    
+
 static void expand_bits_to_bytes(uint8_t dst[], const uint8_t src[], int bits)
 {
     int bytes = bits >> 3;
-    
+
     for (int i = 0; i < bytes; i++) {
         unsigned mask = *src++;
         dst[0] = (mask >> 7) & 1;
@@ -85,14 +85,14 @@
         dst[7] = (mask >> 0) & 1;
         dst += 8;
     }
-    
+
     bits &= 7;
     if (bits > 0) {
         unsigned mask = *src;
         do {
             *dst++ = (mask >> 7) & 1;;
             mask <<= 1;
-        } while (--bits != 0);    
+        } while (--bits != 0);
     }
 }
 
@@ -100,21 +100,21 @@
                                   Mode mode)
 {
     wbmp_head   head;
-    
+
     if (!head.init(stream)) {
         return false;
     }
-        
+
     int width = head.fWidth;
     int height = head.fHeight;
-    
+
     // assign these directly, in case we return kDimensions_Result
     decodedBitmap->setConfig(SkBitmap::kIndex8_Config, width, height);
     decodedBitmap->setIsOpaque(true);
-    
+
     if (SkImageDecoder::kDecodeBounds_Mode == mode)
         return true;
-    
+
     const SkPMColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
     SkColorTable* ct = SkNEW_ARGS(SkColorTable, (colors, 2));
     SkAutoUnref   aur(ct);
diff --git a/src/images/SkImageRefPool.cpp b/src/images/SkImageRefPool.cpp
index c24dba0..b8bbfd2 100644
--- a/src/images/SkImageRefPool.cpp
+++ b/src/images/SkImageRefPool.cpp
@@ -56,7 +56,7 @@
 
 void SkImageRefPool::setRAMUsed(size_t limit) {
     SkImageRef* ref = fTail;
-    
+
     while (NULL != ref && fRAMUsed > limit) {
         // only purge it if its pixels are unlocked
         if (!ref->isLocked() && ref->fBitmap.getPixels()) {
@@ -71,7 +71,7 @@
                      ref->fBitmap.bytesPerPixel(),
                      (int)size, (int)fRAMUsed);
 #endif
-            
+
             // remember the bitmap config (don't call reset),
             // just clear the pixel memory
             ref->fBitmap.setPixels(NULL);
@@ -86,44 +86,44 @@
 void SkImageRefPool::addToHead(SkImageRef* ref) {
     ref->fNext = fHead;
     ref->fPrev = NULL;
-    
+
     if (fHead) {
         SkASSERT(NULL == fHead->fPrev);
         fHead->fPrev = ref;
     }
     fHead = ref;
-    
+
     if (NULL == fTail) {
         fTail = ref;
     }
     fCount += 1;
     SkASSERT(computeCount() == fCount);
-    
+
     fRAMUsed += ref->ramUsed();
 }
 
 void SkImageRefPool::addToTail(SkImageRef* ref) {
     ref->fNext = NULL;
     ref->fPrev = fTail;
-    
+
     if (fTail) {
         SkASSERT(NULL == fTail->fNext);
         fTail->fNext = ref;
     }
     fTail = ref;
-    
+
     if (NULL == fHead) {
         fHead = ref;
     }
     fCount += 1;
     SkASSERT(computeCount() == fCount);
-    
+
     fRAMUsed += ref->ramUsed();
 }
 
 void SkImageRefPool::detach(SkImageRef* ref) {
     SkASSERT(fCount > 0);
-    
+
     if (fHead == ref) {
         fHead = ref->fNext;
     }
@@ -136,12 +136,12 @@
     if (ref->fNext) {
         ref->fNext->fPrev = ref->fPrev;
     }
-    
+
     ref->fNext = ref->fPrev = NULL;
-    
+
     fCount -= 1;
     SkASSERT(computeCount() == fCount);
-    
+
     SkASSERT(fRAMUsed >= ref->ramUsed());
     fRAMUsed -= ref->ramUsed();
 }
@@ -149,23 +149,23 @@
 int SkImageRefPool::computeCount() const {
     SkImageRef* ref = fHead;
     int count = 0;
-    
+
     while (ref != NULL) {
         count += 1;
         ref = ref->fNext;
     }
-    
+
 #ifdef SK_DEBUG
     ref = fTail;
     int count2 = 0;
-    
+
     while (ref != NULL) {
         count2 += 1;
         ref = ref->fPrev;
     }
     SkASSERT(count2 == count);
 #endif
-    
+
     return count;
 }
 
@@ -177,15 +177,15 @@
 #if defined(SK_DEBUG) || defined(DUMP_IMAGEREF_LIFECYCLE)
     SkDebugf("ImagePool dump: bugdet: %d used: %d count: %d\n",
              (int)fRAMBudget, (int)fRAMUsed, fCount);
-    
+
     SkImageRef* ref = fHead;
-    
+
     while (ref != NULL) {
         SkDebugf("  [%3d %3d %d] ram=%d data=%d locked=%d %s\n", ref->fBitmap.width(),
                  ref->fBitmap.height(), ref->fBitmap.config(),
                  ref->ramUsed(), (int)ref->fStream->getLength(),
                  ref->isLocked(), ref->getURI());
-        
+
         ref = ref->fNext;
     }
 #endif
diff --git a/src/images/SkImageRefPool.h b/src/images/SkImageRefPool.h
index d29b8db..08633ee 100644
--- a/src/images/SkImageRefPool.h
+++ b/src/images/SkImageRefPool.h
@@ -17,30 +17,30 @@
 public:
     SkImageRefPool();
     ~SkImageRefPool();
-    
+
     size_t  getRAMBudget() const { return fRAMBudget; }
     void    setRAMBudget(size_t);
-    
+
     size_t  getRAMUsed() const { return fRAMUsed; }
     void    setRAMUsed(size_t limit);
-    
+
     void addToHead(SkImageRef*);
     void addToTail(SkImageRef*);
     void detach(SkImageRef*);
 
     void dump() const;
-    
+
 private:
     size_t fRAMBudget;
     size_t fRAMUsed;
-    
+
     int         fCount;
     SkImageRef* fHead, *fTail;
-    
+
     int computeCount() const;
-    
+
     friend class SkImageRef_GlobalPool;
-    
+
     void justAddedPixels(SkImageRef*);
     void canLosePixels(SkImageRef*);
     void purgeIfNeeded();
diff --git a/src/images/SkImageRef_GlobalPool.cpp b/src/images/SkImageRef_GlobalPool.cpp
index bd63f72..a5a71a3 100644
--- a/src/images/SkImageRef_GlobalPool.cpp
+++ b/src/images/SkImageRef_GlobalPool.cpp
@@ -56,10 +56,10 @@
     }
     return true;
 }
-    
+
 void SkImageRef_GlobalPool::onUnlockPixels() {
     this->INHERITED::onUnlockPixels();
-    
+
     // by design, onUnlockPixels() already is inside the mutex-lock
     GetGlobalPool()->canLosePixels(this);
 }
@@ -87,7 +87,7 @@
 }
 
 size_t SkImageRef_GlobalPool::GetRAMUsed() {
-    SkAutoMutexAcquire ac(gImageRefMutex);    
+    SkAutoMutexAcquire ac(gImageRefMutex);
     return GetGlobalPool()->getRAMUsed();
 }
 
diff --git a/src/images/SkMovie.cpp b/src/images/SkMovie.cpp
index 978cd16..e671950 100644
--- a/src/images/SkMovie.cpp
+++ b/src/images/SkMovie.cpp
@@ -57,7 +57,7 @@
     SkMSec dur = this->duration();
     if (time > dur)
         time = dur;
-        
+
     bool changed = false;
     if (time != fCurrTime)
     {
diff --git a/src/images/SkMovie_gif.cpp b/src/images/SkMovie_gif.cpp
index 91d3591..9cebc0f 100644
--- a/src/images/SkMovie_gif.cpp
+++ b/src/images/SkMovie_gif.cpp
@@ -25,7 +25,7 @@
     virtual bool onGetInfo(Info*);
     virtual bool onSetTime(SkMSec);
     virtual bool onGetBitmap(SkBitmap*);
-    
+
 private:
     GifFileType* fGIF;
     int fCurrIndex;
diff --git a/src/images/SkPageFlipper.cpp b/src/images/SkPageFlipper.cpp
index 8e51e63..4fd8632 100644
--- a/src/images/SkPageFlipper.cpp
+++ b/src/images/SkPageFlipper.cpp
@@ -32,7 +32,7 @@
 void SkPageFlipper::resize(int width, int height) {
     fWidth = width;
     fHeight = height;
-    
+
     // this is the opposite of the constructors
     fDirty1->setRect(0, 0, width, height);
     fDirty0->setEmpty();
diff --git a/src/images/SkScaledBitmapSampler.cpp b/src/images/SkScaledBitmapSampler.cpp
index 15633d3..25b32fd 100644
--- a/src/images/SkScaledBitmapSampler.cpp
+++ b/src/images/SkScaledBitmapSampler.cpp
@@ -302,7 +302,7 @@
     if (width <= 0 || height <= 0) {
         sk_throw();
     }
-    
+
     if (sampleSize <= 1) {
         fScaledWidth = width;
         fScaledHeight = height;
@@ -310,25 +310,25 @@
         fDX = fDY = 1;
         return;
     }
-    
+
     int dx = SkMin32(sampleSize, width);
     int dy = SkMin32(sampleSize, height);
-    
+
     fScaledWidth = width / dx;
     fScaledHeight = height / dy;
-    
+
     SkASSERT(fScaledWidth > 0);
     SkASSERT(fScaledHeight > 0);
-    
+
     fX0 = dx >> 1;
     fY0 = dy >> 1;
-    
+
     SkASSERT(fX0 >= 0 && fX0 < width);
     SkASSERT(fY0 >= 0 && fY0 < height);
-    
+
     fDX = dx;
     fDY = dy;
-    
+
     SkASSERT(fDX > 0 && (fX0 + fDX * (fScaledWidth - 1)) < width);
     SkASSERT(fDY > 0 && (fY0 + fDY * (fScaledHeight - 1)) < height);
 }
@@ -413,7 +413,7 @@
         default:
             return false;
     }
-    
+
     fRowProc = gProcs[index];
     fDstRow = (char*)dst->getPixels();
     fDstRowBytes = dst->rowBytes();
diff --git a/src/images/SkScaledBitmapSampler.h b/src/images/SkScaledBitmapSampler.h
index 8a735df..f6de4cc 100644
--- a/src/images/SkScaledBitmapSampler.h
+++ b/src/images/SkScaledBitmapSampler.h
@@ -16,10 +16,10 @@
 class SkScaledBitmapSampler {
 public:
     SkScaledBitmapSampler(int origWidth, int origHeight, int cellSize);
-    
+
     int scaledWidth() const { return fScaledWidth; }
     int scaledHeight() const { return fScaledHeight; }
-    
+
     int srcY0() const { return fY0; }
     int srcDY() const { return fDY; }
 
@@ -59,7 +59,7 @@
     char*   fDstRow; // points into bitmap's pixels
     int     fDstRowBytes;
     int     fCurrY; // used for dithering
-    int     fSrcPixelSize;  // 1, 3, 4    
+    int     fSrcPixelSize;  // 1, 3, 4
     RowProc fRowProc;
 
     // optional reference to the src colors if the src is a palette model
diff --git a/src/images/bmpdecoderhelper.h b/src/images/bmpdecoderhelper.h
index f3324ee..f2f4109 100644
--- a/src/images/bmpdecoderhelper.h
+++ b/src/images/bmpdecoderhelper.h
@@ -32,14 +32,14 @@
   ~scoped_array() {
     delete[] ptr_;
   }
-  
+
   void reset(T* p = 0) {
     if (p != ptr_) {
       delete[] ptr_;
       ptr_ = p;
     }
   }
-  
+
   T& operator[](int i) const {
     return ptr_[i];
   }
@@ -53,7 +53,7 @@
  public:
   BmpDecoderCallback() { }
   virtual ~BmpDecoderCallback() {}
-  
+
   /**
    * This is called once for an image. It is passed the width and height and
    * should return the address of a buffer that is large enough to store
@@ -62,7 +62,7 @@
    * valid dimensions.
    */
   virtual uint8* SetSize(int width, int height) = 0;
-   
+
  private:
   DISALLOW_EVIL_CONSTRUCTORS(BmpDecoderCallback);
 };
@@ -110,7 +110,7 @@
   uint8* output_;
   bool inverted_;
 };
-  
+
 } // namespace
 
 #endif
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 9f0177e..5cb801f 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -469,7 +469,7 @@
 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
                           const SkPDFGlyphSet* subset,
                           SkDynamicMemoryWStream* cmap);
-                          
+
 void append_cmap_sections(const SkTDArray<SkUnichar>& glyphToUnicode,
                           const SkPDFGlyphSet* subset,
                           SkDynamicMemoryWStream* cmap) {
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
index 09a4352..e6f1d7f 100644
--- a/src/pdf/SkPDFShader.cpp
+++ b/src/pdf/SkPDFShader.cpp
@@ -275,14 +275,14 @@
 }
 
 /* Conical gradient shader, based on the Canvas spec for radial gradients
-   See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient 
+   See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient
  */
 static SkString twoPointConicalCode(const SkShader::GradientInfo& info) {
     SkScalar dx = info.fPoint[1].fX - info.fPoint[0].fX;
     SkScalar dy = info.fPoint[1].fY - info.fPoint[0].fY;
     SkScalar r0 = info.fRadius[0];
     SkScalar dr = info.fRadius[1] - info.fRadius[0];
-    SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - 
+    SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) -
                  SkScalarMul(dr, dr);
 
     // First compute t, if the pixel falls outside the cone, then we'll end
@@ -327,7 +327,7 @@
 
         // quadratic case: the Canvas spec wants the largest
         // root t for which radius(t) > 0
-        
+
         // compute the discriminant (b^2 - 4ac)
         function.appendScalar(SkScalarMul(SkIntToScalar(4), a));
         function.append(" mul sub dup\n");
diff --git a/src/pdf/SkPDFTypes.h b/src/pdf/SkPDFTypes.h
index 7d24940..28034ef 100644
--- a/src/pdf/SkPDFTypes.h
+++ b/src/pdf/SkPDFTypes.h
@@ -113,7 +113,7 @@
 
 private:
     SkRefPtr<SkPDFObject> fObj;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -137,7 +137,7 @@
 
 private:
     int32_t fValue;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -162,7 +162,7 @@
 
 private:
     bool fValue;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -188,7 +188,7 @@
 
 private:
     SkScalar fValue;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -262,7 +262,7 @@
     const SkString fValue;
 
     static SkString FormatName(const SkString& input);
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -329,7 +329,7 @@
 private:
     static const int kMaxLen = 8191;
     SkTDArray<SkPDFObject*> fValue;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
@@ -427,7 +427,7 @@
     static const int kMaxLen = 4095;
 
     SkTDArray<struct Rec> fValue;
-    
+
     typedef SkPDFObject INHERITED;
 };
 
diff --git a/src/pipe/SkGPipePriv.h b/src/pipe/SkGPipePriv.h
index edfe2b6..207a3bd 100644
--- a/src/pipe/SkGPipePriv.h
+++ b/src/pipe/SkGPipePriv.h
@@ -212,7 +212,7 @@
 
 enum PaintOps {
     kReset_PaintOp,     // no arg
-    
+
     kFlags_PaintOp,     // arg inline
     kColor_PaintOp,     // arg 32
     kStyle_PaintOp,     // arg inline
@@ -220,7 +220,7 @@
     kCap_PaintOp,       // arg inline
     kWidth_PaintOp,     // arg scalar
     kMiter_PaintOp,// arg scalar
-    
+
     kEncoding_PaintOp,  // arg inline - text
     kHinting_PaintOp,   // arg inline - text
     kAlign_PaintOp,     // arg inline - text
@@ -254,14 +254,14 @@
 
 static inline uint32_t PaintOp_packOp(PaintOps op) {
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
-    
+
     return op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS);
 }
 
 static inline uint32_t PaintOp_packOpData(PaintOps op, unsigned data) {
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
     SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
-    
+
     return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) | data;
 }
 
@@ -269,7 +269,7 @@
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
     SkASSERT(0 == (flags & ~PAINTOPS_FLAG_MASK));
     SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
-    
+
     return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) |
     (flags << PAINTOPS_DATA_BITS) |
     data;
diff --git a/src/pipe/SkGPipeRead.cpp b/src/pipe/SkGPipeRead.cpp
index d217aeb..ce83c83 100644
--- a/src/pipe/SkGPipeRead.cpp
+++ b/src/pipe/SkGPipeRead.cpp
@@ -85,7 +85,7 @@
 
     const SkPaint& paint() const { return fPaint; }
     SkPaint* editPaint() { return &fPaint; }
-    
+
     SkFlattenable* getFlat(unsigned index) const {
         if (0 == index) {
             return NULL;
@@ -151,12 +151,12 @@
         const void* data = fReader->skip(SkAlign4(size));
         SkMemoryStream stream(data, size, false);
         *fTypefaces.append() = SkTypeface::Deserialize(&stream);
-    }    
+    }
 
     void setTypeface(SkPaint* paint, unsigned id) {
         paint->setTypeface(id ? fTypefaces[id - 1] : NULL);
     }
-    
+
 private:
     void updateReader() {
         if (NULL == fReader) {
@@ -720,7 +720,7 @@
         uint32_t op32 = reader.readUInt();
         unsigned op = DrawOp_unpackOp(op32);
         // SkDEBUGCODE(DrawOps drawOp = (DrawOps)op;)
-        
+
         if (op >= SK_ARRAY_COUNT(gReadTable)) {
             SkDebugf("---- bad op during GPipeState::playback\n");
             status = kError_Status;
@@ -731,7 +731,7 @@
             break;
         }
         table[op](canvas, reader.getReader32(), op32, fState);
-        if (readAtom && 
+        if (readAtom &&
             (table[op] != paintOp_rp &&
              table[op] != def_Typeface_rp &&
              table[op] != def_PaintFlat_rp &&
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index 42f82c9..b41ebb7 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -84,7 +84,7 @@
     void setBitmapStorage(SkBitmapHeap* heap) {
         this->setBitmapHeap(heap);
     }
-    
+
     const SkFlatData* flatToReplace() const;
 
     // Mark an SkFlatData as one that should not be returned by flatToReplace.
@@ -385,11 +385,11 @@
 class BitmapShuttle : public SkBitmapHeap::ExternalStorage {
 public:
     BitmapShuttle(SkGPipeCanvas*);
-    
+
     ~BitmapShuttle();
-    
+
     virtual bool insert(const SkBitmap& bitmap, int32_t slot) SK_OVERRIDE;
-    
+
 private:
     SkGPipeCanvas*    fCanvas;
 };
@@ -401,7 +401,7 @@
 #define FLATTENABLES_TO_KEEP 10
 
 SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
-                             SkWriter32* writer, uint32_t flags, 
+                             SkWriter32* writer, uint32_t flags,
                              uint32_t width, uint32_t height)
 : fFactorySet(isCrossProcess(flags) ? SkNEW(SkNamedFactorySet) : NULL)
 , fWriter(*writer)
@@ -426,7 +426,7 @@
     if (this->needOpBytes()) {
         this->writeOp(kReportFlags_DrawOp, fFlags, 0);
     }
-    
+
     if (shouldFlattenBitmaps(flags)) {
         BitmapShuttle* shuttle = SkNEW_ARGS(BitmapShuttle, (this));
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap, (shuttle, BITMAPS_TO_KEEP));
@@ -744,7 +744,7 @@
     } else {
         flags = 0;
     }
-    
+
     if (this->commonDrawBitmap(bm, kDrawBitmapRect_DrawOp, flags, opBytesNeeded, paint)) {
         if (hasSrc) {
             fWriter.write32(src->fLeft);
@@ -760,7 +760,7 @@
                                      const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = matrix.writeToMemory(NULL);
-    
+
     if (this->commonDrawBitmap(bm, kDrawBitmapMatrix_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.writeMatrix(matrix);
     }
@@ -939,7 +939,7 @@
     doNotify();
     if (detachCurrentBlock) {
         // force a new block to be requested for the next recorded command
-        fBlockSize = 0; 
+        fBlockSize = 0;
     }
 }
 
diff --git a/src/ports/SkFontDescriptor.cpp b/src/ports/SkFontDescriptor.cpp
index 34f4f17..7679d92 100644
--- a/src/ports/SkFontDescriptor.cpp
+++ b/src/ports/SkFontDescriptor.cpp
@@ -13,7 +13,7 @@
     kFontFamilyName = 0x01,
     kFullName       = 0x04,
     kPostscriptName = 0x06,
-    
+
     // These count backwards from 0xFF, so as not to collide with the SFNT
     // defines for names in its 'name' table.
     kFontFileName   = 0xFE,
diff --git a/src/ports/SkFontDescriptor.h b/src/ports/SkFontDescriptor.h
index b226029..5febfd8 100644
--- a/src/ports/SkFontDescriptor.h
+++ b/src/ports/SkFontDescriptor.h
@@ -28,7 +28,7 @@
     const char* getFullName() { return fFullName.c_str(); }
     const char* getPostscriptName() { return fPostscriptName.c_str(); }
     const char* getFontFileName() { return fFontFileName.c_str(); }
-    
+
     void setFamilyName(const char* name) { fFamilyName.set(name); }
     void setFullName(const char* name) { fFullName.set(name); }
     void setPostscriptName(const char* name) { fPostscriptName.set(name); }
diff --git a/src/ports/SkFontHost_FONTPATH.cpp b/src/ports/SkFontHost_FONTPATH.cpp
index 04e4934..69e73f5 100644
--- a/src/ports/SkFontHost_FONTPATH.cpp
+++ b/src/ports/SkFontHost_FONTPATH.cpp
@@ -14,14 +14,14 @@
 #include <stdio.h>
 
 /* define this if we can use mmap() to access fonts from the filesystem */
-#define SK_CAN_USE_MMAP 
+#define SK_CAN_USE_MMAP
 
 #ifndef SK_FONTPATH
     #define SK_FONTPATH "the complete path for a font file"
 #endif
 
 struct FontFaceRec {
-    const char* fFileName;    
+    const char* fFileName;
     uint8_t     fFamilyIndex;
     SkBool8     fBold;
     SkBool8     fItalic;
@@ -39,7 +39,7 @@
                                          int isBold, int isItalic)
 {
     SkASSERT(count > 0);
-    
+
     int i;
 
     // look for an exact match
@@ -63,7 +63,7 @@
 
 enum {
     DEFAULT_FAMILY_INDEX,
-    
+
     FAMILY_INDEX_COUNT
 };
 
@@ -236,7 +236,7 @@
                                        SkTypeface::Style style)
 {
     const FontFamilyRec* family;
-    
+
     if (familyFace)
         family = &gFamilies[
                     ((FontFaceRec_Typeface*)familyFace)->fFace.fFamilyIndex];
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index 550fae0..45ae7ec 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -610,7 +610,7 @@
     if (rec->fTextSize > SkIntToScalar(1 << 14)) {
       rec->fTextSize = SkIntToScalar(1 << 14);
     }
-    
+
     if (!gLCDSupportValid) {
         InitFreetype();
         FT_Done_FreeType(gFTLibrary);
diff --git a/src/ports/SkFontHost_FreeType_common.cpp b/src/ports/SkFontHost_FreeType_common.cpp
index 91f172b..332b8c4 100644
--- a/src/ports/SkFontHost_FreeType_common.cpp
+++ b/src/ports/SkFontHost_FreeType_common.cpp
@@ -89,7 +89,7 @@
                         SkTSwap(srcR, srcB);
                     }
                     for (int x = 0; x < width; x++) {
-                        dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(*srcR++, tableR), 
+                        dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(*srcR++, tableR),
                                             sk_apply_lut_if<APPLY_PREBLEND>(*srcG++, tableG),
                                             sk_apply_lut_if<APPLY_PREBLEND>(*srcB++, tableB));
                     }
@@ -98,14 +98,14 @@
                     const uint8_t* triple = src;
                     if (lcdIsBGR) {
                         for (int x = 0; x < width; x++) {
-                            dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(triple[2], tableR), 
+                            dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(triple[2], tableR),
                                                 sk_apply_lut_if<APPLY_PREBLEND>(triple[1], tableG),
                                                 sk_apply_lut_if<APPLY_PREBLEND>(triple[0], tableB));
                             triple += 3;
                         }
                     } else {
                         for (int x = 0; x < width; x++) {
-                            dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(triple[0], tableR), 
+                            dst[x] = packTriple(sk_apply_lut_if<APPLY_PREBLEND>(triple[0], tableR),
                                                 sk_apply_lut_if<APPLY_PREBLEND>(triple[1], tableG),
                                                 sk_apply_lut_if<APPLY_PREBLEND>(triple[2], tableB));
                             triple += 3;
@@ -302,7 +302,7 @@
     if (SkMask::kA8_Format == glyph.fMaskFormat && maskPreBlend) {
         uint8_t* SK_RESTRICT dst = (uint8_t*)glyph.fImage;
         unsigned rowBytes = glyph.rowBytes();
-        
+
         for (int y = glyph.fHeight - 1; y >= 0; --y) {
             for (int x = glyph.fWidth - 1; x >= 0; --x) {
                 dst[x] = tableG[dst[x]];
diff --git a/src/ports/SkFontHost_ascender.cpp b/src/ports/SkFontHost_ascender.cpp
index ccfedef..067d474 100644
--- a/src/ports/SkFontHost_ascender.cpp
+++ b/src/ports/SkFontHost_ascender.cpp
@@ -52,20 +52,20 @@
 {
     int size = aca_Get_FontHandleRec_Size();
     fHandle = (aca_FontHandle)sk_malloc_throw(size);
-    
+
     // get the pointer to the font
-    
+
     fFontStream = new SkMMAPStream("/UcsGB2312-Hei-H.FDL");
     fHintStream = new SkMMAPStream("/genv6-23.bin");
-    
+
     void* hints = sk_malloc_throw(fHintStream->getLength());
     memcpy(hints, fHintStream->getMemoryBase(), fHintStream->getLength());
-    
+
     aca_Create_Font_Handle(fHandle,
                            (void*)fFontStream->getMemoryBase(), fFontStream->getLength(),
                            "fred",
                            hints, fHintStream->getLength());
-    
+
     // compute our factors from the record
 
     SkMatrix    m;
@@ -75,17 +75,17 @@
     //  now compute our scale factors
     SkScalar    sx = m.getScaleX();
     SkScalar    sy = m.getScaleY();
-    
+
     int ppemX = SkScalarRound(sx);
     int ppemY = SkScalarRound(sy);
-    
+
     size = aca_Find_Font_Memory_Required(fHandle, ppemX, ppemY);
     size *= 8;  // Jeff suggests this :)
     fWorkspace = sk_malloc_throw(size);
     aca_Set_Font_Memory(fHandle, (uint8_t*)fWorkspace, size);
 
     aca_GlyphAttribsRec rec;
-    
+
     memset(&rec, 0, sizeof(rec));
     rec.xSize = ppemX;
     rec.ySize = ppemY;
@@ -95,7 +95,7 @@
     rec.doInterpolate = true;
     rec.grayMode = 2;
     aca_Set_Font_Attributes(fHandle, &rec, &size);
-    
+
     fGlyphWorkspace = sk_malloc_throw(size);
     aca_Set_Glyph_Memory(fHandle, fGlyphWorkspace);
 }
@@ -123,10 +123,10 @@
 {
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
-    
+
     aca_GlyphImageRec   rec;
     aca_Vector          topLeft;
-    
+
     int adv = aca_Get_Adv_Width(fHandle, glyph->getGlyphID());
     if (aca_GLYPH_NOT_PRESENT == adv)
         goto ERROR;
@@ -144,7 +144,7 @@
         glyph->fAdvanceY = 0;
         return;
     }
-    
+
     glyph->fWidth = rec.width;
     glyph->fHeight = rec.rows;
     glyph->fRowBytes = rec.width;
@@ -158,13 +158,13 @@
 {
     aca_GlyphImageRec   rec;
     aca_Vector          topLeft;
-    
+
     aca_Rasterize(glyph.getGlyphID(), fHandle, &rec, &topLeft);
-    
+
     const uint8_t* src = (const uint8_t*)rec.buffer;
     uint8_t* dst = (uint8_t*)glyph.fImage;
     int height = glyph.fHeight;
-    
+
     src += rec.y0 * rec.pitch + rec.x0;
     while (--height >= 0)
     {
@@ -179,7 +179,7 @@
 void SkScalerContext_Ascender::generatePath(const SkGlyph& glyph, SkPath* path)
 {
     SkRect r;
-    
+
     r.set(0, 0, SkIntToScalar(4), SkIntToScalar(4));
     path->reset();
     path->addRect(r);
diff --git a/src/ports/SkFontHost_freetype_mac.cpp b/src/ports/SkFontHost_freetype_mac.cpp
index 8b1272a..652fb46 100644
--- a/src/ports/SkFontHost_freetype_mac.cpp
+++ b/src/ports/SkFontHost_freetype_mac.cpp
@@ -22,7 +22,7 @@
         fStream->unref();
     }
 
-    SkStream* fStream;    
+    SkStream* fStream;
 };
 
 static FTMacTypeface* create_from_path(const char path[]) {
@@ -42,7 +42,7 @@
     if (NULL == gDef) {
         gDef = create_from_path(FONT_PATH);
     }
-    
+
     gDef->ref();
     return gDef;
 }
diff --git a/src/ports/SkFontHost_mac_coretext.cpp b/src/ports/SkFontHost_mac_coretext.cpp
index 91fb92c..52ac1cf 100644
--- a/src/ports/SkFontHost_mac_coretext.cpp
+++ b/src/ports/SkFontHost_mac_coretext.cpp
@@ -46,7 +46,7 @@
 public:
     AutoCFRelease(CFTypeRef obj) : fObj(obj) {}
     ~AutoCFRelease() { CFSafeRelease(fObj); }
-    
+
 private:
     CFTypeRef fObj;
 };
@@ -180,7 +180,7 @@
 
 static const char FONT_DEFAULT_NAME[]           = "Lucida Sans";
 
-// see Source/WebKit/chromium/base/mac/mac_util.mm DarwinMajorVersionInternal 
+// see Source/WebKit/chromium/base/mac/mac_util.mm DarwinMajorVersionInternal
 // for original source
 static int readVersion() {
     struct utsname info;
@@ -303,7 +303,7 @@
 
     CGRGBPixel* getCG(const SkScalerContext_Mac& context, const SkGlyph& glyph,
                       CGGlyph glyphID, size_t* rowBytesPtr);
-    
+
 private:
     enum {
         kSize = 32 * 32 * sizeof(CGRGBPixel)
@@ -352,8 +352,8 @@
 class AutoCFDataRelease {
 public:
     AutoCFDataRelease(CFDataRef obj) : fObj(obj) {}
-    const uint16_t* getShortPtr() { 
-        return fObj ? (const uint16_t*) CFDataGetBytePtr(fObj) : NULL; 
+    const uint16_t* getShortPtr() {
+        return fObj ? (const uint16_t*) CFDataGetBytePtr(fObj) : NULL;
     }
     ~AutoCFDataRelease() { CFSafeRelease(fObj); }
 private:
@@ -367,7 +367,7 @@
         id &= 0x3FFFFFFF; // make top two bits 00
         return id;
     }
-    // CTFontGetPlatformFont returns NULL if the font is local 
+    // CTFontGetPlatformFont returns NULL if the font is local
     // (e.g., was created by a CSS3 @font-face rule).
     CGFontRef cgFont = CTFontCopyGraphicsFont(fontRef, NULL);
     AutoCFDataRelease headRef(CGFontCopyTableForTag(cgFont, 'head'));
@@ -777,11 +777,11 @@
 
         CGContextSetAllowsFontSubpixelPositioning(fCG, context.fDoSubPosition);
         CGContextSetShouldSubpixelPositionFonts(fCG, context.fDoSubPosition);
-        
+
         // Draw white on black to create mask.
         // TODO: Draw black on white and invert, CG has a special case codepath.
         CGContextSetGrayFillColor(fCG, 1.0f, 1.0f);
-        
+
         // force our checks below to happen
         fDoAA = !doAA;
         fDoLCD = !doLCD;
@@ -848,9 +848,9 @@
  * field. The choice of long or short offsets is dependent on the maximum
  * possible offset distance.
  *
- * 'loca' short version: The actual local offset divided by 2 is stored. 
+ * 'loca' short version: The actual local offset divided by 2 is stored.
  * 'loca' long version: The actual local offset is stored.
- * 
+ *
  * The result is a offset into a table of 2 byte (16 bit) entries.
  */
 static uint32_t getLocaTableEntry(const uint16_t*& locaPtr, int locaFormat) {
@@ -982,7 +982,7 @@
         if (!isSnowLeopard()) {
         // Lion and Leopard respect the vertical font metrics.
             CTFontGetBoundingRectsForGlyphs(fCTVerticalFont,
-                                            kCTFontVerticalOrientation, 
+                                            kCTFontVerticalOrientation,
                                             &cgGlyph, &theBounds,  1);
         } else {
         // Snow Leopard and earlier respect the vertical font metrics for
@@ -1013,7 +1013,7 @@
             CGPathRelease(path);
         }
     }
-    
+
     glyph->zeroMetrics();
     glyph->fAdvanceX =  SkFloatToFixed(theAdvance.width);
     glyph->fAdvanceY = -SkFloatToFixed(theAdvance.height);
@@ -1021,7 +1021,7 @@
     if (CGRectIsEmpty_inline(theBounds)) {
         return;
     }
-    
+
     if (isLeopard() && !fVertical) {
         // Leopard does not consider the matrix skew in its bounds.
         // Run the bounding rectangle through the skew matrix to determine
@@ -1048,7 +1048,7 @@
     // Get the metrics
     bool lionAdjustedMetrics = false;
     if (isLion() || isMountainLion()) {
-        if (cgGlyph < fGlyphCount && cgGlyph >= getAdjustStart() 
+        if (cgGlyph < fGlyphCount && cgGlyph >= getAdjustStart()
                     && generateBBoxes()) {
             lionAdjustedMetrics = true;
             SkRect adjust;
@@ -1131,7 +1131,7 @@
     const int width = glyph.fWidth;
     size_t dstRB = glyph.rowBytes();
     uint8_t* SK_RESTRICT dst = (uint8_t*)glyph.fImage;
-    
+
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; ++i) {
             dst[i] = rgb_to_a8<APPLY_PREBLEND>(cgPixels[i], table8);
@@ -1156,7 +1156,7 @@
     const int width = glyph.fWidth;
     size_t dstRB = glyph.rowBytes();
     uint16_t* SK_RESTRICT dst = (uint16_t*)glyph.fImage;
-    
+
     for (int y = 0; y < glyph.fHeight; y++) {
         for (int i = 0; i < width; i++) {
             dst[i] = rgb_to_lcd16<APPLY_PREBLEND>(cgPixels[i], tableR, tableG, tableB);
@@ -1203,7 +1203,7 @@
     if (cgPixels == NULL) {
         return;
     }
-    
+
     //TODO: see if drawing black on white and inverting is faster (at least in
     //lcd case) as core graphics appears to have special case code for drawing
     //black text.
@@ -1229,7 +1229,7 @@
             addr = SkTAddByteOffset(addr, cgRowBytes);
         }
     }
-    
+
     // Must be careful not to use these if maskPreBlend == NULL
     const uint8_t* tableR = NULL;
     const uint8_t* tableG = NULL;
@@ -1239,7 +1239,7 @@
         tableG = maskPreBlend->fG;
         tableB = maskPreBlend->fB;
     }
-    
+
     // Convert glyph to mask
     switch (glyph.fMaskFormat) {
         case SkMask::kLCD32_Format: {
@@ -1322,7 +1322,7 @@
         // need to release font when we're done
         font = CTFontCreateCopyWithAttributes(fCTFont, 1, &xform, NULL);
     }
-    
+
     CGGlyph   cgGlyph = (CGGlyph)glyph.getGlyphID(fBaseGlyphCount);
     CGPathRef cgPath  = CTFontCreatePathForGlyph(font, cgGlyph, NULL);
 
@@ -1423,7 +1423,7 @@
 public:
     AutoCGDataProviderRelease(CGDataProviderRef provider) : fProvider(provider) {}
     ~AutoCGDataProviderRelease() { CGDataProviderRelease(fProvider); }
-    
+
 private:
     CGDataProviderRef fProvider;
 };
@@ -1550,13 +1550,13 @@
     ctFont = CTFontCreateCopyWithAttributes(ctFont, CTFontGetUnitsPerEm(ctFont),
                                             NULL, NULL);
     SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
-    
+
     {
         CFStringRef fontName = CTFontCopyPostScriptName(ctFont);
         CFStringToSkString(fontName, &info->fFontName);
         CFRelease(fontName);
     }
-    
+
     info->fMultiMaster = false;
     CFIndex glyphCount = CTFontGetGlyphCount(ctFont);
     info->fLastGlyphID = SkToU16(glyphCount - 1);
@@ -1571,7 +1571,7 @@
     // If it's not a truetype font, mark it as 'other'. Assume that TrueType
     // fonts always have both glyf and loca tables. At the least, this is what
     // sfntly needs to subset the font. CTFontCopyAttribute() does not always
-    // succeed in determining this directly. 
+    // succeed in determining this directly.
     if (!GetTableSize(fontID, 'glyf') || !GetTableSize(fontID, 'loca')) {
         info->fType = SkAdvancedTypefaceMetrics::kOther_Font;
         info->fItalicAngle = 0;
@@ -1768,7 +1768,7 @@
     desc.setPostscriptName(get_str(CTFontCopyPostScriptName(ctFont), &tmpStr));
 
     desc.serialize(stream);
-    
+
     // by convention, we also write out the actual sfnt data, preceeded by
     // a packed-length. For now we skip that, so we just write the zero.
     stream->writePackedUInt(0);
@@ -1815,7 +1815,7 @@
         h = SkPaint::kNormal_Hinting;
     }
     rec->setHinting(h);
-    
+
     bool lcdSupport = supports_LCD();
     if (isLCDFormat(rec->fMaskFormat)) {
         if (lcdSupport) {
@@ -1825,7 +1825,7 @@
             rec->fMaskFormat = SkMask::kA8_Format;
         }
     }
-    
+
     if (lcdSupport) {
         //CoreGraphics dialates smoothed text as needed.
         rec->setContrast(0);
@@ -1845,7 +1845,7 @@
     if (NULL == cfArray) {
         return 0;
     }
-    
+
     AutoCFRelease ar(cfArray);
     return CFArrayGetCount(cfArray);
 }
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index 7ea3d49..b9f1cdc 100755
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -1514,7 +1514,7 @@
    The following need not be any standard base64 encoding.
    The encoded value is never decoded.
 */
-static const char postscript_safe_base64_encode[] = 
+static const char postscript_safe_base64_encode[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "abcdefghijklmnopqrstuvwxyz"
     "0123456789-_=";
@@ -1576,7 +1576,7 @@
     if (FAILED(create_unique_font_name(familyName, familyNameSize))) {
         return NULL;
     }
-    
+
     // Change the name of the font.
     SkAutoTUnref<SkData> rewrittenFontData(SkOTUtils::RenameFont(stream, familyName, familyNameSize-1));
     if (NULL == rewrittenFontData.get()) {
diff --git a/src/ports/SkFontHost_win_dw.cpp b/src/ports/SkFontHost_win_dw.cpp
index c3a13a0..288ee4c 100644
--- a/src/ports/SkFontHost_win_dw.cpp
+++ b/src/ports/SkFontHost_win_dw.cpp
@@ -90,7 +90,7 @@
             GetProcAddress(LoadLibraryW(L"dwrite.dll"), "DWriteCreateFactory")
         )
     ;
-    
+
     if (!dWriteCreateFactoryProc) {
         return E_UNEXPECTED;
     }
@@ -99,7 +99,7 @@
                                 __uuidof(IDWriteFactory),
                                 reinterpret_cast<IUnknown**>(&gDWriteFactory)),
         "Could not create DirectWrite factory.");
-    
+
     *factory = gDWriteFactory;
     return S_OK;
 }
@@ -162,7 +162,7 @@
                                          0.0f, // baselineOriginY,
                                          &glyphRunAnalysis),
          "Could not create glyph run analysis.");
-    
+
     //NOTE: this assumes that the glyph has already been measured
     //with an exact same glyph run analysis.
     RECT bbox;
@@ -296,7 +296,7 @@
         SkDEBUGF(("The hard coded font family does not exist."));
         return E_UNEXPECTED;
     }
-    
+
     SkTScopedComPtr<IDWriteFontFamily> fontFamily;
     HRM(sysFonts->GetFontFamily(index, &fontFamily),
         "Could not load the requested font family.");
@@ -518,7 +518,7 @@
     //DirectWrite does not provide this information.
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
-    
+
     glyph->fAdvanceX = 0;
     glyph->fAdvanceY = 0;
 
@@ -533,7 +533,7 @@
     SkScalar advanceX = SkScalarMulDiv(fRec.fTextSize,
                                        SkIntToScalar(gm.advanceWidth),
                                        SkIntToScalar(dwfm.designUnitsPerEm));
-    
+
     if (!(fRec.fFlags & kSubpixelPositioning_Flag)) {
         advanceX = SkScalarRoundToScalar(advanceX);
     }
@@ -600,7 +600,7 @@
                                          0.0f, // baselineOriginY,
                                          &glyphRunAnalysis),
          "Could not create glyph run analysis.");
-    
+
     RECT bbox;
     HRVM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, &bbox),
          "Could not get texture bounds.");
@@ -1236,7 +1236,7 @@
             float gamma = defaultRenderingParams->GetGamma();
             rec->setDeviceGamma(SkFloatToScalar(gamma));
             rec->setPaintGamma(SkFloatToScalar(gamma));
-            
+
             rec->setContrast(SkFloatToScalar(defaultRenderingParams->GetEnhancedContrast()));
         }
     }
@@ -1491,7 +1491,7 @@
         }
     }
     */
-    
+
     // If Restricted, the font may not be embedded in a document.
     // If not Restricted, the font can be embedded.
     // If PreviewPrint, the embedding is read-only.
diff --git a/src/ports/SkGlobalInitialization_default.cpp b/src/ports/SkGlobalInitialization_default.cpp
index c0dfd39..e9235a8 100644
--- a/src/ports/SkGlobalInitialization_default.cpp
+++ b/src/ports/SkGlobalInitialization_default.cpp
@@ -4,7 +4,7 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
- 
+
 #include "SkTypes.h"
 
 #if !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
diff --git a/src/ports/SkImageDecoder_CG.cpp b/src/ports/SkImageDecoder_CG.cpp
index 4e2bcc9..26f5744 100644
--- a/src/ports/SkImageDecoder_CG.cpp
+++ b/src/ports/SkImageDecoder_CG.cpp
@@ -31,7 +31,7 @@
     size_t len = stream->getLength();
     void* data = sk_malloc_throw(len);
     stream->read(data, len);
-    
+
     return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);
 }
 
@@ -56,24 +56,24 @@
         return false;
     }
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
-    
+
     CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL);
     if (NULL == image) {
         return false;
     }
     SkAutoTCallVProc<CGImage, CGImageRelease> arimage(image);
-    
+
     const int width = CGImageGetWidth(image);
     const int height = CGImageGetHeight(image);
     bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
-    
+
     if (!this->allocPixelRef(bm, NULL)) {
         return false;
     }
-    
+
     bm->lockPixels();
     bm->eraseColor(0);
 
@@ -127,7 +127,7 @@
         return NULL;
     }
     SkAutoTCallVProc<const void, CFRelease> arconsumer(consumer);
-    
+
     return CGImageDestinationCreateWithDataConsumer(consumer, type, 1, NULL);
 }
 
@@ -137,7 +137,7 @@
 
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
-    
+
 private:
     Type fType;
 };
@@ -159,7 +159,7 @@
         default:
             return false;
     }
-    
+
     CGImageDestinationRef dst = SkStreamToImageDestination(stream, type);
     if (NULL == dst) {
         return false;
diff --git a/src/ports/SkImageDecoder_WIC.cpp b/src/ports/SkImageDecoder_WIC.cpp
index a69ed4a..79d107a 100644
--- a/src/ports/SkImageDecoder_WIC.cpp
+++ b/src/ports/SkImageDecoder_WIC.cpp
@@ -29,9 +29,9 @@
     if (!scopedCo.succeeded()) {
         return false;
     }
-    
+
     HRESULT hr = S_OK;
-    
+
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
     if (SUCCEEDED(hr)) {
@@ -42,19 +42,19 @@
             , IID_PPV_ARGS(&piImagingFactory)
         );
     }
-    
+
     //Convert SkStream to IStream.
     SkTScopedComPtr<IStream> piStream;
     if (SUCCEEDED(hr)) {
         hr = SkIStream::CreateFromSkStream(stream, false, &piStream);
     }
-    
+
     //Make sure we're at the beginning of the stream.
     if (SUCCEEDED(hr)) {
         LARGE_INTEGER liBeginning = { 0 };
         hr = piStream->Seek(liBeginning, STREAM_SEEK_SET, NULL);
     }
-    
+
     //Create the decoder from the stream content.
     SkTScopedComPtr<IWICBitmapDecoder> piBitmapDecoder;
     if (SUCCEEDED(hr)) {
@@ -65,13 +65,13 @@
             , &piBitmapDecoder                //Pointer to the decoder
         );
     }
-    
+
     //Get the first frame from the decoder.
     SkTScopedComPtr<IWICBitmapFrameDecode> piBitmapFrameDecode;
     if (SUCCEEDED(hr)) {
         hr = piBitmapDecoder->GetFrame(0, &piBitmapFrameDecode);
     }
-    
+
     //Get the BitmapSource interface of the frame.
     SkTScopedComPtr<IWICBitmapSource> piBitmapSourceOriginal;
     if (SUCCEEDED(hr)) {
@@ -79,14 +79,14 @@
             IID_PPV_ARGS(&piBitmapSourceOriginal)
         );
     }
-    
+
     //Get the size of the bitmap.
     UINT width;
     UINT height;
     if (SUCCEEDED(hr)) {
         hr = piBitmapSourceOriginal->GetSize(&width, &height);
     }
-    
+
     //Exit early if we're only looking for the bitmap bounds.
     if (SUCCEEDED(hr)) {
         bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
@@ -97,13 +97,13 @@
             return false;
         }
     }
-    
+
     //Create a format converter.
     SkTScopedComPtr<IWICFormatConverter> piFormatConverter;
     if (SUCCEEDED(hr)) {
         hr = piImagingFactory->CreateFormatConverter(&piFormatConverter);
     }
-    
+
     if (SUCCEEDED(hr)) {
         hr = piFormatConverter->Initialize(
             piBitmapSourceOriginal.get()      //Input bitmap to convert
@@ -114,7 +114,7 @@
             , WICBitmapPaletteTypeCustom      //Palette translation type
         );
     }
-    
+
     //Get the BitmapSource interface of the format converter.
     SkTScopedComPtr<IWICBitmapSource> piBitmapSourceConverted;
     if (SUCCEEDED(hr)) {
@@ -122,7 +122,7 @@
             IID_PPV_ARGS(&piBitmapSourceConverted)
         );
     }
-    
+
     //Copy the pixels into the bitmap.
     if (SUCCEEDED(hr)) {
         SkAutoLockPixels alp(*bm);
@@ -135,7 +135,7 @@
             reinterpret_cast<BYTE *>(bm->getPixels())
         );
     }
-    
+
     return SUCCEEDED(hr);
 }
 
@@ -197,9 +197,9 @@
     if (!scopedCo.succeeded()) {
         return false;
     }
-    
+
     HRESULT hr = S_OK;
-    
+
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
     if (SUCCEEDED(hr)) {
@@ -210,41 +210,41 @@
             , IID_PPV_ARGS(&piImagingFactory)
         );
     }
-    
+
     //Convert the SkWStream to an IStream.
     SkTScopedComPtr<IStream> piStream;
     if (SUCCEEDED(hr)) {
         hr = SkWIStream::CreateFromSkWStream(stream, &piStream);
     }
-    
+
     //Create an encode of the appropriate type.
     SkTScopedComPtr<IWICBitmapEncoder> piEncoder;
     if (SUCCEEDED(hr)) {
         hr = piImagingFactory->CreateEncoder(type, NULL, &piEncoder);
     }
-    
+
     if (SUCCEEDED(hr)) {
         hr = piEncoder->Initialize(piStream.get(), WICBitmapEncoderNoCache);
     }
-    
+
     //Create a the frame.
     SkTScopedComPtr<IWICBitmapFrameEncode> piBitmapFrameEncode;
     SkTScopedComPtr<IPropertyBag2> piPropertybag;
     if (SUCCEEDED(hr)) {
         hr = piEncoder->CreateNewFrame(&piBitmapFrameEncode, &piPropertybag);
     }
-    
+
     if (SUCCEEDED(hr)) {
         PROPBAG2 name = { 0 };
         name.dwType = PROPBAG2_TYPE_DATA;
         name.vt = VT_R4;
         name.pstrName = L"ImageQuality";
-    
+
         VARIANT value;
         VariantInit(&value);
         value.vt = VT_R4;
         value.fltVal = (FLOAT)(quality / 100.0);
-        
+
         //Ignore result code.
         //  This returns E_FAIL if the named property is not in the bag.
         //TODO(bungeman) enumerate the properties,
@@ -254,14 +254,14 @@
     if (SUCCEEDED(hr)) {
         hr = piBitmapFrameEncode->Initialize(piPropertybag.get());
     }
-    
+
     //Set the size of the frame.
     const UINT width = bitmap->width();
     const UINT height = bitmap->height();
     if (SUCCEEDED(hr)) {
         hr = piBitmapFrameEncode->SetSize(width, height);
     }
-    
+
     //Set the pixel format of the frame.
     const WICPixelFormatGUID formatDesired = GUID_WICPixelFormat32bppBGRA;
     WICPixelFormatGUID formatGUID = formatDesired;
@@ -272,7 +272,7 @@
         //Be sure the image format is the one requested.
         hr = IsEqualGUID(formatGUID, formatDesired) ? S_OK : E_FAIL;
     }
-    
+
     //Write the pixels into the frame.
     if (SUCCEEDED(hr)) {
         SkAutoLockPixels alp(*bitmap);
@@ -282,15 +282,15 @@
             , bitmap->rowBytes()*height
             , reinterpret_cast<BYTE*>(bitmap->getPixels()));
     }
-    
+
     if (SUCCEEDED(hr)) {
         hr = piBitmapFrameEncode->Commit();
     }
-    
+
     if (SUCCEEDED(hr)) {
         hr = piEncoder->Commit();
     }
-    
+
     return SUCCEEDED(hr);
 }
 
diff --git a/src/ports/SkImageRef_ashmem.cpp b/src/ports/SkImageRef_ashmem.cpp
index 81f24dd..01b950e 100644
--- a/src/ports/SkImageRef_ashmem.cpp
+++ b/src/ports/SkImageRef_ashmem.cpp
@@ -34,14 +34,14 @@
                                              SkBitmap::Config config,
                                              int sampleSize)
         : SkImageRef(stream, config, sampleSize) {
-            
+
     fRec.fFD = -1;
     fRec.fAddr = NULL;
     fRec.fSize = 0;
     fRec.fPinned = false;
-            
+
     fCT = NULL;
-            
+
     this->useDefaultMutex();   // we don't need/want the shared imageref mutex
 }
 
@@ -80,7 +80,7 @@
         if (-1 == fd) {
             SkASSERT(NULL == addr);
             SkASSERT(0 == fRec->fSize);
-            
+
             fd = ashmem_create_region(fName, size);
 #ifdef DUMP_ASHMEM_LIFECYCLE
             SkDebugf("=== ashmem_create_region %s size=%d fd=%d\n", fName, size, fd);
@@ -90,7 +90,7 @@
                          fName, size);
                 return false;
             }
-            
+
             int err = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
             if (err) {
                 SkDebugf("------ ashmem_set_prot_region(%d) failed %d\n",
@@ -98,7 +98,7 @@
                 close(fd);
                 return false;
             }
-            
+
             addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
             if (-1 == (long)addr) {
                 SkDebugf("---------- mmap failed for imageref_ashmem size=%d\n",
@@ -106,7 +106,7 @@
                 close(fd);
                 return false;
             }
-            
+
             fRec->fFD = fd;
             fRec->fAddr = addr;
             fRec->fSize = size;
@@ -120,7 +120,7 @@
         fRec->fPinned = true;
         return true;
     }
-    
+
 private:
     // we just point to our caller's memory, these are not copies
     SkAshmemRec* fRec;
@@ -130,13 +130,13 @@
 bool SkImageRef_ashmem::onDecode(SkImageDecoder* codec, SkStream* stream,
                                  SkBitmap* bitmap, SkBitmap::Config config,
                                  SkImageDecoder::Mode mode) {
-    
+
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return this->INHERITED::onDecode(codec, stream, bitmap, config, mode);
     }
 
     AshmemAllocator alloc(&fRec, this->getURI());
-    
+
     codec->setAllocator(&alloc);
     bool success = this->INHERITED::onDecode(codec, stream, bitmap, config,
                                              mode);
@@ -192,21 +192,21 @@
     } else {
         // no FD, will create an ashmem region in allocator
     }
-    
+
     return this->INHERITED::onLockPixels(ct);
 }
 
 void SkImageRef_ashmem::onUnlockPixels() {
     this->INHERITED::onUnlockPixels();
-    
+
     if (-1 != fRec.fFD) {
         SkASSERT(fRec.fAddr);
         SkASSERT(fRec.fPinned);
-        
+
         ashmem_unpin_region(fRec.fFD, 0, 0);
         fRec.fPinned = false;
     }
-    
+
     // we clear this with or without an error, since we've either closed or
     // unpinned the region
     fBitmap.setPixels(NULL, NULL);
diff --git a/src/ports/SkImageRef_ashmem.h b/src/ports/SkImageRef_ashmem.h
index 5b4e814..f98507a 100644
--- a/src/ports/SkImageRef_ashmem.h
+++ b/src/ports/SkImageRef_ashmem.h
@@ -21,7 +21,7 @@
 public:
     SkImageRef_ashmem(SkStream*, SkBitmap::Config, int sampleSize = 1);
     virtual ~SkImageRef_ashmem();
-    
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkImageRef_ashmem)
 
 protected:
@@ -31,10 +31,10 @@
     virtual bool onDecode(SkImageDecoder* codec, SkStream* stream,
                           SkBitmap* bitmap, SkBitmap::Config config,
                           SkImageDecoder::Mode mode);
-    
+
     virtual void* onLockPixels(SkColorTable**);
     virtual void onUnlockPixels();
-    
+
 private:
     void closeFD();
 
diff --git a/src/ports/SkThread_pthread.cpp b/src/ports/SkThread_pthread.cpp
index ad243b9..b430dd9 100644
--- a/src/ports/SkThread_pthread.cpp
+++ b/src/ports/SkThread_pthread.cpp
@@ -15,7 +15,7 @@
 
 /**
  We prefer the GCC intrinsic implementation of the atomic operations over the
- SkMutex-based implementation. The SkMutex version suffers from static 
+ SkMutex-based implementation. The SkMutex version suffers from static
  destructor ordering problems.
  Note clang also defines the GCC version macros and implements the intrinsics.
  TODO: Verify that gcc-style __sync_* intrinsics work on ARM
@@ -82,7 +82,7 @@
 int32_t sk_atomic_add(int32_t* addr, int32_t inc)
 {
     SkAutoMutexAcquire ac(gAtomicMutex);
-    
+
     int32_t value = *addr;
     *addr = value + inc;
     return value;
@@ -166,7 +166,7 @@
     status = pthread_mutexattr_init(&attr);
     print_pthread_error(status);
     SkASSERT(0 == status);
-    
+
     status = pthread_mutex_init((pthread_mutex_t*)fStorage, &attr);
     print_pthread_error(status);
     SkASSERT(0 == status);
diff --git a/src/ports/SkXMLParser_expat.cpp b/src/ports/SkXMLParser_expat.cpp
index c78dc35..8c1c2bf 100644
--- a/src/ports/SkXMLParser_expat.cpp
+++ b/src/ports/SkXMLParser_expat.cpp
@@ -28,7 +28,7 @@
 inline const char* ConvertUnicodeToChar(const short* ch16, size_t len, SkAutoMalloc& ch8Malloc) {
     char* ch8 = (char*) ch8Malloc.get();
     int index;
-    for (index = 0; index < len; index++) 
+    for (index = 0; index < len; index++)
         ch8[index] = (char) ch16[index];
     ch8[index] = '\0';
     return ch8;
diff --git a/src/ports/SkXMLParser_tinyxml.cpp b/src/ports/SkXMLParser_tinyxml.cpp
index 2e308aa..de1fbe5 100644
--- a/src/ports/SkXMLParser_tinyxml.cpp
+++ b/src/ports/SkXMLParser_tinyxml.cpp
@@ -22,12 +22,12 @@
     while (attr)
     {
         //printf("walk_elem_attr(%s=\"%s\") ", attr->Name(), attr->Value());
-    
+
         parser->addAttribute(attr->Name(), attr->Value());
         attr = attr->Next();
     }
     //printf("\n");
-    
+
     const TiXmlNode* node = elem->FirstChild();
     while (node)
     {
@@ -37,7 +37,7 @@
             parser->text(node->Value(), strlen(node->Value()));
         node = node->NextSibling();
     }
-    
+
     parser->endElement(elem->Value());
 }
 
@@ -51,7 +51,7 @@
         printf("tinyxml error: <%s> row[%d] col[%d]\n", doc.ErrorDesc(), doc.ErrorRow(), doc.ErrorCol());
         return false;
     }
-    
+
     walk_elem(parser, doc.RootElement());
     return true;
 }
@@ -59,13 +59,13 @@
 bool SkXMLParser::parse(SkStream& stream)
 {
     size_t size = stream.read(NULL, 0);
-    
+
     SkAutoMalloc    buffer(size + 1);
     char*           buf = (char*)buffer.get();
-    
+
     stream.read(buf, size);
     buf[size] = 0;
-    
+
     return load_buf(this, buf);
 }
 
@@ -73,10 +73,10 @@
 {
     SkAutoMalloc    buffer(len + 1);
     char*           buf = (char*)buffer.get();
-    
+
     memcpy(buf, doc, len);
     buf[len] = 0;
-    
+
     return load_buf(this, buf);
 }
 
diff --git a/src/ports/SkXMLPullParser_expat.cpp b/src/ports/SkXMLPullParser_expat.cpp
index 825ca68..5fcdff3 100644
--- a/src/ports/SkXMLPullParser_expat.cpp
+++ b/src/ports/SkXMLPullParser_expat.cpp
@@ -18,8 +18,8 @@
 {
     SkASSERT(src);
     char*   dst = (char*)chunk.alloc(len + 1, SkChunkAlloc::kThrow_AllocFailType);
-    
-    memcpy(dst, src, len);    
+
+    memcpy(dst, src, len);
     dst[len] = 0;
     return dst;
 }
@@ -37,11 +37,11 @@
 
 struct Data {
     Data() : fAlloc(2048), fState(NORMAL) {}
-    
+
     XML_Parser              fParser;
     SkXMLPullParser::Curr*  fCurr;
     SkChunkAlloc            fAlloc;
-    
+
     enum State {
         NORMAL,
         MISSED_START_TAG,
@@ -58,7 +58,7 @@
     SkChunkAlloc&           alloc = p->fAlloc;
 
     c->fName = dupstr(alloc, el, strlen(el));
-    
+
     int n = count_pairs(attr);
     SkXMLPullParser::AttrInfo* info = (SkXMLPullParser::AttrInfo*)alloc.alloc(n * sizeof(SkXMLPullParser::AttrInfo),
                                                                               SkChunkAlloc::kThrow_AllocFailType);
@@ -88,7 +88,7 @@
             so we set a flag to notify them of the missed start_tag
         */
         p->fState = Data::MISSED_START_TAG;
-        
+
         SkASSERT(c->fName != NULL);
         SkASSERT(strcmp(c->fName, el) == 0);
     }
@@ -134,7 +134,7 @@
     XML_Error code = XML_GetErrorCode(parser);
     int lineNumber = XML_GetCurrentLineNumber(parser);
     const char* msg = XML_ErrorString(code);
-    
+
     printf("-------- XML error [%d] on line %d, %s\n", code, lineNumber, msg);
 }
 
@@ -183,7 +183,7 @@
     XML_Status status;
 
     status = XML_ResumeParser(p);
-    
+
 CHECK_STATUS:
     switch (status) {
     case XML_STATUS_OK:
@@ -204,7 +204,7 @@
             // return a start_tag, and clear the flag so we return end_tag next
             SkASSERT(SkXMLPullParser::END_TAG == fCurr.fEventType);
             fImpl->fData.fState = Data::RETURN_END_TAG;
-            fImpl->fData.fEndTag = fCurr.fName;  // save this pointer            
+            fImpl->fData.fEndTag = fCurr.fName;  // save this pointer
             return SkXMLPullParser::START_TAG;
         }
         break;
diff --git a/src/sfnt/SkOTUtils.cpp b/src/sfnt/SkOTUtils.cpp
index 61edabd..6e94437 100644
--- a/src/sfnt/SkOTUtils.cpp
+++ b/src/sfnt/SkOTUtils.cpp
@@ -73,7 +73,7 @@
     //originalDataSize is the size of the original data without the name table.
     size_t originalDataSize = fontData->getLength() - oldNameTablePhysicalSize;
     size_t newDataSize = originalDataSize + nameTablePhysicalSize;
-    
+
     SK_OT_BYTE* data = static_cast<SK_OT_BYTE*>(sk_malloc_throw(newDataSize));
     SkAutoTUnref<SkData> rewrittenFontData(SkData::NewFromMalloc(data, newDataSize));
 
diff --git a/src/sfnt/SkTypedEnum.h b/src/sfnt/SkTypedEnum.h
index ce1a939..73d7314 100644
--- a/src/sfnt/SkTypedEnum.h
+++ b/src/sfnt/SkTypedEnum.h
@@ -40,7 +40,7 @@
         SK_PAIR_FIRST(elem) = SK_PAIR_SECOND(elem),
 
     #define SK_TYPED_ENUM_IDS(data, elem) \
-        elem, 
+        elem,
 
     #define SK_TYPED_ENUM_IDS_L(data, elem) \
         elem
diff --git a/src/svg/SkSVGClipPath.cpp b/src/svg/SkSVGClipPath.cpp
index 0a41764..fa3a799 100644
--- a/src/svg/SkSVGClipPath.cpp
+++ b/src/svg/SkSVGClipPath.cpp
@@ -32,7 +32,7 @@
     const char* refStr = &use->f_xlink_href.c_str()[1];
     SkASSERT(parser.getIDs().find(refStr, &ref));
     SkASSERT(ref);
-    if (ref->getType() == SkSVGType_Rect) 
+    if (ref->getType() == SkSVGType_Rect)
         parser._addAttribute("rectangle", refStr);
     else
         parser._addAttribute("path", refStr);
diff --git a/src/svg/SkSVGElements.cpp b/src/svg/SkSVGElements.cpp
index 0096fc0..66dcd4e 100644
--- a/src/svg/SkSVGElements.cpp
+++ b/src/svg/SkSVGElements.cpp
@@ -13,7 +13,7 @@
 SkSVGBase::~SkSVGBase() {
 }
 
-void SkSVGBase::addAttribute(SkSVGParser& parser, int attrIndex, 
+void SkSVGBase::addAttribute(SkSVGParser& parser, int attrIndex,
         const char* attrValue, size_t attrLength) {
     SkString* first = (SkString*) ((char*) this + sizeof(SkSVGElement));
     first += attrIndex;
@@ -82,7 +82,7 @@
 //}
 
 void SkSVGElement::write(SkSVGParser& , SkString& ) {
-    SkASSERT(0); 
+    SkASSERT(0);
 }
 
 
diff --git a/src/svg/SkSVGGradient.cpp b/src/svg/SkSVGGradient.cpp
index 27964e7..d5f7639 100644
--- a/src/svg/SkSVGGradient.cpp
+++ b/src/svg/SkSVGGradient.cpp
@@ -84,7 +84,7 @@
     parser.fSuppressPaint = true;
     SkString originalID(f_id);
     f_id.set("mask"); // write out gradient named given name + color (less initial #)
-    f_id.append(baseColor.c_str() + 1); 
+    f_id.append(baseColor.c_str() + 1);
     SkString originalColors;
     for (SkSVGElement** ptr = fChildren.begin(); ptr < fChildren.end(); ptr++) {
         SkSVGStop* colorElement = (SkSVGStop*) *ptr;
diff --git a/src/svg/SkSVGPaintState.cpp b/src/svg/SkSVGPaintState.cpp
index 1a30cb8..db30900 100644
--- a/src/svg/SkSVGPaintState.cpp
+++ b/src/svg/SkSVGPaintState.cpp
@@ -49,7 +49,7 @@
     return result;
 }
 
-void SkSVGPaint::addAttribute(SkSVGParser& parser, int attrIndex, 
+void SkSVGPaint::addAttribute(SkSVGParser& parser, int attrIndex,
         const char* attrValue, size_t attrLength) {
     SkString* attr = (*this)[attrIndex];
     switch(attrIndex) {
@@ -221,7 +221,7 @@
                 sum.setConcat(matrix, sum);
                 continue;
             }
-            if ( index == kClipPath) 
+            if ( index == kClipPath)
                 *clips.insert(0) = lastAttr;
         }
         walking = walking->fNext;
@@ -267,7 +267,7 @@
 #endif
 }
 
-bool SkSVGPaint::writeChangedAttributes(SkSVGParser& parser, 
+bool SkSVGPaint::writeChangedAttributes(SkSVGParser& parser,
         SkSVGPaint& current, bool* changed) {
     SkSVGPaint& lastState = parser.fLastFlush;
     for (int index = kInitial + 1; index < kTerminal; index++) {
@@ -285,7 +285,7 @@
             case kEnableBackground:
                 break;
             case kFill:
-                if (topAttr->equals("none") == false && lastAttr->equals("none") == true) 
+                if (topAttr->equals("none") == false && lastAttr->equals("none") == true)
                     parser._addAttribute("stroke", "false");
                 goto fillStrokeAttrCommon;
             case kFillRule:
@@ -307,7 +307,7 @@
             case kStopOpacity:
                 break;
             case kStroke:
-                if (topAttr->equals("none") == false && lastAttr->equals("none") == true) 
+                if (topAttr->equals("none") == false && lastAttr->equals("none") == true)
                     parser._addAttribute("stroke", "true");
 fillStrokeAttrCommon:
                 if (strncmp(attrValue, "url(", 4) == 0) {
@@ -442,7 +442,7 @@
     }
     return true;
 }
-                
+
 void SkSVGPaint::Push(SkSVGPaint** head, SkSVGPaint* newRecord) {
     newRecord->fNext = *head;
     *head = newRecord;
diff --git a/src/svg/SkSVGParser.cpp b/src/svg/SkSVGParser.cpp
index c8712b4..74ea023 100644
--- a/src/svg/SkSVGParser.cpp
+++ b/src/svg/SkSVGParser.cpp
@@ -35,9 +35,9 @@
 
 static int gGeneratedMatrixID = 0;
 
-SkSVGParser::SkSVGParser(SkXMLParserError* errHandler) : 
-	SkXMLParser(errHandler),
-	fHead(&fEmptyPaint), fIDs(256),
+SkSVGParser::SkSVGParser(SkXMLParserError* errHandler) :
+    SkXMLParser(errHandler),
+    fHead(&fEmptyPaint), fIDs(256),
         fXMLWriter(&fStream), fCurrElement(NULL), fInSVG(false), fSuppressPaint(false) {
     fLastTransform.reset();
     fEmptyPaint.f_fill.set("black");
@@ -72,7 +72,7 @@
     size_t result = 0;
     while (result < count) {
         if (strncmp(attributes->fName, attrValue, len) == 0 && strlen(attributes->fName) == len) {
-            SkASSERT(result == (attributes->fOffset - 
+            SkASSERT(result == (attributes->fOffset -
                 (isPaint ? sizeof(SkString) : sizeof(SkSVGElement))) / sizeof(SkString));
             return result;
         }
@@ -199,9 +199,9 @@
     SkSVGTypes type = GetType(name, len);
 //    SkASSERT(type >= 0);
     if (type < 0) {
-		type = SkSVGType_G;
+        type = SkSVGType_G;
 //        return true;
-	}
+    }
     SkSVGElement* parent = fParents.count() > 0 ? fParents.top() : NULL;
     SkSVGElement* element = CreateElement(type, parent);
     bool result = false;
@@ -219,7 +219,7 @@
 bool SkSVGParser::onText(const char text[], int len) {
     if (fInSVG == false)
         return false;
-    SkSVGTypes type = fCurrElement->getType(); 
+    SkSVGTypes type = fCurrElement->getType();
     if (type != SkSVGType_Text && type != SkSVGType_Tspan)
         return false;
     SkSVGText* textElement = (SkSVGText*) fCurrElement;
@@ -310,7 +310,7 @@
         string.append(elems[index], end - elems[index] + 1);
     }
     string.remove(string.size() - 1, 1);
-    string.append(",0,0,1]");    
+    string.append(",0,0,1]");
     _addAttribute("matrix", string);
     _endElement();  // matrix
 }
@@ -434,8 +434,8 @@
 const int kSVGTypeNamesSize = SK_ARRAY_COUNT(gSVGTypeNames);
 
 SkSVGTypes SkSVGParser::GetType(const char match[], size_t len ) {
-    int index = SkStrSearch(&gSVGTypeNames[0].fName, kSVGTypeNamesSize, match, 
+    int index = SkStrSearch(&gSVGTypeNames[0].fName, kSVGTypeNamesSize, match,
         len, sizeof(gSVGTypeNames[0]));
-    return index >= 0 && index < kSVGTypeNamesSize ? gSVGTypeNames[index].fType : 
+    return index >= 0 && index < kSVGTypeNamesSize ? gSVGTypeNames[index].fType :
         (SkSVGTypes) -1;
 }
diff --git a/src/svg/SkSVGPath.cpp b/src/svg/SkSVGPath.cpp
index 92f5b14..ab18a65 100644
--- a/src/svg/SkSVGPath.cpp
+++ b/src/svg/SkSVGPath.cpp
@@ -29,7 +29,7 @@
     }
     if (hasMultiplePaths) {
         SkString& fillRule = parser.getPaintLast(SkSVGPaint::kFillRule);
-        if (fillRule.size() > 0) 
+        if (fillRule.size() > 0)
             parser._addAttribute("fillType", fillRule.equals("evenodd") ? "evenOdd" : "winding");
     }
     SVG_ADD_ATTRIBUTE(d);
diff --git a/src/svg/SkSVGPolygon.cpp b/src/svg/SkSVGPolygon.cpp
index 97cf5e0..4b458db 100644
--- a/src/svg/SkSVGPolygon.cpp
+++ b/src/svg/SkSVGPolygon.cpp
@@ -18,7 +18,7 @@
 
 DEFINE_SVG_INFO(Polygon)
 
-void SkSVGPolygon::addAttribute(SkSVGParser& parser, int attrIndex, 
+void SkSVGPolygon::addAttribute(SkSVGParser& parser, int attrIndex,
         const char* attrValue, size_t attrLength) {
     INHERITED::addAttribute(parser, attrIndex, attrValue, attrLength);
 }
@@ -27,7 +27,7 @@
     parser._startElement("polygon");
     SkSVGElement::translate(parser, defState);
     SVG_ADD_ATTRIBUTE(points);
-    if (f_fillRule.size() > 0) 
+    if (f_fillRule.size() > 0)
         parser._addAttribute("fillType", f_fillRule.equals("evenodd") ? "evenOdd" : "winding");
     parser._endElement();
 }
diff --git a/src/svg/SkSVGPolygon.h b/src/svg/SkSVGPolygon.h
index d353764..b2848d0 100644
--- a/src/svg/SkSVGPolygon.h
+++ b/src/svg/SkSVGPolygon.h
@@ -14,7 +14,7 @@
 
 class SkSVGPolygon : public SkSVGPolyline {
     DECLARE_SVG_INFO(Polygon);
-    virtual void addAttribute(SkSVGParser& , int attrIndex, 
+    virtual void addAttribute(SkSVGParser& , int attrIndex,
         const char* attrValue, size_t attrLength);
 private:
     typedef SkSVGPolyline INHERITED;
diff --git a/src/svg/SkSVGPolyline.cpp b/src/svg/SkSVGPolyline.cpp
index fe83c04..83dad48 100644
--- a/src/svg/SkSVGPolyline.cpp
+++ b/src/svg/SkSVGPolyline.cpp
@@ -24,7 +24,7 @@
 
 DEFINE_SVG_INFO(Polyline)
 
-void SkSVGPolyline::addAttribute(SkSVGParser& , int attrIndex, 
+void SkSVGPolyline::addAttribute(SkSVGParser& , int attrIndex,
         const char* attrValue, size_t attrLength) {
     if (attrIndex != kPoints)
         return;
@@ -37,7 +37,7 @@
     parser._startElement("polyline");
     INHERITED::translate(parser, defState);
     SVG_ADD_ATTRIBUTE(points);
-    if (f_fillRule.size() > 0) 
+    if (f_fillRule.size() > 0)
         parser._addAttribute("fillType", f_fillRule.equals("evenodd") ? "evenOdd" : "winding");
     parser._endElement();
 }
diff --git a/src/svg/SkSVGPolyline.h b/src/svg/SkSVGPolyline.h
index 62dc417..b8d5af4 100644
--- a/src/svg/SkSVGPolyline.h
+++ b/src/svg/SkSVGPolyline.h
@@ -15,7 +15,7 @@
 
 class SkSVGPolyline : public SkSVGElement {
     DECLARE_SVG_INFO(Polyline);
-    virtual void addAttribute(SkSVGParser& , int attrIndex, 
+    virtual void addAttribute(SkSVGParser& , int attrIndex,
         const char* attrValue, size_t attrLength);
 protected:
     SkString f_clipRule;
diff --git a/src/svg/SkSVGSVG.cpp b/src/svg/SkSVGSVG.cpp
index a072d09..fcce62d 100644
--- a/src/svg/SkSVGSVG.cpp
+++ b/src/svg/SkSVGSVG.cpp
@@ -48,8 +48,8 @@
     box.fTop = SkScalarDiv(viewBox[1], height);
     box.fRight = SkScalarDiv(viewBox[2], width);
     box.fBottom = SkScalarDiv(viewBox[3], height);
-    if (box.fLeft == 0 && box.fTop == 0 && 
-        box.fRight == SK_Scalar1 && box.fBottom == SK_Scalar1) 
+    if (box.fLeft == 0 && box.fTop == 0 &&
+        box.fRight == SK_Scalar1 && box.fBottom == SK_Scalar1)
             return;
     parser._startElement("matrix");
     if (box.fLeft != 0) {
@@ -72,5 +72,5 @@
         y.appendScalar(box.fBottom);
         parser._addAttributeLen("scaleY", y.c_str(), y.size());
     }
-    parser._endElement();   
+    parser._endElement();
 }
diff --git a/src/svg/SkSVGSVG.h b/src/svg/SkSVGSVG.h
index 7d1e16a..155f9a9 100644
--- a/src/svg/SkSVGSVG.h
+++ b/src/svg/SkSVGSVG.h
@@ -22,11 +22,11 @@
     SkString f_width;
     SkString f_version;
     SkString f_viewBox;
-	SkString f_x;
+    SkString f_x;
     SkString f_xml_space;
     SkString f_xmlns;
     SkString f_xml_xlink;
-	SkString f_y;
+    SkString f_y;
 
     typedef SkSVGElement INHERITED;
 };
diff --git a/src/svg/SkSVGSymbol.cpp b/src/svg/SkSVGSymbol.cpp
index a988467..ce341e6 100644
--- a/src/svg/SkSVGSymbol.cpp
+++ b/src/svg/SkSVGSymbol.cpp
@@ -18,5 +18,5 @@
 
 void SkSVGSymbol::translate(SkSVGParser& parser, bool defState) {
     INHERITED::translate(parser, defState);
-    // !!! children need to be written into document 
+    // !!! children need to be written into document
 }
diff --git a/src/utils/SkBase64.cpp b/src/utils/SkBase64.cpp
index a8d4e87..8e1f223 100644
--- a/src/utils/SkBase64.cpp
+++ b/src/utils/SkBase64.cpp
@@ -12,7 +12,7 @@
 #define DecodePad -2
 #define EncodePad 64
 
-static const char default_encode[] = 
+static const char default_encode[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "abcdefghijklmnopqrstuvwxyz"
     "0123456789+/=";
@@ -55,7 +55,7 @@
             signed char decoded = decodeData[srcByte - '+'];
             bytes[byte] = decoded;
             if (decoded < 0) {
-                if (decoded == DecodePad) 
+                if (decoded == DecodePad)
                     goto handlePad;
                 return kBadCharError;
             } else
@@ -89,7 +89,7 @@
             *dst = (unsigned char) one;
         }
         dst++;
-        if (padTwo) 
+        if (padTwo)
             break;
         if (writeDestination)
             *dst = (unsigned char) two;
@@ -105,7 +105,7 @@
     return kNoError;
 }
 
-#if defined _WIN32 && _MSC_VER >= 1300  
+#if defined _WIN32 && _MSC_VER >= 1300
 #pragma warning ( pop )
 #endif
 
@@ -126,7 +126,7 @@
             unsigned b = *src++;
             unsigned c = *src++;
             int      d = c & 0x3F;
-            c = (c >> 6 | b << 2) & 0x3F; 
+            c = (c >> 6 | b << 2) & 0x3F;
             b = (b >> 4 | a << 4) & 0x3F;
             a = a >> 2;
             *dst++ = encode[a];
diff --git a/src/utils/SkBoundaryPatch.cpp b/src/utils/SkBoundaryPatch.cpp
index c305c8b..afc76b5 100644
--- a/src/utils/SkBoundaryPatch.cpp
+++ b/src/utils/SkBoundaryPatch.cpp
@@ -50,7 +50,7 @@
 
     const SkScalar invR = SkScalarInvert(SkIntToScalar(rows - 1));
     const SkScalar invC = SkScalarInvert(SkIntToScalar(cols - 1));
-    
+
     for (int y = 0; y < cols; y++) {
         SkScalar yy = y * invC;
         for (int x = 0; x < rows; x++) {
diff --git a/src/utils/SkCamera.cpp b/src/utils/SkCamera.cpp
index ac6fa0f..7d6963c 100644
--- a/src/utils/SkCamera.cpp
+++ b/src/utils/SkCamera.cpp
@@ -369,7 +369,7 @@
     fCamera.fLocation.set(x * SkFloatToScalar(72.0f), y * SkFloatToScalar(72.0f), lz);
     fCamera.fObserver.set(0, 0, lz);
     fCamera.update();
-    
+
 }
 
 SkScalar Sk3DView::getCameraLocationX() {
@@ -419,7 +419,7 @@
 
 void Sk3DView::applyToCanvas(SkCanvas* canvas) const {
     SkMatrix    matrix;
-    
+
     this->getMatrix(&matrix);
     canvas->concat(matrix);
 }
diff --git a/src/utils/SkCubicInterval.cpp b/src/utils/SkCubicInterval.cpp
index 6c6b0a9..904f26b 100644
--- a/src/utils/SkCubicInterval.cpp
+++ b/src/utils/SkCubicInterval.cpp
@@ -59,7 +59,7 @@
 
     // now search for t given unitX
     SkScalar t = find_cubic_t(x1, x2 - 2*x1, x1 - x2 + SK_Scalar1, unitX);
-    
+
     // now evaluate the cubic in Y
     y1 *= 3;
     y2 *= 3;
diff --git a/src/utils/SkCullPoints.cpp b/src/utils/SkCullPoints.cpp
index 3e3082f..e76679d 100644
--- a/src/utils/SkCullPoints.cpp
+++ b/src/utils/SkCullPoints.cpp
@@ -15,7 +15,7 @@
     return v.fX * dy - v.fY * dx < 0;
 #else
     Sk64   tmp0, tmp1;
-    
+
     tmp0.setMul(v.fX, dy);
     tmp1.setMul(dx, v.fY);
     tmp0.sub(tmp1);
@@ -33,7 +33,7 @@
         return false;
     }
 
-    // since the crossprod test is a little expensive, check for easy-in cases first    
+    // since the crossprod test is a little expensive, check for easy-in cases first
     if (r.contains(x0, y0) || r.contains(x1, y1)) {
         return true;
     }
@@ -41,7 +41,7 @@
     // At this point we're not sure, so we do a crossprod test
     SkIPoint           vec;
     const SkIPoint*    rAsQuad = fAsQuad;
-    
+
     vec.set(x1 - x0, y1 - y0);
     bool isNeg = cross_product_is_neg(vec, x0 - rAsQuad[0].fX, y0 - rAsQuad[0].fY);
     for (int i = 1; i < 4; i++) {
@@ -89,14 +89,14 @@
     LineToResult result = kNo_Result;
     int x0 = fPrevPt.fX;
     int y0 = fPrevPt.fY;
-    
+
     // need to upgrade sect_test to chop the result
     // and to correctly return kLineTo_Result when the result is connected
     // to the previous call-out
     if (this->sect_test(x0, y0, x, y)) {
         line[0].set(x0, y0);
         line[1].set(x, y);
-        
+
         if (fPrevResult != kNo_Result && fPrevPt.equals(x0, y0)) {
             result = kLineTo_Result;
         } else {
@@ -133,7 +133,7 @@
 
 void SkCullPointsPath::lineTo(int x, int y) {
     SkIPoint   pts[2];
-    
+
     switch (fCP.lineTo(x, y, pts)) {
     case SkCullPoints::kMoveToLineTo_Result:
         fPath->moveTo(SkIntToScalar(pts[0].fX), SkIntToScalar(pts[0].fY));
@@ -184,7 +184,7 @@
     if (hires) {
         const SkScalar coordLimit = SkIntToScalar(16384);
         const SkRect limit = { 0, 0, coordLimit, coordLimit };
-        
+
         SkMatrix matrix;
         matrix.setRectToRect(bounds, limit, SkMatrix::kFill_ScaleToFit);
 
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index 661e017..81ebcbd 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -35,7 +35,7 @@
         // code may need to be revised if that assumption is ever broken.
         if (shader && !shader->asAGradient(NULL)) {
             SkBitmap bm;
-            if (shader->asABitmap(&bm, NULL, NULL) && 
+            if (shader->asABitmap(&bm, NULL, NULL) &&
                 NULL != bm.getTexture()) {
                 return true;
             }
@@ -47,7 +47,7 @@
 
 class AutoImmediateDrawIfNeeded {
 public:
-    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap, 
+    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap,
                               const SkPaint* paint) {
         this->init(canvas, bitmap, paint);
     }
@@ -77,7 +77,7 @@
 
 namespace {
 
-bool isPaintOpaque(const SkPaint* paint, 
+bool isPaintOpaque(const SkPaint* paint,
                    const SkBitmap* bmpReplacesShader = NULL) {
     // TODO: SkXfermode should have a virtual isOpaque method, which would
     // make it possible to test modes that do not have a Coeff representation.
@@ -102,7 +102,7 @@
             } else if (paint->getShader() && !paint->getShader()->isOpaque()) {
                 break;
             }
-            if (paint->getColorFilter() && 
+            if (paint->getColorFilter() &&
                 ((paint->getColorFilter()->getFlags() &
                 SkColorFilter::kAlphaUnchanged_Flag) == 0)) {
                 break;
@@ -112,7 +112,7 @@
             if (paint->getAlpha() != 0) {
                 break;
             }
-            if (paint->getColorFilter() && 
+            if (paint->getColorFilter() &&
                 ((paint->getColorFilter()->getFlags() &
                 SkColorFilter::kAlphaUnchanged_Flag) == 0)) {
                 break;
@@ -203,7 +203,7 @@
 }
 
 void DeferredPipeController::playback() {
-    
+
     for (int currentBlock = 0; currentBlock < fBlockList.count(); currentBlock++ ) {
         fReader.playback(fBlockList[currentBlock].fBlock, fBlockList[currentBlock].fSize);
     }
@@ -376,10 +376,10 @@
 
 void DeferredDevice::beginRecording() {
     SkASSERT(NULL == fRecordingCanvas);
-    fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0, 
+    fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
         fImmediateDevice->width(), fImmediateDevice->height());
 }
-    
+
 void DeferredDevice::setNotificationClient(
     SkDeferredCanvas::NotificationClient* notificationClient) {
     fNotificationClient = notificationClient;
@@ -409,7 +409,7 @@
 
             // Restore pre-purge state
             if (!clipRegion.isEmpty()) {
-                fRecordingCanvas->clipRegion(clipRegion, 
+                fRecordingCanvas->clipRegion(clipRegion,
                     SkRegion::kReplace_Op);
             }
             if (!matrix.isIdentity()) {
@@ -475,7 +475,7 @@
         storageAllocated = this->storageAllocatedForRecording();
     }
 
-    if (fNotificationClient && 
+    if (fNotificationClient &&
         storageAllocated != fPreviousStorageAllocated) {
         fPreviousStorageAllocated = storageAllocated;
         fNotificationClient->storageAllocatedForRecordingChanged(storageAllocated);
@@ -486,16 +486,16 @@
     return fRecordingCanvas;
 }
 
-uint32_t DeferredDevice::getDeviceCapabilities() { 
+uint32_t DeferredDevice::getDeviceCapabilities() {
     return fImmediateDevice->getDeviceCapabilities();
 }
 
-int DeferredDevice::width() const { 
+int DeferredDevice::width() const {
     return fImmediateDevice->width();
 }
 
 int DeferredDevice::height() const {
-    return fImmediateDevice->height(); 
+    return fImmediateDevice->height();
 }
 
 SkGpuRenderTarget* DeferredDevice::accessRenderTarget() {
@@ -661,7 +661,7 @@
 
         if (paint) {
             SkPaint::Style paintStyle = paint->getStyle();
-            if (!(paintStyle == SkPaint::kFill_Style || 
+            if (!(paintStyle == SkPaint::kFill_Style ||
                 paintStyle == SkPaint::kStrokeAndFill_Style)) {
                 return false;
             }
@@ -673,8 +673,8 @@
 
         // The following test holds with AA enabled, and is conservative
         // by a 0.5 pixel margin with AA disabled
-        if (transformedRect.fLeft > SkIntToScalar(0) || 
-            transformedRect.fTop > SkIntToScalar(0) || 
+        if (transformedRect.fLeft > SkIntToScalar(0) ||
+            transformedRect.fTop > SkIntToScalar(0) ||
             transformedRect.fRight < SkIntToScalar(canvasSize.fWidth) ||
             transformedRect.fBottom < SkIntToScalar(canvasSize.fHeight)) {
             return false;
@@ -686,8 +686,8 @@
             {
                 SkIRect bounds;
                 canvas->getClipDeviceBounds(&bounds);
-                if (bounds.fLeft > 0 || bounds.fTop > 0 || 
-                    bounds.fRight < canvasSize.fWidth || 
+                if (bounds.fLeft > 0 || bounds.fTop > 0 ||
+                    bounds.fRight < canvasSize.fWidth ||
                     bounds.fBottom < canvasSize.fHeight)
                     return false;
             }
@@ -808,7 +808,7 @@
 }
 
 void SkDeferredCanvas::drawPaint(const SkPaint& paint) {
-    if (fDeferredDrawing && this->isFullFrame(NULL, &paint) && 
+    if (fDeferredDrawing && this->isFullFrame(NULL, &paint) &&
         isPaintOpaque(&paint)) {
         this->getDeferredDevice()->contentsCleared();
     }
@@ -825,7 +825,7 @@
 }
 
 void SkDeferredCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
-    if (fDeferredDrawing && this->isFullFrame(&rect, &paint) && 
+    if (fDeferredDrawing && this->isFullFrame(&rect, &paint) &&
         isPaintOpaque(&paint)) {
         this->getDeferredDevice()->contentsCleared();
     }
@@ -845,7 +845,7 @@
                                   SkScalar top, const SkPaint* paint) {
     SkRect bitmapRect = SkRect::MakeXYWH(left, top,
         SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
-    if (fDeferredDrawing && 
+    if (fDeferredDrawing &&
         this->isFullFrame(&bitmapRect, paint) &&
         isPaintOpaque(paint, &bitmap)) {
         this->getDeferredDevice()->contentsCleared();
@@ -856,11 +856,11 @@
     this->recordedDrawCommand();
 }
 
-void SkDeferredCanvas::drawBitmapRect(const SkBitmap& bitmap, 
+void SkDeferredCanvas::drawBitmapRect(const SkBitmap& bitmap,
                                       const SkIRect* src,
                                       const SkRect& dst,
                                       const SkPaint* paint) {
-    if (fDeferredDrawing && 
+    if (fDeferredDrawing &&
         this->isFullFrame(&dst, paint) &&
         isPaintOpaque(paint, &bitmap)) {
         this->getDeferredDevice()->contentsCleared();
@@ -896,10 +896,10 @@
                                   const SkPaint* paint) {
     SkRect bitmapRect = SkRect::MakeXYWH(
         SkIntToScalar(left),
-        SkIntToScalar(top), 
+        SkIntToScalar(top),
         SkIntToScalar(bitmap.width()),
         SkIntToScalar(bitmap.height()));
-    if (fDeferredDrawing && 
+    if (fDeferredDrawing &&
         this->isFullFrame(&bitmapRect, paint) &&
         isPaintOpaque(paint, &bitmap)) {
         this->getDeferredDevice()->contentsCleared();
@@ -966,10 +966,10 @@
 }
 
 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
-    this->drawingCanvas()->setDrawFilter(filter); 
+    this->drawingCanvas()->setDrawFilter(filter);
     this->INHERITED::setDrawFilter(filter);
     this->recordedDrawCommand();
-    return filter;    
+    return filter;
 }
 
 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
diff --git a/src/utils/SkInterpolator.cpp b/src/utils/SkInterpolator.cpp
index d43792f..2ef2702 100644
--- a/src/utils/SkInterpolator.cpp
+++ b/src/utils/SkInterpolator.cpp
@@ -165,7 +165,7 @@
 bool SkInterpolator::setKeyFrame(int index, SkMSec time,
                             const SkScalar values[], const SkScalar blend[4]) {
     SkASSERT(values != NULL);
-    
+
     if (blend == NULL) {
         blend = gIdentityBlend;
     }
@@ -237,13 +237,13 @@
                            SkScalar cx, SkScalar cy) {
     // pin to the unit-square, and convert to 2.14
     Dot14 x = pin_and_convert(value);
-    
+
     if (x == 0) return 0;
     if (x == Dot14_ONE) return SK_Scalar1;
-    
+
     Dot14 b = pin_and_convert(bx);
     Dot14 c = pin_and_convert(cx);
-    
+
     // Now compute our coefficients from the control points
     //  t   -> 3b
     //  t^2 -> 3c - 6b
@@ -264,7 +264,7 @@
             t += dt;
         }
     }
-    
+
     // Now we have t, so compute the coeff for Y and evaluate
     b = pin_and_convert(by);
     c = pin_and_convert(cy);
diff --git a/src/utils/SkJSON.cpp b/src/utils/SkJSON.cpp
index c55d464..06989f3 100644
--- a/src/utils/SkJSON.cpp
+++ b/src/utils/SkJSON.cpp
@@ -56,7 +56,7 @@
         SkASSERT(name);
 
         fNext = NULL;
-        
+
         size_t len = strlen(name);
         // extra 1 for str[0] which stores the type
         char* str = alloc_string(1 + len);
@@ -64,14 +64,14 @@
         // str[1] skips the type, len+1 includes the terminating 0 byte.
         memcpy(&str[1], name, len + 1);
         fName = str;
-        
+
         // fValue is uninitialized
     }
     ~Slot();
-    
+
     Type type() const { return (Type)fName[0]; }
     const char* name() const { return &fName[1]; }
-    
+
     Slot*   fNext;
     char*   fName;    // fName[0] is the type, &fName[1] is the "name"
     union {
@@ -378,7 +378,7 @@
 
 void SkJSON::Object::dumpLevel(int level) const {
     for (Slot* slot = fHead; slot; slot = slot->fNext) {
-        Type t = slot->type();        
+        Type t = slot->type();
         tabForLevel(level + 1);
         SkDebugf("\"%s\" : ", slot->name());
         switch (slot->type()) {
@@ -507,11 +507,11 @@
 };
 
 typedef void* (*DupProc)(const void*);
-             
+
 static void* dup_object(const void* src) {
     return SkNEW_ARGS(SkJSON::Object, (*(SkJSON::Object*)src));
 }
-                      
+
 static void* dup_array(const void* src) {
     return SkNEW_ARGS(SkJSON::Array, (*(SkJSON::Array*)src));
 }
@@ -561,7 +561,7 @@
 SkJSON::Array::Array(const int32_t values[], int count) {
     this->init(kInt, count, values);
 }
-    
+
 SkJSON::Array::Array(const float values[], int count) {
     this->init(kFloat, count, values);
 }
diff --git a/src/utils/SkMeshUtils.cpp b/src/utils/SkMeshUtils.cpp
index f7af383..7970ba1 100644
--- a/src/utils/SkMeshUtils.cpp
+++ b/src/utils/SkMeshUtils.cpp
@@ -55,11 +55,11 @@
                 *idx++ = index;
                 *idx++ = index + rows + 1;
                 *idx++ = index + 1;
-                
+
                 *idx++ = index + 1;
                 *idx++ = index + rows + 1;
                 *idx++ = index + rows + 2;
-                
+
                 index += 1;
             }
             index += 1;
@@ -89,7 +89,7 @@
                        int rows, int cols, const SkPoint verts[],
                        const SkColor colors[], const SkPaint& paint) {
     SkMeshIndices idx;
-    
+
     if (idx.init(bitmap.width(), bitmap.height(), rows, cols)) {
         SkPaint p(paint);
         p.setShader(SkShader::CreateBitmapShader(bitmap,
diff --git a/src/utils/SkNinePatch.cpp b/src/utils/SkNinePatch.cpp
index 26ae8eb..9dc8bd2 100644
--- a/src/utils/SkNinePatch.cpp
+++ b/src/utils/SkNinePatch.cpp
@@ -15,11 +15,11 @@
     0, 5, 1,    0, 4, 5,
     1, 6, 2,    1, 5, 6,
     2, 7, 3,    2, 6, 7,
-    
+
     4, 9, 5,    4, 8, 9,
     5, 10, 6,   5, 9, 10,
     6, 11, 7,   6, 10, 11,
-    
+
     8, 13, 9,   8, 12, 13,
     9, 14, 10,  9, 13, 14,
     10, 15, 11, 10, 14, 15
@@ -27,18 +27,18 @@
 
 static int fillIndices(uint16_t indices[], int xCount, int yCount) {
     uint16_t* startIndices = indices;
-    
+
     int n = 0;
     for (int y = 0; y < yCount; y++) {
         for (int x = 0; x < xCount; x++) {
             *indices++ = n;
             *indices++ = n + xCount + 2;
             *indices++ = n + 1;
-            
+
             *indices++ = n;
             *indices++ = n + xCount + 1;
             *indices++ = n + xCount + 2;
-            
+
             n += 1;
         }
         n += 1;
@@ -108,14 +108,14 @@
     if (bounds.isEmpty() || bitmap.width() == 0 || bitmap.height() == 0) {
         return;
     }
-    
+
     // should try a quick-reject test before calling lockPixels
     SkAutoLockPixels alp(bitmap);
     // after the lock, it is valid to check
     if (!bitmap.readyToDraw()) {
         return;
     }
-    
+
     // check for degenerate divs (just an optimization, not required)
     {
         int i;
@@ -129,17 +129,17 @@
             numYDivs -= 1;
         }
     }
-    
+
     Mesh mesh;
-    
+
     const int numXStretch = (numXDivs + 1) >> 1;
     const int numYStretch = (numYDivs + 1) >> 1;
-    
+
     if (numXStretch < 1 && numYStretch < 1) {
         canvas->drawBitmapRect(bitmap, NULL, bounds, paint);
         return;
     }
-    
+
     if (false) {
         int i;
         for (i = 0; i < numXDivs; i++) {
@@ -149,9 +149,9 @@
             SkDebugf("--- ydivs[%d] %d\n", i, yDivs[i]);
         }
     }
-    
+
     SkScalar stretchX = 0, stretchY = 0;
-    
+
     if (numXStretch > 0) {
         int stretchSize = 0;
         for (int i = 1; i < numXDivs; i += 2) {
@@ -163,7 +163,7 @@
         else // reuse stretchX, but keep it negative as a signal
             stretchX = SkScalarDiv(-bounds.width(), fixed);
     }
-    
+
     if (numYStretch > 0) {
         int stretchSize = 0;
         for (int i = 1; i < numYDivs; i += 2) {
@@ -175,7 +175,7 @@
         else // reuse stretchX, but keep it negative as a signal
             stretchY = SkScalarDiv(-bounds.height(), fixed);
     }
-    
+
 #if 0
     SkDebugf("---- drawasamesh [%d %d] -> [%g %g] <%d %d> (%g %g)\n",
              bitmap.width(), bitmap.height(),
@@ -193,12 +193,12 @@
     SkPoint* verts = (SkPoint*)storage.get();
     SkPoint* texs = verts + vCount;
     uint16_t* indices = (uint16_t*)(texs + vCount);
-    
+
     mesh.fVerts = verts;
     mesh.fTexs = texs;
     mesh.fColors = NULL;
     mesh.fIndices = NULL;
-    
+
     // we use <= for YDivs, since the prebuild indices work for 3x2 and 3x1 too
     if (numXDivs == 2 && numYDivs <= 2) {
         mesh.fIndices = g3x3Indices;
@@ -207,7 +207,7 @@
         SkASSERT(n == indexCount);
         mesh.fIndices = indices;
     }
-    
+
     SkScalar vy = bounds.fTop;
     fillRow(verts, texs, vy, 0, bounds, xDivs, numXDivs,
             stretchX, bitmap.width());
@@ -235,7 +235,7 @@
     }
     fillRow(verts, texs, bounds.fBottom, SkIntToScalar(bitmap.height()),
             bounds, xDivs, numXDivs, stretchX, bitmap.width());
-    
+
     SkShader* shader = SkShader::CreateBitmapShader(bitmap,
                                                     SkShader::kClamp_TileMode,
                                                     SkShader::kClamp_TileMode);
@@ -310,7 +310,7 @@
     if (false /* is our canvas backed by a gpu?*/) {
         int32_t xDivs[2];
         int32_t yDivs[2];
-        
+
         xDivs[0] = margins.fLeft;
         xDivs[1] = bitmap.width() - margins.fRight;
         yDivs[0] = margins.fTop;
@@ -326,7 +326,7 @@
                 (margins.fTop + margins.fBottom);
             yDivs[1] = yDivs[0];
         }
-        
+
         SkNinePatch::DrawMesh(canvas, bounds, bitmap,
                               xDivs, 2, yDivs, 2, paint);
     } else {
diff --git a/src/utils/SkParse.cpp b/src/utils/SkParse.cpp
index cb265c3..9609ddc 100644
--- a/src/utils/SkParse.cpp
+++ b/src/utils/SkParse.cpp
@@ -62,7 +62,7 @@
     return str;
 }
 
-int SkParse::Count(const char str[]) 
+int SkParse::Count(const char str[])
 {
     char c;
     int count = 0;
@@ -83,7 +83,7 @@
     return count;
 }
 
-int SkParse::Count(const char str[], char separator) 
+int SkParse::Count(const char str[], char separator)
 {
     char c;
     int count = 0;
@@ -234,7 +234,7 @@
 
     if (*str == '.')
     {
-        static const int gFractions[] = { (1 << 24)  / 10, (1 << 24)  / 100, (1 << 24)  / 1000, 
+        static const int gFractions[] = { (1 << 24)  / 10, (1 << 24)  / 100, (1 << 24)  / 1000,
             (1 << 24)  / 10000, (1 << 24)  / 100000 };
         str += 1;
         int d = 0;
@@ -330,7 +330,7 @@
 }
 
 #ifdef SK_SUPPORT_UNITTEST
-void SkParse::UnitTest() 
+void SkParse::UnitTest()
 {
     // !!! additional parse tests go here
     SkParse::TestColor();
diff --git a/src/utils/SkParsePath.cpp b/src/utils/SkParsePath.cpp
index 22433e6..18ea5e0 100644
--- a/src/utils/SkParsePath.cpp
+++ b/src/utils/SkParsePath.cpp
@@ -58,7 +58,7 @@
     return str;
 }
 
-static const char* find_scalar(const char str[], SkScalar* value, 
+static const char* find_scalar(const char str[], SkScalar* value,
                                bool isRelative, SkScalar relative) {
     str = SkParse::FindScalar(str, value);
     if (isRelative) {
@@ -103,7 +103,7 @@
                 op = 'L';
                 c = points[0];
                 break;
-            case 'L': 
+            case 'L':
                 data = find_points(data, points, 1, relative, &c);
                 path.lineTo(points[0]);
                 c = points[0];
@@ -120,10 +120,10 @@
                 path.lineTo(c.fX, y);
                 c.fY = y;
             } break;
-            case 'C': 
+            case 'C':
                 data = find_points(data, points, 3, relative, &c);
                 goto cubicCommon;
-            case 'S': 
+            case 'S':
                 data = find_points(data, &points[1], 2, relative, &c);
                 points[0] = c;
                 if (previousOp == 'C' || previousOp == 'S') {
@@ -191,7 +191,7 @@
 #ifdef SK_SCALAR_IS_FLOAT
     char buffer[64];
 #ifdef SK_BUILD_FOR_WIN32
-	int len = _snprintf(buffer, sizeof(buffer), "%g", value);
+    int len = _snprintf(buffer, sizeof(buffer), "%g", value);
 #else
     int len = snprintf(buffer, sizeof(buffer), "%g", value);
 #endif
diff --git a/src/utils/SkThreadUtils.h b/src/utils/SkThreadUtils.h
index b0c5044..8963981 100644
--- a/src/utils/SkThreadUtils.h
+++ b/src/utils/SkThreadUtils.h
@@ -13,32 +13,32 @@
 class SkThread : SkNoncopyable {
 public:
     typedef void (*entryPointProc)(void*);
-    
+
     SkThread(entryPointProc entryPoint, void* data = NULL);
-    
+
     /**
      * Non-virtual, do not subclass.
      */
     ~SkThread();
-    
+
     /**
      * Starts the thread. Returns false if the thread could not be started.
      */
     bool start();
-    
+
     /**
      * Waits for the thread to finish.
      * If the thread has not started, returns immediately.
      */
     void join();
-    
+
     /**
      * SkThreads with an affinity for the same processor will attempt to run cache
      * locally with each other. SkThreads with an affinity for different processors
      * will attempt to run on different cores. Returns false if the request failed.
      */
     bool setProcessorAffinity(unsigned int processor);
-    
+
 private:
     void* fData;
 };
diff --git a/src/utils/mac/SkBitmap_Mac.cpp b/src/utils/mac/SkBitmap_Mac.cpp
index a995131..1f73f0f 100644
--- a/src/utils/mac/SkBitmap_Mac.cpp
+++ b/src/utils/mac/SkBitmap_Mac.cpp
@@ -20,7 +20,7 @@
 static void convertGL32_to_Mac32(uint32_t dst[], const SkBitmap& bm) {
     memcpy(dst, bm.getPixels(), bm.getSize());
     return;
-    
+
     uint32_t* stop = dst + (bm.getSize() >> 2);
     const uint8_t* src = (const uint8_t*)bm.getPixels();
     while (dst < stop) {
@@ -38,7 +38,7 @@
             unsigned r = SkPacked16ToR32(c);
             unsigned g = SkPacked16ToG32(c);
             unsigned b = SkPacked16ToB32(c);
-        
+
             *dst++ = (b << 24) | (g << 16) | (r << 8) | 0xFF;
         }
     }
@@ -47,11 +47,11 @@
 static void convert4444_to_555(uint16_t dst[], const uint16_t src[], int count)
 {
     const uint16_t* stop = src + count;
-    
+
     while (src < stop)
     {
         unsigned c = *src++;
-        
+
         unsigned r = SkGetPackedR4444(c);
         unsigned g = SkGetPackedG4444(c);
         unsigned b = SkGetPackedB4444(c);
@@ -61,7 +61,7 @@
         b = (b << 1) | (b >> 3);
         // build the 555
         c = (r << 10) | (g << 5) | b;
-        
+
 #ifdef SWAP_16BIT
         c = (c >> 8) | (c << 8);
 #endif
@@ -111,10 +111,10 @@
 }
 
 void SkBitmap::drawToPort(WindowRef wind, CGContextRef cg) const {
-	if (fPixels == NULL || fWidth == 0 || fHeight == 0) {
-		return;
+    if (fPixels == NULL || fWidth == 0 || fHeight == 0) {
+        return;
     }
-    
+
     bool useQD = false;
     if (NULL == cg) {
         SetPortWindowPort(wind);
@@ -136,7 +136,7 @@
         rect.origin.x = rect.origin.y = 0;
         rect.size.width = bm.width();
         rect.size.height = bm.height();
-        
+
         CGContextDrawImage(cg, rect, image);
         CGImageRelease(image);
     }
diff --git a/src/utils/mac/SkCreateCGImageRef.cpp b/src/utils/mac/SkCreateCGImageRef.cpp
index e5f7c69..df20ba9 100644
--- a/src/utils/mac/SkCreateCGImageRef.cpp
+++ b/src/utils/mac/SkCreateCGImageRef.cpp
@@ -18,14 +18,14 @@
     (SK_A32_SHIFT == (a) && SK_R32_SHIFT == (r) \
     && SK_G32_SHIFT == (g) && SK_B32_SHIFT == (b))
 
-static bool getBitmapInfo(const SkBitmap& bm, 
+static bool getBitmapInfo(const SkBitmap& bm,
                           size_t* bitsPerComponent,
                           CGBitmapInfo* info,
                           bool* upscaleTo32) {
     if (upscaleTo32) {
         *upscaleTo32 = false;
     }
-    
+
     switch (bm.config()) {
         case SkBitmap::kRGB_565_Config:
             if (upscaleTo32) {
@@ -105,11 +105,11 @@
     const size_t s = bitmap->getSize();
 
     // our provider "owns" the bitmap*, and will take care of deleting it
-	// we initially lock it, so we can access the pixels. The bitmap will be deleted in the release
-	// proc, which will in turn unlock the pixels
-	bitmap->lockPixels();
+    // we initially lock it, so we can access the pixels. The bitmap will be deleted in the release
+    // proc, which will in turn unlock the pixels
+    bitmap->lockPixels();
     CGDataProviderRef dataRef = CGDataProviderCreateWithData(bitmap, bitmap->getPixels(), s,
-															 SkBitmap_ReleaseInfo);
+                                                             SkBitmap_ReleaseInfo);
 
     bool releaseColorSpace = false;
     if (NULL == colorSpace) {
@@ -177,7 +177,7 @@
     if (NULL == data) {
         return false;
     }
-    
+
     CGPDFDocumentRef pdf = CGPDFDocumentCreateWithProvider(data);
     CGDataProviderRelease(data);
     if (NULL == pdf) {
@@ -189,12 +189,12 @@
     if (NULL == page) {
         return false;
     }
-    
+
     CGRect bounds = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);
-    
+
     int w = (int)CGRectGetWidth(bounds);
     int h = (int)CGRectGetHeight(bounds);
-        
+
     SkBitmap bitmap;
     bitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h);
     bitmap.allocPixels();
@@ -202,7 +202,7 @@
 
     size_t bitsPerComponent;
     CGBitmapInfo info;
-    getBitmapInfo(bitmap, &bitsPerComponent, &info, NULL); 
+    getBitmapInfo(bitmap, &bitsPerComponent, &info, NULL);
 
     CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
     CGContextRef ctx = CGBitmapContextCreate(bitmap.getPixels(), w, h,
diff --git a/src/utils/win/SkDWriteFontFileStream.h b/src/utils/win/SkDWriteFontFileStream.h
index cd5787e..b214858 100644
--- a/src/utils/win/SkDWriteFontFileStream.h
+++ b/src/utils/win/SkDWriteFontFileStream.h
@@ -23,7 +23,7 @@
 public:
     explicit SkDWriteFontFileStream(IDWriteFontFileStream* fontFileStream);
     virtual ~SkDWriteFontFileStream();
-    
+
     virtual bool rewind() SK_OVERRIDE;
     virtual size_t read(void* buffer, size_t size) SK_OVERRIDE;
     virtual const void* getMemoryBase() SK_OVERRIDE;
diff --git a/src/utils/win/SkDWriteGeometrySink.cpp b/src/utils/win/SkDWriteGeometrySink.cpp
index 4aec3bb..5455e66 100644
--- a/src/utils/win/SkDWriteGeometrySink.cpp
+++ b/src/utils/win/SkDWriteGeometrySink.cpp
@@ -28,7 +28,7 @@
         return S_OK;
     } else {
         *object = NULL;
-        return E_NOINTERFACE; 
+        return E_NOINTERFACE;
     }
 }
 
diff --git a/src/utils/win/SkHRESULT.cpp b/src/utils/win/SkHRESULT.cpp
index 3d463f8..8b6b79f 100644
--- a/src/utils/win/SkHRESULT.cpp
+++ b/src/utils/win/SkHRESULT.cpp
@@ -13,7 +13,7 @@
                HRESULT hr, const char* msg) {
     SkDEBUGCODE(if (NULL != msg) SkDEBUGF(("%s\n", msg)));
     SkDEBUGF(("%s(%lu) : error 0x%x: ", file, line, hr));
-    
+
     LPSTR errorText = NULL;
     FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_SYSTEM |
@@ -25,7 +25,7 @@
                    0,
                    NULL
     );
-    
+
     if (NULL == errorText) {
         SkDEBUGF(("<unknown>\n"));
     } else {
diff --git a/src/utils/win/SkIStream.cpp b/src/utils/win/SkIStream.cpp
index fce015c..1d00611 100644
--- a/src/utils/win/SkIStream.cpp
+++ b/src/utils/win/SkIStream.cpp
@@ -34,7 +34,7 @@
         return S_OK;
     } else {
         *ppvObject = NULL;
-        return E_NOINTERFACE; 
+        return E_NOINTERFACE;
     }
 }
 
@@ -62,7 +62,7 @@
 { return E_NOTIMPL; }
 
 // IStream Interface
-HRESULT STDMETHODCALLTYPE SkBaseIStream::SetSize(ULARGE_INTEGER) 
+HRESULT STDMETHODCALLTYPE SkBaseIStream::SetSize(ULARGE_INTEGER)
 { return E_NOTIMPL; }
 
 HRESULT STDMETHODCALLTYPE SkBaseIStream::CopyTo(IStream*
@@ -190,7 +190,7 @@
         hr = STG_E_INVALIDFUNCTION;
         break;
     }
-    
+
     if (NULL != lpNewFilePointer) {
         lpNewFilePointer->QuadPart = this->fLocation.QuadPart;
     }
diff --git a/src/views/SkBGViewArtist.cpp b/src/views/SkBGViewArtist.cpp
index d9a45b8..ffc410a 100644
--- a/src/views/SkBGViewArtist.cpp
+++ b/src/views/SkBGViewArtist.cpp
@@ -11,7 +11,7 @@
 
 SkBGViewArtist::SkBGViewArtist(SkColor c)
 {
-	fPaint.setColor(c);
+    fPaint.setColor(c);
 }
 
 SkBGViewArtist::~SkBGViewArtist()
@@ -20,12 +20,12 @@
 
 void SkBGViewArtist::onDraw(SkView*, SkCanvas* canvas)
 {
-	// only works for views that are clipped their bounds.
-	canvas->drawPaint(fPaint);
+    // only works for views that are clipped their bounds.
+    canvas->drawPaint(fPaint);
 }
 
 void SkBGViewArtist::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	SkPaint_Inflate(&fPaint, dom, node);
+    SkPaint_Inflate(&fPaint, dom, node);
 }
 
diff --git a/src/views/SkEvent.cpp b/src/views/SkEvent.cpp
index 0149215..1513170 100644
--- a/src/views/SkEvent.cpp
+++ b/src/views/SkEvent.cpp
@@ -59,9 +59,9 @@
     return strlen(buffer);
 }
 
-void SkEvent::getType(SkString* str) const 
-{ 
-    if (str) 
+void SkEvent::getType(SkString* str) const
+{
+    if (str)
     {
         if ((size_t) fType & 1) // not a pointer
         {
@@ -74,13 +74,13 @@
     }
 }
 
-bool SkEvent::isType(const SkString& str) const 
+bool SkEvent::isType(const SkString& str) const
 {
-    return this->isType(str.c_str(), str.size()); 
+    return this->isType(str.c_str(), str.size());
 }
 
-bool SkEvent::isType(const char type[], size_t typeLen) const 
-{ 
+bool SkEvent::isType(const char type[], size_t typeLen) const
+{
     if (typeLen == 0)
         typeLen = strlen(type);
     if ((size_t) fType & 1) {   // not a pointer
@@ -88,7 +88,7 @@
         size_t len = makeCharArray(chars, (size_t) fType);
         return len == typeLen && strncmp(chars, type, typeLen) == 0;
     }
-    return strncmp(fType, type, typeLen) == 0 && fType[typeLen] == 0; 
+    return strncmp(fType, type, typeLen) == 0 && fType[typeLen] == 0;
 }
 
 void SkEvent::setType(const char type[], size_t typeLen)
@@ -183,7 +183,7 @@
     {
         if (title)
             SkDebugf("%s ", title);
-            
+
         SkString    etype;
         this->getType(&etype);
         SkDebugf("event<%s> fast32=%d", etype.c_str(), this->getFast32());
@@ -193,7 +193,7 @@
         SkMetaData::Type    mtype;
         int                 count;
         const char*         name;
-        
+
         while ((name = iter.next(&mtype, &count)) != NULL)
         {
             SkASSERT(count > 0);
@@ -296,7 +296,7 @@
         delete this;
         return;
     }
-    
+
     if (delay) {
         this->postTime(SkTime::GetMSecs() + delay);
         return;
@@ -307,7 +307,7 @@
     globals.fEventMutex.acquire();
     bool wasEmpty = SkEvent::Enqueue(this);
     globals.fEventMutex.release();
-    
+
     // call outside of us holding the mutex
     if (wasEmpty) {
         SkEvent::SignalNonEmptyQueue();
@@ -321,11 +321,11 @@
     }
 
     SkEvent_Globals& globals = getGlobals();
-    
+
     globals.fEventMutex.acquire();
     SkMSec queueDelay = SkEvent::EnqueueTime(this, time);
     globals.fEventMutex.release();
-    
+
     // call outside of us holding the mutex
     if ((int32_t)queueDelay != ~0) {
         SkEvent::SignalQueueTimer(queueDelay);
@@ -473,7 +473,7 @@
 int SkEvent::CountEventsOnQueue() {
     SkEvent_Globals& globals = getGlobals();
     globals.fEventMutex.acquire();
-    
+
     int count = 0;
     const SkEvent* evt = globals.fEventQHead;
     while (evt) {
diff --git a/src/views/SkEventSink.cpp b/src/views/SkEventSink.cpp
index 8f39156..b6a3a6e 100644
--- a/src/views/SkEventSink.cpp
+++ b/src/views/SkEventSink.cpp
@@ -163,7 +163,7 @@
     this->addTagList(next);
 }
 
-void SkEventSink::copyListeners(const SkEventSink& sink) 
+void SkEventSink::copyListeners(const SkEventSink& sink)
 {
     SkListenersTagList* sinkList = (SkListenersTagList*)sink.findTagList(kListeners_SkTagList);
     if (sinkList == NULL)
@@ -226,7 +226,7 @@
     if (proc) {
         return proc(evt) ? kHandled_EventResult : kNotHandled_EventResult;
     }
-        
+
     SkEventSink* sink = SkEventSink::FindSink(evt.getTargetID());
     if (sink) {
         return sink->doEvent(evt) ? kHandled_EventResult : kNotHandled_EventResult;
diff --git a/src/views/SkOSMenu.cpp b/src/views/SkOSMenu.cpp
index ed37541..3de0a9e 100644
--- a/src/views/SkOSMenu.cpp
+++ b/src/views/SkOSMenu.cpp
@@ -11,7 +11,7 @@
 static int gOSMenuCmd = 7000;
 
 SkOSMenu::SkOSMenu(const char title[]) {
-	fTitle.set(title);
+    fTitle.set(title);
 }
 
 SkOSMenu::~SkOSMenu() {
@@ -46,7 +46,7 @@
     }
 }
 
-bool SkOSMenu::handleKeyEquivalent(SkUnichar key) {    
+bool SkOSMenu::handleKeyEquivalent(SkUnichar key) {
     int value = 0, size = 0;
     bool state;
     SkOSMenu::TriState tristate;
@@ -89,7 +89,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkOSMenu::Item::Item(const char label[], SkOSMenu::Type type, 
+SkOSMenu::Item::Item(const char label[], SkOSMenu::Type type,
                      const char slotName[], SkEvent* evt) {
     fLabel.set(label);
     fSlotName.set(slotName);
@@ -133,7 +133,7 @@
 static const char* gList_Items_Str = "SkOSMenuList_Items";
 static const char* gList_ItemCount_S32 = "SkOSMenuList_ItemCount";
 
-int SkOSMenu::appendItem(const char label[], Type type, const char slotName[], 
+int SkOSMenu::appendItem(const char label[], Type type, const char slotName[],
                          SkEvent* evt) {
     SkOSMenu::Item* item = new Item(label, type, slotName, evt);
     fItems.append(1, &item);
@@ -147,7 +147,7 @@
     return appendItem(label, SkOSMenu::kAction_Type, "", evt);
 }
 
-int SkOSMenu::appendList(const char label[], const char slotName[], 
+int SkOSMenu::appendList(const char label[], const char slotName[],
                          SkEventSinkID target, int index, const char option[], ...) {
     SkEvent* evt = new SkEvent(gMenuEventType, target);
     va_list args;
@@ -168,8 +168,8 @@
     return appendItem(label, SkOSMenu::kList_Type, slotName, evt);
 }
 
-int SkOSMenu::appendSlider(const char label[], const char slotName[], 
-                           SkEventSinkID target, SkScalar min, SkScalar max, 
+int SkOSMenu::appendSlider(const char label[], const char slotName[],
+                           SkEventSinkID target, SkScalar min, SkScalar max,
                            SkScalar defaultValue) {
     SkEvent* evt = new SkEvent(gMenuEventType, target);
     evt->setScalar(gSlider_Min_Scalar, min);
@@ -178,7 +178,7 @@
     return appendItem(label, SkOSMenu::kSlider_Type, slotName, evt);
 }
 
-int SkOSMenu::appendSwitch(const char label[], const char slotName[], 
+int SkOSMenu::appendSwitch(const char label[], const char slotName[],
                            SkEventSinkID target, bool defaultState) {
     SkEvent* evt = new SkEvent(gMenuEventType, target);
     evt->setBool(slotName, defaultState);
@@ -192,7 +192,7 @@
     return appendItem(label, SkOSMenu::kTriState_Type, slotName, evt);
 }
 
-int SkOSMenu::appendTextField(const char label[], const char slotName[], 
+int SkOSMenu::appendTextField(const char label[], const char slotName[],
                               SkEventSinkID target, const char placeholder[]) {
     SkEvent* evt = new SkEvent(gMenuEventType, target);
     evt->setString(slotName, placeholder);
@@ -234,7 +234,7 @@
 }
 
 bool SkOSMenu::FindListIndex(const SkEvent& evt, const char slotName[], int* value) {
-    return evt.isType(gMenuEventType) && evt.findS32(slotName, value); 
+    return evt.isType(gMenuEventType) && evt.findS32(slotName, value);
 }
 
 bool SkOSMenu::FindSliderValue(const SkEvent& evt, const char slotName[], SkScalar* value) {
diff --git a/src/views/SkParsePaint.cpp b/src/views/SkParsePaint.cpp
index 4839439..7a305f2 100644
--- a/src/views/SkParsePaint.cpp
+++ b/src/views/SkParsePaint.cpp
@@ -13,98 +13,98 @@
 
 static SkShader* inflate_shader(const SkDOM& dom, const SkDOM::Node* node)
 {
-	if ((node = dom.getFirstChild(node, "shader")) == NULL)
-		return NULL;
+    if ((node = dom.getFirstChild(node, "shader")) == NULL)
+        return NULL;
 
-	const char* str;
+    const char* str;
 
-	if (dom.hasAttr(node, "type", "linear-gradient"))
-	{
-		SkColor		colors[2];
-		SkPoint		pts[2];
+    if (dom.hasAttr(node, "type", "linear-gradient"))
+    {
+        SkColor        colors[2];
+        SkPoint        pts[2];
 
-		colors[0] = colors[1] = SK_ColorBLACK;	// need to initialized the alpha to opaque, since FindColor doesn't set it
-		if ((str = dom.findAttr(node, "c0")) != NULL &&
-			SkParse::FindColor(str, &colors[0]) &&
-			(str = dom.findAttr(node, "c1")) != NULL &&
-			SkParse::FindColor(str, &colors[1]) &&
-			dom.findScalars(node, "p0", &pts[0].fX, 2) &&
-			dom.findScalars(node, "p1", &pts[1].fX, 2))
-		{
-			SkShader::TileMode	mode = SkShader::kClamp_TileMode;
-			int					index;
+        colors[0] = colors[1] = SK_ColorBLACK;    // need to initialized the alpha to opaque, since FindColor doesn't set it
+        if ((str = dom.findAttr(node, "c0")) != NULL &&
+            SkParse::FindColor(str, &colors[0]) &&
+            (str = dom.findAttr(node, "c1")) != NULL &&
+            SkParse::FindColor(str, &colors[1]) &&
+            dom.findScalars(node, "p0", &pts[0].fX, 2) &&
+            dom.findScalars(node, "p1", &pts[1].fX, 2))
+        {
+            SkShader::TileMode    mode = SkShader::kClamp_TileMode;
+            int                    index;
 
-			if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
-				mode = (SkShader::TileMode)index;
-			return SkGradientShader::CreateLinear(pts, colors, NULL, 2, mode);
-		}
-	}
-	else if (dom.hasAttr(node, "type", "bitmap"))
-	{
-		if ((str = dom.findAttr(node, "src")) == NULL)
-			return NULL;
+            if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
+                mode = (SkShader::TileMode)index;
+            return SkGradientShader::CreateLinear(pts, colors, NULL, 2, mode);
+        }
+    }
+    else if (dom.hasAttr(node, "type", "bitmap"))
+    {
+        if ((str = dom.findAttr(node, "src")) == NULL)
+            return NULL;
 
-		SkBitmap	bm;
+        SkBitmap    bm;
 
-		if (SkImageDecoder::DecodeFile(str, &bm))
-		{
-			SkShader::TileMode	mode = SkShader::kRepeat_TileMode;
-			int					index;
+        if (SkImageDecoder::DecodeFile(str, &bm))
+        {
+            SkShader::TileMode    mode = SkShader::kRepeat_TileMode;
+            int                    index;
 
-			if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
-				mode = (SkShader::TileMode)index;
+            if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0)
+                mode = (SkShader::TileMode)index;
 
-			return SkShader::CreateBitmapShader(bm, mode, mode);
-		}
-	}
-	return NULL;
+            return SkShader::CreateBitmapShader(bm, mode, mode);
+        }
+    }
+    return NULL;
 }
 
 void SkPaint_Inflate(SkPaint* paint, const SkDOM& dom, const SkDOM::Node* node)
 {
-	SkASSERT(paint);
-	SkASSERT(&dom);
-	SkASSERT(node);
+    SkASSERT(paint);
+    SkASSERT(&dom);
+    SkASSERT(node);
 
-	SkScalar x;
+    SkScalar x;
 
-	if (dom.findScalar(node, "stroke-width", &x))
-		paint->setStrokeWidth(x);
-	if (dom.findScalar(node, "text-size", &x))
-		paint->setTextSize(x);
-	
-	bool	b;
+    if (dom.findScalar(node, "stroke-width", &x))
+        paint->setStrokeWidth(x);
+    if (dom.findScalar(node, "text-size", &x))
+        paint->setTextSize(x);
 
-	SkASSERT("legacy: use is-stroke" && !dom.findBool(node, "is-frame", &b));
+    bool    b;
 
-	if (dom.findBool(node, "is-stroke", &b))
-		paint->setStyle(b ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
-	if (dom.findBool(node, "is-antialias", &b))
-		paint->setAntiAlias(b);
-	if (dom.findBool(node, "is-lineartext", &b))
-		paint->setLinearText(b);
+    SkASSERT("legacy: use is-stroke" && !dom.findBool(node, "is-frame", &b));
 
-	const char* str = dom.findAttr(node, "color");
-	if (str)
-	{
-		SkColor	c = paint->getColor();
-		if (SkParse::FindColor(str, &c))
-			paint->setColor(c);
-	}
+    if (dom.findBool(node, "is-stroke", &b))
+        paint->setStyle(b ? SkPaint::kStroke_Style : SkPaint::kFill_Style);
+    if (dom.findBool(node, "is-antialias", &b))
+        paint->setAntiAlias(b);
+    if (dom.findBool(node, "is-lineartext", &b))
+        paint->setLinearText(b);
 
-	// do this AFTER parsing for the color
-	if (dom.findScalar(node, "opacity", &x))
-	{
-		x = SkMaxScalar(0, SkMinScalar(x, SK_Scalar1));
-		paint->setAlpha(SkScalarRound(x * 255));
-	}
+    const char* str = dom.findAttr(node, "color");
+    if (str)
+    {
+        SkColor    c = paint->getColor();
+        if (SkParse::FindColor(str, &c))
+            paint->setColor(c);
+    }
 
-	int	index = dom.findList(node, "text-anchor", "left,center,right");
-	if (index >= 0)
-		paint->setTextAlign((SkPaint::Align)index);
+    // do this AFTER parsing for the color
+    if (dom.findScalar(node, "opacity", &x))
+    {
+        x = SkMaxScalar(0, SkMinScalar(x, SK_Scalar1));
+        paint->setAlpha(SkScalarRound(x * 255));
+    }
 
-	SkShader* shader = inflate_shader(dom, node);
-	if (shader)
-		paint->setShader(shader)->unref();
+    int    index = dom.findList(node, "text-anchor", "left,center,right");
+    if (index >= 0)
+        paint->setTextAlign((SkPaint::Align)index);
+
+    SkShader* shader = inflate_shader(dom, node);
+    if (shader)
+        paint->setShader(shader)->unref();
 }
 
diff --git a/src/views/SkProgressView.cpp b/src/views/SkProgressView.cpp
index d82b48e..edb78bd 100644
--- a/src/views/SkProgressView.cpp
+++ b/src/views/SkProgressView.cpp
@@ -14,120 +14,120 @@
 
 SkProgressView::SkProgressView(uint32_t flags) : SkView(flags), fOnShader(NULL), fOffShader(NULL)
 {
-	fValue = 0;
-	fMax = 0;
-	fInterp = NULL;
-	fDoInterp = false;
+    fValue = 0;
+    fMax = 0;
+    fInterp = NULL;
+    fDoInterp = false;
 }
 
 SkProgressView::~SkProgressView()
 {
-	delete fInterp;
-	SkSafeUnref(fOnShader);
-	SkSafeUnref(fOffShader);
+    delete fInterp;
+    SkSafeUnref(fOnShader);
+    SkSafeUnref(fOffShader);
 }
 
 void SkProgressView::setMax(U16CPU max)
 {
-	if (fMax != max)
-	{
-		fMax = SkToU16(max);
-		if (fValue > 0)
-			this->inval(NULL);
-	}
+    if (fMax != max)
+    {
+        fMax = SkToU16(max);
+        if (fValue > 0)
+            this->inval(NULL);
+    }
 }
 
 void SkProgressView::setValue(U16CPU value)
 {
-	if (fValue != value)
-	{
-		if (fDoInterp)
-		{
-			if (fInterp)
-				delete fInterp;
-			fInterp = new SkInterpolator(1, 2);
-			SkScalar x = (SkScalar)(fValue << 8);
-			fInterp->setKeyFrame(0, SkTime::GetMSecs(), &x, 0);
-			x = (SkScalar)(value << 8);
-			fInterp->setKeyFrame(1, SkTime::GetMSecs() + 333, &x);
-		}
-		fValue = SkToU16(value);
-		this->inval(NULL);
-	}
+    if (fValue != value)
+    {
+        if (fDoInterp)
+        {
+            if (fInterp)
+                delete fInterp;
+            fInterp = new SkInterpolator(1, 2);
+            SkScalar x = (SkScalar)(fValue << 8);
+            fInterp->setKeyFrame(0, SkTime::GetMSecs(), &x, 0);
+            x = (SkScalar)(value << 8);
+            fInterp->setKeyFrame(1, SkTime::GetMSecs() + 333, &x);
+        }
+        fValue = SkToU16(value);
+        this->inval(NULL);
+    }
 }
 
 void SkProgressView::onDraw(SkCanvas* canvas)
 {
-	if (fMax == 0)
-		return;
+    if (fMax == 0)
+        return;
 
-	SkFixed	percent;
+    SkFixed    percent;
 
-	if (fInterp)
-	{
-		SkScalar x;
-		if (fInterp->timeToValues(SkTime::GetMSecs(), &x) == SkInterpolator::kFreezeEnd_Result)
-		{
-			delete fInterp;
-			fInterp = NULL;
-		}
-		percent = (SkFixed)x;	// now its 16.8
-		percent = SkMax32(0, SkMin32(percent, fMax << 8));	// now its pinned
-		percent = SkFixedDiv(percent, fMax << 8);	// now its 0.16
-		this->inval(NULL);
-	}
-	else
-	{
-		U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
-		percent = SkFixedDiv(value, fMax);
-	}
+    if (fInterp)
+    {
+        SkScalar x;
+        if (fInterp->timeToValues(SkTime::GetMSecs(), &x) == SkInterpolator::kFreezeEnd_Result)
+        {
+            delete fInterp;
+            fInterp = NULL;
+        }
+        percent = (SkFixed)x;    // now its 16.8
+        percent = SkMax32(0, SkMin32(percent, fMax << 8));    // now its pinned
+        percent = SkFixedDiv(percent, fMax << 8);    // now its 0.16
+        this->inval(NULL);
+    }
+    else
+    {
+        U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
+        percent = SkFixedDiv(value, fMax);
+    }
 
 
-	SkRect	r;
-	SkPaint	p;
+    SkRect    r;
+    SkPaint    p;
 
-	r.set(0, 0, this->width(), this->height());
-	p.setAntiAlias(true);
-	
-	r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
-	p.setStyle(SkPaint::kFill_Style);
+    r.set(0, 0, this->width(), this->height());
+    p.setAntiAlias(true);
 
-	p.setColor(SK_ColorDKGRAY);
-	p.setShader(fOnShader);
-	canvas->drawRect(r, p);
+    r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
+    p.setStyle(SkPaint::kFill_Style);
 
-	p.setColor(SK_ColorWHITE);
-	p.setShader(fOffShader);
-	r.fLeft = r.fRight;
-	r.fRight = this->width() - SK_Scalar1;
-	if (r.width() > 0)
-		canvas->drawRect(r, p);
+    p.setColor(SK_ColorDKGRAY);
+    p.setShader(fOnShader);
+    canvas->drawRect(r, p);
+
+    p.setColor(SK_ColorWHITE);
+    p.setShader(fOffShader);
+    r.fLeft = r.fRight;
+    r.fRight = this->width() - SK_Scalar1;
+    if (r.width() > 0)
+        canvas->drawRect(r, p);
 }
 
 #include "SkImageDecoder.h"
 
 static SkShader* inflate_shader(const char file[])
 {
-	SkBitmap	bm;
+    SkBitmap    bm;
 
-	return SkImageDecoder::DecodeFile(file, &bm) ?
-			SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode) :
-			NULL;
+    return SkImageDecoder::DecodeFile(file, &bm) ?
+            SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode) :
+            NULL;
 }
 
 void SkProgressView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	const char* s;
+    const char* s;
 
-	SkASSERT(fOnShader == NULL);
-	SkASSERT(fOffShader == NULL);
+    SkASSERT(fOnShader == NULL);
+    SkASSERT(fOffShader == NULL);
 
-	if ((s = dom.findAttr(node, "src-on")) != NULL)
-		fOnShader = inflate_shader(s);
-	if ((s = dom.findAttr(node, "src-off")) != NULL)
-		fOffShader = inflate_shader(s);
-	(void)dom.findBool(node, "do-interp", &fDoInterp);
+    if ((s = dom.findAttr(node, "src-on")) != NULL)
+        fOnShader = inflate_shader(s);
+    if ((s = dom.findAttr(node, "src-off")) != NULL)
+        fOffShader = inflate_shader(s);
+    (void)dom.findBool(node, "do-interp", &fDoInterp);
 }
 
diff --git a/src/views/SkStackViewLayout.cpp b/src/views/SkStackViewLayout.cpp
index bf6f363..e4fbb80 100644
--- a/src/views/SkStackViewLayout.cpp
+++ b/src/views/SkStackViewLayout.cpp
@@ -9,51 +9,51 @@
 
 SkStackViewLayout::SkStackViewLayout()
 {
-	fMargin.set(0, 0, 0, 0);
-	fSpacer	= 0;
-	fOrient	= kHorizontal_Orient;
-	fPack	= kStart_Pack;
-	fAlign	= kStart_Align;
-	fRound	= false;
+    fMargin.set(0, 0, 0, 0);
+    fSpacer    = 0;
+    fOrient    = kHorizontal_Orient;
+    fPack    = kStart_Pack;
+    fAlign    = kStart_Align;
+    fRound    = false;
 }
 
 void SkStackViewLayout::setOrient(Orient ori)
 {
-	SkASSERT((unsigned)ori < kOrientCount);
-	fOrient = SkToU8(ori);
+    SkASSERT((unsigned)ori < kOrientCount);
+    fOrient = SkToU8(ori);
 }
 
 void SkStackViewLayout::getMargin(SkRect* margin) const
 {
-	if (margin)
-		*margin = fMargin;
+    if (margin)
+        *margin = fMargin;
 }
 
 void SkStackViewLayout::setMargin(const SkRect& margin)
 {
-	fMargin = margin;
+    fMargin = margin;
 }
 
 void SkStackViewLayout::setSpacer(SkScalar spacer)
 {
-	fSpacer = spacer;
+    fSpacer = spacer;
 }
 
 void SkStackViewLayout::setPack(Pack pack)
 {
-	SkASSERT((unsigned)pack < kPackCount);
-	fPack = SkToU8(pack);
+    SkASSERT((unsigned)pack < kPackCount);
+    fPack = SkToU8(pack);
 }
 
 void SkStackViewLayout::setAlign(Align align)
 {
-	SkASSERT((unsigned)align < kAlignCount);
-	fAlign = SkToU8(align);
+    SkASSERT((unsigned)align < kAlignCount);
+    fAlign = SkToU8(align);
 }
 
 void SkStackViewLayout::setRound(bool r)
 {
-	fRound = SkToU8(r);
+    fRound = SkToU8(r);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -68,170 +68,170 @@
 static SkScalar right_align_proc(SkScalar childLimit, SkScalar parentLimit) { return parentLimit - childLimit; }
 static SkScalar fill_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; }
 
-/*	Measure the main-dimension for all the children. If a child is marked flex in that direction
-	ignore its current value but increment the counter for flexChildren
+/*    Measure the main-dimension for all the children. If a child is marked flex in that direction
+    ignore its current value but increment the counter for flexChildren
 */
 static SkScalar compute_children_limit(SkView* parent, GetSizeProc sizeProc, int* count,
-									   uint32_t flexMask, int* flexCount)
+                                       uint32_t flexMask, int* flexCount)
 {
-	SkView::B2FIter	iter(parent);
-	SkView*			child;
-	SkScalar		limit = 0;
-	int				n = 0, flex = 0;
+    SkView::B2FIter    iter(parent);
+    SkView*            child;
+    SkScalar        limit = 0;
+    int                n = 0, flex = 0;
 
-	while ((child = iter.next()) != NULL)
-	{
-		n += 1;
-		if (child->getFlags() & flexMask)
-			flex += 1;
-		else
-			limit += (child->*sizeProc)();
-	}
-	if (count)
-		*count = n;
-	if (flexCount)
-		*flexCount = flex;
-	return limit;
+    while ((child = iter.next()) != NULL)
+    {
+        n += 1;
+        if (child->getFlags() & flexMask)
+            flex += 1;
+        else
+            limit += (child->*sizeProc)();
+    }
+    if (count)
+        *count = n;
+    if (flexCount)
+        *flexCount = flex;
+    return limit;
 }
 
 void SkStackViewLayout::onLayoutChildren(SkView* parent)
 {
-	static AlignProc gAlignProcs[] = {
-		left_align_proc,
-		center_align_proc,
-		right_align_proc,
-		fill_align_proc
-	};
+    static AlignProc gAlignProcs[] = {
+        left_align_proc,
+        center_align_proc,
+        right_align_proc,
+        fill_align_proc
+    };
 
-	SkScalar			startM, endM, crossStartM, crossLimit;
-	GetSizeProc			mainGetSizeP, crossGetSizeP;
-	SetLocProc			mainLocP, crossLocP;
-	SetSizeProc			mainSetSizeP, crossSetSizeP;
-	SkView::Flag_Mask	flexMask;
+    SkScalar            startM, endM, crossStartM, crossLimit;
+    GetSizeProc            mainGetSizeP, crossGetSizeP;
+    SetLocProc            mainLocP, crossLocP;
+    SetSizeProc            mainSetSizeP, crossSetSizeP;
+    SkView::Flag_Mask    flexMask;
 
-	if (fOrient == kHorizontal_Orient)
-	{
-		startM		= fMargin.fLeft;
-		endM		= fMargin.fRight;
-		crossStartM	= fMargin.fTop;
-		crossLimit	= -fMargin.fTop - fMargin.fBottom;
+    if (fOrient == kHorizontal_Orient)
+    {
+        startM        = fMargin.fLeft;
+        endM        = fMargin.fRight;
+        crossStartM    = fMargin.fTop;
+        crossLimit    = -fMargin.fTop - fMargin.fBottom;
 
-		mainGetSizeP	= &SkView::width;
-		crossGetSizeP	= &SkView::height;
-		mainLocP	= &SkView::setLocX;
-		crossLocP	= &SkView::setLocY;
+        mainGetSizeP    = &SkView::width;
+        crossGetSizeP    = &SkView::height;
+        mainLocP    = &SkView::setLocX;
+        crossLocP    = &SkView::setLocY;
 
-		mainSetSizeP  = &SkView::setWidth;
-		crossSetSizeP = &SkView::setHeight;
+        mainSetSizeP  = &SkView::setWidth;
+        crossSetSizeP = &SkView::setHeight;
 
-		flexMask	= SkView::kFlexH_Mask;
-	}
-	else
-	{
-		startM		= fMargin.fTop;
-		endM		= fMargin.fBottom;
-		crossStartM	= fMargin.fLeft;
-		crossLimit	= -fMargin.fLeft - fMargin.fRight;
+        flexMask    = SkView::kFlexH_Mask;
+    }
+    else
+    {
+        startM        = fMargin.fTop;
+        endM        = fMargin.fBottom;
+        crossStartM    = fMargin.fLeft;
+        crossLimit    = -fMargin.fLeft - fMargin.fRight;
 
-		mainGetSizeP	= &SkView::height;
-		crossGetSizeP	= &SkView::width;
-		mainLocP	= &SkView::setLocY;
-		crossLocP	= &SkView::setLocX;
+        mainGetSizeP    = &SkView::height;
+        crossGetSizeP    = &SkView::width;
+        mainLocP    = &SkView::setLocY;
+        crossLocP    = &SkView::setLocX;
 
-		mainSetSizeP  = &SkView::setHeight;
-		crossSetSizeP = &SkView::setWidth;
+        mainSetSizeP  = &SkView::setHeight;
+        crossSetSizeP = &SkView::setWidth;
 
-		flexMask	= SkView::kFlexV_Mask;
-	}
-	crossLimit += (parent->*crossGetSizeP)();
-	if (fAlign != kStretch_Align)
-		crossSetSizeP = NULL;
+        flexMask    = SkView::kFlexV_Mask;
+    }
+    crossLimit += (parent->*crossGetSizeP)();
+    if (fAlign != kStretch_Align)
+        crossSetSizeP = NULL;
 
-	int			childCount, flexCount;
-	SkScalar	childLimit = compute_children_limit(parent, mainGetSizeP, &childCount, flexMask, &flexCount);
+    int            childCount, flexCount;
+    SkScalar    childLimit = compute_children_limit(parent, mainGetSizeP, &childCount, flexMask, &flexCount);
 
-	if (childCount == 0)
-		return;
+    if (childCount == 0)
+        return;
 
-	childLimit += (childCount - 1) * fSpacer;
+    childLimit += (childCount - 1) * fSpacer;
 
-	SkScalar		parentLimit = (parent->*mainGetSizeP)() - startM - endM;
-	SkScalar		pos = startM + gAlignProcs[fPack](childLimit, parentLimit);
-	SkScalar		flexAmount = 0;
-	SkView::B2FIter	iter(parent);
-	SkView*			child;
+    SkScalar        parentLimit = (parent->*mainGetSizeP)() - startM - endM;
+    SkScalar        pos = startM + gAlignProcs[fPack](childLimit, parentLimit);
+    SkScalar        flexAmount = 0;
+    SkView::B2FIter    iter(parent);
+    SkView*            child;
 
-	if (flexCount > 0 && parentLimit > childLimit)
-		flexAmount = (parentLimit - childLimit) / flexCount;
+    if (flexCount > 0 && parentLimit > childLimit)
+        flexAmount = (parentLimit - childLimit) / flexCount;
 
-	while ((child = iter.next()) != NULL)
-	{
-		if (fRound)
-			pos = SkIntToScalar(SkScalarRound(pos));
-		(child->*mainLocP)(pos);
-		SkScalar crossLoc = crossStartM + gAlignProcs[fAlign]((child->*crossGetSizeP)(), crossLimit);
-		if (fRound)
-			crossLoc = SkIntToScalar(SkScalarRound(crossLoc));
-		(child->*crossLocP)(crossLoc);
+    while ((child = iter.next()) != NULL)
+    {
+        if (fRound)
+            pos = SkIntToScalar(SkScalarRound(pos));
+        (child->*mainLocP)(pos);
+        SkScalar crossLoc = crossStartM + gAlignProcs[fAlign]((child->*crossGetSizeP)(), crossLimit);
+        if (fRound)
+            crossLoc = SkIntToScalar(SkScalarRound(crossLoc));
+        (child->*crossLocP)(crossLoc);
 
-		if (crossSetSizeP)
-			(child->*crossSetSizeP)(crossLimit);
-		if (child->getFlags() & flexMask)
-			(child->*mainSetSizeP)(flexAmount);
-		pos += (child->*mainGetSizeP)() + fSpacer;
-	}
+        if (crossSetSizeP)
+            (child->*crossSetSizeP)(crossLimit);
+        if (child->getFlags() & flexMask)
+            (child->*mainSetSizeP)(flexAmount);
+        pos += (child->*mainGetSizeP)() + fSpacer;
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
-	static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
-	{
-		const char* value = dom.findAttr(node, attr);
-		if (value)
-			SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
-	}
+    static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+    {
+        const char* value = dom.findAttr(node, attr);
+        if (value)
+            SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+    }
 #else
-	#define assert_no_attr(dom, node, attr)
+    #define assert_no_attr(dom, node, attr)
 #endif
 
 void SkStackViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	int			index;
-	SkScalar	value[4];
+    int            index;
+    SkScalar    value[4];
 
-	if ((index = dom.findList(node, "orient", "horizontal,vertical")) >= 0)
-		this->setOrient((Orient)index);
-	else {
-		assert_no_attr(dom, node, "orient");
+    if ((index = dom.findList(node, "orient", "horizontal,vertical")) >= 0)
+        this->setOrient((Orient)index);
+    else {
+        assert_no_attr(dom, node, "orient");
         }
 
-	if (dom.findScalars(node, "margin", value, 4))
-	{
-		SkRect	margin;
-		margin.set(value[0], value[1], value[2], value[3]);
-		this->setMargin(margin);
-	}
-	else {
-		assert_no_attr(dom, node, "margin");
+    if (dom.findScalars(node, "margin", value, 4))
+    {
+        SkRect    margin;
+        margin.set(value[0], value[1], value[2], value[3]);
+        this->setMargin(margin);
+    }
+    else {
+        assert_no_attr(dom, node, "margin");
         }
 
-	if (dom.findScalar(node, "spacer", value))
-		this->setSpacer(value[0]);
-	else {
-		assert_no_attr(dom, node, "spacer");
+    if (dom.findScalar(node, "spacer", value))
+        this->setSpacer(value[0]);
+    else {
+        assert_no_attr(dom, node, "spacer");
         }
 
-	if ((index = dom.findList(node, "pack", "start,center,end")) >= 0)
-		this->setPack((Pack)index);
-	else {
-		assert_no_attr(dom, node, "pack");
+    if ((index = dom.findList(node, "pack", "start,center,end")) >= 0)
+        this->setPack((Pack)index);
+    else {
+        assert_no_attr(dom, node, "pack");
         }
 
-	if ((index = dom.findList(node, "align", "start,center,end,stretch")) >= 0)
-		this->setAlign((Align)index);
-	else {
-		assert_no_attr(dom, node, "align");
+    if ((index = dom.findList(node, "align", "start,center,end,stretch")) >= 0)
+        this->setAlign((Align)index);
+    else {
+        assert_no_attr(dom, node, "align");
         }
 }
 
@@ -239,36 +239,36 @@
 
 SkFillViewLayout::SkFillViewLayout()
 {
-	fMargin.setEmpty();
+    fMargin.setEmpty();
 }
 
 void SkFillViewLayout::getMargin(SkRect* r) const
 {
-	if (r)
-		*r = fMargin;
+    if (r)
+        *r = fMargin;
 }
 
 void SkFillViewLayout::setMargin(const SkRect& margin)
 {
-	fMargin = margin;
+    fMargin = margin;
 }
 
 void SkFillViewLayout::onLayoutChildren(SkView* parent)
 {
-	SkView::B2FIter	iter(parent);
-	SkView*			child;
+    SkView::B2FIter    iter(parent);
+    SkView*            child;
 
-	while ((child = iter.next()) != NULL)
-	{
-		child->setLoc(fMargin.fLeft, fMargin.fTop);
-		child->setSize(	parent->width() - fMargin.fRight - fMargin.fLeft,
-						parent->height() - fMargin.fBottom - fMargin.fTop);
-	}
+    while ((child = iter.next()) != NULL)
+    {
+        child->setLoc(fMargin.fLeft, fMargin.fTop);
+        child->setSize(    parent->width() - fMargin.fRight - fMargin.fLeft,
+                        parent->height() - fMargin.fBottom - fMargin.fTop);
+    }
 }
 
 void SkFillViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
-	(void)dom.findScalars(node, "margin", (SkScalar*)&fMargin, 4);
+    this->INHERITED::onInflate(dom, node);
+    (void)dom.findScalars(node, "margin", (SkScalar*)&fMargin, 4);
 }
 
diff --git a/src/views/SkTextBox.cpp b/src/views/SkTextBox.cpp
index 47237a9..355944a 100644
--- a/src/views/SkTextBox.cpp
+++ b/src/views/SkTextBox.cpp
@@ -156,7 +156,7 @@
         y += scaledSpacing;
         if (y + metrics.fAscent >= height)
             break;
-    } 
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/views/SkTouchGesture.cpp b/src/views/SkTouchGesture.cpp
index 1828f03..afda8c1 100644
--- a/src/views/SkTouchGesture.cpp
+++ b/src/views/SkTouchGesture.cpp
@@ -191,7 +191,7 @@
 float SkTouchGesture::limitTotalZoom(float scale) const {
     // this query works 'cause we know that we're square-scale w/ no skew/rotation
     const float curr = SkScalarToFloat(fGlobalM[0]);
-    
+
     if (scale > 1 && curr * scale > MAX_ZOOM_SCALE) {
         scale = MAX_ZOOM_SCALE / curr;
     } else if (scale < 1 && curr * scale < MIN_ZOOM_SCALE) {
@@ -239,7 +239,7 @@
             SkASSERT(kZoom_State == fState);
             const Rec& rec0 = fTouches[0];
             const Rec& rec1 = fTouches[1];
-            
+
             float scale = this->computePinch(rec0, rec1);
             scale = this->limitTotalZoom(scale);
 
diff --git a/src/views/SkView.cpp b/src/views/SkView.cpp
index eb93198..94eb490 100644
--- a/src/views/SkView.cpp
+++ b/src/views/SkView.cpp
@@ -95,7 +95,7 @@
         this->setLoc(fLoc.fX + dx, fLoc.fY + dy);
 }
 
-void SkView::setLocalMatrix(const SkMatrix& matrix) 
+void SkView::setLocalMatrix(const SkMatrix& matrix)
 {
     this->inval(NULL);
     fMatrix = matrix;
@@ -106,22 +106,22 @@
 {
     if (fWidth && fHeight && this->isVisible())
     {
-        SkRect	r;
+        SkRect    r;
         r.set(fLoc.fX, fLoc.fY, fLoc.fX + fWidth, fLoc.fY + fHeight);
         if (this->isClipToBounds() &&
             canvas->quickReject(r)) {
                 return;
         }
 
-        SkAutoCanvasRestore	as(canvas, true);
+        SkAutoCanvasRestore    as(canvas, true);
 
         if (this->isClipToBounds()) {
             canvas->clipRect(r);
         }
-        
-        canvas->translate(fLoc.fX, fLoc.fY);		
+
+        canvas->translate(fLoc.fX, fLoc.fY);
         canvas->concat(fMatrix);
-        
+
         if (fParent) {
             fParent->beforeChild(this, canvas);
         }
@@ -133,21 +133,21 @@
         if (fParent) {
             fParent->afterChild(this, canvas);
         }
-        
-        B2FIter	iter(this);
-        SkView*	child;
+
+        B2FIter    iter(this);
+        SkView*    child;
 
         SkCanvas* childCanvas = this->beforeChildren(canvas);
 
         while ((child = iter.next()) != NULL)
             child->draw(childCanvas);
-        
+
         this->afterChildren(canvas);
     }
 }
 
 void SkView::inval(SkRect* rect) {
-    SkView*	view = this;
+    SkView*    view = this;
     SkRect storage;
 
     for (;;) {
@@ -184,7 +184,7 @@
 bool SkView::setFocusView(SkView* fv)
 {
     SkView* view = this;
-    
+
     do {
         if (view->onSetFocusView(fv))
             return true;
@@ -194,8 +194,8 @@
 
 SkView* SkView::getFocusView() const
 {
-    SkView*			focus = NULL;
-    const SkView*	view = this;
+    SkView*            focus = NULL;
+    const SkView*    view = this;
     do {
         if (view->onGetFocusView(&focus))
             break;
@@ -223,16 +223,16 @@
         if (this->acceptFocus())
             return this;
 
-        B2FIter	iter(this);
-        SkView*	child, *focus;
+        B2FIter    iter(this);
+        SkView*    child, *focus;
         while ((child = iter.next()) != NULL)
             if ((focus = child->acceptFocus(dir)) != NULL)
                 return focus;
     }
     else // prev
     {
-        F2BIter	iter(this);
-        SkView*	child, *focus;
+        F2BIter    iter(this);
+        SkView*    child, *focus;
         while ((child = iter.next()) != NULL)
             if ((focus = child->acceptFocus(dir)) != NULL)
                 return focus;
@@ -249,13 +249,13 @@
     SkView* focus = this->getFocusView();
 
     if (focus == NULL)
-    {	// start with the root
+    {    // start with the root
         focus = this;
         while (focus->fParent)
             focus = focus->fParent;
     }
 
-    SkView*	child, *parent;
+    SkView*    child, *parent;
 
     if (dir == kNext_FocusDirection)
     {
@@ -279,10 +279,10 @@
             parent = parent->fParent;
         } while (parent != NULL);
     }
-    else	// prevfocus
+    else    // prevfocus
     {
         parent = focus->fParent;
-        if (parent == NULL)	// we're the root
+        if (parent == NULL)    // we're the root
             return focus->acceptFocus(dir);
         else
         {
@@ -364,7 +364,7 @@
         this->resetType();
         if (type)
         {
-            size_t	len = strlen(type) + 1;
+            size_t    len = strlen(type) + 1;
             fType = (char*)sk_malloc_throw(len);
             memcpy(fType, type, len);
             fWeOwnTheType = true;
@@ -379,8 +379,8 @@
     }
 
     if (this->onSendClickToChildren(x, y)) {
-        F2BIter	iter(this);
-        SkView*	child;
+        F2BIter    iter(this);
+        SkView*    child;
 
         while ((child = iter.next()) != NULL)
         {
@@ -526,9 +526,9 @@
 
     this->inval(NULL);
 
-    SkView*	next = NULL;
+    SkView*    next = NULL;
 
-    if (fNextSibling != this)	// do we have any siblings
+    if (fNextSibling != this)    // do we have any siblings
     {
         fNextSibling->fPrevSibling = fPrevSibling;
         fPrevSibling->fNextSibling = fNextSibling;
@@ -657,7 +657,7 @@
 
 //////////////////////////////////////////////////////////////////
 
-/*	Even if the subclass overrides onInflate, they should always be
+/*    Even if the subclass overrides onInflate, they should always be
     sure to call the inherited method, so that we get called.
 */
 void SkView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
@@ -705,8 +705,8 @@
 {
     this->onPostInflate(dict);
 
-    B2FIter	iter(this);
-    SkView*	child;
+    B2FIter    iter(this);
+    SkView*    child;
     while ((child = iter.next()) != NULL)
         child->postInflate(dict);
 }
@@ -716,7 +716,7 @@
 SkView* SkView::sendEventToParents(const SkEvent& evt)
 {
     SkView* parent = fParent;
-    
+
     while (parent)
     {
         if (parent->doEvent(evt))
@@ -728,7 +728,7 @@
 
 SkView* SkView::sendQueryToParents(SkEvent* evt) {
     SkView* parent = fParent;
-    
+
     while (parent) {
         if (parent->doQuery(evt)) {
             return parent;
@@ -747,7 +747,7 @@
     fChild = fFirstChild ? fFirstChild->fPrevSibling : NULL;
 }
 
-SkView*	SkView::F2BIter::next()
+SkView*    SkView::F2BIter::next()
 {
     SkView* curr = fChild;
 
@@ -767,7 +767,7 @@
     fChild = fFirstChild;
 }
 
-SkView*	SkView::B2FIter::next()
+SkView*    SkView::B2FIter::next()
 {
     SkView* curr = fChild;
 
@@ -810,9 +810,9 @@
 
     if (recurse)
     {
-        SkView::B2FIter	iter(view);
-        SkView*			child;
-        bool			noChildren = true;
+        SkView::B2FIter    iter(view);
+        SkView*            child;
+        bool            noChildren = true;
 
         while ((child = iter.next()) != NULL)
         {
diff --git a/src/views/SkViewInflate.cpp b/src/views/SkViewInflate.cpp
index 184e540..4d7de04 100644
--- a/src/views/SkViewInflate.cpp
+++ b/src/views/SkViewInflate.cpp
@@ -19,128 +19,128 @@
 
 void SkViewInflate::rInflate(const SkDOM& dom, const SkDOM::Node* node, SkView* parent)
 {
-	const char* str = dom.findAttr(node, "id");
-	if (str)
-		fIDs.set(str, parent);
+    const char* str = dom.findAttr(node, "id");
+    if (str)
+        fIDs.set(str, parent);
 
-	const SkDOM::Node* child = dom.getFirstChild(node);
-	while (child)
-	{
-		SkView* view = this->createView(dom, child);
-		if (view)
-		{
-			this->rInflate(dom, child, view);
-			parent->attachChildToFront(view)->unref();
-		}
-		else
-		{
-			const char* name = dom.getName(child);
-			const char* target;
+    const SkDOM::Node* child = dom.getFirstChild(node);
+    while (child)
+    {
+        SkView* view = this->createView(dom, child);
+        if (view)
+        {
+            this->rInflate(dom, child, view);
+            parent->attachChildToFront(view)->unref();
+        }
+        else
+        {
+            const char* name = dom.getName(child);
+            const char* target;
 
-			if (!strcmp(name, "listenTo") && (target = dom.findAttr(child, "target")) != NULL)
-				this->addIDStr(&fListenTo, parent, target);
+            if (!strcmp(name, "listenTo") && (target = dom.findAttr(child, "target")) != NULL)
+                this->addIDStr(&fListenTo, parent, target);
 
-			if (!strcmp(name, "broadcastTo") && (target = dom.findAttr(child, "target")) != NULL)
-				this->addIDStr(&fBroadcastTo, parent, target);
-		}
-		child = dom.getNextSibling(child);
-	}
+            if (!strcmp(name, "broadcastTo") && (target = dom.findAttr(child, "target")) != NULL)
+                this->addIDStr(&fBroadcastTo, parent, target);
+        }
+        child = dom.getNextSibling(child);
+    }
 
-	parent->setVisibleP(true);
-	this->inflateView(parent, dom, node);
+    parent->setVisibleP(true);
+    this->inflateView(parent, dom, node);
 }
 
 void SkViewInflate::inflateView(SkView* view, const SkDOM& dom, const SkDOM::Node* node)
 {
-	// called after all of view's children have been instantiated.
-	// this may be overridden by a subclass, to load in layout or other helpers
-	// they should call through to us (INHERITED) before or after their patch
-	view->inflate(dom, node);
+    // called after all of view's children have been instantiated.
+    // this may be overridden by a subclass, to load in layout or other helpers
+    // they should call through to us (INHERITED) before or after their patch
+    view->inflate(dom, node);
 }
 
 SkView* SkViewInflate::inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root)
 {
-	fIDs.reset();
+    fIDs.reset();
 
-	if (root == NULL)
-	{
-		root = this->createView(dom, node);
-		if (root == NULL)
-		{
-			printf("createView returned NULL on <%s>\n", dom.getName(node));
-			return NULL;
-		}
-	}
-	this->rInflate(dom, node, root);
+    if (root == NULL)
+    {
+        root = this->createView(dom, node);
+        if (root == NULL)
+        {
+            printf("createView returned NULL on <%s>\n", dom.getName(node));
+            return NULL;
+        }
+    }
+    this->rInflate(dom, node, root);
 
-	// resolve listeners and broadcasters
-	{
-		SkView*			target;
-		const IDStr*	iter = fListenTo.begin();
-		const IDStr*	stop = fListenTo.end();
-		for (; iter < stop; iter++)
-		{
-			if (fIDs.find(iter->fStr, &target))
-				target->addListenerID(iter->fView->getSinkID());
-		}
+    // resolve listeners and broadcasters
+    {
+        SkView*            target;
+        const IDStr*    iter = fListenTo.begin();
+        const IDStr*    stop = fListenTo.end();
+        for (; iter < stop; iter++)
+        {
+            if (fIDs.find(iter->fStr, &target))
+                target->addListenerID(iter->fView->getSinkID());
+        }
 
-		iter = fBroadcastTo.begin();
-		stop = fBroadcastTo.end();
-		for (; iter < stop; iter++)
-		{
-			if (fIDs.find(iter->fStr, &target))
-				iter->fView->addListenerID(target->getSinkID());
-		}
-	}
+        iter = fBroadcastTo.begin();
+        stop = fBroadcastTo.end();
+        for (; iter < stop; iter++)
+        {
+            if (fIDs.find(iter->fStr, &target))
+                iter->fView->addListenerID(target->getSinkID());
+        }
+    }
 
-	// now that the tree is built, give everyone a shot at the ID dict
-	root->postInflate(fIDs);
-	return root;
+    // now that the tree is built, give everyone a shot at the ID dict
+    root->postInflate(fIDs);
+    return root;
 }
 
 SkView* SkViewInflate::inflate(const char xml[], size_t len, SkView* root)
 {
-	SkDOM				dom;
-	const SkDOM::Node*	node = dom.build(xml, len);
+    SkDOM                dom;
+    const SkDOM::Node*    node = dom.build(xml, len);
 
-	return node ? this->inflate(dom, node, root) : NULL;
+    return node ? this->inflate(dom, node, root) : NULL;
 }
 
 SkView* SkViewInflate::findViewByID(const char id[]) const
 {
-	SkASSERT(id);
-	SkView* view;
-	return fIDs.find(id, &view) ? view : NULL;
+    SkASSERT(id);
+    SkView* view;
+    return fIDs.find(id, &view) ? view : NULL;
 }
 
 SkView* SkViewInflate::createView(const SkDOM& dom, const SkDOM::Node* node)
 {
-	if (!strcmp(dom.getName(node), "view"))
-		return new SkView;
-	return NULL;
+    if (!strcmp(dom.getName(node), "view"))
+        return new SkView;
+    return NULL;
 }
 
 void SkViewInflate::addIDStr(SkTDArray<IDStr>* list, SkView* view, const char* str)
 {
-	size_t len = strlen(str) + 1;
-	IDStr* pair = list->append();
-	pair->fView = view;
-	pair->fStr = (char*)fStrings.alloc(len, SkChunkAlloc::kThrow_AllocFailType);
-	memcpy(pair->fStr, str, len);
+    size_t len = strlen(str) + 1;
+    IDStr* pair = list->append();
+    pair->fView = view;
+    pair->fStr = (char*)fStrings.alloc(len, SkChunkAlloc::kThrow_AllocFailType);
+    memcpy(pair->fStr, str, len);
 }
 
 #ifdef SK_DEBUG
 void SkViewInflate::dump() const
 {
-	const IDStr* iter = fListenTo.begin();
-	const IDStr* stop = fListenTo.end();
-	for (; iter < stop; iter++)
-		SkDebugf("inflate: listenTo(\"%s\")\n", iter->fStr);
+    const IDStr* iter = fListenTo.begin();
+    const IDStr* stop = fListenTo.end();
+    for (; iter < stop; iter++)
+        SkDebugf("inflate: listenTo(\"%s\")\n", iter->fStr);
 
-	iter = fBroadcastTo.begin();
-	stop = fBroadcastTo.end();
-	for (; iter < stop; iter++)
-		SkDebugf("inflate: broadcastFrom(\"%s\")\n", iter->fStr);
+    iter = fBroadcastTo.begin();
+    stop = fBroadcastTo.end();
+    for (; iter < stop; iter++)
+        SkDebugf("inflate: broadcastFrom(\"%s\")\n", iter->fStr);
 }
 #endif
 
diff --git a/src/views/SkViewPriv.cpp b/src/views/SkViewPriv.cpp
index ad15f3f..ba40c1e 100644
--- a/src/views/SkViewPriv.cpp
+++ b/src/views/SkViewPriv.cpp
@@ -11,94 +11,94 @@
 
 void SkView::Artist::draw(SkView* view, SkCanvas* canvas)
 {
-	SkASSERT(view && canvas);
-	this->onDraw(view, canvas);
+    SkASSERT(view && canvas);
+    this->onDraw(view, canvas);
 }
 
 void SkView::Artist::inflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	SkASSERT(&dom && node);
-	this->onInflate(dom, node);
+    SkASSERT(&dom && node);
+    this->onInflate(dom, node);
 }
 
 void SkView::Artist::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	// subclass should override this as needed
+    // subclass should override this as needed
 }
 
 SkView::Artist* SkView::getArtist() const
 {
-	Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
-	SkASSERT(rec == NULL || rec->fArtist != NULL);
+    Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
+    SkASSERT(rec == NULL || rec->fArtist != NULL);
 
-	return rec ? rec->fArtist : NULL;
+    return rec ? rec->fArtist : NULL;
 }
 
 SkView::Artist* SkView::setArtist(Artist* obj)
 {
-	if (obj == NULL)
-	{
-		this->removeTagList(kViewArtist_SkTagList);
-	}
-	else	// add/replace
-	{
-		Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
+    if (obj == NULL)
+    {
+        this->removeTagList(kViewArtist_SkTagList);
+    }
+    else    // add/replace
+    {
+        Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
 
-		if (rec)
-			SkRefCnt_SafeAssign(rec->fArtist, obj);
-		else
-			this->addTagList(new Artist_SkTagList(obj));
-	}
-	return obj;
+        if (rec)
+            SkRefCnt_SafeAssign(rec->fArtist, obj);
+        else
+            this->addTagList(new Artist_SkTagList(obj));
+    }
+    return obj;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void SkView::Layout::layoutChildren(SkView* parent)
 {
-	SkASSERT(parent);
-	if (parent->width() > 0 && parent->height() > 0)
-		this->onLayoutChildren(parent);
+    SkASSERT(parent);
+    if (parent->width() > 0 && parent->height() > 0)
+        this->onLayoutChildren(parent);
 }
 
 void SkView::Layout::inflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	SkASSERT(&dom && node);
-	this->onInflate(dom, node);
+    SkASSERT(&dom && node);
+    this->onInflate(dom, node);
 }
 
 void SkView::Layout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	// subclass should override this as needed
+    // subclass should override this as needed
 }
 
 SkView::Layout* SkView::getLayout() const
 {
-	Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
-	SkASSERT(rec == NULL || rec->fLayout != NULL);
+    Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
+    SkASSERT(rec == NULL || rec->fLayout != NULL);
 
-	return rec ? rec->fLayout : NULL;
+    return rec ? rec->fLayout : NULL;
 }
 
 SkView::Layout* SkView::setLayout(Layout* obj, bool invokeLayoutNow)
 {
-	if (obj == NULL)
-	{
-		this->removeTagList(kViewLayout_SkTagList);
-	}
-	else	// add/replace
-	{
-		Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
+    if (obj == NULL)
+    {
+        this->removeTagList(kViewLayout_SkTagList);
+    }
+    else    // add/replace
+    {
+        Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
 
-		if (rec)
-			SkRefCnt_SafeAssign(rec->fLayout, obj);
-		else
-			this->addTagList(new Layout_SkTagList(obj));
-	}
-	
-	if (invokeLayoutNow)
-		this->invokeLayout();
+        if (rec)
+            SkRefCnt_SafeAssign(rec->fLayout, obj);
+        else
+            this->addTagList(new Layout_SkTagList(obj));
+    }
 
-	return obj;
+    if (invokeLayoutNow)
+        this->invokeLayout();
+
+    return obj;
 }
 
diff --git a/src/views/SkViewPriv.h b/src/views/SkViewPriv.h
index d8cf966..8a9c0b7 100644
--- a/src/views/SkViewPriv.h
+++ b/src/views/SkViewPriv.h
@@ -12,33 +12,33 @@
 #include "SkTagList.h"
 
 struct Layout_SkTagList : SkTagList {
-	SkView::Layout*	fLayout;
+    SkView::Layout*    fLayout;
 
-	Layout_SkTagList(SkView::Layout* layout)
-		: SkTagList(kViewLayout_SkTagList), fLayout(layout)
-	{
-		SkASSERT(layout);
-		layout->ref();
-	}
-	virtual ~Layout_SkTagList()
-	{
-		fLayout->unref();
-	}
+    Layout_SkTagList(SkView::Layout* layout)
+        : SkTagList(kViewLayout_SkTagList), fLayout(layout)
+    {
+        SkASSERT(layout);
+        layout->ref();
+    }
+    virtual ~Layout_SkTagList()
+    {
+        fLayout->unref();
+    }
 };
 
 struct Artist_SkTagList : SkTagList {
-	SkView::Artist*	fArtist;
+    SkView::Artist*    fArtist;
 
-	Artist_SkTagList(SkView::Artist* artist)
-		: SkTagList(kViewArtist_SkTagList), fArtist(artist)
-	{
-		SkASSERT(artist);
-		artist->ref();
-	}
-	virtual ~Artist_SkTagList()
-	{
-		fArtist->unref();
-	}
+    Artist_SkTagList(SkView::Artist* artist)
+        : SkTagList(kViewArtist_SkTagList), fArtist(artist)
+    {
+        SkASSERT(artist);
+        artist->ref();
+    }
+    virtual ~Artist_SkTagList()
+    {
+        fArtist->unref();
+    }
 };
 
 #endif
diff --git a/src/views/SkWidget.cpp b/src/views/SkWidget.cpp
index 104429d..e7de522 100644
--- a/src/views/SkWidget.cpp
+++ b/src/views/SkWidget.cpp
@@ -22,7 +22,7 @@
 
 const char* SkWidgetView::GetEventType()
 {
-	return "SkWidgetView";
+    return "SkWidgetView";
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -30,300 +30,300 @@
 
 class SkTextView::Interp {
 public:
-	Interp(const SkString& old, SkMSec now, SkMSec dur, AnimaDir dir) : fOldText(old), fInterp(1, 2)
-	{
-		SkScalar x = 0;
-		fInterp.setKeyFrame(0, now, &x, 0);
-		x = SK_Scalar1;
-		if (dir == kBackward_AnimDir)
-			x = -x;
-		fInterp.setKeyFrame(1, now + dur, &x);
-	}
-	bool draw(SkCanvas* canvas, const SkString& newText, SkScalar x, SkScalar y, SkPaint& paint)
-	{
-		SkScalar scale;
+    Interp(const SkString& old, SkMSec now, SkMSec dur, AnimaDir dir) : fOldText(old), fInterp(1, 2)
+    {
+        SkScalar x = 0;
+        fInterp.setKeyFrame(0, now, &x, 0);
+        x = SK_Scalar1;
+        if (dir == kBackward_AnimDir)
+            x = -x;
+        fInterp.setKeyFrame(1, now + dur, &x);
+    }
+    bool draw(SkCanvas* canvas, const SkString& newText, SkScalar x, SkScalar y, SkPaint& paint)
+    {
+        SkScalar scale;
 
-		if (fInterp.timeToValues(SkTime::GetMSecs(), &scale) == SkInterpolator::kFreezeEnd_Result)
-		{
-			canvas->drawText(newText.c_str(), newText.size(), x, y, paint);
-			return false;
-		}
-		else
-		{
-			U8 alpha = paint.getAlpha();
-			SkScalar above, below;
-			(void)paint.measureText(NULL, 0, &above, &below);
-			SkScalar height = below - above;
-			SkScalar dy = SkScalarMul(height, scale);
-			if (scale < 0)
-				height = -height;
+        if (fInterp.timeToValues(SkTime::GetMSecs(), &scale) == SkInterpolator::kFreezeEnd_Result)
+        {
+            canvas->drawText(newText.c_str(), newText.size(), x, y, paint);
+            return false;
+        }
+        else
+        {
+            U8 alpha = paint.getAlpha();
+            SkScalar above, below;
+            (void)paint.measureText(NULL, 0, &above, &below);
+            SkScalar height = below - above;
+            SkScalar dy = SkScalarMul(height, scale);
+            if (scale < 0)
+                height = -height;
 
-			// draw the old
-			paint.setAlpha((U8)SkScalarMul(alpha, SK_Scalar1 - SkScalarAbs(scale)));
-			canvas->drawText(fOldText.c_str(), fOldText.size(), x, y - dy, paint);
-			// draw the new
-			paint.setAlpha((U8)SkScalarMul(alpha, SkScalarAbs(scale)));
-			canvas->drawText(newText.c_str(), newText.size(), x, y + height - dy, paint);
-			// restore the paint
-			paint.setAlpha(alpha);
-			return true;
-		}
-	}
+            // draw the old
+            paint.setAlpha((U8)SkScalarMul(alpha, SK_Scalar1 - SkScalarAbs(scale)));
+            canvas->drawText(fOldText.c_str(), fOldText.size(), x, y - dy, paint);
+            // draw the new
+            paint.setAlpha((U8)SkScalarMul(alpha, SkScalarAbs(scale)));
+            canvas->drawText(newText.c_str(), newText.size(), x, y + height - dy, paint);
+            // restore the paint
+            paint.setAlpha(alpha);
+            return true;
+        }
+    }
 
 private:
-	SkString		fOldText;
-	SkInterpolator	fInterp;
+    SkString        fOldText;
+    SkInterpolator    fInterp;
 };
 
 SkTextView::SkTextView(U32 flags) : SkView(flags), fInterp(NULL), fDoInterp(false)
 {
-	fMargin.set(0, 0);
+    fMargin.set(0, 0);
 }
 
 SkTextView::~SkTextView()
 {
-	delete fInterp;
+    delete fInterp;
 }
 
 void SkTextView::getText(SkString* str) const
 {
-	if (str)
-		str->set(fText);
+    if (str)
+        str->set(fText);
 }
 
 void SkTextView::setText(const char text[], AnimaDir dir)
 {
-	if (!fText.equals(text))
-	{
-		SkString tmp(text);
-		this->privSetText(tmp, dir);
-	}
+    if (!fText.equals(text))
+    {
+        SkString tmp(text);
+        this->privSetText(tmp, dir);
+    }
 }
 
 void SkTextView::setText(const char text[], size_t len, AnimaDir dir)
 {
-	if (!fText.equals(text))
-	{
-		SkString tmp(text, len);
-		this->privSetText(tmp, dir);
-	}
+    if (!fText.equals(text))
+    {
+        SkString tmp(text, len);
+        this->privSetText(tmp, dir);
+    }
 }
 
 void SkTextView::setText(const SkString& src, AnimaDir dir)
 {
-	if (fText != src)
-		this->privSetText(src, dir);
+    if (fText != src)
+        this->privSetText(src, dir);
 }
 
 void SkTextView::privSetText(const SkString& src, AnimaDir dir)
 {
-	SkASSERT(fText != src);
+    SkASSERT(fText != src);
 
-	if (fDoInterp)
-	{
-		if (fInterp)
-			delete fInterp;
-		fInterp = new Interp(fText, SkTime::GetMSecs(), 500, dir);
-	}
-	fText = src;
-	this->inval(NULL);
+    if (fDoInterp)
+    {
+        if (fInterp)
+            delete fInterp;
+        fInterp = new Interp(fText, SkTime::GetMSecs(), 500, dir);
+    }
+    fText = src;
+    this->inval(NULL);
 }
 
 /////////////////////////////////////////////////////////////////
 
 void SkTextView::getMargin(SkPoint* margin) const
 {
-	if (margin)
-		*margin = fMargin;
+    if (margin)
+        *margin = fMargin;
 }
 
 void SkTextView::setMargin(const SkPoint& margin)
 {
-	if (fMargin != margin)
-	{
-		fMargin = margin;
-		this->inval(NULL);
-	}
+    if (fMargin != margin)
+    {
+        fMargin = margin;
+        this->inval(NULL);
+    }
 }
 
 void SkTextView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	if (fText.size() == 0)
-		return;
+    if (fText.size() == 0)
+        return;
 
-	SkPaint::Align	align = fPaint.getTextAlign();
-	SkScalar		x, y;
+    SkPaint::Align    align = fPaint.getTextAlign();
+    SkScalar        x, y;
 
-	switch (align) {
-	case SkPaint::kLeft_Align:
-		x = fMargin.fX;
-		break;
-	case SkPaint::kCenter_Align:
-		x = SkScalarHalf(this->width());
-		break;
-	default:
-		SkASSERT(align == SkPaint::kRight_Align);
-		x = this->width() - fMargin.fX;
-		break;
-	}
+    switch (align) {
+    case SkPaint::kLeft_Align:
+        x = fMargin.fX;
+        break;
+    case SkPaint::kCenter_Align:
+        x = SkScalarHalf(this->width());
+        break;
+    default:
+        SkASSERT(align == SkPaint::kRight_Align);
+        x = this->width() - fMargin.fX;
+        break;
+    }
 
-	fPaint.measureText(NULL, 0, &y, NULL);
-	y = fMargin.fY - y;
+    fPaint.measureText(NULL, 0, &y, NULL);
+    y = fMargin.fY - y;
 
-	if (fInterp)
-	{
-		if (fInterp->draw(canvas, fText, x, y, fPaint))
-			this->inval(NULL);
-		else
-		{
-			delete fInterp;
-			fInterp = NULL;
-		}
-	}
-	else
-		canvas->drawText(fText.c_str(), fText.size(), x, y, fPaint);
+    if (fInterp)
+    {
+        if (fInterp->draw(canvas, fText, x, y, fPaint))
+            this->inval(NULL);
+        else
+        {
+            delete fInterp;
+            fInterp = NULL;
+        }
+    }
+    else
+        canvas->drawText(fText.c_str(), fText.size(), x, y, fPaint);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 void SkTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	const char* text = dom.findAttr(node, "text");
-	if (text)
-		this->setText(text);
+    const char* text = dom.findAttr(node, "text");
+    if (text)
+        this->setText(text);
 
-	SkPoint	margin;
-	if (dom.findScalars(node, "margin", (SkScalar*)&margin, 2))
-		this->setMargin(margin);
-	(void)dom.findBool(node, "do-interp", &fDoInterp);
+    SkPoint    margin;
+    if (dom.findScalars(node, "margin", (SkScalar*)&margin, 2))
+        this->setMargin(margin);
+    (void)dom.findBool(node, "do-interp", &fDoInterp);
 
-	SkPaint_Inflate(&fPaint, dom, node);
+    SkPaint_Inflate(&fPaint, dom, node);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 SkSliderView::SkSliderView(U32 flags) : SkWidgetView(flags)
 {
-	fValue = 0;
-	fMax = 0;
+    fValue = 0;
+    fMax = 0;
 }
 
 static U16 actual_value(U16CPU value, U16CPU max)
 {
-	return SkToU16(SkMax32(0, SkMin32(value, max)));
+    return SkToU16(SkMax32(0, SkMin32(value, max)));
 }
 
 void SkSliderView::setMax(U16CPU max)
 {
-	if (fMax != max)
-	{
-		fMax = SkToU16(max);
-		if (fValue > 0)
-			this->inval(NULL);
-	}
+    if (fMax != max)
+    {
+        fMax = SkToU16(max);
+        if (fValue > 0)
+            this->inval(NULL);
+    }
 }
 
 void SkSliderView::setValue(U16CPU value)
 {
-	if (fValue != value)
-	{
-		U16 prev = actual_value(fValue, fMax);
-		U16 next = actual_value(value, fMax);
+    if (fValue != value)
+    {
+        U16 prev = actual_value(fValue, fMax);
+        U16 next = actual_value(value, fMax);
 
-		fValue = SkToU16(value);
-		if (prev != next)
-		{
-			this->inval(NULL);
+        fValue = SkToU16(value);
+        if (prev != next)
+        {
+            this->inval(NULL);
 
-			if (this->hasListeners())
-			{
-				SkEvent	evt;
-				
-				evt.setType(SkWidgetView::GetEventType());
-				evt.setFast32(this->getSinkID());
-				evt.setS32("sliderValue", next);
-				this->postToListeners(evt);
-			}
-		}
-	}
+            if (this->hasListeners())
+            {
+                SkEvent    evt;
+
+                evt.setType(SkWidgetView::GetEventType());
+                evt.setFast32(this->getSinkID());
+                evt.setS32("sliderValue", next);
+                this->postToListeners(evt);
+            }
+        }
+    }
 }
 
 #include "SkGradientShader.h"
 
 static void setgrad(SkPaint* paint, const SkRect& r)
 {
-	SkPoint	pts[2];
-	SkColor	colors[2];
+    SkPoint    pts[2];
+    SkColor    colors[2];
 
 #if 0
-	pts[0].set(r.fLeft, r.fTop);
-	pts[1].set(r.fLeft + r.height(), r.fBottom);
+    pts[0].set(r.fLeft, r.fTop);
+    pts[1].set(r.fLeft + r.height(), r.fBottom);
 #else
-	pts[0].set(r.fRight, r.fBottom);
-	pts[1].set(r.fRight - r.height(), r.fTop);
+    pts[0].set(r.fRight, r.fBottom);
+    pts[1].set(r.fRight - r.height(), r.fTop);
 #endif
-	colors[0] = SK_ColorBLUE;
-	colors[1] = SK_ColorWHITE;
+    colors[0] = SK_ColorBLUE;
+    colors[1] = SK_ColorWHITE;
 
-	paint->setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode))->unref();
+    paint->setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode))->unref();
 }
 
 void SkSliderView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
+    U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
 
-	SkRect	r;
-	SkPaint	p;
+    SkRect    r;
+    SkPaint    p;
 
-	r.set(0, 0, this->width(), this->height());
+    r.set(0, 0, this->width(), this->height());
 
-	p.setAntiAliasOn(true);
-	p.setStyle(SkPaint::kStroke_Style);
-	p.setStrokeWidth(SK_Scalar1);
-	r.inset(SK_Scalar1/2, SK_Scalar1/2);
-	canvas->drawRect(r, p);
+    p.setAntiAliasOn(true);
+    p.setStyle(SkPaint::kStroke_Style);
+    p.setStrokeWidth(SK_Scalar1);
+    r.inset(SK_Scalar1/2, SK_Scalar1/2);
+    canvas->drawRect(r, p);
 
-	if (fMax)
-	{
-		SkFixed percent = SkFixedDiv(value, fMax);
-		
-		r.inset(SK_Scalar1/2, SK_Scalar1/2);
-		r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
-		p.setStyle(SkPaint::kFill_Style);
-		setgrad(&p, r);
-		canvas->drawRect(r, p);
-	}
+    if (fMax)
+    {
+        SkFixed percent = SkFixedDiv(value, fMax);
+
+        r.inset(SK_Scalar1/2, SK_Scalar1/2);
+        r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent));
+        p.setStyle(SkPaint::kFill_Style);
+        setgrad(&p, r);
+        canvas->drawRect(r, p);
+    }
 
 #if 0
-	r.set(0, 0, this->width(), this->height());
-	r.inset(SK_Scalar1, SK_Scalar1);
-	r.inset(r.width()/2, 0);
-	p.setColor(SK_ColorBLACK);
-	canvas->drawLine(*(SkPoint*)&r.fLeft, *(SkPoint*)&r.fRight, p);
+    r.set(0, 0, this->width(), this->height());
+    r.inset(SK_Scalar1, SK_Scalar1);
+    r.inset(r.width()/2, 0);
+    p.setColor(SK_ColorBLACK);
+    canvas->drawLine(*(SkPoint*)&r.fLeft, *(SkPoint*)&r.fRight, p);
 #endif
 }
 
 SkView::Click* SkSliderView::onFindClickHandler(SkScalar x, SkScalar y)
 {
-	return new Click(this);
+    return new Click(this);
 }
 
 bool SkSliderView::onClick(Click* click)
 {
-	if (fMax)
-	{
-		SkScalar percent = SkScalarDiv(click->fCurr.fX + SK_Scalar1, this->width() - SK_Scalar1*2);
-		percent = SkMaxScalar(0, SkMinScalar(percent, SK_Scalar1));
-		this->setValue(SkScalarRound(percent * fMax));
-		return true;
-	}
-	return false;
+    if (fMax)
+    {
+        SkScalar percent = SkScalarDiv(click->fCurr.fX + SK_Scalar1, this->width() - SK_Scalar1*2);
+        percent = SkMaxScalar(0, SkMinScalar(percent, SK_Scalar1));
+        this->setValue(SkScalarRound(percent * fMax));
+        return true;
+    }
+    return false;
 }
 
 #endif
diff --git a/src/views/SkWidgets.cpp b/src/views/SkWidgets.cpp
index 69d755b..1693a31 100644
--- a/src/views/SkWidgets.cpp
+++ b/src/views/SkWidgets.cpp
@@ -15,14 +15,14 @@
 #if 0
 
 #ifdef SK_DEBUG
-	static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
-	{
-		const char* value = dom.findAttr(node, attr);
-		if (value)
-			SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
-	}
+    static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[])
+    {
+        const char* value = dom.findAttr(node, attr);
+        if (value)
+            SkDebugf("unknown attribute %s=\"%s\"\n", attr, value);
+    }
 #else
-	#define assert_no_attr(dom, node, attr)
+    #define assert_no_attr(dom, node, attr)
 #endif
 
 #include "SkAnimator.h"
@@ -31,56 +31,56 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 enum SkinType {
-	kPushButton_SkinType,
-	kStaticText_SkinType,
+    kPushButton_SkinType,
+    kStaticText_SkinType,
 
-	kSkinTypeCount
+    kSkinTypeCount
 };
 
 struct SkinSuite {
-	SkinSuite();
-	~SkinSuite()
-	{
-		for (int i = 0; i < kSkinTypeCount; i++)
-			delete fAnimators[i];
-	}
+    SkinSuite();
+    ~SkinSuite()
+    {
+        for (int i = 0; i < kSkinTypeCount; i++)
+            delete fAnimators[i];
+    }
 
-	SkAnimator*	get(SkinType);
+    SkAnimator*    get(SkinType);
 
 private:
-	SkAnimator*	fAnimators[kSkinTypeCount];
+    SkAnimator*    fAnimators[kSkinTypeCount];
 };
 
 SkinSuite::SkinSuite()
 {
-	static const char kSkinPath[] = "skins/";
+    static const char kSkinPath[] = "skins/";
 
-	static const char* gSkinNames[] = {
-		"pushbutton_skin.xml",
-		"statictext_skin.xml"
-	};
+    static const char* gSkinNames[] = {
+        "pushbutton_skin.xml",
+        "statictext_skin.xml"
+    };
 
-	for (unsigned i = 0; i < SK_ARRAY_COUNT(gSkinNames); i++)
-	{
-		size_t		len = strlen(gSkinNames[i]);
-		SkString	path(sizeof(kSkinPath) - 1 + len);
+    for (unsigned i = 0; i < SK_ARRAY_COUNT(gSkinNames); i++)
+    {
+        size_t        len = strlen(gSkinNames[i]);
+        SkString    path(sizeof(kSkinPath) - 1 + len);
 
-		memcpy(path.writable_str(), kSkinPath, sizeof(kSkinPath) - 1);
-		memcpy(path.writable_str() + sizeof(kSkinPath) - 1, gSkinNames[i], len);
+        memcpy(path.writable_str(), kSkinPath, sizeof(kSkinPath) - 1);
+        memcpy(path.writable_str() + sizeof(kSkinPath) - 1, gSkinNames[i], len);
 
-		fAnimators[i] = new SkAnimator;
-		if (!fAnimators[i]->decodeURI(path.c_str()))
-		{
-			delete fAnimators[i];
-			fAnimators[i] = NULL;
-		}
-	}
+        fAnimators[i] = new SkAnimator;
+        if (!fAnimators[i]->decodeURI(path.c_str()))
+        {
+            delete fAnimators[i];
+            fAnimators[i] = NULL;
+        }
+    }
 }
 
 SkAnimator* SkinSuite::get(SkinType st)
 {
-	SkASSERT((unsigned)st < kSkinTypeCount);
-	return fAnimators[st];
+    SkASSERT((unsigned)st < kSkinTypeCount);
+    return fAnimators[st];
 }
 
 static SkinSuite* gSkinSuite;
@@ -88,11 +88,11 @@
 static SkAnimator* get_skin_animator(SkinType st)
 {
 #if 0
-	if (gSkinSuite == NULL)
-		gSkinSuite = new SkinSuite;
-	return gSkinSuite->get(st);
+    if (gSkinSuite == NULL)
+        gSkinSuite = new SkinSuite;
+    return gSkinSuite->get(st);
 #else
-	return NULL;
+    return NULL;
 #endif
 }
 
@@ -104,134 +104,134 @@
 
 void SkWidget::Term()
 {
-	delete gSkinSuite;
+    delete gSkinSuite;
 }
 
 void SkWidget::onEnabledChange()
 {
-	this->inval(NULL);
+    this->inval(NULL);
 }
 
 void SkWidget::postWidgetEvent()
 {
-	if (!fEvent.isType("") && this->hasListeners())
-	{
-		this->prepareWidgetEvent(&fEvent);
-		this->postToListeners(fEvent);
-	}
+    if (!fEvent.isType("") && this->hasListeners())
+    {
+        this->prepareWidgetEvent(&fEvent);
+        this->postToListeners(fEvent);
+    }
 }
 
 void SkWidget::prepareWidgetEvent(SkEvent*)
 {
-	// override in subclass to add any additional fields before posting
+    // override in subclass to add any additional fields before posting
 }
 
 void SkWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	if ((node = dom.getFirstChild(node, "event")) != NULL)
-		fEvent.inflate(dom, node);
+    if ((node = dom.getFirstChild(node, "event")) != NULL)
+        fEvent.inflate(dom, node);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 size_t SkHasLabelWidget::getLabel(SkString* str) const
 {
-	if (str)
-		*str = fLabel;
-	return fLabel.size();
+    if (str)
+        *str = fLabel;
+    return fLabel.size();
 }
 
 size_t SkHasLabelWidget::getLabel(char buffer[]) const
 {
-	if (buffer)
-		memcpy(buffer, fLabel.c_str(), fLabel.size());
-	return fLabel.size();
+    if (buffer)
+        memcpy(buffer, fLabel.c_str(), fLabel.size());
+    return fLabel.size();
 }
 
 void SkHasLabelWidget::setLabel(const SkString& str)
 {
-	this->setLabel(str.c_str(), str.size());
+    this->setLabel(str.c_str(), str.size());
 }
 
 void SkHasLabelWidget::setLabel(const char label[])
 {
-	this->setLabel(label, strlen(label));
+    this->setLabel(label, strlen(label));
 }
 
 void SkHasLabelWidget::setLabel(const char label[], size_t len)
 {
-	if (!fLabel.equals(label, len))
-	{
-		fLabel.set(label, len);
-		this->onLabelChange();
-	}
+    if (!fLabel.equals(label, len))
+    {
+        fLabel.set(label, len);
+        this->onLabelChange();
+    }
 }
 
 void SkHasLabelWidget::onLabelChange()
 {
-	// override in subclass
+    // override in subclass
 }
 
 void SkHasLabelWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	const char* text = dom.findAttr(node, "label");
-	if (text)
-		this->setLabel(text);
+    const char* text = dom.findAttr(node, "label");
+    if (text)
+        this->setLabel(text);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 void SkButtonWidget::setButtonState(State state)
 {
-	if (fState != state)
-	{
-		fState = state;
-		this->onButtonStateChange();
-	}
+    if (fState != state)
+    {
+        fState = state;
+        this->onButtonStateChange();
+    }
 }
 
 void SkButtonWidget::onButtonStateChange()
 {
-	this->inval(NULL);
+    this->inval(NULL);
 }
 
 void SkButtonWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	int	index;
-	if ((index = dom.findList(node, "buttonState", "off,on,unknown")) >= 0)
-		this->setButtonState((State)index);
+    int    index;
+    if ((index = dom.findList(node, "buttonState", "off,on,unknown")) >= 0)
+        this->setButtonState((State)index);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 bool SkPushButtonWidget::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey)
-	{
-		this->postWidgetEvent();
-		return true;
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey)
+    {
+        this->postWidgetEvent();
+        return true;
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 static const char* computeAnimatorState(int enabled, int focused, SkButtonWidget::State state)
 {
-	if (!enabled)
-		return "disabled";
-	if (state == SkButtonWidget::kOn_State)
-	{
-		SkASSERT(focused);
-		return "enabled-pressed";
-	}
-	if (focused)
-		return "enabled-focused";
-	return "enabled";
+    if (!enabled)
+        return "disabled";
+    if (state == SkButtonWidget::kOn_State)
+    {
+        SkASSERT(focused);
+        return "enabled-pressed";
+    }
+    if (focused)
+        return "enabled-focused";
+    return "enabled";
 }
 
 #include "SkBlurMaskFilter.h"
@@ -239,106 +239,106 @@
 
 static void create_emboss(SkPaint* paint, SkScalar radius, bool focus, bool pressed)
 {
-	SkEmbossMaskFilter::Light	light;
+    SkEmbossMaskFilter::Light    light;
 
-	light.fDirection[0] = SK_Scalar1/2;
-	light.fDirection[1] = SK_Scalar1/2;
-	light.fDirection[2] = SK_Scalar1/3;
-	light.fAmbient		= 0x48;
-	light.fSpecular		= 0x80;
+    light.fDirection[0] = SK_Scalar1/2;
+    light.fDirection[1] = SK_Scalar1/2;
+    light.fDirection[2] = SK_Scalar1/3;
+    light.fAmbient        = 0x48;
+    light.fSpecular        = 0x80;
 
-	if (pressed)
-	{
-		light.fDirection[0] = -light.fDirection[0];
-		light.fDirection[1] = -light.fDirection[1];
-	}
-	if (focus)
-		light.fDirection[2] += SK_Scalar1/4;
+    if (pressed)
+    {
+        light.fDirection[0] = -light.fDirection[0];
+        light.fDirection[1] = -light.fDirection[1];
+    }
+    if (focus)
+        light.fDirection[2] += SK_Scalar1/4;
 
-	paint->setMaskFilter(new SkEmbossMaskFilter(light, radius))->unref();
+    paint->setMaskFilter(new SkEmbossMaskFilter(light, radius))->unref();
 }
 
 void SkPushButtonWidget::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	SkString label;
-	this->getLabel(&label);
+    SkString label;
+    this->getLabel(&label);
 
-	SkAnimator* anim = get_skin_animator(kPushButton_SkinType);
+    SkAnimator* anim = get_skin_animator(kPushButton_SkinType);
 
-	if (anim)
-	{
-		SkEvent	evt("user");
+    if (anim)
+    {
+        SkEvent    evt("user");
 
-		evt.setString("id", "prime");
-		evt.setScalar("prime-width", this->width());
-		evt.setScalar("prime-height", this->height());
-		evt.setString("prime-text", label);
-		evt.setString("prime-state", computeAnimatorState(this->isEnabled(), this->hasFocus(), this->getButtonState()));
+        evt.setString("id", "prime");
+        evt.setScalar("prime-width", this->width());
+        evt.setScalar("prime-height", this->height());
+        evt.setString("prime-text", label);
+        evt.setString("prime-state", computeAnimatorState(this->isEnabled(), this->hasFocus(), this->getButtonState()));
 
-		(void)anim->doUserEvent(evt);
-		SkPaint paint;
-		anim->draw(canvas, &paint, SkTime::GetMSecs());
-	}
-	else
-	{
-		SkRect	r;
-		SkPaint	p;
+        (void)anim->doUserEvent(evt);
+        SkPaint paint;
+        anim->draw(canvas, &paint, SkTime::GetMSecs());
+    }
+    else
+    {
+        SkRect    r;
+        SkPaint    p;
 
-		r.set(0, 0, this->width(), this->height());
-		p.setAntiAliasOn(true);
-		p.setColor(SK_ColorBLUE);
-		create_emboss(&p, SkIntToScalar(12)/5, this->hasFocus(), this->getButtonState() == kOn_State);
-		canvas->drawRoundRect(r, SkScalarHalf(this->height()), SkScalarHalf(this->height()), p);
-		p.setMaskFilter(NULL);
+        r.set(0, 0, this->width(), this->height());
+        p.setAntiAliasOn(true);
+        p.setColor(SK_ColorBLUE);
+        create_emboss(&p, SkIntToScalar(12)/5, this->hasFocus(), this->getButtonState() == kOn_State);
+        canvas->drawRoundRect(r, SkScalarHalf(this->height()), SkScalarHalf(this->height()), p);
+        p.setMaskFilter(NULL);
 
-		p.setTextAlign(SkPaint::kCenter_Align);
+        p.setTextAlign(SkPaint::kCenter_Align);
 
-		SkTextBox	box;
-		box.setMode(SkTextBox::kOneLine_Mode);
-		box.setSpacingAlign(SkTextBox::kCenter_SpacingAlign);
-		box.setBox(0, 0, this->width(), this->height());
+        SkTextBox    box;
+        box.setMode(SkTextBox::kOneLine_Mode);
+        box.setSpacingAlign(SkTextBox::kCenter_SpacingAlign);
+        box.setBox(0, 0, this->width(), this->height());
 
-//		if (this->getButtonState() == kOn_State)
-//			p.setColor(SK_ColorRED);
-//		else
-			p.setColor(SK_ColorWHITE);
+//        if (this->getButtonState() == kOn_State)
+//            p.setColor(SK_ColorRED);
+//        else
+            p.setColor(SK_ColorWHITE);
 
-		box.draw(canvas, label.c_str(), label.size(), p);
-	}
+        box.draw(canvas, label.c_str(), label.size(), p);
+    }
 }
 
 SkView::Click* SkPushButtonWidget::onFindClickHandler(SkScalar x, SkScalar y)
 {
-	this->acceptFocus();
-	return new Click(this);
+    this->acceptFocus();
+    return new Click(this);
 }
 
 bool SkPushButtonWidget::onClick(Click* click)
 {
-	SkRect	r;
-	State	state = kOff_State;
+    SkRect    r;
+    State    state = kOff_State;
 
-	this->getLocalBounds(&r);
-	if (r.contains(click->fCurr))
-	{
-		if (click->fState == Click::kUp_State)
-			this->postWidgetEvent();
-		else
-			state = kOn_State;
-	}
-	this->setButtonState(state);
-	return true;
+    this->getLocalBounds(&r);
+    if (r.contains(click->fCurr))
+    {
+        if (click->fState == Click::kUp_State)
+            this->postWidgetEvent();
+        else
+            state = kOn_State;
+    }
+    this->setButtonState(state);
+    return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 SkStaticTextView::SkStaticTextView(U32 flags) : SkView(flags)
 {
-	fMargin.set(0, 0);
-	fMode = kFixedSize_Mode;
-	fSpacingAlign = SkTextBox::kStart_SpacingAlign;
+    fMargin.set(0, 0);
+    fMode = kFixedSize_Mode;
+    fSpacingAlign = SkTextBox::kStart_SpacingAlign;
 }
 
 SkStaticTextView::~SkStaticTextView()
@@ -347,148 +347,148 @@
 
 void SkStaticTextView::computeSize()
 {
-	if (fMode == kAutoWidth_Mode)
-	{
-		SkScalar width = fPaint.measureText(fText.c_str(), fText.size(), NULL, NULL);
-		this->setWidth(width + fMargin.fX * 2);
-	}
-	else if (fMode == kAutoHeight_Mode)
-	{
-		SkScalar width = this->width() - fMargin.fX * 2;
-		int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
+    if (fMode == kAutoWidth_Mode)
+    {
+        SkScalar width = fPaint.measureText(fText.c_str(), fText.size(), NULL, NULL);
+        this->setWidth(width + fMargin.fX * 2);
+    }
+    else if (fMode == kAutoHeight_Mode)
+    {
+        SkScalar width = this->width() - fMargin.fX * 2;
+        int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
 
-		SkScalar	before, after;
-		(void)fPaint.measureText(0, NULL, &before, &after);
+        SkScalar    before, after;
+        (void)fPaint.measureText(0, NULL, &before, &after);
 
-		this->setHeight(lines * (after - before) + fMargin.fY * 2);
-	}
+        this->setHeight(lines * (after - before) + fMargin.fY * 2);
+    }
 }
 
 void SkStaticTextView::setMode(Mode mode)
 {
-	SkASSERT((unsigned)mode < kModeCount);
+    SkASSERT((unsigned)mode < kModeCount);
 
-	if (fMode != mode)
-	{
-		fMode = SkToU8(mode);
-		this->computeSize();
-	}
+    if (fMode != mode)
+    {
+        fMode = SkToU8(mode);
+        this->computeSize();
+    }
 }
 
 void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
 {
-	fSpacingAlign = SkToU8(align);
-	this->inval(NULL);
+    fSpacingAlign = SkToU8(align);
+    this->inval(NULL);
 }
 
 void SkStaticTextView::getMargin(SkPoint* margin) const
 {
-	if (margin)
-		*margin = fMargin;
+    if (margin)
+        *margin = fMargin;
 }
 
 void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy)
 {
-	if (fMargin.fX != dx || fMargin.fY != dy)
-	{
-		fMargin.set(dx, dy);
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (fMargin.fX != dx || fMargin.fY != dy)
+    {
+        fMargin.set(dx, dy);
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 size_t SkStaticTextView::getText(SkString* text) const
 {
-	if (text)
-		*text = fText;
-	return fText.size();
+    if (text)
+        *text = fText;
+    return fText.size();
 }
 
 size_t SkStaticTextView::getText(char text[]) const
 {
-	if (text)
-		memcpy(text, fText.c_str(), fText.size());
-	return fText.size();
+    if (text)
+        memcpy(text, fText.c_str(), fText.size());
+    return fText.size();
 }
 
 void SkStaticTextView::setText(const SkString& text)
 {
-	this->setText(text.c_str(), text.size());
+    this->setText(text.c_str(), text.size());
 }
 
 void SkStaticTextView::setText(const char text[])
 {
-	this->setText(text, strlen(text));
+    this->setText(text, strlen(text));
 }
 
 void SkStaticTextView::setText(const char text[], size_t len)
 {
-	if (!fText.equals(text, len))
-	{
-		fText.set(text, len);
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (!fText.equals(text, len))
+    {
+        fText.set(text, len);
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 void SkStaticTextView::getPaint(SkPaint* paint) const
 {
-	if (paint)
-		*paint = fPaint;
+    if (paint)
+        *paint = fPaint;
 }
 
 void SkStaticTextView::setPaint(const SkPaint& paint)
 {
-	if (fPaint != paint)
-	{
-		fPaint = paint;
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (fPaint != paint)
+    {
+        fPaint = paint;
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 void SkStaticTextView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	if (fText.isEmpty())
-		return;
+    if (fText.isEmpty())
+        return;
 
-	SkTextBox	box;
+    SkTextBox    box;
 
-	box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
-	box.setSpacingAlign(this->getSpacingAlign());
-	box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
-	box.draw(canvas, fText.c_str(), fText.size(), fPaint);
+    box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
+    box.setSpacingAlign(this->getSpacingAlign());
+    box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
+    box.draw(canvas, fText.c_str(), fText.size(), fPaint);
 }
 
 void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	int	index;
-	if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
-		this->setMode((Mode)index);
-	else
-		assert_no_attr(dom, node, "mode");
+    int    index;
+    if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
+        this->setMode((Mode)index);
+    else
+        assert_no_attr(dom, node, "mode");
 
-	if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
-		this->setSpacingAlign((SkTextBox::SpacingAlign)index);
-	else
-		assert_no_attr(dom, node, "mode");
+    if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
+        this->setSpacingAlign((SkTextBox::SpacingAlign)index);
+    else
+        assert_no_attr(dom, node, "mode");
 
-	SkScalar s[2];
-	if (dom.findScalars(node, "margin", s, 2))
-		this->setMargin(s[0], s[1]);
-	else
-		assert_no_attr(dom, node, "margin");
+    SkScalar s[2];
+    if (dom.findScalars(node, "margin", s, 2))
+        this->setMargin(s[0], s[1]);
+    else
+        assert_no_attr(dom, node, "margin");
 
-	const char* text = dom.findAttr(node, "text");
-	if (text)
-		this->setText(text);
+    const char* text = dom.findAttr(node, "text");
+    if (text)
+        this->setText(text);
 
-	if ((node = dom.getFirstChild(node, "paint")) != NULL)
-		SkPaint_Inflate(&fPaint, dom, node);
+    if ((node = dom.getFirstChild(node, "paint")) != NULL)
+        SkPaint_Inflate(&fPaint, dom, node);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -505,56 +505,56 @@
 
 bool SkBitmapView::getBitmap(SkBitmap* bitmap) const
 {
-	if (bitmap)
-		*bitmap = fBitmap;
-	return fBitmap.getConfig() != SkBitmap::kNo_Config;
+    if (bitmap)
+        *bitmap = fBitmap;
+    return fBitmap.getConfig() != SkBitmap::kNo_Config;
 }
 
 void SkBitmapView::setBitmap(const SkBitmap* bitmap, bool viewOwnsPixels)
 {
-	if (bitmap)
-	{
-		fBitmap = *bitmap;
-		fBitmap.setOwnsPixels(viewOwnsPixels);
-	}
+    if (bitmap)
+    {
+        fBitmap = *bitmap;
+        fBitmap.setOwnsPixels(viewOwnsPixels);
+    }
 }
 
 bool SkBitmapView::loadBitmapFromFile(const char path[])
 {
-	SkBitmap	bitmap;
+    SkBitmap    bitmap;
 
-	if (SkImageDecoder::DecodeFile(path, &bitmap))
-	{
-		this->setBitmap(&bitmap, true);
-		bitmap.setOwnsPixels(false);
-		return true;
-	}
-	return false;
+    if (SkImageDecoder::DecodeFile(path, &bitmap))
+    {
+        this->setBitmap(&bitmap, true);
+        bitmap.setOwnsPixels(false);
+        return true;
+    }
+    return false;
 }
 
 void SkBitmapView::onDraw(SkCanvas* canvas)
 {
-	if (fBitmap.getConfig() != SkBitmap::kNo_Config &&
-		fBitmap.width() && fBitmap.height())
-	{
-		SkAutoCanvasRestore	restore(canvas, true);
-		SkPaint				p;
+    if (fBitmap.getConfig() != SkBitmap::kNo_Config &&
+        fBitmap.width() && fBitmap.height())
+    {
+        SkAutoCanvasRestore    restore(canvas, true);
+        SkPaint                p;
 
-		p.setFilterType(SkPaint::kBilinear_FilterType);
-		canvas->scale(	this->width() / fBitmap.width(),
-						this->height() / fBitmap.height(),
-						0, 0);
-		canvas->drawBitmap(fBitmap, 0, 0, p);
-	}
+        p.setFilterType(SkPaint::kBilinear_FilterType);
+        canvas->scale(    this->width() / fBitmap.width(),
+                        this->height() / fBitmap.height(),
+                        0, 0);
+        canvas->drawBitmap(fBitmap, 0, 0, p);
+    }
 }
 
 void SkBitmapView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	const char* src = dom.findAttr(node, "src");
-	if (src)
-		(void)this->loadBitmapFromFile(src);
+    const char* src = dom.findAttr(node, "src");
+    if (src)
+        (void)this->loadBitmapFromFile(src);
 }
 
 #endif
diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp
index c952a61..85b3803 100644
--- a/src/views/SkWindow.cpp
+++ b/src/views/SkWindow.cpp
@@ -19,31 +19,31 @@
 #include "SkBounder.h"
 class test_bounder : public SkBounder {
 public:
-	test_bounder(const SkBitmap& bm) : fCanvas(bm) {}
+    test_bounder(const SkBitmap& bm) : fCanvas(bm) {}
 protected:
-	virtual bool onIRect(const SkIRect& r)
-	{
-		SkRect	rr;
+    virtual bool onIRect(const SkIRect& r)
+    {
+        SkRect    rr;
 
-		rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop),
-				SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom));
+        rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop),
+                SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom));
 
-		SkPaint	p;
+        SkPaint    p;
 
-		p.setStyle(SkPaint::kStroke_Style);
-		p.setColor(SK_ColorYELLOW);
+        p.setStyle(SkPaint::kStroke_Style);
+        p.setColor(SK_ColorYELLOW);
 
 #if 0
-		rr.inset(SK_ScalarHalf, SK_ScalarHalf);
+        rr.inset(SK_ScalarHalf, SK_ScalarHalf);
 #else
-		rr.inset(-SK_ScalarHalf, -SK_ScalarHalf);
+        rr.inset(-SK_ScalarHalf, -SK_ScalarHalf);
 #endif
 
-		fCanvas.drawRect(rr, p);
-		return true;
-	}
+        fCanvas.drawRect(rr, p);
+        return true;
+    }
 private:
-	SkCanvas	fCanvas;
+    SkCanvas    fCanvas;
 };
 
 SkWindow::SkWindow() : fFocusView(NULL)
@@ -87,39 +87,39 @@
 
 void SkWindow::setConfig(SkBitmap::Config config)
 {
-	this->resize(fBitmap.width(), fBitmap.height(), config);
+    this->resize(fBitmap.width(), fBitmap.height(), config);
 }
 
 void SkWindow::resize(int width, int height, SkBitmap::Config config)
 {
-	if (config == SkBitmap::kNo_Config)
-		config = fConfig;
+    if (config == SkBitmap::kNo_Config)
+        config = fConfig;
 
-	if (width != fBitmap.width() || height != fBitmap.height() || config != fConfig)
-	{
-		fConfig = config;
-		fBitmap.setConfig(config, width, height);
-		fBitmap.allocPixels();
+    if (width != fBitmap.width() || height != fBitmap.height() || config != fConfig)
+    {
+        fConfig = config;
+        fBitmap.setConfig(config, width, height);
+        fBitmap.allocPixels();
         fBitmap.setIsOpaque(true);
 
-		this->setSize(SkIntToScalar(width), SkIntToScalar(height));
-		this->inval(NULL);
-	}
+        this->setSize(SkIntToScalar(width), SkIntToScalar(height));
+        this->inval(NULL);
+    }
 }
 
 void SkWindow::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
 {
-	fBitmap.eraseARGB(a, r, g, b);
+    fBitmap.eraseARGB(a, r, g, b);
 }
 
 void SkWindow::eraseRGB(U8CPU r, U8CPU g, U8CPU b)
 {
-	fBitmap.eraseRGB(r, g, b);
+    fBitmap.eraseRGB(r, g, b);
 }
 
 bool SkWindow::handleInval(const SkRect* localR)
 {
-	SkIRect	ir;
+    SkIRect    ir;
 
     if (localR) {
         SkRect devR;
@@ -131,13 +131,13 @@
         devR.round(&ir);
     } else {
         ir.set(0, 0,
-			   SkScalarRound(this->width()),
-			   SkScalarRound(this->height()));
+               SkScalarRound(this->width()),
+               SkScalarRound(this->height()));
     }
-	fDirtyRgn.op(ir, SkRegion::kUnion_Op);
+    fDirtyRgn.op(ir, SkRegion::kUnion_Op);
 
-	this->onHandleInval(ir);
-	return true;
+    this->onHandleInval(ir);
+    return true;
 }
 
 void SkWindow::forceInvalAll() {
@@ -147,9 +147,9 @@
 }
 
 #if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-	#include <windows.h>
-	#include <gx.h>
-	extern GXDisplayProperties gDisplayProps;
+    #include <windows.h>
+    #include <gx.h>
+    extern GXDisplayProperties gDisplayProps;
 #endif
 
 #ifdef SK_SIMULATE_FAILED_MALLOC
@@ -158,128 +158,128 @@
 
 bool SkWindow::update(SkIRect* updateArea, SkCanvas* canvas)
 {
-	if (!fDirtyRgn.isEmpty())
-	{
-		SkBitmap bm = this->getBitmap();
+    if (!fDirtyRgn.isEmpty())
+    {
+        SkBitmap bm = this->getBitmap();
 
 #if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-		char* buffer = (char*)GXBeginDraw();
-		SkASSERT(buffer);
+        char* buffer = (char*)GXBeginDraw();
+        SkASSERT(buffer);
 
-		RECT	rect;
-		GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect);
-		buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch;
+        RECT    rect;
+        GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect);
+        buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch;
 
-		bm.setPixels(buffer);
+        bm.setPixels(buffer);
 #endif
 
-		SkCanvas	rasterCanvas;
+        SkCanvas    rasterCanvas;
 
         if (NULL == canvas) {
             canvas = &rasterCanvas;
         }
         canvas->setBitmapDevice(bm);
 
-		canvas->clipRegion(fDirtyRgn);
-		if (updateArea)
-			*updateArea = fDirtyRgn.getBounds();
+        canvas->clipRegion(fDirtyRgn);
+        if (updateArea)
+            *updateArea = fDirtyRgn.getBounds();
 
         SkAutoCanvasRestore acr(canvas, true);
         canvas->concat(fMatrix);
 
-		// empty this now, so we can correctly record any inval calls that
-		// might be made during the draw call.
-		fDirtyRgn.setEmpty();
+        // empty this now, so we can correctly record any inval calls that
+        // might be made during the draw call.
+        fDirtyRgn.setEmpty();
 
 #ifdef TEST_BOUNDER
-		test_bounder	b(bm);
-		canvas->setBounder(&b);
+        test_bounder    b(bm);
+        canvas->setBounder(&b);
 #endif
 #ifdef SK_SIMULATE_FAILED_MALLOC
-		gEnableControlledThrow = true;
+        gEnableControlledThrow = true;
 #endif
 #ifdef SK_BUILD_FOR_WIN32
-		//try {
-			this->draw(canvas);
-		//}
-		//catch (...) {
-		//}
+        //try {
+            this->draw(canvas);
+        //}
+        //catch (...) {
+        //}
 #else
-		this->draw(canvas);
+        this->draw(canvas);
 #endif
 #ifdef SK_SIMULATE_FAILED_MALLOC
-		gEnableControlledThrow = false;
+        gEnableControlledThrow = false;
 #endif
 #ifdef TEST_BOUNDER
-		canvas->setBounder(NULL);
+        canvas->setBounder(NULL);
 #endif
 
 #if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-		GXEndDraw();
+        GXEndDraw();
 #endif
 
-		return true;
-	}
-	return false;
+        return true;
+    }
+    return false;
 }
 
 bool SkWindow::handleChar(SkUnichar uni)
 {
-	if (this->onHandleChar(uni))
-		return true;
+    if (this->onHandleChar(uni))
+        return true;
 
-	SkView* focus = this->getFocusView();
-	if (focus == NULL)
-		focus = this;
+    SkView* focus = this->getFocusView();
+    if (focus == NULL)
+        focus = this;
 
-	SkEvent evt(SK_EventType_Unichar);
-	evt.setFast32(uni);
-	return focus->doEvent(evt);
+    SkEvent evt(SK_EventType_Unichar);
+    evt.setFast32(uni);
+    return focus->doEvent(evt);
 }
 
 bool SkWindow::handleKey(SkKey key)
 {
-	if (key == kNONE_SkKey)
-		return false;
+    if (key == kNONE_SkKey)
+        return false;
 
-	if (this->onHandleKey(key))
-		return true;
+    if (this->onHandleKey(key))
+        return true;
 
-	// send an event to the focus-view
-	{
-		SkView* focus = this->getFocusView();
-		if (focus == NULL)
-			focus = this;
+    // send an event to the focus-view
+    {
+        SkView* focus = this->getFocusView();
+        if (focus == NULL)
+            focus = this;
 
-		SkEvent evt(SK_EventType_Key);
-		evt.setFast32(key);
-		if (focus->doEvent(evt))
-			return true;
-	}
+        SkEvent evt(SK_EventType_Key);
+        evt.setFast32(key);
+        if (focus->doEvent(evt))
+            return true;
+    }
 
-	if (key == kUp_SkKey || key == kDown_SkKey)
-	{
-		if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == NULL)
-			this->onSetFocusView(NULL);
-		return true;
-	}
-	return false;
+    if (key == kUp_SkKey || key == kDown_SkKey)
+    {
+        if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == NULL)
+            this->onSetFocusView(NULL);
+        return true;
+    }
+    return false;
 }
 
 bool SkWindow::handleKeyUp(SkKey key)
 {
     if (key == kNONE_SkKey)
         return false;
-        
+
     if (this->onHandleKeyUp(key))
         return true;
-    
+
     //send an event to the focus-view
     {
         SkView* focus = this->getFocusView();
         if (focus == NULL)
             focus = this;
-            
+
         //should this one be the same?
         SkEvent evt(SK_EventType_KeyUp);
         evt.setFast32(key);
@@ -290,8 +290,8 @@
 }
 
 void SkWindow::addMenu(SkOSMenu* menu) {
-	*fMenus.append() = menu;
-	this->onAddMenu(menu);
+    *fMenus.append() = menu;
+    this->onAddMenu(menu);
 }
 
 void SkWindow::setTitle(const char title[]) {
@@ -306,36 +306,36 @@
 
 bool SkWindow::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventDelayInval))
-	{
-		SkRegion::Iterator	iter(fDirtyRgn);
+    if (evt.isType(SK_EventDelayInval))
+    {
+        SkRegion::Iterator    iter(fDirtyRgn);
 
-		for (; !iter.done(); iter.next())
-			this->onHandleInval(iter.rect());
-		fWaitingOnInval = false;
-		return true;
-	}
-	return this->INHERITED::onEvent(evt);
+        for (; !iter.done(); iter.next())
+            this->onHandleInval(iter.rect());
+        fWaitingOnInval = false;
+        return true;
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 bool SkWindow::onGetFocusView(SkView** focus) const
 {
-	if (focus)
-		*focus = fFocusView;
-	return true;
+    if (focus)
+        *focus = fFocusView;
+    return true;
 }
 
 bool SkWindow::onSetFocusView(SkView* focus)
 {
-	if (fFocusView != focus)
-	{
-		if (fFocusView)
-			fFocusView->onFocusChange(false);
-		fFocusView = focus;
-		if (focus)
-			focus->onFocusChange(true);
-	}
-	return true;
+    if (fFocusView != focus)
+    {
+        if (fFocusView)
+            fFocusView->onFocusChange(false);
+        fFocusView = focus;
+        if (focus)
+            focus->onFocusChange(true);
+    }
+    return true;
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -346,12 +346,12 @@
 
 bool SkWindow::onHandleChar(SkUnichar)
 {
-	return false;
+    return false;
 }
 
 bool SkWindow::onHandleKey(SkKey key)
 {
-	return false;
+    return false;
 }
 
 bool SkWindow::onHandleKeyUp(SkKey key)
@@ -365,7 +365,7 @@
 
 bool SkWindow::onDispatchClick(int x, int y, Click::State state,
         void* owner) {
-	bool handled = false;
+    bool handled = false;
 
     // First, attempt to find an existing click with this owner.
     int index = -1;
@@ -376,7 +376,7 @@
         }
     }
 
-	switch (state) {
+    switch (state) {
         case Click::kDown_State: {
             if (index != -1) {
                 delete fClicks[index];
@@ -410,7 +410,7 @@
         default:
             // Do nothing
             break;
-	}
-	return handled;
+    }
+    return handled;
 }
 
diff --git a/src/views/animated/SkBorderView.cpp b/src/views/animated/SkBorderView.cpp
index cc1c08b..3eff605 100644
--- a/src/views/animated/SkBorderView.cpp
+++ b/src/views/animated/SkBorderView.cpp
@@ -17,80 +17,80 @@
                                fTop(SkIntToScalar(0)),
                                fBottom(SkIntToScalar(0))
 {
-	fAnim.setHostEventSink(this);
-	init_skin_anim(kBorder_SkinEnum, &fAnim);
+    fAnim.setHostEventSink(this);
+    init_skin_anim(kBorder_SkinEnum, &fAnim);
 }
 
 SkBorderView::~SkBorderView()
 {
-	
+
 }
 
 void SkBorderView::setSkin(const char skin[])
 {
-	init_skin_anim(skin, &fAnim);
+    init_skin_anim(skin, &fAnim);
 }
 
 /* virtual */ void SkBorderView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 }
 
 /*virtual*/ void SkBorderView::onSizeChange()
 {
-	this->INHERITED::onSizeChange();
-	SkEvent evt("user");
-	evt.setString("id", "setDim");
-	evt.setScalar("dimX", this->width());
-	evt.setScalar("dimY", this->height());
-	fAnim.doUserEvent(evt);
+    this->INHERITED::onSizeChange();
+    SkEvent evt("user");
+    evt.setString("id", "setDim");
+    evt.setScalar("dimX", this->width());
+    evt.setScalar("dimY", this->height());
+    fAnim.doUserEvent(evt);
 }
 
 /*virtual*/ void SkBorderView::onDraw(SkCanvas* canvas)
 {
-	SkPaint						paint;		
-	SkAnimator::DifferenceType	diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
-	
-	if (diff == SkAnimator::kDifferent)
-		this->inval(NULL);
-	else if (diff == SkAnimator::kPartiallyDifferent)
-	{
-		SkRect	bounds;
-		fAnim.getInvalBounds(&bounds);
-		this->inval(&bounds);
-	}
+    SkPaint                        paint;
+    SkAnimator::DifferenceType    diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+    if (diff == SkAnimator::kDifferent)
+        this->inval(NULL);
+    else if (diff == SkAnimator::kPartiallyDifferent)
+    {
+        SkRect    bounds;
+        fAnim.getInvalBounds(&bounds);
+        this->inval(&bounds);
+    }
 }
 
 /*virtual*/ bool SkBorderView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Inval))
-	{
-		this->inval(NULL);
-		return true;
-	}
-	if (evt.isType("recommendDim"))
-	{
-		evt.findScalar("leftMargin", &fLeft);
-		evt.findScalar("rightMargin", &fRight);
-		evt.findScalar("topMargin", &fTop);
-		evt.findScalar("bottomMargin", &fBottom);
-	
-		//setup_views.cpp uses SkView::Layout instead of SkStackViewLayout
-		//but that gives me an error
-		SkStackViewLayout* layout;
-		fMargin.set(fLeft, fTop, fRight, fBottom);
-		if (this->getLayout())
-		{
-			layout = (SkStackViewLayout*)this->getLayout();
-			layout->setMargin(fMargin);
-		}
-		else
-		{
-			layout = new SkStackViewLayout;
-			layout->setMargin(fMargin);
-			this->setLayout(layout)->unref();
-		}
-		this->invokeLayout();
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Inval))
+    {
+        this->inval(NULL);
+        return true;
+    }
+    if (evt.isType("recommendDim"))
+    {
+        evt.findScalar("leftMargin", &fLeft);
+        evt.findScalar("rightMargin", &fRight);
+        evt.findScalar("topMargin", &fTop);
+        evt.findScalar("bottomMargin", &fBottom);
+
+        //setup_views.cpp uses SkView::Layout instead of SkStackViewLayout
+        //but that gives me an error
+        SkStackViewLayout* layout;
+        fMargin.set(fLeft, fTop, fRight, fBottom);
+        if (this->getLayout())
+        {
+            layout = (SkStackViewLayout*)this->getLayout();
+            layout->setMargin(fMargin);
+        }
+        else
+        {
+            layout = new SkStackViewLayout;
+            layout->setMargin(fMargin);
+            this->setLayout(layout)->unref();
+        }
+        this->invokeLayout();
+    }
+    return this->INHERITED::onEvent(evt);
 }
diff --git a/src/views/animated/SkImageView.cpp b/src/views/animated/SkImageView.cpp
index 8924dd3..a75aa73 100644
--- a/src/views/animated/SkImageView.cpp
+++ b/src/views/animated/SkImageView.cpp
@@ -16,288 +16,288 @@
 
 SkImageView::SkImageView()
 {
-	fMatrix		= NULL;
-	fScaleType	= kMatrix_ScaleType;
+    fMatrix        = NULL;
+    fScaleType    = kMatrix_ScaleType;
 
-	fData.fAnim	= NULL;		// handles initializing the other union values
-	fDataIsAnim	= true;
-	
-	fUriIsValid	= false;	// an empty string is not valid
+    fData.fAnim    = NULL;        // handles initializing the other union values
+    fDataIsAnim    = true;
+
+    fUriIsValid    = false;    // an empty string is not valid
 }
 
 SkImageView::~SkImageView()
 {
-	if (fMatrix)
-		sk_free(fMatrix);
-		
-	this->freeData();
+    if (fMatrix)
+        sk_free(fMatrix);
+
+    this->freeData();
 }
 
 void SkImageView::getUri(SkString* uri) const
 {
-	if (uri)
-		*uri = fUri;
+    if (uri)
+        *uri = fUri;
 }
 
 void SkImageView::setUri(const char uri[])
 {
-	if (!fUri.equals(uri))
-	{
-		fUri.set(uri);
-		this->onUriChange();
-	}
+    if (!fUri.equals(uri))
+    {
+        fUri.set(uri);
+        this->onUriChange();
+    }
 }
 
 void SkImageView::setUri(const SkString& uri)
 {
-	if (fUri != uri)
-	{
-		fUri = uri;
-		this->onUriChange();
-	}
+    if (fUri != uri)
+    {
+        fUri = uri;
+        this->onUriChange();
+    }
 }
 
 void SkImageView::setScaleType(ScaleType st)
 {
-	SkASSERT((unsigned)st <= kFitEnd_ScaleType);
+    SkASSERT((unsigned)st <= kFitEnd_ScaleType);
 
-	if ((ScaleType)fScaleType != st)
-	{
-		fScaleType = SkToU8(st);
-		if (fUriIsValid)
-			this->inval(NULL);
-	}
+    if ((ScaleType)fScaleType != st)
+    {
+        fScaleType = SkToU8(st);
+        if (fUriIsValid)
+            this->inval(NULL);
+    }
 }
 
 bool SkImageView::getImageMatrix(SkMatrix* matrix) const
 {
-	if (fMatrix)
-	{
-		SkASSERT(!fMatrix->isIdentity());
-		if (matrix)
-			*matrix = *fMatrix;
-		return true;
-	}
-	else
-	{
-		if (matrix)
-			matrix->reset();
-		return false;
-	}
+    if (fMatrix)
+    {
+        SkASSERT(!fMatrix->isIdentity());
+        if (matrix)
+            *matrix = *fMatrix;
+        return true;
+    }
+    else
+    {
+        if (matrix)
+            matrix->reset();
+        return false;
+    }
 }
 
 void SkImageView::setImageMatrix(const SkMatrix* matrix)
 {
-	bool changed = false;
+    bool changed = false;
 
-	if (matrix && !matrix->isIdentity())
-	{
-		if (fMatrix == NULL)
-			fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
-		*fMatrix = *matrix;
-		changed = true;
-	}
-	else	// set us to identity
-	{
-		if (fMatrix)
-		{
-			SkASSERT(!fMatrix->isIdentity());
-			sk_free(fMatrix);
-			fMatrix = NULL;
-			changed = true;
-		}
-	}
+    if (matrix && !matrix->isIdentity())
+    {
+        if (fMatrix == NULL)
+            fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));
+        *fMatrix = *matrix;
+        changed = true;
+    }
+    else    // set us to identity
+    {
+        if (fMatrix)
+        {
+            SkASSERT(!fMatrix->isIdentity());
+            sk_free(fMatrix);
+            fMatrix = NULL;
+            changed = true;
+        }
+    }
 
-	// only redraw if we changed our matrix and we're not in scaleToFit mode
-	if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid)
-		this->inval(NULL);
+    // only redraw if we changed our matrix and we're not in scaleToFit mode
+    if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid)
+        this->inval(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkImageView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Inval))
-	{
-		if (fUriIsValid)
-			this->inval(NULL);
-		return true;
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Inval))
+    {
+        if (fUriIsValid)
+            this->inval(NULL);
+        return true;
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st)
 {
-	SkASSERT(st != SkImageView::kMatrix_ScaleType);
-	SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType);
+    SkASSERT(st != SkImageView::kMatrix_ScaleType);
+    SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType);
 
-	SkASSERT(SkImageView::kFitXY_ScaleType - 1 == SkMatrix::kFill_ScaleToFit);
-	SkASSERT(SkImageView::kFitStart_ScaleType - 1 == SkMatrix::kStart_ScaleToFit);
-	SkASSERT(SkImageView::kFitCenter_ScaleType - 1 == SkMatrix::kCenter_ScaleToFit);
-	SkASSERT(SkImageView::kFitEnd_ScaleType - 1 == SkMatrix::kEnd_ScaleToFit);
-	
-	return (SkMatrix::ScaleToFit)(st - 1);
+    SkASSERT(SkImageView::kFitXY_ScaleType - 1 == SkMatrix::kFill_ScaleToFit);
+    SkASSERT(SkImageView::kFitStart_ScaleType - 1 == SkMatrix::kStart_ScaleToFit);
+    SkASSERT(SkImageView::kFitCenter_ScaleType - 1 == SkMatrix::kCenter_ScaleToFit);
+    SkASSERT(SkImageView::kFitEnd_ScaleType - 1 == SkMatrix::kEnd_ScaleToFit);
+
+    return (SkMatrix::ScaleToFit)(st - 1);
 }
 
 void SkImageView::onDraw(SkCanvas* canvas)
 {
-	SkRect	src;
-	if (!this->getDataBounds(&src))
-	{
-		SkDEBUGCODE(canvas->drawColor(SK_ColorRED);)
-		return;		// nothing to draw
-	}
-		
-	SkAutoCanvasRestore	restore(canvas, true);
-	SkMatrix			matrix;
-	
-	if (this->getScaleType() == kMatrix_ScaleType)
-		(void)this->getImageMatrix(&matrix);
-	else
-	{
-		SkRect	dst;		
-		dst.set(0, 0, this->width(), this->height());
-		matrix.setRectToRect(src, dst, scaleTypeToScaleToFit(this->getScaleType()));
-	}
-	canvas->concat(matrix);
+    SkRect    src;
+    if (!this->getDataBounds(&src))
+    {
+        SkDEBUGCODE(canvas->drawColor(SK_ColorRED);)
+        return;        // nothing to draw
+    }
 
-	SkPaint	paint;
-	
-	paint.setAntiAlias(true);
+    SkAutoCanvasRestore    restore(canvas, true);
+    SkMatrix            matrix;
 
-	if (fDataIsAnim)
-	{
-		SkMSec	now = SkTime::GetMSecs();
-		
-		SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now);
-		
+    if (this->getScaleType() == kMatrix_ScaleType)
+        (void)this->getImageMatrix(&matrix);
+    else
+    {
+        SkRect    dst;
+        dst.set(0, 0, this->width(), this->height());
+        matrix.setRectToRect(src, dst, scaleTypeToScaleToFit(this->getScaleType()));
+    }
+    canvas->concat(matrix);
+
+    SkPaint    paint;
+
+    paint.setAntiAlias(true);
+
+    if (fDataIsAnim)
+    {
+        SkMSec    now = SkTime::GetMSecs();
+
+        SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now);
+
 SkDEBUGF(("SkImageView : now = %X[%12.3f], diff = %d\n", now, now/1000., diff));
 
-		if (diff == SkAnimator::kDifferent)
-			this->inval(NULL);
-		else if (diff == SkAnimator::kPartiallyDifferent)
-		{
-			SkRect	bounds;
-			fData.fAnim->getInvalBounds(&bounds);
-			matrix.mapRect(&bounds);	// get the bounds into view coordinates
-			this->inval(&bounds);
-		}
-	}
-	else
-		canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint);
+        if (diff == SkAnimator::kDifferent)
+            this->inval(NULL);
+        else if (diff == SkAnimator::kPartiallyDifferent)
+        {
+            SkRect    bounds;
+            fData.fAnim->getInvalBounds(&bounds);
+            matrix.mapRect(&bounds);    // get the bounds into view coordinates
+            this->inval(&bounds);
+        }
+    }
+    else
+        canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint);
 }
 
 void SkImageView::onInflate(const SkDOM& dom, const SkDOMNode* node)
 {
-	this->INHERITED::onInflate(dom, node);
-	
-	const char* src = dom.findAttr(node, "src");
-	if (src)
-		this->setUri(src);
+    this->INHERITED::onInflate(dom, node);
 
-	int	index = dom.findList(node, "scaleType", "matrix,fitXY,fitStart,fitCenter,fitEnd");
-	if (index >= 0)
-		this->setScaleType((ScaleType)index);
-		
-	// need inflate syntax/reader for matrix
+    const char* src = dom.findAttr(node, "src");
+    if (src)
+        this->setUri(src);
+
+    int    index = dom.findList(node, "scaleType", "matrix,fitXY,fitStart,fitCenter,fitEnd");
+    if (index >= 0)
+        this->setScaleType((ScaleType)index);
+
+    // need inflate syntax/reader for matrix
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 
 void SkImageView::onUriChange()
 {
-	if (this->freeData())
-		this->inval(NULL);
-	fUriIsValid = true;		// give ensureUriIsLoaded() a shot at the new uri
+    if (this->freeData())
+        this->inval(NULL);
+    fUriIsValid = true;        // give ensureUriIsLoaded() a shot at the new uri
 }
 
 bool SkImageView::freeData()
 {
-	if (fData.fAnim)	// test is valid for all union values
-	{
-		if (fDataIsAnim)
-			delete fData.fAnim;
-		else
-			delete fData.fBitmap;
+    if (fData.fAnim)    // test is valid for all union values
+    {
+        if (fDataIsAnim)
+            delete fData.fAnim;
+        else
+            delete fData.fBitmap;
 
-		fData.fAnim = NULL;	// valid for all union values
-		return true;
-	}
-	return false;
+        fData.fAnim = NULL;    // valid for all union values
+        return true;
+    }
+    return false;
 }
 
 bool SkImageView::getDataBounds(SkRect* bounds)
 {
-	SkASSERT(bounds);
+    SkASSERT(bounds);
 
-	if (this->ensureUriIsLoaded())
-	{
-		SkScalar width, height;
+    if (this->ensureUriIsLoaded())
+    {
+        SkScalar width, height;
 
-		if (fDataIsAnim)
-		{			
-			if (SkScalarIsNaN(width = fData.fAnim->getScalar("dimensions", "x")) ||
-				SkScalarIsNaN(height = fData.fAnim->getScalar("dimensions", "y")))
-			{
-				// cons up fake bounds
-				width = this->width();
-				height = this->height();
-			}
-		}
-		else
-		{
-			width = SkIntToScalar(fData.fBitmap->width());
-			height = SkIntToScalar(fData.fBitmap->height());
-		}
-		bounds->set(0, 0, width, height);
-		return true;
-	}
-	return false;
+        if (fDataIsAnim)
+        {
+            if (SkScalarIsNaN(width = fData.fAnim->getScalar("dimensions", "x")) ||
+                SkScalarIsNaN(height = fData.fAnim->getScalar("dimensions", "y")))
+            {
+                // cons up fake bounds
+                width = this->width();
+                height = this->height();
+            }
+        }
+        else
+        {
+            width = SkIntToScalar(fData.fBitmap->width());
+            height = SkIntToScalar(fData.fBitmap->height());
+        }
+        bounds->set(0, 0, width, height);
+        return true;
+    }
+    return false;
 }
 
 bool SkImageView::ensureUriIsLoaded()
 {
-	if (fData.fAnim)	// test is valid for all union values
-	{
-		SkASSERT(fUriIsValid);
-		return true;
-	}
-	if (!fUriIsValid)
-		return false;
+    if (fData.fAnim)    // test is valid for all union values
+    {
+        SkASSERT(fUriIsValid);
+        return true;
+    }
+    if (!fUriIsValid)
+        return false;
 
-	// try to load the url
-	if (fUri.endsWith(".xml"))	// assume it is screenplay
-	{
-		SkAnimator* anim = new SkAnimator;
-		
-		if (!anim->decodeURI(fUri.c_str()))
-		{
-			delete anim;
-			fUriIsValid = false;
-			return false;
-		}
-		anim->setHostEventSink(this);
+    // try to load the url
+    if (fUri.endsWith(".xml"))    // assume it is screenplay
+    {
+        SkAnimator* anim = new SkAnimator;
 
-		fData.fAnim = anim;
-		fDataIsAnim = true;
-	}
-	else	// assume it is an image format
-	{
+        if (!anim->decodeURI(fUri.c_str()))
+        {
+            delete anim;
+            fUriIsValid = false;
+            return false;
+        }
+        anim->setHostEventSink(this);
+
+        fData.fAnim = anim;
+        fDataIsAnim = true;
+    }
+    else    // assume it is an image format
+    {
     #if 0
-		SkBitmap* bitmap = new SkBitmap;
+        SkBitmap* bitmap = new SkBitmap;
 
-		if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap))
-		{
-			delete bitmap;
-			fUriIsValid = false;
-			return false;
-		}
-		fData.fBitmap = bitmap;
-		fDataIsAnim = false;
+        if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap))
+        {
+            delete bitmap;
+            fUriIsValid = false;
+            return false;
+        }
+        fData.fBitmap = bitmap;
+        fDataIsAnim = false;
     #else
         return false;
     #endif
-	}
-	return true;
+    }
+    return true;
 }
 
diff --git a/src/views/animated/SkListView.cpp b/src/views/animated/SkListView.cpp
index 20747a2..ec9d2ee 100644
--- a/src/views/animated/SkListView.cpp
+++ b/src/views/animated/SkListView.cpp
@@ -16,192 +16,192 @@
 
 SkEvent* SkListSource::getEvent(int index)
 {
-	return NULL;
+    return NULL;
 }
 
 #include "SkOSFile.h"
 
 class SkDirListSource : public SkListSource {
 public:
-	SkDirListSource(const char path[], const char suffix[], const char target[])
-		: fPath(path), fSuffix(suffix), fTarget(target)
-	{
-		fCount = -1;
-	}
-	virtual int	countRows()
-	{
-		if (fCount < 0)
-		{
-			fCount = 0;
-			fIter.reset(fPath.c_str(), fSuffix.c_str());
-			while (fIter.next(NULL))
-				fCount += 1;
-			fIter.reset(fPath.c_str(), fSuffix.c_str());
-			fIndex = 0;
-		}
-		return fCount;
-	}
-	virtual void getRow(int index, SkString* left, SkString* right)
-	{
-		(void)this->countRows();
-		SkASSERT((unsigned)index < (unsigned)fCount);
+    SkDirListSource(const char path[], const char suffix[], const char target[])
+        : fPath(path), fSuffix(suffix), fTarget(target)
+    {
+        fCount = -1;
+    }
+    virtual int    countRows()
+    {
+        if (fCount < 0)
+        {
+            fCount = 0;
+            fIter.reset(fPath.c_str(), fSuffix.c_str());
+            while (fIter.next(NULL))
+                fCount += 1;
+            fIter.reset(fPath.c_str(), fSuffix.c_str());
+            fIndex = 0;
+        }
+        return fCount;
+    }
+    virtual void getRow(int index, SkString* left, SkString* right)
+    {
+        (void)this->countRows();
+        SkASSERT((unsigned)index < (unsigned)fCount);
 
-		if (fIndex > index)
-		{
-			fIter.reset(fPath.c_str(), fSuffix.c_str());
-			fIndex = 0;
-		}
+        if (fIndex > index)
+        {
+            fIter.reset(fPath.c_str(), fSuffix.c_str());
+            fIndex = 0;
+        }
 
-		while (fIndex < index)
-		{
-			fIter.next(NULL);
-			fIndex += 1;
-		}
+        while (fIndex < index)
+        {
+            fIter.next(NULL);
+            fIndex += 1;
+        }
 
-		if (fIter.next(left))
-		{
-			if (left)
-				left->remove(left->size() - fSuffix.size(), fSuffix.size());
-		}
-		else
-		{
-			if (left)
-				left->reset();
-		}
-		if (right)	// only set to ">" if we know we're on a sub-directory
-			right->reset();
+        if (fIter.next(left))
+        {
+            if (left)
+                left->remove(left->size() - fSuffix.size(), fSuffix.size());
+        }
+        else
+        {
+            if (left)
+                left->reset();
+        }
+        if (right)    // only set to ">" if we know we're on a sub-directory
+            right->reset();
 
-		fIndex += 1;
-	}
-	virtual SkEvent* getEvent(int index)
-	{
-		SkASSERT((unsigned)index < (unsigned)fCount);
+        fIndex += 1;
+    }
+    virtual SkEvent* getEvent(int index)
+    {
+        SkASSERT((unsigned)index < (unsigned)fCount);
 
-		SkEvent*	evt = new SkEvent();
-		SkString	label;
+        SkEvent*    evt = new SkEvent();
+        SkString    label;
 
-		this->getRow(index, &label, NULL);
-		evt->setString("name", label.c_str());
+        this->getRow(index, &label, NULL);
+        evt->setString("name", label.c_str());
 
-		int c = fPath.c_str()[fPath.size() - 1];
-		if (c != '/' && c != '\\')
-			label.prepend("/");
-		label.prepend(fPath);
-		label.append(fSuffix);
-		evt->setString("path", label.c_str());
-		evt->setS32("index", index);
-		evt->setS32("duration", 22);
-		evt->setType(fTarget);
-		return evt;
-	}
+        int c = fPath.c_str()[fPath.size() - 1];
+        if (c != '/' && c != '\\')
+            label.prepend("/");
+        label.prepend(fPath);
+        label.append(fSuffix);
+        evt->setString("path", label.c_str());
+        evt->setS32("index", index);
+        evt->setS32("duration", 22);
+        evt->setType(fTarget);
+        return evt;
+    }
 
 private:
-	SkString		fPath, fSuffix;
-	SkString		fTarget;
-	SkOSFile::Iter	fIter;
-	int				fCount;
-	int				fIndex;
+    SkString        fPath, fSuffix;
+    SkString        fTarget;
+    SkOSFile::Iter    fIter;
+    int                fCount;
+    int                fIndex;
 };
 
 SkListSource* SkListSource::CreateFromDir(const char path[], const char suffix[], const char target[])
 {
-	return new SkDirListSource(path, suffix, target);
+    return new SkDirListSource(path, suffix, target);
 }
 
 //////////////////////////////////////////////////////////////////
 
 class SkDOMListSource : public SkListSource {
 public:
-	enum Type {
-		kUnknown_Type,
-		kDir_Type,
-		kToggle_Type
-	};
-	struct ItemRec {
-		SkString	fLabel;
-		SkString	fTail, fAltTail;
-		SkString	fTarget;
-		Type		fType;
-	};
+    enum Type {
+        kUnknown_Type,
+        kDir_Type,
+        kToggle_Type
+    };
+    struct ItemRec {
+        SkString    fLabel;
+        SkString    fTail, fAltTail;
+        SkString    fTarget;
+        Type        fType;
+    };
 
-	SkDOMListSource(const SkDOM& dom, const SkDOM::Node* node) : fDirTail(">")
-	{
-		const SkDOM::Node* child = dom.getFirstChild(node, "item");
-		int	count = 0;
+    SkDOMListSource(const SkDOM& dom, const SkDOM::Node* node) : fDirTail(">")
+    {
+        const SkDOM::Node* child = dom.getFirstChild(node, "item");
+        int    count = 0;
 
-		while (child)
-		{
-			count += 1;
-			child = dom.getNextSibling(child, "item");
-		}
+        while (child)
+        {
+            count += 1;
+            child = dom.getNextSibling(child, "item");
+        }
 
-		fCount = count;
-		fList = NULL;
-		if (count)
-		{
-			ItemRec* rec = fList = new ItemRec[count];
+        fCount = count;
+        fList = NULL;
+        if (count)
+        {
+            ItemRec* rec = fList = new ItemRec[count];
 
-			child = dom.getFirstChild(node, "item");
-			while (child)
-			{
-				rec->fLabel.set(dom.findAttr(child, "label"));
-				rec->fTail.set(dom.findAttr(child, "tail"));
-				rec->fAltTail.set(dom.findAttr(child, "alt-tail"));
-				rec->fTarget.set(dom.findAttr(child, "target"));
-				rec->fType = kUnknown_Type;
+            child = dom.getFirstChild(node, "item");
+            while (child)
+            {
+                rec->fLabel.set(dom.findAttr(child, "label"));
+                rec->fTail.set(dom.findAttr(child, "tail"));
+                rec->fAltTail.set(dom.findAttr(child, "alt-tail"));
+                rec->fTarget.set(dom.findAttr(child, "target"));
+                rec->fType = kUnknown_Type;
 
-				int	index = dom.findList(child, "type", "dir,toggle");
-				if (index >= 0)
-					rec->fType = (Type)(index + 1);
+                int    index = dom.findList(child, "type", "dir,toggle");
+                if (index >= 0)
+                    rec->fType = (Type)(index + 1);
 
-				child = dom.getNextSibling(child, "item");
-				rec += 1;
-			}
-		}
-	}
-	virtual ~SkDOMListSource()
-	{
-		delete[] fList;
-	}
-	virtual int	countRows()
-	{
-		return fCount;
-	}
-	virtual void getRow(int index, SkString* left, SkString* right)
-	{
-		SkASSERT((unsigned)index < (unsigned)fCount);
+                child = dom.getNextSibling(child, "item");
+                rec += 1;
+            }
+        }
+    }
+    virtual ~SkDOMListSource()
+    {
+        delete[] fList;
+    }
+    virtual int    countRows()
+    {
+        return fCount;
+    }
+    virtual void getRow(int index, SkString* left, SkString* right)
+    {
+        SkASSERT((unsigned)index < (unsigned)fCount);
 
-		if (left)
-			*left = fList[index].fLabel;
-		if (right)
-			*right = fList[index].fType == kDir_Type ? fDirTail : fList[index].fTail;
-	}
-	virtual SkEvent* getEvent(int index)
-	{
-		SkASSERT((unsigned)index < (unsigned)fCount);
+        if (left)
+            *left = fList[index].fLabel;
+        if (right)
+            *right = fList[index].fType == kDir_Type ? fDirTail : fList[index].fTail;
+    }
+    virtual SkEvent* getEvent(int index)
+    {
+        SkASSERT((unsigned)index < (unsigned)fCount);
 
-		if (fList[index].fType == kDir_Type)
-		{
-			SkEvent* evt = new SkEvent();
-			evt->setType(fList[index].fTarget);
-			evt->setFast32(index);
-			return evt;
-		}
-		if (fList[index].fType == kToggle_Type)
-			fList[index].fTail.swap(fList[index].fAltTail);
+        if (fList[index].fType == kDir_Type)
+        {
+            SkEvent* evt = new SkEvent();
+            evt->setType(fList[index].fTarget);
+            evt->setFast32(index);
+            return evt;
+        }
+        if (fList[index].fType == kToggle_Type)
+            fList[index].fTail.swap(fList[index].fAltTail);
 
-		return NULL;
-	}
+        return NULL;
+    }
 
 private:
-	int			fCount;
-	ItemRec*	fList;
-	SkString	fDirTail;
+    int            fCount;
+    ItemRec*    fList;
+    SkString    fDirTail;
 };
 
 SkListSource* SkListSource::CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node)
 {
-	return new SkDOMListSource(dom, node);
+    return new SkDOMListSource(dom, node);
 }
 
 //////////////////////////////////////////////////////////////////
@@ -209,304 +209,304 @@
 
 SkListView::SkListView(U32 flags) : SkWidgetView(flags)
 {
-	fSource = NULL;
-	fScrollIndex = 0;
-	fCurrIndex = -1;
-	fRowHeight = SkIntToScalar(16);
-	fVisibleRowCount = 0;
-	fStrCache = NULL;
+    fSource = NULL;
+    fScrollIndex = 0;
+    fCurrIndex = -1;
+    fRowHeight = SkIntToScalar(16);
+    fVisibleRowCount = 0;
+    fStrCache = NULL;
 
-	fPaint[kBG_Attr].setColor(0);
-	fPaint[kNormalText_Attr].setTextSize(SkIntToScalar(14));
-	fPaint[kHiliteText_Attr].setTextSize(SkIntToScalar(14));
-	fPaint[kHiliteText_Attr].setColor(SK_ColorWHITE);
-	fPaint[kHiliteCell_Attr].setColor(SK_ColorBLUE);
+    fPaint[kBG_Attr].setColor(0);
+    fPaint[kNormalText_Attr].setTextSize(SkIntToScalar(14));
+    fPaint[kHiliteText_Attr].setTextSize(SkIntToScalar(14));
+    fPaint[kHiliteText_Attr].setColor(SK_ColorWHITE);
+    fPaint[kHiliteCell_Attr].setColor(SK_ColorBLUE);
 }
 
 SkListView::~SkListView()
 {
-	delete[] fStrCache;
-	fSource->safeUnref();
+    delete[] fStrCache;
+    fSource->safeUnref();
 }
 
 void SkListView::setRowHeight(SkScalar height)
 {
-	SkASSERT(height >= 0);
+    SkASSERT(height >= 0);
 
-	if (fRowHeight != height)
-	{
-		fRowHeight = height;
-		this->inval(NULL);
-		this->onSizeChange();
-	}
+    if (fRowHeight != height)
+    {
+        fRowHeight = height;
+        this->inval(NULL);
+        this->onSizeChange();
+    }
 }
 
 void SkListView::setSelection(int index)
 {
-	if (fCurrIndex != index)
-	{
-		this->invalSelection();
-		fCurrIndex = index;
-		this->invalSelection();
-		this->ensureSelectionIsVisible();
+    if (fCurrIndex != index)
+    {
+        this->invalSelection();
+        fCurrIndex = index;
+        this->invalSelection();
+        this->ensureSelectionIsVisible();
 
-		{
-			SkEvent	evt;
-			evt.setType("listview-selection");
-			evt.setFast32(index);
-			this->sendEventToParents(evt);
-		}
-	}
+        {
+            SkEvent    evt;
+            evt.setType("listview-selection");
+            evt.setFast32(index);
+            this->sendEventToParents(evt);
+        }
+    }
 }
 
 void SkListView::moveSelectionUp()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = fSource->countRows() - 1;
-		else
-			index = SkMax32(index - 1, 0);
-		this->setSelection(index);
-	}
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = fSource->countRows() - 1;
+        else
+            index = SkMax32(index - 1, 0);
+        this->setSelection(index);
+    }
 }
 
 void SkListView::moveSelectionDown()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = 0;
-		else
-			index = SkMin32(index + 1, fSource->countRows() - 1);
-		this->setSelection(index);
-	}
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = 0;
+        else
+            index = SkMin32(index + 1, fSource->countRows() - 1);
+        this->setSelection(index);
+    }
 }
 
 void SkListView::invalSelection()
 {
-	SkRect	r;
-	if (this->getRowRect(fCurrIndex, &r))
-		this->inval(&r);
+    SkRect    r;
+    if (this->getRowRect(fCurrIndex, &r))
+        this->inval(&r);
 }
 
 void SkListView::ensureSelectionIsVisible()
 {
-	if (fSource == NULL)
-		return;
+    if (fSource == NULL)
+        return;
 
-	if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
-	{
-		int index = this->logicalToVisualIndex(fCurrIndex);
+    if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
+    {
+        int index = this->logicalToVisualIndex(fCurrIndex);
 
-		if ((unsigned)index >= (unsigned)fVisibleRowCount)	// need to scroll
-		{
-			if (index < 0)	// too high
-				fScrollIndex = fCurrIndex;
-			else
-				fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
-			SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
+        if ((unsigned)index >= (unsigned)fVisibleRowCount)    // need to scroll
+        {
+            if (index < 0)    // too high
+                fScrollIndex = fCurrIndex;
+            else
+                fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
+            SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
 
-			this->dirtyStrCache();
-			this->inval(NULL);
-		}
-	}
+            this->dirtyStrCache();
+            this->inval(NULL);
+        }
+    }
 }
 
 bool SkListView::getRowRect(int index, SkRect* r) const
 {
-	SkASSERT(r);
-	index = this->logicalToVisualIndex(index);
-	if (index >= 0)
-	{
-		SkScalar top = index * fRowHeight;
+    SkASSERT(r);
+    index = this->logicalToVisualIndex(index);
+    if (index >= 0)
+    {
+        SkScalar top = index * fRowHeight;
 
-		if (top < this->height())
-		{
-			if (r)
-				r->set(0, top, this->width(), top + fRowHeight);
-			return true;
-		}
-	}
-	return false;
+        if (top < this->height())
+        {
+            if (r)
+                r->set(0, top, this->width(), top + fRowHeight);
+            return true;
+        }
+    }
+    return false;
 }
 
 SkPaint& SkListView::paint(Attr attr)
 {
-	SkASSERT((unsigned)attr < kAttrCount);
-	return fPaint[attr];
+    SkASSERT((unsigned)attr < kAttrCount);
+    return fPaint[attr];
 }
 
 SkListSource* SkListView::setListSource(SkListSource* src)
 {
-	if (fSource != src)
-	{
-		SkRefCnt_SafeAssign(fSource, src);
-		this->dirtyStrCache();
-		this->ensureSelectionIsVisible();
-		this->inval(NULL);
-	}
-	return src;
+    if (fSource != src)
+    {
+        SkRefCnt_SafeAssign(fSource, src);
+        this->dirtyStrCache();
+        this->ensureSelectionIsVisible();
+        this->inval(NULL);
+    }
+    return src;
 }
 
 void SkListView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	canvas->drawPaint(fPaint[kBG_Attr]);
+    canvas->drawPaint(fPaint[kBG_Attr]);
 
-	int	visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
-	if (visibleCount == 0)
-		return;
+    int    visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
+    if (visibleCount == 0)
+        return;
 
-	this->ensureStrCache(visibleCount);
-	int currIndex = this->logicalToVisualIndex(fCurrIndex);
+    this->ensureStrCache(visibleCount);
+    int currIndex = this->logicalToVisualIndex(fCurrIndex);
 
-	if ((unsigned)currIndex < (unsigned)visibleCount)
-	{
-		SkAutoCanvasRestore	restore(canvas, true);
-		SkRect	r;
+    if ((unsigned)currIndex < (unsigned)visibleCount)
+    {
+        SkAutoCanvasRestore    restore(canvas, true);
+        SkRect    r;
 
-		canvas->translate(0, currIndex * fRowHeight);
-		(void)this->getRowRect(fScrollIndex, &r);
-		canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
-	}
+        canvas->translate(0, currIndex * fRowHeight);
+        (void)this->getRowRect(fScrollIndex, &r);
+        canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
+    }
 
-	SkPaint*	p;
-	SkScalar	y, x = SkIntToScalar(6);
-	SkScalar	rite = this->width() - x;
+    SkPaint*    p;
+    SkScalar    y, x = SkIntToScalar(6);
+    SkScalar    rite = this->width() - x;
 
-	{
-		SkScalar ascent, descent;
-		fPaint[kNormalText_Attr].measureText(0, NULL, &ascent, &descent);
-		y = SkScalarHalf(fRowHeight - descent + ascent) - ascent;
-	}
+    {
+        SkScalar ascent, descent;
+        fPaint[kNormalText_Attr].measureText(0, NULL, &ascent, &descent);
+        y = SkScalarHalf(fRowHeight - descent + ascent) - ascent;
+    }
 
-	for (int i = 0; i < visibleCount; i++)
-	{
-		if (i == currIndex)
-			p = &fPaint[kHiliteText_Attr];
-		else
-			p = &fPaint[kNormalText_Attr];
+    for (int i = 0; i < visibleCount; i++)
+    {
+        if (i == currIndex)
+            p = &fPaint[kHiliteText_Attr];
+        else
+            p = &fPaint[kNormalText_Attr];
 
-		p->setTextAlign(SkPaint::kLeft_Align);
-		canvas->drawText(fStrCache[i].c_str(), fStrCache[i].size(), x, y, *p);
-		p->setTextAlign(SkPaint::kRight_Align);
-		canvas->drawText(fStrCache[i + visibleCount].c_str(), fStrCache[i + visibleCount].size(), rite, y, *p);
-		canvas->translate(0, fRowHeight);
-	}
+        p->setTextAlign(SkPaint::kLeft_Align);
+        canvas->drawText(fStrCache[i].c_str(), fStrCache[i].size(), x, y, *p);
+        p->setTextAlign(SkPaint::kRight_Align);
+        canvas->drawText(fStrCache[i + visibleCount].c_str(), fStrCache[i + visibleCount].size(), rite, y, *p);
+        canvas->translate(0, fRowHeight);
+    }
 }
 
 void SkListView::onSizeChange()
 {
-	SkScalar count = SkScalarDiv(this->height(), fRowHeight);
-	int		 n = SkScalarFloor(count);
+    SkScalar count = SkScalarDiv(this->height(), fRowHeight);
+    int         n = SkScalarFloor(count);
 
-	// only want to show rows that are mostly visible
-	if (n == 0 || count - SkIntToScalar(n) > SK_Scalar1*75/100)
-		n += 1;
+    // only want to show rows that are mostly visible
+    if (n == 0 || count - SkIntToScalar(n) > SK_Scalar1*75/100)
+        n += 1;
 
-	if (fVisibleRowCount != n)
-	{
-		fVisibleRowCount = n;
-		this->ensureSelectionIsVisible();
-		this->dirtyStrCache();
-	}
+    if (fVisibleRowCount != n)
+    {
+        fVisibleRowCount = n;
+        this->ensureSelectionIsVisible();
+        this->dirtyStrCache();
+    }
 }
 
 void SkListView::dirtyStrCache()
 {
-	if (fStrCache)
-	{
-		delete[] fStrCache;
-		fStrCache = NULL;
-	}
+    if (fStrCache)
+    {
+        delete[] fStrCache;
+        fStrCache = NULL;
+    }
 }
 
 void SkListView::ensureStrCache(int count)
 {
-	if (fStrCache == NULL)
-	{
-		fStrCache = new SkString[count << 1];
+    if (fStrCache == NULL)
+    {
+        fStrCache = new SkString[count << 1];
 
-		if (fSource)
-			for (int i = 0; i < count; i++)
-				fSource->getRow(i + fScrollIndex, &fStrCache[i], &fStrCache[i + count]);
-	}
+        if (fSource)
+            for (int i = 0; i < count; i++)
+                fSource->getRow(i + fScrollIndex, &fStrCache[i], &fStrCache[i + count]);
+    }
 }
 
 bool SkListView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Key))
-	{
-		switch (evt.getFast32()) {
-		case kUp_SkKey:
-			this->moveSelectionUp();
-			return true;
-		case kDown_SkKey:
-			this->moveSelectionDown();
-			return true;
-		case kRight_SkKey:
-		case kOK_SkKey:
-			if (fSource && fCurrIndex >= 0)
-			{
-				SkEvent* evt = fSource->getEvent(fCurrIndex);
-				if (evt)
-				{
-					SkView* view = this->sendEventToParents(*evt);
-					delete evt;
-					return view != NULL;
-				}
-				else	// hack to make toggle work
-				{
-					this->dirtyStrCache();
-					this->inval(NULL);
-				}
-			}
-			break;
-		}
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Key))
+    {
+        switch (evt.getFast32()) {
+        case kUp_SkKey:
+            this->moveSelectionUp();
+            return true;
+        case kDown_SkKey:
+            this->moveSelectionDown();
+            return true;
+        case kRight_SkKey:
+        case kOK_SkKey:
+            if (fSource && fCurrIndex >= 0)
+            {
+                SkEvent* evt = fSource->getEvent(fCurrIndex);
+                if (evt)
+                {
+                    SkView* view = this->sendEventToParents(*evt);
+                    delete evt;
+                    return view != NULL;
+                }
+                else    // hack to make toggle work
+                {
+                    this->dirtyStrCache();
+                    this->inval(NULL);
+                }
+            }
+            break;
+        }
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	SkScalar			x;
-	const SkDOM::Node*	child;
+    SkScalar            x;
+    const SkDOM::Node*    child;
 
-	if (dom.findScalar(node, "row-height", &x))
-		this->setRowHeight(x);
+    if (dom.findScalar(node, "row-height", &x))
+        this->setRowHeight(x);
 
-	if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
-		SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
+    if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
+        SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
 
-	// look for a listsource
-	{
-		SkListSource* src = NULL;
+    // look for a listsource
+    {
+        SkListSource* src = NULL;
 
-		if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
-		{
-			const char* path = dom.findAttr(child, "path");
-			if (path)
-				src = SkListSource::CreateFromDir(	path,
-													dom.findAttr(child, "filter"),
-													dom.findAttr(child, "target"));
-		}
-		else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
-		{
-			src = SkListSource::CreateFromDOM(dom, child);
-		}
+        if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
+        {
+            const char* path = dom.findAttr(child, "path");
+            if (path)
+                src = SkListSource::CreateFromDir(    path,
+                                                    dom.findAttr(child, "filter"),
+                                                    dom.findAttr(child, "target"));
+        }
+        else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
+        {
+            src = SkListSource::CreateFromDOM(dom, child);
+        }
 
-		if (src)
-		{
-			this->setListSource(src)->unref();
-			this->setSelection(0);
-		}
-	}
+        if (src)
+        {
+            this->setListSource(src)->unref();
+            this->setSelection(0);
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -517,386 +517,386 @@
 
 class SkScrollBarView : public SkView {
 public:
-	SkScrollBarView(const char bg[], const char fg[])
-	{
-		fBGRef = SkBitmapRef::Decode(bg, true);
-		fFGRef = SkBitmapRef::Decode(fg, true);
+    SkScrollBarView(const char bg[], const char fg[])
+    {
+        fBGRef = SkBitmapRef::Decode(bg, true);
+        fFGRef = SkBitmapRef::Decode(fg, true);
 
-		if (fBGRef)
-			this->setWidth(SkIntToScalar(fBGRef->bitmap().width()));
-	}
-	~SkScrollBarView()
-	{
-		delete fBGRef;
-		delete fFGRef;
-	}
+        if (fBGRef)
+            this->setWidth(SkIntToScalar(fBGRef->bitmap().width()));
+    }
+    ~SkScrollBarView()
+    {
+        delete fBGRef;
+        delete fFGRef;
+    }
 protected:
-	virtual void onDraw(SkCanvas* canvas)
-	{
-		if (fBGRef == NULL) return;
+    virtual void onDraw(SkCanvas* canvas)
+    {
+        if (fBGRef == NULL) return;
 
-		SkPaint	paint;
+        SkPaint    paint;
 
-		SkShader* shader = SkShader::CreateBitmapShader(fBGRef->bitmap(), false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
-		paint.setShader(shader)->unref();
+        SkShader* shader = SkShader::CreateBitmapShader(fBGRef->bitmap(), false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
+        paint.setShader(shader)->unref();
 
-		canvas->drawPaint(paint);
-	}
+        canvas->drawPaint(paint);
+    }
 private:
-	SkBitmapRef*	fBGRef, *fFGRef;
+    SkBitmapRef*    fBGRef, *fFGRef;
 };
 
 SkGridView::SkGridView(U32 flags) : SkWidgetView(flags)
 {
-	fSource = NULL;
-	fCurrIndex = -1;
-	fVisibleCount.set(0, 0);
+    fSource = NULL;
+    fCurrIndex = -1;
+    fVisibleCount.set(0, 0);
 
-	fPaint[kBG_Attr].setColor(SK_ColorWHITE);
-	fPaint[kHiliteCell_Attr].setColor(SK_ColorYELLOW);
-	fPaint[kHiliteCell_Attr].setStyle(SkPaint::kStroke_Style);
-	fPaint[kHiliteCell_Attr].setAntiAliasOn(true);
-	fPaint[kHiliteCell_Attr].setStrokeWidth(SK_Scalar1*3);
+    fPaint[kBG_Attr].setColor(SK_ColorWHITE);
+    fPaint[kHiliteCell_Attr].setColor(SK_ColorYELLOW);
+    fPaint[kHiliteCell_Attr].setStyle(SkPaint::kStroke_Style);
+    fPaint[kHiliteCell_Attr].setAntiAliasOn(true);
+    fPaint[kHiliteCell_Attr].setStrokeWidth(SK_Scalar1*3);
 
-	fScrollBar = new SkScrollBarView("icons/scrollbarGrey.jpg", "icons/scrollbarBlue.jpg");
-	this->attachChildToFront(fScrollBar)->unref();
-	fScrollBar->setVisibleP(true);
+    fScrollBar = new SkScrollBarView("icons/scrollbarGrey.jpg", "icons/scrollbarBlue.jpg");
+    this->attachChildToFront(fScrollBar)->unref();
+    fScrollBar->setVisibleP(true);
 }
 
 SkGridView::~SkGridView()
 {
-	fSource->safeUnref();
+    fSource->safeUnref();
 }
 
 void SkGridView::getCellSize(SkPoint* size) const
 {
-	if (size)
-		*size = fCellSize;
+    if (size)
+        *size = fCellSize;
 }
 
 void SkGridView::setCellSize(SkScalar x, SkScalar y)
 {
-	SkASSERT(x >= 0 && y >= 0);
+    SkASSERT(x >= 0 && y >= 0);
 
-	if (!fCellSize.equals(x, y))
-	{
-		fCellSize.set(x, y);
-		this->inval(NULL);
-	}
+    if (!fCellSize.equals(x, y))
+    {
+        fCellSize.set(x, y);
+        this->inval(NULL);
+    }
 }
 
 void SkGridView::setSelection(int index)
 {
-	if (fCurrIndex != index)
-	{
-		this->invalSelection();
-		fCurrIndex = index;
-		this->invalSelection();
-		this->ensureSelectionIsVisible();
+    if (fCurrIndex != index)
+    {
+        this->invalSelection();
+        fCurrIndex = index;
+        this->invalSelection();
+        this->ensureSelectionIsVisible();
 
-		// this generates the click
-		{
-			SkEvent	evt;
-			evt.setType("listview-selection");
-			evt.setFast32(index);
-			this->sendEventToParents(evt);
-		}
-	}
+        // this generates the click
+        {
+            SkEvent    evt;
+            evt.setType("listview-selection");
+            evt.setFast32(index);
+            this->sendEventToParents(evt);
+        }
+    }
 }
 
 void SkGridView::moveSelectionUp()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = fSource->countRows() - 1;
-		else
-			index = SkMax32(index - 1, 0);
-		this->setSelection(index);
-	}
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = fSource->countRows() - 1;
+        else
+            index = SkMax32(index - 1, 0);
+        this->setSelection(index);
+    }
 }
 
 void SkGridView::moveSelectionDown()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = 0;
-		else
-			index = SkMin32(index + 1, fSource->countRows() - 1);
-		this->setSelection(index);
-	}
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = 0;
+        else
+            index = SkMin32(index + 1, fSource->countRows() - 1);
+        this->setSelection(index);
+    }
 }
 
 void SkGridView::invalSelection()
 {
-	SkRect	r;
-	if (this->getCellRect(fCurrIndex, &r))
-	{
-		SkScalar inset = 0;
-		if (fPaint[kHiliteCell_Attr].getStyle() != SkPaint::kFill_Style)
-			inset += fPaint[kHiliteCell_Attr].getStrokeWidth() / 2;
-		if (fPaint[kHiliteCell_Attr].isAntiAliasOn())
-			inset += SK_Scalar1;
-		r.inset(-inset, -inset);
-		this->inval(&r);
-	}
+    SkRect    r;
+    if (this->getCellRect(fCurrIndex, &r))
+    {
+        SkScalar inset = 0;
+        if (fPaint[kHiliteCell_Attr].getStyle() != SkPaint::kFill_Style)
+            inset += fPaint[kHiliteCell_Attr].getStrokeWidth() / 2;
+        if (fPaint[kHiliteCell_Attr].isAntiAliasOn())
+            inset += SK_Scalar1;
+        r.inset(-inset, -inset);
+        this->inval(&r);
+    }
 }
 
 void SkGridView::ensureSelectionIsVisible()
 {
-	if (fSource == NULL)
-		return;
+    if (fSource == NULL)
+        return;
 #if 0
-	if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
-	{
-		int index = this->logicalToVisualIndex(fCurrIndex);
+    if ((unsigned)fCurrIndex < (unsigned)fSource->countRows())
+    {
+        int index = this->logicalToVisualIndex(fCurrIndex);
 
-		if ((unsigned)index >= (unsigned)fVisibleRowCount)	// need to scroll
-		{
-			if (index < 0)	// too high
-				fScrollIndex = fCurrIndex;
-			else
-				fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
-			SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
+        if ((unsigned)index >= (unsigned)fVisibleRowCount)    // need to scroll
+        {
+            if (index < 0)    // too high
+                fScrollIndex = fCurrIndex;
+            else
+                fScrollIndex = fCurrIndex - fVisibleRowCount + 1;
+            SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows());
 
-			this->dirtyStrCache();
-			this->inval(NULL);
-		}
-	}
+            this->dirtyStrCache();
+            this->inval(NULL);
+        }
+    }
 #endif
 }
 
 bool SkGridView::getCellRect(int index, SkRect* r) const
 {
-	if (fVisibleCount.fY == 0)
-		return false;
+    if (fVisibleCount.fY == 0)
+        return false;
 
-	index = this->logicalToVisualIndex(index);
-	if (index >= 0)
-	{
-		SkRect	bounds;
-		int row = index / fVisibleCount.fY;
-		int col = index % fVisibleCount.fY;
+    index = this->logicalToVisualIndex(index);
+    if (index >= 0)
+    {
+        SkRect    bounds;
+        int row = index / fVisibleCount.fY;
+        int col = index % fVisibleCount.fY;
 
-		bounds.set(0, 0, fCellSize.fX, fCellSize.fY);
-		bounds.offset(col * (fCellSize.fX + SkIntToScalar(col > 0)),
-					  row * (fCellSize.fY + SkIntToScalar(row > 0)));
+        bounds.set(0, 0, fCellSize.fX, fCellSize.fY);
+        bounds.offset(col * (fCellSize.fX + SkIntToScalar(col > 0)),
+                      row * (fCellSize.fY + SkIntToScalar(row > 0)));
 
-		if (bounds.fTop < this->height())
-		{
-			if (r)
-				*r = bounds;
-			return true;
-		}
-	}
-	return false;
+        if (bounds.fTop < this->height())
+        {
+            if (r)
+                *r = bounds;
+            return true;
+        }
+    }
+    return false;
 }
 
 SkPaint& SkGridView::paint(Attr attr)
 {
-	SkASSERT((unsigned)attr < kAttrCount);
-	return fPaint[attr];
+    SkASSERT((unsigned)attr < kAttrCount);
+    return fPaint[attr];
 }
 
 SkListSource* SkGridView::setListSource(SkListSource* src)
 {
-	if (fSource != src)
-	{
-		SkRefCnt_SafeAssign(fSource, src);
-	//	this->dirtyStrCache();
-		this->ensureSelectionIsVisible();
-		this->inval(NULL);
-	}
-	return src;
+    if (fSource != src)
+    {
+        SkRefCnt_SafeAssign(fSource, src);
+    //    this->dirtyStrCache();
+        this->ensureSelectionIsVisible();
+        this->inval(NULL);
+    }
+    return src;
 }
 
 #include "SkShader.h"
 
 static void copybits(SkCanvas* canvas, const SkBitmap& bm, const SkRect& dst, const SkPaint& paint)
 {
-	SkRect		src;
-	SkMatrix	matrix;
+    SkRect        src;
+    SkMatrix    matrix;
 
-	src.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()));
-	if (matrix.setRectToRect(src, dst))
-	{
-		SkPaint	  p(paint);
-		SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
-		p.setShader(shader)->unref();
+    src.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()));
+    if (matrix.setRectToRect(src, dst))
+    {
+        SkPaint      p(paint);
+        SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
+        p.setShader(shader)->unref();
 
-		shader->setLocalMatrix(matrix);
-		canvas->drawRect(dst, p);
-	}
+        shader->setLocalMatrix(matrix);
+        canvas->drawRect(dst, p);
+    }
 }
 
 #include "SkImageDecoder.h"
 
 void SkGridView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	canvas->drawPaint(fPaint[kBG_Attr]);
+    canvas->drawPaint(fPaint[kBG_Attr]);
 
-	if (fSource == NULL)
-		return;
+    if (fSource == NULL)
+        return;
 
 #if 0
-	int	visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
-	if (visibleCount == 0)
-		return;
+    int    visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
+    if (visibleCount == 0)
+        return;
 
-	this->ensureStrCache(visibleCount);
-	int currIndex = this->logicalToVisualIndex(fCurrIndex);
+    this->ensureStrCache(visibleCount);
+    int currIndex = this->logicalToVisualIndex(fCurrIndex);
 #endif
 
-	SkPaint	p;
-	for (int i = 0; i < fSource->countRows(); i++)
-	{
-		bool	 forced = false;
-		SkEvent* evt = fSource->getEvent(i);
-		SkASSERT(evt);
-		SkString path(evt->findString("path"));
-		delete evt;
+    SkPaint    p;
+    for (int i = 0; i < fSource->countRows(); i++)
+    {
+        bool     forced = false;
+        SkEvent* evt = fSource->getEvent(i);
+        SkASSERT(evt);
+        SkString path(evt->findString("path"));
+        delete evt;
 
-		SkBitmapRef* bmr = SkBitmapRef::Decode(path.c_str(), false);
-		if (bmr == NULL)
-		{
-			bmr = SkBitmapRef::Decode(path.c_str(), true);
-			if (bmr)
-				forced = true;
-		}
+        SkBitmapRef* bmr = SkBitmapRef::Decode(path.c_str(), false);
+        if (bmr == NULL)
+        {
+            bmr = SkBitmapRef::Decode(path.c_str(), true);
+            if (bmr)
+                forced = true;
+        }
 
-		if (bmr)
-		{
-			SkAutoTDelete<SkBitmapRef>	autoRef(bmr);
-			SkRect	r;
-			if (!this->getCellRect(i, &r))
-				break;
-			copybits(canvas, bmr->bitmap(), r, p);
-		}
-		// only draw one forced bitmap at a time
-		if (forced)
-		{
-			this->inval(NULL);	// could inval only the remaining visible cells...
-			break;
-		}
-	}
+        if (bmr)
+        {
+            SkAutoTDelete<SkBitmapRef>    autoRef(bmr);
+            SkRect    r;
+            if (!this->getCellRect(i, &r))
+                break;
+            copybits(canvas, bmr->bitmap(), r, p);
+        }
+        // only draw one forced bitmap at a time
+        if (forced)
+        {
+            this->inval(NULL);    // could inval only the remaining visible cells...
+            break;
+        }
+    }
 
-	// draw the hilite
-	{
-		SkRect	r;
-		if (fCurrIndex >= 0 && this->getCellRect(fCurrIndex, &r))
-			canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
-	}
+    // draw the hilite
+    {
+        SkRect    r;
+        if (fCurrIndex >= 0 && this->getCellRect(fCurrIndex, &r))
+            canvas->drawRect(r, fPaint[kHiliteCell_Attr]);
+    }
 }
 
 static int check_count(int n, SkScalar s)
 {
-	// only want to show cells that are mostly visible
-	if (n == 0 || s - SkIntToScalar(n) > SK_Scalar1*75/100)
-		n += 1;
-	return n;
+    // only want to show cells that are mostly visible
+    if (n == 0 || s - SkIntToScalar(n) > SK_Scalar1*75/100)
+        n += 1;
+    return n;
 }
 
 void SkGridView::onSizeChange()
 {
-	fScrollBar->setHeight(this->height());
-	fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0);
+    fScrollBar->setHeight(this->height());
+    fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0);
 
-	if (fCellSize.equals(0, 0))
-	{
-		fVisibleCount.set(0, 0);
-		return;
-	}
+    if (fCellSize.equals(0, 0))
+    {
+        fVisibleCount.set(0, 0);
+        return;
+    }
 
-	SkScalar rows = SkScalarDiv(this->height(), fCellSize.fY);
-	SkScalar cols = SkScalarDiv(this->width(), fCellSize.fX);
-	int		 y = SkScalarFloor(rows);
-	int		 x = SkScalarFloor(cols);
+    SkScalar rows = SkScalarDiv(this->height(), fCellSize.fY);
+    SkScalar cols = SkScalarDiv(this->width(), fCellSize.fX);
+    int         y = SkScalarFloor(rows);
+    int         x = SkScalarFloor(cols);
 
-	y = check_count(y, rows);
-	x = check_count(x, cols);
+    y = check_count(y, rows);
+    x = check_count(x, cols);
 
-	if (!fVisibleCount.equals(x, y))
-	{
-		fVisibleCount.set(x, y);
-		this->ensureSelectionIsVisible();
-	//	this->dirtyStrCache();
-	}
+    if (!fVisibleCount.equals(x, y))
+    {
+        fVisibleCount.set(x, y);
+        this->ensureSelectionIsVisible();
+    //    this->dirtyStrCache();
+    }
 }
 
 bool SkGridView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Key))
-	{
-		switch (evt.getFast32()) {
-		case kUp_SkKey:
-			this->moveSelectionUp();
-			return true;
-		case kDown_SkKey:
-			this->moveSelectionDown();
-			return true;
-		case kRight_SkKey:
-		case kOK_SkKey:
-			if (fSource && fCurrIndex >= 0)
-			{
-				SkEvent* evt = fSource->getEvent(fCurrIndex);
-				if (evt)
-				{
-					// augment the event with our local rect
-					(void)this->getCellRect(fCurrIndex, (SkRect*)evt->setScalars("local-rect", 4, NULL));
+    if (evt.isType(SK_EventType_Key))
+    {
+        switch (evt.getFast32()) {
+        case kUp_SkKey:
+            this->moveSelectionUp();
+            return true;
+        case kDown_SkKey:
+            this->moveSelectionDown();
+            return true;
+        case kRight_SkKey:
+        case kOK_SkKey:
+            if (fSource && fCurrIndex >= 0)
+            {
+                SkEvent* evt = fSource->getEvent(fCurrIndex);
+                if (evt)
+                {
+                    // augment the event with our local rect
+                    (void)this->getCellRect(fCurrIndex, (SkRect*)evt->setScalars("local-rect", 4, NULL));
 
-					SkView* view = this->sendEventToParents(*evt);
-					delete evt;
-					return view != NULL;
-				}
-			}
-			break;
-		}
-	}
-	return this->INHERITED::onEvent(evt);
+                    SkView* view = this->sendEventToParents(*evt);
+                    delete evt;
+                    return view != NULL;
+                }
+            }
+            break;
+        }
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 void SkGridView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	SkScalar			x[2];
-	const SkDOM::Node*	child;
+    SkScalar            x[2];
+    const SkDOM::Node*    child;
 
-	if (dom.findScalars(node, "cell-size", x, 2))
-		this->setCellSize(x[0], x[1]);
+    if (dom.findScalars(node, "cell-size", x, 2))
+        this->setCellSize(x[0], x[1]);
 
-	if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
-		SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
+    if ((child = dom.getFirstChild(node, "hilite-paint")) != NULL)
+        SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child);
 
-	// look for a listsource
-	{
-		SkListSource* src = NULL;
+    // look for a listsource
+    {
+        SkListSource* src = NULL;
 
-		if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
-		{
-			const char* path = dom.findAttr(child, "path");
-			if (path)
-				src = SkListSource::CreateFromDir(	path,
-													dom.findAttr(child, "filter"),
-													dom.findAttr(child, "target"));
-		}
-		else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
-		{
-			src = SkListSource::CreateFromDOM(dom, child);
-		}
+        if ((child = dom.getFirstChild(node, "file-listsource")) != NULL)
+        {
+            const char* path = dom.findAttr(child, "path");
+            if (path)
+                src = SkListSource::CreateFromDir(    path,
+                                                    dom.findAttr(child, "filter"),
+                                                    dom.findAttr(child, "target"));
+        }
+        else if ((child = dom.getFirstChild(node, "xml-listsource")) != NULL)
+        {
+            src = SkListSource::CreateFromDOM(dom, child);
+        }
 
-		if (src)
-		{
-			this->setListSource(src)->unref();
-			this->setSelection(0);
-		}
-	}
-	this->onSizeChange();
+        if (src)
+        {
+            this->setListSource(src)->unref();
+            this->setSelection(0);
+        }
+    }
+    this->onSizeChange();
 }
 
 #endif
diff --git a/src/views/animated/SkListWidget.cpp b/src/views/animated/SkListWidget.cpp
index 4d95e0f..f91c684 100644
--- a/src/views/animated/SkListWidget.cpp
+++ b/src/views/animated/SkListWidget.cpp
@@ -13,320 +13,320 @@
 extern void init_skin_anim(const char name[], SkAnimator*);
 
 struct SkListView::BindingRec {
-	SkString	fSlotName;
-	int			fFieldIndex;
+    SkString    fSlotName;
+    int            fFieldIndex;
 };
 
 SkListView::SkListView()
 {
-	fSource = NULL;				// our list-source
-	fScrollBar = NULL;
-	fAnims = NULL;				// array of animators[fVisibleRowCount]
-	fBindings = NULL;			// our fields->slot array
-	fBindingCount = 0;			// number of entries in fSlots array
-	fScrollIndex = 0;			// number of cells to skip before first visible cell
-	fCurrIndex = -1;			// index of "selected" cell
-	fVisibleRowCount = 0;		// number of cells that can fit in our bounds
-	fAnimContentDirty = true;	// true if fAnims[] have their correct content
-	fAnimFocusDirty = true;
+    fSource = NULL;                // our list-source
+    fScrollBar = NULL;
+    fAnims = NULL;                // array of animators[fVisibleRowCount]
+    fBindings = NULL;            // our fields->slot array
+    fBindingCount = 0;            // number of entries in fSlots array
+    fScrollIndex = 0;            // number of cells to skip before first visible cell
+    fCurrIndex = -1;            // index of "selected" cell
+    fVisibleRowCount = 0;        // number of cells that can fit in our bounds
+    fAnimContentDirty = true;    // true if fAnims[] have their correct content
+    fAnimFocusDirty = true;
 
-	fHeights[kNormal_Height] = SkIntToScalar(16);
-	fHeights[kSelected_Height] = SkIntToScalar(16);
-	
-	this->setFlags(this->getFlags() | kFocusable_Mask);
+    fHeights[kNormal_Height] = SkIntToScalar(16);
+    fHeights[kSelected_Height] = SkIntToScalar(16);
+
+    this->setFlags(this->getFlags() | kFocusable_Mask);
 }
 
 SkListView::~SkListView()
 {
-	SkSafeUnref(fScrollBar);
-	SkSafeUnref(fSource);
-	delete[] fAnims;
-	delete[] fBindings;
+    SkSafeUnref(fScrollBar);
+    SkSafeUnref(fSource);
+    delete[] fAnims;
+    delete[] fBindings;
 }
 
 void SkListView::setHasScrollBar(bool hasSB)
 {
-	if (hasSB != this->hasScrollBar())
-	{
-		if (hasSB)
-		{
-			SkASSERT(fScrollBar == NULL);
-			fScrollBar = (SkScrollBarView*)SkWidgetFactory(kScroll_WidgetEnum);
-			fScrollBar->setVisibleP(true);
-			this->attachChildToFront(fScrollBar);
-			fScrollBar->setHeight(this->height());	// assume it auto-sets its width
-		//	fScrollBar->setLoc(this->getContentWidth(), 0);
-			fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
-		}
-		else
-		{
-			SkASSERT(fScrollBar);
-			fScrollBar->detachFromParent();
-			fScrollBar->unref();
-			fScrollBar = NULL;
-		}
-		this->dirtyCache(kAnimContent_DirtyFlag);
-	}
+    if (hasSB != this->hasScrollBar())
+    {
+        if (hasSB)
+        {
+            SkASSERT(fScrollBar == NULL);
+            fScrollBar = (SkScrollBarView*)SkWidgetFactory(kScroll_WidgetEnum);
+            fScrollBar->setVisibleP(true);
+            this->attachChildToFront(fScrollBar);
+            fScrollBar->setHeight(this->height());    // assume it auto-sets its width
+        //    fScrollBar->setLoc(this->getContentWidth(), 0);
+            fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
+        }
+        else
+        {
+            SkASSERT(fScrollBar);
+            fScrollBar->detachFromParent();
+            fScrollBar->unref();
+            fScrollBar = NULL;
+        }
+        this->dirtyCache(kAnimContent_DirtyFlag);
+    }
 }
 
 void SkListView::setSelection(int index)
 {
-	if (fCurrIndex != index)
-	{
-		fAnimFocusDirty = true;
-		this->inval(NULL);
+    if (fCurrIndex != index)
+    {
+        fAnimFocusDirty = true;
+        this->inval(NULL);
 
-		this->invalSelection();
-		fCurrIndex = index;
-		this->invalSelection();
-		this->ensureSelectionIsVisible();
-	}
+        this->invalSelection();
+        fCurrIndex = index;
+        this->invalSelection();
+        this->ensureSelectionIsVisible();
+    }
 }
 
 bool SkListView::moveSelectionUp()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = fSource->countRecords() - 1;
-		else
-			index = SkMax32(index - 1, 0);
-		
-		if (fCurrIndex != index)
-		{
-			this->setSelection(index);
-			return true;
-		}
-	}
-	return false;
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = fSource->countRecords() - 1;
+        else
+            index = SkMax32(index - 1, 0);
+
+        if (fCurrIndex != index)
+        {
+            this->setSelection(index);
+            return true;
+        }
+    }
+    return false;
 }
 
 bool SkListView::moveSelectionDown()
 {
-	if (fSource)
-	{
-		int	index = fCurrIndex;
-		if (index < 0)	// no selection
-			index = 0;
-		else
-			index = SkMin32(index + 1, fSource->countRecords() - 1);
-		
-		if (fCurrIndex != index)
-		{
-			this->setSelection(index);
-			return true;
-		}
-	}
-	return false;
+    if (fSource)
+    {
+        int    index = fCurrIndex;
+        if (index < 0)    // no selection
+            index = 0;
+        else
+            index = SkMin32(index + 1, fSource->countRecords() - 1);
+
+        if (fCurrIndex != index)
+        {
+            this->setSelection(index);
+            return true;
+        }
+    }
+    return false;
 }
 
 void SkListView::invalSelection()
 {
-	SkRect	r;
-	if (this->getRowRect(fCurrIndex, &r))
-		this->inval(&r);
+    SkRect    r;
+    if (this->getRowRect(fCurrIndex, &r))
+        this->inval(&r);
 }
 
 void SkListView::ensureSelectionIsVisible()
 {
-	if (fSource && (unsigned)fCurrIndex < (unsigned)fSource->countRecords())
-	{
-		int index = this->logicalToVisualIndex(fCurrIndex);
+    if (fSource && (unsigned)fCurrIndex < (unsigned)fSource->countRecords())
+    {
+        int index = this->logicalToVisualIndex(fCurrIndex);
 
-		if ((unsigned)index >= (unsigned)fVisibleRowCount)	// need to scroll
-		{
-			int newIndex;
-			
-			if (index < 0)	// too high
-				newIndex = fCurrIndex;
-			else
-				newIndex = fCurrIndex - fVisibleRowCount + 1;
-			SkASSERT((unsigned)newIndex < (unsigned)fSource->countRecords());
-			this->inval(NULL);
-			
-			if (fScrollIndex != newIndex)
-			{
-				fScrollIndex = newIndex;
-				if (fScrollBar)
-					fScrollBar->setStart(newIndex);
-				this->dirtyCache(kAnimContent_DirtyFlag);
-			}
-		}
-	}
+        if ((unsigned)index >= (unsigned)fVisibleRowCount)    // need to scroll
+        {
+            int newIndex;
+
+            if (index < 0)    // too high
+                newIndex = fCurrIndex;
+            else
+                newIndex = fCurrIndex - fVisibleRowCount + 1;
+            SkASSERT((unsigned)newIndex < (unsigned)fSource->countRecords());
+            this->inval(NULL);
+
+            if (fScrollIndex != newIndex)
+            {
+                fScrollIndex = newIndex;
+                if (fScrollBar)
+                    fScrollBar->setStart(newIndex);
+                this->dirtyCache(kAnimContent_DirtyFlag);
+            }
+        }
+    }
 }
 
 SkScalar SkListView::getContentWidth() const
 {
-	SkScalar width = this->width();
-	
-	if (fScrollBar)
-	{
-		width -= fScrollBar->width();
-		if (width < 0)
-			width = 0;
-	}
-	return width;
+    SkScalar width = this->width();
+
+    if (fScrollBar)
+    {
+        width -= fScrollBar->width();
+        if (width < 0)
+            width = 0;
+    }
+    return width;
 }
 
 bool SkListView::getRowRect(int index, SkRect* r) const
 {
-	SkASSERT(r);
+    SkASSERT(r);
 
-	index = this->logicalToVisualIndex(index);
-	if (index >= 0)
-	{
-		int	selection = this->logicalToVisualIndex(fCurrIndex);
-		
-		SkScalar height = fHeights[index == selection ? kSelected_Height : kNormal_Height];
-		SkScalar top = index * fHeights[kNormal_Height];
+    index = this->logicalToVisualIndex(index);
+    if (index >= 0)
+    {
+        int    selection = this->logicalToVisualIndex(fCurrIndex);
 
-		if (index > selection && selection >= 0)
-			top += fHeights[kSelected_Height] - fHeights[kNormal_Height];	
+        SkScalar height = fHeights[index == selection ? kSelected_Height : kNormal_Height];
+        SkScalar top = index * fHeights[kNormal_Height];
 
-		if (top < this->height())
-		{
-			if (r)
-				r->set(0, top, this->getContentWidth(), top + height);
-			return true;
-		}
-	}
-	return false;
+        if (index > selection && selection >= 0)
+            top += fHeights[kSelected_Height] - fHeights[kNormal_Height];
+
+        if (top < this->height())
+        {
+            if (r)
+                r->set(0, top, this->getContentWidth(), top + height);
+            return true;
+        }
+    }
+    return false;
 }
 
 SkListSource* SkListView::setListSource(SkListSource* src)
 {
-	if (fSource != src)
-	{
-		SkRefCnt_SafeAssign(fSource, src);
-		this->ensureSelectionIsVisible();
-		this->inval(NULL);
-		
-		if (fScrollBar)
-			fScrollBar->setTotal(fSource->countRecords());
-	}
-	return src;
+    if (fSource != src)
+    {
+        SkRefCnt_SafeAssign(fSource, src);
+        this->ensureSelectionIsVisible();
+        this->inval(NULL);
+
+        if (fScrollBar)
+            fScrollBar->setTotal(fSource->countRecords());
+    }
+    return src;
 }
 
 void SkListView::dirtyCache(unsigned dirtyFlags)
 {
-	if (dirtyFlags & kAnimCount_DirtyFlag)
-	{
-		delete fAnims;
-		fAnims = NULL;
-		fAnimContentDirty = true;
-		fAnimFocusDirty = true;
-	}
-	if (dirtyFlags & kAnimContent_DirtyFlag)
-	{
-		if (!fAnimContentDirty)
-		{
-			this->inval(NULL);
-			fAnimContentDirty = true;
-		}
-		fAnimFocusDirty = true;
-	}
+    if (dirtyFlags & kAnimCount_DirtyFlag)
+    {
+        delete fAnims;
+        fAnims = NULL;
+        fAnimContentDirty = true;
+        fAnimFocusDirty = true;
+    }
+    if (dirtyFlags & kAnimContent_DirtyFlag)
+    {
+        if (!fAnimContentDirty)
+        {
+            this->inval(NULL);
+            fAnimContentDirty = true;
+        }
+        fAnimFocusDirty = true;
+    }
 }
 
 bool SkListView::ensureCache()
 {
-	if (fSkinName.size() == 0)
-		return false;
+    if (fSkinName.size() == 0)
+        return false;
 
-	if (fAnims == NULL)
-	{
-		int n = SkMax32(1, fVisibleRowCount);
+    if (fAnims == NULL)
+    {
+        int n = SkMax32(1, fVisibleRowCount);
 
-		SkASSERT(fAnimContentDirty);
-		fAnims = new SkAnimator[n];
-		for (int i = 0; i < n; i++)
-		{
-			fAnims[i].setHostEventSink(this);
-			init_skin_anim(fSkinName.c_str(), &fAnims[i]);
-		}
-		
-		fHeights[kNormal_Height] = fAnims[0].getScalar("idleHeight", "value");
-		fHeights[kSelected_Height] = fAnims[0].getScalar("focusedHeight", "value");
+        SkASSERT(fAnimContentDirty);
+        fAnims = new SkAnimator[n];
+        for (int i = 0; i < n; i++)
+        {
+            fAnims[i].setHostEventSink(this);
+            init_skin_anim(fSkinName.c_str(), &fAnims[i]);
+        }
 
-		fAnimFocusDirty = true;
-	}
+        fHeights[kNormal_Height] = fAnims[0].getScalar("idleHeight", "value");
+        fHeights[kSelected_Height] = fAnims[0].getScalar("focusedHeight", "value");
 
-	if (fAnimContentDirty && fSource)
-	{
-		fAnimContentDirty = false;
+        fAnimFocusDirty = true;
+    }
 
-		SkString	str;
-		SkEvent		evt("user");
-		evt.setString("id", "setFields");
-		evt.setS32("rowCount", fVisibleRowCount);
-		
-		SkEvent	dimEvt("user");
-		dimEvt.setString("id", "setDim");
-		dimEvt.setScalar("dimX", this->getContentWidth());
-		dimEvt.setScalar("dimY", this->height());
+    if (fAnimContentDirty && fSource)
+    {
+        fAnimContentDirty = false;
 
-		for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
-		{
-			evt.setS32("relativeIndex", i - fScrollIndex);
-			for (int j = 0; j < fBindingCount; j++)
-			{
-				fSource->getRecord(i, fBindings[j].fFieldIndex, &str);
+        SkString    str;
+        SkEvent        evt("user");
+        evt.setString("id", "setFields");
+        evt.setS32("rowCount", fVisibleRowCount);
+
+        SkEvent    dimEvt("user");
+        dimEvt.setString("id", "setDim");
+        dimEvt.setScalar("dimX", this->getContentWidth());
+        dimEvt.setScalar("dimY", this->height());
+
+        for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
+        {
+            evt.setS32("relativeIndex", i - fScrollIndex);
+            for (int j = 0; j < fBindingCount; j++)
+            {
+                fSource->getRecord(i, fBindings[j].fFieldIndex, &str);
 //SkDEBUGF(("getRecord(%d,%d,%s) slot(%s)\n", i, fBindings[j].fFieldIndex, str.c_str(), fBindings[j].fSlotName.c_str()));
-				evt.setString(fBindings[j].fSlotName.c_str(), str.c_str());
-			}
-			(void)fAnims[i % fVisibleRowCount].doUserEvent(evt);
-			(void)fAnims[i % fVisibleRowCount].doUserEvent(dimEvt);
-		}
-		fAnimFocusDirty = true;
-	}
+                evt.setString(fBindings[j].fSlotName.c_str(), str.c_str());
+            }
+            (void)fAnims[i % fVisibleRowCount].doUserEvent(evt);
+            (void)fAnims[i % fVisibleRowCount].doUserEvent(dimEvt);
+        }
+        fAnimFocusDirty = true;
+    }
 
-	if (fAnimFocusDirty)
-	{
+    if (fAnimFocusDirty)
+    {
 //SkDEBUGF(("service fAnimFocusDirty\n"));
-		fAnimFocusDirty = false;
+        fAnimFocusDirty = false;
 
-		SkEvent		focusEvt("user");
-		focusEvt.setString("id", "setFocus");
+        SkEvent        focusEvt("user");
+        focusEvt.setString("id", "setFocus");
 
-		for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
-		{
-			focusEvt.setS32("FOCUS", i == fCurrIndex);
-			(void)fAnims[i % fVisibleRowCount].doUserEvent(focusEvt);
-		}
-	}
+        for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++)
+        {
+            focusEvt.setS32("FOCUS", i == fCurrIndex);
+            (void)fAnims[i % fVisibleRowCount].doUserEvent(focusEvt);
+        }
+    }
 
-	return true;
+    return true;
 }
 
 void SkListView::ensureVisibleRowCount()
 {
-	SkScalar	height = this->height();
-	int			n = 0;
-	
-	if (height > 0)
-	{
-		n = 1;
-		height -= fHeights[kSelected_Height];
-		if (height > 0)
-		{
-			SkScalar count = SkScalarDiv(height, fHeights[kNormal_Height]);
-			n += SkScalarFloor(count);
-			if (count - SkIntToScalar(n) > SK_Scalar1*3/4)
-				n += 1;
-				
-		//	SkDebugf("count %g, n %d\n", count/65536., n);
-		}
-	}
+    SkScalar    height = this->height();
+    int            n = 0;
 
-	if (fVisibleRowCount != n)
-	{
-		if (fScrollBar)
-			fScrollBar->setShown(n);
+    if (height > 0)
+    {
+        n = 1;
+        height -= fHeights[kSelected_Height];
+        if (height > 0)
+        {
+            SkScalar count = SkScalarDiv(height, fHeights[kNormal_Height]);
+            n += SkScalarFloor(count);
+            if (count - SkIntToScalar(n) > SK_Scalar1*3/4)
+                n += 1;
 
-		fVisibleRowCount = n;
-		this->ensureSelectionIsVisible();
-		this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag);
-	}
+        //    SkDebugf("count %g, n %d\n", count/65536., n);
+        }
+    }
+
+    if (fVisibleRowCount != n)
+    {
+        if (fScrollBar)
+            fScrollBar->setShown(n);
+
+        fVisibleRowCount = n;
+        this->ensureSelectionIsVisible();
+        this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -336,76 +336,76 @@
 
 void SkListView::onSizeChange()
 {
-	this->INHERITED::onSizeChange();
+    this->INHERITED::onSizeChange();
 
-	if (fScrollBar)
-		fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
+    if (fScrollBar)
+        fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
 
-	this->ensureVisibleRowCount();
+    this->ensureVisibleRowCount();
 }
 
 void SkListView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	this->ensureVisibleRowCount();
+    this->ensureVisibleRowCount();
 
-	int	visibleCount = SkMin32(fVisibleRowCount, fSource->countRecords() - fScrollIndex);
-	if (visibleCount == 0 || !this->ensureCache())
-		return;
+    int    visibleCount = SkMin32(fVisibleRowCount, fSource->countRecords() - fScrollIndex);
+    if (visibleCount == 0 || !this->ensureCache())
+        return;
 
 //SkDebugf("visibleCount %d scrollIndex %d currIndex %d\n", visibleCount, fScrollIndex, fCurrIndex);
 
-	SkAutoCanvasRestore	ar(canvas, true);
-	SkMSec				now = SkTime::GetMSecs();
-	SkRect				bounds;
+    SkAutoCanvasRestore    ar(canvas, true);
+    SkMSec                now = SkTime::GetMSecs();
+    SkRect                bounds;
 
-	bounds.fLeft	= 0;
-	bounds.fRight	= this->getContentWidth();
-	bounds.fBottom	= 0;
-	// assign bounds.fTop inside the loop
+    bounds.fLeft    = 0;
+    bounds.fRight    = this->getContentWidth();
+    bounds.fBottom    = 0;
+    // assign bounds.fTop inside the loop
 
-	// hack to reveal our bounds for debugging
-	if (this->hasFocus())
-		canvas->drawARGB(0x11, 0, 0, 0xFF);
-	else
-		canvas->drawARGB(0x11, 0x88, 0x88, 0x88);
+    // hack to reveal our bounds for debugging
+    if (this->hasFocus())
+        canvas->drawARGB(0x11, 0, 0, 0xFF);
+    else
+        canvas->drawARGB(0x11, 0x88, 0x88, 0x88);
 
-	for (int i = fScrollIndex; i < fScrollIndex + visibleCount; i++)
-	{
-		SkPaint	 paint;
-		SkScalar height = fHeights[i == fCurrIndex ? kSelected_Height : kNormal_Height];
+    for (int i = fScrollIndex; i < fScrollIndex + visibleCount; i++)
+    {
+        SkPaint     paint;
+        SkScalar height = fHeights[i == fCurrIndex ? kSelected_Height : kNormal_Height];
 
-		bounds.fTop = bounds.fBottom;
-		bounds.fBottom += height;
-		
-		canvas->save();
-		if (fAnims[i % fVisibleRowCount].draw(canvas, &paint, now) != SkAnimator::kNotDifferent)
-			this->inval(&bounds);
-		canvas->restore();
+        bounds.fTop = bounds.fBottom;
+        bounds.fBottom += height;
 
-		canvas->translate(0, height);
-	}
+        canvas->save();
+        if (fAnims[i % fVisibleRowCount].draw(canvas, &paint, now) != SkAnimator::kNotDifferent)
+            this->inval(&bounds);
+        canvas->restore();
+
+        canvas->translate(0, height);
+    }
 }
 
 bool SkListView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Key))
-	{
-		switch (evt.getFast32()) {
-		case kUp_SkKey:
-			return this->moveSelectionUp();
-		case kDown_SkKey:
-			return this->moveSelectionDown();
-		case kRight_SkKey:
-		case kOK_SkKey:
-			this->postWidgetEvent();
-			return true;
-		default:
-			break;
-		}
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Key))
+    {
+        switch (evt.getFast32()) {
+        case kUp_SkKey:
+            return this->moveSelectionUp();
+        case kDown_SkKey:
+            return this->moveSelectionDown();
+        case kRight_SkKey:
+        case kOK_SkKey:
+            this->postWidgetEvent();
+            return true;
+        default:
+            break;
+        }
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -414,78 +414,78 @@
 
 /*virtual*/ bool SkListView::onPrepareWidgetEvent(SkEvent* evt)
 {
-	if (fSource && fCurrIndex >= 0 && this->INHERITED::onPrepareWidgetEvent(evt) &&
-		fSource->prepareWidgetEvent(evt, fCurrIndex))
-	{
-		evt->setS32(gListViewEventSlot, fCurrIndex);
-		return true;
-	}
-	return false;
+    if (fSource && fCurrIndex >= 0 && this->INHERITED::onPrepareWidgetEvent(evt) &&
+        fSource->prepareWidgetEvent(evt, fCurrIndex))
+    {
+        evt->setS32(gListViewEventSlot, fCurrIndex);
+        return true;
+    }
+    return false;
 }
 
 int SkListView::GetWidgetEventListIndex(const SkEvent& evt)
 {
-	int32_t	index;
+    int32_t    index;
 
-	return evt.findS32(gListViewEventSlot, &index) ? index : -1;
+    return evt.findS32(gListViewEventSlot, &index) ? index : -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
-	
-	{
-		bool hasScrollBar;
-		if (dom.findBool(node, "scrollBar", &hasScrollBar))
-			this->setHasScrollBar(hasScrollBar);
-	}
+    this->INHERITED::onInflate(dom, node);
 
-	const SkDOM::Node*	child;
+    {
+        bool hasScrollBar;
+        if (dom.findBool(node, "scrollBar", &hasScrollBar))
+            this->setHasScrollBar(hasScrollBar);
+    }
 
-	if ((child = dom.getFirstChild(node, "bindings")) != NULL)
-	{
-		delete[] fBindings;
-		fBindings = NULL;
-		fBindingCount = 0;
+    const SkDOM::Node*    child;
 
-		SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields"));
-		SkASSERT(listSrc);
-		fSkinName.set(dom.findAttr(child, "skin-slots"));
-		SkASSERT(fSkinName.size());
+    if ((child = dom.getFirstChild(node, "bindings")) != NULL)
+    {
+        delete[] fBindings;
+        fBindings = NULL;
+        fBindingCount = 0;
 
-		this->setListSource(listSrc)->unref();
-			
-		int count = dom.countChildren(child, "bind");
-		if (count > 0)
-		{
-			fBindings = new BindingRec[count];
-			count = 0;	// reuse this to count up to the number of valid bindings
+        SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields"));
+        SkASSERT(listSrc);
+        fSkinName.set(dom.findAttr(child, "skin-slots"));
+        SkASSERT(fSkinName.size());
 
-			child = dom.getFirstChild(child, "bind");
-			SkASSERT(child);
-			do {
-				const char* fieldName = dom.findAttr(child, "field");
-				const char* slotName = dom.findAttr(child, "slot");
-				if (fieldName && slotName)
-				{
-					fBindings[count].fFieldIndex = listSrc->findFieldIndex(fieldName);
-					if (fBindings[count].fFieldIndex >= 0)
-						fBindings[count++].fSlotName.set(slotName);
-				}
-			} while ((child = dom.getNextSibling(child, "bind")) != NULL);
+        this->setListSource(listSrc)->unref();
 
-			fBindingCount = SkToU16(count);
-			if (count == 0)
-			{
-				SkDEBUGF(("SkListView::onInflate: no valid <bind> elements in <listsource>\n"));
-				delete[] fBindings;
-			}
-		}
-		this->dirtyCache(kAnimCount_DirtyFlag);
-		this->setSelection(0);
-	}
+        int count = dom.countChildren(child, "bind");
+        if (count > 0)
+        {
+            fBindings = new BindingRec[count];
+            count = 0;    // reuse this to count up to the number of valid bindings
+
+            child = dom.getFirstChild(child, "bind");
+            SkASSERT(child);
+            do {
+                const char* fieldName = dom.findAttr(child, "field");
+                const char* slotName = dom.findAttr(child, "slot");
+                if (fieldName && slotName)
+                {
+                    fBindings[count].fFieldIndex = listSrc->findFieldIndex(fieldName);
+                    if (fBindings[count].fFieldIndex >= 0)
+                        fBindings[count++].fSlotName.set(slotName);
+                }
+            } while ((child = dom.getNextSibling(child, "bind")) != NULL);
+
+            fBindingCount = SkToU16(count);
+            if (count == 0)
+            {
+                SkDEBUGF(("SkListView::onInflate: no valid <bind> elements in <listsource>\n"));
+                delete[] fBindings;
+            }
+        }
+        this->dirtyCache(kAnimCount_DirtyFlag);
+        this->setSelection(0);
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -493,137 +493,137 @@
 
 class SkXMLListSource : public SkListSource {
 public:
-	SkXMLListSource(const char doc[], size_t len);
-	virtual ~SkXMLListSource()
-	{
-		delete[] fFields;
-		delete[] fRecords;
-	}
+    SkXMLListSource(const char doc[], size_t len);
+    virtual ~SkXMLListSource()
+    {
+        delete[] fFields;
+        delete[] fRecords;
+    }
 
-	virtual int countFields() { return fFieldCount; }
-	virtual void getFieldName(int index, SkString* field)
-	{
-		SkASSERT((unsigned)index < (unsigned)fFieldCount);
-		if (field)
-			*field = fFields[index];
-	}
-	virtual int findFieldIndex(const char field[])
-	{
-		for (int i = 0; i < fFieldCount; i++)
-			if (fFields[i].equals(field))
-				return i;
-		return -1;
-	}
+    virtual int countFields() { return fFieldCount; }
+    virtual void getFieldName(int index, SkString* field)
+    {
+        SkASSERT((unsigned)index < (unsigned)fFieldCount);
+        if (field)
+            *field = fFields[index];
+    }
+    virtual int findFieldIndex(const char field[])
+    {
+        for (int i = 0; i < fFieldCount; i++)
+            if (fFields[i].equals(field))
+                return i;
+        return -1;
+    }
 
-	virtual int	countRecords() { return fRecordCount; }
-	virtual void getRecord(int rowIndex, int fieldIndex, SkString* data)
-	{
-		SkASSERT((unsigned)rowIndex < (unsigned)fRecordCount);
-		SkASSERT((unsigned)fieldIndex < (unsigned)fFieldCount);
-		if (data)
-			*data = fRecords[rowIndex * fFieldCount + fieldIndex];
-	}
+    virtual int    countRecords() { return fRecordCount; }
+    virtual void getRecord(int rowIndex, int fieldIndex, SkString* data)
+    {
+        SkASSERT((unsigned)rowIndex < (unsigned)fRecordCount);
+        SkASSERT((unsigned)fieldIndex < (unsigned)fFieldCount);
+        if (data)
+            *data = fRecords[rowIndex * fFieldCount + fieldIndex];
+    }
 
-	virtual bool prepareWidgetEvent(SkEvent* evt, int rowIndex)
-	{
-		// hack, for testing right now. Need the xml to tell us what to jam in and where
-		SkString	data;
-		
-		this->getRecord(rowIndex, 0, &data);
-		evt->setString("xml-listsource", data.c_str());
-		return true;
-	}
-	
+    virtual bool prepareWidgetEvent(SkEvent* evt, int rowIndex)
+    {
+        // hack, for testing right now. Need the xml to tell us what to jam in and where
+        SkString    data;
+
+        this->getRecord(rowIndex, 0, &data);
+        evt->setString("xml-listsource", data.c_str());
+        return true;
+    }
+
 private:
-	SkString*	fFields;	// [fFieldCount]
-	SkString*	fRecords;	// [fRecordCount][fFieldCount]
-	int			fFieldCount, fRecordCount;
+    SkString*    fFields;    // [fFieldCount]
+    SkString*    fRecords;    // [fRecordCount][fFieldCount]
+    int            fFieldCount, fRecordCount;
 };
 
 #include "SkDOM.h"
 
 SkXMLListSource::SkXMLListSource(const char doc[], size_t len)
 {
-	fFieldCount = fRecordCount = 0;
-	fFields = fRecords = NULL;
+    fFieldCount = fRecordCount = 0;
+    fFields = fRecords = NULL;
 
-	SkDOM	dom;
+    SkDOM    dom;
 
-	const SkDOM::Node* node = dom.build(doc, len);
-	SkASSERT(node);
-	const SkDOM::Node*	child;	
+    const SkDOM::Node* node = dom.build(doc, len);
+    SkASSERT(node);
+    const SkDOM::Node*    child;
 
-	child = dom.getFirstChild(node, "fields");
-	if (child)
-	{
-		fFieldCount = dom.countChildren(child, "field");
-		fFields = new SkString[fFieldCount];
+    child = dom.getFirstChild(node, "fields");
+    if (child)
+    {
+        fFieldCount = dom.countChildren(child, "field");
+        fFields = new SkString[fFieldCount];
 
-		int n = 0;
-		child = dom.getFirstChild(child, "field");
-		while (child)
-		{
-			fFields[n].set(dom.findAttr(child, "name"));
-			child = dom.getNextSibling(child, "field");
-			n += 1;
-		}
-		SkASSERT(n == fFieldCount);
-	}
-	
-	child = dom.getFirstChild(node, "records");
-	if (child)
-	{
-		fRecordCount = dom.countChildren(child, "record");
-		fRecords = new SkString[fRecordCount * fFieldCount];
+        int n = 0;
+        child = dom.getFirstChild(child, "field");
+        while (child)
+        {
+            fFields[n].set(dom.findAttr(child, "name"));
+            child = dom.getNextSibling(child, "field");
+            n += 1;
+        }
+        SkASSERT(n == fFieldCount);
+    }
 
-		int n = 0;
-		child = dom.getFirstChild(child, "record");
-		while (child)
-		{
-			for (int i = 0; i < fFieldCount; i++)
-				fRecords[n * fFieldCount + i].set(dom.findAttr(child, fFields[i].c_str()));
-			child = dom.getNextSibling(child, "record");
-			n += 1;
-		}
-		SkASSERT(n == fRecordCount);
-	}
+    child = dom.getFirstChild(node, "records");
+    if (child)
+    {
+        fRecordCount = dom.countChildren(child, "record");
+        fRecords = new SkString[fRecordCount * fFieldCount];
+
+        int n = 0;
+        child = dom.getFirstChild(child, "record");
+        while (child)
+        {
+            for (int i = 0; i < fFieldCount; i++)
+                fRecords[n * fFieldCount + i].set(dom.findAttr(child, fFields[i].c_str()));
+            child = dom.getNextSibling(child, "record");
+            n += 1;
+        }
+        SkASSERT(n == fRecordCount);
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 SkListSource* SkListSource::Factory(const char name[])
 {
-	static const char gDoc[] =
-		"<db name='contacts.db'>"
-			"<fields>"
-				"<field name='name'/>"
-				"<field name='work-num'/>"
-				"<field name='home-num'/>"
-				"<field name='type'/>"
-			"</fields>"
-			"<records>"
-				"<record name='Andy McFadden' work-num='919 357-1234' home-num='919 123-4567' type='0'/>"
-				"<record name='Brian Swetland' work-num='919 123-1234' home-num='929 123-4567' type='1' />"
-				"<record name='Chris Desalvo' work-num='919 345-1234' home-num='949 123-4567' type='1' />"
-				"<record name='Chris White' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
-				"<record name='Dan Bornstein' work-num='919 357-1234' home-num='919 123-4567' type='0' />"
-				"<record name='Don Cung' work-num='919 123-1234' home-num='929 123-4567' type='2' />"
-				"<record name='Eric Fischer' work-num='919 345-1234' home-num='949 123-4567' type='2' />"
-				"<record name='Ficus Kirkpatric' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
-				"<record name='Jack Veenstra' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
-				"<record name='Jeff Yaksick' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
-				"<record name='Joe Onorato' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
-				"<record name='Mathias Agopian' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
-				"<record name='Mike Fleming' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
-				"<record name='Nick Sears' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
-				"<record name='Rich Miner' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
-				"<record name='Tracey Cole' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
-				"<record name='Wei Huang' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
-			"</records>"
-		"</db>";
-		
+    static const char gDoc[] =
+        "<db name='contacts.db'>"
+            "<fields>"
+                "<field name='name'/>"
+                "<field name='work-num'/>"
+                "<field name='home-num'/>"
+                "<field name='type'/>"
+            "</fields>"
+            "<records>"
+                "<record name='Andy McFadden' work-num='919 357-1234' home-num='919 123-4567' type='0'/>"
+                "<record name='Brian Swetland' work-num='919 123-1234' home-num='929 123-4567' type='1' />"
+                "<record name='Chris Desalvo' work-num='919 345-1234' home-num='949 123-4567' type='1' />"
+                "<record name='Chris White' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+                "<record name='Dan Bornstein' work-num='919 357-1234' home-num='919 123-4567' type='0' />"
+                "<record name='Don Cung' work-num='919 123-1234' home-num='929 123-4567' type='2' />"
+                "<record name='Eric Fischer' work-num='919 345-1234' home-num='949 123-4567' type='2' />"
+                "<record name='Ficus Kirkpatric' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+                "<record name='Jack Veenstra' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+                "<record name='Jeff Yaksick' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+                "<record name='Joe Onorato' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+                "<record name='Mathias Agopian' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+                "<record name='Mike Fleming' work-num='919 234-1234' home-num='939 123-4567' type='2' />"
+                "<record name='Nick Sears' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+                "<record name='Rich Miner' work-num='919 234-1234' home-num='939 123-4567' type='1' />"
+                "<record name='Tracey Cole' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+                "<record name='Wei Huang' work-num='919 234-1234' home-num='939 123-4567' type='0' />"
+            "</records>"
+        "</db>";
+
 //SkDebugf("doc size %d\n", sizeof(gDoc)-1);
-	return new SkXMLListSource(gDoc, sizeof(gDoc) - 1);
+    return new SkXMLListSource(gDoc, sizeof(gDoc) - 1);
 }
 
 
diff --git a/src/views/animated/SkProgressBarView.cpp b/src/views/animated/SkProgressBarView.cpp
index ce26ac4..e7754eb 100644
--- a/src/views/animated/SkProgressBarView.cpp
+++ b/src/views/animated/SkProgressBarView.cpp
@@ -13,97 +13,97 @@
 
 SkProgressBarView::SkProgressBarView()
 {
-	init_skin_anim(kProgress_SkinEnum, &fAnim);
-	fAnim.setHostEventSink(this);
-	fProgress = 0;
-	fMax = 100;
-	
+    init_skin_anim(kProgress_SkinEnum, &fAnim);
+    fAnim.setHostEventSink(this);
+    fProgress = 0;
+    fMax = 100;
+
 }
 
 void SkProgressBarView::changeProgress(int diff)
 {
-	int newProg = fProgress + diff;
-	if (newProg > 0 && newProg < fMax)
-		this->setProgress(newProg);
-	//otherwise i'll just leave it as it is
-	//this implies that if a new max and progress are set, max must be set first
+    int newProg = fProgress + diff;
+    if (newProg > 0 && newProg < fMax)
+        this->setProgress(newProg);
+    //otherwise i'll just leave it as it is
+    //this implies that if a new max and progress are set, max must be set first
 }
 
 /*virtual*/ void SkProgressBarView::onDraw(SkCanvas* canvas)
 {
-	SkPaint						paint;		
-	SkAnimator::DifferenceType	diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
-	
-	if (diff == SkAnimator::kDifferent)
-		this->inval(NULL);
-	else if (diff == SkAnimator::kPartiallyDifferent)
-	{
-		SkRect	bounds;
-		fAnim.getInvalBounds(&bounds);
-		this->inval(&bounds);
-	}
+    SkPaint                        paint;
+    SkAnimator::DifferenceType    diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+    if (diff == SkAnimator::kDifferent)
+        this->inval(NULL);
+    else if (diff == SkAnimator::kPartiallyDifferent)
+    {
+        SkRect    bounds;
+        fAnim.getInvalBounds(&bounds);
+        this->inval(&bounds);
+    }
 }
-	
+
 /*virtual*/ bool SkProgressBarView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Inval))
-	{
-		this->inval(NULL);
-		return true;
-	}
-	if (evt.isType("recommendDim"))
-	{
-		SkScalar	height;
-		
-		if (evt.findScalar("y", &height))
-			this->setHeight(height);
-		return true;
-	}
-	return this->INHERITED::onEvent(evt);
+    if (evt.isType(SK_EventType_Inval))
+    {
+        this->inval(NULL);
+        return true;
+    }
+    if (evt.isType("recommendDim"))
+    {
+        SkScalar    height;
+
+        if (evt.findScalar("y", &height))
+            this->setHeight(height);
+        return true;
+    }
+    return this->INHERITED::onEvent(evt);
 }
 
 /*virtual*/ void SkProgressBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
-	int32_t temp;
-	if (dom.findS32(node, "max", &temp))
-		this->setMax(temp);
-	if (dom.findS32(node, "progress", &temp))
-		this->setProgress(temp);
+    this->INHERITED::onInflate(dom, node);
+    int32_t temp;
+    if (dom.findS32(node, "max", &temp))
+        this->setMax(temp);
+    if (dom.findS32(node, "progress", &temp))
+        this->setProgress(temp);
 }
 
 /*virtual*/ void SkProgressBarView::onSizeChange()
 {
-	this->INHERITED::onSizeChange();
-	SkEvent evt("user");
-	evt.setString("id", "setDim");
-	evt.setScalar("dimX", this->width());
-	evt.setScalar("dimY", this->height());
-	fAnim.doUserEvent(evt);
+    this->INHERITED::onSizeChange();
+    SkEvent evt("user");
+    evt.setString("id", "setDim");
+    evt.setScalar("dimX", this->width());
+    evt.setScalar("dimY", this->height());
+    fAnim.doUserEvent(evt);
 }
 
 void SkProgressBarView::reset()
 {
-	fProgress = 0;
-	SkEvent e("user");
-	e.setString("id", "reset");
-	fAnim.doUserEvent(e);
+    fProgress = 0;
+    SkEvent e("user");
+    e.setString("id", "reset");
+    fAnim.doUserEvent(e);
 }
 
 void SkProgressBarView::setMax(int max)
 {
-	fMax = max;
-	SkEvent e("user");
-	e.setString("id", "setMax");
-	e.setS32("newMax", max);
-	fAnim.doUserEvent(e);
+    fMax = max;
+    SkEvent e("user");
+    e.setString("id", "setMax");
+    e.setS32("newMax", max);
+    fAnim.doUserEvent(e);
 }
 
 void SkProgressBarView::setProgress(int progress)
 {
-	fProgress = progress;
-	SkEvent e("user");
-	e.setString("id", "setProgress");
-	e.setS32("newProgress", progress);
-	fAnim.doUserEvent(e);
+    fProgress = progress;
+    SkEvent e("user");
+    e.setString("id", "setProgress");
+    e.setS32("newProgress", progress);
+    fAnim.doUserEvent(e);
 }
diff --git a/src/views/animated/SkScrollBarView.cpp b/src/views/animated/SkScrollBarView.cpp
index 98288f5..0d93775 100644
--- a/src/views/animated/SkScrollBarView.cpp
+++ b/src/views/animated/SkScrollBarView.cpp
@@ -16,131 +16,131 @@
 
 SkScrollBarView::SkScrollBarView()
 {
-	fAnim.setHostEventSink(this);
-	init_skin_anim(kScroll_SkinEnum, &fAnim);
+    fAnim.setHostEventSink(this);
+    init_skin_anim(kScroll_SkinEnum, &fAnim);
 
-	fTotalLength = 0;
-	fStartPoint = 0;
-	fShownLength = 0;
+    fTotalLength = 0;
+    fStartPoint = 0;
+    fShownLength = 0;
 
-	this->adjust();
+    this->adjust();
 }
 
 void SkScrollBarView::setStart(unsigned start)
 {
-	if ((int)start < 0)
-		start = 0;
-	
-	if (fStartPoint != start)
-	{
-		fStartPoint = start;
-		this->adjust();
-	}
+    if ((int)start < 0)
+        start = 0;
+
+    if (fStartPoint != start)
+    {
+        fStartPoint = start;
+        this->adjust();
+    }
 }
 
 void SkScrollBarView::setShown(unsigned shown)
 {
-	if ((int)shown < 0)
-		shown = 0;
+    if ((int)shown < 0)
+        shown = 0;
 
-	if (fShownLength != shown)
-	{
-		fShownLength = shown;
-		this->adjust();
-	}
+    if (fShownLength != shown)
+    {
+        fShownLength = shown;
+        this->adjust();
+    }
 }
 
 void SkScrollBarView::setTotal(unsigned total)
 {
-	if ((int)total < 0)
-		total = 0;
+    if ((int)total < 0)
+        total = 0;
 
-	if (fTotalLength != total)
-	{
-		fTotalLength = total;
-		this->adjust();
-	}
+    if (fTotalLength != total)
+    {
+        fTotalLength = total;
+        this->adjust();
+    }
 }
 
 /* virtual */ void SkScrollBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
-	this->INHERITED::onInflate(dom, node);
-	
-	int32_t value;
-	if (dom.findS32(node, "total", &value))
-		this->setTotal(value);
-	if (dom.findS32(node, "shown", &value))
-		this->setShown(value);
+    this->INHERITED::onInflate(dom, node);
+
+    int32_t value;
+    if (dom.findS32(node, "total", &value))
+        this->setTotal(value);
+    if (dom.findS32(node, "shown", &value))
+        this->setShown(value);
 }
 
 /*virtual*/ void SkScrollBarView::onSizeChange()
 {
-	this->INHERITED::onSizeChange();
-	SkEvent evt("user");
-	evt.setString("id", "setDim");
-	evt.setScalar("dimX", this->width());
-	evt.setScalar("dimY", this->height());
-	fAnim.doUserEvent(evt);
+    this->INHERITED::onSizeChange();
+    SkEvent evt("user");
+    evt.setString("id", "setDim");
+    evt.setScalar("dimX", this->width());
+    evt.setScalar("dimY", this->height());
+    fAnim.doUserEvent(evt);
 }
 
 /*virtual*/ void SkScrollBarView::onDraw(SkCanvas* canvas)
 {
-	SkPaint						paint;		
-	SkAnimator::DifferenceType	diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
-	
-	if (diff == SkAnimator::kDifferent)
-		this->inval(NULL);
-	else if (diff == SkAnimator::kPartiallyDifferent)
-	{
-		SkRect	bounds;
-		fAnim.getInvalBounds(&bounds);
-		this->inval(&bounds);
-	}
+    SkPaint                        paint;
+    SkAnimator::DifferenceType    diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
+    if (diff == SkAnimator::kDifferent)
+        this->inval(NULL);
+    else if (diff == SkAnimator::kPartiallyDifferent)
+    {
+        SkRect    bounds;
+        fAnim.getInvalBounds(&bounds);
+        this->inval(&bounds);
+    }
 }
 
 /*virtual*/ bool SkScrollBarView::onEvent(const SkEvent& evt)
 {
-	if (evt.isType(SK_EventType_Inval))
-	{
-		this->inval(NULL);
-		return true;
-	}
-	if (evt.isType("recommendDim"))
-	{
-		SkScalar	width;
-		
-		if (evt.findScalar("x", &width))
-			this->setWidth(width);
-		return true;
-	}
+    if (evt.isType(SK_EventType_Inval))
+    {
+        this->inval(NULL);
+        return true;
+    }
+    if (evt.isType("recommendDim"))
+    {
+        SkScalar    width;
 
-	return this->INHERITED::onEvent(evt);
+        if (evt.findScalar("x", &width))
+            this->setWidth(width);
+        return true;
+    }
+
+    return this->INHERITED::onEvent(evt);
 }
 
 void SkScrollBarView::adjust()
 {
-	int total = fTotalLength;
-	int start = fStartPoint;
-	int shown = fShownLength;
-	int hideBar = 0;
-	
-	if (total <= 0 || shown <= 0 || shown >= total)	// no bar to show
-	{
-		total = 1;		// avoid divide-by-zero. should be done by skin/script
-		hideBar = 1;	// signal we don't want a thumb
-	}
-	else
-	{
-		if (start + shown > total)
-			start = total - shown;
-	}
-	
-	SkEvent e("user");
-	e.setString("id", "adjustScrollBar");
-	e.setScalar("_totalLength", SkIntToScalar(total));
-	e.setScalar("_startPoint", SkIntToScalar(start));
-	e.setScalar("_shownLength", SkIntToScalar(shown));
-//	e.setS32("hideBar", hideBar);
-	fAnim.doUserEvent(e);
+    int total = fTotalLength;
+    int start = fStartPoint;
+    int shown = fShownLength;
+    int hideBar = 0;
+
+    if (total <= 0 || shown <= 0 || shown >= total)    // no bar to show
+    {
+        total = 1;        // avoid divide-by-zero. should be done by skin/script
+        hideBar = 1;    // signal we don't want a thumb
+    }
+    else
+    {
+        if (start + shown > total)
+            start = total - shown;
+    }
+
+    SkEvent e("user");
+    e.setString("id", "adjustScrollBar");
+    e.setScalar("_totalLength", SkIntToScalar(total));
+    e.setScalar("_startPoint", SkIntToScalar(start));
+    e.setScalar("_shownLength", SkIntToScalar(shown));
+//    e.setS32("hideBar", hideBar);
+    fAnim.doUserEvent(e);
 }
 
diff --git a/src/views/animated/SkStaticTextView.cpp b/src/views/animated/SkStaticTextView.cpp
index 79eecd6..8ab1183 100644
--- a/src/views/animated/SkStaticTextView.cpp
+++ b/src/views/animated/SkStaticTextView.cpp
@@ -21,11 +21,11 @@
 
 SkStaticTextView::SkStaticTextView()
 {
-	fMargin.set(0, 0);
-	fMode = kFixedSize_Mode;
-	fSpacingAlign = SkTextBox::kStart_SpacingAlign;
-	
-//	init_skin_paint(kStaticText_SkinEnum, &fPaint);
+    fMargin.set(0, 0);
+    fMode = kFixedSize_Mode;
+    fSpacingAlign = SkTextBox::kStart_SpacingAlign;
+
+//    init_skin_paint(kStaticText_SkinEnum, &fPaint);
 }
 
 SkStaticTextView::~SkStaticTextView()
@@ -34,155 +34,155 @@
 
 void SkStaticTextView::computeSize()
 {
-	if (fMode == kAutoWidth_Mode)
-	{
-		SkScalar width = fPaint.measureText(fText.c_str(), fText.size());
-		this->setWidth(width + fMargin.fX * 2);
-	}
-	else if (fMode == kAutoHeight_Mode)
-	{
-		SkScalar width = this->width() - fMargin.fX * 2;
-		int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
+    if (fMode == kAutoWidth_Mode)
+    {
+        SkScalar width = fPaint.measureText(fText.c_str(), fText.size());
+        this->setWidth(width + fMargin.fX * 2);
+    }
+    else if (fMode == kAutoHeight_Mode)
+    {
+        SkScalar width = this->width() - fMargin.fX * 2;
+        int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0;
 
-		this->setHeight(lines * fPaint.getFontSpacing() + fMargin.fY * 2);
-	}
+        this->setHeight(lines * fPaint.getFontSpacing() + fMargin.fY * 2);
+    }
 }
 
 void SkStaticTextView::setMode(Mode mode)
 {
-	SkASSERT((unsigned)mode < kModeCount);
+    SkASSERT((unsigned)mode < kModeCount);
 
-	if (fMode != mode)
-	{
-		fMode = SkToU8(mode);
-		this->computeSize();
-	}
+    if (fMode != mode)
+    {
+        fMode = SkToU8(mode);
+        this->computeSize();
+    }
 }
 
 void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
 {
-	fSpacingAlign = SkToU8(align);
-	this->inval(NULL);
+    fSpacingAlign = SkToU8(align);
+    this->inval(NULL);
 }
 
 void SkStaticTextView::getMargin(SkPoint* margin) const
 {
-	if (margin)
-		*margin = fMargin;
+    if (margin)
+        *margin = fMargin;
 }
 
 void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy)
 {
-	if (fMargin.fX != dx || fMargin.fY != dy)
-	{
-		fMargin.set(dx, dy);
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (fMargin.fX != dx || fMargin.fY != dy)
+    {
+        fMargin.set(dx, dy);
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 size_t SkStaticTextView::getText(SkString* text) const
 {
-	if (text)
-		*text = fText;
-	return fText.size();
+    if (text)
+        *text = fText;
+    return fText.size();
 }
 
 size_t SkStaticTextView::getText(char text[]) const
 {
-	if (text)
-		memcpy(text, fText.c_str(), fText.size());
-	return fText.size();
+    if (text)
+        memcpy(text, fText.c_str(), fText.size());
+    return fText.size();
 }
 
 void SkStaticTextView::setText(const SkString& text)
 {
-	this->setText(text.c_str(), text.size());
+    this->setText(text.c_str(), text.size());
 }
 
 void SkStaticTextView::setText(const char text[])
 {
-	if (text == NULL)
-		text = "";
-	this->setText(text, strlen(text));
+    if (text == NULL)
+        text = "";
+    this->setText(text, strlen(text));
 }
 
 void SkStaticTextView::setText(const char text[], size_t len)
 {
-	if (!fText.equals(text, len))
-	{
-		fText.set(text, len);
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (!fText.equals(text, len))
+    {
+        fText.set(text, len);
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 void SkStaticTextView::getPaint(SkPaint* paint) const
 {
-	if (paint)
-		*paint = fPaint;
+    if (paint)
+        *paint = fPaint;
 }
 
 void SkStaticTextView::setPaint(const SkPaint& paint)
 {
-	if (fPaint != paint)
-	{
-		fPaint = paint;
-		this->computeSize();
-		this->inval(NULL);
-	}
+    if (fPaint != paint)
+    {
+        fPaint = paint;
+        this->computeSize();
+        this->inval(NULL);
+    }
 }
 
 void SkStaticTextView::onDraw(SkCanvas* canvas)
 {
-	this->INHERITED::onDraw(canvas);
+    this->INHERITED::onDraw(canvas);
 
-	if (fText.isEmpty())
-		return;
+    if (fText.isEmpty())
+        return;
 
-	SkTextBox	box;
+    SkTextBox    box;
 
-	box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
-	box.setSpacingAlign(this->getSpacingAlign());
-	box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
-	box.draw(canvas, fText.c_str(), fText.size(), fPaint);
+    box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode);
+    box.setSpacingAlign(this->getSpacingAlign());
+    box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY);
+    box.draw(canvas, fText.c_str(), fText.size(), fPaint);
 }
 
 void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
 if (false) { // avoid bit rot, suppress warning
-	this->INHERITED::onInflate(dom, node);
+    this->INHERITED::onInflate(dom, node);
 
-	int	index;
-	if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
-		this->setMode((Mode)index);
-	else
-		assert_no_attr(dom, node, "mode");
+    int    index;
+    if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0)
+        this->setMode((Mode)index);
+    else
+        assert_no_attr(dom, node, "mode");
 
-	if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
-		this->setSpacingAlign((SkTextBox::SpacingAlign)index);
-	else
-		assert_no_attr(dom, node, "spacing-align");
+    if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0)
+        this->setSpacingAlign((SkTextBox::SpacingAlign)index);
+    else
+        assert_no_attr(dom, node, "spacing-align");
 
-	SkScalar s[2];
-	if (dom.findScalars(node, "margin", s, 2))
-		this->setMargin(s[0], s[1]);
-	else
-		assert_no_attr(dom, node, "margin");
+    SkScalar s[2];
+    if (dom.findScalars(node, "margin", s, 2))
+        this->setMargin(s[0], s[1]);
+    else
+        assert_no_attr(dom, node, "margin");
 
-	const char* text = dom.findAttr(node, "text");
-	if (text)
-		this->setText(text);
+    const char* text = dom.findAttr(node, "text");
+    if (text)
+        this->setText(text);
 
-	if ((node = dom.getFirstChild(node, "paint")) != NULL &&
-		(node = dom.getFirstChild(node, "screenplay")) != NULL)
-	{
+    if ((node = dom.getFirstChild(node, "paint")) != NULL &&
+        (node = dom.getFirstChild(node, "screenplay")) != NULL)
+    {
 // FIXME: Including inflate_paint causes Windows build to fail -- it complains
 //  that SKListView::SkListView is undefined.
 #if 0
-		inflate_paint(dom, node, &fPaint);
+        inflate_paint(dom, node, &fPaint);
 #endif
-	}
+    }
 }
 }
 
diff --git a/src/views/animated/SkWidgetViews.cpp b/src/views/animated/SkWidgetViews.cpp
index ee03b7b..9c1cae7 100644
--- a/src/views/animated/SkWidgetViews.cpp
+++ b/src/views/animated/SkWidgetViews.cpp
@@ -19,7 +19,7 @@
     kProgress_SkinEnum,
     kScroll_SkinEnum,
     kStaticText_SkinEnum,
-    
+
     kSkinEnumCount
 };
 */
@@ -45,7 +45,7 @@
 {
     SkASSERT(path && anim);
 
-    SkFILEStream	stream(path);
+    SkFILEStream    stream(path);
 
     if (!stream.isValid())
     {
@@ -69,9 +69,9 @@
 {
     SkASSERT(paint);
 
-    SkAnimator	anim;
-    SkCanvas	canvas;
-    
+    SkAnimator    anim;
+    SkCanvas    canvas;
+
     init_skin_anim(se, &anim);
     anim.draw(&canvas, paint, 0);
 }
@@ -80,15 +80,15 @@
 {
     SkASSERT(paint);
 
-    SkAnimator	anim;
-    SkCanvas	canvas;
-    
+    SkAnimator    anim;
+    SkCanvas    canvas;
+
     if (!anim.decodeDOM(dom, node))
     {
         SkDEBUGF(("inflate_paint: decoding dom failed\n"));
         SkDEBUGCODE(dom.dump(node);)
         sk_throw();
-    }	
+    }
     anim.draw(&canvas, paint, 0);
 }
 
@@ -102,7 +102,7 @@
 {
     return fLabel.c_str();
 }
-    
+
 void SkWidgetView::getLabel(SkString* label) const
 {
     if (label)
@@ -118,7 +118,7 @@
 {
     if ((label == NULL && fLabel.size() != 0) || !fLabel.equals(label, len))
     {
-        SkString	tmp(label, len);
+        SkString    tmp(label, len);
 
         this->onLabelChange(fLabel.c_str(), tmp.c_str());
         fLabel.swap(tmp);
@@ -138,13 +138,13 @@
 {
     if (!fEvent.isType(""))
     {
-        SkEvent	evt(fEvent);	// make a copy since onPrepareWidgetEvent may edit the event
+        SkEvent    evt(fEvent);    // make a copy since onPrepareWidgetEvent may edit the event
 
         if (this->onPrepareWidgetEvent(&evt))
         {
             SkDEBUGCODE(evt.dump("SkWidgetView::postWidgetEvent");)
 
-            this->postToListeners(evt);	// wonder if this should return true if there are > 0 listeners...
+            this->postToListeners(evt);    // wonder if this should return true if there are > 0 listeners...
             return true;
         }
     }
@@ -158,7 +158,7 @@
     const char* label = dom.findAttr(node, "label");
     if (label)
         this->setLabel(label);
-        
+
     if ((node = dom.getFirstChild(node, "event")) != NULL)
         fEvent.inflate(dom, node);
 }
@@ -178,8 +178,8 @@
 
 SkEventSinkID SkWidgetView::GetWidgetEventSinkID(const SkEvent& evt)
 {
-    int32_t	sinkID;
-    
+    int32_t    sinkID;
+
     return evt.findS32(gWidgetEventSinkIDSlotName, &sinkID) ? (SkEventSinkID)sinkID : 0;
 }
 
@@ -204,14 +204,14 @@
 void SkCheckButtonView::setCheckState(CheckState state)
 {
     SkASSERT((unsigned)state <= kUnknown_CheckState);
-    
+
     if (fCheckState != state)
     {
         this->onCheckStateChange(this->getCheckState(), state);
         fCheckState = SkToU8(state);
     }
 }
-    
+
 /*virtual*/ void SkCheckButtonView::onCheckStateChange(CheckState oldState, CheckState newState)
 {
     this->inval(NULL);
@@ -220,7 +220,7 @@
 /*virtual*/ void SkCheckButtonView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
 {
     this->INHERITED::onInflate(dom, node);
-    
+
     int index = dom.findList(node, "check-state", "off,on,unknown");
     if (index >= 0)
         this->setCheckState((CheckState)index);
@@ -238,8 +238,8 @@
 
 bool SkCheckButtonView::GetWidgetEventCheckState(const SkEvent& evt, CheckState* state)
 {
-    int32_t	state32;
-    
+    int32_t    state32;
+
     if (evt.findS32(gCheckStateSlotName, &state32))
     {
         if (state)
@@ -274,7 +274,7 @@
         evt.setString("LABEL", newLabel);
         fAnim.doUserEvent(evt);
     }
-    
+
     virtual void onFocusChange(bool gainFocus)
     {
         this->INHERITED::onFocusChange(gainFocus);
@@ -298,19 +298,19 @@
 
     virtual void onDraw(SkCanvas* canvas)
     {
-        SkPaint						paint;		
-        SkAnimator::DifferenceType	diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
-        
+        SkPaint                        paint;
+        SkAnimator::DifferenceType    diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs());
+
         if (diff == SkAnimator::kDifferent)
             this->inval(NULL);
         else if (diff == SkAnimator::kPartiallyDifferent)
         {
-            SkRect	bounds;
+            SkRect    bounds;
             fAnim.getInvalBounds(&bounds);
             this->inval(&bounds);
         }
     }
-    
+
     virtual bool onEvent(const SkEvent& evt)
     {
         if (evt.isType(SK_EventType_Inval))
@@ -320,20 +320,20 @@
         }
         if (evt.isType("recommendDim"))
         {
-            SkScalar	height;
-            
+            SkScalar    height;
+
             if (evt.findScalar("y", &height))
                 this->setHeight(height);
             return true;
         }
         return this->INHERITED::onEvent(evt);
     }
-    
+
     virtual bool onPrepareWidgetEvent(SkEvent* evt)
     {
         if (this->INHERITED::onPrepareWidgetEvent(evt))
         {
-            SkEvent	e("user");
+            SkEvent    e("user");
             e.setString("id", "handlePress");
             (void)fAnim.doUserEvent(e);
             return true;
@@ -342,8 +342,8 @@
     }
 
 private:
-    SkAnimator	fAnim;
-    
+    SkAnimator    fAnim;
+
     typedef SkButtonView INHERITED;
 };
 
@@ -354,7 +354,7 @@
 {
     if (name == NULL)
         return NULL;
-    
+
     // must be in the same order as the SkSkinWidgetEnum is declared
     static const char* gNames[] = {
         "sk-border",
@@ -364,7 +364,7 @@
         "sk-progress",
         "sk-scroll",
         "sk-text"
-        
+
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); i++)
diff --git a/src/views/mac/SkNSView.h b/src/views/mac/SkNSView.h
index 8b83b34..109a998 100644
--- a/src/views/mac/SkNSView.h
+++ b/src/views/mac/SkNSView.h
@@ -21,7 +21,7 @@
 
 @interface SkNSView : NSView {
     BOOL fRedrawRequestPending;
-    
+
     NSString* fTitle;
     SkOSWindow* fWind;
 #if SK_SUPPORT_GPU
diff --git a/src/views/mac/SkOSWindow_Mac.cpp b/src/views/mac/SkOSWindow_Mac.cpp
index 63106f0..ec10790 100644
--- a/src/views/mac/SkOSWindow_Mac.cpp
+++ b/src/views/mac/SkOSWindow_Mac.cpp
@@ -26,15 +26,15 @@
 static void (*gPrevNewHandler)();
 
 extern "C" {
-	static void sk_new_handler()
-	{
-		if (SkGraphics::SetFontCacheUsed(0))
-			return;
-		if (gPrevNewHandler)
-			gPrevNewHandler();
-		else
-			sk_throw();
-	}
+    static void sk_new_handler()
+    {
+        if (SkGraphics::SetFontCacheUsed(0))
+            return;
+        if (gPrevNewHandler)
+            gPrevNewHandler();
+        else
+            sk_throw();
+    }
 }
 
 static SkOSWindow* gCurrOSWin;
@@ -43,36 +43,36 @@
 
 static OSStatus MyDrawEventHandler(EventHandlerCallRef myHandler,
                                    EventRef event, void *userData) {
-	// NOTE: GState is save/restored by the HIView system doing the callback,
+    // NOTE: GState is save/restored by the HIView system doing the callback,
     // so the draw handler doesn't need to do it
 
-	OSStatus status = noErr;
-	CGContextRef context;
-	HIRect		bounds;
+    OSStatus status = noErr;
+    CGContextRef context;
+    HIRect        bounds;
 
-	// Get the CGContextRef
-	status = GetEventParameter (event, kEventParamCGContextRef,
+    // Get the CGContextRef
+    status = GetEventParameter (event, kEventParamCGContextRef,
                                 typeCGContextRef, NULL,
                                 sizeof (CGContextRef),
                                 NULL,
                                 &context);
 
-	if (status != noErr) {
-		SkDebugf("Got error %d getting the context!\n", status);
-		return status;
-	}
+    if (status != noErr) {
+        SkDebugf("Got error %d getting the context!\n", status);
+        return status;
+    }
 
-	// Get the bounding rectangle
-	HIViewGetBounds ((HIViewRef) userData, &bounds);
+    // Get the bounding rectangle
+    HIViewGetBounds ((HIViewRef) userData, &bounds);
 
     gCurrOSWin->doPaint(context);
-	return status;
+    return status;
 }
 
-#define SK_MacEventClass			FOUR_CHAR_CODE('SKec')
-#define SK_MacEventKind				FOUR_CHAR_CODE('SKek')
-#define SK_MacEventParamName		FOUR_CHAR_CODE('SKev')
-#define SK_MacEventSinkIDParamName	FOUR_CHAR_CODE('SKes')
+#define SK_MacEventClass            FOUR_CHAR_CODE('SKec')
+#define SK_MacEventKind                FOUR_CHAR_CODE('SKek')
+#define SK_MacEventParamName        FOUR_CHAR_CODE('SKev')
+#define SK_MacEventSinkIDParamName    FOUR_CHAR_CODE('SKes')
 
 static void set_bindingside(HISideBinding* side, HIViewRef parent, HIBindingKind kind) {
     side->toView = parent;
@@ -94,17 +94,17 @@
 
 SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd), fAGLCtx(NULL)
 {
-	OSStatus    result;
+    OSStatus    result;
     WindowRef   wr = (WindowRef)hWnd;
 
     HIViewRef imageView, parent;
     HIViewRef rootView = HIViewGetRoot(wr);
     HIViewFindByID(rootView, kHIViewWindowContentID, &parent);
     result = HIImageViewCreate(NULL, &imageView);
-	SkASSERT(result == noErr);
+    SkASSERT(result == noErr);
 
     result = HIViewAddSubview(parent, imageView);
-	SkASSERT(result == noErr);
+    SkASSERT(result == noErr);
 
     fHVIEW = imageView;
 
@@ -128,41 +128,41 @@
     HIImageViewSetOpaque(imageView, true);
     HIImageViewSetScaleToFit(imageView, false);
 
-	static const EventTypeSpec  gTypes[] = {
-		{ kEventClassKeyboard,  kEventRawKeyDown			},
+    static const EventTypeSpec  gTypes[] = {
+        { kEventClassKeyboard,  kEventRawKeyDown            },
         { kEventClassKeyboard,  kEventRawKeyUp              },
-		{ kEventClassMouse,		kEventMouseDown				},
-		{ kEventClassMouse,		kEventMouseDragged			},
-		{ kEventClassMouse,		kEventMouseMoved			},
-		{ kEventClassMouse,		kEventMouseUp				},
-		{ kEventClassTextInput, kEventTextInputUnicodeForKeyEvent   },
-		{ kEventClassWindow,	kEventWindowBoundsChanged	},
-//		{ kEventClassWindow,	kEventWindowDrawContent		},
-		{ SK_MacEventClass,		SK_MacEventKind				}
-	};
+        { kEventClassMouse,        kEventMouseDown                },
+        { kEventClassMouse,        kEventMouseDragged            },
+        { kEventClassMouse,        kEventMouseMoved            },
+        { kEventClassMouse,        kEventMouseUp                },
+        { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent   },
+        { kEventClassWindow,    kEventWindowBoundsChanged    },
+//        { kEventClassWindow,    kEventWindowDrawContent        },
+        { SK_MacEventClass,        SK_MacEventKind                }
+    };
 
-	EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler);
-	int				count = SK_ARRAY_COUNT(gTypes);
+    EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler);
+    int                count = SK_ARRAY_COUNT(gTypes);
 
-	result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
-						count, gTypes, this, nil);
-	SkASSERT(result == noErr);
+    result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
+                        count, gTypes, this, nil);
+    SkASSERT(result == noErr);
 
-	gCurrOSWin = this;
-	gCurrEventQ = GetCurrentEventQueue();
-	gEventTarget = GetWindowEventTarget(wr);
+    gCurrOSWin = this;
+    gCurrEventQ = GetCurrentEventQueue();
+    gEventTarget = GetWindowEventTarget(wr);
 
-	static bool gOnce = true;
-	if (gOnce) {
-		gOnce = false;
-		gPrevNewHandler = set_new_handler(sk_new_handler);
-	}
+    static bool gOnce = true;
+    if (gOnce) {
+        gOnce = false;
+        gPrevNewHandler = set_new_handler(sk_new_handler);
+    }
 }
 
 void SkOSWindow::doPaint(void* ctx)
 {
 #if 0
-	this->update(NULL);
+    this->update(NULL);
 
     const SkBitmap& bm = this->getBitmap();
     CGImageRef img = SkCreateCGImageRef(bm);
@@ -187,10 +187,10 @@
 
 void SkOSWindow::updateSize()
 {
-	Rect	r;
+    Rect    r;
 
-	GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
-	this->resize(r.right - r.left, r.bottom - r.top);
+    GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
+    this->resize(r.right - r.left, r.bottom - r.top);
 
 #if 0
     HIRect    frame;
@@ -238,24 +238,24 @@
 
 static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data)
 {
-	EventParamType  actualType;
-	UInt32			actualSize;
-	OSStatus		status;
+    EventParamType  actualType;
+    UInt32            actualSize;
+    OSStatus        status;
 
-	status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data);
-	SkASSERT(status == noErr);
-	SkASSERT(actualType == type);
-	SkASSERT(actualSize == size);
+    status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data);
+    SkASSERT(status == noErr);
+    SkASSERT(actualType == type);
+    SkASSERT(actualSize == size);
 }
 
 enum {
-	SK_MacReturnKey		= 36,
-	SK_MacDeleteKey		= 51,
-	SK_MacEndKey		= 119,
-	SK_MacLeftKey		= 123,
-	SK_MacRightKey		= 124,
-	SK_MacDownKey		= 125,
-	SK_MacUpKey			= 126,
+    SK_MacReturnKey        = 36,
+    SK_MacDeleteKey        = 51,
+    SK_MacEndKey        = 119,
+    SK_MacLeftKey        = 123,
+    SK_MacRightKey        = 124,
+    SK_MacDownKey        = 125,
+    SK_MacUpKey            = 126,
 
     SK_Mac0Key          = 0x52,
     SK_Mac1Key          = 0x53,
@@ -271,17 +271,17 @@
 
 static SkKey raw2key(UInt32 raw)
 {
-	static const struct {
-		UInt32  fRaw;
-		SkKey   fKey;
-	} gKeys[] = {
-		{ SK_MacUpKey,		kUp_SkKey		},
-		{ SK_MacDownKey,	kDown_SkKey		},
-		{ SK_MacLeftKey,	kLeft_SkKey		},
-		{ SK_MacRightKey,   kRight_SkKey	},
-		{ SK_MacReturnKey,  kOK_SkKey		},
-		{ SK_MacDeleteKey,  kBack_SkKey		},
-		{ SK_MacEndKey,		kEnd_SkKey		},
+    static const struct {
+        UInt32  fRaw;
+        SkKey   fKey;
+    } gKeys[] = {
+        { SK_MacUpKey,        kUp_SkKey        },
+        { SK_MacDownKey,    kDown_SkKey        },
+        { SK_MacLeftKey,    kLeft_SkKey        },
+        { SK_MacRightKey,   kRight_SkKey    },
+        { SK_MacReturnKey,  kOK_SkKey        },
+        { SK_MacDeleteKey,  kBack_SkKey        },
+        { SK_MacEndKey,        kEnd_SkKey        },
         { SK_Mac0Key,       k0_SkKey        },
         { SK_Mac1Key,       k1_SkKey        },
         { SK_Mac2Key,       k2_SkKey        },
@@ -292,54 +292,54 @@
         { SK_Mac7Key,       k7_SkKey        },
         { SK_Mac8Key,       k8_SkKey        },
         { SK_Mac9Key,       k9_SkKey        }
-	};
+    };
 
-	for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
-		if (gKeys[i].fRaw == raw)
-			return gKeys[i].fKey;
-	return kNONE_SkKey;
+    for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
+        if (gKeys[i].fRaw == raw)
+            return gKeys[i].fKey;
+    return kNONE_SkKey;
 }
 
 static void post_skmacevent()
 {
-	EventRef	ref;
-	OSStatus	status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
-	SkASSERT(status == noErr);
+    EventRef    ref;
+    OSStatus    status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
+    SkASSERT(status == noErr);
 
 #if 0
-	status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
-	SkASSERT(status == noErr);
-	status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
-	SkASSERT(status == noErr);
+    status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
+    SkASSERT(status == noErr);
+    status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
+    SkASSERT(status == noErr);
 #endif
 
-	EventTargetRef target = gEventTarget;
-	SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
-	SkASSERT(status == noErr);
+    EventTargetRef target = gEventTarget;
+    SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
+    SkASSERT(status == noErr);
 
-	status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
-	SkASSERT(status == noErr);
+    status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
+    SkASSERT(status == noErr);
 
-	ReleaseEvent(ref);
+    ReleaseEvent(ref);
 }
 
 pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData )
 {
-	SkOSWindow* win = (SkOSWindow*)userData;
-	OSStatus	result = eventNotHandledErr;
-	UInt32		wClass = GetEventClass(inEvent);
-	UInt32		wKind = GetEventKind(inEvent);
+    SkOSWindow* win = (SkOSWindow*)userData;
+    OSStatus    result = eventNotHandledErr;
+    UInt32        wClass = GetEventClass(inEvent);
+    UInt32        wKind = GetEventKind(inEvent);
 
-	gCurrOSWin = win;	// will need to be in TLS. Set this so PostEvent will work
+    gCurrOSWin = win;    // will need to be in TLS. Set this so PostEvent will work
 
-	switch (wClass) {
+    switch (wClass) {
         case kEventClassMouse: {
-			Point   pt;
-			getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt);
-			SetPortWindowPort((WindowRef)win->getHWND());
-			GlobalToLocal(&pt);
+            Point   pt;
+            getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt);
+            SetPortWindowPort((WindowRef)win->getHWND());
+            GlobalToLocal(&pt);
 
-			switch (wKind) {
+            switch (wKind) {
                 case kEventMouseDown:
                     if (win->handleClick(pt.h, pt.v, Click::kDown_State)) {
                         result = noErr;
@@ -357,9 +357,9 @@
                     break;
                 default:
                     break;
-			}
+            }
             break;
-		}
+        }
         case kEventClassKeyboard:
             if (wKind == kEventRawKeyDown) {
                 UInt32  raw;
@@ -412,8 +412,8 @@
                     post_skmacevent();
             }
     #if 0
-            SkEvent*		evt;
-            SkEventSinkID	sinkID;
+            SkEvent*        evt;
+            SkEventSinkID    sinkID;
             getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
             getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
     #endif
@@ -422,47 +422,47 @@
         }
         default:
             break;
-	}
-	if (result == eventNotHandledErr) {
-		result = CallNextEventHandler(inHandler, inEvent);
     }
-	return result;
+    if (result == eventNotHandledErr) {
+        result = CallNextEventHandler(inHandler, inEvent);
+    }
+    return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////
 
 void SkEvent::SignalNonEmptyQueue()
 {
-	post_skmacevent();
-//	SkDebugf("signal nonempty\n");
+    post_skmacevent();
+//    SkDebugf("signal nonempty\n");
 }
 
-static TMTask	gTMTaskRec;
-static TMTask*	gTMTaskPtr;
+static TMTask    gTMTaskRec;
+static TMTask*    gTMTaskPtr;
 
 static void sk_timer_proc(TMTask* rec)
 {
-	SkEvent::ServiceQueueTimer();
-//	SkDebugf("timer task fired\n");
+    SkEvent::ServiceQueueTimer();
+//    SkDebugf("timer task fired\n");
 }
 
 void SkEvent::SignalQueueTimer(SkMSec delay)
 {
-	if (gTMTaskPtr)
-	{
-		RemoveTimeTask((QElem*)gTMTaskPtr);
-		DisposeTimerUPP(gTMTaskPtr->tmAddr);
-		gTMTaskPtr = nil;
-	}
-	if (delay)
-	{
-		gTMTaskPtr = &gTMTaskRec;
-		memset(gTMTaskPtr, 0, sizeof(gTMTaskRec));
-		gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc);
-		OSErr err = InstallTimeTask((QElem*)gTMTaskPtr);
-//		SkDebugf("installtimetask of %d returned %d\n", delay, err);
-		PrimeTimeTask((QElem*)gTMTaskPtr, delay);
-	}
+    if (gTMTaskPtr)
+    {
+        RemoveTimeTask((QElem*)gTMTaskPtr);
+        DisposeTimerUPP(gTMTaskPtr->tmAddr);
+        gTMTaskPtr = nil;
+    }
+    if (delay)
+    {
+        gTMTaskPtr = &gTMTaskRec;
+        memset(gTMTaskPtr, 0, sizeof(gTMTaskRec));
+        gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc);
+        OSErr err = InstallTimeTask((QElem*)gTMTaskPtr);
+//        SkDebugf("installtimetask of %d returned %d\n", delay, err);
+        PrimeTimeTask((QElem*)gTMTaskPtr, delay);
+    }
 }
 
 #define USE_MSAA 0
diff --git a/src/views/sdl/SkOSWindow_SDL.cpp b/src/views/sdl/SkOSWindow_SDL.cpp
index c2ba8b4..4edc5ac 100644
--- a/src/views/sdl/SkOSWindow_SDL.cpp
+++ b/src/views/sdl/SkOSWindow_SDL.cpp
@@ -24,7 +24,7 @@
 
 static bool skia_setBitmapFromSurface(SkBitmap* dst, SDL_Surface* src) {
     SkBitmap::Config config;
-    
+
     switch (src->format->BytesPerPixel) {
         case 2:
             config = SkBitmap::kRGB_565_Config;
@@ -35,7 +35,7 @@
         default:
             return false;
     }
-    
+
     dst->setConfig(config, src->w, src->h, src->pitch);
     dst->setPixels(src->pixels);
     return true;
@@ -44,7 +44,7 @@
 SkOSWindow::SkOSWindow(void* screen) {
     fScreen = reinterpret_cast<SDL_Surface*>(screen);
     this->resize(fScreen->w, fScreen->h);
-    
+
     uint32_t rmask = SK_R32_MASK << SK_R32_SHIFT;
     uint32_t gmask = SK_G32_MASK << SK_G32_SHIFT;
     uint32_t bmask = SK_B32_MASK << SK_B32_SHIFT;
@@ -141,7 +141,7 @@
         SDLK_UNKNOWN,   // power
         SDLK_UNKNOWN,   // camera
     };
-    
+
     const SDLKey* array = gKeys;
     for (size_t i = 0; i < SK_ARRAY_COUNT(gKeys); i++) {
         if (array[i] == src) {
@@ -213,7 +213,7 @@
 
 static Uint32 timer_callback(Uint32 interval) {
 //    SkDebugf("-------- timercallback %d\n", interval);
-	SkEvent::ServiceQueueTimer();
+    SkEvent::ServiceQueueTimer();
     return 0;
 }
 
diff --git a/src/views/unix/SkOSWindow_Unix.cpp b/src/views/unix/SkOSWindow_Unix.cpp
index e761bde..46a2b3d 100644
--- a/src/views/unix/SkOSWindow_Unix.cpp
+++ b/src/views/unix/SkOSWindow_Unix.cpp
@@ -231,7 +231,7 @@
     this->initWindow(msaaSampleCount);
     if (NULL == fUnixWindow.fDisplay) {
         return false;
-    } 
+    }
     if (NULL == fUnixWindow.fGLContext) {
         SkASSERT(NULL != fVi);
 
diff --git a/src/views/unix/keysym2ucs.c b/src/views/unix/keysym2ucs.c
index 520c6a7..a0c4ced 100644
--- a/src/views/unix/keysym2ucs.c
+++ b/src/views/unix/keysym2ucs.c
@@ -828,19 +828,19 @@
 
     /* also check for directly encoded 24-bit UCS characters */
     if ((keysym & 0xff000000) == 0x01000000)
-	return keysym & 0x00ffffff;
+    return keysym & 0x00ffffff;
 
     /* binary search in table */
     while (max >= min) {
-	mid = (min + max) / 2;
-	if (keysymtab[mid].keysym < keysym)
-	    min = mid + 1;
-	else if (keysymtab[mid].keysym > keysym)
-	    max = mid - 1;
-	else {
-	    /* found it */
-	    return keysymtab[mid].ucs;
-	}
+    mid = (min + max) / 2;
+    if (keysymtab[mid].keysym < keysym)
+        min = mid + 1;
+    else if (keysymtab[mid].keysym > keysym)
+        max = mid - 1;
+    else {
+        /* found it */
+        return keysymtab[mid].ucs;
+    }
     }
 
     /* no matching Unicode value found */
diff --git a/src/views/win/SkOSWindow_win.cpp b/src/views/win/SkOSWindow_win.cpp
index 88a0a36..038a2e8 100644
--- a/src/views/win/SkOSWindow_win.cpp
+++ b/src/views/win/SkOSWindow_win.cpp
@@ -115,7 +115,7 @@
         } break;
         case WM_UNICHAR:
             this->handleChar(wParam);
-            return true; 
+            return true;
         case WM_CHAR: {
             this->handleChar(SkUTF8_ToUnichar((char*)&wParam));
             return true;
@@ -138,11 +138,11 @@
             delete rect;
             return true;
         } break;
-    
-        case WM_LBUTTONDOWN: 
+
+        case WM_LBUTTONDOWN:
             this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kDown_State);
             return true;
-                    
+
         case WM_MOUSEMOVE:
             this->handleClick(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), Click::kMoved_State);
             return true;
@@ -172,15 +172,15 @@
         memset(&bmi, 0, sizeof(bmi));
         bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
         bmi.bmiHeader.biWidth       = bitmap.width();
-        bmi.bmiHeader.biHeight      = -bitmap.height(); // top-down image 
+        bmi.bmiHeader.biHeight      = -bitmap.height(); // top-down image
         bmi.bmiHeader.biPlanes      = 1;
         bmi.bmiHeader.biBitCount    = 32;
         bmi.bmiHeader.biCompression = BI_RGB;
         bmi.bmiHeader.biSizeImage   = 0;
 
-        // 
-        // Do the SetDIBitsToDevice. 
-        // 
+        //
+        // Do the SetDIBitsToDevice.
+        //
         // TODO(wjmaclean):
         //       Fix this call to handle SkBitmaps that have rowBytes != width,
         //       i.e. may have padding at the end of lines. The SkASSERT below
@@ -235,7 +235,7 @@
     SK_MacRightKey      = 124,
     SK_MacDownKey       = 125,
     SK_MacUpKey         = 126,
-    
+
     SK_Mac0Key          = 0x52,
     SK_Mac1Key          = 0x53,
     SK_Mac2Key          = 0x54,
@@ -247,7 +247,7 @@
     SK_Mac8Key          = 0x5b,
     SK_Mac9Key          = 0x5c
 };
-    
+
 static SkKey raw2key(uint32_t raw)
 {
     static const struct {
@@ -272,7 +272,7 @@
         { SK_Mac8Key,       k8_SkKey        },
         { SK_Mac9Key,       k9_SkKey        }
     };
-    
+
     for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
         if (gKeys[i].fRaw == raw)
             return gKeys[i].fKey;
@@ -303,7 +303,7 @@
         gTimer = NULL;
     }
     if (delay)
-    {     
+    {
         gTimer = SetTimer(NULL, 0, delay, sk_timer_proc);
         //SkDebugf("SetTimer of %d returned %d\n", delay, gTimer);
     }
@@ -382,7 +382,7 @@
         BOOL set = SetPixelFormat(dc, format, &pfd);
         SkASSERT(TRUE == set);
     }
-    
+
     HGLRC glrc = wglCreateContext(dc);
     SkASSERT(glrc);
 
@@ -428,7 +428,7 @@
                   EGLSurface* eglSurface) {
     static const EGLint contextAttribs[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
-        EGL_NONE, EGL_NONE 
+        EGL_NONE, EGL_NONE
     };
     static const EGLint configAttribList[] = {
         EGL_RED_SIZE,       8,
@@ -482,33 +482,33 @@
         }
     }
     if (!foundConfig) {
-        if (!eglChooseConfig(display, configAttribList, 
+        if (!eglChooseConfig(display, configAttribList,
                                     &config, 1, &numConfigs)) {
            return false;
         }
     }
 
     // Create a surface
-    EGLSurface surface = eglCreateWindowSurface(display, config, 
-                                                (EGLNativeWindowType)hWnd, 
+    EGLSurface surface = eglCreateWindowSurface(display, config,
+                                                (EGLNativeWindowType)hWnd,
                                                 surfaceAttribList);
     if (surface == EGL_NO_SURFACE) {
        return false;
     }
 
     // Create a GL context
-    EGLContext context = eglCreateContext(display, config, 
+    EGLContext context = eglCreateContext(display, config,
                                           EGL_NO_CONTEXT,
                                           contextAttribs );
     if (context == EGL_NO_CONTEXT ) {
        return false;
-    }   
-    
+    }
+
     // Make the context current
     if (!eglMakeCurrent(display, surface, surface, context)) {
        return false;
     }
-    
+
     *eglDisplay = display;
     *eglContext = context;
     *eglSurface = surface;
@@ -583,7 +583,7 @@
     switch (attachType) {
     case kNone_BackEndType:
         // nothing to do
-        break; 
+        break;
 #if SK_SUPPORT_GPU
     case kNativeGL_BackEndType:
         result = attachGL(msaaSampleCount);
@@ -611,7 +611,7 @@
     switch (fAttached) {
     case kNone_BackEndType:
         // nothing to do
-        break; 
+        break;
 #if SK_SUPPORT_GPU
     case kNativeGL_BackEndType:
         detachGL();
@@ -633,7 +633,7 @@
     switch (fAttached) {
     case kNone_BackEndType:
         // nothing to do
-        return; 
+        return;
 #if SK_SUPPORT_GPU
     case kNativeGL_BackEndType:
         presentGL();
diff --git a/src/xml/SkDOM.cpp b/src/xml/SkDOM.cpp
index 474c291..bdfdd86 100644
--- a/src/xml/SkDOM.cpp
+++ b/src/xml/SkDOM.cpp
@@ -19,10 +19,10 @@
 
     if (this->startElement(elemName))
         return false;
-    
+
     SkDOM::AttrIter iter(dom, node);
     const char*     name, *value;
-    
+
     while ((name = iter.next(&value)) != NULL)
         if (this->addAttribute(name, value))
             return false;
@@ -32,7 +32,7 @@
             if (!this->parse(dom, node))
                 return false;
         } while ((node = dom.getNextSibling(node)) != NULL);
-    
+
     return !this->endElement(elemName);
 }
 
@@ -312,7 +312,7 @@
     const char* elem = dom.getName(node);
 
     parser->startElement(elem);
-    
+
     SkDOM::AttrIter iter(dom, node);
     const char*     name;
     const char*     value;
@@ -467,7 +467,7 @@
 void SkDOM::UnitTest()
 {
 #ifdef SK_SUPPORT_UNITTEST
-    static const char gDoc[] = 
+    static const char gDoc[] =
         "<root a='1' b='2'>"
             "<elem1 c='3' />"
             "<elem2 d='4' />"
diff --git a/src/xml/SkJSDisplayable.cpp b/src/xml/SkJSDisplayable.cpp
index 0e14fde..5027797 100644
--- a/src/xml/SkJSDisplayable.cpp
+++ b/src/xml/SkJSDisplayable.cpp
@@ -83,7 +83,7 @@
 }
 
 
-JSFunctionSpec SkJSDisplayable_methods[] = 
+JSFunctionSpec SkJSDisplayable_methods[] =
 {
     { "draw", SkJSDisplayable::Draw, 1, 0, 0 },
     { 0 }
@@ -219,7 +219,7 @@
                                  jsval *vp)
 {
     if (JSVAL_IS_INT(id) == 0)
-        return JS_TRUE; 
+        return JS_TRUE;
     SkJSDisplayable *p = (SkJSDisplayable *) JS_GetPrivate(cx, obj);
     SkDisplayable* displayable = p->fDisplayable;
     SkDisplayTypes displayableType = displayable->getType();
@@ -295,7 +295,7 @@
 
 JSBool SkJSDisplayable::SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp) {
     if (JSVAL_IS_INT(id) == 0)
-        return JS_TRUE; 
+        return JS_TRUE;
     SkJSDisplayable *p = (SkJSDisplayable *) JS_GetPrivate(cx, obj);
     SkDisplayable* displayable = p->fDisplayable;
     SkDisplayTypes displayableType = displayable->getType();
diff --git a/src/xml/SkXMLParser.cpp b/src/xml/SkXMLParser.cpp
index 17329be..63929a9 100644
--- a/src/xml/SkXMLParser.cpp
+++ b/src/xml/SkXMLParser.cpp
@@ -74,7 +74,7 @@
     return this->onEndElement(elem);
 }
 
-bool SkXMLParser::text(const char text[], int len) 
+bool SkXMLParser::text(const char text[], int len)
 {
     return this->onText(text, len);
 }
diff --git a/src/xml/SkXMLPullParser.cpp b/src/xml/SkXMLPullParser.cpp
index 03fed42..4080aeb 100644
--- a/src/xml/SkXMLPullParser.cpp
+++ b/src/xml/SkXMLPullParser.cpp
@@ -26,7 +26,7 @@
 {
     fCurr.fEventType = ERROR;
     fDepth = 0;
-    
+
     this->setStream(stream);
 }
 
@@ -65,12 +65,12 @@
     case END_TAG:
         fDepth -= 1;
         // fall through
-    default:        
+    default:
         reset(&fCurr);
         fCurr.fEventType = this->onNextToken();
         break;
     }
-    
+
     switch (fCurr.fEventType) {
     case START_TAG:
         fDepth += 1;
@@ -125,11 +125,11 @@
 void SkXMLPullParser::getAttributeInfo(int index, AttrInfo* info)
 {
     SkASSERT((unsigned)index < (unsigned)fCurr.fAttrInfoCount);
-    
+
     if (info)
         *info = fCurr.fAttrInfos[index];
 }
-    
+
 bool SkXMLPullParser::onEntityReplacement(const char name[],
                                           SkString* replacement)
 {
diff --git a/src/xml/SkXMLWriter.cpp b/src/xml/SkXMLWriter.cpp
index 935745d..451d1d5 100644
--- a/src/xml/SkXMLWriter.cpp
+++ b/src/xml/SkXMLWriter.cpp
@@ -69,7 +69,7 @@
     return firstChild;
 }
 
-SkXMLWriter::Elem* SkXMLWriter::getEnd() 
+SkXMLWriter::Elem* SkXMLWriter::getEnd()
 {
     Elem* elem;
     fElems.pop(&elem);