Skia Merge (revision 922)

Change-Id: I7ed57d10905d8bad6486a4d7410165eec1cc2b4f

301 files changed, 31023 insertions, 23100 deletions

diff --git a/Android.mk b/Android.mk
index f2b86d4..72c3eba 100644
--- a/Android.mk
+++ b/Android.mk
@@ -123,6 +123,7 @@ LOCAL_SRC_FILES:= \
 	src/core/SkColorFilter.cpp \
 	src/core/SkColorTable.cpp \
 	src/core/SkComposeShader.cpp \
+	src/core/SkCubicClipper.cpp \
 	src/core/SkDeque.cpp \
 	src/core/SkDevice.cpp \
 	src/core/SkDither.cpp \
@@ -155,7 +156,6 @@ LOCAL_SRC_FILES:= \
 	src/core/SkPtrRecorder.cpp \
 	src/core/SkQuadClipper.cpp \
 	src/core/SkRasterizer.cpp \
-	src/core/SkRefCnt.cpp \
 	src/core/SkRefDict.cpp \
 	src/core/SkRegion_path.cpp \
 	src/core/SkScalerContext.cpp \
@@ -183,6 +183,8 @@ LOCAL_SRC_FILES:= \
 	src/utils/SkLayer.cpp \
 	src/utils/SkMeshUtils.cpp \
 	src/utils/SkNinePatch.cpp \
+	src/utils/SkParse.cpp \
+	src/utils/SkParsePath.cpp \
 	src/utils/SkProxyCanvas.cpp
 
 ifeq ($(TARGET_ARCH),arm)
@@ -238,6 +240,76 @@ LOCAL_MODULE:= libskia
 include $(BUILD_SHARED_LIBRARY)
 
 #############################################################
+# Build the skia gpu (ganesh) library
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_ARM_MODE := arm
+
+ifneq ($(ARCH_ARM_HAVE_VFP),true)
+       LOCAL_CFLAGS += -DSK_SOFTWARE_FLOAT
+endif
+
+ifeq ($(ARCH_ARM_HAVE_NEON),true)
+       LOCAL_CFLAGS += -D__ARM_HAVE_NEON
+endif
+
+LOCAL_SRC_FILES:= \
+  gpu/src/GrAllocPool.cpp \
+  gpu/src/GrAtlas.cpp \
+  gpu/src/GrClip.cpp \
+  gpu/src/GrContext.cpp \
+  gpu/src/GrDrawTarget.cpp \
+  gpu/src/GrGLIndexBuffer.cpp	\
+  gpu/src/GrGLTexture.cpp \
+  gpu/src/GrGLVertexBuffer.cpp \
+  gpu/src/GrGpu.cpp \
+  gpu/src/GrGpuGLShaders2.cpp \
+  gpu/src/GrGpuGLFixed.cpp \
+  gpu/src/GrGpuFactory.cpp \
+  gpu/src/GrGLUtil.cpp \
+  gpu/src/GrGpuGL.cpp \
+  gpu/src/GrInOrderDrawBuffer.cpp \
+  gpu/src/GrMatrix.cpp \
+  gpu/src/GrMemory.cpp \
+  gpu/src/GrPath.cpp \
+  gpu/src/GrRectanizer_fifo.cpp \
+  gpu/src/GrTextureCache.cpp \
+  gpu/src/GrTextContext.cpp \
+  gpu/src/GrTextStrike.cpp \
+  gpu/src/GrBufferAllocPool.cpp\
+  gpu/src/GrPathRenderer.cpp \
+  gpu/src/GrStencil.cpp \
+  src/gpu/SkGpuCanvas.cpp	\
+  src/gpu/SkGpuDevice.cpp \
+  src/gpu/SkGr.cpp \
+  src/gpu/SkGrTexturePixelRef.cpp \
+  src/gpu/SkGrFontScaler.cpp \
+	src/gpu/GrPrintf_skia.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+  libcutils \
+  libutils \
+  libskia \
+  libEGL \
+  libGLESv2
+
+LOCAL_C_INCLUDES += \
+  $(LOCAL_PATH)/gpu/include \
+  $(LOCAL_PATH)/gpu/src \
+  $(LOCAL_PATH)/include/core \
+  $(LOCAL_PATH)/include/gpu \
+  $(LOCAL_PATH)/src/core
+
+LOCAL_LDLIBS += -lpthread
+
+LOCAL_MODULE:= libskiagpu
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_STATIC_LIBRARY)
+
+#############################################################
 # Build the skia tools
 #
 
diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp
index 0c3eb56..a6f300e 100644
--- a/bench/RectBench.cpp
+++ b/bench/RectBench.cpp
@@ -3,6 +3,7 @@
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
+#include "SkShader.h"
 
 class RectBench : public SkBenchmark {
 public:
@@ -112,6 +113,85 @@ protected:
     virtual const char* onGetName() { return fName; }
 };
 
+/*******************************************************************************
+ * to bench BlitMask [Opaque, Black, color, shader]
+ *******************************************************************************/
+
+class BlitMaskBench : public RectBench {
+public:
+    enum kMaskType {
+        kMaskOpaque = 0,
+        kMaskBlack,
+        kMaskColor,
+        KMaskShader
+    };
+    SkCanvas::PointMode fMode;
+    const char* fName;
+
+    BlitMaskBench(void* param, SkCanvas::PointMode mode, 
+                  BlitMaskBench::kMaskType type, const char* name) :
+                  RectBench(param, 2), fMode(mode), _type(type) {
+        fName = name;
+    }
+
+protected:
+    virtual void onDraw(SkCanvas* canvas) {
+        SkScalar gSizes[] = {
+            SkIntToScalar(13), SkIntToScalar(24)
+        };
+        size_t sizes = SK_ARRAY_COUNT(gSizes);
+
+        if (this->hasStrokeWidth()) {
+            gSizes[0] = this->getStrokeWidth();
+            sizes = 1;
+        }
+        SkRandom rand;
+        SkColor color = 0xFF000000;
+        U8CPU alpha = 0xFF;
+        SkPaint paint;
+        paint.setStrokeCap(SkPaint::kRound_Cap);
+        if (_type == KMaskShader) {
+            SkBitmap srcBM;
+            srcBM.setConfig(SkBitmap::kARGB_8888_Config, 10, 1);
+            srcBM.allocPixels();
+            srcBM.eraseColor(0xFF00FF00);
+
+            SkShader* s;
+            s  = SkShader::CreateBitmapShader(srcBM, SkShader::kClamp_TileMode,
+                                              SkShader::kClamp_TileMode);
+            paint.setShader(s)->unref();
+        }
+        for (size_t i = 0; i < sizes; i++) {
+            switch (_type) {	
+                case kMaskOpaque: 
+                    color = fColors[i]; 
+                    alpha = 0xFF; 
+                    break;
+                case kMaskBlack: 
+                    alpha = 0xFF;
+                    color = 0xFF000000;
+                    break;
+                case kMaskColor:
+                    color = fColors[i]; 
+                    alpha = rand.nextU() & 255;
+                    break;
+                case KMaskShader:
+                    break;
+            }
+            paint.setStrokeWidth(gSizes[i]);
+            this->setupPaint(&paint);
+            paint.setColor(color);
+            paint.setAlpha(alpha);
+            canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
+       }
+    }
+    virtual const char* onGetName() { return fName; }
+private:
+	typedef RectBench INHERITED;
+	kMaskType _type;
+};
+
+
 static SkBenchmark* RectFactory1(void* p) { return SkNEW_ARGS(RectBench, (p, 1)); }
 static SkBenchmark* RectFactory2(void* p) { return SkNEW_ARGS(RectBench, (p, 3)); }
 static SkBenchmark* OvalFactory1(void* p) { return SkNEW_ARGS(OvalBench, (p, 1)); }
@@ -128,6 +208,32 @@ static SkBenchmark* PolygonFactory(void* p) {
     return SkNEW_ARGS(PointsBench, (p, SkCanvas::kPolygon_PointMode, "polygon"));
 }
 
+/* init the blitmask bench
+ */
+static SkBenchmark* BlitMaskOpaqueFactory(void* p) {
+    return SkNEW_ARGS(BlitMaskBench,
+                      (p, SkCanvas::kPoints_PointMode,
+                      BlitMaskBench::kMaskOpaque, "maskopaque")
+                      );
+}
+static SkBenchmark* BlitMaskBlackFactory(void* p) {
+    return SkNEW_ARGS(BlitMaskBench,
+                      (p, SkCanvas::kPoints_PointMode,
+                      BlitMaskBench::kMaskBlack, "maskblack")
+                      );
+}
+static SkBenchmark* BlitMaskColorFactory(void* p) {
+    return SkNEW_ARGS(BlitMaskBench,
+                      (p, SkCanvas::kPoints_PointMode,
+                      BlitMaskBench::kMaskColor, "maskcolor")
+                      );
+}
+static SkBenchmark* BlitMaskShaderFactory(void* p) {
+    return SkNEW_ARGS(BlitMaskBench,
+                     (p, SkCanvas::kPoints_PointMode,
+                     BlitMaskBench::KMaskShader, "maskshader")
+                     );
+}
 static BenchRegistry gRectReg1(RectFactory1);
 static BenchRegistry gRectReg2(RectFactory2);
 static BenchRegistry gOvalReg1(OvalFactory1);
@@ -137,3 +243,7 @@ static BenchRegistry gRRectReg2(RRectFactory2);
 static BenchRegistry gPointsReg(PointsFactory);
 static BenchRegistry gLinesReg(LinesFactory);
 static BenchRegistry gPolygonReg(PolygonFactory);
+static BenchRegistry gRectRegOpaque(BlitMaskOpaqueFactory);
+static BenchRegistry gRectRegBlack(BlitMaskBlackFactory);
+static BenchRegistry gRectRegColor(BlitMaskColorFactory);
+static BenchRegistry gRectRegShader(BlitMaskShaderFactory);
diff --git a/gm/Android.mk b/gm/Android.mk
index 6861e16..15e56d6 100644
--- a/gm/Android.mk
+++ b/gm/Android.mk
@@ -3,27 +3,33 @@ LOCAL_PATH:= $(call my-dir)
 include $(CLEAR_VARS)
 
 LOCAL_SRC_FILES := \
-	filltypes.cpp \
+  bitmapfilters.cpp \
+  blurs.cpp \
+  complexclip.cpp \
+  filltypes.cpp \
   gradients.cpp \
-	tilemodes.cpp \
-	bitmapfilters.cpp \
-	xfermodes.cpp \
-	gmmain.cpp
+  points.cpp \
+  poly2poly.cpp \
+  shadertext.cpp \
+  shadows.cpp \
+  shapes.cpp \
+  tilemodes.cpp \
+  xfermodes.cpp \
+  gmmain.cpp
 
 # additional optional class for this tool
 LOCAL_SRC_FILES += \
-	../src/utils/SkUnitMappers.cpp \
-	../src/utils/SkEGLContext_none.cpp
+  ../src/utils/SkEGLContext_none.cpp
 
 LOCAL_SHARED_LIBRARIES := libcutils libskia
 LOCAL_C_INCLUDES := \
-    external/skia/include/config \
-    external/skia/include/core \
-    external/skia/include/images \
-    external/skia/include/utils \
-    external/skia/include/effects \
-    external/skia/gpu/include \
-    external/skia/include/gpu
+  external/skia/include/config \
+  external/skia/include/core \
+  external/skia/include/images \
+  external/skia/include/utils \
+  external/skia/include/effects \
+  external/skia/gpu/include \
+  external/skia/include/gpu
 
 #LOCAL_CFLAGS := 
 
diff --git a/gm/blurs.cpp b/gm/blurs.cpp
index 8250d76..26fdc79 100644
--- a/gm/blurs.cpp
+++ b/gm/blurs.cpp
@@ -74,7 +74,7 @@ protected:
                 canvas->drawText("Hamburgefons Style", 18, x, y, paint);
             }
             canvas->restore();
-//            flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
+            flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
             canvas->translate(350, 0);
         }
     }
diff --git a/gm/complexclip.cpp b/gm/complexclip.cpp
new file mode 100644
index 0000000..867d230
--- /dev/null
+++ b/gm/complexclip.cpp
@@ -0,0 +1,152 @@
+#include "gm.h"
+#include "SkCanvas.h"
+//#include "SkParsePath.h"
+#include "SkPath.h"
+//#include "SkRandom.h"
+
+namespace skiagm {
+
+class ComplexClipGM : public GM {
+public:
+	ComplexClipGM() {
+    }
+
+protected:
+
+    SkString onShortName() {
+        return SkString("complexclip");
+    }
+
+    SkISize onISize() { return make_isize(550, 1000); }
+
+    void drawBG(SkCanvas* canvas) {
+        canvas->drawColor(SkColorSetRGB(0xA0,0xDD,0xA0));
+    }
+
+    virtual void onDraw(SkCanvas* canvas) {
+        SkPath path;
+        path.moveTo(SkIntToScalar(0),   SkIntToScalar(50));
+        path.quadTo(SkIntToScalar(0),   SkIntToScalar(0),   SkIntToScalar(50),  SkIntToScalar(0));
+        path.lineTo(SkIntToScalar(175), SkIntToScalar(0));
+        path.quadTo(SkIntToScalar(200), SkIntToScalar(0),   SkIntToScalar(200), SkIntToScalar(25));
+        path.lineTo(SkIntToScalar(200), SkIntToScalar(150));
+        path.quadTo(SkIntToScalar(200), SkIntToScalar(200), SkIntToScalar(150), SkIntToScalar(200));
+        path.lineTo(SkIntToScalar(0),   SkIntToScalar(200));
+        path.close();
+        path.moveTo(SkIntToScalar(50),  SkIntToScalar(50));
+        path.lineTo(SkIntToScalar(150), SkIntToScalar(50));
+        path.lineTo(SkIntToScalar(150), SkIntToScalar(125));
+        path.quadTo(SkIntToScalar(150), SkIntToScalar(150), SkIntToScalar(125), SkIntToScalar(150));
+        path.lineTo(SkIntToScalar(50),  SkIntToScalar(150));
+        path.close();
+        path.setFillType(SkPath::kEvenOdd_FillType);
+        SkColor pathColor = SK_ColorBLACK;
+        SkPaint pathPaint;
+        pathPaint.setAntiAlias(true);
+        pathPaint.setColor(pathColor);
+
+        SkPath clipA;
+        clipA.moveTo(SkIntToScalar(10),  SkIntToScalar(20));
+        clipA.lineTo(SkIntToScalar(165), SkIntToScalar(22));
+        clipA.lineTo(SkIntToScalar(70),  SkIntToScalar(105));
+        clipA.lineTo(SkIntToScalar(165), SkIntToScalar(177));
+        clipA.lineTo(SkIntToScalar(-5),  SkIntToScalar(180));
+        clipA.close();
+        SkColor colorA = SK_ColorCYAN;
+
+        SkPath clipB;
+        clipB.moveTo(SkIntToScalar(40),  SkIntToScalar(10));
+        clipB.lineTo(SkIntToScalar(190), SkIntToScalar(15));
+        clipB.lineTo(SkIntToScalar(195), SkIntToScalar(190));
+        clipB.lineTo(SkIntToScalar(40),  SkIntToScalar(185));
+        clipB.lineTo(SkIntToScalar(155), SkIntToScalar(100));
+        clipB.close();
+        SkColor colorB = SK_ColorRED;
+
+        drawBG(canvas);
+        SkPaint paint;
+        paint.setAntiAlias(true);
+
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(0);
+
+        canvas->translate(SkIntToScalar(10),SkIntToScalar(10));
+        canvas->drawPath(path, pathPaint);
+        paint.setColor(colorA);
+        canvas->drawPath(clipA, paint);
+        paint.setColor(colorB);
+        canvas->drawPath(clipB, paint);
+
+        static const struct {
+            SkRegion::Op fOp;
+            const char*  fName;
+        } gOps[] = { //extra spaces in names for measureText
+            {SkRegion::kIntersect_Op,         "Isect "},
+            {SkRegion::kDifference_Op,        "Diff " },
+            {SkRegion::kUnion_Op,             "Union "},
+            {SkRegion::kXOR_Op,               "Xor "  },
+            {SkRegion::kReverseDifference_Op, "RDiff "}
+        };
+
+        canvas->translate(0, SkIntToScalar(40));
+        canvas->scale(3 * SK_Scalar1 / 4, 3 * SK_Scalar1 / 4);
+        canvas->save();
+
+        for (int invA = 0; invA < 2; ++invA) {
+            for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); ++op) {
+                int idx = invA * SK_ARRAY_COUNT(gOps) + op;
+                if (!(idx % 3)) {
+                    canvas->restore();
+                    canvas->translate(0, SkIntToScalar(250));
+                    canvas->save();
+                }
+                canvas->save();
+                    // set clip
+                    clipA.setFillType(invA ? SkPath::kInverseEvenOdd_FillType :
+                                             SkPath::kEvenOdd_FillType);
+                    canvas->clipPath(clipA);
+                    canvas->clipPath(clipB, gOps[op].fOp);
+
+                    // draw path clipped
+                    canvas->drawPath(path, pathPaint);
+                canvas->restore();
+
+                // draw path in hairline
+                paint.setColor(pathColor);
+                canvas->drawPath(path, paint);
+
+                // draw clips in hair line
+                paint.setColor(colorA);
+                canvas->drawPath(clipA, paint);
+                paint.setColor(colorB);
+                canvas->drawPath(clipB, paint);
+
+                paint.setTextSize(SkIntToScalar(20));
+
+                SkScalar txtX = SkIntToScalar(55);
+                paint.setColor(colorA);
+                const char* aTxt = invA ? "InverseA " : "A ";
+                canvas->drawText(aTxt, strlen(aTxt), txtX, SkIntToScalar(220), paint);
+                txtX += paint.measureText(aTxt, strlen(aTxt));
+                paint.setColor(SK_ColorBLACK);
+                canvas->drawText(gOps[op].fName, strlen(gOps[op].fName),
+                                    txtX, SkIntToScalar(220), paint);
+                txtX += paint.measureText(gOps[op].fName, strlen(gOps[op].fName));
+                paint.setColor(colorB);
+                canvas->drawText("B", 1, txtX, SkIntToScalar(220), paint);
+
+                canvas->translate(SkIntToScalar(250),0);
+            }
+        }
+        canvas->restore();
+    }
+private:
+    typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new ComplexClipGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/gm_files.mk b/gm/gm_files.mk
deleted file mode 100644
index 2f7769e..0000000
--- a/gm/gm_files.mk
+++ /dev/null
@@ -1,12 +0,0 @@
-SOURCE := \
-	bitmapfilters.cpp \
-	blurs.cpp \
-	filltypes.cpp \
-	gradients.cpp \
-	points.cpp \
-	poly2poly.cpp \
-	shapes.cpp \
-	tilemodes.cpp \
-	xfermodes.cpp \
-	shadertext.cpp \
-	gmmain.cpp
diff --git a/gm/shadows.cpp b/gm/shadows.cpp
new file mode 100644
index 0000000..5afde49
--- /dev/null
+++ b/gm/shadows.cpp
@@ -0,0 +1,99 @@
+#include "gm.h"
+#include "SkPicture.h"
+#include "SkRectShape.h"
+#include "SkBlurDrawLooper.h"
+
+namespace skiagm {
+
+///////////////////////////////////////////////////////////////////////////////
+
+class ShadowsGM : public GM {
+
+public:
+    SkPath fCirclePath;
+    SkPaint fPaint;
+    SkRectShape fRectShape;
+    ShadowsGM() {
+        fCirclePath.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(10) );
+    fPaint.setStrokeWidth(SkIntToScalar(4));
+    fPaint.setAntiAlias(true);
+    fPaint.setColor(0xFF00FF00);
+    fPaint.setStyle(SkPaint::kStroke_Style); 
+    SkRect rect;
+    rect.set(SkIntToScalar(10), SkIntToScalar(10),
+             SkIntToScalar(30), SkIntToScalar(30));
+    fRectShape.setRect(rect);
+    fRectShape.paint().setColor(SK_ColorRED);
+    }
+
+    virtual ~ShadowsGM() {
+    }
+
+protected:
+    virtual SkString onShortName() {
+        return SkString("shadows");
+    }
+
+    virtual SkISize onISize() {
+        return make_isize(200, 80);
+    }
+
+    void drawBG(SkCanvas* canvas) {
+        canvas->drawColor(0xFFDDDDDD);
+    }
+
+    virtual void onDraw(SkCanvas* canvas) {
+        this->drawBG(canvas);
+
+    SkBlurDrawLooper* shadowLoopers[5];
+    shadowLoopers[0] =
+        new SkBlurDrawLooper (10, 5, 10, 0xFF0000FF, 
+                              SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
+                              SkBlurDrawLooper::kOverrideColor_BlurFlag |
+                              SkBlurDrawLooper::kHighQuality_BlurFlag );
+    SkAutoUnref aurL0(shadowLoopers[0]);
+    shadowLoopers[1] =
+        new SkBlurDrawLooper (10, 5, 10, 0xFF0000FF, 
+                              SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
+                              SkBlurDrawLooper::kOverrideColor_BlurFlag );
+    SkAutoUnref aurL1(shadowLoopers[1]);
+    shadowLoopers[2] =
+        new SkBlurDrawLooper (5, 5, 10, 0xFF000000,
+                              SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
+                              SkBlurDrawLooper::kHighQuality_BlurFlag  );
+    SkAutoUnref aurL2(shadowLoopers[2]);
+    shadowLoopers[3] =
+        new SkBlurDrawLooper (5, -5 ,-10, 0x7FFF0000, 
+                              SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
+                              SkBlurDrawLooper::kOverrideColor_BlurFlag |
+                              SkBlurDrawLooper::kHighQuality_BlurFlag  );
+    SkAutoUnref aurL3(shadowLoopers[3]);
+    shadowLoopers[4] =
+        new SkBlurDrawLooper (0, 5, 5, 0xFF000000, 
+                              SkBlurDrawLooper::kIgnoreTransform_BlurFlag |
+                              SkBlurDrawLooper::kOverrideColor_BlurFlag |
+                              SkBlurDrawLooper::kHighQuality_BlurFlag  );
+    SkAutoUnref aurL4(shadowLoopers[4]);
+
+    for (int looper = 0; looper < 5; looper ++)
+    {
+        fRectShape.paint().setLooper(shadowLoopers[looper]);
+        canvas->resetMatrix();
+        canvas->translate(SkIntToScalar(looper*40), SkIntToScalar(0));
+        canvas->drawShape(&fRectShape);
+        fPaint.setLooper(shadowLoopers[looper]); 
+        canvas->translate(SkIntToScalar(0), SkIntToScalar(40));
+        canvas->drawPath(fCirclePath, fPaint);
+    }
+}
+
+private:
+    typedef GM INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new ShadowsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gpu/include/FlingState.h b/gpu/include/FlingState.h
new file mode 100644
index 0000000..a1da4fb
--- /dev/null
+++ b/gpu/include/FlingState.h
@@ -0,0 +1,59 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkFlingState_DEFINED
+#define SkFlingState_DEFINED
+
+#include "SkScalar.h"
+#include "SkPoint.h"
+
+class SkMatrix;
+
+struct FlingState {
+    FlingState() : fActive(false) {}
+
+    bool isActive() const { return fActive; }
+    void stop() { fActive = false; }
+
+    void reset(float sx, float sy);
+    bool evaluateMatrix(SkMatrix* matrix);
+
+private:
+    SkPoint     fDirection;
+    SkScalar    fSpeed0;
+    double      fTime0;
+    bool        fActive;
+};
+
+class GrAnimateFloat {
+public:
+    GrAnimateFloat();
+
+    void start(float v0, float v1, float duration);
+    bool isActive() const { return fTime0 != 0; }
+    void stop() { fTime0 = 0; }
+
+    float evaluate();
+
+private:
+    float   fValue0, fValue1, fDuration;
+    SkMSec  fTime0;
+};
+
+#endif
+
+
diff --git a/gpu/include/GrAllocPool.h b/gpu/include/GrAllocPool.h
new file mode 100644
index 0000000..251c0b4
--- /dev/null
+++ b/gpu/include/GrAllocPool.h
@@ -0,0 +1,71 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrAllocPool_DEFINED
+#define GrAllocPool_DEFINED
+
+#include "GrNoncopyable.h"
+
+class GrAllocPool : GrNoncopyable {
+public:
+    GrAllocPool(size_t blockSize = 0);
+    ~GrAllocPool();
+
+    /**
+     *  Frees all blocks that have been allocated with alloc().
+     */
+    void reset();
+
+    /**
+     *  Returns a block of memory bytes size big. This address must not be
+     *  passed to realloc/free/delete or any other function that assumes the
+     *  address was allocated by malloc or new (because it hasn't).
+     */
+    void* alloc(size_t bytes);
+    
+    /**
+     * Releases the most recently allocated bytes back to allocpool.
+     */
+    void release(size_t bytes);
+
+private:
+    struct Block;
+
+    Block*  fBlock;
+    size_t  fMinBlockSize;
+
+#if GR_DEBUG
+    int fBlocksAllocated;
+    void validate() const;
+#else
+    void validate() const {}
+#endif
+};
+
+template <typename T> class GrTAllocPool {
+public:
+    GrTAllocPool(int count) : fPool(count * sizeof(T)) {}
+
+    void reset() { fPool.reset(); }
+    T* alloc() { return (T*)fPool.alloc(sizeof(T)); }
+
+private:
+    GrAllocPool fPool;
+};
+
+#endif
+
diff --git a/gpu/include/GrAllocator.h b/gpu/include/GrAllocator.h
new file mode 100755
index 0000000..da02ba4
--- /dev/null
+++ b/gpu/include/GrAllocator.h
@@ -0,0 +1,230 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrAllocator_DEFINED
+#define GrAllocator_DEFINED
+
+#include "GrConfig.h"
+#include "GrTArray.h"
+
+class GrAllocator {
+public:
+    virtual ~GrAllocator() {
+        reset();
+    }
+
+    /**
+     * Create an allocator
+     *
+     * @param   itemSize        the size of each item to allocate
+     * @param   itemsPerBlock   the number of items to allocate at once
+     * @param   initialBlock    optional memory to use for the first block.
+     *                          Must be at least itemSize*itemsPerBlock sized.
+     *                          Caller is responsible for freeing this memory.
+     */
+    GrAllocator(size_t itemSize, uint32_t itemsPerBlock, void* initialBlock) :
+            fBlocks(fBlockInitialStorage, NUM_INIT_BLOCK_PTRS),
+            fItemSize(itemSize),
+            fItemsPerBlock(itemsPerBlock),
+            fOwnFirstBlock(NULL == initialBlock),
+            fCount(0) {
+        fBlockSize = fItemSize * fItemsPerBlock;
+        fBlocks.push_back() = initialBlock;
+        GR_DEBUGCODE(if (!fOwnFirstBlock) {*((char*)initialBlock+fBlockSize-1)='a';} );
+    }
+
+    /**
+     * Adds an item and returns pointer to it.
+     *
+     * @return pointer to the added item.
+     */
+    void* push_back() {        
+        uint32_t indexInBlock = fCount % fItemsPerBlock;
+        // we always have at least one block
+        if (0 == indexInBlock) {
+            if (0 != fCount) {
+                fBlocks.push_back() = GrMalloc(fBlockSize);
+            } else if (fOwnFirstBlock) {
+                fBlocks[0] = GrMalloc(fBlockSize);
+            }
+        }        
+        void* ret = (char*)fBlocks[fCount/fItemsPerBlock] + 
+                    fItemSize * indexInBlock;
+        ++fCount;
+        return ret;
+    }
+
+    /**
+     * removes all added items
+     */
+    void reset() {        
+        uint32_t blockCount = GrMax((unsigned)1, 
+                                    GrUIDivRoundUp(fCount, fItemsPerBlock));
+        for (uint32_t i = 1; i < blockCount; ++i) {
+            GrFree(fBlocks[i]);
+        }
+        if (fOwnFirstBlock) {
+            GrFree(fBlocks[0]);
+            fBlocks[0] = NULL;
+        }
+        fBlocks.pop_back_n(blockCount-1);
+        fCount = 0;
+    }
+
+    /**
+     * count of items
+     */
+    uint32_t count() const {
+        return fCount;
+    }
+    
+    /**
+     * is the count 0
+     */
+    bool empty() const { return fCount == 0; }
+    
+    /**
+     * access last item, only call if count() != 0
+     */
+    void* back() {
+        GrAssert(fCount);
+        return (*this)[fCount-1];
+    }
+    
+    /**
+     * access last item, only call if count() != 0
+     */
+    const void* back() const {
+        GrAssert(fCount);
+        return (*this)[fCount-1];
+    }
+    
+    /**
+     * access item by index.
+     */    
+    void* operator[] (uint32_t i) {
+        GrAssert(i < fCount);
+        return (char*)fBlocks[i / fItemsPerBlock] + 
+               fItemSize * (i % fItemsPerBlock);
+    }
+
+    /**
+     * access item by index.
+     */  
+    const void* operator[] (uint32_t i) const {
+        GrAssert(i < fCount);
+        return (const char*)fBlocks[i / fItemsPerBlock] + 
+               fItemSize * (i % fItemsPerBlock);
+    }
+
+private:
+    static const uint32_t NUM_INIT_BLOCK_PTRS = 8;
+    
+    GrTArray<void*> fBlocks;
+    size_t          fBlockSize;    
+    char            fBlockInitialStorage[NUM_INIT_BLOCK_PTRS*sizeof(void*)];    
+    size_t          fItemSize;
+    uint32_t        fItemsPerBlock;
+    bool            fOwnFirstBlock;
+    uint32_t        fCount;    
+};
+
+template <typename T>
+class GrTAllocator {
+private:
+    GrAllocator fAllocator;
+    
+public:
+    virtual ~GrTAllocator() {};
+    
+    /**
+     * Create an allocator
+     *
+     * @param   itemsPerBlock   the number of items to allocate at once
+     * @param   initialBlock    optional memory to use for the first block.
+     *                          Must be at least size(T)*itemsPerBlock sized.
+     *                          Caller is responsible for freeing this memory.
+     */
+    GrTAllocator(uint32_t itemsPerBlock, void* initialBlock) :
+        fAllocator(sizeof(T), itemsPerBlock, initialBlock)
+    {}
+    
+    /**
+     * Adds an item and returns it.
+     *
+     * @return the added item.
+     */
+    T& push_back() {
+        void* item = fAllocator.push_back();
+        GrAssert(NULL != item);
+        new (item) T;
+        return *(T*)item;
+    }
+    
+    /**
+     * removes all added items
+     */
+    void reset() {
+        uint32_t c = fAllocator.count();
+        for (uint32_t i = 0; i < c; ++i) {
+            ((T*)fAllocator[i])->~T();
+        }
+        fAllocator.reset();
+    }
+    
+    /**
+     * count of items
+     */
+    uint32_t count() const {
+        return fAllocator.count();
+    }
+    
+    /**
+     * is the count 0
+     */
+    bool empty() const { return fAllocator.empty(); }
+    
+    /**
+     * access last item, only call if count() != 0
+     */
+    T& back() {
+        return *(T*)fAllocator.back();
+    }
+
+    /**
+     * access last item, only call if count() != 0
+     */
+    const T& back() const {
+        return *(const T*)fAllocator.back();
+    }
+
+    /**
+     * access item by index.
+     */  
+    T& operator[] (uint32_t i) {
+        return *(T*)(fAllocator[i]);
+    }
+    
+    /**
+     * access item by index.
+     */
+    const T& operator[] (uint32_t i) const {
+        return *(const T*)(fAllocator[i]);
+    }    
+};
+
+#endif
diff --git a/gpu/include/GrAtlas.h b/gpu/include/GrAtlas.h
new file mode 100644
index 0000000..9526e0b
--- /dev/null
+++ b/gpu/include/GrAtlas.h
@@ -0,0 +1,88 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrAtlas_DEFINED
+#define GrAtlas_DEFINED
+
+#include "GrPoint.h"
+#include "GrTexture.h"
+#include "GrTDArray.h"
+
+class GrGpu;
+class GrRectanizer;
+class GrAtlasMgr;
+
+class GrAtlas {
+public:
+    GrAtlas(GrAtlasMgr*, int plotX, int plotY);
+
+    int getPlotX() const { return fPlot.fX; }
+    int getPlotY() const { return fPlot.fY; }
+
+    GrTexture* texture() const { return fTexture; }
+
+    bool addSubImage(int width, int height, const void*, GrIPoint16*);
+
+    static void FreeLList(GrAtlas* atlas) {
+        while (atlas) {
+            GrAtlas* next = atlas->fNext;
+            delete atlas;
+            atlas = next;
+        }
+    }
+
+    // testing
+    GrAtlas* nextAtlas() const { return fNext; }
+
+private:
+    ~GrAtlas(); // does not try to delete the fNext field
+
+    GrAtlas*        fNext;
+    GrTexture*      fTexture;
+    GrRectanizer*   fRects;
+    GrAtlasMgr*     fAtlasMgr;
+    GrIPoint16      fPlot;
+
+    friend class GrAtlasMgr;
+};
+
+class GrPlotMgr;
+
+class GrAtlasMgr {
+public:
+    GrAtlasMgr(GrGpu*);
+    ~GrAtlasMgr();
+
+    GrAtlas* addToAtlas(GrAtlas*, int width, int height, const void*,
+                        GrIPoint16*);
+
+    GrTexture* getTexture() const { return fTexture; }
+
+    // to be called by ~GrAtlas()
+    void freePlot(int x, int y);
+
+    void abandonAll();
+
+private:
+    GrGpu*      fGpu;
+    GrTexture*  fTexture;
+    GrPlotMgr*  fPlotMgr;
+};
+
+#endif
+
+
diff --git a/gpu/include/GrClip.h b/gpu/include/GrClip.h
new file mode 100644
index 0000000..54082b7
--- /dev/null
+++ b/gpu/include/GrClip.h
@@ -0,0 +1,147 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrClip_DEFINED
+#define GrClip_DEFINED
+
+#include "GrClipIterator.h"
+#include "GrRect.h"
+#include "GrPath.h"
+#include "GrTArray.h"
+
+
+class GrClip {
+public:
+    GrClip();
+    GrClip(const GrClip& src);
+    /**
+     *  If specified, the conservativeBounds parameter already takes (tx,ty)
+     *  into account.
+     */
+    GrClip(GrClipIterator* iter, GrScalar tx, GrScalar ty,
+           const GrRect* conservativeBounds = NULL);
+    GrClip(const GrIRect& rect);
+    GrClip(const GrRect& rect);
+
+    ~GrClip();
+
+    GrClip& operator=(const GrClip& src);
+
+    bool hasConservativeBounds() const { return fConservativeBoundsValid; }
+
+    const GrRect& getConservativeBounds() const { return fConservativeBounds; }
+
+    int getElementCount() const { return fList.count(); }
+
+    GrClipType getElementType(int i) const { return fList[i].fType; }
+
+    const GrPath& getPath(int i) const {
+        GrAssert(kPath_ClipType == fList[i].fType);
+        return fList[i].fPath;
+    }
+
+    GrPathFill getPathFill(int i) const {
+        GrAssert(kPath_ClipType == fList[i].fType);
+        return fList[i].fPathFill;
+    }
+
+    const GrRect& getRect(int i) const {
+        GrAssert(kRect_ClipType == fList[i].fType);
+        return fList[i].fRect;
+    }
+
+    GrSetOp getOp(int i) const { return fList[i].fOp; }
+
+    bool isRect() const {
+        if (1 == fList.count() && kRect_ClipType == fList[0].fType) {
+            // if we determined that the clip is a single rect
+            // we ought to have also used that rect as the bounds.
+            GrAssert(fConservativeBoundsValid);
+            GrAssert(fConservativeBounds == fList[0].fRect);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    bool isEmpty() const { return 0 == fList.count(); }
+
+    /**
+     *  Resets this clip to be empty
+     */
+    void setEmpty();
+
+    /**
+     *  If specified, the bounds parameter already takes (tx,ty) into account.
+     */
+    void setFromIterator(GrClipIterator* iter, GrScalar tx, GrScalar ty,
+                         const GrRect* conservativeBounds = NULL);
+    void setFromRect(const GrRect& rect);
+    void setFromIRect(const GrIRect& rect);
+
+    friend bool operator==(const GrClip& a, const GrClip& b) {
+        if (a.fList.count() != b.fList.count()) {
+            return false;
+        }
+        int count = a.fList.count();
+        for (int i = 0; i < count; ++i) {
+            if (a.fList[i] != b.fList[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    friend bool operator!=(const GrClip& a, const GrClip& b) {
+        return !(a == b);
+    }
+
+private:
+    struct Element {
+        GrClipType  fType;
+        GrRect      fRect;
+        GrPath      fPath;
+        GrPathFill  fPathFill;
+        GrSetOp     fOp;
+        bool operator ==(const Element& e) const {
+            if (e.fType != fType || e.fOp != fOp) {
+                return false;
+            }
+            switch (fType) {
+                case kRect_ClipType:
+                    return fRect == e.fRect;
+                    break;
+                case kPath_ClipType:
+                    return fPath == e.fPath;
+                default:
+                    GrCrash("Unknown clip element type.");
+                    return false; // suppress warning
+            }
+        }
+        bool operator !=(const Element& e) const { return !(*this == e); }
+    };
+
+    GrRect              fConservativeBounds;
+    bool                fConservativeBoundsValid;
+
+    enum {
+        kPreAllocElements = 4,
+    };
+    uint8_t             fListMemory[sizeof(Element) * kPreAllocElements];
+    GrTArray<Element>   fList;
+};
+#endif
+
diff --git a/gpu/include/GrClipIterator.h b/gpu/include/GrClipIterator.h
new file mode 100644
index 0000000..1fcbdd1
--- /dev/null
+++ b/gpu/include/GrClipIterator.h
@@ -0,0 +1,87 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrClipIterator_DEFINED
+#define GrClipIterator_DEFINED
+
+#include "GrPath.h"
+#include "GrRect.h"
+
+/**
+ * A clip is a list of paths and/or rects with set operations to combine them.
+ */
+class GrClipIterator {
+public:
+    virtual ~GrClipIterator() {}
+
+    /**
+     *  Returns true if there are no more rects to process
+     */
+    virtual bool isDone() const = 0;
+
+    /**
+     *  Rewind the iterator to replay the set of clip elements again
+     */
+    virtual void rewind() = 0;
+
+    /**
+     * Get the type of the current clip element
+     */
+    virtual GrClipType getType() const = 0;
+
+    /**
+     * Return the current path. It is an error to call this when isDone() is
+     * true or when getType() is kRect_Type.
+     */
+    virtual GrPathIter* getPathIter() = 0;
+
+    /**
+     * Return the fill rule for the path. It is an error to call this when
+     * isDone() is true or when getType is kRect_Type.
+     */
+    virtual GrPathFill getPathFill() const = 0;
+
+    /**
+    * Return the current rect. It is an error to call this when isDone is true
+    * or when getType() is kPath_Type.
+    */
+    virtual void getRect(GrRect* rect) const = 0;
+
+    /**
+     * Gets the operation used to apply the current item to previously iterated
+     * items. Iterators should not produce a Replace op.
+     */
+    virtual GrSetOp getOp() const = 0;
+
+    /**
+     *  Call to move to the next element in the list, previous path iter can be
+     *  made invalid.
+     */
+    virtual void next() = 0;
+};
+
+/**
+ *  Call to rewind iter, first checking to see if iter is NULL
+ */
+static inline void GrSafeRewind(GrClipIterator* iter) {
+    if (iter) {
+        iter->rewind();
+    }
+}
+
+#endif
+
diff --git a/gpu/include/GrColor.h b/gpu/include/GrColor.h
new file mode 100644
index 0000000..8dc03d2
--- /dev/null
+++ b/gpu/include/GrColor.h
@@ -0,0 +1,72 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrColor_DEFINED
+#define GrColor_DEFINED
+
+#include "GrTypes.h"
+
+/**
+ *  GrColor is 4 bytes for R, G, B, A, in a compile-time specific order. The
+ *  components are stored premultiplied.
+ */
+typedef uint32_t GrColor;
+
+// indices for address a GrColor as an array of bytes
+
+#define GrColor_INDEX_R     0
+#define GrColor_INDEX_G     1
+#define GrColor_INDEX_B     2
+#define GrColor_INDEX_A     3
+
+// shfit amount to assign a component to a GrColor int
+
+#define GrColor_SHIFT_R     0
+#define GrColor_SHIFT_G     8
+#define GrColor_SHIFT_B     16
+#define GrColor_SHIFT_A     24
+
+/**
+ *  Pack 4 components (RGBA) into a GrColor int
+ */
+static inline GrColor GrColorPackRGBA(unsigned r, unsigned g,
+                                      unsigned b, unsigned a) {
+    GrAssert((uint8_t)r == r);
+    GrAssert((uint8_t)g == g);
+    GrAssert((uint8_t)b == b);
+    GrAssert((uint8_t)a == a);
+    return  (r << GrColor_SHIFT_R) |
+            (g << GrColor_SHIFT_G) |
+            (b << GrColor_SHIFT_B) |
+            (a << GrColor_SHIFT_A);
+}
+
+// extract a component (byte) from a GrColor int
+
+#define GrColorUnpackR(color)   (((color) >> GrColor_SHIFT_R) & 0xFF)
+#define GrColorUnpackG(color)   (((color) >> GrColor_SHIFT_G) & 0xFF)
+#define GrColorUnpackB(color)   (((color) >> GrColor_SHIFT_B) & 0xFF)
+#define GrColorUnpackA(color)   (((color) >> GrColor_SHIFT_A) & 0xFF)
+
+/**
+ *  Since premultiplied means that alpha >= color, we construct a color with
+ *  each component==255 and alpha == 0 to be "illegal"
+ */
+#define GrColor_ILLEGAL     (~(0xFF << GrColor_SHIFT_A))
+
+#endif
+
diff --git a/gpu/include/GrConfig.h b/gpu/include/GrConfig.h
new file mode 100644
index 0000000..7805074
--- /dev/null
+++ b/gpu/include/GrConfig.h
@@ -0,0 +1,385 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrConfig_DEFINED
+#define GrConfig_DEFINED
+
+///////////////////////////////////////////////////////////////////////////////
+// preconfig section:
+//
+// All the work before including GrUserConfig.h should center around guessing
+// what platform we're on, and defining low-level symbols based on that.
+//
+// A build environment may have already defined symbols, so we first check
+// for that
+//
+
+// hack to ensure we know what sort of Apple platform we're on
+#if defined(__APPLE_CPP__) || defined(__APPLE_CC__)
+    #include <TargetConditionals.h>
+#endif
+
+/**
+ *  Gr defines are set to 0 or 1, rather than being undefined or defined
+ */
+
+#if !defined(GR_ANDROID_BUILD)
+    #define GR_ANDROID_BUILD    0
+#endif
+#if !defined(GR_IOS_BUILD)
+    #define GR_IOS_BUILD        0
+#endif
+#if !defined(GR_LINUX_BUILD)
+    #define GR_LINUX_BUILD      0
+#endif
+#if !defined(GR_MAC_BUILD)
+    #define GR_MAC_BUILD        0
+#endif
+#if !defined(GR_WIN32_BUILD)
+    #define GR_WIN32_BUILD      0
+#endif
+#if !defined(GR_QNX_BUILD)
+    #define GR_QNX_BUILD        0
+#endif
+
+/**
+ *  If no build target has been defined, attempt to infer.
+ */
+#if !GR_ANDROID_BUILD && !GR_IOS_BUILD && !GR_LINUX_BUILD && !GR_MAC_BUILD && !GR_WIN32_BUILD && !GR_QNX_BUILD
+    #if defined(_WIN32)
+        #undef GR_WIN32_BUILD
+        #define GR_WIN32_BUILD      1
+//      #error "WIN"
+    #elif TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+        #undef GR_IOS_BUILD
+        #define GR_IOS_BUILD        1
+//      #error "IOS"
+    #elif (defined(ANDROID_NDK) && ANDROID_NDK) || defined(ANDROID)
+        #undef GR_ANDROID_BUILD
+        #define GR_ANDROID_BUILD    1
+//      #error "ANDROID"
+    #elif TARGET_OS_MAC
+        #undef GR_MAC_BUILD
+        #define GR_MAC_BUILD        1
+//      #error "MAC"
+    #elif TARGET_OS_QNX || defined(__QNXNTO__)
+        #undef GR_QNX_BUILD
+        #define GR_QNX_BUILD        1
+//      #error "QNX"
+    #else
+        #undef GR_LINUX_BUILD
+        #define GR_LINUX_BUILD      1
+//      #error "LINUX"
+    #endif
+#endif
+
+// we need both GR_DEBUG and GR_RELEASE to be defined as 0 or 1
+//
+#ifndef GR_DEBUG
+    #ifdef GR_RELEASE
+        #define GR_DEBUG !GR_RELEASE
+    #else
+        #ifdef NDEBUG
+            #define GR_DEBUG    0
+        #else
+            #define GR_DEBUG    1
+        #endif
+    #endif
+#endif
+
+#ifndef GR_RELEASE
+    #define GR_RELEASE  !GR_DEBUG
+#endif
+
+#if GR_DEBUG == GR_RELEASE
+    #error "GR_DEBUG and GR_RELEASE must not be the same"
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ *  Pull stdint.h in before user-config, to be sure our __STDC... macros are
+ *  defined before anyone else might try to include stdint.h
+ */
+#define __STDC_LIMIT_MACROS
+#define __STDC_CONSTANT_MACROS
+#include <stdint.h>
+
+/*
+ *  The "user config" file can be empty, and everything should work. It is
+ *  meant to store a given platform/client's overrides of our guess-work.
+ *
+ *  A alternate user config file can be specified by defining
+ *  GR_USER_CONFIG_FILE. It should be defined relative to GrConfig.h
+ *
+ *  e.g. it can specify GR_DEBUG/GR_RELEASE as it please, change the BUILD
+ *  target, or supply its own defines for anything else (e.g. GR_SCALAR)
+ */
+#if !defined(GR_USER_CONFIG_FILE)
+    #include "GrUserConfig.h"
+#else
+    #include GR_USER_CONFIG_FILE
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// postconfig section:
+//
+// By now we must have a GR_..._BUILD symbol set to 1, and a decision about
+// debug -vs- release
+//
+
+extern void GrPrintf(const char format[], ...);
+
+/**
+ *  GR_STRING makes a string of X where X is expanded before conversion to a string
+ *  if X itself contains macros.
+ */
+#define GR_STRING(X) GR_STRING_IMPL(X)
+#define GR_STRING_IMPL(X) #X
+
+/**
+ *  GR_CONCAT concatenates X and Y  where each is expanded before
+ *  contanenation if either contains macros.
+ */
+#define GR_CONCAT(X,Y) GR_CONCAT_IMPL(X,Y)
+#define GR_CONCAT_IMPL(X,Y) X##Y
+
+/**
+ *  Creates a string of the form "<filename>(<linenumber>) : "
+ */
+#define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "
+
+/**
+ *  Compilers have different ways of issuing warnings. This macro
+ *  attempts to abstract them, but may need to be specialized for your
+ *  particular compiler.
+ *  To insert compiler warnings use "#pragma message GR_WARN(<string>)"
+ */
+#if defined(_MSC_VER) && _MSC_VER
+    #define GR_WARN(MSG) (GR_FILE_AND_LINE_STR "WARNING: " MSG)
+#else//__GNUC__ - may need other defines for different compilers
+    #define GR_WARN(MSG) ("WARNING: " MSG)
+#endif
+
+/**
+ *  GR_ALWAYSBREAK is an unconditional break in all builds.
+ */
+#if !defined(GR_ALWAYSBREAK)
+    #if     GR_WIN32_BUILD
+        #define GR_ALWAYSBREAK __debugbreak()
+    #else
+        // TODO: do other platforms really not have continuable breakpoints?
+        // sign extend for 64bit architectures to be sure this is
+        // in the high address range
+        #define GR_ALWAYSBREAK *((int*)(int64_t)(int32_t)0xbeefcafe) = 0;
+    #endif
+#endif
+
+/**
+ *  GR_DEBUGBREAK is an unconditional break in debug builds.
+ */
+#if !defined(GR_DEBUGBREAK)
+    #if GR_DEBUG
+        #define GR_DEBUGBREAK GR_ALWAYSBREAK
+    #else
+        #define GR_DEBUGBREAK
+    #endif
+#endif
+
+/**
+ *  GR_ALWAYSASSERT is an assertion in all builds.
+ */
+#if !defined(GR_ALWAYSASSERT)
+    #define GR_ALWAYSASSERT(COND)                                        \
+        do {                                                             \
+            if (!(COND)) {                                               \
+                GrPrintf("%s %s failed\n", GR_FILE_AND_LINE_STR, #COND); \
+                GR_ALWAYSBREAK;                                          \
+            }                                                            \
+        } while (false)
+#endif
+
+/**
+ *  GR_DEBUGASSERT is an assertion in debug builds only.
+ */
+#if !defined(GR_DEBUGASSERT)
+    #if GR_DEBUG
+        #define GR_DEBUGASSERT(COND) GR_ALWAYSASSERT(COND)
+    #else
+        #define GR_DEBUGASSERT(COND)
+    #endif
+#endif
+
+/**
+ *  Prettier forms of the above macros.
+ */
+#define GrAssert(COND) GR_DEBUGASSERT(COND)
+#define GrAlwaysAssert(COND) GR_ALWAYSASSERT(COND)
+
+/**
+ * Crash from unrecoverable condition, optionally with a message.
+ */
+inline void GrCrash() { GrAlwaysAssert(false); }
+inline void GrCrash(const char* msg) { GrPrintf(msg); GrAlwaysAssert(false); }
+
+/**
+ *  GR_DEBUGCODE compiles the code X in debug builds only
+ */
+#if !defined(GR_DEBUGCODE)
+    #if GR_DEBUG
+        #define GR_DEBUGCODE(X) X
+    #else
+        #define GR_DEBUGCODE(X)
+    #endif
+#endif
+
+/**
+ *  GR_STATIC_ASSERT is a compile time assertion. Depending on the platform
+ *  it may print the message in the compiler log. Obviously, the condition must
+ *  be evaluatable at compile time.
+ */
+// VS 2010 and GCC compiled with c++0x or gnu++0x support the new
+// static_assert.
+#if !defined(GR_STATIC_ASSERT)
+    #if (defined(_MSC_VER) && _MSC_VER >= 1600) || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)
+        #define GR_STATIC_ASSERT(CONDITION) static_assert(CONDITION, "bug")
+    #else
+        template <bool> class GR_STATIC_ASSERT_FAILURE;
+        template <> class GR_STATIC_ASSERT_FAILURE<true> {};
+        #define GR_STATIC_ASSERT(CONDITION) \
+            enum {GR_CONCAT(X,__LINE__) = \
+            sizeof(GR_STATIC_ASSERT_FAILURE<CONDITION>)}
+    #endif
+#endif
+
+#if !defined(GR_SCALAR_IS_FLOAT)
+    #define GR_SCALAR_IS_FLOAT   0
+#endif
+#if !defined(GR_SCALAR_IS_FIXED)
+    #define GR_SCALAR_IS_FIXED   0
+#endif
+
+#if !defined(GR_TEXT_SCALAR_TYPE_IS_USHORT)
+    #define GR_TEXT_SCALAR_TYPE_IS_USHORT  0
+#endif
+#if !defined(GR_TEXT_SCALAR_TYPE_IS_FLOAT)
+    #define GR_TEXT_SCALAR_TYPE_IS_FLOAT   0
+#endif
+#if !defined(GR_TEXT_SCALAR_TYPE_IS_FIXED)
+    #define GR_TEXT_SCALAR_TYPE_IS_FIXED   0
+#endif
+
+#ifndef GR_DUMP_TEXTURE_UPLOAD
+    #define GR_DUMP_TEXTURE_UPLOAD  0
+#endif
+
+/**
+ *  GR_COLLECT_STATS controls whether the GrGpu class collects stats.
+ *  If not already defined then collect in debug build but not release.
+ */
+#if !defined(GR_COLLECT_STATS)
+    #define GR_COLLECT_STATS GR_DEBUG
+#endif
+
+/**
+ *  GR_STATIC_RECT_VB controls whether rects are drawn by issuing a vertex
+ *  for each corner or using a static vb that is positioned by modifying the
+ *  view / texture matrix.
+ */
+#if !defined(GR_STATIC_RECT_VB)
+    #define GR_STATIC_RECT_VB 0
+#endif
+
+/**
+ *  GR_AGGRESSIVE_SHADER_OPTS controls how aggressively shaders are optimized
+ *  for special cases. On systems where program changes are expensive this
+ *  may not be advantageous. Consecutive draws may no longer use the same
+ *  program.
+ */
+#if !defined(GR_AGGRESSIVE_SHADER_OPTS)
+    #define GR_AGGRESSIVE_SHADER_OPTS 0
+#endif
+
+/**
+ * GR_GEOM_BUFFER_LOCK_THRESHOLD gives a threshold (in bytes) for when Gr should
+ * lock a GrGeometryBuffer to update its contents. It will use Lock() if the
+ * size of the udpated region is greater than the threshold. Otherwise it will
+ * use updateData() or updateSubData().
+ */
+#if !defined(GR_GEOM_BUFFER_LOCK_THRESHOLD)
+    #define GR_GEOM_BUFFER_LOCK_THRESHOLD (1 << 15)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// tail section:
+//
+// Now we just assert if we are missing some required define, or if we detect
+// and inconsistent combination of defines
+//
+
+
+/**
+ *  Only one build target macro should be 1 and the rest should be 0.
+ */
+#define GR_BUILD_SUM    (GR_WIN32_BUILD + GR_MAC_BUILD + GR_IOS_BUILD + GR_ANDROID_BUILD + GR_LINUX_BUILD + GR_QNX_BUILD)
+#if 0 == GR_BUILD_SUM
+    #error "Missing a GR_BUILD define"
+#elif 1 != GR_BUILD_SUM
+    #error "More than one GR_BUILD defined"
+#endif
+
+
+#if !GR_SCALAR_IS_FLOAT && !GR_SCALAR_IS_FIXED
+    #undef  GR_SCALAR_IS_FLOAT
+    #define GR_SCALAR_IS_FLOAT              1
+    #pragma message GR_WARN("Scalar type not defined, defaulting to float")
+#endif
+
+#if !GR_TEXT_SCALAR_IS_FLOAT && \
+    !GR_TEXT_SCALAR_IS_FIXED && \
+    !GR_TEXT_SCALAR_IS_USHORT
+    #undef  GR_TEXT_SCALAR_IS_FLOAT
+    #define GR_TEXT_SCALAR_IS_FLOAT         1
+    #pragma message GR_WARN("Text scalar type not defined, defaulting to float")
+#endif
+
+#if 0
+#if GR_WIN32_BUILD
+//    #pragma message GR_WARN("GR_WIN32_BUILD")
+#endif
+#if GR_MAC_BUILD
+//    #pragma message GR_WARN("GR_MAC_BUILD")
+#endif
+#if GR_IOS_BUILD
+//    #pragma message GR_WARN("GR_IOS_BUILD")
+#endif
+#if GR_ANDROID_BUILD
+//    #pragma message GR_WARN("GR_ANDROID_BUILD")
+#endif
+#if GR_LINUX_BUILD
+//    #pragma message GR_WARN("GR_LINUX_BUILD")
+#endif
+#if GR_QNX_BUILD
+//    #pragma message GR_WARN("GR_QNX_BUILD")
+#endif
+#endif
+
+#endif
+
diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
new file mode 100644
index 0000000..1f90603
--- /dev/null
+++ b/gpu/include/GrContext.h
@@ -0,0 +1,523 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrContext_DEFINED
+#define GrContext_DEFINED
+
+#include "GrClip.h"
+#include "GrGpu.h"
+#include "GrTextureCache.h"
+#include "GrPaint.h"
+
+class GrFontCache;
+class GrPathIter;
+class GrVertexBufferAllocPool;
+class GrIndexBufferAllocPool;
+class GrInOrderDrawBuffer;
+class GrPathRenderer;
+
+class GrContext : public GrRefCnt {
+public:
+    /**
+     * Creates a GrContext from within a 3D context.
+     */
+    static GrContext* Create(GrGpu::Engine engine,
+                             GrGpu::Platform3DContext context3D);
+
+    /**
+     *  Helper to create a opengl-shader based context
+     */
+    static GrContext* CreateGLShaderContext();
+
+    virtual ~GrContext();
+
+    /**
+     * The GrContext normally assumes that no outsider is setting state
+     * within the underlying 3D API's context/device/whatever. This call informs
+     * the context that the state was modified and it should resend. Shouldn't
+     * be called frequently for good performance.
+     */
+    void resetContext();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Textures
+
+    /**
+     *  Abandons all textures. Call this if you have lost the associated GPU
+     *  context, and thus internal texture references/IDs are now invalid.
+     */
+    void abandonAllTextures();
+
+    /**
+     *  Search for an entry with the same Key. If found, "lock" it and return it.
+     *  If not found, return null.
+     */
+    GrTextureEntry* findAndLockTexture(GrTextureKey*,
+                                       const GrSamplerState&);
+
+
+    /**
+     *  Create a new entry, based on the specified key and texture, and return
+     *  its "locked" entry.
+     *
+     *  Ownership of the texture is transferred to the Entry, which will unref()
+     *  it when we are purged or deleted.
+     */
+    GrTextureEntry* createAndLockTexture(GrTextureKey* key,
+                                         const GrSamplerState&,
+                                         const GrGpu::TextureDesc&,
+                                         void* srcData, size_t rowBytes);
+
+    /**
+     *  When done with an entry, call unlockTexture(entry) on it, which returns
+     *  it to the cache, where it may be purged.
+     */
+    void unlockTexture(GrTextureEntry* entry);
+
+    /**
+     *  Removes an texture from the cache. This prevents the texture from
+     *  being found by a subsequent findAndLockTexture() until it is
+     *  reattached. The entry still counts against the cache's budget and should
+     *  be reattached when exclusive access is no longer needed.
+     */
+    void detachCachedTexture(GrTextureEntry*);
+
+    /**
+     * Reattaches a texture to the cache and unlocks it. Allows it to be found
+     * by a subsequent findAndLock or be purged (provided its lock count is
+     * now 0.)
+     */
+    void reattachAndUnlockCachedTexture(GrTextureEntry*);
+
+    /**
+     * Creates a texture that is outside the cache. Does not count against
+     * cache's budget.
+     */
+    GrTexture* createUncachedTexture(const GrGpu::TextureDesc&,
+                                     void* srcData,
+                                     size_t rowBytes);
+
+    /**
+     *  Returns true if the specified use of an indexed texture is supported.
+     */
+    bool supportsIndex8PixelConfig(const GrSamplerState&, int width, int height);
+
+    /**
+     *  Return the current texture cache limits.
+     *
+     *  @param maxTextures If non-null, returns maximum number of textures that
+     *                     can be held in the cache.
+     *  @param maxTextureBytes If non-null, returns maximum number of bytes of
+     *                         texture memory that can be held in the cache.
+     */
+    void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const;
+
+    /**
+     *  Specify the texture cache limits. If the current cache exceeds either
+     *  of these, it will be purged (LRU) to keep the cache within these limits.
+     *
+     *  @param maxTextures The maximum number of textures that can be held in
+     *                     the cache.
+     *  @param maxTextureBytes The maximum number of bytes of texture memory
+     *                         that can be held in the cache.
+     */
+    void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes);
+
+    /**
+     *  Return the max width or height of a texture supported by the current gpu
+     */
+    int getMaxTextureDimension();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Render targets
+
+    /**
+     * Wraps an externally-created rendertarget in a GrRenderTarget.
+     * @param platformRenderTarget  3D API-specific render target identifier
+     *                              e.g. in GL platforamRenderTarget is an FBO
+     *                              id.
+     * @param stencilBits           the number of stencil bits that the render
+     *                              target has.
+     * @param width                 width of the render target.
+     * @param height                height of the render target.
+     */
+    GrRenderTarget* createPlatformRenderTarget(intptr_t platformRenderTarget,
+                                               int stencilBits,
+                                               int width, int height);
+
+    /**
+     * Reads the current target object (e.g. FBO or IDirect3DSurface9*) and
+     * viewport state from the underlying 3D API and wraps it in a
+     * GrRenderTarget. The GrRenderTarget will not attempt to delete/destroy the
+     * underlying object in its destructor and it is up to caller to guarantee
+     * that it remains valid while the GrRenderTarget is used.
+     *
+     * @return the newly created GrRenderTarget
+     */
+    GrRenderTarget* createRenderTargetFrom3DApiState() {
+        return fGpu->createRenderTargetFrom3DApiState();
+    }
+
+    /**
+     * Sets the render target.
+     * @param target    the render target to set. (should not be NULL.)
+     */
+    void setRenderTarget(GrRenderTarget* target);
+
+    /**
+     * Gets the current render target.
+     * @return the currently bound render target. Should never be NULL.
+     */
+    const GrRenderTarget* getRenderTarget() const;
+    GrRenderTarget* getRenderTarget();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Matrix state
+
+    /**
+     * Gets the current transformation matrix.
+     * @return the current matrix.
+     */
+    const GrMatrix& getMatrix() const;
+
+    /**
+     * Sets the transformation matrix.
+     * @param m the matrix to set.
+     */
+    void setMatrix(const GrMatrix& m);
+
+    /**
+     * Concats the current matrix. The passed matrix is applied before the
+     * current matrix.
+     * @param m the matrix to concat.
+     */
+    void concatMatrix(const GrMatrix& m) const;
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Clip state
+    /**
+     * Gets the current clip.
+     * @return the current clip.
+     */
+    const GrClip& getClip() const { return fGpu->getClip(); }
+
+    /**
+     * Sets the clip.
+     * @param clip  the clip to set.
+     */
+    void setClip(const GrClip& clip);
+
+    /**
+     * Convenience method for setting the clip to a rect.
+     * @param rect  the rect to set as the new clip.
+     */
+    void setClip(const GrIRect& rect);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Draws
+
+    /**
+     *  Erase the entire render target, ignoring any clips
+     */
+    void eraseColor(GrColor color);
+
+    /**
+     *  Draw everywhere (respecting the clip) with the paint.
+     */
+    void drawPaint(const GrPaint& paint);
+
+    /**
+     *  Draw the rect using a paint.
+     *  @param paint        describes how to color pixels.
+     *  @param strokeWidth  If strokeWidth < 0, then the rect is filled, else
+     *                      the rect is mitered stroked based on strokeWidth. If
+     *                      strokeWidth == 0, then the stroke is always a single
+     *                      pixel thick.
+     *  @param matrix       Optional matrix applied to the rect. Applied before
+     *                      context's matrix or the paint's matrix.
+     *  The rects coords are used to access the paint (through texture matrix)
+     */
+    void drawRect(const GrPaint& paint,
+                  const GrRect&,
+                  GrScalar strokeWidth = -1,
+                  const GrMatrix* matrix = NULL);
+
+    /**
+     * Maps a rect of paint coordinates onto the a rect of destination
+     * coordinates. Each rect can optionally be transformed. The srcRect
+     * is stretched over the dstRect. The dstRect is transformed by the
+     * context's matrix and the srcRect is transformed by the paint's matrix.
+     * Additional optional matrices can be provided by parameters.
+     *
+     * @param paint     describes how to color pixels.
+     * @param dstRect   the destination rect to draw.
+     * @param srcRect   rect of paint coordinates to be mapped onto dstRect
+     * @param dstMatrix Optional matrix to transform dstRect. Applied before
+     *                  context's matrix.
+     * @param srcMatrix Optional matrix to transform srcRect Applied before
+     *                  paint's matrix.
+     */
+    void drawRectToRect(const GrPaint& paint,
+                        const GrRect& dstRect,
+                        const GrRect& srcRect,
+                        const GrMatrix* dstMatrix = NULL,
+                        const GrMatrix* srcMatrix = NULL);
+
+    /**
+     * Draws a path.
+     *
+     * @param paint         describes how to color pixels.
+     * @param pathIter      the path to draw
+     * @param fill          the path filling rule to use.
+     * @param translate     optional additional translation applied to the
+     *                      path.
+     */
+    void drawPath(const GrPaint& paint,
+                  GrPathIter* pathIter,
+                  GrPathFill fill,
+                  const GrPoint* translate = NULL);
+    /**
+     * Helper version of drawPath that takes a GrPath
+     */
+    void drawPath(const GrPaint& paint,
+                  const GrPath& path,
+                  GrPathFill fill,
+                  const GrPoint* translate = NULL);
+    /**
+     * Draws vertices with a paint.
+     *
+     * @param   paint           describes how to color pixels.
+     * @param   primitiveType   primitives type to draw.
+     * @param   vertexCount     number of vertices.
+     * @param   positions       array of vertex positions, required.
+     * @param   texCoords       optional array of texture coordinates used
+     *                          to access the paint.
+     * @param   colors          optional array of per-vertex colors, supercedes
+     *                          the paint's color field.
+     * @param   indices         optional array of indices. If NULL vertices
+     *                          are drawn non-indexed.
+     * @param   indexCount      if indices is non-null then this is the
+     *                          number of indices.
+     */
+    void drawVertices(const GrPaint& paint,
+                      GrPrimitiveType primitiveType,
+                      int vertexCount,
+                      const GrPoint positions[],
+                      const GrPoint texs[],
+                      const GrColor colors[],
+                      const uint16_t indices[],
+                      int indexCount);
+
+    /**
+     * Similar to drawVertices but caller provides objects that convert to Gr
+     * types. The count of vertices is given by posSrc.
+     *
+     * @param   paint           describes how to color pixels.
+     * @param   primitiveType   primitives type to draw.
+     * @param   posSrc          Source of vertex positions. Must implement
+     *                              int count() const;
+     *                              void writeValue(int i, GrPoint* point) const;
+     *                          count returns the total number of vertices and
+     *                          writeValue writes a vertex position to point.
+     * @param   texSrc          optional, pass NULL to not use explicit tex
+     *                          coords. If present provides tex coords with
+     *                          method:
+     *                              void writeValue(int i, GrPoint* point) const;
+     * @param   texSrc          optional, pass NULL to not use per-vertex colors
+     *                          If present provides colors with method:
+     *                              void writeValue(int i, GrColor* point) const;
+     * @param   indices         optional, pass NULL for non-indexed drawing. If
+     *                          present supplies indices for indexed drawing
+     *                          with following methods:
+     *                              int count() const;
+     *                              void writeValue(int i, uint16_t* point) const;
+     *                          count returns the number of indices and
+     *                          writeValue supplies each index.
+     */
+    template <typename POS_SRC,
+              typename TEX_SRC,
+              typename COL_SRC,
+              typename IDX_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrPrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc,
+                            const COL_SRC* colorSrc,
+                            const IDX_SRC* idxSrc);
+    /**
+     * To avoid the problem of having to create a typename for NULL parameters,
+     * these reduced versions of drawCustomVertices are provided.
+     */
+    template <typename POS_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrPrimitiveType primitiveType,
+                            const POS_SRC& posSrc);
+    template <typename POS_SRC, typename TEX_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrPrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc);
+    template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
+    void drawCustomVertices(const GrPaint& paint,
+                            GrPrimitiveType primitiveType,
+                            const POS_SRC& posSrc,
+                            const TEX_SRC* texCoordSrc,
+                            const COL_SRC* colorSrc);
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Misc.
+
+    /**
+     * Flags that affect flush() behavior.
+     */
+    enum FlushBits {
+        /**
+         * A client may want Gr to bind a GrRenderTarget in the 3D API so that
+         * it can be rendered to directly. However, Gr lazily sets state. Simply
+         * calling setRenderTarget() followed by flush() without flags may not
+         * bind the render target. This flag forces the context to bind the last
+         * set render target in the 3D API.
+         */
+        kForceCurrentRenderTarget_FlushBit   = 0x1,
+        /**
+         * A client may reach a point where it has partially rendered a frame
+         * through a GrContext that it knows the user will never see. This flag
+         * causes the flush to skip submission of deferred content to the 3D API
+         * during the flush.
+         */
+        kDiscard_FlushBit                    = 0x2,
+    };
+
+    /**
+     * Call to ensure all drawing to the context has been issued to the
+     * underlying 3D API.
+     * @param flagsBitfield     flags that control the flushing behavior. See
+     *                          FlushBits.
+     */
+    void flush(int flagsBitfield);
+    /**
+     *  Return true on success, i.e. if we could copy the specified range of
+     *  pixels from the current render-target into the buffer, converting into
+     *  the specified pixel-config.
+     */
+    bool readPixels(int left, int top, int width, int height,
+                    GrTexture::PixelConfig, void* buffer);
+
+    /**
+     *  Copy the src pixels [buffer, stride, pixelconfig] into the current
+     *  render-target at the specified rectangle.
+     */
+    void writePixels(int left, int top, int width, int height,
+                     GrTexture::PixelConfig, const void* buffer, size_t stride);
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Statistics
+
+    void resetStats();
+
+    const GrGpu::Stats& getStats() const;
+
+    void printStats() const;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Helpers
+
+    class AutoRenderTarget : ::GrNoncopyable {
+    public:
+        AutoRenderTarget(GrContext* context, GrRenderTarget* target) {
+            fContext = NULL;
+            fPrevTarget = context->getRenderTarget();
+            if (fPrevTarget != target) {
+                context->setRenderTarget(target);
+                fContext = context;
+            }
+        }
+        ~AutoRenderTarget() {
+            if (fContext) {
+                fContext->setRenderTarget(fPrevTarget);
+            }
+        }
+    private:
+        GrContext*      fContext;
+        GrRenderTarget* fPrevTarget;
+    };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Functions intended for internal use only.
+    GrGpu* getGpu() { return fGpu; }
+    GrFontCache* getFontCache() { return fFontCache; }
+    GrDrawTarget* getTextTarget(const GrPaint& paint);
+    void flushText();
+    const GrIndexBuffer* getQuadIndexBuffer() const;
+
+private:
+    // used to keep track of when we need to flush the draw buffer
+    enum DrawCategory {
+        kBuffered_DrawCategory,      // last draw was inserted in draw buffer
+        kUnbuffered_DrawCategory,    // last draw was not inserted in the draw buffer
+        kText_DrawCategory           // text context was last to draw
+    };
+    DrawCategory fLastDrawCategory;
+
+    GrGpu*          fGpu;
+    GrTextureCache* fTextureCache;
+    GrFontCache*    fFontCache;
+    GrPathRenderer* fPathRenderer;
+
+    GrVertexBufferAllocPool*    fDrawBufferVBAllocPool;
+    GrIndexBufferAllocPool*     fDrawBufferIBAllocPool;
+    GrInOrderDrawBuffer*        fDrawBuffer;
+
+    GrContext(GrGpu* gpu);
+    void flushDrawBuffer();
+
+    static void SetPaint(const GrPaint& paint, GrDrawTarget* target);
+
+    bool finalizeTextureKey(GrTextureKey*, const GrSamplerState&) const;
+
+    GrDrawTarget* prepareToDraw(const GrPaint& paint, DrawCategory drawType);
+
+    void drawClipIntoStencil();
+};
+
+/**
+ *  Save/restore the view-matrix in the context.
+ */
+class GrAutoMatrix : GrNoncopyable {
+public:
+    GrAutoMatrix(GrContext* ctx) : fContext(ctx) {
+        fMatrix = ctx->getMatrix();
+    }
+    GrAutoMatrix(GrContext* ctx, const GrMatrix& matrix) : fContext(ctx) {
+        fMatrix = ctx->getMatrix();
+        ctx->setMatrix(matrix);
+    }
+    ~GrAutoMatrix() {
+        fContext->setMatrix(fMatrix);
+    }
+
+private:
+    GrContext*  fContext;
+    GrMatrix    fMatrix;
+};
+
+#endif
+
+#include "GrContext_impl.h"
diff --git a/gpu/include/GrContext_impl.h b/gpu/include/GrContext_impl.h
new file mode 100644
index 0000000..fdcb2b1
--- /dev/null
+++ b/gpu/include/GrContext_impl.h
@@ -0,0 +1,135 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrContext_impl_DEFINED
+#define GrContext_impl_DEFINED
+
+template <typename POS_SRC, typename TEX_SRC,
+          typename COL_SRC, typename IDX_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrPrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc,
+                                          const COL_SRC* colorSrc,
+                                          const IDX_SRC* idxSrc) {
+
+    GrVertexLayout layout = 0;
+
+    GrDrawTarget::AutoReleaseGeometry geo;
+
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    if (NULL != paint.getTexture()) {
+        if (NULL != texCoordSrc) {
+            layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+        } else {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        }
+    }
+
+    if (NULL != colorSrc) {
+        layout |= GrDrawTarget::kColor_VertexLayoutBit;
+    }
+
+    int vertexCount = posSrc.count();
+    int indexCount = (NULL != idxSrc) ? idxSrc->count() : 0;
+
+    if (!geo.set(target, layout, vertexCount, indexCount)) {
+        GrPrintf("Failed to get space for vertices!");
+        return;
+    }
+
+    int texOffsets[GrDrawTarget::kMaxTexCoords];
+    int colorOffset;
+    int vsize = GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
+                                                        texOffsets,
+                                                        &colorOffset);
+    void* curVertex = geo.vertices();
+
+    for (int i = 0; i < vertexCount; ++i) {
+        posSrc.writeValue(i, (GrPoint*)curVertex);
+
+        if (texOffsets[0] > 0) {
+            texCoordSrc->writeValue(i, (GrPoint*)((intptr_t)curVertex + texOffsets[0]));
+        }
+        if (colorOffset > 0) {
+            colorSrc->writeValue(i, (GrColor*)((intptr_t)curVertex + colorOffset));
+        }
+        curVertex = (void*)((intptr_t)curVertex + vsize);
+    }
+
+    uint16_t* indices = (uint16_t*) geo.indices();
+    for (int i = 0; i < indexCount; ++i) {
+        idxSrc->writeValue(i, indices + i);
+    }
+
+    if (NULL == idxSrc) {
+        target->drawNonIndexed(primitiveType, 0, vertexCount);
+    } else {
+        target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+    }
+}
+
+class GrNullTexCoordSource {
+public:
+    void writeValue(int i, GrPoint* dstCoord) const { GrAssert(false); }
+};
+
+class GrNullColorSource {
+public:
+    void writeValue(int i, GrColor* dstColor) const { GrAssert(false); }
+};
+
+class GrNullIndexSource {
+public:
+    void writeValue(int i, uint16_t* dstIndex) const { GrAssert(false); }
+    int count() const { GrAssert(false); return 0; }
+};
+
+template <typename POS_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrPrimitiveType primitiveType,
+                                          const POS_SRC& posSrc) {
+    this->drawCustomVertices<POS_SRC,
+                             GrNullTexCoordSource,
+                             GrNullColorSource,
+                             GrNullIndexSource>(paint, primitiveType, posSrc,
+                                                NULL, NULL, NULL);
+}
+
+template <typename POS_SRC, typename TEX_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrPrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc) {
+    this->drawCustomVertices<POS_SRC, TEX_SRC,
+                             GrNullColorSource,
+                             GrNullIndexSource>(paint, primitiveType, posSrc,
+                                                texCoordSrc, NULL, NULL);
+}
+
+template <typename POS_SRC, typename TEX_SRC, typename COL_SRC>
+inline void GrContext::drawCustomVertices(const GrPaint& paint,
+                                          GrPrimitiveType primitiveType,
+                                          const POS_SRC& posSrc,
+                                          const TEX_SRC* texCoordSrc,
+                                          const COL_SRC* colorSrc) {
+    drawCustomVertices<POS_SRC, TEX_SRC, COL_SRC,
+                       GrNullIndexSource>(paint, primitiveType, posSrc, 
+                                          texCoordSrc, colorSrc, NULL);
+}
+
+#endif
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
new file mode 100644
index 0000000..aef5937
--- /dev/null
+++ b/gpu/include/GrDrawTarget.h
@@ -0,0 +1,1059 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrDrawTarget_DEFINED
+#define GrDrawTarget_DEFINED
+
+#include "GrMatrix.h"
+#include "GrColor.h"
+#include "GrRefCnt.h"
+#include "GrSamplerState.h"
+#include "GrClip.h"
+#include "GrTexture.h"
+#include "GrStencil.h"
+
+class GrTexture;
+class GrClipIterator;
+class GrVertexBuffer;
+class GrIndexBuffer;
+
+class GrDrawTarget : public GrRefCnt {
+public:
+    /**
+     * 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
+     * per-vertex color or the constant color (setColor/setAlpha) if there are
+     * no per-vertex colors. For subsequent stages the input color is the output
+     * color from the previous enabled stage. The output color of each stage is
+     * the input color modulated with the result of a texture lookup. Texture
+     * lookups are specified by a texture a sampler (setSamplerState). Texture
+     * coordinates for each stage come from the vertices based on a
+     * GrVertexLayout bitfield. The output fragment color is the output color of
+     * the last enabled stage. The presence or absence of texture coordinates
+     * for each stage in the vertex layout indicates whether a stage is enabled
+     * or not.
+     */
+    enum {
+        kNumStages = 2,
+        kMaxTexCoords = kNumStages
+    };
+
+    /**
+     *  Bitfield used to indicate which stages are in use.
+     */
+    typedef int StageBitfield;
+    GR_STATIC_ASSERT(sizeof(StageBitfield)*8 >= kNumStages);
+
+    /**
+     *  Flags that affect rendering. Controlled using enable/disableState(). All
+     *  default to disabled.
+     */
+    enum StateBits {
+        kDither_StateBit          = 0x1,//<! Perform color dithering
+        kAntialias_StateBit       = 0x2,//<! Perform anti-aliasing. The render-
+                                        //   target must support some form of AA
+                                        //   (msaa, coverage sampling, etc). For
+                                        //   GrGpu-created rendertarget/textures
+                                        //   this is controlled by parameters
+                                        //   passed to createTexture.
+        kClip_StateBit            = 0x4,//<! Controls whether drawing is clipped
+                                        //   against the region specified by
+                                        //   setClip.
+        kNoColorWrites_StateBit   = 0x8,//<! If set it disables writing colors.
+                                        //   Useful while performing stencil ops.
+
+        // subclass may use additional bits internally
+        kDummyStateBit,
+        kLastPublicStateBit = kDummyStateBit-1
+    };
+
+    enum DrawFace {
+        kBoth_DrawFace,
+        kCCW_DrawFace,
+        kCW_DrawFace,
+    };
+
+    /**
+     * The DrawTarget may reserve some of the high bits of the stencil. The draw
+     * target will automatically trim reference and mask values so that the
+     * client doesn't overwrite these bits.
+     * The number of bits available is relative to the currently set render
+      *target.
+     * @return the number of bits usable by the draw target client.
+     */
+    int getUsableStencilBits() const {
+        int bits = fCurrDrawState.fRenderTarget->stencilBits();
+        if (bits) {
+            return bits - 1;
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * Sets the stencil settings to use for the next draw.
+     * Changing the clip has the side-effect of possibly zeroing
+     * out the client settable stencil bits. So multipass algorithms
+     * using stencil should not change the clip between passes.
+     * @param settings  the stencil settings to use.
+     */
+    void setStencil(const GrStencilSettings& settings) {
+        fCurrDrawState.fStencilSettings = settings;
+    }
+
+    /**
+     * Shortcut to disable stencil testing and ops.
+     */
+    void disableStencil() {
+        fCurrDrawState.fStencilSettings.setDisabled();
+    }
+
+protected:
+
+    struct DrState {
+        DrState() {
+            // make sure any pad is zero for memcmp
+            // all DrState members should default to something
+            // valid by the memset
+            memset(this, 0, sizeof(DrState));
+            GrAssert((intptr_t)(void*)NULL == 0LL);
+            GrAssert(fStencilSettings.isDisabled());
+        }
+        uint32_t                fFlagBits;
+        GrBlendCoeff            fSrcBlend;
+        GrBlendCoeff            fDstBlend;
+        GrTexture*              fTextures[kNumStages];
+        GrSamplerState          fSamplerStates[kNumStages];
+        GrRenderTarget*         fRenderTarget;
+        GrColor                 fColor;
+        DrawFace                fDrawFace;
+
+        GrStencilSettings       fStencilSettings;
+        GrMatrix                fViewMatrix;
+        bool operator ==(const DrState& s) const {
+            return 0 == memcmp(this, &s, sizeof(DrState));
+        }
+        bool operator !=(const DrState& s) const { return !(*this == s); }
+    };
+
+public:
+    ///////////////////////////////////////////////////////////////////////////
+
+    GrDrawTarget();
+
+    /**
+     * Sets the current clip to the region specified by clip. All draws will be
+     * clipped against this clip if kClip_StateBit is enabled.
+     *
+     * Setting the clip may (or may not) zero out the client's stencil bits.
+     *
+     * @param description of the clipping region
+     */
+    void setClip(const GrClip& clip);
+
+    /**
+     * Gets the current clip.
+     *
+     * @return the clip.
+     */
+    const GrClip& getClip() const;
+
+    /**
+     * Sets the texture used at the next drawing call
+     *
+     * @param stage The texture stage for which the texture will be set
+     *
+     * @param texture The texture to set. Can be NULL though there is no advantage
+     * to settings a NULL texture if doing non-textured drawing
+     */
+    void setTexture(int stage, GrTexture* texture);
+
+    /**
+     * Retrieves the currently set texture.
+     *
+     * @return    The currently set texture. The return value will be NULL if no
+     *            texture has been set, NULL was most recently passed to
+     *            setTexture, or the last setTexture was destroyed.
+     */
+    const GrTexture* getTexture(int stage) const;
+    GrTexture* getTexture(int stage);
+
+    /**
+     * Sets the rendertarget used at the next drawing call
+     *
+     * @param target  The render target to set.
+     */
+    void setRenderTarget(GrRenderTarget* target);
+
+    /**
+     * Retrieves the currently set rendertarget.
+     *
+     * @return    The currently set render target.
+     */
+    const GrRenderTarget* getRenderTarget() const;
+    GrRenderTarget* getRenderTarget();
+
+    /**
+     * Sets the sampler state for a stage used in subsequent draws.
+     *
+     * The sampler state determines how texture coordinates are
+     * intepretted and used to sample the texture.
+     *
+     * @param stage           the stage of the sampler to set
+     * @param samplerState    Specifies the sampler state.
+     */
+    void setSamplerState(int stage, const GrSamplerState& samplerState);
+
+    /**
+     * Concats the matrix of a stage's sampler.
+     *
+     * @param stage   the stage of the sampler to set
+     * @param matrix  the matrix to concat
+     */
+    void preConcatSamplerMatrix(int stage, const GrMatrix& matrix)  {
+        GrAssert(stage >= 0 && stage < kNumStages);
+        fCurrDrawState.fSamplerStates[stage].preConcatMatrix(matrix);
+    }
+
+    /**
+     * Gets the matrix of a stage's sampler
+     *
+     * @param stage     the stage to of sampler to get
+     * @return the sampler state's matrix
+     */
+    const GrMatrix& getSamplerMatrix(int stage) const {
+        return fCurrDrawState.fSamplerStates[stage].getMatrix();
+    }
+
+    /**
+     * Sets the matrix of a stage's sampler
+     *
+     * @param stage     the stage of sampler set
+     * @param matrix    the matrix to set
+     */
+    void setSamplerMatrix(int stage, const GrMatrix& matrix) {
+        fCurrDrawState.fSamplerStates[stage].setMatrix(matrix);
+    }
+
+    /**
+     * Sets the matrix applied to veretx positions.
+     *
+     * In the post-view-matrix space the rectangle [0,w]x[0,h]
+     * fully covers the render target. (w and h are the width and height of the
+     * the rendertarget.)
+     *
+     * @param m the matrix used to transform the vertex positions.
+     */
+    void setViewMatrix(const GrMatrix& m);
+
+    /**
+     *  Multiplies the current view matrix by a matrix
+     *
+     *  After this call V' = V*m where V is the old view matrix,
+     *  m is the parameter to this function, and V' is the new view matrix.
+     *  (We consider positions to be column vectors so position vector p is
+     *  transformed by matrix X as p' = X*p.)
+     *
+     *  @param m the matrix used to modify the view matrix.
+     */
+    void preConcatViewMatrix(const GrMatrix& m);
+
+    /**
+     * Retrieves the current view matrix
+     * @return the current view matrix.
+     */
+    const GrMatrix& getViewMatrix() const;
+
+    /**
+     *  Retrieves the inverse of the current view matrix.
+     *
+     *  If the current view matrix is invertible, return true, and if matrix
+     *  is non-null, copy the inverse into it. If the current view matrix is
+     *  non-invertible, return false and ignore the matrix parameter.
+     *
+     * @param matrix if not null, will receive a copy of the current inverse.
+     */
+    bool getViewInverse(GrMatrix* matrix) const;
+
+    /**
+     *  Sets color for next draw to a premultiplied-alpha color.
+     *
+     *  @param the color to set.
+     */
+    void setColor(GrColor);
+
+    /**
+     *  Sets the color to be used for the next draw to be
+     *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
+     *
+     *  @param alpha The alpha value to set as the color.
+     */
+    void setAlpha(uint8_t alpha);
+
+    /**
+     * Controls whether clockwise, counterclockwise, or both faces are drawn.
+     * @param face  the face(s) to draw.
+     */
+    void setDrawFace(DrawFace face) { fCurrDrawState.fDrawFace = face; }
+
+    /**
+     * Gets whether the target is drawing clockwise, counterclockwise,
+     * or both faces.
+     * @return the current draw face(s).
+     */
+    DrawFace getDrawFace() const { return fCurrDrawState.fDrawFace; }
+
+    /**
+     * Enable render state settings.
+     *
+     * @param flags   bitfield of StateBits specifing the states to enable
+     */
+    void enableState(uint32_t stateBits);
+
+    /**
+     * Disable render state settings.
+     *
+     * @param flags   bitfield of StateBits specifing the states to disable
+     */
+    void disableState(uint32_t stateBits);
+
+    bool isDitherState() const {
+        return 0 != (fCurrDrawState.fFlagBits & kDither_StateBit);
+    }
+
+    bool isClipState() const {
+        return 0 != (fCurrDrawState.fFlagBits & kClip_StateBit);
+    }
+
+    bool isColorWriteDisabled() const {
+        return 0 != (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit);
+    }
+
+    /**
+     * Sets the blending function coeffecients.
+     *
+     * The blend function will be:
+     *    D' = sat(S*srcCoef + D*dstCoef)
+     *
+     *   where D is the existing destination color, S is the incoming source
+     *   color, and D' is the new destination color that will be written. sat()
+     *   is the saturation function.
+     *
+     * @param srcCoef coeffecient applied to the src color.
+     * @param dstCoef coeffecient applied to the dst color.
+     */
+    void setBlendFunc(GrBlendCoeff srcCoef, GrBlendCoeff dstCoef);
+
+    /**
+     * Used to save and restore the GrGpu's drawing state
+     */
+    struct SavedDrawState {
+    private:
+        DrState fState;
+        friend class GrDrawTarget;
+    };
+
+    /**
+     * Saves the current draw state. The state can be restored at a later time
+     * with restoreDrawState.
+     *
+     * See also AutoStateRestore class.
+     *
+     * @param   state will hold the state after the function returns.
+     */
+    void saveCurrentDrawState(SavedDrawState* state) const;
+
+    /**
+     * Restores previously saved draw state. The client guarantees that state
+     * was previously passed to saveCurrentDrawState and that the rendertarget
+     * and texture set at save are still valid.
+     *
+     * See also AutoStateRestore class.
+     *
+     * @param   state the previously saved state to restore.
+     */
+    void restoreDrawState(const SavedDrawState& state);
+
+    /**
+     * Copies the draw state from another target to this target.
+     *
+     * @param srcTarget     draw target used as src of the draw state.
+     */
+    void copyDrawState(const GrDrawTarget& srcTarget);
+
+    /**
+     * The format of vertices is represented as a bitfield of flags.
+     * Flags that indicate the layout of vertex data. Vertices always contain
+     * positions and may also contain up to kMaxTexCoords sets of 2D texture
+     * coordinates and per-vertex colors. Each stage can use any of the texture
+     * coordinates as its input texture coordinates or it may use the positions.
+     *
+     * If no texture coordinates are specified for a stage then the stage is
+     * disabled.
+     *
+     * Only one type of texture coord can be specified per stage. For
+     * example StageTexCoordVertexLayoutBit(0, 2) and
+     * StagePosAsTexCoordVertexLayoutBit(0) cannot both be specified.
+     *
+     * The order in memory is always (position, texture coord 0, ..., color)
+     * 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]).
+     */
+
+    /**
+     * Generates a bit indicating that a texture stage uses texture coordinates
+     *
+     * @param stage       the stage that will use texture coordinates.
+     * @param texCoordIdx the index of the texture coordinates to use
+     *
+     * @return the bit to add to a GrVertexLayout bitfield.
+     */
+    static int StageTexCoordVertexLayoutBit(int stage, int texCoordIdx) {
+        GrAssert(stage < kNumStages);
+        GrAssert(texCoordIdx < kMaxTexCoords);
+        return 1 << (stage + (texCoordIdx * kNumStages));
+    }
+
+    /**
+     * Determines if blend is effectively disabled.
+     *
+     * @return true if blend can be disabled without changing the rendering
+     *  result given the current state including the vertex layout specified
+     *  with the vertex source.
+     */
+    bool canDisableBlend() const;
+
+private:
+    static const int TEX_COORD_BIT_CNT = kNumStages*kMaxTexCoords;
+public:
+    /**
+     * Generates a bit indicating that a texture stage uses the position
+     * as its texture coordinate.
+     *
+     * @param stage       the stage that will use position as texture
+     *                    coordinates.
+     *
+     * @return the bit to add to a GrVertexLayout bitfield.
+     */
+    static int StagePosAsTexCoordVertexLayoutBit(int stage) {
+        GrAssert(stage < kNumStages);
+        return (1 << (TEX_COORD_BIT_CNT + stage));
+    }
+private:
+    static const int STAGE_BIT_CNT = TEX_COORD_BIT_CNT + kNumStages;
+
+public:
+
+    /**
+     * Additional Bits that can be specified in GrVertexLayout.
+     */
+    enum VertexLayoutBits {
+
+        kColor_VertexLayoutBit              = 1 << (STAGE_BIT_CNT + 0),
+                                                //<! vertices have colors
+        kTextFormat_VertexLayoutBit         = 1 << (STAGE_BIT_CNT + 1),
+                                                //<! use text vertices. (Pos
+                                                //   and tex coords may be
+                                                //   a different type for
+                                                //   text [GrGpuTextVertex vs
+                                                //   GrPoint].)
+        // for below assert
+        kDummyVertexLayoutBit,
+        kHighVertexLayoutBit = kDummyVertexLayoutBit - 1
+    };
+    // make sure we haven't exceeded the number of bits in GrVertexLayout.
+    GR_STATIC_ASSERT(kHighVertexLayoutBit < (1 << 8*sizeof(GrVertexLayout)));
+
+    /**
+     * There are three paths for specifying geometry (vertices and optionally
+     * indices) to the draw target. When indexed drawing the indices and vertices
+     * can be each use a different path.
+     *
+     * 1. Provide a cpu array (set*SourceToArray). This is useful when the
+     *    caller's client has already provided vertex data in a format
+     *    the time compatible with a GrVertexLayout. The array must contain the
+     *    data at set*SourceToArray is called. The source stays in effect for
+     *    drawIndexed & drawNonIndexed calls until set*SourceToArray is called
+     *    again or one of the other two paths is chosen.
+     *
+     * 2. Reserve and Lock. This is most useful when the caller has data it must
+     *    transform before drawing and will not likely render it again. The
+     *    caller requests that the draw target make room for some amount of
+     *    vertex and/or index data. The target provides ptrs to hold the data
+     *    data. The caller can write the data into the pts up until the first
+     *    drawIndexed or drawNonIndexed call. At this point the data is frozen
+     *    and the ptrs are no longer guaranteed to be valid. All subsequent
+     *    drawIndexed & drawNonIndexed calls will use this data until
+     *    releaseReserved geometry is called. This must be called before another
+     *    source is set.
+     *
+     * 3. Vertex and Index Buffers. This is most useful for geometry that will
+     *    be rendered multiple times. SetVertexSourceToBuffer &
+     *    SetIndexSourceToBuffer are used to set the buffer and subsequent
+     *    drawIndexed and drawNonIndexed calls use this source until another
+     *    source is set.
+     */
+
+    /**
+     * Reserves space for vertices and/or indices. Draw target will use
+     * reserved vertices / indices at next draw.
+     *
+     * If succeeds:
+     *          if vertexCount is nonzero, *vertices will be the array
+     *          of vertices to be filled by caller. The next draw will read
+     *          these vertices.
+     *
+     *          if indecCount is nonzero, *indices will be the array of indices
+     *          to be filled by caller. The next indexed draw will read from
+     *          these indices.
+     *
+     * If a client does not already have a vertex buffer then this is the
+     * preferred way to allocate vertex/index array. It allows the subclass of
+     * GrDrawTarget to decide whether to put data in buffers, to group vertex
+     * data that uses the same state (e.g. for deferred rendering), etc.
+     *
+     * Following the first draw after reserveAndLockGeometry the ptrs returned
+     * by releaseReservedGeometry are no longer valid and the geometry data
+     * cannot be further modified. The contents that were put in the reserved
+     * space can be drawn by multiple draws, however.
+     *
+     * reserveAndLockGeometry must be matched with a releaseReservedGeometry
+     * call after all draws that reference the reserved geometry data have
+     * been called.
+     *
+     * AutoGeometryRelease can be used to automatically call the release.
+     *
+     * @param vertexCount  the number of vertices to reserve space for. Can be 0.
+     * @param indexCount   the number of indices to reserve space for. Can be 0.
+     * @param vertexLayout the format of vertices (ignored if vertexCount == 0).
+     * @param vertices     will point to reserved vertex space if vertexCount is
+     *                     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.
+     *
+     * @return  true if succeeded in allocating space for the vertices and false
+     *               if not.
+     */
+    bool reserveAndLockGeometry(GrVertexLayout    vertexLayout,
+                                uint32_t          vertexCount,
+                                uint32_t          indexCount,
+                                void**            vertices,
+                                void**            indices);
+    /**
+     * Provides hints to caller about the number of vertices and indices
+     * that can be allocated cheaply. This can be useful if caller is reserving
+     * space but doesn't know exactly how much geometry is needed.
+     *
+     * Also may hint whether the draw target should be flushed first. This is
+     * useful for deferred targets.
+     *
+     * @param vertexLayout layout of vertices caller would like to reserve
+     * @param vertexCount  in: hint about how many vertices the caller would
+     *                     like to allocate.
+     *                     out: a hint about the number of vertices that can be
+     *                     allocated cheaply. Negative means no hint.
+     *                     Ignored if NULL.
+     * @param indexCount   in: hint about how many indices the caller would
+     *                     like to allocate.
+     *                     out: a hint about the number of indices that can be
+     *                     allocated cheaply. Negative means no hint.
+     *                     Ignored if NULL.
+     *
+     * @return  true if target should be flushed based on the input values.
+     */
+    virtual bool geometryHints(GrVertexLayout vertexLayout,
+                               int* vertexCount,
+                               int* indexCount) const;
+
+    /**
+     * Releases reserved vertex/index data from reserveAndLockGeometry().
+     */
+    void releaseReservedGeometry();
+
+    /**
+     * Sets source of vertex data for the next draw. Array must contain
+     * the vertex data when this is called.
+     *
+     * @param array         cpu array containing vertex data.
+     * @param size          size of the vertex data.
+     * @param vertexCount   the number of vertices in the array.
+     */
+    void setVertexSourceToArray(GrVertexLayout vertexLayout,
+                                const void* vertexArray,
+                                int vertexCount);
+
+    /**
+     * Sets source of index data for the next indexed draw. Array must contain
+     * the indices when this is called.
+     *
+     * @param array         cpu array containing index data.
+     * @param indexCount    the number of indices in the array.
+     */
+    void setIndexSourceToArray(const void* indexArray, int indexCount);
+
+    /**
+     * Sets source of vertex data for the next draw. Data does not have to be
+     * in the buffer until drawIndexed or drawNonIndexed.
+     *
+     * @param buffer        vertex buffer containing vertex data. Must be
+     *                      unlocked before draw call.
+     * @param vertexLayout  layout of the vertex data in the buffer.
+     */
+    void setVertexSourceToBuffer(GrVertexLayout vertexLayout,
+                                 const GrVertexBuffer* buffer);
+
+    /**
+     * Sets source of index data for the next indexed draw. Data does not have
+     * to be in the buffer until drawIndexed or drawNonIndexed.
+     *
+     * @param buffer index buffer containing indices. Must be unlocked
+     *               before indexed draw call.
+     */
+    void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
+
+    /**
+     * Draws indexed geometry using the current state and current vertex / index
+     * sources.
+     *
+     * @param type         The type of primitives to draw.
+     * @param startVertex  the vertex in the vertex array/buffer corresponding
+     *                     to index 0
+     * @param startIndex   first index to read from index src.
+     * @param vertexCount  one greater than the max index.
+     * @param indexCount   the number of index elements to read. The index count
+     *                     is effectively trimmed to the last completely
+     *                     specified primitive.
+     */
+    virtual void drawIndexed(GrPrimitiveType type,
+                             int startVertex,
+                             int startIndex,
+                             int vertexCount,
+                             int indexCount) = 0;
+
+    /**
+     * Draws non-indexed geometry using the current state and current vertex
+     * sources.
+     *
+     * @param type         The type of primitives to draw.
+     * @param startVertex  the vertex in the vertex array/buffer corresponding
+     *                     to index 0
+     * @param vertexCount  one greater than the max index.
+     */
+    virtual void drawNonIndexed(GrPrimitiveType type,
+                                int startVertex,
+                                int vertexCount)  = 0;
+
+    /**
+     * Helper function for drawing rects. This does not use the current index
+     * and vertex sources. After returning, the vertex and index sources may
+     * have changed. They should be reestablished before the next drawIndexed
+     * or drawNonIndexed. This cannot be called between reserving and releasing
+     * geometry. The GrDrawTarget subclass may be able to perform additional
+     * optimizations if drawRect is used rather than drawIndexed or
+     * drawNonIndexed.
+     * @param rect      the rect to draw
+     * @param matrix    optional matrix applied to rect (before viewMatrix)
+     * @param stageEnableBitfield bitmask indicating which stages are enabled.
+     *                            Bit i indicates whether stage i is enabled.
+     * @param srcRects  specifies rects for stages enabled by stageEnableMask.
+     *                  if stageEnableMask bit i is 1, srcRects is not NULL,
+     *                  and srcRects[i] is not NULL, then srcRects[i] will be
+     *                  used as coordinates for stage i. Otherwise, if stage i
+     *                  is enabled then rect is used as the coordinates.
+     * @param srcMatrices   optional matrices applied to srcRects. If
+     *                      srcRect[i] is non-NULL and srcMatrices[i] is
+     *                      non-NULL then srcRect[i] will be transformed by
+     *                      srcMatrix[i]. srcMatrices can be NULL when no
+     *                      srcMatrices are desired.
+     */
+    virtual void drawRect(const GrRect& rect,
+                          const GrMatrix* matrix,
+                          StageBitfield stageEnableBitfield,
+                          const GrRect* srcRects[],
+                          const GrMatrix* srcMatrices[]);
+
+    /**
+     * Helper for drawRect when the caller doesn't need separate src rects or
+     * matrices.
+     */
+    void drawSimpleRect(const GrRect& rect,
+                        const GrMatrix* matrix,
+                        StageBitfield stageEnableBitfield) {
+         drawRect(rect, matrix, stageEnableBitfield, NULL, NULL);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class AutoStateRestore : ::GrNoncopyable {
+    public:
+        AutoStateRestore(GrDrawTarget* target);
+        ~AutoStateRestore();
+
+    private:
+        GrDrawTarget*       fDrawTarget;
+        SavedDrawState      fDrawState;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class AutoViewMatrixRestore : ::GrNoncopyable {
+    public:
+        AutoViewMatrixRestore() {
+            fDrawTarget = NULL;
+        }
+
+        AutoViewMatrixRestore(GrDrawTarget* target)
+            : fDrawTarget(target), fMatrix(fDrawTarget->getViewMatrix()) {
+            GrAssert(NULL != target);
+        }
+
+        void set(GrDrawTarget* target) {
+            GrAssert(NULL != target);
+            if (NULL != fDrawTarget) {
+                fDrawTarget->setViewMatrix(fMatrix);
+            }
+            fDrawTarget = target;
+            fMatrix = target->getViewMatrix();
+        }
+
+        ~AutoViewMatrixRestore() {
+            if (NULL != fDrawTarget) {
+                fDrawTarget->setViewMatrix(fMatrix);
+            }
+        }
+
+    private:
+        GrDrawTarget*       fDrawTarget;
+        GrMatrix            fMatrix;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class AutoReleaseGeometry : ::GrNoncopyable {
+    public:
+        AutoReleaseGeometry(GrDrawTarget*  target,
+                            GrVertexLayout vertexLayout,
+                            uint32_t       vertexCount,
+                            uint32_t       indexCount) {
+            fTarget = target;
+            fSuccess = fTarget->reserveAndLockGeometry(vertexLayout,
+                                                       vertexCount,
+                                                       indexCount,
+                                                       &fVertices,
+                                                       &fIndices);
+        }
+
+        AutoReleaseGeometry() {
+            fSuccess = false;
+        }
+
+        ~AutoReleaseGeometry() {
+            if (fSuccess) {
+                fTarget->releaseReservedGeometry();
+            }
+        }
+
+        bool set(GrDrawTarget*  target,
+                 GrVertexLayout vertexLayout,
+                 uint32_t       vertexCount,
+                 uint32_t       indexCount) {
+            if (fSuccess) {
+                fTarget->releaseReservedGeometry();
+            }
+            fTarget = target;
+            fSuccess = fTarget->reserveAndLockGeometry(vertexLayout,
+                                                       vertexCount,
+                                                       indexCount,
+                                                       &fVertices,
+                                                       &fIndices);
+            return fSuccess;
+        }
+
+        bool succeeded() const { return fSuccess; }
+        void* vertices() const { return fVertices; }
+        void* indices() const { return fIndices; }
+
+        GrPoint* positions() const {
+            return static_cast<GrPoint*>(fVertices);
+        }
+
+    private:
+        GrDrawTarget* fTarget;
+        bool          fSuccess;
+        void*         fVertices;
+        void*         fIndices;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class AutoClipRestore : ::GrNoncopyable {
+    public:
+        AutoClipRestore(GrDrawTarget* target) {
+            fTarget = target;
+            fClip = fTarget->getClip();
+        }
+
+        ~AutoClipRestore() {
+            fTarget->setClip(fClip);
+        }
+    private:
+        GrDrawTarget* fTarget;
+        GrClip        fClip;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Helpers for picking apart vertex layouts
+
+    /**
+     * Helper function to compute the size of a vertex from a vertex layout
+     * @return size of a single vertex.
+     */
+    static size_t VertexSize(GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function for determining the index of texture coordinates that
+     * is input for a texture stage. Note that a stage may instead use positions
+     * as texture coordinates, in which case the result of the function is
+     * indistinguishable from the case when the stage is disabled.
+     *
+     * @param stage         the stage to query
+     * @param vertexLayout  layout to query
+     *
+     * @return the texture coordinate index or -1 if the stage doesn't use
+     *         separate (non-position) texture coordinates.
+     */
+    static int VertexTexCoordsForStage(int stage, GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function to compute the offset of texture coordinates in a vertex
+     * @return offset of texture coordinates in vertex layout or -1 if the
+     *         layout has no texture coordinates. Will be 0 if positions are
+     *         used as texture coordinates for the stage.
+     */
+    static int VertexStageCoordOffset(int stage, GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function to compute the offset of the color in a vertex
+     * @return offset of color in vertex layout or -1 if the
+     *         layout has no color.
+     */
+    static int VertexColorOffset(GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function to determine if vertex layout contains explicit texture
+     * coordinates of some index.
+     *
+     * @param coordIndex    the tex coord index to query
+     * @param vertexLayout  layout to query
+     *
+     * @return true if vertex specifies texture coordinates for the index,
+     *              false otherwise.
+     */
+    static bool VertexUsesTexCoordIdx(int coordIndex,
+                                      GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function to determine if vertex layout contains either explicit or
+     * implicit texture coordinates for a stage.
+     *
+     * @param stage         the stage to query
+     * @param vertexLayout  layout to query
+     *
+     * @return true if vertex specifies texture coordinates for the stage,
+     *              false otherwise.
+     */
+    static bool VertexUsesStage(int stage, GrVertexLayout vertexLayout);
+
+    /**
+     * Helper function to compute the size of each vertex and the offsets of
+     * texture coordinates and color. Determines tex coord offsets by tex coord
+     * index rather than by stage. (Each stage can be mapped to any t.c. index
+     * by StageTexCoordVertexLayoutBit.)
+     *
+     * @param vertexLayout          the layout to query
+     * @param texCoordOffsetsByIdx  after return it is the offset of each
+     *                              tex coord index in the vertex or -1 if
+     *                              index isn't used.
+     * @return size of a single vertex
+     */
+    static int VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
+                                         int texCoordOffsetsByIdx[kMaxTexCoords],
+                                         int *colorOffset);
+
+    /**
+     * Helper function to compute the size of each vertex and the offsets of
+     * texture coordinates and color. Determines tex coord offsets by stage
+     * rather than by index. (Each stage can be mapped to any t.c. index
+     * by StageTexCoordVertexLayoutBit.) If a stage uses positions for
+     * tex coords then that stage's offset will be 0 (positions are always at 0).
+     *
+     * @param vertexLayout              the layout to query
+     * @param texCoordOffsetsByStage    after return it is the offset of each
+     *                                  tex coord index in the vertex or -1 if
+     *                                  index isn't used.
+     * @return size of a single vertex
+     */
+    static int VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
+                                           int texCoordOffsetsByStage[kNumStages],
+                                           int *colorOffset);
+
+    /**
+     * Accessing positions, texture coords, or colors, of a vertex within an
+     * array is a hassle involving casts and simple math. These helpers exist
+     * to keep GrDrawTarget clients' code a bit nicer looking.
+     */
+
+    /**
+     * Gets a pointer to a GrPoint of a vertex's position or texture
+     * coordinate.
+     * @param vertices      the vetex array
+     * @param vertexIndex   the index of the vertex in the array
+     * @param vertexSize    the size of each vertex in the array
+     * @param offset        the offset in bytes of the vertex component.
+     *                      Defaults to zero (corresponding to vertex position)
+     * @return pointer to the vertex component as a GrPoint
+     */
+    static GrPoint* GetVertexPoint(void* vertices,
+                                   int vertexIndex,
+                                   int vertexSize,
+                                   int offset = 0) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<GrPoint*>(start + offset +
+                                 vertexIndex * vertexSize);
+    }
+    static const GrPoint* GetVertexPoint(const void* vertices,
+                                         int vertexIndex,
+                                         int vertexSize,
+                                         int offset = 0) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<const GrPoint*>(start + offset +
+                                       vertexIndex * vertexSize);
+    }
+
+    /**
+     * Gets a pointer to a GrColor inside a vertex within a vertex array.
+     * @param vertices      the vetex array
+     * @param vertexIndex   the index of the vertex in the array
+     * @param vertexSize    the size of each vertex in the array
+     * @param offset        the offset in bytes of the vertex color
+     * @return pointer to the vertex component as a GrColor
+     */
+    static GrColor* GetVertexColor(void* vertices,
+                                   int vertexIndex,
+                                   int vertexSize,
+                                   int offset) {
+        intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<GrColor*>(start + offset +
+                                 vertexIndex * vertexSize);
+    }
+    static const GrColor* GetVertexColor(const void* vertices,
+                                         int vertexIndex,
+                                         int vertexSize,
+                                         int offset) {
+        const intptr_t start = GrTCast<intptr_t>(vertices);
+        return GrTCast<const GrColor*>(start + offset +
+                                       vertexIndex * vertexSize);
+    }
+
+    static void VertexLayoutUnitTest();
+
+protected:
+
+    // Helpers for GrDrawTarget subclasses that won't have private access to
+    // SavedDrawState but need to peek at the state values.
+    static DrState& accessSavedDrawState(SavedDrawState& sds)
+                                                        { return sds.fState; }
+    static const DrState& accessSavedDrawState(const SavedDrawState& sds)
+                                                        { return sds.fState; }
+
+    // implemented by subclass
+    virtual bool acquireGeometryHelper(GrVertexLayout vertexLayout,
+                                       void** vertices,
+                                       void** indices) = 0;
+
+    virtual void releaseGeometryHelper() = 0;
+
+    // subclass overrides to be notified when clip is set.
+    virtual void clipWillBeSet(const GrClip& clip) = 0;
+
+    virtual void setVertexSourceToArrayHelper(const void* vertexArray,
+                                              int vertexCount) = 0;
+
+    virtual void setIndexSourceToArrayHelper(const void* indexArray,
+                                             int indexCount) = 0;
+
+    // Helpers for drawRect, protected so subclasses that override drawRect
+    // can use them.
+    static GrVertexLayout GetRectVertexLayout(StageBitfield stageEnableBitfield,
+                                              const GrRect* srcRects[]);
+
+    static void SetRectVertices(const GrRect& rect,
+                                const GrMatrix* matrix,
+                                const GrRect* srcRects[],
+                                const GrMatrix* srcMatrices[],
+                                GrVertexLayout layout,
+                                void* vertices);
+
+    enum GeometrySrcType {
+        kReserved_GeometrySrcType,  // src was set using reserveAndLockGeometry
+        kArray_GeometrySrcType,     // src was set using set*SourceToArray
+        kBuffer_GeometrySrcType     // src was set using set*SourceToBuffer
+    };
+
+    struct ReservedGeometry {
+        bool            fLocked;
+        uint32_t        fVertexCount;
+        uint32_t        fIndexCount;
+    } fReservedGeometry;
+
+    struct GeometrySrc {
+        GeometrySrcType         fVertexSrc;
+        const GrVertexBuffer*   fVertexBuffer; // valid if src type is buffer
+        GeometrySrcType         fIndexSrc;
+        const GrIndexBuffer*    fIndexBuffer; // valid if src type is buffer
+        GrVertexLayout          fVertexLayout;
+    } fGeometrySrc;
+
+    GrClip fClip;
+
+    DrState fCurrDrawState;
+
+    // Not meant for external use. Only setVertexSourceToBuffer and
+    // setIndexSourceToBuffer will work since GrDrawTarget subclasses don't
+    // support nested reserveAndLockGeometry (and cpu arrays internally use the
+    // same path).
+    class AutoGeometrySrcRestore {
+    public:
+        AutoGeometrySrcRestore(GrDrawTarget* target) {
+            fTarget = target;
+            fGeometrySrc = fTarget->fGeometrySrc;
+        }
+        ~AutoGeometrySrcRestore() {
+            fTarget->fGeometrySrc = fGeometrySrc;
+        }
+    private:
+        GrDrawTarget *fTarget;
+        GeometrySrc  fGeometrySrc;
+
+        AutoGeometrySrcRestore();
+        AutoGeometrySrcRestore(const AutoGeometrySrcRestore&);
+        AutoGeometrySrcRestore& operator =(AutoGeometrySrcRestore&);
+    };
+};
+
+#endif
diff --git a/gpu/include/GrFontScaler.h b/gpu/include/GrFontScaler.h
new file mode 100644
index 0000000..6baa56f
--- /dev/null
+++ b/gpu/include/GrFontScaler.h
@@ -0,0 +1,43 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrFontScaler_DEFINED
+#define GrFontScaler_DEFINED
+
+#include "GrGlyph.h"
+#include "GrKey.h"
+
+class GrPath;
+
+/**
+ *  This is a virtual base class which Gr's interface to the host platform's
+ *  font scaler.
+ *
+ *  The client is responsible for subclassing, and instantiating this. The
+ *  instance is create for a specific font+size+matrix.
+ */
+class GrFontScaler : public GrRefCnt {
+public:
+    virtual const GrKey* getKey() = 0;
+    virtual bool getPackedGlyphBounds(GrGlyph::PackedID, GrIRect* bounds) = 0;
+    virtual bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
+                                     int rowBytes, void* image) = 0;
+    virtual bool getGlyphPath(uint16_t glyphID, GrPath*) = 0;
+};
+
+#endif
+
diff --git a/gpu/include/GrGLConfig.h b/gpu/include/GrGLConfig.h
new file mode 100644
index 0000000..c467f99
--- /dev/null
+++ b/gpu/include/GrGLConfig.h
@@ -0,0 +1,423 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGLConfig_DEFINED
+#define GrGLConfig_DEFINED
+
+#include "GrTypes.h"
+
+#if !defined(GR_GL_CUSTOM_SETUP)
+    #define GR_GL_CUSTOM_SETUP 0
+#endif
+/**
+ * We need to pull in the right GL headers and determine whether we are
+ * compiling for ES1, ES2, or desktop GL. (We allow ES1 and ES2 to both be
+ * supported in the same build but not ESx and desktop). We also need to know
+ * the platform-specific way to get extension function pointers (e.g.
+ * eglGetProcAddress). The port specifies this info explicitly or we will infer
+ * it from the GR_*_BUILD flag.
+ *
+ * To specify GL setup directly define GR_GL_CUSTOM_SETUP to 1 and define:
+ *      GR_SUPPORT_GLDESKTOP or (GR_SUPPORT_GLES1 and/or GR_SUPPORT_GLES2) to 1
+ *
+ *      if GR_SUPPORT_GLDESKTOP is 1 then provide:
+ *          1. The name of your GL header in GR_INCLUDE_GLDESKTOP
+ *          2. If necessary, the name of a file that includes extension
+ *             definitions in GR_INCLUDE_GLDESKTOPext.
+ *      if GR_SUPPORT_GLES1 is 1 then provide:
+ *          1. The name of your GL header in GR_INCLUDE_GLES1
+ *          2. If necessary, the name of a file that includes extension
+ *             definitions in GR_INCLUDE_GLES1ext.
+ *      if GR_SUPPORT_GLES2 is 1 then provide:
+ *          1. The name of your GL header in GR_INCLUDE_GLES2
+ *          2. If necessary, the name of a file that includes extension
+ *             definitions in GR_INCLUDE_GLES2ext.
+ *
+ *      Optionally, define GR_GL_FUNC to any qualifier needed on GL function
+ *      pointer declarations (e.g. __stdcall).
+ *
+ *      Define GR_GL_PROC_ADDRESS to take a gl function and produce a
+ *      function pointer. Two examples:
+ *          1. Your platform doesn't require a proc address function, just take
+ *             the address of the function:
+ *             #define GR_GL_PROC_ADDRESS(X) &X
+ *          2. Your platform uses eglGetProcAddress:
+ *             #define GR_GL_PROC_ADDRESS eglGetProcAddress(#X)
+ *
+ *     Optionally define GR_GL_PROC_ADDRESS_HEADER to include any additional
+ *     header necessary to use GR_GL_PROC_ADDRESS (e.g. <EGL/egl.h>)
+ *
+ * Alternatively, define GR_GL_CUSTOM_SETUP_HEADER (and not GR_GL_CUSTOM_SETUP)
+ * to a header that can be included. This file should:
+ *      1. Define the approprate GR_SUPPORT_GL* macro(s) to 1
+ *      2. Includes all necessary GL headers.
+ *      3. Optionally define GR_GL_FUNC.
+ *      4. Define GR_GL_PROC_ADDRESS.
+ *      5. Optionally define GR_GL_PROC_ADDRESS_HEADER
+ *
+ *------------------------------------------------------------------------------
+ *
+ * The following are optional defines that can be enabled at the compiler
+ * command line, in a IDE project, in a GrUserConfig.h file, or in a GL custom
+ * file (if one is in use). They don't require GR_GL_CUSTOM_SETUP or
+ * setup GR_GL_CUSTOM_SETUP_HEADER to be enabled:
+ *
+ * GR_GL_LOG_CALLS: if 1 Gr can print every GL call using GrPrintf. Defaults to
+ * 0. Logging can be enabled and disabled at runtime using a debugger via to
+ * global gLogCallsGL. The initial value of gLogCallsGL is controlled by
+ * GR_GL_LOG_CALLS_START.
+ *
+ * GR_GL_LOG_CALLS_START: controls the initial value of gLogCallsGL when
+ * GR_GL_LOG_CALLS is 1. Defaults to 0.
+ *
+ * GR_GL_CHECK_ERROR: if enabled Gr can do a glGetError() after every GL call.
+ * Defaults to 1 if GR_DEBUG is set, otherwise 0. When GR_GL_CHECK_ERROR is 1
+ * this can be toggled in a debugger using the gCheckErrorGL global. The initial
+ * value of gCheckErrorGL is controlled by by GR_GL_CHECK_ERROR_START.
+ *
+ * GR_GL_CHECK_ERROR_START: controls the initial value of gCheckErrorGL
+ * when GR_GL_CHECK_ERROR is 1.  Defaults to 1.
+ */
+
+#if GR_GL_CUSTOM_SETUP
+
+    #ifdef GR_SUPPORT_GLES1
+        #include GR_INCLUDE_GLES1
+        #if defined(GR_INCLUDE_GLES1ext)
+            #include GR_INCLUDE_GLES1ext
+        #endif
+    #endif
+
+    #ifdef GR_SUPPORT_GLES2
+        #include GR_INCLUDE_GLES2
+        #if defined(GR_INCLUDE_GLES2ext)
+            #include GR_INCLUDE_GLES2ext
+        #endif
+    #endif
+
+    #ifdef GR_SUPPORT_GLDESKTOP
+        #include GR_INCLUDE_GLDESKTOP
+        #if defined(GR_INCLUDE_GLDESKTOPext)
+            #include GR_INCLUDE_GLDESKTOPext
+        #endif
+    #endif
+
+#elif defined(GR_GL_CUSTOM_SETUP_HEADER)
+
+    #include GR_GL_CUSTOM_SETUP_HEADER
+
+#else
+    #undef GR_GL_FUNC
+    #undef GR_GL_PROC_ADDRESS
+    #undef GR_GL_PROC_ADDRESS_HEADER
+
+    #if GR_WIN32_BUILD
+        #define GR_SUPPORT_GLDESKTOP        1
+        // glew has to be included before gl
+        #include <GL/glew.h>
+        #include <GL/gl.h>
+        // remove stupid windows defines
+        #undef near
+        #undef far
+        #define GR_GL_FUNC __stdcall
+        #define GR_GL_PROC_ADDRESS(X)       wglGetProcAddress(#X)
+        #define GR_GL_PROC_ADDRESS_HEADER   <windows.h>
+    #elif GR_MAC_BUILD
+        #define GR_SUPPORT_GLDESKTOP        1
+        #include <OpenGL/gl.h>
+        #include <OpenGL/glext.h>
+        #define GR_GL_PROC_ADDRESS(X)       &X
+    #elif GR_IOS_BUILD
+        #define GR_SUPPORT_GLES1            1
+        #include <OpenGLES/ES1/gl.h>
+        #include <OpenGLES/ES1/glext.h>
+        #define GR_SUPPORT_GLES2            1
+        #include <OpenGLES/ES2/gl.h>
+        #include <OpenGLES/ES2/glext.h>
+        #define GR_GL_PROC_ADDRESS(X)       &X
+    #elif GR_ANDROID_BUILD
+        #ifndef GL_GLEXT_PROTOTYPES
+            #define GL_GLEXT_PROTOTYPES
+        #endif
+        #define GR_SUPPORT_GLES2            1
+        #include <GLES2/gl2.h>
+        #include <GLES2/gl2ext.h>
+        #define GR_GL_PROC_ADDRESS(X)       eglGetProcAddress(#X)
+        #define GR_GL_PROC_ADDRESS_HEADER   <EGL/egl.h>
+    #elif GR_QNX_BUILD
+        #ifndef GL_GLEXT_PROTOTYPES
+            #define GL_GLEXT_PROTOTYPES
+        #endif
+         #define GR_SUPPORT_GLES2           1
+        // This is needed by the QNX GLES2 headers
+        #define GL_API_EXT
+        #include <GLES2/gl2.h>
+        #include <GLES2/gl2ext.h>
+        #define GR_GL_PROC_ADDRESS(X)       eglGetProcAddress(#X)
+        #define GR_GL_PROC_ADDRESS_HEADER   <EGL/egl.h>
+    #elif GR_LINUX_BUILD
+        #ifndef GL_GLEXT_PROTOTYPES
+            #define GL_GLEXT_PROTOTYPES
+        #endif
+        #define GL_EXT_framebuffer_blit     0
+        #include <GL/gl.h>
+        #include <GL/glext.h>
+        #define GR_GL_PROC_ADDRESS(X)       &X
+        #define GR_SUPPORT_GLDESKTOP        1
+    #else
+        #error "unsupported GR_???_BUILD"
+    #endif
+
+#endif
+
+#if !defined(GR_SUPPORT_GLDESKTOP)
+    #define GR_SUPPORT_GLDESKTOP    0
+#endif
+#if !defined(GR_SUPPORT_GLES1)
+    #define GR_SUPPORT_GLES1        0
+#endif
+#if !defined(GR_SUPPORT_GLES2)
+    #define GR_SUPPORT_GLES2        0
+#endif
+
+#define GR_SUPPORT_GLES ((GR_SUPPORT_GLES1) || (GR_SUPPORT_GLES2))
+
+#if !GR_SUPPORT_GLES && !GR_SUPPORT_GLDESKTOP
+    #error "Either desktop or ES GL must be supported"
+#elif GR_SUPPORT_GLES && GR_SUPPORT_GLDESKTOP
+    #error "Cannot support both desktop and ES GL"
+#endif
+
+#if !defined(GR_GL_FUNC)
+    #define GR_GL_FUNC
+#endif
+
+#if !defined(GR_GL_PROC_ADDRESS)
+    #error "Must define GR_GL_PROC_ADDRESS"
+#endif
+
+#if !defined(GR_GL_LOG_CALLS)
+    #define GR_GL_LOG_CALLS             0
+#endif
+
+#if !defined(GR_GL_LOG_CALLS_START)
+    #define GR_GL_LOG_CALLS_START       0
+#endif
+
+#if !defined(GR_GL_CHECK_ERROR)
+    #define GR_GL_CHECK_ERROR           GR_DEBUG
+#endif
+
+#if !defined(GR_GL_CHECK_ERROR_START)
+    #define GR_GL_CHECK_ERROR_START     1
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if GR_SCALAR_IS_FIXED
+    #define GrGLType   GL_FIXED
+#elif GR_SCALAR_IS_FLOAT
+    #define GrGLType   GL_FLOAT
+#else
+    #error "unknown GR_SCALAR type"
+#endif
+
+#if GR_TEXT_SCALAR_IS_USHORT
+    #define GrGLTextType                    GL_UNSIGNED_SHORT
+    #define GR_GL_TEXT_TEXTURE_NORMALIZED   1
+#elif GR_TEXT_SCALAR_IS_FLOAT
+    #define GrGLTextType                    GL_FLOAT
+    #define GR_GL_TEXT_TEXTURE_NORMALIZED   0
+#elif GR_TEXT_SCALAR_IS_FIXED
+    #define GrGLTextType                    GL_FIXED
+    #define GR_GL_TEXT_TEXTURE_NORMALIZED   0
+#else
+    #error "unknown GR_TEXT_SCALAR type"
+#endif
+
+// Pick a pixel config for 32bit bitmaps. Our default is GL_RGBA (expect on
+// Windows where we match GDI's order).
+#ifndef GR_GL_32BPP_COLOR_FORMAT
+    #if GR_WIN32_BUILD
+        #define GR_GL_32BPP_COLOR_FORMAT    GR_BGRA //use GR prefix because this
+    #else                                           //may be an extension.
+        #define GR_GL_32BPP_COLOR_FORMAT    GL_RGBA
+    #endif
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Setup for opengl ES/desktop extensions
+// We make a struct of function pointers so that each GL context
+// can have it's own struct. (Some environments may have different proc
+// addresses for different contexts).
+
+extern "C" {
+struct GrGLExts {
+// FBO
+    GLvoid (GR_GL_FUNC *GenFramebuffers)(GLsizei n, GLuint *framebuffers);
+    GLvoid (GR_GL_FUNC *BindFramebuffer)(GLenum target, GLuint framebuffer);
+    GLvoid (GR_GL_FUNC *FramebufferTexture2D)(GLenum target, GLenum attachment,
+                                              GLenum textarget, GLuint texture,
+                                              GLint level);
+    GLenum (GR_GL_FUNC *CheckFramebufferStatus)(GLenum target);
+    GLvoid (GR_GL_FUNC *DeleteFramebuffers)(GLsizei n, const
+                                            GLuint *framebuffers);
+    GLvoid (GR_GL_FUNC *RenderbufferStorage)(GLenum target,
+                                             GLenum internalformat,
+                                             GLsizei width, GLsizei height);
+    GLvoid (GR_GL_FUNC *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
+    GLvoid (GR_GL_FUNC *DeleteRenderbuffers)(GLsizei n,
+                                             const GLuint *renderbuffers);
+    GLvoid (GR_GL_FUNC *FramebufferRenderbuffer)(GLenum target,
+                                                 GLenum attachment,
+                                                 GLenum renderbuffertarget,
+                                                 GLuint renderbuffer);
+    GLvoid (GR_GL_FUNC *BindRenderbuffer)(GLenum target, GLuint renderbuffer);
+
+// Multisampling
+    // same prototype for ARB_FBO, EXT_FBO, GL 3.0, & Apple ES extension
+    GLvoid (GR_GL_FUNC *RenderbufferStorageMultisample)(GLenum target,
+                                                        GLsizei samples,
+                                                        GLenum internalformat,
+                                                        GLsizei width,
+                                                        GLsizei height);
+    // desktop: ext_fbo_blit, arb_fbo, gl 3.0
+    GLvoid (GR_GL_FUNC *BlitFramebuffer)(GLint srcX0, GLint srcY0,
+                                         GLint srcX1, GLint srcY1,
+                                         GLint dstX0, GLint dstY0,
+                                         GLint dstX1, GLint dstY1,
+                                         GLbitfield mask, GLenum filter);
+    // apple's es extension
+    GLvoid (GR_GL_FUNC *ResolveMultisampleFramebuffer)();
+
+    // IMG'e es extension
+    GLvoid (GR_GL_FUNC *FramebufferTexture2DMultisample)(GLenum target,
+                                                         GLenum attachment,
+                                                         GLenum textarget,
+                                                         GLuint texture,
+                                                         GLint level,
+                                                         GLsizei samples);
+
+// Buffer mapping (extension in ES).
+    GLvoid* (GR_GL_FUNC *MapBuffer)(GLenum target, GLenum access);
+    GLboolean (GR_GL_FUNC *UnmapBuffer)(GLenum target);
+};
+}
+
+// BGRA format
+
+#define GR_BGRA                     0x80E1
+
+// FBO / stencil formats
+#define GR_FRAMEBUFFER              0x8D40
+#define GR_FRAMEBUFFER_COMPLETE     0x8CD5
+#define GR_COLOR_ATTACHMENT0        0x8CE0
+#define GR_FRAMEBUFFER_BINDING      0x8CA6
+#define GR_RENDERBUFFER             0x8D41
+#define GR_STENCIL_ATTACHMENT       0x8D20
+#define GR_STENCIL_INDEX4           0x8D47
+#define GR_STENCIL_INDEX8           0x8D48
+#define GR_STENCIL_INDEX16          0x8D49
+#define GR_DEPTH24_STENCIL8         0x88F0
+#define GR_MAX_RENDERBUFFER_SIZE    0x84E8
+#define GR_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GR_DEPTH_STENCIL            0x84F9
+#define GR_RGBA8                    0x8058
+#define GR_RGB565                   0x8D62
+
+
+// Multisampling
+
+// IMG MAX_SAMPLES uses a different value than desktop, Apple ES extension.
+#define GR_MAX_SAMPLES              0x8D57
+#define GR_MAX_SAMPLES_IMG          0x9135
+#define GR_READ_FRAMEBUFFER         0x8CA8
+#define GR_DRAW_FRAMEBUFFER         0x8CA9
+
+// Buffer mapping
+#define GR_WRITE_ONLY               0x88B9
+#define GR_BUFFER_MAPPED            0x88BC
+
+// Palette texture
+#define GR_PALETTE8_RGBA8           0x8B91
+
+extern void GrGLInitExtensions(GrGLExts* exts);
+
+////////////////////////////////////////////////////////////////////////////////
+
+extern void GrGLCheckErr(const char* location, const char* call);
+
+static inline void GrGLClearErr() {
+    while (GL_NO_ERROR != glGetError()) {}
+}
+
+#if GR_GL_CHECK_ERROR
+    extern bool gCheckErrorGL;
+    #define GR_GL_CHECK_ERROR_IMPL(X) if (gCheckErrorGL) GrGLCheckErr(GR_FILE_AND_LINE_STR, #X)
+#else
+    #define GR_GL_CHECK_ERROR_IMPL(X)
+#endif
+
+#if GR_GL_LOG_CALLS
+    extern bool gLogCallsGL;
+    #define GR_GL_LOG_CALLS_IMPL(X) if (gLogCallsGL) GrPrintf(GR_FILE_AND_LINE_STR "GL: " #X "\n")
+#else
+    #define GR_GL_LOG_CALLS_IMPL(X)
+#endif
+
+#define GR_GL(X)                 gl ## X; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X);
+#define GR_GL_NO_ERR(X)          GrGLClearErr(); gl ## X; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X);
+#define GR_GLEXT(exts, X)        exts. X; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X);
+#define GR_GLEXT_NO_ERR(exts, X) GrGLClearErr(); exts. X; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X);
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Helpers for glGetString()
+ */
+bool has_gl_extension(const char* ext);
+void gl_version(int* major, int* minor);
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  GrGL_RestoreResetRowLength() will reset GL_UNPACK_ROW_LENGTH to 0. We write
+ *  this wrapper, since GL_UNPACK_ROW_LENGTH is not available on all GL versions
+ */
+#if GR_SUPPORT_GLDESKTOP
+    static inline void GrGL_RestoreResetRowLength() {
+        GR_GL(PixelStorei(GL_UNPACK_ROW_LENGTH, 0));
+    }
+#else
+    #define GrGL_RestoreResetRowLength()
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Some drivers want the var-int arg to be zero-initialized on input.
+ */
+#define GR_GL_INIT_ZERO     0
+#define GR_GL_GetIntegerv(e, p)     \
+    do {                            \
+        *(p) = GR_GL_INIT_ZERO;     \
+        GR_GL(GetIntegerv(e, p));   \
+    } while (0)
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif
diff --git a/gpu/include/GrGLConfig_chrome.h b/gpu/include/GrGLConfig_chrome.h
new file mode 100644
index 0000000..6d5f21c
--- /dev/null
+++ b/gpu/include/GrGLConfig_chrome.h
@@ -0,0 +1,24 @@
+#ifndef GrGLConfig_chrome_DEFINED
+#define GrGLConfig_chrome_DEFINED
+
+#define GR_SUPPORT_GLES2    1
+
+// gl2ext.h will define these extensions macros but Chrome doesn't provide
+// prototypes.
+#define GL_OES_mapbuffer                      0
+#define GL_IMG_multisampled_render_to_texture 0
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#define GR_GL_FUNC
+
+#define GR_GL_PROC_ADDRESS(X)       &X
+
+// chrome always assumes BGRA
+#define GR_GL_32BPP_COLOR_FORMAT    GR_BGRA
+
+// glGetError() forces a sync with gpu process on chrome
+#define GR_GL_CHECK_ERROR_START     0
+
+#endif
diff --git a/gpu/include/GrGLIRect.h b/gpu/include/GrGLIRect.h
new file mode 100644
index 0000000..80237d9
--- /dev/null
+++ b/gpu/include/GrGLIRect.h
@@ -0,0 +1,64 @@
+#include "GrGLConfig.h"
+
+#ifndef GrGLIRect_DEFINED
+#define GrGLIRect_DEFINED
+
+/**
+ * Helper struct for dealing with the fact that Ganesh and GL use different
+ * window coordinate systems (top-down vs bottom-up)
+ */
+struct GrGLIRect {
+    GLint   fLeft;
+    GLint   fBottom;
+    GLsizei fWidth;
+    GLsizei fHeight;
+
+    void pushToGLViewport() const {
+        GR_GL(Viewport(fLeft, fBottom, fWidth, fHeight));
+    }
+
+    void pushToGLScissor() const {
+        GR_GL(Scissor(fLeft, fBottom, fWidth, fHeight));
+    }
+
+    void setFromGLViewport() {
+        GR_STATIC_ASSERT(sizeof(GrGLIRect) == 4*sizeof(GLint));
+        GR_GL_GetIntegerv(GL_VIEWPORT, (GLint*) this);
+    }
+
+    // sometimes we have a GrIRect from the client that we
+    // want to simultaneously make relative to GL's viewport
+    // and convert from top-down to bottom-up.
+    void setRelativeTo(const GrGLIRect& glRect,
+                       int leftOffset,
+                       int topOffset,
+                       int width,
+                       int height) {
+        fLeft = glRect.fLeft + leftOffset;
+        fWidth = width;
+        fBottom = glRect.fBottom + (glRect.fHeight - topOffset - height);
+        fHeight = height;
+
+        GrAssert(fLeft >= 0);
+        GrAssert(fWidth >= 0);
+        GrAssert(fBottom >= 0);
+        GrAssert(fHeight >= 0);
+    }
+
+    bool contains(const GrGLIRect& glRect) const {
+        return fLeft <= glRect.fLeft &&
+               fBottom <= glRect.fBottom &&
+               fLeft + fWidth >=  glRect.fLeft + glRect.fWidth &&
+               fBottom + fHeight >=  glRect.fBottom + glRect.fHeight;
+    }
+
+    void invalidate() {fLeft = fWidth = fBottom = fHeight = -1;}
+
+    bool operator ==(const GrGLIRect& glRect) const {
+        return 0 == memcmp(this, &glRect, sizeof(GrGLIRect));
+    }
+
+    bool operator !=(const GrGLIRect& glRect) const {return !(*this == glRect);}
+};
+
+#endif
diff --git a/gpu/include/GrGLIndexBuffer.h b/gpu/include/GrGLIndexBuffer.h
new file mode 100644
index 0000000..5755c07
--- /dev/null
+++ b/gpu/include/GrGLIndexBuffer.h
@@ -0,0 +1,59 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGLIndexBuffer_DEFINED
+#define GrGLIndexBuffer_DEFINED
+
+#include "GrIndexBuffer.h"
+#include "GrGLConfig.h"
+
+class GrGpuGL;
+
+class GrGLIndexBuffer : public GrIndexBuffer {
+protected:
+    GrGLIndexBuffer(GLuint id,
+                    GrGpuGL* gl,
+                    size_t sizeInBytes,
+                    bool dynamic);
+public:
+    virtual ~GrGLIndexBuffer();
+
+    GLuint bufferID() const;
+
+    // overrides of GrIndexBuffer
+    virtual void abandon();
+    virtual void* lock();
+    virtual void* lockPtr() const;
+    virtual void unlock();
+    virtual bool isLocked() const;
+    virtual bool updateData(const void* src, size_t srcSizeInBytes);
+    virtual bool updateSubData(const void* src,  
+                               size_t srcSizeInBytes, 
+                               size_t offset);
+private:
+    void bind() const;
+    
+    GrGpuGL*     fGL;
+    GLuint       fBufferID;
+    void*        fLockPtr;
+    
+    friend class GrGpuGL;
+
+    typedef GrIndexBuffer INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrGLTexture.h b/gpu/include/GrGLTexture.h
new file mode 100644
index 0000000..7b7480c
--- /dev/null
+++ b/gpu/include/GrGLTexture.h
@@ -0,0 +1,220 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGLTexture_DEFINED
+#define GrGLTexture_DEFINED
+
+#include "GrTexture.h"
+#include "GrScalar.h"
+#include "GrGLIRect.h"
+
+class GrGpuGL;
+class GrGLTexture;
+
+/**
+ * A ref counted tex id that deletes the texture in its destructor.
+ */
+class GrGLTexID : public GrRefCnt {
+public:
+    GrGLTexID(GLuint texID) : fTexID(texID) {}
+
+    virtual ~GrGLTexID() {
+        if (0 != fTexID) {
+            GR_GL(DeleteTextures(1, &fTexID));
+        }
+    }
+
+    void abandon() { fTexID = 0; }
+    GLuint id() const { return fTexID; }
+
+private:
+    GLuint      fTexID;
+};
+
+class GrGLRenderTarget : public GrRenderTarget {
+public:
+    virtual ~GrGLRenderTarget();
+    
+    bool resolveable() const { return fRTFBOID != fTexFBOID; }
+    bool needsResolve() const { return fNeedsResolve; }
+    void setDirty(bool dirty) { fNeedsResolve = resolveable() && dirty; }
+    
+    GLuint renderFBOID() const { return fRTFBOID; }
+    GLuint textureFBOID() const { return fTexFBOID; }
+
+    void   abandon();
+
+protected:
+
+    struct GLRenderTargetIDs {
+        GLuint      fRTFBOID;
+        GLuint      fTexFBOID;
+        GLuint      fStencilRenderbufferID;
+        GLuint      fMSColorRenderbufferID;
+        bool        fOwnIDs;
+    };
+    
+    GrGLRenderTarget(const GLRenderTargetIDs& ids,
+                     GrGLTexID* texID,
+                     GLuint stencilBits,
+                     const GrGLIRect& fViewport,
+                     GrGLTexture* texture,
+                     GrGpuGL* gl);
+    
+    void setViewport(const GrGLIRect& rect) { fViewport = rect; }
+    const GrGLIRect& getViewport() const { return fViewport; }
+private:
+    GrGpuGL*    fGL;
+    GLuint      fRTFBOID;
+    GLuint      fTexFBOID;
+    GLuint      fStencilRenderbufferID;
+    GLuint      fMSColorRenderbufferID;
+   
+    // Should this object delete IDs when it is destroyed or does someone
+    // else own them.
+    bool        fOwnIDs;
+    
+    // If there separate Texture and RenderTarget FBO IDs then the rendertarget
+    // must be resolved to the texture FBO before it is used as a texture.
+    bool fNeedsResolve;
+    
+    // when we switch to this rendertarget we want to set the viewport to 
+    // only render to to content area (as opposed to the whole allocation) and
+    // we want the rendering to be at top left (GL has origin in bottom left) 
+    GrGLIRect fViewport;
+
+    // non-NULL if this RT was created by Gr with an associated GrGLTexture.
+    GrGLTexID* fTexIDObj;
+
+    friend class GrGpuGL;
+    friend class GrGLTexture;
+    
+    typedef GrRenderTarget INHERITED;
+};
+
+class GrGLTexture : public GrTexture {
+public:
+    enum Orientation {
+        kBottomUp_Orientation,
+        kTopDown_Orientation,
+    };
+    
+    struct TexParams {
+        GLenum fFilter;
+        GLenum fWrapS;
+        GLenum fWrapT;
+    };
+
+protected:
+    struct GLTextureDesc {
+        uint32_t    fContentWidth;
+        uint32_t    fContentHeight;
+        uint32_t    fAllocWidth;
+        uint32_t    fAllocHeight;
+        PixelConfig fFormat;
+        GLuint      fTextureID;
+        GLenum      fUploadFormat;
+        GLenum      fUploadByteCount;
+        GLenum      fUploadType;
+        GLuint      fStencilBits;
+        Orientation fOrientation;
+    };
+    typedef GrGLRenderTarget::GLRenderTargetIDs GLRenderTargetIDs;
+    GrGLTexture(const GLTextureDesc& textureDesc,
+                const GLRenderTargetIDs& rtIDs,
+                const TexParams& initialTexParams,
+                GrGpuGL* gl);
+
+public:
+    virtual ~GrGLTexture();
+    
+    // overloads of GrTexture
+    virtual void abandon();
+    virtual GrRenderTarget* asRenderTarget();
+    virtual void releaseRenderTarget();
+    virtual void uploadTextureData(uint32_t x,
+                                   uint32_t y,
+                                   uint32_t width,
+                                   uint32_t height,
+                                   const void* srcData);
+    virtual intptr_t getTextureHandle();
+
+    const TexParams& getTexParams() const { return fTexParams; }
+    void setTexParams(const TexParams& texParams) { fTexParams = texParams; }
+    GLuint textureID() const { return fTexIDObj->id(); }
+
+    GLenum uploadFormat() const { return fUploadFormat; }
+    GLenum uploadByteCount() const { return fUploadByteCount; }
+    GLenum uploadType() const { return fUploadType; }
+
+    /**
+     * Retrieves the texture width actually allocated in texels.
+     *
+     * @return the width in texels
+     */
+    int allocWidth() const { return fAllocWidth; }
+
+    /**
+     * Retrieves the texture height actually allocated in texels.
+     *
+     * @return the height in texels
+     */
+    int allocHeight() const { return fAllocHeight; }
+
+    /**
+     * @return width() / allocWidth()
+     */
+    GrScalar contentScaleX() const { return fScaleX; }
+
+    /**
+     * @return height() / allocHeight()
+     */
+    GrScalar contentScaleY() const { return fScaleY; }
+
+    // Ganesh assumes texture coordinates have their origin
+    // in the top-left corner of the image. OpenGL, however,
+    // has the origin in the lower-left corner. For content that
+    // is loaded by Ganesh we just push the content "upside down"
+    // (by GL's understanding of the world ) in glTex*Image and the 
+    // addressing just works out. However, content generated by GL 
+    // (FBO or externally imported texture) will be updside down 
+    // and it is up to the GrGpuGL derivative to handle y-mirroing.
+    Orientation orientation() const { return fOrientation; }
+
+private:
+    TexParams           fTexParams;
+    GrGLTexID*          fTexIDObj;
+    GLenum              fUploadFormat;
+    GLenum              fUploadByteCount;
+    GLenum              fUploadType;
+    int                 fAllocWidth;
+    int                 fAllocHeight;
+    // precomputed content / alloc ratios
+    GrScalar            fScaleX;
+    GrScalar            fScaleY;
+    Orientation         fOrientation;
+    GrGLRenderTarget*   fRenderTarget;
+    GrGpuGL*            fGpuGL;
+
+    static const GLenum gWrapMode2GLWrap[];
+
+    friend class GrGpuGL;
+
+    typedef GrTexture INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrGLVertexBuffer.h b/gpu/include/GrGLVertexBuffer.h
new file mode 100644
index 0000000..30ae734
--- /dev/null
+++ b/gpu/include/GrGLVertexBuffer.h
@@ -0,0 +1,60 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGLVertexBuffer_DEFINED
+#define GrGLVertexBuffer_DEFINED
+
+#include "GrVertexBuffer.h"
+#include "GrGLConfig.h"
+
+class GrGpuGL;
+
+class GrGLVertexBuffer : public GrVertexBuffer {
+protected:
+    GrGLVertexBuffer(GLuint id,
+                     GrGpuGL* gl,
+                     size_t sizeInBytes,
+                     bool dynamic);
+
+public:
+    virtual ~GrGLVertexBuffer();
+    
+    // overrides of GrVertexBuffer
+    virtual void abandon();
+    virtual void* lock();
+    virtual void* lockPtr() const;
+    virtual void unlock();
+    virtual bool isLocked() const;
+    virtual bool updateData(const void* src, size_t srcSizeInBytes);
+    virtual bool updateSubData(const void* src,  
+                               size_t srcSizeInBytes, 
+                               size_t offset);
+    GLuint bufferID() const;
+
+private:
+    void bind() const;
+    
+    GrGpuGL*     fGL;
+    GLuint       fBufferID;
+    void*        fLockPtr;
+
+    friend class GrGpuGL;
+
+    typedef GrVertexBuffer INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrGeometryBuffer.h b/gpu/include/GrGeometryBuffer.h
new file mode 100644
index 0000000..1447e73
--- /dev/null
+++ b/gpu/include/GrGeometryBuffer.h
@@ -0,0 +1,116 @@
+/*
+ Copyright 2011 Google Inc.
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#ifndef GrGeometryBuffer_DEFINED
+#define GrGeometryBuffer_DEFINED
+
+#include "GrRefCnt.h"
+
+/**
+ * Parent class for vertex and index buffers
+ */
+class GrGeometryBuffer : public GrRefCnt {
+public:
+    virtual ~GrGeometryBuffer() {}
+    
+    /**
+     * Retrieves the size of the buffer
+     *
+     * @return the size of the buffer in bytes
+     */
+    size_t size() const { return fSizeInBytes; }
+    
+    /**
+     *Retrieves whether the buffer was created with the dynamic flag
+     *
+     * @return true if the buffer was created with the dynamic flag
+     */
+    bool dynamic() const { return fDynamic; }
+    
+    /**
+     * Indicates that GPU context in which this veretx buffer was created is 
+     * destroyed and that Ganesh should not attempt to free the buffer in the
+     * underlying API.
+     */
+    virtual void abandon() = 0;
+    
+    /**
+     * Locks the buffer to be written by the CPU.
+     * 
+     * The previous content of the buffer is invalidated. It is an error
+     * to draw from the buffer while it is locked. It is an error to call lock
+     * on an already locked buffer.
+     * 
+     * @return a pointer to the data or NULL if the lock fails.
+     */
+    virtual void* lock() = 0;
+    
+    /**
+     * Returns the same ptr that lock() returned at time of lock or NULL if the
+     * is not locked.
+     *
+     * @return ptr to locked buffer data or undefined if buffer is not locked.
+     */
+    virtual void* lockPtr() const = 0;
+    
+    /** 
+     * Unlocks the buffer. 
+     * 
+     * The pointer returned by the previous lock call will no longer be valid.
+     */
+    virtual void unlock() = 0;
+    
+    /** 
+     Queries whether the buffer has been locked.
+     
+     @return true if the buffer is locked, false otherwise.
+     */
+    virtual bool isLocked() const = 0;
+    
+    /**
+     * Updates the buffer data. 
+     *  
+     * The size of the buffer will be preserved. The src data will be 
+     * placed at the begining of the buffer and any remaining contents will
+     * be undefined.
+     * 
+     * @return returns true if the update succeeds, false otherwise.
+     */
+    virtual bool updateData(const void* src, size_t srcSizeInBytes) = 0;
+    
+    /**
+     * Updates a portion of the buffer data. 
+     * 
+     * The contents of the buffer outside the update region are preserved.
+     * 
+     * @return returns true if the update succeeds, false otherwise.
+     */
+    virtual bool updateSubData(const void* src, 
+                               size_t srcSizeInBytes, 
+                               size_t offset) = 0;
+protected:
+    GrGeometryBuffer(size_t sizeInBytes, bool dynamic) : 
+        fSizeInBytes(sizeInBytes),
+        fDynamic(dynamic) {}
+
+private:
+    size_t   fSizeInBytes;
+    bool     fDynamic;
+
+    typedef GrRefCnt INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrGlyph.h b/gpu/include/GrGlyph.h
new file mode 100644
index 0000000..4a3b307
--- /dev/null
+++ b/gpu/include/GrGlyph.h
@@ -0,0 +1,89 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGlyph_DEFINED
+#define GrGlyph_DEFINED
+
+#include "GrPath.h"
+#include "GrRect.h"
+
+class GrAtlas;
+
+/*  Need this to be quad-state:
+    - complete w/ image
+    - just metrics
+    - failed to get image, but has metrics
+    - failed to get metrics
+ */
+struct GrGlyph {
+    typedef uint32_t PackedID;
+
+    GrAtlas*    fAtlas;
+    GrPath*     fPath;
+    PackedID    fPackedID;
+    GrIRect16   fBounds;
+    GrIPoint16  fAtlasLocation;
+
+    void init(GrGlyph::PackedID packed, const GrIRect& bounds) {
+        fAtlas = NULL;
+        fPath = NULL;
+        fPackedID = packed;
+        fBounds.set(bounds);
+        fAtlasLocation.set(0, 0);
+    }
+    
+    void free() {
+        if (fPath) {
+            delete fPath;
+            fPath = NULL;
+        }
+    }
+    
+    int width() const { return fBounds.width(); }
+    int height() const { return fBounds.height(); }
+    bool isEmpty() const { return fBounds.isEmpty(); }
+    uint16_t glyphID() const { return UnpackID(fPackedID); }
+
+    ///////////////////////////////////////////////////////////////////////////
+    
+    static inline unsigned ExtractSubPixelBitsFromFixed(GrFixed pos) {
+        // two most significant fraction bits from fixed-point
+        return (pos >> 14) & 3;
+    }
+    
+    static inline PackedID Pack(uint16_t glyphID, GrFixed x, GrFixed y) {
+        x = ExtractSubPixelBitsFromFixed(x);
+        y = ExtractSubPixelBitsFromFixed(y);
+        return (x << 18) | (y << 16) | glyphID;
+    }
+    
+    static inline GrFixed UnpackFixedX(PackedID packed) {
+        return ((packed >> 18) & 3) << 14;
+    }
+    
+    static inline GrFixed UnpackFixedY(PackedID packed) {
+        return ((packed >> 16) & 3) << 14;
+    }
+    
+    static inline uint16_t UnpackID(PackedID packed) {
+        return (uint16_t)packed;
+    }
+};
+
+
+#endif
+
diff --git a/gpu/include/GrGpu.h b/gpu/include/GrGpu.h
new file mode 100644
index 0000000..75fb1f4
--- /dev/null
+++ b/gpu/include/GrGpu.h
@@ -0,0 +1,574 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrGpu_DEFINED
+#define GrGpu_DEFINED
+
+#include "GrRect.h"
+#include "GrRefCnt.h"
+#include "GrDrawTarget.h"
+#include "GrTexture.h"
+
+class GrVertexBufferAllocPool;
+class GrIndexBufferAllocPool;
+class GrPathRenderer;
+
+class GrGpu : public GrDrawTarget {
+
+public:
+    /**
+     * Possible 3D APIs that may be used by Ganesh.
+     */
+    enum Engine {
+        kOpenGL_Shaders_Engine,
+        kOpenGL_Fixed_Engine,
+        kDirect3D9_Engine
+    };
+
+    /**
+     * Platform specific 3D context.
+     * For
+     *    kOpenGL_Shaders_Engine use NULL
+     *    kOpenGL_Fixed_Engine   use NULL
+     *    kDirect3D9_Engine      use an IDirect3DDevice9*
+     */
+    typedef void* Platform3DContext;
+
+    /**
+     *  Create an instance of GrGpu that matches the specified Engine backend.
+     *  If the requested engine is not supported (at compile-time or run-time)
+     *  this returns NULL.
+     */
+    static GrGpu* Create(Engine, Platform3DContext context3D);
+
+    /**
+     * Used to control the level of antialiasing available for a rendertarget.
+     * Anti-alias quality levels depend on the underlying API/GPU capabilities.
+     */
+    enum AALevels {
+        kNone_AALevel, //<! No antialiasing available.
+        kLow_AALevel,  //<! Low quality antialiased rendering. Actual
+                       //   interpretation is platform-dependent.
+        kMed_AALevel,  //<! Medium quality antialiased rendering. Actual
+                       //   interpretation is platform-dependent.
+        kHigh_AALevel, //<! High quality antialiased rendering. Actual
+                       //   interpretation is platform-dependent.
+    };
+
+
+    /**
+     * Optional bitfield flags that can be passed to createTexture.
+     */
+    enum TextureFlags {
+        kRenderTarget_TextureFlag  = 0x1,   //<! Creates a texture that can be
+                                            //   rendered to by calling
+                                            //   GrGpu::setRenderTarget() with
+                                            //   GrTexture::asRenderTarget().
+        kNoPathRendering_TextureFlag = 0x2, //<! If the texture is used as a
+                                            //   rendertarget but paths will not
+                                            //   be rendered to it.
+        kDynamicUpdate_TextureFlag = 0x4    //!< Hint that the CPU may modify
+                                            // this texture after creation
+    };
+
+    enum {
+        /**
+         *  For Index8 pixel config, the colortable must be 256 entries
+         */
+        kColorTableSize = 256 * sizeof(GrColor)
+    };
+    /**
+     * Describes a texture to be created.
+     */
+    struct TextureDesc {
+        uint32_t               fFlags;  //!< bitfield of TextureFlags
+        GrGpu::AALevels        fAALevel;//!< The level of antialiasing available
+                                        //   for a rendertarget texture. Only
+                                        //   flags contains
+                                        //   kRenderTarget_TextureFlag.
+        uint32_t               fWidth;  //!< Width of the texture
+        uint32_t               fHeight; //!< Height of the texture
+        GrTexture::PixelConfig fFormat; //!< Format of source data of the
+                                        //   texture. Not guaraunteed to be the
+                                        //   same as internal format used by
+                                        //   3D API.
+    };
+
+    /**
+     * Gpu usage statistics.
+     */
+    struct Stats {
+        uint32_t fVertexCnt;  //<! Number of vertices drawn
+        uint32_t fIndexCnt;   //<! Number of indices drawn
+        uint32_t fDrawCnt;    //<! Number of draws
+
+        uint32_t fProgChngCnt;//<! Number of program changes (N/A for fixed)
+
+        /*
+         *  Number of times the texture is set in 3D API
+         */
+        uint32_t fTextureChngCnt;
+        /*
+         *  Number of times the render target is set in 3D API
+         */
+        uint32_t fRenderTargetChngCnt;
+        /*
+         *  Number of textures created (includes textures that are rendertargets).
+         */
+        uint32_t fTextureCreateCnt;
+        /*
+         *  Number of rendertargets created.
+         */
+        uint32_t fRenderTargetCreateCnt;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    GrGpu();
+    virtual ~GrGpu();
+
+    /**
+     * The GrGpu object normally assumes that no outsider is setting state
+     * within the underlying 3D API's context/device/whatever. This call informs
+     * the GrGpu that the state was modified and it shouldn't make assumptions
+     * about the state.
+     */
+    void markContextDirty() { fContextIsDirty = true; }
+
+    void unimpl(const char[]);
+
+    /**
+     * Creates a texture object. If desc width or height is not a power of
+     * two but underlying API requires a power of two texture then srcData
+     * will be embedded in a power of two texture. The extra width and height
+     * is filled as though srcData were rendered clamped into the texture.
+     *
+     * If kRenderTarget_TextureFlag is specified the GrRenderTarget is 
+     * accessible via GrTexture::asRenderTarget(). The texture will hold a ref
+     * on the render target until its releaseRenderTarget() is called or it is
+     * destroyed.
+     *
+     * @param desc        describes the texture to be created.
+     * @param srcData     texel data to load texture. Begins with full-size
+     *                    palette data for paletted textures. Contains width*
+     *                    height texels. If NULL texture data is uninitialized.
+     *
+     * @return    The texture object if successful, otherwise NULL.
+     */
+    GrTexture* createTexture(const TextureDesc& desc,
+                             const void* srcData, size_t rowBytes);
+    /**
+     * Wraps an externally-created rendertarget in a GrRenderTarget.
+     * @param platformRenderTarget  handle to the the render target in the
+     *                              underlying 3D API. Interpretation depends on
+     *                              GrGpu subclass in use.
+     * @param stencilBits           number of stencil bits the target has
+     * @param width                 width of the render target
+     * @param height                height of the render target
+     */
+    virtual GrRenderTarget* createPlatformRenderTarget(
+                                                intptr_t platformRenderTarget,
+                                                int stencilBits,
+                                                int width, int height);
+
+    /**
+     * Reads the current target object (e.g. FBO or IDirect3DSurface9*) and
+     * viewport state from the underlying 3D API and wraps it in a
+     * GrRenderTarget. The GrRenderTarget will not attempt to delete/destroy the
+     * underlying object in its destructor and it is up to caller to guarantee
+     * that it remains valid while the GrRenderTarget is used.
+     *
+     * @return the newly created GrRenderTarget
+     */
+    GrRenderTarget* createRenderTargetFrom3DApiState();
+
+    /**
+     * Creates a vertex buffer.
+     *
+     * @param size    size in bytes of the vertex buffer
+     * @param dynamic hints whether the data will be frequently changed
+     *                by either GrVertexBuffer::lock or
+     *                GrVertexBuffer::updateData.
+     *
+     * @return    The vertex buffer if successful, otherwise NULL.
+     */
+    GrVertexBuffer* createVertexBuffer(uint32_t size, bool dynamic);
+
+    /**
+     * Creates an index buffer.
+     *
+     * @param size    size in bytes of the index buffer
+     * @param dynamic hints whether the data will be frequently changed
+     *                by either GrIndexBuffer::lock or
+     *                GrIndexBuffer::updateData.
+     *
+     * @return The index buffer if successful, otherwise NULL.
+     */
+    GrIndexBuffer* createIndexBuffer(uint32_t size, bool dynamic);
+
+    /**
+     * Erase the entire render target, ignoring any clips/scissors.
+     *
+     * This is issued to the GPU driver immediately.
+     */
+    void eraseColor(GrColor color);
+
+    /**
+     * Are 8 bit paletted textures supported.
+     *
+     * @return    true if 8bit palette textures are supported, false otherwise
+     */
+    bool supports8BitPalette() const { return f8bitPaletteSupport; }
+
+    /**
+     * returns true if two sided stenciling is supported. If false then only
+     * the front face values of the GrStencilSettings
+     * @return    true if only a single stencil pass is needed.
+     */
+    bool supportsTwoSidedStencil() const
+                                        { return fTwoSidedStencilSupport; }
+
+    /**
+     * returns true if stencil wrap is supported. If false then
+     * kIncWrap_StencilOp and kDecWrap_StencilOp are treated as
+     * kIncClamp_StencilOp and kDecClamp_StencilOp, respectively.
+     * @return    true if stencil wrap ops are supported.
+     */
+    bool supportsStencilWrapOps() const
+                                        { return fStencilWrapOpsSupport; }
+
+    /**
+     * Checks whether locking vertex and index buffers is supported.
+     *
+     * @return true if locking is supported.
+     */
+    bool supportsBufferLocking() const { return fBufferLockSupport; }
+
+    /**
+     * Gets the minimum width of a render target. If a texture/rt is created
+     * with a width less than this size the GrGpu object will clamp it to this
+     * value.
+     */
+    int minRenderTargetWidth() const { return fMinRenderTargetWidth; }
+
+    /**
+     * Gets the minimum width of a render target. If a texture/rt is created
+     * with a height less than this size the GrGpu object will clamp it to this
+     * value.
+     */
+    int minRenderTargetHeight() const  { return fMinRenderTargetHeight; }
+
+    /**
+     * Returns true if NPOT textures can be created
+     *
+     * @return    true if NPOT textures can be created
+     */
+    bool npotTextureSupport() const { return fNPOTTextureSupport; }
+
+    /**
+     * Returns true if NPOT textures can be repeat/mirror tiled.
+     *
+     * @return    true if NPOT textures can be tiled
+     */
+    bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; }
+
+    /**
+     * Returns true if a NPOT texture can be a rendertarget
+     *
+     * @return    the true if NPOT texture/rendertarget can be created.
+     */
+    bool npotRenderTargetSupport() const { return fNPOTRenderTargetSupport; }
+
+    int maxTextureDimension() const { return fMaxTextureDimension; }
+
+    // GrDrawTarget overrides
+    virtual void drawIndexed(GrPrimitiveType type,
+                             int startVertex,
+                             int startIndex,
+                             int vertexCount,
+                             int indexCount);
+
+    virtual void drawNonIndexed(GrPrimitiveType type,
+                                int startVertex,
+                                int vertexCount);
+
+    /**
+     * Returns an index buffer that can be used to render quads.
+     * Six indices per quad: 0, 1, 2, 0, 2, 3, etc.
+     * The max number of quads can be queried using GrIndexBuffer::maxQuads().
+     * Draw with kTriangles_PrimitiveType
+     * @ return the quad index buffer
+     */
+    const GrIndexBuffer* getQuadIndexBuffer() const;
+
+    /**
+     * Returns a vertex buffer with four position-only vertices [(0,0), (1,0),
+     * (1,1), (0,1)].
+     * @ return unit square vertex buffer
+     */
+    const GrVertexBuffer* getUnitSquareVertexBuffer() const;
+
+    /**
+     * Ensures that the current render target is actually set in the
+     * underlying 3D API. Used when client wants to use 3D API to directly
+     * render to the RT.
+     */
+    void forceRenderTargetFlush();
+
+    /**
+     * Reads a rectangle of pixels from the current render target.
+     * @param left      left edge of the rectangle to read (inclusive)
+     * @param top       top edge of the rectangle to read (inclusive)
+     * @param width     width of rectangle to read in pixels.
+     * @param height    height of rectangle to read in pixels.
+     * @param buffer    memory to read the rectangle into.
+     *
+     * @return true if the read succeeded, false if not. The read can fail
+     *              because of a unsupported pixel config or because no render
+     *              target is currently set.
+     */
+    bool readPixels(int left, int top, int width, int height,
+                    GrTexture::PixelConfig, void* buffer);
+
+
+    const Stats& getStats() const;
+    void resetStats();
+    void printStats() const;
+
+protected:
+    enum PrivateStateBits {
+        kFirstBit = (kLastPublicStateBit << 1),
+
+        kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify
+                                                 // stencil bits used for
+                                                 // clipping.
+    };
+
+    /**
+     * Extensions to GrDrawTarget::StateBits to implement stencil clipping
+     */
+    struct ClipState {
+        bool            fClipInStencil;
+        bool            fClipIsDirty;
+    } fClipState;
+
+    // GrDrawTarget override
+    virtual void clipWillBeSet(const GrClip& newClip);
+
+    // prepares clip flushes gpu state before a draw
+    bool setupClipAndFlushState(GrPrimitiveType type);
+
+    // Functions used to map clip-respecting stencil tests into normal
+    // stencil funcs supported by GPUs.
+    static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
+                                            GrStencilFunc func);
+    static void ConvertStencilFuncAndMask(GrStencilFunc func,
+                                          bool clipInStencil,
+                                          unsigned int clipBit,
+                                          unsigned int userBits,
+                                          unsigned int* ref,
+                                          unsigned int* mask);
+
+    // stencil settings to clip drawing when stencil clipping is in effect
+    // and the client isn't using the stencil test.
+    static const GrStencilSettings gClipStencilSettings;
+
+    // defaults to false, subclass can set true to support palleted textures
+    bool f8bitPaletteSupport;
+
+    // set by subclass
+    bool fNPOTTextureSupport;
+    bool fNPOTTextureTileSupport;
+    bool fNPOTRenderTargetSupport;
+    bool fTwoSidedStencilSupport;
+    bool fStencilWrapOpsSupport;
+
+    // set by subclass to true if index and vertex buffers can be locked, false
+    // otherwise.
+    bool fBufferLockSupport;
+
+    // set by subclass
+    int fMinRenderTargetWidth;
+    int fMinRenderTargetHeight;
+    int fMaxTextureDimension;
+
+    Stats           fStats;
+
+    const GrVertexBuffer*           fCurrPoolVertexBuffer;
+    int                             fCurrPoolStartVertex;
+
+    const GrIndexBuffer*            fCurrPoolIndexBuffer;
+    int                             fCurrPoolStartIndex;
+
+    // GrDrawTarget overrides
+    virtual bool acquireGeometryHelper(GrVertexLayout vertexLayout,
+                                       void**         vertices,
+                                       void**         indices);
+    virtual void releaseGeometryHelper();
+
+    virtual void setVertexSourceToArrayHelper(const void* vertexArray,
+                                              int vertexCount);
+
+    virtual void setIndexSourceToArrayHelper(const void* indexArray,
+                                             int indexCount);
+    // Helpers for setting up geometry state
+    void finalizeReservedVertices();
+    void finalizeReservedIndices();
+
+    // overridden by API-specific derived class to handle re-emitting 3D API
+    // preample and dirtying state cache.
+    virtual void resetContext() = 0;
+
+    // overridden by API-specific derived class to create objects.
+    virtual GrTexture* createTextureHelper(const TextureDesc& desc,
+                                           const void* srcData,
+                                           size_t rowBytes) = 0;
+    virtual GrRenderTarget* createPlatformRenderTargetHelper(
+                                                intptr_t platformRenderTarget,
+                                                int stencilBits,
+                                                int width, int height) = 0;
+    virtual GrRenderTarget* createRenderTargetFrom3DApiStateHelper() = 0;
+    virtual GrVertexBuffer* createVertexBufferHelper(uint32_t size,
+                                                     bool dynamic) = 0;
+    virtual GrIndexBuffer* createIndexBufferHelper(uint32_t size,
+                                                   bool dynamic) = 0;
+
+    // overridden by API-specific derivated class to perform the erase.
+    virtual void eraseColorHelper(GrColor color) = 0;
+
+    // overridden by API-specific derived class to perform the draw call.
+    virtual void drawIndexedHelper(GrPrimitiveType type,
+                                   uint32_t startVertex,
+                                   uint32_t startIndex,
+                                   uint32_t vertexCount,
+                                   uint32_t indexCount) = 0;
+
+    virtual void drawNonIndexedHelper(GrPrimitiveType type,
+                                      uint32_t vertexCount,
+                                      uint32_t numVertices) = 0;
+
+    // overridden by API-specific derived class to perform flush
+    virtual void forceRenderTargetFlushHelper() = 0;
+
+    // overridden by API-specific derived class to perform the read pixels.
+    virtual bool readPixelsHelper(int left, int top, int width, int height,
+                                  GrTexture::PixelConfig, void* buffer) = 0;
+
+    // called to program the vertex data, indexCount will be 0 if drawing non-
+    // indexed geometry. The subclass may adjust the startVertex and/or
+    // startIndex since it may have already accounted for these in the setup.
+    virtual void setupGeometry(int* startVertex,
+                               int* startIndex,
+                               int vertexCount,
+                               int indexCount) = 0;
+
+
+    // The GrGpu typically records the clients requested state and then flushes
+    // deltas from previous state at draw time. This function does the
+    // API-specific flush of the state
+    // returns false if current state is unsupported.
+    virtual bool flushGraphicsState(GrPrimitiveType type) = 0;
+
+    // Sets the scissor rect, or disables if rect is NULL.
+    virtual void flushScissor(const GrIRect* rect) = 0;
+
+    // GrGpu subclass removes the clip from the stencil buffer
+    virtual void eraseStencilClip(const GrIRect& rect) = 0;
+
+private:
+    // readies the pools to provide vertex/index data.
+    void prepareVertexPool();
+    void prepareIndexPool();
+
+    GrPathRenderer* getPathRenderer();
+
+    void handleDirtyContext() {
+        if (fContextIsDirty) {
+            this->resetContext();
+            fContextIsDirty = false;
+        }
+    }
+
+    GrVertexBufferAllocPool*    fVertexPool;
+
+    GrIndexBufferAllocPool*     fIndexPool;
+
+    mutable GrIndexBuffer*      fQuadIndexBuffer; // mutable so it can be
+                                                  // created on-demand
+
+    mutable GrVertexBuffer*     fUnitSquareVertexBuffer; // mutable so it can be
+                                                         // created on-demand
+
+    GrPathRenderer*             fPathRenderer;
+
+    bool                        fContextIsDirty;
+
+    // when in an internal draw these indicate whether the pools are in use
+    // by one of the outer draws. If false then it is safe to reset the
+    // pool.
+    bool                        fVertexPoolInUse;
+    bool                        fIndexPoolInUse;
+
+    // used to save and restore state when the GrGpu needs
+    // to make its geometry pools available internally
+    class AutoInternalDrawGeomRestore {
+    public:
+        AutoInternalDrawGeomRestore(GrGpu* gpu) : fAgsr(gpu) {
+            fGpu = gpu;
+
+            fVertexPoolWasInUse = gpu->fVertexPoolInUse;
+            fIndexPoolWasInUse  = gpu->fIndexPoolInUse;
+
+            gpu->fVertexPoolInUse = fVertexPoolWasInUse ||
+                                   (kBuffer_GeometrySrcType !=
+                                    gpu->fGeometrySrc.fVertexSrc);
+            gpu->fIndexPoolInUse  = fIndexPoolWasInUse ||
+                                   (kBuffer_GeometrySrcType !=
+                                    gpu->fGeometrySrc.fIndexSrc);;
+
+            fSavedPoolVertexBuffer = gpu->fCurrPoolVertexBuffer;
+            fSavedPoolStartVertex  = gpu->fCurrPoolStartVertex;
+            fSavedPoolIndexBuffer  = gpu->fCurrPoolIndexBuffer;
+            fSavedPoolStartIndex   = gpu->fCurrPoolStartIndex;
+
+            fSavedReservedGeometry = gpu->fReservedGeometry;
+            gpu->fReservedGeometry.fLocked = false;
+        }
+        ~AutoInternalDrawGeomRestore() {
+            fGpu->fCurrPoolVertexBuffer = fSavedPoolVertexBuffer;
+            fGpu->fCurrPoolStartVertex  = fSavedPoolStartVertex;
+            fGpu->fCurrPoolIndexBuffer  = fSavedPoolIndexBuffer;
+            fGpu->fCurrPoolStartIndex   = fSavedPoolStartIndex;
+            fGpu->fVertexPoolInUse = fVertexPoolWasInUse;
+            fGpu->fIndexPoolInUse  = fIndexPoolWasInUse;
+            fGpu->fReservedGeometry = fSavedReservedGeometry;
+        }
+    private:
+        AutoGeometrySrcRestore  fAgsr;
+        GrGpu*                  fGpu;
+        const GrVertexBuffer*   fSavedPoolVertexBuffer;
+        int                     fSavedPoolStartVertex;
+        const GrIndexBuffer*    fSavedPoolIndexBuffer;
+        int                     fSavedPoolStartIndex;
+        bool                    fVertexPoolWasInUse;
+        bool                    fIndexPoolWasInUse;
+        ReservedGeometry        fSavedReservedGeometry;
+    };
+
+    typedef GrDrawTarget INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrGpuVertex.h b/gpu/include/GrGpuVertex.h
new file mode 100644
index 0000000..1e3293a
--- /dev/null
+++ b/gpu/include/GrGpuVertex.h
@@ -0,0 +1,104 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGpuVertex_DEFINED
+#define GrGpuVertex_DEFINED
+
+#include "GrGLConfig.h"
+#include "GrPoint.h"
+
+#if GR_TEXT_SCALAR_IS_USHORT
+    typedef uint16_t                GrTextScalar;  
+    #define GrIntToTextScalar(x)    ((uint16_t)x)
+    #define GrFixedToTextScalar(x)  (x)
+#elif GR_TEXT_SCALAR_IS_FIXED
+    typedef GrFixed                 GrTextScalar;
+    #define GrIntToTextScalar(x)    GrIntToFixed(x)
+    #define GrFixedToTextScalar(x)  (x)
+#elif GR_TEXT_SCALAR_IS_FLOAT
+    typedef float                   GrTextScalar;    
+    #define GrIntToTextScalar(x)    ((GrTextScalar)x)
+    #define GrFixedToTextScalar(x)  GrFixedToFloat(x)
+#else
+    #error "Text scalar type not defined"
+#endif
+
+// text has its own vertex class, since it may want to be in fixed point (given)
+// that it starts with all integers) even when the default vertices are floats
+struct GrGpuTextVertex {
+    GrTextScalar fX;
+    GrTextScalar fY;
+
+    void set(GrTextScalar x, GrTextScalar y) {
+        fX = x;
+        fY = y;
+    }
+
+    void setI(int x, int y) {
+        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,
+                    GrTextScalar b) {
+        GrGpuTextVertex* v = this;
+        v[0].set(l, t);
+        v[1].set(l, b);
+        v[2].set(r, b);
+        v[3].set(r, t);
+    }
+
+    void setIRectFan(int l, int t, int r, int b) {
+        this->setRectFan(GrIntToTextScalar(l), GrIntToTextScalar(t),
+                         GrIntToTextScalar(r), GrIntToTextScalar(b));
+    }
+
+    void setIRectFan(int l, int t, int r, int b, size_t stride) {
+        GrAssert(stride > sizeof(GrGpuTextVertex));
+        char* v = (char*)this;
+        ((GrGpuTextVertex*)(v + 0*stride))->setI(l, t);
+        ((GrGpuTextVertex*)(v + 1*stride))->setI(l, b);
+        ((GrGpuTextVertex*)(v + 2*stride))->setI(r, b);
+        ((GrGpuTextVertex*)(v + 3*stride))->setI(r, t);
+    }
+
+    // counter-clockwise fan
+    void setXRectFan(GrFixed l, GrFixed t, GrFixed r, GrFixed b) {
+        this->setRectFan(GrFixedToTextScalar(l), GrFixedToTextScalar(t),
+                         GrFixedToTextScalar(r), GrFixedToTextScalar(b));
+    }
+
+    void setXRectFan(GrFixed l, GrFixed t, GrFixed r, GrFixed b, size_t stride) {
+        GrAssert(stride > sizeof(GrGpuTextVertex));
+        char* v = (char*)this;
+        ((GrGpuTextVertex*)(v + 0*stride))->setX(l, t);
+        ((GrGpuTextVertex*)(v + 1*stride))->setX(l, b);
+        ((GrGpuTextVertex*)(v + 2*stride))->setX(r, b);
+        ((GrGpuTextVertex*)(v + 3*stride))->setX(r, t);
+    }
+
+};
+
+#endif
+
diff --git a/gpu/include/GrIPoint.h b/gpu/include/GrIPoint.h
new file mode 100644
index 0000000..b979a09
--- /dev/null
+++ b/gpu/include/GrIPoint.h
@@ -0,0 +1,35 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrIPoint_DEFINED
+#define GrIPoint_DEFINED
+
+#include "GrTypes.h"
+
+struct GrIPoint {
+public:
+    int32_t fX, fY;
+    
+    GrIPoint(int32_t x, int32_t y) : fX(x), fY(y) {}
+   
+    void set(int32_t x, int32_t y) {
+        fX = x;
+        fY = y;
+    }
+};
+
+#endif
diff --git a/gpu/include/GrInOrderDrawBuffer.h b/gpu/include/GrInOrderDrawBuffer.h
new file mode 100644
index 0000000..79ec458
--- /dev/null
+++ b/gpu/include/GrInOrderDrawBuffer.h
@@ -0,0 +1,176 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrInOrderDrawBuffer_DEFINED
+#define GrInOrderDrawBuffer_DEFINED
+
+#include "GrDrawTarget.h"
+#include "GrAllocPool.h"
+#include "GrAllocator.h"
+#include "GrClip.h"
+
+class GrVertexBufferAllocPool;
+class GrIndexBufferAllocPool;
+
+/**
+ * GrInOrderDrawBuffer is an implementation of GrDrawTarget that queues up
+ * draws for eventual playback into a GrGpu. In theory one draw buffer could
+ * playback into another. When index or vertex buffers are used as geometry
+ * sources it is the callers the draw buffer only holds references to the
+ * buffers. It is the callers responsibility to ensure that the data is still
+ * valid when the draw buffer is played back into a GrGpu. Similarly, it is the
+ * caller's responsibility to ensure that all referenced textures, buffers,
+ * and rendertargets are associated in the GrGpu object that the buffer is
+ * played back into. The buffer requires VB and IB pools to store geometry.
+ */
+
+class GrInOrderDrawBuffer : public GrDrawTarget {
+public:
+
+    /**
+     * Creates a GrInOrderDrawBuffer
+     *
+     * @param vertexPool pool where vertices for queued draws will be saved when
+     *                   the vertex source is either reserved or array.
+     * @param indexPool  pool where indices for queued draws will be saved when
+     *                   the index source is either reserved or array.
+     */
+    GrInOrderDrawBuffer(GrVertexBufferAllocPool* vertexPool,
+                        GrIndexBufferAllocPool* indexPool);
+
+    virtual ~GrInOrderDrawBuffer();
+
+    /**
+     * Copies the draw state and clip from target to this draw buffer.
+     *
+     * @param target    the target whose clip and state should be copied.
+     */
+    void initializeDrawStateAndClip(const GrDrawTarget& target);
+
+    /**
+     * Provides the buffer with an index buffer that can be used for quad rendering.
+     * The buffer may be able to batch consecutive drawRects if this is provided.
+     * @param indexBuffer   index buffer with quad indices.
+     */
+    void setQuadIndexBuffer(const GrIndexBuffer* indexBuffer);
+
+    /**
+     * Empties the draw buffer of any queued up draws.
+     */
+    void reset();
+
+    /**
+     * plays the queued up draws to another target. Does not empty this buffer so
+     * that it can be played back multiple times.
+     * @param target    the target to receive the playback
+     */
+    void playback(GrDrawTarget* target);
+    
+    // overrides from GrDrawTarget
+    virtual void drawIndexed(GrPrimitiveType primitiveType,
+                             int startVertex,
+                             int startIndex,
+                             int vertexCount,
+                             int indexCount);
+    virtual void drawNonIndexed(GrPrimitiveType primitiveType,
+                                int startVertex,
+                                int vertexCount);
+
+    virtual void drawRect(const GrRect& rect, 
+                          const GrMatrix* matrix = NULL,
+                          int stageEnableMask = 0,
+                          const GrRect* srcRects[] = NULL,
+                          const GrMatrix* srcMatrices[] = NULL);
+
+    virtual bool geometryHints(GrVertexLayout vertexLayout,
+                               int* vertexCount,
+                               int* indexCount) const;
+
+private:
+
+    struct Draw {
+        GrPrimitiveType         fPrimitiveType;
+        int                     fStartVertex;
+        int                     fStartIndex;
+        int                     fVertexCount;
+        int                     fIndexCount;
+        bool                    fStateChanged;
+        bool                    fClipChanged;
+        GrVertexLayout          fVertexLayout;
+        const GrVertexBuffer*   fVertexBuffer;
+        const GrIndexBuffer*    fIndexBuffer;
+    };
+
+    virtual bool acquireGeometryHelper(GrVertexLayout vertexLayout,
+                                       void**         vertices,
+                                       void**         indices);
+    virtual void releaseGeometryHelper();
+    virtual void clipWillBeSet(const GrClip& newClip);
+
+    virtual void setVertexSourceToArrayHelper(const void* vertexArray,
+                                              int vertexCount);
+
+    virtual void setIndexSourceToArrayHelper(const void* indexArray,
+                                             int indexCount);
+
+    bool needsNewState() const;
+    bool needsNewClip() const;
+
+    void pushState();
+    void pushClip();
+
+    GrTAllocator<Draw>              fDraws;
+    GrTAllocator<SavedDrawState>    fStates;
+
+    GrTAllocator<GrClip>            fClips;
+    bool                            fClipSet;
+
+    GrVertexLayout                  fLastRectVertexLayout;
+    const GrIndexBuffer*            fQuadIndexBuffer;
+    int                             fMaxQuads;
+    int                             fCurrQuad;
+
+    GrVertexBufferAllocPool&        fVertexPool;
+    const GrVertexBuffer*           fCurrPoolVertexBuffer;
+    int                             fCurrPoolStartVertex;
+
+    GrIndexBufferAllocPool&         fIndexPool;
+    const GrIndexBuffer*            fCurrPoolIndexBuffer;
+    int                             fCurrPoolStartIndex;
+
+    // caller may conservatively over reserve vertices / indices.
+    // we release unused space back to allocator if possible
+    size_t                          fReservedVertexBytes;
+    size_t                          fReservedIndexBytes;
+    size_t                          fUsedReservedVertexBytes;
+    size_t                          fUsedReservedIndexBytes;
+
+    static const uint32_t           STATES_BLOCK_SIZE = 8;
+    static const uint32_t           DRAWS_BLOCK_SIZE  = 8;
+    static const uint32_t           CLIPS_BLOCK_SIZE  = 8;
+    static const uint32_t           VERTEX_BLOCK_SIZE = 1 << 12;
+    static const uint32_t           INDEX_BLOCK_SIZE  = 1 << 10;
+    int8_t                          fDrawsStorage[sizeof(Draw) *
+                                                  DRAWS_BLOCK_SIZE];
+    int8_t                          fStatesStorage[sizeof(SavedDrawState) *
+                                                   STATES_BLOCK_SIZE];
+    int8_t                          fClipsStorage[sizeof(GrClip) *
+                                                  CLIPS_BLOCK_SIZE];
+    typedef GrDrawTarget INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrIndexBuffer.h b/gpu/include/GrIndexBuffer.h
new file mode 100644
index 0000000..09d1977
--- /dev/null
+++ b/gpu/include/GrIndexBuffer.h
@@ -0,0 +1,38 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrIndexBuffer_DEFINED
+#define GrIndexBuffer_DEFINED
+
+#include "GrGeometryBuffer.h"
+
+class GrIndexBuffer : public GrGeometryBuffer {
+public:
+        /**
+         * Retrieves the maximum number of quads that could be rendered
+         * from the index buffer (using kTriangles_PrimitiveType).
+         * @return the maximum number of quads using full size of index buffer.
+         */
+        int maxQuads() const { return size() / (sizeof(uint16_t) * 6); }
+protected:
+    GrIndexBuffer(size_t sizeInBytes, bool dynamic) :
+        INHERITED(sizeInBytes, dynamic) {}
+private:
+    typedef GrGeometryBuffer INHERITED;
+};
+
+#endif
diff --git a/gpu/include/GrInstanceCounter.h b/gpu/include/GrInstanceCounter.h
new file mode 100644
index 0000000..11cec2b
--- /dev/null
+++ b/gpu/include/GrInstanceCounter.h
@@ -0,0 +1,47 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrInstanceCounter_DEFINED
+#define GrInstanceCounter_DEFINED
+
+#include "GrTypes.h"
+
+template <typename T> class GrInstanceCounter {
+public:
+    GrInstanceCounter() {
+        ++gCounter;
+        GrPrintf("+ %s %d\n", T::InstanceCounterClassName(), gCounter);
+    }
+
+    ~GrInstanceCounter() {
+        --gCounter;
+        GrPrintf("- %s %d\n", T::InstanceCounterClassName(), gCounter);
+    }
+
+private:
+    static int gCounter;
+};
+
+template <typename T> int GrInstanceCounter<T>::gCounter;
+
+#define DECLARE_INSTANCE_COUNTER(T)                                 \
+    static const char* InstanceCounterClassName() { return #T; }    \
+    friend class GrInstanceCounter<T>;                              \
+    GrInstanceCounter<T> fInstanceCounter
+
+#endif
+
diff --git a/gpu/include/GrKey.h b/gpu/include/GrKey.h
new file mode 100644
index 0000000..19133ae
--- /dev/null
+++ b/gpu/include/GrKey.h
@@ -0,0 +1,47 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrKey_DEFINED
+#define GrKey_DEFINED
+
+#include "GrRefCnt.h"
+
+class GrKey : public GrRefCnt {
+public:
+    typedef intptr_t Hash;
+
+    explicit GrKey(Hash hash) : fHash(hash) {}
+
+    intptr_t getHash() const { return fHash; }
+
+    bool operator<(const GrKey& rh) const {
+        return fHash < rh.fHash || (fHash == rh.fHash && this->lt(rh));
+    }
+    bool operator==(const GrKey& rh) const {
+        return fHash == rh.fHash && this->eq(rh);
+    }
+
+protected:
+    virtual bool lt(const GrKey& rh) const = 0;
+    virtual bool eq(const GrKey& rh) const = 0;
+
+private:
+    const Hash fHash;
+};
+
+#endif
+
diff --git a/gpu/include/GrMatrix.h b/gpu/include/GrMatrix.h
new file mode 100644
index 0000000..9a2e660
--- /dev/null
+++ b/gpu/include/GrMatrix.h
@@ -0,0 +1,400 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrMatrix_DEFINED
+#define GrMatrix_DEFINED
+
+#include "GrPoint.h"
+
+struct GrRect;
+
+/*
+ * 3x3 matrix
+ */
+class GrMatrix {
+public:
+    static const GrMatrix& I() {
+        static const GrMatrix I = GrMatrix(GR_Scalar1, 0, 0,
+                                           0, GR_Scalar1, 0,
+                                           0, 0, gRESCALE);
+        return I;
+    };
+    static const GrMatrix& InvalidMatrix() {
+        static const GrMatrix INV = 
+            GrMatrix(GR_ScalarMax, GR_ScalarMax, GR_ScalarMax,
+                     GR_ScalarMax, GR_ScalarMax, GR_ScalarMax,
+                     GR_ScalarMax, GR_ScalarMax, GR_ScalarMax);
+        return INV;
+    }
+    /** 
+     * Handy index constants
+     */
+    enum {
+        kScaleX,
+        kSkewX,
+        kTransX,
+        kSkewY,
+        kScaleY,
+        kTransY,
+        kPersp0,
+        kPersp1,
+        kPersp2
+    };
+    
+    /**
+     * Create an uninitialized matrix
+     */
+    GrMatrix() {
+        fTypeMask = 0;
+    }
+    
+    /**
+     * Create a matrix from an array of values
+     * @param values    row-major array of matrix components
+     */
+    explicit GrMatrix(const GrScalar values[]) {
+        setToArray(values);
+    }
+    
+    /**
+     * Create a matrix from values
+     * @param scaleX    (0,0) matrix element
+     * @param skewX     (0,1) matrix element
+     * @param transX    (0,2) matrix element
+     * @param skewY     (1,0) matrix element
+     * @param scaleY    (1,1) matrix element
+     * @param transY    (1,2) matrix element
+     * @param persp0    (2,0) matrix element
+     * @param persp1    (2,1) matrix element
+     * @param persp2    (2,2) matrix element
+     */
+    GrMatrix(GrScalar scaleX,
+             GrScalar skewX,
+             GrScalar transX,
+             GrScalar skewY,
+             GrScalar scaleY,
+             GrScalar transY,
+             GrScalar persp0,
+             GrScalar persp1,
+             GrScalar persp2) {
+        setAll(scaleX, skewX,  transX,
+               skewY,  scaleY, transY,
+               persp0, persp1, persp2);
+    }
+
+    /**
+     * access matrix component
+     * @return matrix component value
+     */
+    const GrScalar& operator[] (int idx) const {
+        GrAssert((unsigned)idx < 9);
+        return fM[idx];
+    }
+
+    /**
+     * Set a matrix from an array of values
+     * @param values    row-major array of matrix components
+     */
+    void setToArray(const GrScalar values[]) {
+        for (int i = 0; i < 9; ++i) {
+            fM[i] = values[i];
+        }
+        this->computeTypeMask();
+    }
+    
+    /**
+     * Create a matrix from values
+     * @param scaleX    (0,0) matrix element
+     * @param skewX     (0,1) matrix element
+     * @param transX    (0,2) matrix element
+     * @param skewY     (1,0) matrix element
+     * @param scaleY    (1,1) matrix element
+     * @param transY    (1,2) matrix element
+     * @param persp0    (2,0) matrix element
+     * @param persp1    (2,1) matrix element
+     * @param persp2    (2,2) matrix element
+     */
+    void setAll(GrScalar scaleX,
+                GrScalar skewX,
+                GrScalar transX,
+                GrScalar skewY,
+                GrScalar scaleY,
+                GrScalar transY,
+                GrScalar persp0,
+                GrScalar persp1,                
+                GrScalar persp2) {
+        fM[kScaleX] = scaleX;
+        fM[kSkewX]  = skewX;
+        fM[kTransX] = transX;
+        fM[kSkewY]  = skewY;
+        fM[kScaleY] = scaleY;
+        fM[kTransY] = transY;
+        fM[kPersp0] = persp0;
+        fM[kPersp1] = persp1;
+        fM[kPersp2] = persp2;
+        
+        this->computeTypeMask();
+    }
+    
+    /**
+     * set matrix component
+     * @param idx    index of component to set
+     * @param value  value to set component to
+     */
+    inline void set(int idx, GrScalar value);
+    
+    /**
+     * make this matrix an identity matrix
+     */
+    void setIdentity();
+
+    /**
+     * overwrite entire matrix to be a translation matrix
+     * @param dx    amount to translate by in x
+     * @param dy    amount to translate by in y
+     */
+    void setTranslate(GrScalar dx, GrScalar dy);
+
+    /**
+     * overwrite entire matrix to be a scaling matrix
+     * @param sx    x scale factor
+     * @param sy    y scale factor
+     */
+    void setScale(GrScalar sx, GrScalar sy);
+
+    /**
+     * overwrite entire matrix to be a skew matrix
+     * @param skx   x skew factor
+     * @param sky   y skew factor
+     */
+    void setSkew(GrScalar skx, GrScalar sky);
+
+    /**
+     * set this matrix to be a concantenation of two
+     * matrices (a*b). Either a, b, or both can be this matrix.
+     * @param a     first matrix to multiply
+     * @param b     second matrix to multiply
+     */
+    void setConcat(const GrMatrix& a, const GrMatrix& b);
+
+    /**
+     * Set this matrix to this*m
+     * @param m     matrix to concatenate
+     */
+    void preConcat(const GrMatrix& m);
+
+    /**
+     * Set this matrix to m*this
+     * @param m     matrix to concatenate
+     */
+    void postConcat(const GrMatrix& m);
+
+    /**
+     *  Compute the inverse of this matrix, and return true if it is invertible,
+     *  or false if not.
+     *
+     *  If inverted is not null, and the matrix is invertible, then the inverse
+     *  is written into it. If the matrix is not invertible (this method returns
+     *  false) then inverted is left unchanged.
+     */
+    bool invert(GrMatrix* inverted) const;
+    
+    /**
+     * Transforms a point by the matrix
+     *
+     * @param src   the point to transform
+     * @return the transformed point
+     */
+    GrPoint mapPoint(const GrPoint& src) const {
+        GrPoint result;
+        (this->*gMapProcs[fTypeMask])(&result, &src, 1);
+        return result;
+    }
+    
+    /**
+     * Transforms an array of points by the matrix.
+     *
+     * @param dstPts the array to write transformed points into
+     * @param srcPts the array of points to transform
+     @ @param count the number of points to transform
+     */
+    void mapPoints(GrPoint dstPts[], 
+                   const GrPoint srcPts[], 
+                   uint32_t count) const {
+        (this->*gMapProcs[fTypeMask])(dstPts, srcPts, count);
+    }
+
+    /**
+     * Transforms pts with arbitrary stride in place.
+     *
+     * @param start  pointer to first point to transform
+     * @param stride distance in bytes between consecutive points
+     @ @param count the number of points to transform
+     */
+    void mapPointsWithStride(GrPoint* start, 
+                             size_t stride, 
+                             uint32_t count) const {
+        for (uint32_t i = 0; i < count; ++i) {            
+            this->mapPoints(start, start, 1);
+            start = (GrPoint*)((intptr_t)start + stride);
+        }
+    }
+    
+    /**
+     *  Transform the 4 corners of the src rect, and return the bounding rect
+     *  in the dst rect. Note: src and dst may point to the same memory.
+     */
+    void mapRect(GrRect* dst, const GrRect& src) const;
+
+    /**
+     *  Transform the 4 corners of the rect, and return their bounds in the rect
+     */
+    void mapRect(GrRect* rect) const {
+        this->mapRect(rect, *rect);
+    }
+
+    /**
+     * Checks if matrix is a perspective matrix.
+     * @return true if third row is not (0, 0, 1)
+     */
+    bool hasPerspective() const;
+    
+    /**
+     * Checks whether matrix is identity
+     * @return true if matrix is idenity
+     */
+    bool isIdentity() const;
+    
+    /**
+     * Calculates the maximum stretching factor of the matrix. Only defined if
+     * the matrix does not have perspective.
+     *
+     * @return maximum strecthing factor or negative if matrix has perspective.
+     */
+    GrScalar getMaxStretch() const;
+
+    /**
+     * Checks for matrix equality. Test is element-by-element equality,
+     * not a homogeneous test.
+     * @return true if matrices are equal, false otherwise
+     */
+    bool operator == (const GrMatrix& m) const;
+
+    /**
+     * Checks for matrix inequality. Test is element-by-element inequality,
+     * not a homogeneous test.
+     * @return true if matrices are not equal, false otherwise
+     */
+    bool operator != (const GrMatrix& m) const;
+    
+    static void UnitTest();
+
+private:
+    static const GrScalar gRESCALE;
+
+    void computeTypeMask() {
+        fTypeMask = 0;
+        if (0 != fM[kPersp0] || 0 != fM[kPersp1] || gRESCALE != fM[kPersp2]) {
+            fTypeMask |= kPerspective_TypeBit;
+        }
+        if (GR_Scalar1 != fM[kScaleX] || GR_Scalar1 != fM[kScaleY]) {
+            fTypeMask |= kScale_TypeBit;
+            if (0 == fM[kScaleX] && 0 == fM[kScaleY]) {
+                fTypeMask |= kZeroScale_TypeBit;
+            }
+        }
+        if (0 != fM[kSkewX] || 0 != fM[kSkewY]) {
+            fTypeMask |= kSkew_TypeBit;
+        }
+        if (0 != fM[kTransX] || 0 != fM[kTransY]) {
+            fTypeMask |= kTranslate_TypeBit;
+        }
+    }
+
+    
+    double determinant() const;
+    
+    enum TypeBits {
+        kScale_TypeBit       = 1 << 0, // set if scales are not both 1
+        kTranslate_TypeBit   = 1 << 1, // set if translates are not both 0
+        kSkew_TypeBit        = 1 << 2, // set if skews are not both 0
+        kPerspective_TypeBit = 1 << 3, // set if perspective
+        kZeroScale_TypeBit   = 1 << 4, // set if scales are both zero
+    };
+
+    void mapIdentity(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapScale(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapScaleAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapSkew(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapScaleAndSkew(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapSkewAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapNonPerspective(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapPerspective(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapZero(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapSetToTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapSwappedScale(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    void mapSwappedScaleAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    
+    void mapInvalid(GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    
+    typedef void (GrMatrix::*MapProc) (GrPoint* dst, const GrPoint* src, uint32_t count) const;
+    static const MapProc gMapProcs[];
+
+    int      fTypeMask;
+    
+    GrScalar fM[9];
+};
+
+void GrMatrix::set(int idx, GrScalar value) {
+    GrAssert((unsigned)idx < 9);
+    fM[idx] = value;
+    if (idx > 5) {
+        if (0 != fM[kPersp0] || 0 != fM[kPersp1] ||
+            gRESCALE != fM[kPersp2]) {
+            fTypeMask |= kPerspective_TypeBit;
+        } else {
+            fTypeMask &= ~kPerspective_TypeBit;
+        }
+    } else if (!(idx % 4)) {
+        if ((GR_Scalar1 == fM[kScaleX] && GR_Scalar1 == fM[kScaleY])) {
+            fTypeMask &= ~kScale_TypeBit;
+            fTypeMask &= ~kZeroScale_TypeBit;
+        } else {
+            fTypeMask |= kScale_TypeBit;
+            if ((0 == fM[kScaleX] && 0 == fM[kScaleY])) {
+                fTypeMask |= kZeroScale_TypeBit;
+            } else {
+                fTypeMask &= ~kZeroScale_TypeBit;
+            }
+        }
+    } else if (2 == (idx % 3)) {
+        if (0 != fM[kTransX] || 0 != fM[kTransY]) {
+            fTypeMask |= kTranslate_TypeBit;
+        } else {
+            fTypeMask &= ~kTranslate_TypeBit;
+        }
+    } else {
+        if (0 != fM[kSkewX] || 0 != fM[kSkewY]) {
+            fTypeMask |= kSkew_TypeBit;
+        } else {
+            fTypeMask &= ~kSkew_TypeBit;
+        }
+    }
+}
+
+#endif
diff --git a/gpu/include/GrMemory.h b/gpu/include/GrMemory.h
new file mode 100644
index 0000000..be8b1d7
--- /dev/null
+++ b/gpu/include/GrMemory.h
@@ -0,0 +1,181 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrMemory_DEFINED
+#define GrMemory_DEFINED
+
+#include "GrNoncopyable.h"
+
+class GrAutoMalloc : GrNoncopyable {
+public:
+    GrAutoMalloc() : fPtr(NULL), fAllocatedBytes(0){
+    }
+
+    GrAutoMalloc(size_t bytes) : fPtr(GrMalloc(bytes)), fAllocatedBytes(bytes) {}
+    ~GrAutoMalloc() { GrFree(fPtr); }
+
+    /**
+     *  Return the allocated memory, or NULL if it has already been freed or
+     *  detached.
+     */
+    void* get() const { return fPtr; }
+
+    size_t size() const { return fAllocatedBytes; }
+
+    /**
+     *  transfer ownership of the memory to the caller. It must be freed with
+     *  a call to GrFree()
+     */
+    void* detach() {
+        void* ptr = fPtr;
+        fPtr = NULL;    // we no longer own the block
+        fAllocatedBytes = 0;
+        return ptr;
+    }
+
+    /**
+     *  Reallocates to a new size. May or may not call malloc. The contents
+     *  are not preserved. If growOnly is true it will never reduce the
+     *  allocated size.
+     */
+    void* realloc(size_t newSize, bool growOnly = false) {
+        bool alloc;
+        if (growOnly) {
+            alloc = newSize > fAllocatedBytes;
+        } else {
+            alloc = newSize != fAllocatedBytes;
+        }
+        if (alloc) {
+            GrFree(fPtr);
+            fPtr = newSize ? GrMalloc(newSize) : NULL;
+            fAllocatedBytes = newSize;
+        }
+        GrAssert(fAllocatedBytes >= newSize);
+        GR_DEBUGCODE(memset(fPtr, 0xEF, fAllocatedBytes));
+        return fPtr;
+    }
+
+    /**
+     *  free the block now. get() will now return NULL
+     */
+    void free() {
+        GrFree(fPtr);
+        fPtr = NULL;
+        fAllocatedBytes = 0;
+    }
+
+private:
+    void* fPtr;
+    size_t fAllocatedBytes;
+};
+
+/**
+ *  Variant of GrAutoMalloc with a compile-time specified byte size that is
+ *  pre-allocated in the class object, avoiding a call to to GrMalloc if
+ *  possible.
+ */
+template <size_t SIZE> class GrAutoSMalloc : GrNoncopyable {
+public:
+    GrAutoSMalloc() {
+        fPtr = fStorage;
+        fAllocatedBytes = SIZE;
+    }
+
+    explicit GrAutoSMalloc(size_t bytes) {
+        if (bytes > SIZE) {
+            fPtr = GrMalloc(bytes);
+            fAllocatedBytes = bytes;
+        } else {
+            fPtr = fStorage;
+            fAllocatedBytes = SIZE;
+        }
+    }
+
+    ~GrAutoSMalloc() {
+        if (fPtr != (void*)fStorage) {
+            GrFree(fPtr);
+        }
+    }
+
+    /**
+     *  Return the allocated memory, or NULL if it has already been freed or
+     *  detached.
+     */
+    void* get() const { return fPtr; }
+
+    /**
+     *  Reallocates to a new size. May or may not call malloc. The contents
+     *  are not preserved. If growOnly is true it will never reduce the
+     *  allocated size.
+     */
+    void* realloc(size_t newSize, bool growOnly = false) {
+        if (newSize <= SIZE) {
+            if (NULL == fPtr) {
+                fPtr = fStorage;
+                fAllocatedBytes = SIZE;
+            } else if (!growOnly && fPtr != (void*)fStorage) {
+                GrFree(fPtr);
+                fPtr = fStorage;
+                fAllocatedBytes = SIZE;
+            }
+        } else if ((newSize > fAllocatedBytes) ||
+                   (!growOnly && newSize < (fAllocatedBytes >> 1))) {
+            if (NULL != fPtr && fPtr != (void*)fStorage) {
+                GrFree(fPtr);
+            }
+            fPtr = GrMalloc(newSize);
+            fAllocatedBytes = newSize;
+        }
+        GrAssert(fAllocatedBytes >= newSize);
+        GrAssert((fPtr == fStorage) == (fAllocatedBytes == SIZE));
+        GR_DEBUGCODE(memset(fPtr, 0xEF, fAllocatedBytes));
+        return fPtr;
+    }
+
+    /**
+     *  free the block now. get() will now return NULL
+     */
+    void free() {
+        if (fPtr != (void*)fStorage) {
+            GrFree(fPtr);
+        }
+        fAllocatedBytes = 0;
+        fPtr = NULL;
+    }
+
+private:
+    void*    fPtr;
+    uint32_t fAllocatedBytes;
+    uint32_t fStorage[GrALIGN4(SIZE) >> 2];
+};
+
+/**
+ *  Variant of GrAutoMalloc with a compile-time specified byte size that is
+ *  pre-allocated in the class object, avoiding a call to to GrMalloc if
+ *  possible.
+ */
+template <int COUNT, typename T>
+class GrAutoSTMalloc : public GrAutoSMalloc<COUNT * sizeof(T)> {
+public:
+    GrAutoSTMalloc(int count) : GrAutoSMalloc<COUNT * sizeof(T)>(count * sizeof(T)) {}
+
+    operator T*() { return (T*)this->get(); }
+};
+
+
+#endif
+
diff --git a/gpu/include/GrMesh.h b/gpu/include/GrMesh.h
new file mode 100644
index 0000000..4d904e4
--- /dev/null
+++ b/gpu/include/GrMesh.h
@@ -0,0 +1,42 @@
+#ifndef GrMesh_DEFINED
+#define GrMesh_DEFINED
+
+#include "SkRect.h"
+#include "SkPoint.h"
+
+class SkCanvas;
+class SkPaint;
+
+class GrMesh {
+public:
+    GrMesh();
+    ~GrMesh();
+
+    GrMesh& operator=(const GrMesh& src);
+
+    void init(const SkRect& bounds, int rows, int cols,
+              const SkRect& texture);
+
+    const SkRect& bounds() const { return fBounds; }
+
+    int rows() const { return fRows; }
+    int cols() const { return fCols; }
+    SkPoint& pt(int row, int col) {
+        return fPts[row * (fRows + 1) + col];
+    }
+
+    void draw(SkCanvas*, const SkPaint&);
+    void drawWireframe(SkCanvas* canvas, const SkPaint& paint);
+
+private:
+    SkRect      fBounds;
+    int         fRows, fCols;
+    SkPoint*    fPts;
+    SkPoint*    fTex;   // just points into fPts, not separately allocated
+    int         fCount;
+    uint16_t*   fIndices;
+    int         fIndexCount;
+};
+
+#endif
+
diff --git a/gpu/include/GrNoncopyable.h b/gpu/include/GrNoncopyable.h
new file mode 100644
index 0000000..888e3b1
--- /dev/null
+++ b/gpu/include/GrNoncopyable.h
@@ -0,0 +1,38 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrNoncopyable_DEFINED
+#define GrNoncopyable_DEFINED
+
+#include "GrTypes.h"
+
+/**
+ *  Base for classes that want to disallow copying themselves. It makes its
+ *  copy-constructor and assignment operators private (and unimplemented).
+ */
+class GrNoncopyable {
+public:
+    GrNoncopyable() {}
+
+private:
+    // illegal
+    GrNoncopyable(const GrNoncopyable&);
+    GrNoncopyable& operator=(const GrNoncopyable&);
+};
+
+#endif
+
diff --git a/gpu/include/GrPaint.h b/gpu/include/GrPaint.h
new file mode 100644
index 0000000..9402209
--- /dev/null
+++ b/gpu/include/GrPaint.h
@@ -0,0 +1,103 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrPaint_DEFINED
+#define GrPaint_DEFINED
+
+#include "GrTexture.h"
+#include "GrColor.h"
+#include "GrSamplerState.h"
+
+/**
+ * The paint describes how pixels are colored when the context draws to
+ * them.
+ */
+class GrPaint {
+public:
+
+    // All the paint fields are public except texture (it's ref-counted)
+    GrBlendCoeff                fSrcBlendCoeff;
+    GrBlendCoeff                fDstBlendCoeff;
+    bool                        fAntiAlias;
+    bool                        fDither;
+
+    GrColor                     fColor;
+
+    GrSamplerState              fSampler;
+
+    void setTexture(GrTexture* texture) {
+        GrSafeRef(texture);
+        GrSafeUnref(fTexture);
+        fTexture = texture;
+    }
+
+    GrTexture* getTexture() const { return fTexture; }
+
+    // uninitialized
+    GrPaint() {
+        fTexture = NULL;
+    }
+
+    GrPaint(const GrPaint& paint) {
+        fSrcBlendCoeff = paint.fSrcBlendCoeff;
+        fDstBlendCoeff = paint.fDstBlendCoeff;
+        fAntiAlias = paint.fAntiAlias;
+        fDither = paint.fDither;
+
+        fColor = paint.fColor;
+
+        fSampler = paint.fSampler;
+        fTexture = paint.fTexture;
+        GrSafeRef(fTexture);
+    }
+
+    ~GrPaint() {
+        GrSafeUnref(fTexture);
+    }
+
+    // sets paint to src-over, solid white, no texture
+    void reset() {
+        resetBlend();
+        resetOptions();
+        resetColor();
+        resetTexture();
+    }
+
+private:
+    GrTexture*      fTexture;
+
+    void resetBlend() {
+        fSrcBlendCoeff = kOne_BlendCoeff;
+        fDstBlendCoeff = kZero_BlendCoeff;
+    }
+
+    void resetOptions() {
+        fAntiAlias = false;
+        fDither = false;
+    }
+
+    void resetColor() {
+        fColor = GrColorPackRGBA(0xff, 0xff, 0xff, 0xff);
+    }
+
+    void resetTexture() {
+        setTexture(NULL);
+        fSampler.setClampNoFilter();
+    }
+
+};
+
+#endif
diff --git a/gpu/include/GrPath.h b/gpu/include/GrPath.h
new file mode 100644
index 0000000..80bbeb3
--- /dev/null
+++ b/gpu/include/GrPath.h
@@ -0,0 +1,103 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrPath_DEFINED
+#define GrPath_DEFINED
+
+#include "GrPathSink.h"
+#include "GrPathIter.h"
+#include "GrTDArray.h"
+#include "GrPoint.h"
+
+class GrPath : public GrPathSink {
+public:
+    GrPath();
+    GrPath(const GrPath&);
+    explicit GrPath(GrPathIter&);
+    virtual ~GrPath();
+
+    GrConvexHint getConvexHint() const { return fConvexHint; }
+    void setConvexHint(GrConvexHint hint) { fConvexHint = hint; }
+
+    void resetFromIter(GrPathIter*);
+
+    bool operator ==(const GrPath& path) const;
+    bool operator !=(const GrPath& path) const { return !(*this == path); }
+    // overrides from GrPathSink
+
+    virtual void moveTo(GrScalar x, GrScalar y);
+    virtual void lineTo(GrScalar x, GrScalar y);
+    virtual void quadTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1);
+    virtual void cubicTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1,
+                         GrScalar x2, GrScalar y2);
+    virtual void close();
+
+    /**
+     *  Offset the path by (tx, ty), adding tx to the horizontal position
+     *  and adds ty to the vertical position of every point.
+     */
+    void offset(GrScalar tx, GrScalar ty);
+
+    class Iter : public GrPathIter {
+    public:
+        /**
+         * Creates an uninitialized iterator
+         */
+        Iter();
+
+        Iter(const GrPath& path);
+
+        // overrides from GrPathIter
+        virtual GrPathCmd next(GrPoint points[]);
+        virtual GrConvexHint convexHint() const;
+        virtual GrPathCmd next();
+        virtual void rewind();
+
+        /**
+         * Sets iterator to begining of path
+         */
+        void reset(const GrPath& path);
+    private:
+        const GrPath* fPath;
+        GrPoint       fLastPt;
+        int           fCmdIndex;
+        int           fPtIndex;
+    };
+
+    static void ConvexUnitTest();
+
+private:
+
+    GrTDArray<GrPathCmd>    fCmds;
+    GrTDArray<GrPoint>      fPts;
+    GrConvexHint  fConvexHint;
+
+    // this ensures we have a moveTo at the start of each contour
+    inline void ensureMoveTo();
+
+    bool wasLastVerb(GrPathCmd cmd) const {
+        int count = fCmds.count();
+        return count > 0 && cmd == fCmds[count - 1];
+    }
+
+    friend class Iter;
+
+    typedef GrPathSink INHERITED;
+};
+
+#endif
+
diff --git a/gpu/include/GrPathIter.h b/gpu/include/GrPathIter.h
new file mode 100644
index 0000000..55427c0
--- /dev/null
+++ b/gpu/include/GrPathIter.h
@@ -0,0 +1,70 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrPathIter_DEFINED
+#define GrPathIter_DEFINED
+
+#include "GrTypes.h"
+
+struct GrPoint;
+
+/**
+ 2D Path iterator. Porting layer creates a subclass of this. It allows Ganesh to
+ parse the top-level API's 2D paths. Supports lines, quadratics, and cubic
+ pieces and moves (multi-part paths).
+ */
+class GrPathIter {
+public:
+
+    virtual ~GrPathIter() {};
+
+    /**
+     * Iterates through the path. Should not be called after
+     * kEnd_Command has been returned once. This version retrieves the
+     * points for the command.
+     * @param points  The points relevant to returned commend. See Command
+     *               enum for number of points valid for each command.
+     * @return The next command of the path.
+     */
+    virtual GrPathCmd next(GrPoint points[4]) = 0;
+
+    /**
+     * If the host API has knowledge of the convexity of the path
+     * it can be communicated by this hint. Gr can analyze the path
+     * as it is iterated. So it is not necessary to do additional work to
+     * compute convexity status if it isn't already determined.
+     *
+     * @return a hint about the convexity of the path.
+     */
+    virtual GrConvexHint convexHint() const = 0;
+
+     /**
+      * Iterates through the path. Should not be called after
+      * kEnd_Command has been returned once. This version does not retrieve the
+      * points for the command.
+      * @return The next command of the path.
+      */
+     virtual GrPathCmd next() = 0;
+
+    /**
+     Restarts iteration from the beginning.
+     */
+    virtual void rewind() = 0;
+
+};
+
+#endif
diff --git a/gpu/include/GrPathSink.h b/gpu/include/GrPathSink.h
new file mode 100644
index 0000000..4e8a0c2
--- /dev/null
+++ b/gpu/include/GrPathSink.h
@@ -0,0 +1,36 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrPathSink_DEFINED
+#define GrPathSink_DEFINED
+
+#include "GrScalar.h"
+
+class GrPathSink {
+public:
+    virtual ~GrPathSink() {}
+
+    virtual void moveTo(GrScalar x, GrScalar y) = 0;
+    virtual void lineTo(GrScalar x, GrScalar y) = 0;
+    virtual void quadTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1) = 0;
+    virtual void cubicTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1,
+                         GrScalar x2, GrScalar y2) = 0;
+    virtual void close() = 0;
+};
+
+#endif
+
diff --git a/gpu/include/GrPlotMgr.h b/gpu/include/GrPlotMgr.h
new file mode 100644
index 0000000..cd60bde
--- /dev/null
+++ b/gpu/include/GrPlotMgr.h
@@ -0,0 +1,84 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrPlotMgr_DEFINED
+#define GrPlotMgr_DEFINED
+
+#include "GrTypes.h"
+#include "GrPoint.h"
+
+class GrPlotMgr : GrNoncopyable {
+public:
+    GrPlotMgr(int width, int height) {
+        fDim.set(width, height);
+        size_t needed = width * height;
+        if (needed <= sizeof(fStorage)) {
+            fBusy = fStorage;
+        } else {
+            fBusy = new char[needed];
+        }
+        this->reset();
+    }
+
+    ~GrPlotMgr() {
+        if (fBusy != fStorage) {
+            delete[] fBusy;
+        }
+    }
+    
+    void reset() {
+        Gr_bzero(fBusy, fDim.fX * fDim.fY);
+    }
+
+    bool newPlot(GrIPoint16* loc) {
+        char* busy = fBusy;
+        for (int y = 0; y < fDim.fY; y++) {
+            for (int x = 0; x < fDim.fX; x++) {
+                if (!*busy) {
+                    *busy = true;
+                    loc->set(x, y);
+                    return true;
+                }
+                busy++;
+            }
+        }
+        return false;
+    }
+
+    bool isBusy(int x, int y) const {
+        GrAssert((unsigned)x < (unsigned)fDim.fX);
+        GrAssert((unsigned)y < (unsigned)fDim.fY);
+        return fBusy[y * fDim.fX + x] != 0;
+    }
+
+    void freePlot(int x, int y) {
+        GrAssert((unsigned)x < (unsigned)fDim.fX);
+        GrAssert((unsigned)y < (unsigned)fDim.fY);
+        fBusy[y * fDim.fX + x] = false;
+    }
+
+private:
+    enum {
+        STORAGE = 64
+    };
+    char fStorage[STORAGE];
+    char* fBusy;
+    GrIPoint16  fDim;
+};
+
+#endif
+
diff --git a/gpu/include/GrPoint.h b/gpu/include/GrPoint.h
new file mode 100644
index 0000000..c07543b
--- /dev/null
+++ b/gpu/include/GrPoint.h
@@ -0,0 +1,334 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrPoint_DEFINED
+#define GrPoint_DEFINED
+
+#include "GrTypes.h"
+#include "GrScalar.h"
+
+/**
+ *  2D Point struct
+ */
+struct GrPoint {
+public:
+    GrScalar fX, fY;
+
+    GrPoint() {}
+    GrPoint(GrScalar x, GrScalar y) { fX = x; fY = y; }
+    
+    GrScalar x() const { return fX; }
+    GrScalar y() const { return fY; }
+
+    void set(GrScalar x, GrScalar y) {
+        fX = x;
+        fY = y;
+    }
+    
+    void setAsMidPoint(const GrPoint& a, const GrPoint& b) {
+        fX = GrScalarAve(a.fX, b.fX);
+        fY = GrScalarAve(a.fY, b.fY);
+    }
+
+    void offset(GrScalar dx, GrScalar dy) {
+        fX += dx;
+        fY += dy;
+    }
+
+    GrScalar distanceToSqd(const GrPoint& p) const {
+        GrScalar dx = (p.fX - fX);
+        GrScalar dy = (p.fY - fY);
+        return GrMul(dx, dx) + GrMul(dy, dy);
+    }
+    
+    GrScalar distanceTo(const GrPoint& p) const {
+        // TODO: fixed point sqrt
+        return GrFloatToScalar(sqrtf(GrScalarToFloat(distanceToSqd(p))));
+    }
+    
+    GrScalar distanceToOriginSqd() const {
+        return GrMul(fX, fX) + GrMul(fY, fY);
+    }
+
+    GrScalar distanceToOrigin() const {
+        return GrFloatToScalar(sqrtf(GrScalarToFloat(distanceToOriginSqd())));
+    }
+    
+    inline GrScalar distanceToLineBetweenSqd(const GrPoint& a, 
+                                             const GrPoint& b) const;
+
+    inline GrScalar distanceToLineBetween(const GrPoint& a, 
+                                          const GrPoint& b) const;
+    
+    inline GrScalar distanceToLineSegmentBetweenSqd(const GrPoint& a, 
+                                                    const GrPoint& b) const;
+    
+    inline GrScalar distanceToLineSegmentBetween(const GrPoint& a, 
+                                                 const GrPoint& b) const;
+    
+    // counter-clockwise fan
+    void setRectFan(GrScalar l, GrScalar t, GrScalar r, GrScalar b) {
+        GrPoint* v = this;
+        v[0].set(l, t);
+        v[1].set(l, b);
+        v[2].set(r, b);
+        v[3].set(r, t);
+    }
+    
+    void setRectFan(GrScalar l, GrScalar t, GrScalar r, GrScalar b, size_t stride) {
+        GrAssert(stride >= sizeof(GrPoint));
+        ((GrPoint*)((intptr_t)this + 0 * stride))->set(l, t);
+        ((GrPoint*)((intptr_t)this + 1 * stride))->set(l, b);
+        ((GrPoint*)((intptr_t)this + 2 * stride))->set(r, b);
+        ((GrPoint*)((intptr_t)this + 3 * stride))->set(r, t);
+    }
+    
+    // counter-clockwise fan
+    void setIRectFan(int l, int t, int r, int b) {
+        GrPoint* v = this;
+        v[0].set(GrIntToScalar(l), GrIntToScalar(t));
+        v[1].set(GrIntToScalar(l), GrIntToScalar(b));
+        v[2].set(GrIntToScalar(r), GrIntToScalar(b));
+        v[3].set(GrIntToScalar(r), GrIntToScalar(t));
+    }
+    
+    void setIRectFan(int l, int t, int r, int b, size_t stride) {
+        GrAssert(stride >= sizeof(GrPoint));
+        ((GrPoint*)((intptr_t)this + 0 * stride))->set(GrIntToScalar(l), 
+                                                      GrIntToScalar(t));
+        ((GrPoint*)((intptr_t)this + 1 * stride))->set(GrIntToScalar(l), 
+                                                      GrIntToScalar(b));
+        ((GrPoint*)((intptr_t)this + 2 * stride))->set(GrIntToScalar(r), 
+                                                      GrIntToScalar(b));
+        ((GrPoint*)((intptr_t)this + 3 * stride))->set(GrIntToScalar(r), 
+                                                      GrIntToScalar(t));
+    }
+    
+    bool operator ==(const GrPoint& p) const {
+        return fX == p.fX && fY == p.fY;
+    }
+    
+    bool operator !=(const GrPoint& p) const {
+        return fX != p.fX || fY != p.fY;
+    }
+};
+
+struct GrIPoint16 {
+    int16_t fX, fY;
+    
+    void set(intptr_t x, intptr_t y) {
+        fX = GrToS16(x);
+        fY = GrToS16(y);
+    }
+};
+
+struct GrVec {
+public:
+    GrScalar fX, fY;
+    
+    GrVec() {}
+    GrVec(GrScalar x, GrScalar y) { fX = x; fY = y; }
+    
+    GrScalar x() const { return fX; }
+    GrScalar y() const { return fY; }
+    
+    /**
+     * set x and y length of the vector.
+     */
+    void set(GrScalar x, GrScalar y) {
+        fX = x;
+        fY = y;
+    }
+    
+    /**
+     * set vector to point from a to b.
+     */
+    void setBetween(const GrPoint& a, const GrPoint& b) {
+        fX = b.fX - a.fX;
+        fY = b.fY - a.fY;
+    }
+    
+    /**
+     * Make this vector be orthogonal to vec. Looking down vec the
+     * new vector will point left.
+     */
+    void setOrthogLeft(const GrVec& vec) {
+        // vec could be this
+        GrVec v = vec;
+        fX = -v.fY;
+        fY = v.fX;
+    }
+
+    /**
+     * Make this vector be orthogonal to vec. Looking down vec the
+     * new vector will point right.
+     */
+    void setOrthogRight(const GrVec& vec) {
+        // vec could be this
+        GrVec v = vec;
+        fX = v.fY;
+        fY = -v.fX;
+    }
+
+    /**
+     * set orthogonal to vec from a to b. Will be facing left relative to a,b
+     * vec
+     */
+    void setOrthogLeftToVecBetween(const GrPoint& a, const GrPoint& b) {
+        fX = a.fY - b.fY;
+        fY = b.fX - a.fX;
+    }
+
+    /**
+     * set orthogonal to vec from a to b. Will be facing right relative to a,b
+     * vec.
+     */
+    void setOrthogRightToVecBetween(const GrPoint& a, const GrPoint& b) {
+        fX = b.fY - a.fY;
+        fY = a.fX - b.fX;
+    }
+
+    /**
+     * length of the vector squared.
+     */
+    GrScalar lengthSqd() const {
+        return GrMul(fX, fX) + GrMul(fY, fY);
+    }
+    
+    /**
+     * length of the vector.
+     */
+    GrScalar length() const {
+        // TODO: fixed point sqrt
+        return GrFloatToScalar(sqrtf(GrScalarToFloat(lengthSqd())));
+    }
+    
+    /**
+     * normalizes the vector if it's length is not 0.
+     * @return true if normalized, otherwise false.
+     */
+    bool normalize() {
+        GrScalar l = lengthSqd();
+        if (l) {
+            // TODO: fixed point sqrt and invert
+            l = 1 / sqrtf(l);
+            fX *= l;
+            fY *= l;
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Dot product of this with vec.
+     */
+    GrScalar dot(const GrVec& vec) const {
+        return GrMul(vec.fX, fX) + GrMul(vec.fY, fY);
+    }
+   
+    /**
+     * Dot product of this vec with vector from (0,0) to a pt.
+     */
+    GrScalar dotWithVecToPt(const GrPoint& pt) const {
+        return GrMul(pt.fX, fX) + GrMul(pt.fY, fY);
+    }
+
+    /**
+     * z-value of this cross vec.
+     */
+    GrScalar cross(const GrVec& vec) const {
+        return GrMul(fX, vec.fY) - GrMul(fY, vec.fX);
+    }
+    
+    bool operator ==(const GrPoint& p) const {
+        return fX == p.fX && fY == p.fY;
+    }
+    
+    bool operator !=(const GrPoint& p) const {
+        return fX != p.fX || fY != p.fY;
+    }
+};
+
+GrScalar GrPoint::distanceToLineBetweenSqd(const GrPoint& a, 
+                                           const GrPoint& b) const {
+    // Let d be the distance between c (this) and line ab.
+    // The area of the triangle defined by a, b, and c is 
+    // A = |b-a|*d/2. Let u = b-a and v = c-a. The cross product of
+    // u and v is aligned with the z axis and its magnitude is 2A. 
+    // So d = |u x v| / |u|.
+    GrVec u, v;
+    u.setBetween(a,b);
+    v.setBetween(a,*this);
+    
+    GrScalar det = u.cross(v);
+    return (GrMul(det, det)) / u.lengthSqd();
+}
+
+GrScalar GrPoint::distanceToLineBetween(const GrPoint& a, 
+                                        const GrPoint& b) const {
+    GrVec u, v;
+    u.setBetween(a,b);
+    v.setBetween(a,*this);
+    
+    GrScalar det = u.cross(v);
+    return (GrScalarAbs(det)) / u.length();
+}
+
+GrScalar GrPoint::distanceToLineSegmentBetweenSqd(const GrPoint& a, 
+                                                  const GrPoint& b) const {
+    // See comments to distanceToLineBetweenSqd. If the projection of c onto
+    // u is between a and b then this returns the same result as that 
+    // function. Otherwise, it returns the distance to the closer of a and
+    // b. Let the projection of v onto u be v'.  There are three cases:
+    //    1. v' points opposite to u. c is not between a and b and is closer
+    //       to a than b.
+    //    2. v' points along u and has magnitude less than y. c is between
+    //       a and b and the distance to the segment is the same as distance
+    //       to the line ab.
+    //    3. v' points along u and has greater magnitude than u. c is not
+    //       not between a and b and is closer to b than a.
+    // v' = (u dot v) * u / |u|. So if (u dot v)/|u| is less than zero we're 
+    // in case 1. If (u dot v)/|u| is > |u| we are in case 3. Otherwise
+    // we're in case 2. We actually compare (u dot v) to 0 and |u|^2 to 
+    // avoid a sqrt to compute |u|.
+    
+    GrVec u, v;
+    u.setBetween(a,b);
+    v.setBetween(a,*this);
+    
+    GrScalar uLengthSqd = u.lengthSqd();
+    GrScalar uDotV = u.dot(v);
+    
+    if (uDotV <= 0) {
+        return v.lengthSqd();
+    } else if (uDotV > uLengthSqd) {
+        return b.distanceToSqd(*this);
+    } else {
+        GrScalar det = u.cross(v);
+        return (GrMul(det, det)) / uLengthSqd;
+    }
+}
+
+GrScalar GrPoint::distanceToLineSegmentBetween(const GrPoint& a, 
+                                               const GrPoint& b) const {
+    // TODO: fixed point sqrt
+    return GrFloatToScalar(sqrtf(GrScalarToFloat(distanceToLineSegmentBetweenSqd(a,b))));
+}
+
+
+#endif
+
diff --git a/gpu/include/GrRandom.h b/gpu/include/GrRandom.h
new file mode 100644
index 0000000..408f61d
--- /dev/null
+++ b/gpu/include/GrRandom.h
@@ -0,0 +1,62 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrRandom_DEFINED
+#define GrRandom_DEFINED
+
+class GrRandom {
+public:
+    GrRandom() : fSeed(0) {}
+    GrRandom(uint32_t seed) : fSeed(seed) {}
+
+    uint32_t seed() const { return fSeed; }
+
+    uint32_t nextU() {
+        fSeed = fSeed * kMUL + kADD;
+        return fSeed;
+    }
+
+    int32_t nextS() { return (int32_t)this->nextU(); }
+
+    /**
+     *  Returns value [0...1) as a float
+     */
+    float nextF() {
+        // const is 1 / (2^32 - 1)
+        return (float)(this->nextU() * 2.32830644e-10);
+    }
+
+    /**
+     *  Returns value [min...max) as a float
+     */
+    float nextF(float min, float max) {
+        return min + this->nextF() * (max - min);
+    }
+
+private:
+    /*
+     *  These constants taken from "Numerical Recipes in C", reprinted 1999
+     */
+    enum {
+        kMUL = 1664525,
+        kADD = 1013904223
+    };
+    uint32_t    fSeed;
+};
+
+#endif
+
diff --git a/gpu/include/GrRect.h b/gpu/include/GrRect.h
new file mode 100644
index 0000000..552fa5e
--- /dev/null
+++ b/gpu/include/GrRect.h
@@ -0,0 +1,366 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrRect_DEFINED
+#define GrRect_DEFINED
+
+#include "GrPoint.h"
+
+struct GrIRect {
+    int32_t fLeft, fTop, fRight, fBottom;
+
+    GrIRect() {}
+    GrIRect(int32_t left, int32_t top, int32_t right, int32_t bottom) {
+        fLeft = left;
+        fTop = top;
+        fRight = right;
+        fBottom = bottom;
+    }
+
+    int32_t x() const { return fLeft; }
+    int32_t y() const { return fTop; }
+    int32_t width() const { return fRight - fLeft; }
+    int32_t height() const { return fBottom - fTop; }
+
+    bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
+    bool isInverted() const { return fLeft > fRight || fTop > fBottom; }
+
+    void setEmpty() { fLeft = fTop = fRight = fBottom = 0; }
+
+    void setXYWH(int32_t x, int32_t y, int32_t w, int32_t h) {
+        fLeft = x;
+        fTop = y;
+        fRight = x + w;
+        fBottom = y + h;
+    }
+
+    void setLTRB(int32_t l, int32_t t, int32_t r, int32_t b) {
+        fLeft = l;
+        fTop = t;
+        fRight = r;
+        fBottom = b;
+    }
+
+    /**
+     *  Make the largest representable rectangle
+     */
+    void setLargest() {
+        fLeft = fTop = GR_Int32Min;
+        fRight = fBottom = GR_Int32Max;
+    }
+
+    bool quickReject(int l, int t, int r, int b) const {
+        return l >= fRight || fLeft >= r || t >= fBottom || fTop >= b;
+    }
+
+    void unionWith(const GrIRect& r) {
+        if (fLeft > r.fLeft) fLeft = r.fLeft;
+        if (fTop > r.fTop) fTop = r.fTop;
+        if (fRight < r.fRight) fRight = r.fRight;
+        if (fBottom < r.fBottom) fBottom = r.fBottom;
+    }
+
+    /**
+     * Sets this rect to the intersection with a clip rect. If there is no
+     * intersection then this rect will be made empty.
+     */
+    void intersectWith(const GrIRect& clipRect) {
+        if (fRight < clipRect.fLeft ||
+            fLeft > clipRect.fRight ||
+            fBottom < clipRect.fTop ||
+            fTop > clipRect.fBottom) {
+            this->setEmpty();
+        } else {
+            fLeft = GrMax(fLeft, clipRect.fLeft);
+            fRight = GrMin(fRight, clipRect.fRight);
+            fTop = GrMax(fTop, clipRect.fTop);
+            fBottom = GrMin(fBottom, clipRect.fBottom);
+        }
+    }
+
+    friend bool operator==(const GrIRect& a, const GrIRect& b) {
+        return 0 == memcmp(&a, &b, sizeof(a));
+    }
+
+    friend bool operator!=(const GrIRect& a, const GrIRect& b) {
+        return 0 != memcmp(&a, &b, sizeof(a));
+    }
+
+    bool equalsLTRB(int l, int t, int r, int b) const {
+        return fLeft == l && fTop == t &&
+               fRight == r && fBottom == b;
+    }
+    bool equalsXYWH(int x, int y, int w, int h) const {
+        return fLeft == x && fTop == y &&
+               this->width() == w && this->height() == h;
+    }
+
+    bool contains(const GrIRect& r) const {
+        return fLeft   <= r.fLeft &&
+               fRight  >= r.fRight &&
+               fTop    <= r.fTop &&
+               fBottom >= r.fBottom;
+    }
+};
+
+struct GrIRect16 {
+    int16_t fLeft, fTop, fRight, fBottom;
+
+    int width() const { return fRight - fLeft; }
+    int height() const { return fBottom - fTop; }
+    int area() const { return this->width() * this->height(); }
+    bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
+
+    void set(const GrIRect& r) {
+        fLeft   = GrToS16(r.fLeft);
+        fTop    = GrToS16(r.fTop);
+        fRight  = GrToS16(r.fRight);
+        fBottom = GrToS16(r.fBottom);
+    }
+};
+
+/**
+ *  2D Rect struct
+ */
+struct GrRect {
+    GrScalar fLeft, fTop, fRight, fBottom;
+
+    /**
+     *  Uninitialized rectangle.
+     */
+    GrRect() {}
+
+    /**
+     *  Initialize a rectangle to a point.
+     *  @param pt the point used to initialize the rectanglee.
+     */
+    explicit GrRect(const GrPoint& pt) {
+        setToPoint(pt);
+    }
+
+    GrRect(GrScalar left, GrScalar top, GrScalar right, GrScalar bottom) {
+        fLeft = left;
+        fTop = top;
+        fRight = right;
+        fBottom = bottom;
+    }
+
+    explicit GrRect(const GrIRect& src) {
+        fLeft = GrIntToScalar(src.fLeft);
+        fTop = GrIntToScalar(src.fTop);
+        fRight = GrIntToScalar(src.fRight);
+        fBottom = GrIntToScalar(src.fBottom);
+    }
+
+    GrScalar x() const { return fLeft; }
+    GrScalar y() const { return fTop; }
+    GrScalar width() const { return fRight - fLeft; }
+    GrScalar height() const { return fBottom - fTop; }
+
+    GrScalar left() const { return fLeft; }
+    GrScalar top() const { return fTop; }
+    GrScalar right() const { return fRight; }
+    GrScalar bottom() const { return fBottom; }
+
+    GrScalar diagonalLengthSqd() const {
+        GrScalar w = width();
+        GrScalar h = height();
+        return GrMul(w, w) + GrMul(h, h);
+    }
+
+    GrScalar diagonalLength() const {
+        // TODO: fixed point sqrt
+        return GrFloatToScalar(sqrtf(GrScalarToFloat(diagonalLengthSqd())));
+    }
+
+    /**
+     *  Returns true if the width or height is <= 0
+     */
+    bool isEmpty() const {
+        return fLeft >= fRight || fTop >= fBottom;
+    }
+
+    void setEmpty() {
+        fLeft = fTop = fRight = fBottom = 0;
+    }
+
+    /**
+     *  returns true if the rectangle is inverted either in x or y
+     */
+    bool isInverted() const {
+        return (fLeft > fRight) || (fTop > fBottom);
+    }
+
+    /**
+     * Does this rect contain a point.
+     */
+    bool contains(const GrPoint& point) const {
+        return point.fX >= fLeft && point.fX < fRight &&
+               point.fY >= fTop && point.fY < fBottom;
+    }
+
+    /**
+     * Does this rect fully contain another rect.
+     */
+    bool contains(const GrRect& r) const {
+        return fLeft   <= r.fLeft &&
+               fRight  >= r.fRight &&
+               fTop    <= r.fTop &&
+               fBottom >= r.fBottom;
+    }
+
+    /**
+     *  Offset the rectangle by (tx, ty), adding tx to the horizontal position
+     *  and adds ty to the vertical position.
+     */
+    void offset(GrScalar tx, GrScalar ty) {
+        fLeft  += tx;   fTop    += ty;
+        fRight += tx;   fBottom += ty;
+    }
+
+    /**
+     *  Initialize a rectangle to a point.
+     *  @param pt the point used to initialize the rectangle.
+     */
+    void setToPoint(const GrPoint& pt) {
+        fLeft = pt.fX;
+        fTop = pt.fY;
+        fRight = pt.fX;
+        fBottom = pt.fY;
+    }
+
+    void set(const GrIRect& r) {
+        fLeft = GrIntToScalar(r.fLeft);
+        fTop = GrIntToScalar(r.fTop);
+        fRight = GrIntToScalar(r.fRight);
+        fBottom = GrIntToScalar(r.fBottom);
+    }
+
+    void roundOut(GrIRect* r) const {
+        r->setLTRB(GrScalarFloorToInt(fLeft),
+                   GrScalarFloorToInt(fTop),
+                   GrScalarCeilToInt(fRight),
+                   GrScalarCeilToInt(fBottom));
+    }
+
+    /**
+     *  Set the rect to the union of the array of points. If the array is empty
+     *  the rect will be empty [0,0,0,0]
+     */
+    void setBounds(const GrPoint pts[], int count);
+
+    /**
+     *  Make the largest representable rectangle
+     *  Set the rect to fLeft = fTop = GR_ScalarMin and
+     *  fRight = fBottom = GR_ScalarMax.
+     */
+    void setLargest() {
+        fLeft = fTop = GR_ScalarMin;
+        fRight = fBottom = GR_ScalarMax;
+    }
+
+    /**
+     Set the rect to fLeft = fTop = GR_ScalarMax and
+     fRight = fBottom = GR_ScalarMin.
+     Useful for initializing a bounding rectangle.
+     */
+    void setLargestInverted() {
+        fLeft = fTop = GR_ScalarMax;
+        fRight = fBottom = GR_ScalarMin;
+    }
+
+    void setLTRB(GrScalar left,
+                 GrScalar top,
+                 GrScalar right,
+                 GrScalar bottom) {
+        fLeft = left;
+        fTop = top;
+        fRight = right;
+        fBottom = bottom;
+    }
+
+    void setXYWH(GrScalar x, GrScalar y, GrScalar width, GrScalar height) {
+        fLeft = x;
+        fTop = y;
+        fRight = x + width;
+        fBottom = y + height;
+    }
+
+    /**
+     Expand the edges of the rectangle to include a point.
+     Useful for constructing a bounding rectangle.
+     @param pt  the point used to grow the rectangle.
+     */
+    void growToInclude(const GrPoint& pt) {
+        fLeft  = GrMin(pt.fX, fLeft);
+        fRight = GrMax(pt.fX, fRight);
+
+        fTop    = GrMin(pt.fY, fTop);
+        fBottom = GrMax(pt.fY, fBottom);
+    }
+
+    /**
+     * Grows a rect to include another rect.
+     * @param rect the rect to include
+     */
+    void growToInclude(const GrRect& rect) {
+        GrAssert(!rect.isEmpty());
+        fLeft  = GrMin(rect.fLeft, fLeft);
+        fRight = GrMax(rect.fRight, fRight);
+
+        fTop    = GrMin(rect.fTop, fTop);
+        fBottom = GrMax(rect.fBottom, fBottom);
+    }
+
+    /**
+     * Sets this rect to the intersection with a clip rect. If there is no
+     * intersection then this rect will be made empty.
+     */
+    void intersectWith(const GrRect& clipRect) {
+        if (fRight < clipRect.fLeft ||
+            fLeft > clipRect.fRight ||
+            fBottom < clipRect.fTop ||
+            fTop > clipRect.fBottom) {
+            this->setEmpty();
+        } else {
+            fLeft = GrMax(fLeft, clipRect.fLeft);
+            fRight = GrMin(fRight, clipRect.fRight);
+            fTop = GrMax(fTop, clipRect.fTop);
+            fBottom = GrMin(fBottom, clipRect.fBottom);
+        }
+    }
+
+    /**
+     *  Assigns 4 sequential points in order to construct a counter-clockwise
+     *  triangle fan, given the corners of this rect. Returns the address of
+     *  the next point, treating pts as an array.
+     */
+    GrPoint* setRectFan(GrPoint pts[4]) const {
+        pts->setRectFan(fLeft, fTop, fRight, fBottom);
+        return pts + 4;
+    }
+
+    bool operator ==(const GrRect& r) const {
+        return fLeft == r.fLeft     &&
+               fTop == r.fTop       &&
+               fRight == r.fRight   &&
+               fBottom == r.fBottom;
+    }
+};
+
+#endif
+
diff --git a/gpu/include/GrRectanizer.h b/gpu/include/GrRectanizer.h
new file mode 100644
index 0000000..50bb8fe
--- /dev/null
+++ b/gpu/include/GrRectanizer.h
@@ -0,0 +1,64 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrRectanizer_DEFINED
+#define GrRectanizer_DEFINED
+
+#include "GrRect.h"
+#include "GrTDArray.h"
+
+class GrRectanizerPurgeListener {
+public:
+    virtual ~GrRectanizerPurgeListener() {}
+
+    virtual void notifyPurgeStrip(void*, int yCoord) = 0;
+};
+
+class GrRectanizer {
+public:
+    GrRectanizer(int width, int height) : fWidth(width), fHeight(height) {
+        GrAssert(width >= 0);
+        GrAssert(height >= 0);
+    }
+
+    virtual ~GrRectanizer() {}
+
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+
+    virtual bool addRect(int width, int height, GrIPoint16* loc) = 0;
+    virtual float percentFull() const = 0;
+
+    // return the Y-coordinate of a strip that should be purged, given height
+    // i.e. return the oldest such strip, or some other criteria. Return -1
+    // if there is no candidate
+    virtual int stripToPurge(int height) const = 0;
+    virtual void purgeStripAtY(int yCoord) = 0;
+
+    /**
+     *  Our factory, which returns the subclass du jour
+     */
+    static GrRectanizer* Factory(int width, int height);
+
+private:
+    int fWidth;
+    int fHeight;
+};
+
+#endif
+
+
diff --git a/gpu/include/GrRefCnt.h b/gpu/include/GrRefCnt.h
new file mode 100644
index 0000000..7204aff
--- /dev/null
+++ b/gpu/include/GrRefCnt.h
@@ -0,0 +1,125 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrRefCnt_DEFINED
+#define GrRefCnt_DEFINED
+
+#include "GrTypes.h"
+#include "GrNoncopyable.h"
+
+/**
+ *  Base class for reference counting. When an object is first instantiated,
+ *  its reference count is 1. If the object may be null, use GrSafeRef() and
+ *  GrSafeUnref().
+ *
+ *  It is an error (though only checked for in the debug build) to call unref()
+ *  such that the reference count becomes 0.
+ */
+class GrRefCnt : GrNoncopyable {
+public:
+            GrRefCnt() : fRefCnt(1) {}
+    virtual ~GrRefCnt() {
+        GrAssert(1 == fRefCnt);
+#if GR_DEBUG
+        fRefCnt = 0;    // force validate() to trigger if called afterwards
+#endif
+    }
+
+    int32_t refcnt() const { return fRefCnt; }
+
+    void ref() const {
+        GrAssert(fRefCnt > 0);
+        ++fRefCnt;
+    }
+
+    void unref() const {
+        GrAssert(fRefCnt > 0);
+        if (1 == fRefCnt) {
+            delete this;
+        } else {
+            --fRefCnt;
+        }
+    }
+
+#if GR_DEBUG
+    void validate() const {
+        GrAssert(fRefCnt > 0);
+    }
+#else
+    void validate() const {}
+#endif
+
+private:
+    mutable int32_t fRefCnt;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Call with instance/subclass of GrRefCnt. This does nothing if obj is null,
+ *  but otherwise it calls ref().
+ */
+static inline void GrSafeRef(const GrRefCnt* obj) {
+    if (obj) {
+        obj->ref();
+    }
+}
+
+/**
+ *  Call with instance/subclass of GrRefCnt. This does nothing if obj is null,
+ *  but otherwise it calls unref().
+ */
+static inline void GrSafeUnref(const GrRefCnt* obj) {
+    if (obj) {
+        obj->unref();
+    }
+}
+
+/**
+ *  Assigns src to dst, checking for NULLs in each, and correctly incrementing
+ *  the reference count of src, and decrementing the reference count of dst
+ */
+static inline void GrSafeAssign(GrRefCnt*& dst, GrRefCnt* src) {
+    if (src) {
+        src->ref();
+    }
+    if (dst) {
+        dst->unref();
+    }
+    dst = src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class GrAutoRef : GrNoncopyable {
+public:
+    GrAutoRef(GrRefCnt* obj) : fObj(obj) { GrSafeRef(obj); }
+    ~GrAutoRef() { GrSafeUnref(fObj); }
+private:
+    GrRefCnt* fObj;
+};
+
+class GrAutoUnref : GrNoncopyable {
+public:
+    GrAutoUnref(GrRefCnt* obj) : fObj(obj) {}
+    ~GrAutoUnref() { GrSafeUnref(fObj); }
+private:
+    GrRefCnt* fObj;
+};
+
+#endif
+
diff --git a/gpu/include/GrSamplerState.h b/gpu/include/GrSamplerState.h
new file mode 100644
index 0000000..910bc74
--- /dev/null
+++ b/gpu/include/GrSamplerState.h
@@ -0,0 +1,191 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrSamplerState_DEFINED
+#define GrSamplerState_DEFINED
+
+#include "GrTypes.h"
+#include "GrMatrix.h"
+
+class GrSamplerState {
+public:
+    /**
+     * The intepretation of the texture matrix depends on the sample mode. The
+     * texture matrix is applied both when the texture coordinates are explicit
+     * and  when vertex positions are used as texture  coordinates. In the latter
+     * case the texture matrix is applied to the pre-view-matrix position 
+     * values.
+     *
+     * kNormal_SampleMode
+     *  The post-matrix texture coordinates are in normalize space with (0,0) at
+     *  the top-left and (1,1) at the bottom right.
+     * kRadial_SampleMode
+     *  The matrix specifies the radial gradient parameters.
+     *  (0,0) in the post-matrix space is center of the radial gradient.
+     * kRadial2_SampleMode
+     *   Matrix transforms to space where first circle is centered at the
+     *   origin. The second circle will be centered (x, 0) where x may be 
+     *   0 and is provided by setRadial2Params. The post-matrix space is 
+     *   normalized such that 1 is the second radius - first radius.
+     * kSweepSampleMode
+     *  The angle from the origin of texture coordinates in post-matrix space
+     *  determines the gradient value.
+     */
+    enum SampleMode {
+        kNormal_SampleMode,     //!< sample color directly
+        kRadial_SampleMode,     //!< treat as radial gradient
+        kRadial2_SampleMode,    //!< treat as 2-point radial gradient
+        kSweep_SampleMode,      //!< treat as sweep gradient
+    };
+
+    /**
+     * Describes how a texture is sampled when coordinates are outside the
+     * texture border
+     */
+    enum WrapMode {
+        kClamp_WrapMode,
+        kRepeat_WrapMode,
+        kMirror_WrapMode
+    };
+
+    /**
+     * Default sampler state is set to clamp, use normal sampling mode, be
+     * unfiltered, and use identity matrix.
+     */
+    GrSamplerState() {
+        this->setClampNoFilter();
+    }
+
+    explicit GrSamplerState(bool filter) {
+        fWrapX = kClamp_WrapMode;
+        fWrapY = kClamp_WrapMode;
+        fSampleMode = kNormal_SampleMode;
+        fFilter = filter;
+        fMatrix.setIdentity();
+    }
+
+    GrSamplerState(WrapMode wx, WrapMode wy, bool filter) {
+        fWrapX = wx;
+        fWrapY = wy;
+        fSampleMode = kNormal_SampleMode;
+        fFilter = filter;
+        fMatrix.setIdentity();
+    }
+
+    GrSamplerState(WrapMode wx, WrapMode wy, const GrMatrix& matrix, bool filter) {
+        fWrapX = wx;
+        fWrapY = wy;
+        fSampleMode = kNormal_SampleMode;
+        fFilter = filter;
+        fMatrix = matrix;
+    }
+
+    GrSamplerState(WrapMode wx, WrapMode wy, SampleMode sample, const GrMatrix& matrix, bool filter) {
+        fWrapX = wx;
+        fWrapY = wy;
+        fSampleMode = sample;
+        fMatrix = matrix;
+        fFilter = filter;
+    }
+
+    WrapMode getWrapX() const { return fWrapX; }
+    WrapMode getWrapY() const { return fWrapY; }
+    SampleMode getSampleMode() const { return fSampleMode; }
+    const GrMatrix& getMatrix() const { return fMatrix; }
+    bool isFilter() const { return fFilter; }
+
+    bool isGradient() const {
+        return  kRadial_SampleMode == fSampleMode ||
+                kRadial2_SampleMode == fSampleMode ||
+                kSweep_SampleMode == fSampleMode;
+    }
+
+    void setWrapX(WrapMode mode) { fWrapX = mode; }
+    void setWrapY(WrapMode mode) { fWrapY = mode; }
+    void setSampleMode(SampleMode mode) { fSampleMode = mode; }
+    
+    /**
+     * Sets the sampler's matrix. See SampleMode for explanation of
+     * relationship between the matrix and sample mode.
+     * @param matrix the matrix to set
+     */
+    void setMatrix(const GrMatrix& matrix) { fMatrix = matrix; }
+    
+    /**
+     *  Multiplies the current sampler matrix  a matrix
+     *
+     *  After this call M' = M*m where M is the old matrix, m is the parameter
+     *  to this function, and M' is the new matrix. (We consider points to
+     *  be column vectors so tex cood vector t is transformed by matrix X as 
+     *  t' = X*t.)
+     *
+     *  @param matrix   the matrix used to modify the matrix.
+     */
+    void preConcatMatrix(const GrMatrix& matrix) { fMatrix.preConcat(matrix); }
+
+    /**
+     * Enables or disables filtering.
+     * @param filter    indicates whether filtering is applied.
+     */
+    void setFilter(bool filter) { fFilter = filter; }
+
+    void setClampNoFilter() {
+        fWrapX = kClamp_WrapMode;
+        fWrapY = kClamp_WrapMode;
+        fSampleMode = kNormal_SampleMode;
+        fFilter = false;
+        fMatrix.setIdentity();
+    }
+
+    GrScalar getRadial2CenterX1() const { return fRadial2CenterX1; }
+    GrScalar getRadial2Radius0() const { return fRadial2Radius0; }
+    bool     isRadial2PosRoot() const { return fRadial2PosRoot; }
+
+    /**
+     * Sets the parameters for kRadial2_SampleMode. The texture
+     * matrix must be set so that the first point is at (0,0) and the second
+     * point lies on the x-axis. The second radius minus the first is 1 unit.
+     * The additional parameters to define the gradient are specified by this
+     * function.
+     */
+    void setRadial2Params(GrScalar centerX1, GrScalar radius0, bool posRoot) {
+        fRadial2CenterX1 = centerX1;
+        fRadial2Radius0 = radius0;
+        fRadial2PosRoot = posRoot;
+    }
+
+    static const GrSamplerState& ClampNoFilter() {
+        return gClampNoFilter;
+    }
+
+private:
+    WrapMode    fWrapX;
+    WrapMode    fWrapY;
+    SampleMode  fSampleMode;
+    bool        fFilter;
+    GrMatrix    fMatrix;
+
+    // these are undefined unless fSampleMode == kRadial2_SampleMode
+    GrScalar    fRadial2CenterX1;
+    GrScalar    fRadial2Radius0;
+    bool        fRadial2PosRoot;
+
+    static const GrSamplerState gClampNoFilter;
+};
+
+#endif
+
diff --git a/gpu/include/GrScalar.h b/gpu/include/GrScalar.h
new file mode 100644
index 0000000..1353fb2
--- /dev/null
+++ b/gpu/include/GrScalar.h
@@ -0,0 +1,116 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrScalar_DEFINED
+#define GrScalar_DEFINED
+
+#include "GrTypes.h"
+
+#include <float.h>
+#include <math.h>
+
+#define GR_Int32Max            (0x7fffffff)
+#define GR_Int32Min            (0x80000000)
+
+/**
+ *  Convert an int to fixed point 
+ */
+#if GR_DEBUG
+    inline GrFixed GrIntToFixed(int i) {
+        GrAssert(((i & 0xffff0000) == 0xffff0000) || ((i & 0xffff0000) == 0x0));
+        return i << 16;
+    }
+#else
+    #define GrIntToFixed(i) (GrFixed)((i) << 16)
+#endif
+
+#define GR_Fixed1              (1 << 16)
+#define GR_FixedHalf           (1 << 15)
+#define GR_FixedMax            GR_Int32Max
+#define GR_FixedMin            GR_Int32Min
+
+#define GrFixedFloorToFixed(x)  ((x) & ~0xFFFF)
+#define GrFixedFloorToInt(x)    ((x) >> 16)
+
+/**
+ *  Convert fixed point to floating point
+ */
+#define GrFixedToFloat(x)      ((x) * 0.0000152587890625f)
+
+/**
+ *  Convert floating point to fixed point
+ */
+#define GrFloatToFixed(x)      ((GrFixed)((x) * GR_Fixed1))
+
+inline GrFixed GrFixedAbs(GrFixed x) {
+    int32_t s = (x & 0x80000000) >> 31;
+    return (GrFixed)(((int32_t)x ^ s) - s);  
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if GR_SCALAR_IS_FIXED
+    typedef GrFixed                 GrScalar;
+    #define GrIntToScalar(x)        GrIntToFixed(x)
+    #define GrFixedToScalar(x)      (x)
+    #define GrScalarToFloat(x)      GrFixedToFloat(x)
+    #define GrFloatToScalar(x)      GrFloatToFixed(x)
+    #define GrScalarHalf(x)         ((x) >> 1)
+    #define GrScalarAve(x,y)        (((x)+(y)) >> 1)
+    #define GrScalarAbs(x)          GrFixedAbs(x)
+    #define GR_Scalar1              GR_Fixed1
+    #define GR_ScalarHalf           GR_FixedHalf
+    #define GR_ScalarMax            GR_FixedMax
+    #define GR_ScalarMin            GR_FixedMin
+#elif GR_SCALAR_IS_FLOAT
+    typedef float                   GrScalar;
+    #define GrIntToScalar(x)        ((GrScalar)x)
+    #define GrFixedToScalar(x)      GrFixedToFloat(x)
+    #define GrScalarToFloat(x)      (x)
+    #define GrFloatToScalar(x)      (x)
+    #define GrScalarHalf(x)         ((x) * 0.5f)
+    #define GrScalarAbs(x)          fabsf(x)
+    #define GrScalarAve(x,y)        (((x) + (y)) * 0.5f)
+    #define GR_Scalar1              1.f    
+    #define GR_ScalarHalf           0.5f
+    #define GR_ScalarMax            (FLT_MAX)
+    #define GR_ScalarMin            (-FLT_MAX)
+
+    static inline int32_t GrScalarFloorToInt(float x) {
+        return (int32_t)::floorf(x);
+    }
+    static inline int32_t GrScalarCeilToInt(float x) {
+        return (int32_t)::ceilf(x);
+    }
+#else
+    #error "Scalar type not defined"
+#endif
+
+/**
+ *  Multiply two GrScalar values
+ */
+static inline GrScalar GrMul(GrScalar a, GrScalar b) {
+#if GR_SCALAR_IS_FLOAT
+    return a * b;
+#else
+    int64_t tmp = (int64_t)a * b;
+    return (tmp + GR_FixedHalf) >> 16;
+#endif
+}
+
+#endif
+
diff --git a/gpu/include/GrStencil.h b/gpu/include/GrStencil.h
new file mode 100644
index 0000000..b014ee5
--- /dev/null
+++ b/gpu/include/GrStencil.h
@@ -0,0 +1,210 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrStencil_DEFINED
+#define GrStencil_DEFINED
+
+#include "GrTypes.h"
+/**
+ * Gr uses the stencil buffer to implement complex clipping inside the
+ * GrDrawTarget class. The GrDrawTarget makes a subset of the stencil buffer
+ * bits available for other uses by external code (clients). Client code can
+ * modify these bits. GrDrawTarget will ignore ref, mask, and writemask bits
+ * provided by clients that overlap the bits used to implement clipping. The
+ * client can use the getUsableStencilBits() function to find out how many
+ * client accessible stencil bits are available.
+ *
+ * When code outside the GrDrawTarget class uses the stencil buffer the contract
+ * is as follows:
+ *
+ * > Normal stencil funcs allow the GrGpu client to modify the client bits of
+ *   the stencil buffer outside of the clip.
+ * > Special functions allow a test against the clip. These are more limited
+ *   than the general stencil functions.
+ * > Client can assume all client bits are zero initially.
+ * > Client must ensure that after all its passes are finished it has only
+ *   written to the color buffer in the region inside the clip. Furthermore, it
+ *   must zero all client bits that were modifed (both inside and outside the
+ *   clip).
+ */
+
+/**
+ * Determines which pixels pass / fail the stencil test.
+ * Stencil test passes if (ref & mask) FUNC (stencil & mask) is true
+ */
+enum GrStencilFunc {
+    kAlways_StencilFunc = 0,
+    kNever_StencilFunc,
+    kGreater_StencilFunc,
+    kGEqual_StencilFunc,
+    kLess_StencilFunc,
+    kLEqual_StencilFunc,
+    kEqual_StencilFunc,
+    kNotEqual_StencilFunc,
+
+    // Gr stores the current clip in the
+    // stencil buffer in the high bits that
+    // are not directly accessible modifiable
+    // via the GrDrawTarget interface. The below
+    // stencil funcs test against the current
+    // clip in addition to the GrDrawTarget
+    // client's stencil bits.
+
+    // pass if inside the clip
+    kAlwaysIfInClip_StencilFunc,
+    kEqualIfInClip_StencilFunc,
+    kLessIfInClip_StencilFunc,
+    kLEqualIfInClip_StencilFunc,
+    kNonZeroIfInClip_StencilFunc, // this one forces the ref to be 0
+
+    // counts
+    kStencilFuncCount,
+    kClipStencilFuncCount = kNonZeroIfInClip_StencilFunc -
+                            kAlwaysIfInClip_StencilFunc + 1,
+    kBasicStencilFuncCount = kStencilFuncCount - kClipStencilFuncCount
+};
+
+/**
+ * Operations to perform based on whether stencil test passed failed.
+ */
+enum GrStencilOp {
+    kKeep_StencilOp = 0,    // preserve existing stencil value
+    kReplace_StencilOp,     // replace with reference value from stencl test
+    kIncWrap_StencilOp,     // increment and wrap at max
+    kIncClamp_StencilOp,    // increment and clamp at max
+    kDecWrap_StencilOp,     // decrement and wrap at 0
+    kDecClamp_StencilOp,    // decrement and clamp at 0
+    kZero_StencilOp,        // zero stencil bits
+    kInvert_StencilOp,      // invert stencil bits
+
+    kStencilOpCount
+};
+
+/**
+ * Struct representing stencil state.
+ */
+struct GrStencilSettings {
+    GrStencilOp   fFrontPassOp;     // op to perform when front faces pass
+    GrStencilOp   fBackPassOp;      // op to perform when back faces pass
+    GrStencilOp   fFrontFailOp;     // op to perform when front faces fail
+    GrStencilOp   fBackFailOp;      // op to perform when back faces fail
+    GrStencilFunc fFrontFunc;       // test function for front faces
+    GrStencilFunc fBackFunc;        // test function for back faces
+    unsigned int fFrontFuncMask;    // mask for front face test
+    unsigned int fBackFuncMask;     // mask for back face test
+    unsigned int fFrontFuncRef;     // reference value for front face test
+    unsigned int fBackFuncRef;      // reference value for back face test
+    unsigned int fFrontWriteMask;   // stencil write mask for front faces
+    unsigned int fBackWriteMask;    // stencil write mask for back faces
+
+    bool operator == (const GrStencilSettings& s) const {
+        // make sure this is tightly packed.
+        GR_STATIC_ASSERT(0 == sizeof(GrStencilOp)%4);
+        GR_STATIC_ASSERT(0 == sizeof(GrStencilFunc)%4);
+        GR_STATIC_ASSERT(sizeof(GrStencilSettings) ==
+                        4*sizeof(GrStencilOp) +
+                        2*sizeof(GrStencilFunc) +
+                        6*sizeof(unsigned int));
+        return 0 == memcmp(this, &s, sizeof(GrStencilSettings));
+    }
+
+    bool operator != (const GrStencilSettings& s) const {
+        return !(*this == s);
+    }
+
+    GrStencilSettings& operator =(const GrStencilSettings& s) {
+        memcpy(this, &s, sizeof(GrStencilSettings));
+        return *this;
+    }
+
+    void setSame(GrStencilOp passOp,
+                 GrStencilOp failOp,
+                 GrStencilFunc func,
+                 unsigned int funcMask,
+                 unsigned int funcRef,
+                 unsigned int writeMask) {
+        fFrontPassOp        = passOp;
+        fBackPassOp         = passOp;
+        fFrontFailOp        = failOp;
+        fBackFailOp         = failOp;
+        fFrontFunc          = func;
+        fBackFunc           = func;
+        fFrontFuncMask      = funcMask;
+        fBackFuncMask       = funcMask;
+        fFrontFuncRef       = funcRef;
+        fBackFuncRef        = funcRef;
+        fFrontWriteMask     = writeMask;
+        fBackWriteMask      = writeMask;
+    }
+
+    // canonical value for disabled stenciling
+    static const GrStencilSettings gDisabled;
+    void setDisabled() {
+        *this = gDisabled;
+    }
+    bool isDisabled() const {
+        return kKeep_StencilOp == fFrontPassOp   &&
+               kKeep_StencilOp == fBackPassOp    &&
+               kKeep_StencilOp == fFrontFailOp   &&
+               kKeep_StencilOp == fFrontFailOp   &&
+               kAlways_StencilFunc == fFrontFunc &&
+               kAlways_StencilFunc == fBackFunc;
+    }
+    void invalidate()  {
+        // just write an illegal value to the first member
+        fFrontPassOp = (GrStencilOp)-1;
+    }
+
+private:
+    friend class GrGpu;
+
+    enum {
+        kMaxStencilClipPasses = 2  // maximum number of passes to add a clip 
+                                   // element to the stencil buffer.
+    };
+
+    /**
+     * Given a thing to draw into the stencil clip, a fill type, and a set op
+     * this function determines:
+     *      1. Whether the thing can be draw directly to the stencil clip or
+     *      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 
+     *         always be non-inverted).
+     *
+     * @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 
+     *                               element to the clip.
+     * @param settings          out: the stencil settings to use for each pass
+     *
+     * @return true if the clip element's geometry can be drawn directly to the
+     *         stencil clip bit. Will only be true if canBeDirect is true.
+     *         numPasses will be 1 if return value is true.
+     */
+    static bool GetClipPasses(GrSetOp op, 
+                              bool canBeDirect,
+                              unsigned int stencilClipMask,
+                              bool invertedFill,
+                              int* numPasses,
+                              GrStencilSettings settings[kMaxStencilClipPasses]);
+};
+
+#endif
diff --git a/gpu/include/GrStopwatch.h b/gpu/include/GrStopwatch.h
new file mode 100644
index 0000000..4945897
--- /dev/null
+++ b/gpu/include/GrStopwatch.h
@@ -0,0 +1,135 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrStopwatch_DEFINED
+#define GrStopwatch_DEFINED
+
+#include "GrTypes.h"
+
+template <typename PLATFORM_TIMER>
+/**
+ * Base class for stopwatch. Relies on PLATFORM_TIMER for platform-specific
+ * timer functions. PLATFORM_TIMER provides:
+ *      - typename TIMESTAMP : a timestamp value that can be used with Diff()
+ *      - static TIMESTAMP Now() : gets current timestamp
+ *      - static double Diff(const TIMESTAMP& begin, const TIMESTAMP& end) : 
+ *           computes delta in seconds between two timestamps
+ */
+class GrStopwatchBase {
+public:
+    /**
+     * Contructor - implicit reset()
+     */
+    GrStopwatchBase() {
+        fRunning = false;
+        fTotalElapsed = 0.0;        
+    }
+
+    /**
+     * begins a new lap
+     */
+    void start() {
+        double lastLap = lapTime();
+        fTotalElapsed += lastLap;
+        fRunning = true;
+        fLastStart = PLATFORM_TIMER::Now();
+    }
+    
+    /**
+     * ends current lap (or no effect if lap not started)
+     */
+    void stop() {
+        double lastLap = lapTime();
+        fTotalElapsed += lastLap;
+        fRunning = false;
+    }
+
+    /**
+     * ends current lap, resets total time
+     */
+    void reset() {
+        fRunning = false;
+        fTotalElapsed = 0.f;
+    }
+    
+    /**
+     * Computes the time of all laps since last reset() including current lap
+     * if lap is still running.
+     *
+     * @return the sum time in seconds of all laps since last reset().
+     */
+    double totalTime() const {
+        return fTotalElapsed + lapTime();
+    }
+
+    /**
+     * Current lap time.
+     *
+     * @return time in seconds of current lap if one is running otherwise 0.
+     */
+    double lapTime() const {
+        if (fRunning) {
+            PLATFORM_TIMER::Timestamp now = PLATFORM_TIMER::Now();
+            return PLATFORM_TIMER::Elapsed(fLastStart, now);
+        }
+        return 0.0;
+    }
+
+private:
+    double fTotalElapsed;
+
+    typename PLATFORM_TIMER::Timestamp fLastStart;
+    bool                               fRunning;
+};
+
+#if GR_WIN32_BUILD
+
+    #include <Windows.h>
+
+    class GrWin32Timer {
+    public:
+        typedef LARGE_INTEGER Timestamp;  
+
+        static Timestamp Now() {
+            LARGE_INTEGER now;
+            QueryPerformanceCounter(&now);
+            return now;
+        }
+
+        static double Elapsed(const Timestamp& begin, const Timestamp& end) {
+            double diff = (double)(end.QuadPart - begin.QuadPart);
+            return diff * Scale();
+        }
+    private:
+        static double Scale() {
+            static double scale;
+            if (0.0 == scale) {
+                LARGE_INTEGER freq;
+                QueryPerformanceFrequency(&freq);
+                GrAssert(0 != freq.QuadPart);
+                scale = 1 / (double) freq.QuadPart;
+            }
+            return scale;
+        }
+    };
+    typedef GrStopwatchBase<GrWin32Timer> GrStopwatch;
+#else
+    #error "Implement platform timer for stopwatch"
+#endif
+
+
+#endif
diff --git a/gpu/include/GrStringBuilder.h b/gpu/include/GrStringBuilder.h
new file mode 100644
index 0000000..bcf124f
--- /dev/null
+++ b/gpu/include/GrStringBuilder.h
@@ -0,0 +1,182 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrStringBuilder_DEFINED
+#define GrStringBuilder_DEFINED
+
+#include <GrTArray.h>
+#include <stdio.h>
+
+// Class used to concat strings together into a single string
+// See below for GrSStringBuilder subclass that has a pool of
+// stack storage (to avoid malloc).
+class GrStringBuilder {
+public:
+    GrStringBuilder() :
+            fChars() {
+        fChars.push_back() = '\0';
+    }
+
+    GrStringBuilder(const GrStringBuilder& s) :
+            fChars(s.fChars) {
+        GrAssert('\0' == s.fChars.back());
+    }
+
+    GrStringBuilder(const char* s) :
+            fChars(s, strlen(s)+1) {
+    }
+
+    GrStringBuilder(const GrStringBuilder& a, const GrStringBuilder& b) {
+        GrAssert('\0' == a.fChars.back());
+        GrAssert('\0' == b.fChars.back());
+
+        fChars.push_back_n(a.fChars.count() + b.fChars.count() - 1);
+        char* s = &fChars.front();
+        memcpy(s, &a.fChars.front(), a.fChars.count() - 1);
+        s += a.fChars.count() - 1;
+        memcpy(s, &b.fChars.front(), b.fChars.count());
+    }
+
+    GrStringBuilder& operator =(const GrStringBuilder& s) {
+        fChars = s.fChars;
+        return *this;
+    }
+
+    GrStringBuilder& operator =(const char* s) {
+        GrAssert('\0' == fChars.back());
+
+        int l = strlen(s);
+        fChars.resize_back(l + 1);
+        memcpy(&fChars.front(), s, l + 1);
+        return *this;
+    }
+
+    GrStringBuilder& operator +=(const GrStringBuilder& s) {
+        GrAssert('\0' == fChars.back());
+        GrAssert('\0' == s.fChars.back());
+        fChars.push_back_n(s.length());
+        memcpy(&fChars.fromBack(s.length()), &s.fChars.front(), s.fChars.count());
+        return *this;
+    }
+
+    GrStringBuilder& operator +=(const char* s) {
+        GrAssert('\0' == fChars.back());
+        int l = strlen(s);
+        fChars.push_back_n(l);
+        memcpy(&fChars.fromBack(l), s, l + 1);
+        return *this;
+    }
+
+    GrStringBuilder& operator +=(char c) {
+        GrAssert('\0' == fChars.back());
+        fChars.back() = c;
+        fChars.push_back() = '\0';
+        return *this;
+    }
+
+    void appendInt(int x) {
+        GR_STATIC_ASSERT(4 == sizeof(int));
+        // -, 10 digits, null char
+        char temp[12];
+        sprintf(temp, "%d", x);
+        *this += temp;
+    }
+
+    char& operator [](int i) {
+        GrAssert(i < length());
+        return fChars[i];
+    }
+
+    char operator [](int i) const {
+        GrAssert(i < length());
+        return fChars[i];
+    }
+
+    const char* cstr() const { return &fChars.front(); }
+
+    int length() const { return fChars.count() - 1; }
+
+protected:
+    // helpers for GrSStringBuilder (with storage on the stack)
+
+    GrStringBuilder(void* stackChars, int stackCount) :
+            fChars(stackCount ? stackChars : NULL,
+                   stackCount) {
+        fChars.push_back() = '\0';
+    }
+
+    GrStringBuilder(void* stackChars,
+                    int stackCount,
+                    const GrStringBuilder& s) :
+            fChars(s.fChars,
+                   (stackCount ? stackChars : NULL),
+                   stackCount) {
+    }
+
+    GrStringBuilder(void* stackChars,
+                    int stackCount,
+                    const char* s) :
+            fChars(s,
+                   strlen(s)+1,
+                   stackCount ? stackChars : NULL,
+                   stackCount) {
+    }
+
+    GrStringBuilder(void* stackChars,
+                    int stackCount,
+                    const GrStringBuilder& a,
+                    const GrStringBuilder& b) :
+            fChars(stackCount ? stackChars : NULL,
+                   stackCount) {
+        GrAssert('\0' == a.fChars.back());
+        GrAssert('\0' == b.fChars.back());
+
+        fChars.push_back_n(a.fChars.count() + b.fChars.count() - 1);
+        char* s = &fChars.front();
+        memcpy(s, &a.fChars.front(), a.fChars.count() - 1);
+        s += a.fChars.count() - 1;
+        memcpy(s, &b.fChars.front(), b.fChars.count());
+    }
+
+private:
+    GrTArray<char, true>  fChars;
+};
+
+template <int STACK_COUNT = 128>
+class GrSStringBuilder : public GrStringBuilder {
+public:
+    GrSStringBuilder() : GrStringBuilder(fStackChars, STACK_COUNT) {}
+
+    GrSStringBuilder(const GrStringBuilder& s) : GrStringBuilder(fStackChars,
+                                                                 STACK_COUNT,
+                                                                 s) {
+    }
+
+    GrSStringBuilder(const char* s) : GrStringBuilder(fStackChars,
+                                                      STACK_COUNT,
+                                                      s) {
+    }
+
+    GrSStringBuilder(const GrStringBuilder& a, const GrStringBuilder& b) :
+            GrStringBuilder(fStackChars, STACK_COUNT, a, b) {
+    }
+private:
+    char fStackChars[STACK_COUNT];
+};
+
+#endif
+
diff --git a/gpu/include/GrTArray.h b/gpu/include/GrTArray.h
new file mode 100644
index 0000000..6ef1a13
--- /dev/null
+++ b/gpu/include/GrTArray.h
@@ -0,0 +1,319 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTArray_DEFINED
+#define GrTArray_DEFINED
+
+#include <new>
+#include "GrTypes.h"
+
+// DATA_TYPE indicates that T has a trivial cons, destructor
+// and can be shallow-copied
+template <typename T, bool DATA_TYPE = false> class GrTArray {
+public:
+    GrTArray() {
+        fCount = 0;
+        fReserveCount = MIN_ALLOC_COUNT;
+        fAllocCount = 0;
+        fMemArray = NULL;
+        fPreAllocMemArray = NULL;
+    }
+
+    explicit GrTArray(int reserveCount) {
+        GrAssert(reserveCount >= 0);
+        fCount = 0;
+        fReserveCount = reserveCount > MIN_ALLOC_COUNT ? reserveCount :
+                                                         MIN_ALLOC_COUNT;
+        fAllocCount = fReserveCount;
+        fMemArray = GrMalloc(sizeof(T) * fReserveCount);
+        fPreAllocMemArray = NULL;
+    }
+
+    GrTArray(void* preAllocStorage, int preAllocCount) {
+        GrAssert(preAllocCount >= 0);
+        // we allow NULL,0 args and revert to the default cons. behavior
+        // this makes it possible for a owner-object to use same constructor
+        // to get either prealloc or nonprealloc behavior based using same line
+        GrAssert((NULL == preAllocStorage) == !preAllocCount);
+
+        fCount              = 0;
+        fReserveCount       = preAllocCount > 0 ? preAllocCount :
+                                                  MIN_ALLOC_COUNT;
+        fAllocCount         = preAllocCount;
+        fMemArray           = preAllocStorage;
+        fPreAllocMemArray   = preAllocStorage;
+    }
+
+    explicit GrTArray(const GrTArray& array) {
+        fCount              = array.count();
+        fReserveCount       = MIN_ALLOC_COUNT;
+        fAllocCount         = GrMax(fReserveCount, fCount);
+        fMemArray           = GrMalloc(sizeof(T) * fAllocCount);
+        fPreAllocMemArray   = NULL;
+        if (DATA_TYPE) {
+            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
+        } else {
+            for (int i = 0; i < fCount; ++i) {
+                new (fItemArray + i) T(array[i]);
+            }
+        }
+    }
+
+    GrTArray(const T* array, int count) {
+        GrAssert(count >= 0);
+        fCount              = count;
+        fReserveCount       = MIN_ALLOC_COUNT;
+        fAllocCount         = GrMax(fReserveCount, fCount);
+        fMemArray           = GrMalloc(sizeof(T) * fAllocCount);
+        fPreAllocMemArray   = NULL;
+        if (DATA_TYPE) {
+            memcpy(fMemArray, array, sizeof(T) * fCount);
+        } else {
+            for (int i = 0; i < fCount; ++i) {
+                new (fItemArray + i) T(array[i]);
+            }
+        }
+    }
+
+    GrTArray(const GrTArray& array,
+             void* preAllocStorage, int preAllocCount) {
+
+        GrAssert(preAllocCount >= 0);
+
+        // for same reason as non-copying cons we allow NULL, 0 for prealloc
+        GrAssert((NULL == preAllocStorage) == !preAllocCount);
+
+        fCount              = array.count();
+        fReserveCount       = preAllocCount > 0 ? preAllocCount :
+                                                  MIN_ALLOC_COUNT;
+        fPreAllocMemArray   = preAllocStorage;
+
+        if (fReserveCount >= fCount && preAllocCount) {
+            fAllocCount = fReserveCount;
+            fMemArray = preAllocStorage;
+        } else {
+            fAllocCount = GrMax(fCount, fReserveCount);
+            fMemArray = GrMalloc(fAllocCount * sizeof(T));
+        }
+
+        if (DATA_TYPE) {
+            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
+        } else {
+            for (int i = 0; i < fCount; ++i) {
+                new (fItemArray + i) T(array[i]);
+            }
+        }
+    }
+
+    GrTArray(const T* array, int count,
+             void* preAllocStorage, int preAllocCount) {
+
+        GrAssert(count >= 0);
+        GrAssert(preAllocCount >= 0);
+
+        // for same reason as non-copying cons we allow NULL, 0 for prealloc
+        GrAssert((NULL == preAllocStorage) == !preAllocCount);
+
+        fCount              = count;
+        fReserveCount       = (preAllocCount > 0) ? preAllocCount :
+                                                    MIN_ALLOC_COUNT;
+        fPreAllocMemArray   = preAllocStorage;
+
+        if (fReserveCount >= fCount && preAllocCount) {
+            fAllocCount = fReserveCount;
+            fMemArray = preAllocStorage;
+        } else {
+            fAllocCount = GrMax(fCount, fReserveCount);
+            fMemArray = GrMalloc(fAllocCount * sizeof(T));
+        }
+
+        if (DATA_TYPE) {
+            memcpy(fMemArray, array, sizeof(T) * fCount);
+        } else {
+            for (int i = 0; i < fCount; ++i) {
+                new (fItemArray + i) T(array[i]);
+            }
+        }
+    }
+
+    GrTArray& operator =(const GrTArray& array) {
+        for (int i = 0; i < fCount; ++i) {
+            fItemArray[i].~T();
+        }
+        fCount = 0;
+        checkRealloc((int)array.count());
+        fCount = array.count();
+        if (DATA_TYPE) {
+            memcpy(fMemArray, array.fMemArray, sizeof(T) * fCount);
+        } else {
+            for (int i = 0; i < fCount; ++i) {
+                new (fItemArray + i) T(array[i]);
+            }
+        }
+        return *this;
+    }
+
+    ~GrTArray() {
+        for (int i = 0; i < fCount; ++i) {
+            fItemArray[i].~T();
+        }
+        if (fMemArray != fPreAllocMemArray) {
+            GrFree(fMemArray);
+        }
+    }
+
+    void reset() { this->pop_back_n(fCount); }
+
+    int count() const { return fCount; }
+
+    bool empty() const { return !fCount; }
+
+    T& push_back() {
+        checkRealloc(1);
+        new ((char*)fMemArray+sizeof(T)*fCount) T;
+        ++fCount;
+        return fItemArray[fCount-1];
+    }
+
+    void push_back_n(int n) {
+        GrAssert(n >= 0);
+        checkRealloc(n);
+        for (int i = 0; i < n; ++i) {
+            new (fItemArray + fCount + i) T;
+        }
+        fCount += n;
+    }
+
+    void pop_back() {
+        GrAssert(fCount > 0);
+        --fCount;
+        fItemArray[fCount].~T();
+        checkRealloc(0);
+    }
+
+    void pop_back_n(int n) {
+        GrAssert(n >= 0);
+        GrAssert(fCount >= n);
+        fCount -= n;
+        for (int i = 0; i < n; ++i) {
+            fItemArray[i].~T();
+        }
+        checkRealloc(0);
+    }
+
+    // pushes or pops from the back to resize
+    void resize_back(int newCount) {
+        GrAssert(newCount >= 0);
+
+        if (newCount > fCount) {
+            push_back_n(newCount - fCount);
+        } else if (newCount < fCount) {
+            pop_back_n(fCount - newCount);
+        }
+    }
+
+    T& operator[] (int i) {
+        GrAssert(i < fCount);
+        GrAssert(i >= 0);
+        return fItemArray[i];
+    }
+
+    const T& operator[] (int i) const {
+        GrAssert(i < fCount);
+        GrAssert(i >= 0);
+        return fItemArray[i];
+    }
+
+    T& front() { GrAssert(fCount > 0); return fItemArray[0];}
+
+    const T& front() const { GrAssert(fCount > 0); return fItemArray[0];}
+
+    T& back() { GrAssert(fCount); return fItemArray[fCount - 1];}
+
+    const T& back() const { GrAssert(fCount > 0); return fItemArray[fCount - 1];}
+
+    T& fromBack(int i) {
+        GrAssert(i >= 0);
+        GrAssert(i < fCount);
+        return fItemArray[fCount - i - 1];
+    }
+
+    const T& fromBack(int i) const {
+        GrAssert(i >= 0);
+        GrAssert(i < fCount);
+        return fItemArray[fCount - i - 1];
+    }
+
+private:
+
+    static const int MIN_ALLOC_COUNT = 8;
+
+    inline void checkRealloc(int delta) {
+        GrAssert(fCount >= 0);
+        GrAssert(fAllocCount >= 0);
+
+        GrAssert(-delta <= fCount);
+
+        int newCount = fCount + delta;
+        int fNewAllocCount = fAllocCount;
+
+        if (newCount > fAllocCount) {
+            fNewAllocCount = GrMax(newCount + ((newCount + 1) >> 1),
+                                   fReserveCount);
+        } else if (newCount < fAllocCount / 3) {
+            fNewAllocCount = GrMax(fAllocCount / 2, fReserveCount);
+        }
+
+        if (fNewAllocCount != fAllocCount) {
+
+            fAllocCount = fNewAllocCount;
+            char* fNewMemArray;
+
+            if (fAllocCount == fReserveCount && NULL != fPreAllocMemArray) {
+                fNewMemArray = (char*) fPreAllocMemArray;
+            } else {
+                fNewMemArray = (char*) GrMalloc(fAllocCount*sizeof(T));
+            }
+
+            if (DATA_TYPE) {
+                memcpy(fNewMemArray, fMemArray, fCount * sizeof(T));
+            } else {
+                for (int i = 0; i < fCount; ++i) {
+                    new (fNewMemArray + sizeof(T) * i) T(fItemArray[i]);
+                    fItemArray[i].~T();
+                }
+            }
+
+            if (fMemArray != fPreAllocMemArray) {
+                GrFree(fMemArray);
+            }
+            fMemArray = fNewMemArray;
+        }
+    }
+
+    int fReserveCount;
+    int fCount;
+    int fAllocCount;
+    void*    fPreAllocMemArray;
+    union {
+        T*       fItemArray;
+        void*    fMemArray;
+    };
+};
+
+#endif
+
diff --git a/gpu/include/GrTBSearch.h b/gpu/include/GrTBSearch.h
new file mode 100644
index 0000000..264ccb0
--- /dev/null
+++ b/gpu/include/GrTBSearch.h
@@ -0,0 +1,53 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTBSearch_DEFINED
+#define GrTBSearch_DEFINED
+
+template <typename ELEM, typename KEY>
+int GrTBSearch(const ELEM array[], int count, KEY target) {
+    GrAssert(count >= 0);
+    if (0 == count) {
+        // we should insert it at 0
+        return ~0;
+    }
+    
+    int high = count - 1;
+    int low = 0;
+    while (high > low) {
+        int index = (low + high) >> 1;
+        if (LT(array[index], target)) {
+            low = index + 1;
+        } else {
+            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;
+    }
+    return ~high;
+}
+
+#endif
+
diff --git a/gpu/include/GrTDArray.h b/gpu/include/GrTDArray.h
new file mode 100644
index 0000000..092242e
--- /dev/null
+++ b/gpu/include/GrTDArray.h
@@ -0,0 +1,222 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTDArray_DEFINED
+#define GrTDArray_DEFINED
+
+#include "GrTypes.h"
+
+static int GrInitialArrayAllocationCount() {
+    return 4;
+}
+
+static int GrNextArrayAllocationCount(int count) {
+    return count + ((count + 1) >> 1);
+}
+
+template <typename T> class GrTDArray {
+public:
+    GrTDArray() : fArray(NULL), fAllocated(0), fCount(0) {}
+    GrTDArray(const GrTDArray& src) {
+        fCount = fAllocated = src.fCount;
+        fArray = (T*)GrMalloc(fAllocated * sizeof(T));
+        memcpy(fArray, src.fArray, fCount * sizeof(T));
+    }
+    ~GrTDArray() {
+        if (fArray) {
+            GrFree(fArray);
+        }
+    }
+
+    bool isEmpty() const { return 0 == fCount; }
+    int count() const { return fCount; }
+
+    const T& at(int index) const {
+        GrAssert((unsigned)index < (unsigned)fCount);
+        return fArray[index];
+    }
+    T& at(int index) {
+        GrAssert((unsigned)index < (unsigned)fCount);
+        return fArray[index];
+    }
+
+    const T& operator[](int index) const { return this->at(index); }
+    T& operator[](int index) { return this->at(index); }
+
+    GrTDArray& operator=(const GrTDArray& src) {
+        if (fAllocated < src.fCount) {
+            fAllocated = src.fCount;
+            GrFree(fArray);
+            fArray = (T*)GrMalloc(fAllocated * sizeof(T));
+        }
+        fCount = src.fCount;
+        memcpy(fArray, src.fArray, fCount * sizeof(T));
+        return *this;
+    }
+
+    void reset() {
+        if (fArray) {
+            GrFree(fArray);
+            fArray = NULL;
+        }
+        fAllocated = fCount = 0;
+    }
+
+    T* begin() const { return fArray; }
+    T* end() const { return fArray + fCount; }
+    T* back() const { GrAssert(fCount); return fArray + (fCount - 1); } 
+
+    T* prepend() {
+        this->growAt(0);
+        return fArray;
+    }
+
+    T* append() {
+        this->growAt(fCount);
+        return fArray + fCount - 1;
+    }
+
+    /**
+     *  index may be [0..count], so that you can insert at the end (like append)
+     */
+    T* insert(int index) {
+        GrAssert((unsigned)index <= (unsigned)fCount);
+        this->growAt(index);
+        return fArray + index;
+    }
+
+    void remove(int index) {
+        GrAssert((unsigned)index < (unsigned)fCount);
+        fCount -= 1;
+        if (index < fCount) {
+            int remaining = fCount - index;
+            memmove(fArray + index, fArray + index + 1, remaining * sizeof(T));
+        }
+    }
+
+    void removeShuffle(int index) {
+        GrAssert((unsigned)index < (unsigned)fCount);
+        fCount -= 1;
+        if (index < fCount) {
+            memmove(fArray + index, fArray + fCount, sizeof(T));
+        }
+    }
+
+    // Utility iterators
+
+    /**
+     *  Calls GrFree() on each element. Assumes each is NULL or was allocated
+     *  with GrMalloc().
+     */
+    void freeAll() {
+        T* stop = this->end();
+        for (T* curr = this->begin(); curr < stop; curr++) {
+            GrFree(*curr);
+        }
+        this->reset();
+    }
+
+    /**
+     *  Calls delete on each element. Assumes each is NULL or was allocated
+     *  with new.
+     */
+    void deleteAll() {
+        T* stop = this->end();
+        for (T* curr = this->begin(); curr < stop; curr++) {
+            delete *curr;
+        }
+        this->reset();
+    }
+
+    /**
+     *  Calls GrSafeUnref() on each element. Assumes each is NULL or is a
+     *  subclass of GrRefCnt.
+     */
+    void unrefAll() {
+        T* stop = this->end();
+        for (T* curr = this->begin(); curr < stop; curr++) {
+            GrSafeUnref(*curr);
+        }
+        this->reset();
+    }
+
+    void visit(void visitor(T&)) const {
+        T* stop = this->end();
+        for (T* curr = this->begin(); curr < stop; curr++) {
+            if (*curr) {
+                visitor(*curr);
+            }
+        }
+    }
+
+    int find(const T& elem) const {
+        int count = this->count();
+        T* curr = this->begin();
+        for (int i = 0; i < count; i++) {
+            if (elem == curr[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    friend bool operator==(const GrTDArray<T>& a, const GrTDArray<T>& b) {
+        return a.count() == b.count() &&
+               (0 == a.count() ||
+                0 == memcmp(a.begin(), b.begin(), a.count() * sizeof(T)));
+    }
+    friend bool operator!=(const GrTDArray<T>& a, const GrTDArray<T>& b) {
+        return !(a == b);
+    }
+
+private:
+    T*  fArray;
+    int fAllocated, fCount;
+
+    // growAt will increment fCount, reallocate fArray (as needed), and slide
+    // the contents of fArray to make a hole for new data at index.
+    void growAt(int index) {
+        GrAssert(fCount <= fAllocated);
+        if (0 == fAllocated) {
+            fAllocated = GrInitialArrayAllocationCount();
+            fArray = (T*)GrMalloc(fAllocated * sizeof(T));
+        } else if (fCount == fAllocated) {
+            fAllocated = GrNextArrayAllocationCount(fAllocated);
+            T* newArray = (T*)GrMalloc(fAllocated * sizeof(T));
+            memcpy(newArray, fArray, index * sizeof(T));
+            memcpy(newArray + index + 1, fArray + index,
+                   (fCount - index) * sizeof(T));
+            GrFree(fArray);
+            fArray = newArray;
+        } else {
+            // check that we're not just appending
+            if (index < fCount) {
+                memmove(fArray + index + 1, fArray + index,
+                        (fCount - index) * sizeof(T));
+            }
+        }
+        GrAssert(fCount < fAllocated);
+        fCount += 1;
+    }
+};
+
+extern void* GrTDArray_growAt(void*, int* allocated, int& count, int index,
+                              size_t);
+
+
+#endif
+
diff --git a/gpu/include/GrTHashCache.h b/gpu/include/GrTHashCache.h
new file mode 100644
index 0000000..510f9ab
--- /dev/null
+++ b/gpu/include/GrTHashCache.h
@@ -0,0 +1,226 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTHashCache_DEFINED
+#define GrTHashCache_DEFINED
+
+#include "GrTDArray.h"
+
+/**
+ *  Key needs
+ *      static bool EQ(const Entry&, const HashKey&);
+ *      static bool LT(const Entry&, const HashKey&);
+ *      uint32_t getHash() const;
+ *
+ *  Allows duplicate key entries but on find you may get
+ *  any of the duplicate entries returned.
+ */
+template <typename T, typename Key, size_t kHashBits> class GrTHashTable {
+public:
+    GrTHashTable() { Gr_bzero(fHash, sizeof(fHash)); }
+    ~GrTHashTable() {}
+
+    int count() const { return fSorted.count(); }
+    T*  find(const Key&) const;
+    // return true if key was unique when inserted.
+    bool insert(const Key&, T*);
+    void remove(const Key&, const T*);
+    T* removeAt(int index, uint32_t hash);
+    void removeAll();
+    void deleteAll();
+    void unrefAll();
+
+    /**
+     *  Return the index for the element, using a linear search.
+     */
+    int slowFindIndex(T* elem) const { return fSorted.find(elem); }
+
+#if GR_DEBUG
+    void validate() const;
+    bool contains(T*) const;
+#endif
+
+    // testing
+    const GrTDArray<T*>& getArray() const { return fSorted; }
+private:
+    enum {
+        kHashCount = 1 << kHashBits,
+        kHashMask  = kHashCount - 1
+    };
+    static unsigned hash2Index(uint32_t hash) {
+        hash ^= hash >> 16;
+        if (kHashBits <= 8) {
+            hash ^= hash >> 8;
+        }
+        return hash & kHashMask;
+    }
+
+    mutable T* fHash[kHashCount];
+    GrTDArray<T*> fSorted;
+
+    // search fSorted, and return the found index, or ~index of where it
+    // should be inserted
+    int searchArray(const Key&) const;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename Key, size_t kHashBits>
+int GrTHashTable<T, Key, kHashBits>::searchArray(const Key& key) const {
+    int count = fSorted.count();
+    if (0 == count) {
+        // we should insert it at 0
+        return ~0;
+    }
+
+    const T* const* array = fSorted.begin();
+    int high = count - 1;
+    int low = 0;
+    while (high > low) {
+        int index = (low + high) >> 1;
+        if (Key::LT(*array[index], key)) {
+            low = index + 1;
+        } else {
+            high = index;
+        }
+    }
+
+    // check if we found it
+    if (Key::EQ(*array[high], key)) {
+        // above search should have found the first occurrence if there
+        // are multiple.
+        GrAssert(0 == high || Key::LT(*array[high - 1], key));
+        return high;
+    }
+
+    // now return the ~ of where we should insert it
+    if (Key::LT(*array[high], key)) {
+        high += 1;
+    }
+    return ~high;
+}
+
+template <typename T, typename Key, size_t kHashBits>
+T* GrTHashTable<T, Key, kHashBits>::find(const Key& key) const {
+    int hashIndex = hash2Index(key.getHash());
+    T* elem = fHash[hashIndex];
+
+    if (NULL == elem || !Key::EQ(*elem, key)) {
+        // bsearch for the key in our sorted array
+        int index = this->searchArray(key);
+        if (index < 0) {
+            return NULL;
+        }
+        elem = fSorted[index];
+        // update the hash
+        fHash[hashIndex] = elem;
+    }
+    return elem;
+}
+
+template <typename T, typename Key, size_t kHashBits>
+bool GrTHashTable<T, Key, kHashBits>::insert(const Key& key, T* elem) {
+    int index = this->searchArray(key);
+    bool first = index < 0;
+    if (first) {
+        // turn it into the actual index
+        index = ~index;
+    }
+    // add it to our array
+    *fSorted.insert(index) = elem;
+    // update our hash table (overwrites any dupe's position in the hash)
+    fHash[hash2Index(key.getHash())] = elem;
+    return first;
+}
+
+template <typename T, typename Key, size_t kHashBits>
+void GrTHashTable<T, Key, kHashBits>::remove(const Key& key, const T* elem) {
+    int index = hash2Index(key.getHash());
+    if (fHash[index] == elem) {
+        fHash[index] = NULL;
+    }
+
+    // remove from our sorted array
+    index = this->searchArray(key);
+    GrAssert(index >= 0);
+    // if there are multiple matches searchArray will give us the first match
+    // march forward until we find elem.
+    while (elem != fSorted[index]) {
+        ++index;
+        GrAssert(index < fSorted.count());
+    }
+    GrAssert(elem == fSorted[index]);
+    fSorted.remove(index);
+}
+
+template <typename T, typename Key, size_t kHashBits>
+T* GrTHashTable<T, Key, kHashBits>::removeAt(int elemIndex, uint32_t hash) {
+    int hashIndex = hash2Index(hash);
+    if (fHash[hashIndex] == fSorted[elemIndex]) {
+        fHash[hashIndex] = NULL;
+    }
+    // remove from our sorted array
+    T* elem = fSorted[elemIndex];
+    fSorted.remove(elemIndex);
+    return elem;
+}
+
+template <typename T, typename Key, size_t kHashBits>
+void GrTHashTable<T, Key, kHashBits>::removeAll() {
+    fSorted.reset();
+    Gr_bzero(fHash, sizeof(fHash));
+}
+
+template <typename T, typename Key, size_t kHashBits>
+void GrTHashTable<T, Key, kHashBits>::deleteAll() {
+    fSorted.deleteAll();
+    Gr_bzero(fHash, sizeof(fHash));
+}
+
+template <typename T, typename Key, size_t kHashBits>
+void GrTHashTable<T, Key, kHashBits>::unrefAll() {
+    fSorted.unrefAll();
+    Gr_bzero(fHash, sizeof(fHash));
+}
+
+#if GR_DEBUG
+template <typename T, typename Key, size_t kHashBits>
+void GrTHashTable<T, Key, kHashBits>::validate() const {
+    for (size_t i = 0; i < GR_ARRAY_COUNT(fHash); i++) {
+        if (fHash[i]) {
+            unsigned hashIndex = hash2Index(Key::GetHash(*fHash[i]));
+            GrAssert(hashIndex == i);
+        }
+    }
+
+    int count = fSorted.count();
+    for (int i = 1; i < count; i++) {
+        GrAssert(Key::LT(*fSorted[i - 1], *fSorted[i]) ||
+                 Key::EQ(*fSorted[i - 1], *fSorted[i]));
+    }
+}
+
+template <typename T, typename Key, size_t kHashBits>
+bool GrTHashTable<T, Key, kHashBits>::contains(T* elem) const {
+    int index = fSorted.find(elem);
+    return index >= 0;
+}
+
+#endif
+
+#endif
+
diff --git a/gpu/include/GrTLList.h b/gpu/include/GrTLList.h
new file mode 100644
index 0000000..1f59635
--- /dev/null
+++ b/gpu/include/GrTLList.h
@@ -0,0 +1,61 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTLList_DEFINED
+#define GrTLList_DEFINED
+
+#include "GrNoncopyable.h"
+
+template <typename T> class GrTLList : GrNoncopyable {
+public:
+    class Entry {
+        Entry*  fPrev;
+        Entry*  fNext;
+    };
+
+    GrTLList() : fHead(NULL), fTail(NULL) {}
+#if GR_DEBUG
+    ~GrTLList() {
+        GrAssert(NULL == fHead);
+        GrAssert(NULL == ftail);
+    }
+#endif
+
+    T*  head() const { return fHead; }
+    T*  tail() const { return fTail; }
+    
+    void addToHead(T*);
+    void addToTail(T*);
+    void removeFromList(T*);
+
+private:
+    Entry*  fHead;
+    Entry*  fTail;
+
+    friend class Entry;
+};
+
+
+class Parent {
+    GrTDLList<Child>    fList;
+};
+
+class Child : public GrTLList::Entry<Child> {
+};
+
+#endif
+
diff --git a/gpu/include/GrTextContext.h b/gpu/include/GrTextContext.h
new file mode 100644
index 0000000..a598251
--- /dev/null
+++ b/gpu/include/GrTextContext.h
@@ -0,0 +1,74 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTextContext_DEFINED
+#define GrTextContext_DEFINED
+
+#include "GrGlyph.h"
+#include "GrPaint.h"
+
+struct GrGpuTextVertex;
+class GrMatrix;
+class GrContext;
+class GrTextStrike;
+class GrFontScaler;
+class GrDrawTarget;
+
+class GrTextContext {
+public:
+    GrTextContext(GrContext*,
+                  const GrPaint& paint,
+                  const GrMatrix* extMatrix = NULL);
+    ~GrTextContext();
+
+    void drawPackedGlyph(GrGlyph::PackedID, GrFixed left, GrFixed top,
+                         GrFontScaler*);
+
+    void flush();   // optional; automatically called by destructor
+
+private:
+    GrPaint         fPaint;
+    GrVertexLayout  fVertexLayout;
+    GrContext*      fContext;
+    GrDrawTarget*   fDrawTarget;
+
+    GrMatrix        fExtMatrix;
+    GrFontScaler*   fScaler;
+    GrTextStrike*   fStrike;
+
+    inline void flushGlyphs();
+
+    enum {
+        kMinRequestedGlyphs      = 1,
+        kDefaultRequestedGlyphs  = 64,
+        kMinRequestedVerts       = kMinRequestedGlyphs * 4,
+        kDefaultRequestedVerts   = kDefaultRequestedGlyphs * 4,
+    };
+
+    GrGpuTextVertex* fVertices;
+
+    int32_t     fMaxVertices;
+    GrTexture*  fCurrTexture;
+    int         fCurrVertex;
+
+    GrIRect     fClipRect;
+    GrMatrix    fOrigViewMatrix;    // restore previous viewmatrix
+};
+
+#endif
+
+
diff --git a/gpu/include/GrTextStrike.h b/gpu/include/GrTextStrike.h
new file mode 100644
index 0000000..abafa57
--- /dev/null
+++ b/gpu/include/GrTextStrike.h
@@ -0,0 +1,119 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTextStrike_DEFINED
+#define GrTextStrike_DEFINED
+
+#include "GrAllocPool.h"
+#include "GrFontScaler.h"
+#include "GrTHashCache.h"
+#include "GrPoint.h"
+#include "GrGlyph.h"
+
+class GrAtlasMgr;
+class GrFontCache;
+class GrGpu;
+class GrFontPurgeListener;
+
+/**
+ *  The textcache maps a hostfontscaler instance to a dictionary of
+ *  glyphid->strike
+ */
+class GrTextStrike {
+public:
+    GrTextStrike(GrFontCache*, const GrKey* fontScalerKey, GrAtlasMgr*);
+    ~GrTextStrike();
+
+    const GrKey* getFontScalerKey() const { return fFontScalerKey; }
+    GrFontCache* getFontCache() const { return fFontCache; }
+
+    inline GrGlyph* getGlyph(GrGlyph::PackedID, GrFontScaler*);
+    bool getGlyphAtlas(GrGlyph*, GrFontScaler*);
+
+    // testing
+    int countGlyphs() const { return fCache.getArray().count(); }
+    const GrGlyph* glyphAt(int index) const {
+        return fCache.getArray()[index];
+    }
+    GrAtlas* getAtlas() const { return fAtlas; }
+
+public:
+    // for LRU
+    GrTextStrike*   fPrev;
+    GrTextStrike*   fNext;
+
+private:
+    class Key;
+    GrTHashTable<GrGlyph, Key, 7> fCache;
+    const GrKey* fFontScalerKey;
+    GrTAllocPool<GrGlyph> fPool;
+
+    GrFontCache*    fFontCache;
+    GrAtlasMgr*     fAtlasMgr;
+    GrAtlas*        fAtlas;     // linklist
+
+    GrGlyph* generateGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler);
+    // returns true if after the purge, the strike is empty
+    bool purgeAtlasAtY(GrAtlas* atlas, int yCoord);
+
+    friend class GrFontCache;
+};
+
+class GrFontCache {
+public:
+    GrFontCache(GrGpu*);
+    ~GrFontCache();
+
+    inline GrTextStrike* getStrike(GrFontScaler*);
+
+    void freeAll();
+    void abandonAll();
+
+    void purgeExceptFor(GrTextStrike*);
+
+    // testing
+    int countStrikes() const { return fCache.getArray().count(); }
+    const GrTextStrike* strikeAt(int index) const {
+        return fCache.getArray()[index];
+    }
+    GrTextStrike* getHeadStrike() const { return fHead; }
+
+#if GR_DEBUG
+    void validate() const;
+#else
+    void validate() const {}
+#endif
+
+private:
+    friend class GrFontPurgeListener;
+
+    class Key;
+    GrTHashTable<GrTextStrike, Key, 8> fCache;
+    // for LRU
+    GrTextStrike* fHead;
+    GrTextStrike* fTail;
+
+    GrGpu*      fGpu;
+    GrAtlasMgr* fAtlasMgr;
+
+    
+    GrTextStrike* generateStrike(GrFontScaler*, const Key&);
+    inline void detachStrikeFromList(GrTextStrike*);
+};
+
+#endif
+
diff --git a/gpu/include/GrTexture.h b/gpu/include/GrTexture.h
new file mode 100644
index 0000000..666aa57
--- /dev/null
+++ b/gpu/include/GrTexture.h
@@ -0,0 +1,206 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTexture_DEFINED
+#define GrTexture_DEFINED
+
+#include "GrRefCnt.h"
+#include "GrClip.h"
+
+class GrTexture;
+
+/**
+ * GrRenderTarget represents a 2D buffer of pixels that can be rendered to.
+ * A context's render target is set by setRenderTarget(). Render targets are
+ * created by a createTexture with the kRenderTarget_TextureFlag flag.
+ * Additionally, GrContext provides methods for creating GrRenderTargets
+ * that wrap externally created render targets.
+ */
+class GrRenderTarget : public GrRefCnt {
+public:
+    /**
+     * @return the width of the rendertarget
+     */
+    int width() const { return fWidth; }
+    /**
+     * @return the height of the rendertarget
+     */
+    int height() const { return fHeight; }
+
+    /**
+     * @return the number of stencil bits in the rendertarget
+     */
+    int stencilBits() const { return fStencilBits; }
+
+    /**
+     * @return the texture associated with the rendertarget, may be NULL.
+     */
+    GrTexture* asTexture() {return fTexture;}
+
+protected:
+    GrRenderTarget(GrTexture* texture,
+                   int width,
+                   int height,
+                   int stencilBits)
+        : fTexture(texture),
+          fWidth(width),
+          fHeight(height),
+          fStencilBits(stencilBits) {}
+
+
+    GrTexture* fTexture;
+    int        fWidth;
+    int        fHeight;
+    int        fStencilBits;
+
+private:
+    // GrGpu keeps a cached clip in the render target to avoid redundantly
+    // rendering the clip into the same stencil buffer.
+    friend class GrGpu;
+    GrClip     fLastStencilClip;
+
+    typedef GrRefCnt INHERITED;
+};
+
+class GrTexture : public GrRefCnt {
+public:
+    enum PixelConfig {
+        kUnknown_PixelConfig,
+        kAlpha_8_PixelConfig,
+        kIndex_8_PixelConfig,
+        kRGB_565_PixelConfig,
+        kRGBA_4444_PixelConfig, //!< premultiplied
+        kRGBA_8888_PixelConfig, //!< premultiplied
+        kRGBX_8888_PixelConfig, //!< treat the alpha channel as opaque
+    };
+    static size_t BytesPerPixel(PixelConfig);
+    static bool PixelConfigIsOpaque(PixelConfig);
+
+protected:
+    GrTexture(int width,
+              int height,
+              PixelConfig config) :
+                fWidth(width),
+                fHeight(height),
+                fConfig(config) {
+                    // only make sense if alloc size is pow2
+                    fShiftFixedX = 31 - Gr_clz(fWidth);
+                    fShiftFixedY = 31 - Gr_clz(fHeight);
+                }
+public:
+    virtual ~GrTexture();
+
+    /**
+     * Retrieves the width of the texture.
+     *
+     * @return the width in texels
+     */
+    int width() const { return fWidth; }
+    /**
+     * Retrieves the height of the texture.
+     *
+     * @return the height in texels
+     */
+    int height() const { return fHeight; }
+
+    /**
+     * Convert from texels to normalized texture coords for POT textures
+     * only.
+     */
+    GrFixed normalizeFixedX(GrFixed x) const { GrAssert(GrIsPow2(fWidth));
+                                               return x >> fShiftFixedX; }
+    GrFixed normalizeFixedY(GrFixed y) const { GrAssert(GrIsPow2(fHeight));
+                                               return y >> fShiftFixedY; }
+
+    /**
+     * Retrieves the pixel config specified when the texture was created.
+     */
+    PixelConfig config() const { return fConfig; }
+
+    /**
+     *  Approximate number of bytes used by the texture
+     */
+    size_t sizeInBytes() const {
+        return fWidth * fHeight * BytesPerPixel(fConfig);
+    }
+
+    /**
+     * Updates a subrectangle of texels in the texture.
+     *
+     * @param x       left edge of rectangle to update
+     * @param y       top edge of rectangle to update
+     * @param width   width of rectangle to update
+     * @param height  height of rectangle to update
+     * @param srcData width*height texels of data in same format that was used
+     *                at texture creation.
+     */
+    virtual void uploadTextureData(uint32_t x,
+                                   uint32_t y,
+                                   uint32_t width,
+                                   uint32_t height,
+                                   const void* srcData) = 0;
+    /**
+     * Indicates that GPU context in which this texture was created is destroyed
+     * and that Ganesh should not attempt to free the texture with the
+     * underlying API.
+     */
+    virtual void abandon() = 0;
+
+    /**
+     * Retrieves the render target underlying this texture that can be passed to
+     * GrGpu::setRenderTarget().
+     *
+     * @return    handle to render target or undefined if the texture is not a
+     *            render target
+     */
+    virtual GrRenderTarget* asRenderTarget() = 0;
+
+    /**
+     * Removes the reference on the associated GrRenderTarget held by this
+     * texture. Afterwards asRenderTarget() will return NULL. The 
+     * GrRenderTarget survives the release if another ref is held on it.
+     */
+    virtual void releaseRenderTarget() = 0;
+
+    /**
+     *  Return the native ID or handle to the texture, depending on the
+     *  platform. e.g. on opengl, return the texture ID.
+     */
+    virtual intptr_t getTextureHandle() = 0;
+
+#if GR_DEBUG
+    void validate() const {
+        this->INHERITED::validate();
+    }
+#else
+    void validate() const {}
+#endif
+
+private:
+    int fWidth;
+    int fHeight;
+    // these two shift a fixed-point value into normalized coordinates
+    // for this texture if the texture is power of two sized.
+    int      fShiftFixedX;
+    int      fShiftFixedY;
+    PixelConfig fConfig;
+
+    typedef GrRefCnt INHERITED;
+};
+
+#endif
+
diff --git a/gpu/include/GrTextureCache.h b/gpu/include/GrTextureCache.h
new file mode 100644
index 0000000..68e1daa
--- /dev/null
+++ b/gpu/include/GrTextureCache.h
@@ -0,0 +1,310 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTextureCache_DEFINED
+#define GrTextureCache_DEFINED
+
+#include "GrTypes.h"
+#include "GrTHashCache.h"
+
+class GrTexture;
+
+// return true if a<b, or false if b<a
+//
+#define RET_IF_LT_OR_GT(a, b)   \
+    do {                        \
+        if ((a) < (b)) {        \
+            return true;        \
+        }                       \
+        if ((b) < (a)) {        \
+            return false;       \
+        }                       \
+    } while (0)
+
+/**
+ *  Helper class for GrTextureCache, the Key is used to identify src data for
+ *  a texture. It is identified by 2 32bit data fields which can hold any
+ *  data (uninterpreted by the cache) and a width/height.
+ */
+class GrTextureKey {
+public:
+    enum {
+        kHashBits   = 7,
+        kHashCount  = 1 << kHashBits,
+        kHashMask   = kHashCount - 1
+    };
+
+    GrTextureKey(uint32_t p0, uint32_t p1, uint16_t width, uint16_t height) {
+        fP0 = p0;
+        fP1 = p1;
+        fP2 = width | (height << 16);
+        GR_DEBUGCODE(fHashIndex = -1);
+    }
+
+    GrTextureKey(const GrTextureKey& src) {
+        fP0 = src.fP0;
+        fP1 = src.fP1;
+        fP2 = src.fP2;
+        finalize(src.fPrivateBits);
+    }
+
+    //!< returns hash value [0..kHashMask] for the key
+    int hashIndex() const { return fHashIndex; }
+
+    friend bool operator==(const GrTextureKey& a, const GrTextureKey& b) {
+        GR_DEBUGASSERT(-1 != a.fHashIndex && -1 != b.fHashIndex);
+        return a.fP0 == b.fP0 && a.fP1 == b.fP1 && a.fP2 == b.fP2 &&
+               a.fPrivateBits == b.fPrivateBits;
+    }
+
+    friend bool operator!=(const GrTextureKey& a, const GrTextureKey& b) {
+        GR_DEBUGASSERT(-1 != a.fHashIndex && -1 != b.fHashIndex);
+        return !(a == b);
+    }
+
+    friend bool operator<(const GrTextureKey& a, const GrTextureKey& b) {
+        RET_IF_LT_OR_GT(a.fP0, b.fP0);
+        RET_IF_LT_OR_GT(a.fP1, b.fP1);
+        RET_IF_LT_OR_GT(a.fP2, b.fP2);
+        return a.fPrivateBits < b.fPrivateBits;
+    }
+
+private:
+    void finalize(uint32_t privateBits) {
+        fPrivateBits = privateBits;
+        this->computeHashIndex();
+    }
+
+    uint16_t width() const { return fP2 & 0xffff; }
+    uint16_t height() const { return (fP2 >> 16); }
+
+    static uint32_t rol(uint32_t x) {
+        return (x >> 24) | (x << 8);
+    }
+    static uint32_t ror(uint32_t x) {
+        return (x >> 8) | (x << 24);
+    }
+    static uint32_t rohalf(uint32_t x) {
+        return (x >> 16) | (x << 16);
+    }
+
+    void computeHashIndex() {
+        uint32_t hash = fP0 ^ rol(fP1) ^ ror(fP2) ^ rohalf(fPrivateBits);
+        // this way to mix and reduce hash to its index may have to change
+        // depending on how many bits we allocate to the index
+        hash ^= hash >> 16;
+        hash ^= hash >> 8;
+        fHashIndex = hash & kHashMask;
+    }
+
+    uint32_t    fP0;
+    uint32_t    fP1;
+    uint32_t    fP2;
+    uint32_t    fPrivateBits;
+
+    // this is computed from the fP... fields
+    int         fHashIndex;
+
+    friend class GrContext;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class GrTextureEntry {
+public:
+    GrTexture* texture() const { return fTexture; }
+    const GrTextureKey& key() const { return fKey; }
+
+#if GR_DEBUG
+    GrTextureEntry* next() const { return fNext; }
+    GrTextureEntry* prev() const { return fPrev; }
+#endif
+
+#if GR_DEBUG
+    void validate() const;
+#else
+    void validate() const {}
+#endif
+
+private:
+    GrTextureEntry(const GrTextureKey& key, GrTexture* texture);
+    ~GrTextureEntry();
+
+    bool isLocked() const { return fLockCount != 0; }
+    void lock() { ++fLockCount; }
+    void unlock() {
+        GrAssert(fLockCount > 0);
+        --fLockCount;
+    }
+
+    GrTextureKey    fKey;
+    GrTexture*      fTexture;
+
+    // track if we're in use, used when we need to purge
+    // we only purge unlocked entries
+    int fLockCount;
+
+    // we're a dlinklist
+    GrTextureEntry* fPrev;
+    GrTextureEntry* fNext;
+
+    friend class GrTextureCache;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GrTHashCache.h"
+
+/**
+ *  Cache of GrTexture objects.
+ *
+ *  These have a corresponding GrTextureKey, built from 96bits identifying the
+ *  texture/bitmap.
+ *
+ *  The cache stores the entries in a double-linked list, which is its LRU.
+ *  When an entry is "locked" (i.e. given to the caller), it is moved to the
+ *  head of the list. If/when we must purge some of the entries, we walk the
+ *  list backwards from the tail, since those are the least recently used.
+ *
+ *  For fast searches, we maintain a sorted array (based on the GrTextureKey)
+ *  which we can bsearch. When a new entry is added, it is inserted into this
+ *  array.
+ *
+ *  For even faster searches, a hash is computed from the Key. If there is
+ *  a collision between two keys with the same hash, we fall back on the
+ *  bsearch, and update the hash to reflect the most recent Key requested.
+ */
+class GrTextureCache {
+public:
+    GrTextureCache(int maxCount, size_t maxBytes);
+    ~GrTextureCache();  // uses kFreeTexture_DeleteMode
+
+    /**
+     *  Return the current texture cache limits.
+     *
+     *  @param maxTextures If non-null, returns maximum number of textures that
+     *                     can be held in the cache.
+     *  @param maxTextureBytes If non-null, returns maximum number of bytes of
+     *                         texture memory that can be held in the cache.
+     */
+    void getLimits(int* maxTextures, size_t* maxTextureBytes) const;
+
+    /**
+     *  Specify the texture cache limits. If the current cache exceeds either
+     *  of these, it will be purged (LRU) to keep the cache within these limits.
+     *
+     *  @param maxTextures The maximum number of textures that can be held in
+     *                     the cache.
+     *  @param maxTextureBytes The maximum number of bytes of texture memory
+     *                         that can be held in the cache.
+     */
+    void setLimits(int maxTextures, size_t maxTextureBytes);
+
+    /**
+     *  Search for an entry with the same Key. If found, "lock" it and return it.
+     *  If not found, return null.
+     */
+    GrTextureEntry* findAndLock(const GrTextureKey&);
+
+    /**
+     *  Create a new entry, based on the specified key and texture, and return
+     *  its "locked" entry.
+     *
+     *  Ownership of the texture is transferred to the Entry, which will unref()
+     *  it when we are purged or deleted.
+     */
+    GrTextureEntry* createAndLock(const GrTextureKey&, GrTexture*);
+
+    /**
+     * Detach removes an entry from the cache. This prevents the entry from
+     * being found by a subsequent findAndLock() until it is reattached. The
+     * entry still counts against the cache's budget and should be reattached
+     * when exclusive access is no longer needed.
+     */
+    void detach(GrTextureEntry*);
+
+    /**
+     * Reattaches a texture to the cache and unlocks it. Allows it to be found
+     * by a subsequent findAndLock or be purged (provided its lock count is
+     * now 0.)
+     */
+    void reattachAndUnlock(GrTextureEntry*);
+
+    /**
+     *  When done with an entry, call unlock(entry) on it, which returns it to
+     *  a purgable state.
+     */
+    void unlock(GrTextureEntry*);
+
+    enum DeleteMode {
+        kFreeTexture_DeleteMode,
+        kAbandonTexture_DeleteMode
+    };
+    void deleteAll(DeleteMode);
+
+#if GR_DEBUG
+    void validate() const;
+#else
+    void validate() const {}
+#endif
+
+private:
+    void internalDetach(GrTextureEntry*, bool);
+    void attachToHead(GrTextureEntry*, bool);
+    void purgeAsNeeded();   // uses kFreeTexture_DeleteMode
+
+    class Key;
+    GrTHashTable<GrTextureEntry, Key, 8> fCache;
+
+    // manage the dlink list
+    GrTextureEntry* fHead;
+    GrTextureEntry* fTail;
+
+    // our budget, used in purgeAsNeeded()
+    int fMaxCount;
+    size_t fMaxBytes;
+
+    // our current stats, related to our budget
+    int fEntryCount;
+    size_t fEntryBytes;
+    int fClientDetachedCount;
+    size_t fClientDetachedBytes;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if GR_DEBUG
+    class GrAutoTextureCacheValidate {
+    public:
+        GrAutoTextureCacheValidate(GrTextureCache* cache) : fCache(cache) {
+            cache->validate();
+        }
+        ~GrAutoTextureCacheValidate() {
+            fCache->validate();
+        }
+    private:
+        GrTextureCache* fCache;
+    };
+#else
+    class GrAutoTextureCacheValidate {
+    public:
+        GrAutoTextureCacheValidate(GrTextureCache*) {}
+    };
+#endif
+
+#endif
+
diff --git a/gpu/include/GrTouchGesture.h b/gpu/include/GrTouchGesture.h
new file mode 100644
index 0000000..03f970b
--- /dev/null
+++ b/gpu/include/GrTouchGesture.h
@@ -0,0 +1,56 @@
+#ifndef GrTouchGesture_DEFINED
+#define GrTouchGesture_DEFINED
+
+#include "GrTypes.h"
+#include "SkTDArray.h"
+#include "SkMatrix.h"
+
+#include "FlingState.h"
+
+class GrTouchGesture {
+public:
+    GrTouchGesture();
+    ~GrTouchGesture();
+
+    void touchBegin(void* owner, float x, float y);
+    void touchMoved(void* owner, float x, float y);
+    void touchEnd(void* owner);
+    void reset();
+
+    const SkMatrix& localM();
+    const SkMatrix& globalM() const { return fGlobalM; }
+
+private:
+    enum State {
+        kEmpty_State,
+        kTranslate_State,
+        kZoom_State,
+    };
+
+    struct Rec {
+        void*   fOwner;
+        float   fStartX, fStartY;
+        float   fPrevX, fPrevY;
+        float   fLastX, fLastY;
+        SkMSec  fPrevT, fLastT;
+    };
+    SkTDArray<Rec> fTouches;
+
+    State    fState;
+    SkMatrix fLocalM, fGlobalM;
+    FlingState  fFlinger;
+    SkMSec  fLastUpT;
+    SkPoint fLastUpP;
+
+
+    void flushLocalM();
+    int findRec(void* owner) const;
+    void appendNewRec(void* owner, float x, float y);
+    float computePinch(const Rec&, const Rec&);
+    float limitTotalZoom(float scale) const;
+    bool handleDblTap(float, float);
+};
+
+#endif
+
+
diff --git a/gpu/include/GrTypes.h b/gpu/include/GrTypes.h
new file mode 100644
index 0000000..f407e2f
--- /dev/null
+++ b/gpu/include/GrTypes.h
@@ -0,0 +1,314 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTypes_DEFINED
+#define GrTypes_DEFINED
+
+#include "GrConfig.h"
+
+#include <memory.h>
+#include <string.h>
+
+/**
+ *  Macro to round n up to the next multiple of 4, or return it unchanged if
+ *  n is already a multiple of 4
+ */
+#define GrALIGN4(n)     (((n) + 3) >> 2 << 2)
+#define GrIsALIGN4(n)   (((n) & 3) == 0)
+
+template <typename T> const T& GrMin(const T& a, const T& b) {
+	return (a < b) ? a : b;
+}
+
+template <typename T> const T& GrMax(const T& a, const T& b) {
+	return (b < a) ? a : b;
+}
+
+// compile time versions of min/max
+#define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b))
+#define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a))
+
+/**
+ *  divide, rounding up
+ */
+static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
+    return (x + (y-1)) / y;
+}
+static inline size_t GrSizeDivRoundUp(size_t x, uint32_t y) {
+    return (x + (y-1)) / y;
+}
+
+/**
+ *  align up
+ */
+static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) {
+    return GrUIDivRoundUp(x, alignment) * alignment;
+}
+static inline uint32_t GrSizeAlignUp(size_t x, uint32_t alignment) {
+    return GrSizeDivRoundUp(x, alignment) * alignment;
+}
+
+/**
+ * amount of pad needed to align up
+ */
+static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) {
+    return (alignment - x % alignment) % alignment;
+}
+static inline size_t GrSizeAlignUpPad(size_t x, uint32_t alignment) {
+    return (alignment - x % alignment) % alignment;
+}
+
+/**
+ *  align down
+ */
+static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) {
+    return (x / alignment) * alignment;
+}
+static inline uint32_t GrSizeAlignDown(size_t x, uint32_t alignment) {
+    return (x / alignment) * alignment;
+}
+
+/**
+ *  Count elements in an array
+ */
+#define GR_ARRAY_COUNT(array)  (sizeof(array) / sizeof(array[0]))
+
+//!< allocate a block of memory, will never return NULL
+extern void* GrMalloc(size_t bytes);
+
+//!< free block allocated by GrMalloc. ptr may be NULL
+extern void GrFree(void* ptr);
+
+static inline void Gr_bzero(void* dst, size_t size) {
+    memset(dst, 0, size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Return the number of leading zeros in n
+ */
+extern int Gr_clz(uint32_t n);
+
+/**
+ *  Return true if n is a power of 2
+ */
+static inline bool GrIsPow2(unsigned n) {
+    return n && 0 == (n & (n - 1));
+}
+
+/**
+ *  Return the next power of 2 >= n.
+ */
+static inline uint32_t GrNextPow2(uint32_t n) {
+    return n ? (1 << (32 - Gr_clz(n - 1))) : 1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  16.16 fixed point type
+ */
+typedef int32_t GrFixed;
+
+#if GR_DEBUG
+
+static inline int16_t GrToS16(intptr_t x) {
+    GrAssert((int16_t)x == x);
+    return (int16_t)x;
+}
+
+#else
+
+#define GrToS16(x)  x
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Use to cast a ptr to a different type, and maintain strict-aliasing
+ */
+template <typename Dst, typename Src> Dst GrTCast(Src src) {
+    union {
+        Src src;
+        Dst dst;
+    } data;
+    data.src = src;
+    return data.dst;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Type used to describe format of vertices in arrays
+ * Values are defined in GrDrawTarget
+ */
+typedef uint16_t GrVertexLayout;
+
+/**
+* Geometric primitives used for drawing.
+*/
+enum GrPrimitiveType {
+    kTriangles_PrimitiveType,
+    kTriangleStrip_PrimitiveType,
+    kTriangleFan_PrimitiveType,
+    kPoints_PrimitiveType,
+    kLines_PrimitiveType,
+    kLineStrip_PrimitiveType
+};
+
+/**
+ * Coeffecients for alpha-blending.
+ */
+enum GrBlendCoeff {
+    kZero_BlendCoeff,    //<! 0
+    kOne_BlendCoeff,     //<! 1
+    kSC_BlendCoeff,      //<! src color
+    kISC_BlendCoeff,     //<! one minus src color
+    kDC_BlendCoeff,      //<! dst color
+    kIDC_BlendCoeff,     //<! one minus dst color
+    kSA_BlendCoeff,      //<! src alpha
+    kISA_BlendCoeff,     //<! one minus src alpha
+    kDA_BlendCoeff,      //<! dst alpha
+    kIDA_BlendCoeff,     //<! one minus dst alpha
+};
+
+/**
+ * Set Operations used to construct clips.
+ */
+enum GrSetOp {
+    kReplace_SetOp,
+    kIntersect_SetOp,
+    kUnion_SetOp,
+    kXor_SetOp,
+    kDifference_SetOp,
+    kReverseDifference_SetOp,
+};
+
+/**
+ * Clips are composed from these objects.
+ */
+enum GrClipType {
+    kRect_ClipType,
+    kPath_ClipType
+};
+
+/**
+ * Commands used to describe a path. Each command
+ * is accompanied by some number of points.
+ */
+enum GrPathCmd {
+    kMove_PathCmd,      //!< Starts a new subpath at
+                        //   at the returned point
+                        // 1 point
+    kLine_PathCmd,      //!< Adds a line segment
+                        // 2 points
+    kQuadratic_PathCmd, //!< Adds a quadratic segment
+                        // 3 points
+    kCubic_PathCmd,     //!< Adds a cubic segment
+                        // 4 points
+    kClose_PathCmd,     //!< Closes the current subpath
+                        //   by connecting a line to the
+                        //   starting point.
+                        // 0 points
+    kEnd_PathCmd        //!< Indicates the end of the last subpath
+                        //   when iterating
+                        // 0 points.
+};
+
+/**
+ * Gets the number of points associated with a path command.
+ */
+static int inline NumPathCmdPoints(GrPathCmd cmd) {
+    static const int gNumPoints[] = {
+        1, 2, 3, 4, 0, 0
+    };
+    return gNumPoints[cmd];
+}
+
+/**
+ * Path filling rules
+ */
+enum GrPathFill {
+    kWinding_PathFill,
+    kEvenOdd_PathFill,
+    kInverseWinding_PathFill,
+    kInverseEvenOdd_PathFill,
+    kHairLine_PathFill,
+
+    kPathFillCount
+};
+
+static inline GrPathFill NonInvertedFill(GrPathFill fill) {
+    static const GrPathFill gNonInvertedFills[] = {
+        kWinding_PathFill, // kWinding_PathFill
+        kEvenOdd_PathFill, // kEvenOdd_PathFill
+        kWinding_PathFill, // kInverseWinding_PathFill
+        kEvenOdd_PathFill, // kInverseEvenOdd_PathFill
+        kHairLine_PathFill,// kHairLine_PathFill
+    };
+    GR_STATIC_ASSERT(0 == kWinding_PathFill);
+    GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
+    GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
+    GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
+    GR_STATIC_ASSERT(4 == kHairLine_PathFill);
+    GR_STATIC_ASSERT(5 == kPathFillCount);
+    return gNonInvertedFills[fill];
+}
+
+static inline bool IsFillInverted(GrPathFill fill) {
+    static const bool gIsFillInverted[] = {
+        false, // kWinding_PathFill
+        false, // kEvenOdd_PathFill
+        true,  // kInverseWinding_PathFill
+        true,  // kInverseEvenOdd_PathFill
+        false, // kHairLine_PathFill
+    };
+    GR_STATIC_ASSERT(0 == kWinding_PathFill);
+    GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
+    GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
+    GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
+    GR_STATIC_ASSERT(4 == kHairLine_PathFill);
+    GR_STATIC_ASSERT(5 == kPathFillCount);
+    return gIsFillInverted[fill];
+}
+
+/**
+ * Hints provided about a path's convexity (or lack thereof).
+ */
+enum GrConvexHint {
+    kNone_ConvexHint,                         //<! No hint about convexity
+                                              //   of the path
+    kConvex_ConvexHint,                       //<! Path is one convex piece
+    kNonOverlappingConvexPieces_ConvexHint,   //<! Multiple convex pieces,
+                                              //   pieces are known to be
+                                              //   disjoint
+    kSameWindingConvexPieces_ConvexHint,      //<! Multiple convex pieces,
+                                              //   may or may not intersect,
+                                              //   either all wind cw or all
+                                              //   wind ccw.
+    kConcave_ConvexHint                       //<! Path is known to be
+                                              //   concave
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+// this is included only to make it easy to use this debugging facility
+#include "GrInstanceCounter.h"
+
+#endif
diff --git a/gpu/include/GrUserConfig.h b/gpu/include/GrUserConfig.h
new file mode 100644
index 0000000..201d836
--- /dev/null
+++ b/gpu/include/GrUserConfig.h
@@ -0,0 +1,90 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrUserConfig_DEFINED
+#define GrUserConfig_DEFINED
+
+#if defined(GR_USER_CONFIG_FILE)
+    #error "default user config pulled in but GR_USER_CONFIG_FILE is defined."
+#endif
+
+#if 0
+    #undef GR_RELEASE
+    #undef GR_DEBUG
+    #define GR_RELEASE  0
+    #define GR_DEBUG    1
+#endif
+
+/*
+ *  The default 32bit pixel config for texture upload is GL_RGBA on all
+ *  platforms except on Windows where it is GL_BGRA. If your bitmaps map to a
+ *  different GL enum, specify that with this define. For portability use
+ *  GR_BGRA rather than GL_BGRA for platforms where this format is an
+ *  extension.
+ */
+//#define GR_GL_32BPP_COLOR_FORMAT  GL_RGBA
+
+/*
+ *  To diagnose texture cache performance, define this to 1 if you want to see
+ *  a log statement everytime we upload an image to create a texture.
+ */
+//#define GR_DUMP_TEXTURE_UPLOAD    1
+
+/*
+ * To log all GL calls define this. Can be turned on and off at runtime by
+ * gPrintGL global variable.
+ */
+//#define GR_GL_LOG_CALLS 1
+
+/*
+ * When drawing rects this causes Ganesh to use a vertex buffer containing
+ * a unit square that is positioned by a matrix. Enable on systems where
+ * emitting per-rect-draw verts is more expensive than constant/matrix
+ * updates. Defaults to 0.
+ */
+//#define GR_STATIC_RECT_VB 1
+
+/*
+ * This causes more aggressive shader optimization. May hurt performance if
+ * switching shaders is expensive.
+ */
+//#define GR_AGGRESSIVE_SHADER_OPTS 1
+
+/*
+ * This gives a threshold in bytes of when to lock a GrGeometryBuffer vs using
+ * updateData or updateSubData. (Note the depending on the underlying 3D API
+ * the update functions may always be implemented using a lock)
+ */
+//#define GR_GEOM_BUFFER_LOCK_THRESHOLD (1<<15)
+
+///////////////////////////////////////////////////////////////////////////////
+/*
+ *  temporary flags (may go away soon)
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Decide Ganesh types
+
+#define GR_SCALAR_IS_FIXED          0
+#define GR_SCALAR_IS_FLOAT          1
+
+#define GR_TEXT_SCALAR_IS_USHORT    0
+#define GR_TEXT_SCALAR_IS_FIXED     0
+#define GR_TEXT_SCALAR_IS_FLOAT     1
+
+#endif
+
+
diff --git a/gpu/include/GrVertexBuffer.h b/gpu/include/GrVertexBuffer.h
new file mode 100644
index 0000000..3792c15
--- /dev/null
+++ b/gpu/include/GrVertexBuffer.h
@@ -0,0 +1,31 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrVertexBuffer_DEFINED
+#define GrVertexBuffer_DEFINED
+
+#include "GrGeometryBuffer.h"
+
+class GrVertexBuffer : public GrGeometryBuffer {
+protected:
+    GrVertexBuffer(size_t sizeInBytes, bool dynamic) : 
+        INHERITED(sizeInBytes, dynamic) {}
+private:
+    typedef GrGeometryBuffer INHERITED;
+};
+
+#endif
diff --git a/gpu/include/SkUIView.h b/gpu/include/SkUIView.h
new file mode 100644
index 0000000..5e12e00
--- /dev/null
+++ b/gpu/include/SkUIView.h
@@ -0,0 +1,64 @@
+#import <UIKit/UIKit.h>
+
+#include "SkMatrix.h"
+#include "FlingState.h"
+
+#import <OpenGLES/EAGL.h>
+#import <OpenGLES/ES1/gl.h>
+#import <OpenGLES/ES1/glext.h>
+
+class SkOSWindow;
+class SkEvent;
+
+@interface SkUIView : UIView <UIAccelerometerDelegate> {
+    BOOL fRedrawRequestPending;
+    SkOSWindow* fWind;
+    SkMatrix    fMatrix, fLocalMatrix;
+    bool        fNeedGestureEnded;
+
+    SkMatrix    fRotateMatrix;
+
+    float       fFirstPinchX, fFirstPinchY;
+    bool        fNeedFirstPinch;
+
+    float       fZoomAroundX, fZoomAroundY;
+    bool        fZoomAround;
+
+    FlingState  fFlingState;
+
+    GrAnimateFloat  fWarpState;
+    bool            fUseWarp;
+
+    struct {
+        EAGLContext*    fContext;
+        GLuint          fRenderbuffer;
+        GLuint          fStencilbuffer;
+        GLuint          fFramebuffer;
+        GLint           fWidth;
+        GLint           fHeight;
+    } fGL;
+    
+    UILabel* fTitleLabel;
+
+    enum Backend {
+        kGL_Backend,
+        kRaster_Backend,
+    };
+
+    // these are visible to DetailViewController
+    Backend fBackend;
+    bool    fComplexClip;
+}
+
+@property (nonatomic, assign) SkOSWindow *fWind;
+@property (nonatomic, retain) UILabel* fTitleLabel;
+@property (nonatomic, assign) Backend fBackend;
+@property (nonatomic, assign) bool fComplexClip;
+@property (nonatomic, assign, setter=setWarpState) bool fUseWarp;
+
+- (void)setSkTitle:(const char*)title;
+- (void)postInvalWithRect:(const SkIRect*)rectOrNil;
+- (BOOL)onHandleEvent:(const SkEvent&)event;
+
+@end
+
diff --git a/gpu/src/FlingState.cpp b/gpu/src/FlingState.cpp
new file mode 100644
index 0000000..cb634cc
--- /dev/null
+++ b/gpu/src/FlingState.cpp
@@ -0,0 +1,134 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "FlingState.h"
+#include "SkMatrix.h"
+#include "SkTime.h"
+
+#define DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER   true
+
+static const float MAX_FLING_SPEED = 1500;
+
+static float pin_max_fling(float speed) {
+    if (speed > MAX_FLING_SPEED) {
+        speed = MAX_FLING_SPEED;
+    }
+    return speed;
+}
+
+static double getseconds() {
+    return SkTime::GetMSecs() * 0.001;
+}
+
+// returns +1 or -1, depending on the sign of x
+// returns +1 if x is zero
+static SkScalar SkScalarSign(SkScalar x) {
+    SkScalar sign = SK_Scalar1;
+    if (x < 0) {
+        sign = -sign;
+    }
+    return sign;
+}
+
+static void unit_axis_align(SkVector* unit) {
+    const SkScalar TOLERANCE = SkDoubleToScalar(0.15);
+    if (SkScalarAbs(unit->fX) < TOLERANCE) {
+        unit->fX = 0;
+        unit->fY = SkScalarSign(unit->fY);
+    } else if (SkScalarAbs(unit->fY) < TOLERANCE) {
+        unit->fX = SkScalarSign(unit->fX);
+        unit->fY = 0;
+    }
+}
+
+void FlingState::reset(float sx, float sy) {
+    fActive = true;
+    fDirection.set(sx, sy);
+    fSpeed0 = SkPoint::Normalize(&fDirection);
+    fSpeed0 = pin_max_fling(fSpeed0);
+    fTime0 = getseconds();
+
+    unit_axis_align(&fDirection);
+//    printf("---- speed %g dir %g %g\n", fSpeed0, fDirection.fX, fDirection.fY);
+}
+
+bool FlingState::evaluateMatrix(SkMatrix* matrix) {
+    if (!fActive) {
+        return false;
+    }
+
+    const float t =  getseconds() - fTime0;
+    const float MIN_SPEED = 2;
+    const float K0 = 5.0;
+    const float K1 = 0.02;
+    const float speed = fSpeed0 * (sk_float_exp(- K0 * t) - K1);
+    if (speed <= MIN_SPEED) {
+        fActive = false;
+        return false;
+    }
+    float dist = (fSpeed0 - speed) / K0;
+
+//    printf("---- time %g speed %g dist %g\n", t, speed, dist);
+    float tx = fDirection.fX * dist;
+    float ty = fDirection.fY * dist;
+    if (DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER) {
+        tx = sk_float_round2int(tx);
+        ty = sk_float_round2int(ty);
+    }
+    matrix->setTranslate(tx, ty);
+//    printf("---- evaluate (%g %g)\n", tx, ty);
+
+    return true;
+}
+
+////////////////////////////////////////
+
+GrAnimateFloat::GrAnimateFloat() : fTime0(0) {}
+
+void GrAnimateFloat::start(float v0, float v1, float duration) {
+    fValue0 = v0;
+    fValue1 = v1;
+    fDuration = duration;
+    if (duration > 0) {
+        fTime0 = SkTime::GetMSecs();
+        if (!fTime0) {
+            fTime0 = 1;  // time0 is our sentinel
+        }
+    } else {
+        fTime0 = 0;
+    }
+}
+
+float GrAnimateFloat::evaluate() {
+    if (!fTime0) {
+        return fValue1;
+    }
+    
+    double elapsed = (SkTime::GetMSecs() - fTime0) * 0.001;
+    if (elapsed >= fDuration) {
+        fTime0 = 0;
+        return fValue1;
+    }
+    
+    double t = elapsed / fDuration;
+    if (true) {
+        t = (3 - 2 * t) * t * t;
+    }
+    return fValue0 + t * (fValue1 - fValue0);
+}
+
+
diff --git a/gpu/src/GrAllocPool.cpp b/gpu/src/GrAllocPool.cpp
new file mode 100644
index 0000000..f133f97
--- /dev/null
+++ b/gpu/src/GrAllocPool.cpp
@@ -0,0 +1,127 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrAllocPool.h"
+
+#define GrAllocPool_MIN_BLOCK_SIZE      ((size_t)128)
+
+struct GrAllocPool::Block {
+    Block*  fNext;
+    char*   fPtr;
+    size_t  fBytesFree;
+    size_t  fBytesTotal;
+
+    static Block* Create(size_t size, Block* next) {
+        GrAssert(size >= GrAllocPool_MIN_BLOCK_SIZE);
+
+        Block* block = (Block*)GrMalloc(sizeof(Block) + size);
+        block->fNext = next;
+        block->fPtr = (char*)block + sizeof(Block);
+        block->fBytesFree = size;
+        block->fBytesTotal = size;
+        return block;
+    }
+
+    bool canAlloc(size_t bytes) const {
+        return bytes <= fBytesFree;
+    }
+
+    void* alloc(size_t bytes) {
+        GrAssert(bytes <= fBytesFree);
+        fBytesFree -= bytes;
+        void* ptr = fPtr;
+        fPtr += bytes;
+        return ptr;
+    }
+    
+    size_t release(size_t bytes) {
+        GrAssert(bytes > 0);
+        size_t free = GrMin(bytes, fBytesTotal - fBytesFree);
+        fBytesFree += free;
+        fPtr -= free;
+        return bytes - free;
+    }
+    
+    bool empty() const { return fBytesTotal == fBytesFree; }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrAllocPool::GrAllocPool(size_t blockSize) {
+    fBlock = NULL;
+    fMinBlockSize = GrMax(blockSize, GrAllocPool_MIN_BLOCK_SIZE);
+    GR_DEBUGCODE(fBlocksAllocated = 0;)
+}
+
+GrAllocPool::~GrAllocPool() {
+    this->reset();
+}
+
+void GrAllocPool::reset() {
+    this->validate();
+
+    Block* block = fBlock;
+    while (block) {
+        Block* next = block->fNext;
+        GrFree(block);
+        block = next;
+    }
+    fBlock = NULL;
+    GR_DEBUGCODE(fBlocksAllocated = 0;)
+}
+
+void* GrAllocPool::alloc(size_t size) {
+    this->validate();
+    
+    if (!fBlock || !fBlock->canAlloc(size)) {
+        size_t blockSize = GrMax(fMinBlockSize, size);
+        fBlock = Block::Create(blockSize, fBlock);
+        GR_DEBUGCODE(fBlocksAllocated += 1;)
+    }
+    return fBlock->alloc(size);
+}
+
+void GrAllocPool::release(size_t bytes) {
+    this->validate();
+    
+    while (bytes && NULL != fBlock) {
+        bytes = fBlock->release(bytes);
+        if (fBlock->empty()) {
+            Block* next = fBlock->fNext;
+            GrFree(fBlock);
+            fBlock = next;
+            GR_DEBUGCODE(fBlocksAllocated -= 1;)
+        }
+    }
+}
+
+
+#if GR_DEBUG
+
+void GrAllocPool::validate() const {
+    Block* block = fBlock;
+    int count = 0;
+    while (block) {
+        count += 1;
+        block = block->fNext;
+    }
+    GrAssert(fBlocksAllocated == count);
+}
+
+#endif
+
+
diff --git a/gpu/src/GrAtlas.cpp b/gpu/src/GrAtlas.cpp
new file mode 100644
index 0000000..b55a029
--- /dev/null
+++ b/gpu/src/GrAtlas.cpp
@@ -0,0 +1,187 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrAtlas.h"
+#include "GrGpu.h"
+#include "GrMemory.h"
+#include "GrRectanizer.h"
+#include "GrPlotMgr.h"
+
+#if 0
+#define GR_PLOT_WIDTH   8
+#define GR_PLOT_HEIGHT  4
+#define GR_ATLAS_WIDTH  256
+#define GR_ATLAS_HEIGHT 256
+
+#define GR_ATLAS_TEXTURE_WIDTH  (GR_PLOT_WIDTH * GR_ATLAS_WIDTH)
+#define GR_ATLAS_TEXTURE_HEIGHT (GR_PLOT_HEIGHT * GR_ATLAS_HEIGHT)
+
+#else
+
+#define GR_ATLAS_TEXTURE_WIDTH  1024
+#define GR_ATLAS_TEXTURE_HEIGHT 2048
+
+#define GR_ATLAS_WIDTH  341
+#define GR_ATLAS_HEIGHT 341
+
+#define GR_PLOT_WIDTH   (GR_ATLAS_TEXTURE_WIDTH / GR_ATLAS_WIDTH)
+#define GR_PLOT_HEIGHT  (GR_ATLAS_TEXTURE_HEIGHT / GR_ATLAS_HEIGHT)
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define BORDER      1
+
+#if GR_DEBUG
+    static int gCounter;
+#endif
+
+GrAtlas::GrAtlas(GrAtlasMgr* mgr, int plotX, int plotY) {
+    fAtlasMgr = mgr;    // just a pointer, not an owner
+    fNext = NULL;
+    fTexture = mgr->getTexture(); // we're not an owner, just a pointer
+    fPlot.set(plotX, plotY);
+
+    fRects = GrRectanizer::Factory(GR_ATLAS_WIDTH - BORDER,
+                                   GR_ATLAS_HEIGHT - BORDER);
+
+#if GR_DEBUG
+    GrPrintf(" GrAtlas %p [%d %d] %d\n", this, plotX, plotY, gCounter);
+    gCounter += 1;
+#endif
+}
+
+GrAtlas::~GrAtlas() {
+    fAtlasMgr->freePlot(fPlot.fX, fPlot.fY);
+
+    delete fRects;
+
+#if GR_DEBUG
+    --gCounter;
+    GrPrintf("~GrAtlas %p [%d %d] %d\n", this, fPlot.fX, fPlot.fY, gCounter);
+#endif
+}
+
+static void adjustForPlot(GrIPoint16* loc, const GrIPoint16& plot) {
+    loc->fX += plot.fX * GR_ATLAS_WIDTH;
+    loc->fY += plot.fY * GR_ATLAS_HEIGHT;
+}
+
+bool GrAtlas::addSubImage(int width, int height, const void* image,
+                          GrIPoint16* loc) {
+    if (!fRects->addRect(width + BORDER, height + BORDER, loc)) {
+        return false;
+    }
+
+    GrAutoSMalloc<1024> storage;
+    int srcW = width + 2*BORDER;
+    int srcH = height + 2*BORDER;
+    if (BORDER) {
+        uint8_t* ptr = (uint8_t*)storage.realloc(srcW * srcH);
+        Gr_bzero(ptr, srcW);                // zero top row
+        ptr += srcW;
+        for (int y = 0; y < height; y++) {
+            *ptr++ = 0;                     // zero left edge
+            memcpy(ptr, image, width); ptr += width;
+            *ptr++ = 0;                     // zero right edge
+            image = (const void*)((const char*)image + width);
+        }
+        Gr_bzero(ptr, srcW);                // zero bottom row
+        image = storage.get();
+    }
+    adjustForPlot(loc, fPlot);
+    fTexture->uploadTextureData(loc->fX, loc->fY, srcW, srcH, image);
+
+    // now tell the caller to skip the top/left BORDER
+    loc->fX += BORDER;
+    loc->fY += BORDER;
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrAtlasMgr::GrAtlasMgr(GrGpu* gpu) {
+    fGpu = gpu;
+    gpu->ref();
+    fTexture = NULL;
+    fPlotMgr = new GrPlotMgr(GR_PLOT_WIDTH, GR_PLOT_HEIGHT);
+}
+
+GrAtlasMgr::~GrAtlasMgr() {
+    GrSafeUnref(fTexture);
+    delete fPlotMgr;
+    fGpu->unref();
+}
+
+GrAtlas* GrAtlasMgr::addToAtlas(GrAtlas* atlas,
+                                int width, int height, const void* image,
+                                GrIPoint16* loc) {
+    if (atlas && atlas->addSubImage(width, height, image, loc)) {
+        return atlas;
+    }
+
+    // If the above fails, then either we have no starting atlas, or the current
+    // one is full. Either way we need to allocate a new atlas
+
+    GrIPoint16 plot;
+    if (!fPlotMgr->newPlot(&plot)) {
+        return NULL;
+    }
+
+    if (NULL == fTexture) {
+        GrGpu::TextureDesc desc = {
+            GrGpu::kDynamicUpdate_TextureFlag, 
+            GrGpu::kNone_AALevel,
+            GR_ATLAS_TEXTURE_WIDTH, 
+            GR_ATLAS_TEXTURE_HEIGHT,
+            GrTexture::kAlpha_8_PixelConfig
+        };
+        fTexture = fGpu->createTexture(desc, NULL, 0);
+        if (NULL == fTexture) {
+            return NULL;
+        }
+    }
+
+    GrAtlas* newAtlas = new GrAtlas(this, plot.fX, plot.fY);
+    if (!newAtlas->addSubImage(width, height, image, loc)) {
+        delete newAtlas;
+        return NULL;
+    }
+
+    newAtlas->fNext = atlas;
+    return newAtlas;
+}
+
+void GrAtlasMgr::freePlot(int x, int y) {
+    GrAssert(fPlotMgr->isBusy(x, y));
+    fPlotMgr->freePlot(x, y);
+}
+
+void GrAtlasMgr::abandonAll() {
+#if 0
+    GrAtlas** curr = fList.begin();
+    GrAtlas** stop = fList.end();
+    for (; curr < stop; curr++) {
+        (*curr)->texture()->abandon();
+        delete *curr;
+    }
+    fList.reset();
+#endif
+}
+
+
diff --git a/gpu/src/GrBufferAllocPool.cpp b/gpu/src/GrBufferAllocPool.cpp
new file mode 100644
index 0000000..35f0c5e
--- /dev/null
+++ b/gpu/src/GrBufferAllocPool.cpp
@@ -0,0 +1,430 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#include "GrBufferAllocPool.h"
+#include "GrTypes.h"
+#include "GrVertexBuffer.h"
+#include "GrIndexBuffer.h"
+#include "GrGpu.h"
+
+#if GR_DEBUG
+    #define VALIDATE validate
+#else
+    #define VALIDATE()
+#endif
+
+#define GrBufferAllocPool_MIN_BLOCK_SIZE ((size_t)1 << 12)
+
+GrBufferAllocPool::GrBufferAllocPool(GrGpu* gpu,
+                                     BufferType bufferType,
+                                     bool frequentResetHint,
+                                     size_t blockSize,
+                                     int preallocBufferCnt) :
+        fBlocks(GrMax(8, 2*preallocBufferCnt)) {
+    GrAssert(NULL != gpu);
+    fGpu = gpu;
+    fBufferType = bufferType;
+    fFrequentResetHint = frequentResetHint;
+    fGpu->ref();
+    fBufferPtr = NULL;
+    fMinBlockSize = GrMax(GrBufferAllocPool_MIN_BLOCK_SIZE, blockSize);
+
+    fPreallocBuffersInUse = 0;
+    fFirstPreallocBuffer = 0;
+    for (int i = 0; i < preallocBufferCnt; ++i) {
+        GrGeometryBuffer* buffer = this->createBuffer(fMinBlockSize);
+        if (NULL != buffer) {
+            *fPreallocBuffers.append() = buffer;
+            buffer->ref();
+        }
+    }
+}
+
+GrBufferAllocPool::~GrBufferAllocPool() {
+    VALIDATE();
+    if (fBlocks.count()) {
+        GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
+        if (buffer->isLocked()) {
+            buffer->unlock();
+        }
+    }
+    fPreallocBuffers.unrefAll();
+    while (!fBlocks.empty()) {
+        destroyBlock();
+    }
+    fGpu->unref();
+}
+
+void GrBufferAllocPool::reset() {
+    VALIDATE();
+    if (fBlocks.count()) {
+        GrGeometryBuffer* buffer = fBlocks.back().fBuffer;
+        if (buffer->isLocked()) {
+            buffer->unlock();
+        }
+    }
+    while (!fBlocks.empty()) {
+        destroyBlock();
+    }
+    if (fPreallocBuffers.count()) {
+        // must set this after above loop.
+        fFirstPreallocBuffer = (fFirstPreallocBuffer + fPreallocBuffersInUse) %
+                               fPreallocBuffers.count();
+    }
+    fCpuData.realloc(fGpu->supportsBufferLocking() ? 0 : fMinBlockSize);
+    GrAssert(0 == fPreallocBuffersInUse);
+    VALIDATE();
+}
+
+void GrBufferAllocPool::unlock() {
+    VALIDATE();
+
+    if (NULL != fBufferPtr) {
+        BufferBlock& block = fBlocks.back();
+        if (block.fBuffer->isLocked()) {
+            block.fBuffer->unlock();
+        } else {
+            size_t flushSize = block.fBuffer->size() - block.fBytesFree;
+            flushCpuData(fBlocks.back().fBuffer, flushSize);
+        }
+        fBufferPtr = NULL;
+    }
+    VALIDATE();
+}
+
+#if GR_DEBUG
+void GrBufferAllocPool::validate() const {
+    if (NULL != fBufferPtr) {
+        GrAssert(!fBlocks.empty());
+        if (fBlocks.back().fBuffer->isLocked()) {
+            GrGeometryBuffer* buf = fBlocks.back().fBuffer;
+            GrAssert(buf->lockPtr() == fBufferPtr);
+        } else {
+            GrAssert(fCpuData.get() == fBufferPtr);
+            GrAssert(fCpuData.size() == fBlocks.back().fBuffer->size());
+        }
+    } else {
+        GrAssert(fBlocks.empty() || !fBlocks.back().fBuffer->isLocked());
+    }
+    for (int i = 0; i < fBlocks.count() - 1; ++i) {
+        GrAssert(!fBlocks[i].fBuffer->isLocked());
+    }
+}
+#endif
+
+void* GrBufferAllocPool::makeSpace(size_t size,
+                                   size_t alignment,
+                                   const GrGeometryBuffer** buffer,
+                                   size_t* offset) {
+    VALIDATE();
+
+    GrAssert(NULL != buffer);
+    GrAssert(NULL != offset);
+
+    if (NULL != fBufferPtr) {
+        BufferBlock& back = fBlocks.back();
+        size_t usedBytes = back.fBuffer->size() - back.fBytesFree;
+        size_t pad = GrSizeAlignUpPad(usedBytes,
+                                      alignment);
+        if ((size + pad) <= back.fBytesFree) {
+            usedBytes += pad;
+            *offset = usedBytes;
+            *buffer = back.fBuffer;
+            back.fBytesFree -= size + pad;
+            return (void*)(reinterpret_cast<intptr_t>(fBufferPtr) + usedBytes);
+        }
+    }
+
+    if (!createBlock(size)) {
+        return NULL;
+    }
+    VALIDATE();
+    GrAssert(NULL != fBufferPtr);
+
+    *offset = 0;
+    BufferBlock& back = fBlocks.back();
+    *buffer = back.fBuffer;
+    back.fBytesFree -= size;
+    return fBufferPtr;
+}
+
+int GrBufferAllocPool::currentBufferItems(size_t itemSize) const {
+    VALIDATE();
+    if (NULL != fBufferPtr) {
+        const BufferBlock& back = fBlocks.back();
+        size_t usedBytes = back.fBuffer->size() - back.fBytesFree;
+        size_t pad = GrSizeAlignUpPad(usedBytes, itemSize);
+        return (back.fBytesFree - pad) / itemSize;
+    } else if (fPreallocBuffersInUse < fPreallocBuffers.count()) {
+        return fMinBlockSize / itemSize;
+    }
+    return 0;
+}
+
+int GrBufferAllocPool::preallocatedBuffersRemaining() const {
+    return fPreallocBuffers.count() - fPreallocBuffersInUse;
+}
+
+int GrBufferAllocPool::preallocatedBufferCount() const {
+    return fPreallocBuffers.count();
+}
+
+void GrBufferAllocPool::putBack(size_t bytes) {
+    VALIDATE();
+    if (NULL != fBufferPtr) {
+        BufferBlock& back = fBlocks.back();
+        size_t bytesUsed = back.fBuffer->size() - back.fBytesFree;
+        if (bytes >= bytesUsed) {
+            destroyBlock();
+            bytes -= bytesUsed;
+        } else {
+            back.fBytesFree += bytes;
+            return;
+        }
+    }
+    VALIDATE();
+    GrAssert(NULL == fBufferPtr);
+    // we don't partially roll-back buffers because our VB semantics say locking
+    // a VB discards its previous content.
+    // We could honor it by being sure we use updateSubData and not lock
+    // we will roll-back fully released buffers, though.
+    while (!fBlocks.empty() &&
+           bytes >= fBlocks.back().fBuffer->size()) {
+        bytes -= fBlocks.back().fBuffer->size();
+        destroyBlock();
+    }
+    VALIDATE();
+}
+
+bool GrBufferAllocPool::createBlock(size_t requestSize) {
+
+    size_t size = GrMax(requestSize, fMinBlockSize);
+    GrAssert(size >= GrBufferAllocPool_MIN_BLOCK_SIZE);
+
+    VALIDATE();
+
+    BufferBlock& block = fBlocks.push_back();
+
+    if (size == fMinBlockSize &&
+        fPreallocBuffersInUse < fPreallocBuffers.count()) {
+
+        uint32_t nextBuffer = (fPreallocBuffersInUse + fFirstPreallocBuffer) %
+                               fPreallocBuffers.count();
+        block.fBuffer = fPreallocBuffers[nextBuffer];
+        block.fBuffer->ref();
+        ++fPreallocBuffersInUse;
+    } else {
+        block.fBuffer = this->createBuffer(size);
+        if (NULL == block.fBuffer) {
+            fBlocks.pop_back();
+            return false;
+        }
+    }
+
+    block.fBytesFree = size;
+    if (NULL != fBufferPtr) {
+        GrAssert(fBlocks.count() > 1);
+        BufferBlock& prev = fBlocks.fromBack(1);
+        if (prev.fBuffer->isLocked()) {
+            prev.fBuffer->unlock();
+        } else {
+            flushCpuData(prev.fBuffer,
+                         prev.fBuffer->size() - prev.fBytesFree);
+        }
+        fBufferPtr = NULL;
+    }
+
+    GrAssert(NULL == fBufferPtr);
+
+    if (fGpu->supportsBufferLocking() &&
+        size > GR_GEOM_BUFFER_LOCK_THRESHOLD &&
+        (!fFrequentResetHint || requestSize > GR_GEOM_BUFFER_LOCK_THRESHOLD)) {
+        fBufferPtr = block.fBuffer->lock();
+    }
+
+    if (NULL == fBufferPtr) {
+        fBufferPtr = fCpuData.realloc(size);
+    }
+
+    VALIDATE();
+
+    return true;
+}
+
+void GrBufferAllocPool::destroyBlock() {
+    GrAssert(!fBlocks.empty());
+
+    BufferBlock& block = fBlocks.back();
+    if (fPreallocBuffersInUse > 0) {
+        uint32_t prevPreallocBuffer = (fPreallocBuffersInUse +
+                                       fFirstPreallocBuffer +
+                                       (fPreallocBuffers.count() - 1)) %
+                                      fPreallocBuffers.count();
+        if (block.fBuffer == fPreallocBuffers[prevPreallocBuffer]) {
+            --fPreallocBuffersInUse;
+        }
+    }
+    GrAssert(!block.fBuffer->isLocked());
+    block.fBuffer->unref();
+    fBlocks.pop_back();
+    fBufferPtr = NULL;
+}
+
+void GrBufferAllocPool::flushCpuData(GrGeometryBuffer* buffer,
+                                     size_t flushSize) {
+    GrAssert(NULL != buffer);
+    GrAssert(!buffer->isLocked());
+    GrAssert(fCpuData.get() == fBufferPtr);
+    GrAssert(fCpuData.size() == buffer->size());
+    GrAssert(flushSize <= buffer->size());
+
+    bool updated = false;
+    if (fGpu->supportsBufferLocking() &&
+        flushSize > GR_GEOM_BUFFER_LOCK_THRESHOLD) {
+        void* data = buffer->lock();
+        if (NULL != data) {
+            memcpy(data, fBufferPtr, flushSize);
+            buffer->unlock();
+            updated = true;
+        }
+    }
+    buffer->updateData(fBufferPtr, flushSize);
+}
+
+GrGeometryBuffer* GrBufferAllocPool::createBuffer(size_t size) {
+    if (kIndex_BufferType == fBufferType) {
+        return fGpu->createIndexBuffer(size, true);
+    } else {
+        GrAssert(kVertex_BufferType == fBufferType);
+        return fGpu->createVertexBuffer(size, true);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrVertexBufferAllocPool::GrVertexBufferAllocPool(GrGpu* gpu,
+                                                 bool frequentResetHint,
+                                                 size_t bufferSize,
+                                                 int preallocBufferCnt)
+: GrBufferAllocPool(gpu,
+                    kVertex_BufferType,
+                    frequentResetHint,
+                    bufferSize,
+                    preallocBufferCnt) {
+}
+
+void* GrVertexBufferAllocPool::makeSpace(GrVertexLayout layout,
+                                         int vertexCount,
+                                         const GrVertexBuffer** buffer,
+                                         int* startVertex) {
+
+    GrAssert(vertexCount >= 0);
+    GrAssert(NULL != buffer);
+    GrAssert(NULL != startVertex);
+
+    size_t vSize = GrDrawTarget::VertexSize(layout);
+    size_t offset;
+    const GrGeometryBuffer* geomBuffer;
+    void* ptr = INHERITED::makeSpace(vSize * vertexCount,
+                                     vSize,
+                                     &geomBuffer,
+                                     &offset);
+
+    *buffer = (const GrVertexBuffer*) geomBuffer;
+    GrAssert(0 == offset % vSize);
+    *startVertex = offset / vSize;
+    return ptr;
+}
+
+bool GrVertexBufferAllocPool::appendVertices(GrVertexLayout layout,
+                                             int vertexCount,
+                                             const void* vertices,
+                                             const GrVertexBuffer** buffer,
+                                             int* startVertex) {
+    void* space = makeSpace(layout, vertexCount, buffer, startVertex);
+    if (NULL != space) {
+        memcpy(space,
+               vertices,
+               GrDrawTarget::VertexSize(layout) * vertexCount);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+int GrVertexBufferAllocPool::preallocatedBufferVertices(GrVertexLayout layout) const {
+    return INHERITED::preallocatedBufferSize() /
+            GrDrawTarget::VertexSize(layout);
+}
+
+int GrVertexBufferAllocPool::currentBufferVertices(GrVertexLayout layout) const {
+    return currentBufferItems(GrDrawTarget::VertexSize(layout));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrIndexBufferAllocPool::GrIndexBufferAllocPool(GrGpu* gpu,
+                                               bool frequentResetHint,
+                                               size_t bufferSize,
+                                               int preallocBufferCnt)
+: GrBufferAllocPool(gpu,
+                    kIndex_BufferType,
+                    frequentResetHint,
+                    bufferSize,
+                    preallocBufferCnt) {
+}
+
+void* GrIndexBufferAllocPool::makeSpace(int indexCount,
+                                        const GrIndexBuffer** buffer,
+                                        int* startIndex) {
+
+    GrAssert(indexCount >= 0);
+    GrAssert(NULL != buffer);
+    GrAssert(NULL != startIndex);
+
+    size_t offset;
+    const GrGeometryBuffer* geomBuffer;
+    void* ptr = INHERITED::makeSpace(indexCount * sizeof(uint16_t),
+                                     sizeof(uint16_t),
+                                     &geomBuffer,
+                                     &offset);
+
+    *buffer = (const GrIndexBuffer*) geomBuffer;
+    GrAssert(0 == offset % sizeof(uint16_t));
+    *startIndex = offset / sizeof(uint16_t);
+    return ptr;
+}
+
+bool GrIndexBufferAllocPool::appendIndices(int indexCount,
+                                           const void* indices,
+                                           const GrIndexBuffer** buffer,
+                                           int* startIndex) {
+    void* space = makeSpace(indexCount, buffer, startIndex);
+    if (NULL != space) {
+        memcpy(space, indices, sizeof(uint16_t) * indexCount);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+int GrIndexBufferAllocPool::preallocatedBufferIndices() const {
+    return INHERITED::preallocatedBufferSize() / sizeof(uint16_t);
+}
+
+int GrIndexBufferAllocPool::currentBufferIndices() const {
+    return currentBufferItems(sizeof(uint16_t));
+}
diff --git a/gpu/src/GrBufferAllocPool.h b/gpu/src/GrBufferAllocPool.h
new file mode 100644
index 0000000..80f16ab
--- /dev/null
+++ b/gpu/src/GrBufferAllocPool.h
@@ -0,0 +1,349 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrBufferAllocPool_DEFINED
+#define GrBufferAllocPool_DEFINED
+
+#include "GrNoncopyable.h"
+#include "GrTDArray.h"
+#include "GrTArray.h"
+#include "GrMemory.h"
+
+class GrGeometryBuffer;
+class GrGpu;
+
+/**
+ * A pool of geometry buffers tied to a GrGpu.
+ *
+ * The pool allows a client to make space for geometry and then put back excess
+ * space if it over allocated. When a client is ready to draw from the pool
+ * it calls unlock on the pool ensure buffers are ready for drawing. The pool
+ * can be reset after drawing is completed to recycle space.
+ *
+ * At creation time a minimum per-buffer size can be specified. Additionally,
+ * a number of buffers to preallocate can be specified. These will
+ * be allocated at the min size and kept around until the pool is destroyed.
+ */
+class GrBufferAllocPool : GrNoncopyable {
+protected:
+
+    // We could make the createBuffer a virtual except that we want to use it
+    // in the cons for pre-allocated buffers.
+    enum BufferType {
+        kVertex_BufferType,
+        kIndex_BufferType,
+    };
+
+    /**
+     * Constructor
+     *
+     * @param gpu                   The GrGpu used to create the buffers.
+     * @param bufferType            The type of buffers to create.
+     * @param frequentResetHint     A hint that indicates that the pool
+     *                              should expect frequent unlock() calls
+     *                              (as opposed to many makeSpace / acquires
+     *                              between resets).
+     * @param bufferSize            The minimum size of created buffers.
+     *                              This value will be clamped to some
+     *                              reasonable minimum.
+     * @param preallocBufferCnt     The pool will allocate this number of
+     *                              buffers at bufferSize and keep them until it
+     *                              is destroyed.
+     */
+     GrBufferAllocPool(GrGpu* gpu,
+                       BufferType bufferType,
+                       bool frequentResetHint,
+                       size_t   bufferSize = 0,
+                       int preallocBufferCnt = 0);
+
+    virtual ~GrBufferAllocPool();
+
+public:
+    /**
+     * Ensures all buffers are unlocked and have all data written to them.
+     * Call before drawing using buffers from the pool.
+     */
+    void unlock();
+
+    /**
+     *  Invalidates all the data in the pool, unrefs non-preallocated buffers.
+     */
+    void reset();
+
+    /**
+     * Gets the number of preallocated buffers that are yet to be used.
+     */
+    int preallocatedBuffersRemaining() const;
+
+    /**
+     * gets the number of preallocated buffers
+     */
+    int preallocatedBufferCount() const;
+
+
+    /**
+     * Frees data from makeSpaces in LIFO order.
+     */
+    void putBack(size_t bytes);
+
+    /**
+     * Gets the GrGpu that this pool is associated with.
+     */
+    GrGpu* getGpu() { return fGpu; }
+
+protected:
+    /**
+     * Gets the size of the preallocated buffers.
+     *
+     * @return the size of preallocated buffers.
+     */
+    size_t preallocatedBufferSize() const {
+        return fPreallocBuffers.count() ? fMinBlockSize : 0;
+    }
+
+    /**
+     * Returns a block of memory to hold data. A buffer designated to hold the
+     * data is given to the caller. The buffer may or may not be locked. The
+     * returned ptr remains valid until any of the following:
+     *      *makeSpace is called again.
+     *      *unlock is called.
+     *      *reset is called.
+     *      *this object is destroyed.
+     *
+     * Once unlock on the pool is called the data is guaranteed to be in the
+     * buffer at the offset indicated by offset. Until that time it may be
+     * in temporary storage and/or the buffer may be locked.
+     *
+     * @param size         the amount of data to make space for
+     * @param alignment    alignment constraint from start of buffer
+     * @param buffer       returns the buffer that will hold the data.
+     * @param offset       returns the offset into buffer of the data.
+     * @return pointer to where the client should write the data.
+     */
+    void* makeSpace(size_t size,
+                    size_t alignment,
+                    const GrGeometryBuffer** buffer,
+                    size_t* offset);
+
+    /**
+     * Gets the number of items of a size that can be added to the current
+     * buffer without spilling to another buffer. If the pool has been reset, or
+     * the previous makeSpace completely exhausted a buffer then the returned
+     * size will be the size of the next available preallocated buffer, or zero
+     * if no preallocated buffer remains available. It is assumed that items
+     * should be itemSize-aligned from the start of a buffer.
+     *
+     * @return the number of items that would fit in the current buffer.
+     */
+    int currentBufferItems(size_t itemSize) const;
+
+    GrGeometryBuffer* createBuffer(size_t size);
+
+private:
+
+    struct BufferBlock {
+        size_t              fBytesFree;
+        GrGeometryBuffer*   fBuffer;
+    };
+
+    bool createBlock(size_t requestSize);
+    void destroyBlock();
+    void flushCpuData(GrGeometryBuffer* buffer, size_t flushSize);
+#if GR_DEBUG
+    void validate() const;
+#endif
+
+    GrGpu*                          fGpu;
+    bool                            fFrequentResetHint;
+    GrTDArray<GrGeometryBuffer*>    fPreallocBuffers;
+    size_t                          fMinBlockSize;
+    BufferType                      fBufferType;
+
+    GrTArray<BufferBlock>           fBlocks;
+    int                             fPreallocBuffersInUse;
+    int                             fFirstPreallocBuffer;
+    GrAutoMalloc                    fCpuData;
+    void*                       	fBufferPtr;
+};
+
+class GrVertexBuffer;
+
+/**
+ * A GrBufferAllocPool of vertex buffers
+ */
+class GrVertexBufferAllocPool : public GrBufferAllocPool {
+public:
+    /**
+     * Constructor
+     *
+     * @param gpu                   The GrGpu used to create the vertex buffers.
+     * @param frequentResetHint     A hint that indicates that the pool
+     *                              should expect frequent unlock() calls
+     *                              (as opposed to many makeSpace / acquires
+     *                              between resets).
+     * @param bufferSize            The minimum size of created VBs This value
+     *                              will be clamped to some reasonable minimum.
+     * @param preallocBufferCnt     The pool will allocate this number of VBs at
+     *                              bufferSize and keep them until it is
+     *                              destroyed.
+     */
+    GrVertexBufferAllocPool(GrGpu* gpu,
+                            bool frequentResetHint,
+                            size_t bufferSize = 0,
+                            int preallocBufferCnt = 0);
+
+    /**
+     * Returns a block of memory to hold vertices. A buffer designated to hold
+     * the vertices given to the caller. The buffer may or may not be locked.
+     * The returned ptr remains valid until any of the following:
+     *      *makeSpace is called again.
+     *      *unlock is called.
+     *      *reset is called.
+     *      *this object is destroyed.
+     *
+     * Once unlock on the pool is called the vertices are guaranteed to be in
+     * the buffer at the offset indicated by startVertex. Until that time they
+     * may be in temporary storage and/or the buffer may be locked.
+     *
+     * @param layout       specifies type of vertices to allocate space for
+     * @param vertexCount  number of vertices to allocate space for
+     * @param buffer       returns the vertex buffer that will hold the
+     *                     vertices.
+     * @param startVertex  returns the offset into buffer of the first vertex.
+     *                     In units of the size of a vertex from layout param.
+     * @return pointer to first vertex.
+     */
+    void* makeSpace(GrVertexLayout layout,
+                    int vertexCount,
+                    const GrVertexBuffer** buffer,
+                    int* startVertex);
+
+    /**
+     * Shortcut to make space and then write verts into the made space.
+     */
+    bool appendVertices(GrVertexLayout layout,
+                        int vertexCount,
+                        const void* vertices,
+                        const GrVertexBuffer** buffer,
+                        int* startVertex);
+
+    /**
+     * Gets the number of vertices that can be added to the current VB without
+     * spilling to another VB. If the pool has been reset, or the previous
+     * makeSpace completely exhausted a VB then the returned number of vertices
+     * would fit in the next available preallocated buffer. If any makeSpace
+     * would force a new VB to be created the return value will be zero.
+     *
+     * @param   the format of vertices to compute space for.
+     * @return the number of vertices that would fit in the current buffer.
+     */
+    int currentBufferVertices(GrVertexLayout layout) const;
+
+    /**
+     * Gets the number of vertices that can fit in a  preallocated vertex buffer.
+     * Zero if no preallocated buffers.
+     *
+     * @param   the format of vertices to compute space for.
+     *
+     * @return number of vertices that fit in one of the preallocated vertex
+     *         buffers.
+     */
+    int preallocatedBufferVertices(GrVertexLayout layout) const;
+
+private:
+    typedef GrBufferAllocPool INHERITED;
+};
+
+class GrIndexBuffer;
+
+/**
+ * A GrBufferAllocPool of index buffers
+ */
+class GrIndexBufferAllocPool : public GrBufferAllocPool {
+public:
+    /**
+     * Constructor
+     *
+     * @param gpu                   The GrGpu used to create the index buffers.
+     * @param frequentResetHint     A hint that indicates that the pool
+     *                              should expect frequent unlock() calls
+     *                              (as opposed to many makeSpace / acquires
+     *                              between resets).
+     * @param bufferSize            The minimum size of created IBs This value
+     *                              will be clamped to some reasonable minimum.
+     * @param preallocBufferCnt     The pool will allocate this number of VBs at
+     *                              bufferSize and keep them until it is
+     *                              destroyed.
+     */
+    GrIndexBufferAllocPool(GrGpu* gpu,
+                           bool frequentResetHint,
+                           size_t bufferSize = 0,
+                           int preallocBufferCnt = 0);
+
+    /**
+     * Returns a block of memory to hold indices. A buffer designated to hold
+     * the indices is given to the caller. The buffer may or may not be locked.
+     * The returned ptr remains valid until any of the following:
+     *      *makeSpace is called again.
+     *      *unlock is called.
+     *      *reset is called.
+     *      *this object is destroyed.
+     *
+     * Once unlock on the pool is called the indices are guaranteed to be in the
+     * buffer at the offset indicated by startIndex. Until that time they may be
+     * in temporary storage and/or the buffer may be locked.
+     *
+     * @param indexCount   number of indices to allocate space for
+     * @param buffer       returns the index buffer that will hold the indices.
+     * @param startIndex   returns the offset into buffer of the first index.
+     * @return pointer to first index.
+     */
+    void* makeSpace(int indexCount,
+                    const GrIndexBuffer** buffer,
+                    int* startIndex);
+
+    /**
+     * Shortcut to make space and then write indices into the made space.
+     */
+    bool appendIndices(int indexCount,
+                       const void* indices,
+                       const GrIndexBuffer** buffer,
+                       int* startIndex);
+
+    /**
+     * Gets the number of indices that can be added to the current IB without
+     * spilling to another IB. If the pool has been reset, or the previous
+     * makeSpace completely exhausted a IB then the returned number of indices
+     * would fit in the next available preallocated buffer. If any makeSpace
+     * would force a new IB to be created the return value will be zero.
+     */
+    int currentBufferIndices() const;
+
+    /**
+     * Gets the number of indices that can fit in a preallocated index buffer.
+     * Zero if no preallocated buffers.
+     *
+     * @return number of indices that fit in one of the preallocated index
+     *         buffers.
+     */
+    int preallocatedBufferIndices() const;
+
+private:
+    typedef GrBufferAllocPool INHERITED;
+};
+
+#endif
diff --git a/gpu/src/GrClip.cpp b/gpu/src/GrClip.cpp
new file mode 100644
index 0000000..e8da3d1
--- /dev/null
+++ b/gpu/src/GrClip.cpp
@@ -0,0 +1,153 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrClip.h"
+
+GrClip::GrClip()
+    : fList(fListMemory, kPreAllocElements) {
+    fConservativeBounds.setEmpty();
+    fConservativeBoundsValid = true;
+}
+
+GrClip::GrClip(const GrClip& src)
+    : fList(fListMemory, kPreAllocElements) {
+    *this = src;
+}
+
+GrClip::GrClip(const GrIRect& rect)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromIRect(rect);
+}
+
+GrClip::GrClip(const GrRect& rect)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromRect(rect);
+}
+
+GrClip::GrClip(GrClipIterator* iter, GrScalar tx, GrScalar ty,
+               const GrRect* bounds)
+    : fList(fListMemory, kPreAllocElements) {
+    this->setFromIterator(iter, tx, ty, bounds);
+}
+
+GrClip::~GrClip() {}
+
+GrClip& GrClip::operator=(const GrClip& src) {
+    fList = src.fList;
+    fConservativeBounds = src.fConservativeBounds;
+    fConservativeBoundsValid = src.fConservativeBoundsValid;
+    return *this;
+}
+
+void GrClip::setEmpty() {
+    fList.reset();
+    fConservativeBounds.setEmpty();
+    fConservativeBoundsValid = true;
+}
+
+void GrClip::setFromRect(const GrRect& r) {
+    fList.reset();
+    if (r.isEmpty()) {
+        // use a canonical empty rect for == testing.
+        setEmpty();
+    } else {
+        fList.push_back();
+        fList.back().fRect = r;
+        fList.back().fType = kRect_ClipType;
+        fConservativeBounds = r;
+        fConservativeBoundsValid = true;
+    }
+}
+
+void GrClip::setFromIRect(const GrIRect& r) {
+    fList.reset();
+    if (r.isEmpty()) {
+        // use a canonical empty rect for == testing.
+        setEmpty();
+    } else {
+        fList.push_back();
+        fList.back().fRect.set(r);
+        fList.back().fType = kRect_ClipType;
+        fConservativeBounds.set(r);
+        fConservativeBoundsValid = true;
+    }
+}
+
+void GrClip::setFromIterator(GrClipIterator* iter, GrScalar tx, GrScalar ty,
+                             const GrRect* conservativeBounds) {
+    fList.reset();
+
+    int rectCount = 0;
+
+    // compute bounds for common case of series of intersecting rects.
+    bool isectRectValid = true;
+
+    if (iter) {
+        for (iter->rewind(); !iter->isDone(); iter->next()) {
+            Element& e = fList.push_back();
+            e.fType = iter->getType();
+            e.fOp = iter->getOp();
+            // iterators should not emit replace
+            GrAssert(kReplace_SetOp != e.fOp);
+            switch (e.fType) {
+                case kRect_ClipType:
+                    iter->getRect(&e.fRect);
+                    if (tx || ty) {
+                        e.fRect.offset(tx, ty);
+                    }
+                    ++rectCount;
+                    if (isectRectValid) {
+                        if (1 == rectCount || kIntersect_SetOp == e.fOp) {
+                            GrAssert(fList.count() <= 2);
+                            if (fList.count() > 1) {
+                                GrAssert(2 == rectCount);
+                                rectCount = 1;
+                                fList.pop_back();
+                                GrAssert(kRect_ClipType == fList.back().fType);
+                                fList.back().fRect.intersectWith(e.fRect);
+                            }
+                        } else {
+                            isectRectValid = false;
+                        }
+                    }
+                    break;
+                case kPath_ClipType:
+                    e.fPath.resetFromIter(iter->getPathIter());
+                    if (tx || ty) {
+                        e.fPath.offset(tx, ty);
+                    }
+                    e.fPathFill = iter->getPathFill();
+                    isectRectValid = false;
+                    break;
+                default:
+                    GrCrash("Unknown clip element type.");
+            }
+        }
+    }
+    fConservativeBoundsValid = false;
+    if (isectRectValid) {
+        fConservativeBoundsValid = true;
+        if (rectCount > 0) {
+            fConservativeBounds = fList[0].fRect;
+        } else {
+            fConservativeBounds.setEmpty();
+        }
+    } else if (NULL != conservativeBounds) {
+        fConservativeBounds = *conservativeBounds;
+        fConservativeBoundsValid = true;
+    }
+}
diff --git a/gpu/src/GrContext.cpp b/gpu/src/GrContext.cpp
new file mode 100644
index 0000000..cf51cc9
--- /dev/null
+++ b/gpu/src/GrContext.cpp
@@ -0,0 +1,810 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#include "GrContext.h"
+#include "GrTypes.h"
+#include "GrTextureCache.h"
+#include "GrTextStrike.h"
+#include "GrMemory.h"
+#include "GrPathIter.h"
+#include "GrClipIterator.h"
+#include "GrIndexBuffer.h"
+#include "GrInOrderDrawBuffer.h"
+#include "GrBufferAllocPool.h"
+#include "GrPathRenderer.h"
+
+#define DEFER_TEXT_RENDERING 1
+
+#define BATCH_RECT_TO_RECT (1 && !GR_STATIC_RECT_VB)
+
+static const size_t MAX_TEXTURE_CACHE_COUNT = 128;
+static const size_t MAX_TEXTURE_CACHE_BYTES = 8 * 1024 * 1024;
+
+static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 18;
+static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
+
+// We are currently only batching Text and drawRectToRect, both
+// of which use the quad index buffer.
+static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 0;
+static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 0;
+
+GrContext* GrContext::Create(GrGpu::Engine engine,
+                             GrGpu::Platform3DContext context3D) {
+    GrContext* ctx = NULL;
+    GrGpu* fGpu = GrGpu::Create(engine, context3D);
+    if (NULL != fGpu) {
+        ctx = new GrContext(fGpu);
+        fGpu->unref();
+    }
+    return ctx;
+}
+
+GrContext* GrContext::CreateGLShaderContext() {
+    return GrContext::Create(GrGpu::kOpenGL_Shaders_Engine, NULL);
+}
+
+GrContext::~GrContext() {
+    fGpu->unref();
+    delete fTextureCache;
+    delete fFontCache;
+    delete fDrawBuffer;
+    delete fDrawBufferVBAllocPool;
+    delete fDrawBufferIBAllocPool;
+    delete fPathRenderer;
+}
+
+void GrContext::abandonAllTextures() {
+    fTextureCache->deleteAll(GrTextureCache::kAbandonTexture_DeleteMode);
+    fFontCache->abandonAll();
+}
+
+GrTextureEntry* GrContext::findAndLockTexture(GrTextureKey* key,
+                                              const GrSamplerState& sampler) {
+    finalizeTextureKey(key, sampler);
+    return fTextureCache->findAndLock(*key);
+}
+
+static void stretchImage(void* dst,
+                         int dstW,
+                         int dstH,
+                         void* src,
+                         int srcW,
+                         int srcH,
+                         int bpp) {
+    GrFixed dx = (srcW << 16) / dstW;
+    GrFixed dy = (srcH << 16) / dstH;
+
+    GrFixed y = dy >> 1;
+
+    int dstXLimit = dstW*bpp;
+    for (int j = 0; j < dstH; ++j) {
+        GrFixed x = dx >> 1;
+        void* srcRow = (uint8_t*)src + (y>>16)*srcW*bpp;
+        void* dstRow = (uint8_t*)dst + j*dstW*bpp;
+        for (int i = 0; i < dstXLimit; i += bpp) {
+            memcpy((uint8_t*) dstRow + i,
+                   (uint8_t*) srcRow + (x>>16)*bpp,
+                   bpp);
+            x += dx;
+        }
+        y += dy;
+    }
+}
+
+GrTextureEntry* GrContext::createAndLockTexture(GrTextureKey* key,
+                                                const GrSamplerState& sampler,
+                                                const GrGpu::TextureDesc& desc,
+                                                void* srcData, size_t rowBytes) {
+    GrAssert(key->width() == desc.fWidth);
+    GrAssert(key->height() == desc.fHeight);
+
+#if GR_DUMP_TEXTURE_UPLOAD
+    GrPrintf("GrContext::createAndLockTexture [%d %d]\n", desc.fWidth, desc.fHeight);
+#endif
+
+    GrTextureEntry* entry = NULL;
+    bool special = finalizeTextureKey(key, sampler);
+    if (special) {
+        GrTextureEntry* clampEntry;
+        GrTextureKey clampKey(*key);
+        clampEntry = findAndLockTexture(&clampKey, GrSamplerState::ClampNoFilter());
+
+        if (NULL == clampEntry) {
+            clampEntry = createAndLockTexture(&clampKey,
+                                              GrSamplerState::ClampNoFilter(),
+                                              desc, srcData, rowBytes);
+            GrAssert(NULL != clampEntry);
+            if (NULL == clampEntry) {
+                return NULL;
+            }
+        }
+        GrGpu::TextureDesc rtDesc = desc;
+        rtDesc.fFlags |= GrGpu::kRenderTarget_TextureFlag |
+                         GrGpu::kNoPathRendering_TextureFlag;
+        rtDesc.fWidth  = GrNextPow2(GrMax<int>(desc.fWidth,
+                                               fGpu->minRenderTargetWidth()));
+        rtDesc.fHeight = GrNextPow2(GrMax<int>(desc.fHeight,
+                                               fGpu->minRenderTargetHeight()));
+
+        GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
+
+        if (NULL != texture) {
+            GrDrawTarget::AutoStateRestore asr(fGpu);
+            fGpu->setRenderTarget(texture->asRenderTarget());
+            fGpu->setTexture(0, clampEntry->texture());
+            fGpu->disableStencil();
+            fGpu->setViewMatrix(GrMatrix::I());
+            fGpu->setAlpha(0xff);
+            fGpu->setBlendFunc(kOne_BlendCoeff, kZero_BlendCoeff);
+            fGpu->disableState(GrDrawTarget::kDither_StateBit |
+                               GrDrawTarget::kClip_StateBit   |
+                               GrDrawTarget::kAntialias_StateBit);
+            GrSamplerState stretchSampler(GrSamplerState::kClamp_WrapMode,
+                                          GrSamplerState::kClamp_WrapMode,
+                                          sampler.isFilter());
+            fGpu->setSamplerState(0, stretchSampler);
+
+            static const GrVertexLayout layout =
+                                GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+            GrDrawTarget::AutoReleaseGeometry arg(fGpu, layout, 4, 0);
+
+            if (arg.succeeded()) {
+                GrPoint* verts = (GrPoint*) arg.vertices();
+                verts[0].setIRectFan(0, 0,
+                                     texture->width(),
+                                     texture->height(),
+                                     2*sizeof(GrPoint));
+                verts[1].setIRectFan(0, 0, 1, 1, 2*sizeof(GrPoint));
+                fGpu->drawNonIndexed(kTriangleFan_PrimitiveType,
+                                     0, 4);
+                entry = fTextureCache->createAndLock(*key, texture);
+            }
+            texture->releaseRenderTarget();
+        } else {
+            // TODO: Our CPU stretch doesn't filter. But we create separate
+            // stretched textures when the sampler state is either filtered or
+            // not. Either implement filtered stretch blit on CPU or just create
+            // one when FBO case fails.
+
+            rtDesc.fFlags = 0;
+            // no longer need to clamp at min RT size.
+            rtDesc.fWidth  = GrNextPow2(desc.fWidth);
+            rtDesc.fHeight = GrNextPow2(desc.fHeight);
+            int bpp = GrTexture::BytesPerPixel(desc.fFormat);
+            GrAutoSMalloc<128*128*4> stretchedPixels(bpp *
+                                                     rtDesc.fWidth *
+                                                     rtDesc.fHeight);
+            stretchImage(stretchedPixels.get(), rtDesc.fWidth, rtDesc.fHeight,
+                         srcData, desc.fWidth, desc.fHeight, bpp);
+
+            size_t stretchedRowBytes = rtDesc.fWidth * bpp;
+
+            GrTexture* texture = fGpu->createTexture(rtDesc,
+                                                     stretchedPixels.get(),
+                                                     stretchedRowBytes);
+            GrAssert(NULL != texture);
+            entry = fTextureCache->createAndLock(*key, texture);
+        }
+        fTextureCache->unlock(clampEntry);
+
+    } else {
+        GrTexture* texture = fGpu->createTexture(desc, srcData, rowBytes);
+        if (NULL != texture) {
+            entry = fTextureCache->createAndLock(*key, texture);
+        } else {
+            entry = NULL;
+        }
+    }
+    return entry;
+}
+
+void GrContext::unlockTexture(GrTextureEntry* entry) {
+    fTextureCache->unlock(entry);
+}
+
+void GrContext::detachCachedTexture(GrTextureEntry* entry) {
+    fTextureCache->detach(entry);
+}
+
+void GrContext::reattachAndUnlockCachedTexture(GrTextureEntry* entry) {
+    fTextureCache->reattachAndUnlock(entry);
+}
+
+GrTexture* GrContext::createUncachedTexture(const GrGpu::TextureDesc& desc,
+                                            void* srcData,
+                                            size_t rowBytes) {
+    return fGpu->createTexture(desc, srcData, rowBytes);
+}
+
+void GrContext::getTextureCacheLimits(int* maxTextures,
+                                      size_t* maxTextureBytes) const {
+    fTextureCache->getLimits(maxTextures, maxTextureBytes);
+}
+
+void GrContext::setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) {
+    fTextureCache->setLimits(maxTextures, maxTextureBytes);
+}
+
+int GrContext::getMaxTextureDimension() {
+    return fGpu->maxTextureDimension();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrRenderTarget* GrContext::createPlatformRenderTarget(
+                                                intptr_t platformRenderTarget,
+                                                int stencilBits,
+                                                int width, int height) {
+    return fGpu->createPlatformRenderTarget(platformRenderTarget, stencilBits,
+                                            width, height);
+}
+
+bool GrContext::supportsIndex8PixelConfig(const GrSamplerState& sampler,
+                                          int width, int height) {
+    if (!fGpu->supports8BitPalette()) {
+        return false;
+    }
+
+
+    bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
+
+    if (!isPow2) {
+        if (!fGpu->npotTextureSupport()) {
+            return false;
+        }
+
+        bool tiled = sampler.getWrapX() != GrSamplerState::kClamp_WrapMode ||
+                     sampler.getWrapY() != GrSamplerState::kClamp_WrapMode;
+        if (tiled && !fGpu->npotTextureTileSupport()) {
+            return false;
+        }
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::setClip(const GrClip& clip) {
+    fGpu->setClip(clip);
+    fGpu->enableState(GrDrawTarget::kClip_StateBit);
+}
+
+void GrContext::setClip(const GrIRect& rect) {
+    GrClip clip;
+    clip.setFromIRect(rect);
+    fGpu->setClip(clip);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::eraseColor(GrColor color) {
+    fGpu->eraseColor(color);
+}
+
+void GrContext::drawPaint(const GrPaint& paint) {
+    // set rect to be big enough to fill the space, but not super-huge, so we
+    // don't overflow fixed-point implementations
+    GrRect r;
+    r.setLTRB(0, 0,
+              GrIntToScalar(getRenderTarget()->width()),
+              GrIntToScalar(getRenderTarget()->height()));
+    GrMatrix inverse;
+    if (fGpu->getViewInverse(&inverse)) {
+        inverse.mapRect(&r);
+    } else {
+        GrPrintf("---- fGpu->getViewInverse failed\n");
+    }
+    this->drawRect(paint, r);
+}
+
+/*  create a triangle strip that strokes the specified triangle. There are 8
+ unique vertices, but we repreat the last 2 to close up. Alternatively we
+ could use an indices array, and then only send 8 verts, but not sure that
+ would be faster.
+ */
+static void setStrokeRectStrip(GrPoint verts[10], const GrRect& rect,
+                               GrScalar width) {
+    const GrScalar rad = GrScalarHalf(width);
+
+    verts[0].set(rect.fLeft + rad, rect.fTop + rad);
+    verts[1].set(rect.fLeft - rad, rect.fTop - rad);
+    verts[2].set(rect.fRight - rad, rect.fTop + rad);
+    verts[3].set(rect.fRight + rad, rect.fTop - rad);
+    verts[4].set(rect.fRight - rad, rect.fBottom - rad);
+    verts[5].set(rect.fRight + rad, rect.fBottom + rad);
+    verts[6].set(rect.fLeft + rad, rect.fBottom - rad);
+    verts[7].set(rect.fLeft - rad, rect.fBottom + rad);
+    verts[8] = verts[0];
+    verts[9] = verts[1];
+}
+
+void GrContext::drawRect(const GrPaint& paint,
+                         const GrRect& rect,
+                         GrScalar width,
+                         const GrMatrix* matrix) {
+
+    bool textured = NULL != paint.getTexture();
+
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    if (width >= 0) {
+        // TODO: consider making static vertex buffers for these cases.
+        // Hairline could be done by just adding closing vertex to
+        // unitSquareVertexBuffer()
+        GrVertexLayout layout = (textured) ?
+                                 GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
+                                 0;
+        static const int worstCaseVertCount = 10;
+        GrDrawTarget::AutoReleaseGeometry geo(target, layout, worstCaseVertCount, 0);
+
+        if (!geo.succeeded()) {
+            return;
+        }
+
+        GrPrimitiveType primType;
+        int vertCount;
+        GrPoint* vertex = geo.positions();
+
+        if (width > 0) {
+            vertCount = 10;
+            primType = kTriangleStrip_PrimitiveType;
+            setStrokeRectStrip(vertex, rect, width);
+        } else {
+            // hairline
+            vertCount = 5;
+            primType = kLineStrip_PrimitiveType;
+            vertex[0].set(rect.fLeft, rect.fTop);
+            vertex[1].set(rect.fRight, rect.fTop);
+            vertex[2].set(rect.fRight, rect.fBottom);
+            vertex[3].set(rect.fLeft, rect.fBottom);
+            vertex[4].set(rect.fLeft, rect.fTop);
+        }
+
+        GrDrawTarget::AutoViewMatrixRestore avmr;
+        if (NULL != matrix) {
+            avmr.set(target);
+            target->preConcatViewMatrix(*matrix);
+            target->preConcatSamplerMatrix(0, *matrix);
+        }
+
+        target->drawNonIndexed(primType, 0, vertCount);
+    } else {
+        #if GR_STATIC_RECT_VB
+            GrVertexLayout layout = (textured) ?
+                            GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0) :
+                            0;
+            target->setVertexSourceToBuffer(layout,
+                                            fGpu->getUnitSquareVertexBuffer());
+            GrDrawTarget::AutoViewMatrixRestore avmr(target);
+            GrMatrix m;
+            m.setAll(rect.width(), 0,             rect.fLeft,
+                     0,            rect.height(), rect.fTop,
+                     0,            0,             GrMatrix::I()[8]);
+
+            if (NULL != matrix) {
+                m.postConcat(*matrix);
+            }
+
+            target->preConcatViewMatrix(m);
+
+            if (textured) {
+                target->preConcatSamplerMatrix(0, m);
+            }
+            target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+        #else
+            target->drawSimpleRect(rect, matrix, textured ? 1 : 0);
+        #endif
+    }
+}
+
+void GrContext::drawRectToRect(const GrPaint& paint,
+                               const GrRect& dstRect,
+                               const GrRect& srcRect,
+                               const GrMatrix* dstMatrix,
+                               const GrMatrix* srcMatrix) {
+
+    if (NULL == paint.getTexture()) {
+        drawRect(paint, dstRect, -1, dstMatrix);
+        return;
+    }
+
+    GR_STATIC_ASSERT(!BATCH_RECT_TO_RECT || !GR_STATIC_RECT_VB);
+
+#if GR_STATIC_RECT_VB
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+    GrDrawTarget::AutoViewMatrixRestore avmr(target);
+
+    GrMatrix m;
+
+    m.setAll(dstRect.width(), 0,                dstRect.fLeft,
+             0,               dstRect.height(), dstRect.fTop,
+             0,               0,                GrMatrix::I()[8]);
+    if (NULL != dstMatrix) {
+        m.postConcat(*dstMatrix);
+    }
+    target->preConcatViewMatrix(m);
+
+    m.setAll(srcRect.width(), 0,                srcRect.fLeft,
+             0,               srcRect.height(), srcRect.fTop,
+             0,               0,                GrMatrix::I()[8]);
+    if (NULL != srcMatrix) {
+        m.postConcat(*srcMatrix);
+    }
+    target->preConcatSamplerMatrix(0, m);
+
+    target->setVertexSourceToBuffer(layout, fGpu->getUnitSquareVertexBuffer());
+    target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+#else
+
+    GrDrawTarget* target;
+#if BATCH_RECT_TO_RECT
+    target = this->prepareToDraw(paint, kBuffered_DrawCategory);
+#else
+    target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+#endif
+
+    const GrRect* srcRects[GrDrawTarget::kNumStages] = {NULL};
+    const GrMatrix* srcMatrices[GrDrawTarget::kNumStages] = {NULL};
+    srcRects[0] = &srcRect;
+    srcMatrices[0] = srcMatrix;
+
+    target->drawRect(dstRect, dstMatrix, 1, srcRects, srcMatrices);
+#endif
+}
+
+void GrContext::drawVertices(const GrPaint& paint,
+                             GrPrimitiveType primitiveType,
+                             int vertexCount,
+                             const GrPoint positions[],
+                             const GrPoint texCoords[],
+                             const GrColor colors[],
+                             const uint16_t indices[],
+                             int indexCount) {
+    GrVertexLayout layout = 0;
+    int vertexSize = sizeof(GrPoint);
+
+    GrDrawTarget::AutoReleaseGeometry geo;
+
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    if (NULL != paint.getTexture()) {
+        if (NULL == texCoords) {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        } else {
+            layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
+            vertexSize += sizeof(GrPoint);
+        }
+    }
+
+    if (NULL != colors) {
+        layout |= GrDrawTarget::kColor_VertexLayoutBit;
+        vertexSize += sizeof(GrColor);
+    }
+
+    if (sizeof(GrPoint) != vertexSize) {
+        if (!geo.set(target, layout, vertexCount, 0)) {
+            GrPrintf("Failed to get space for vertices!");
+            return;
+        }
+        int texOffsets[GrDrawTarget::kMaxTexCoords];
+        int colorOffset;
+        int vsize = GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
+                                                            texOffsets,
+                                                            &colorOffset);
+        void* curVertex = geo.vertices();
+
+        for (int i = 0; i < vertexCount; ++i) {
+            *((GrPoint*)curVertex) = positions[i];
+
+            if (texOffsets[0] > 0) {
+                *(GrPoint*)((intptr_t)curVertex + texOffsets[0]) = texCoords[i];
+            }
+            if (colorOffset > 0) {
+                *(GrColor*)((intptr_t)curVertex + colorOffset) = colors[i];
+            }
+            curVertex = (void*)((intptr_t)curVertex + vsize);
+        }
+    } else {
+        target->setVertexSourceToArray(layout, positions, vertexCount);
+    }
+
+    if (NULL != indices) {
+        target->setIndexSourceToArray(indices, indexCount);
+        target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
+    } else {
+        target->drawNonIndexed(primitiveType, 0, vertexCount);
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::drawPath(const GrPaint& paint,
+                         GrPathIter* path,
+                         GrPathFill fill,
+                         const GrPoint* translate) {
+
+
+    GrDrawTarget* target = this->prepareToDraw(paint, kUnbuffered_DrawCategory);
+
+    GrDrawTarget::StageBitfield enabledStages = 0;
+    if (NULL != paint.getTexture()) {
+        enabledStages |= 1;
+    }
+    fPathRenderer->drawPath(target, enabledStages, path, fill, translate);
+}
+
+void GrContext::drawPath(const GrPaint& paint,
+                         const GrPath& path,
+                         GrPathFill fill,
+                         const GrPoint* translate) {
+    GrPath::Iter iter(path);
+    this->drawPath(paint, &iter, fill, translate);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::flush(int flagsBitfield) {
+    if (kDiscard_FlushBit & flagsBitfield) {
+        fDrawBuffer->reset();
+    } else {
+        flushDrawBuffer();
+    }
+
+    if (kForceCurrentRenderTarget_FlushBit & flagsBitfield) {
+        fGpu->forceRenderTargetFlush();
+    }
+}
+
+void GrContext::flushText() {
+    if (kText_DrawCategory == fLastDrawCategory) {
+        flushDrawBuffer();
+    }
+}
+
+void GrContext::flushDrawBuffer() {
+#if BATCH_RECT_TO_RECT || DEFER_TEXT_RENDERING
+    fDrawBuffer->playback(fGpu);
+    fDrawBuffer->reset();
+#endif
+}
+
+bool GrContext::readPixels(int left, int top, int width, int height,
+                           GrTexture::PixelConfig config, void* buffer) {
+    this->flush(true);
+    return fGpu->readPixels(left, top, width, height, config, buffer);
+}
+
+void GrContext::writePixels(int left, int top, int width, int height,
+                            GrTexture::PixelConfig config, const void* buffer,
+                            size_t stride) {
+
+    // TODO: when underlying api has a direct way to do this we should use it
+    // (e.g. glDrawPixels on desktop GL).
+
+    const GrGpu::TextureDesc desc = {
+        0, GrGpu::kNone_AALevel, width, height, config
+    };
+    GrTexture* texture = fGpu->createTexture(desc, buffer, stride);
+    if (NULL == texture) {
+        return;
+    }
+
+    this->flush(true);
+
+    GrAutoUnref                     aur(texture);
+    GrDrawTarget::AutoStateRestore  asr(fGpu);
+
+    GrMatrix matrix;
+    matrix.setTranslate(GrIntToScalar(left), GrIntToScalar(top));
+    fGpu->setViewMatrix(matrix);
+
+    fGpu->disableState(GrDrawTarget::kClip_StateBit);
+    fGpu->setAlpha(0xFF);
+    fGpu->setBlendFunc(kOne_BlendCoeff,
+                       kZero_BlendCoeff);
+    fGpu->setTexture(0, texture);
+
+    GrSamplerState sampler;
+    sampler.setClampNoFilter();
+    matrix.setScale(GR_Scalar1 / width, GR_Scalar1 / height);
+    sampler.setMatrix(matrix);
+    fGpu->setSamplerState(0, sampler);
+
+    GrVertexLayout layout = GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+    static const int VCOUNT = 4;
+
+    GrDrawTarget::AutoReleaseGeometry geo(fGpu, layout, VCOUNT, 0);
+    if (!geo.succeeded()) {
+        return;
+    }
+    ((GrPoint*)geo.vertices())->setIRectFan(0, 0, width, height);
+    fGpu->drawNonIndexed(kTriangleFan_PrimitiveType, 0, VCOUNT);
+}
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::SetPaint(const GrPaint& paint, GrDrawTarget* target) {
+    target->setTexture(0, paint.getTexture());
+    target->setSamplerState(0, paint.fSampler);
+    target->setColor(paint.fColor);
+
+    if (paint.fDither) {
+        target->enableState(GrDrawTarget::kDither_StateBit);
+    } else {
+        target->disableState(GrDrawTarget::kDither_StateBit);
+    }
+    if (paint.fAntiAlias) {
+        target->enableState(GrDrawTarget::kAntialias_StateBit);
+    } else {
+        target->disableState(GrDrawTarget::kAntialias_StateBit);
+    }
+    target->setBlendFunc(paint.fSrcBlendCoeff, paint.fDstBlendCoeff);
+}
+
+GrDrawTarget* GrContext::prepareToDraw(const GrPaint& paint,
+                                       DrawCategory category) {
+    if (category != fLastDrawCategory) {
+        flushDrawBuffer();
+        fLastDrawCategory = category;
+    }
+    SetPaint(paint, fGpu);
+    GrDrawTarget* target = fGpu;
+    switch (category) {
+    case kText_DrawCategory:
+#if DEFER_TEXT_RENDERING
+        target = fDrawBuffer;
+        fDrawBuffer->initializeDrawStateAndClip(*fGpu);
+#else
+        target = fGpu;
+#endif
+        break;
+    case kUnbuffered_DrawCategory:
+        target = fGpu;
+        break;
+    case kBuffered_DrawCategory:
+        target = fDrawBuffer;
+        fDrawBuffer->initializeDrawStateAndClip(*fGpu);
+        break;
+    }
+    return target;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrContext::resetContext() {
+    fGpu->markContextDirty();
+}
+
+void GrContext::setRenderTarget(GrRenderTarget* target) {
+    flush(false);
+    fGpu->setRenderTarget(target);
+}
+
+GrRenderTarget* GrContext::getRenderTarget() {
+    return fGpu->getRenderTarget();
+}
+
+const GrRenderTarget* GrContext::getRenderTarget() const {
+    return fGpu->getRenderTarget();
+}
+
+const GrMatrix& GrContext::getMatrix() const {
+    return fGpu->getViewMatrix();
+}
+
+void GrContext::setMatrix(const GrMatrix& m) {
+    fGpu->setViewMatrix(m);
+}
+
+void GrContext::concatMatrix(const GrMatrix& m) const {
+    fGpu->preConcatViewMatrix(m);
+}
+
+static inline intptr_t setOrClear(intptr_t bits, int shift, intptr_t pred) {
+    intptr_t mask = 1 << shift;
+    if (pred) {
+        bits |= mask;
+    } else {
+        bits &= ~mask;
+    }
+    return bits;
+}
+
+void GrContext::resetStats() {
+    fGpu->resetStats();
+}
+
+const GrGpu::Stats& GrContext::getStats() const {
+    return fGpu->getStats();
+}
+
+void GrContext::printStats() const {
+    fGpu->printStats();
+}
+
+GrContext::GrContext(GrGpu* gpu) {
+    fGpu = gpu;
+    fGpu->ref();
+    fTextureCache = new GrTextureCache(MAX_TEXTURE_CACHE_COUNT,
+                                       MAX_TEXTURE_CACHE_BYTES);
+    fFontCache = new GrFontCache(fGpu);
+
+    fLastDrawCategory = kUnbuffered_DrawCategory;
+
+#if DEFER_TEXT_RENDERING || BATCH_RECT_TO_RECT
+    fDrawBufferVBAllocPool =
+        new GrVertexBufferAllocPool(gpu, false,
+                                    DRAW_BUFFER_VBPOOL_BUFFER_SIZE,
+                                    DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS);
+    fDrawBufferIBAllocPool =
+        new GrIndexBufferAllocPool(gpu, false,
+                                   DRAW_BUFFER_IBPOOL_BUFFER_SIZE,
+                                   DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS);
+
+    fDrawBuffer = new GrInOrderDrawBuffer(fDrawBufferVBAllocPool,
+                                          fDrawBufferIBAllocPool);
+#else
+    fDrawBuffer = NULL;
+    fDrawBufferVBAllocPool = NULL;
+    fDrawBufferIBAllocPool = NULL;
+#endif
+
+#if BATCH_RECT_TO_RECT
+    fDrawBuffer->setQuadIndexBuffer(this->getQuadIndexBuffer());
+#endif
+    fPathRenderer = new GrDefaultPathRenderer(fGpu->supportsTwoSidedStencil(),
+                                              fGpu->supportsStencilWrapOps());
+}
+
+bool GrContext::finalizeTextureKey(GrTextureKey* key,
+                                   const GrSamplerState& sampler) const {
+    uint32_t bits = 0;
+    uint16_t width = key->width();
+    uint16_t height = key->height();
+
+
+    if (!fGpu->npotTextureTileSupport()) {
+        bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
+
+        bool tiled = (sampler.getWrapX() != GrSamplerState::kClamp_WrapMode) ||
+                     (sampler.getWrapY() != GrSamplerState::kClamp_WrapMode);
+
+        if (tiled && !isPow2) {
+            bits |= 1;
+            bits |= sampler.isFilter() ? 2 : 0;
+        }
+    }
+    key->finalize(bits);
+    return 0 != bits;
+}
+
+GrDrawTarget* GrContext::getTextTarget(const GrPaint& paint) {
+    GrDrawTarget* target;
+#if DEFER_TEXT_RENDERING
+    target = prepareToDraw(paint, kText_DrawCategory);
+#else
+    target = prepareToDraw(paint, kUnbuffered_DrawCategory);
+#endif
+    SetPaint(paint, target);
+    return target;
+}
+
+const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
+    return fGpu->getQuadIndexBuffer();
+}
diff --git a/gpu/src/GrDrawMesh.cpp b/gpu/src/GrDrawMesh.cpp
new file mode 100644
index 0000000..bd79005
--- /dev/null
+++ b/gpu/src/GrDrawMesh.cpp
@@ -0,0 +1,140 @@
+#include "GrMesh.h"
+#include "SkCanvas.h"
+
+GrMesh::GrMesh() : fPts(NULL), fCount(0), fIndices(NULL), fIndexCount(0) {}
+
+GrMesh::~GrMesh() {
+    delete[] fPts;
+    delete[] fIndices;
+}
+
+GrMesh& GrMesh::operator=(const GrMesh& src) {
+    delete[] fPts;
+    delete[] fIndices;
+
+    fBounds = src.fBounds;
+    fRows = src.fRows;
+    fCols = src.fCols;
+
+    fCount = src.fCount;
+    fPts = new SkPoint[fCount * 2];
+    fTex = fPts + fCount;
+    memcpy(fPts, src.fPts, fCount * 2 * sizeof(SkPoint));
+    
+    delete[] fIndices;
+    fIndexCount = src.fIndexCount;
+    fIndices = new uint16_t[fIndexCount];
+    memcpy(fIndices, src.fIndices, fIndexCount * sizeof(uint16_t));
+
+    return *this;
+}
+
+void GrMesh::init(const SkRect& bounds, int rows, int cols,
+                const SkRect& texture) {
+    SkASSERT(rows > 0 && cols > 0);
+
+    fBounds = bounds;
+    fRows = rows;
+    fCols = cols;
+
+    delete[] fPts;
+    fCount = (rows + 1) * (cols + 1);
+    fPts = new SkPoint[fCount * 2];
+    fTex = fPts + fCount;
+
+    delete[] fIndices;
+    fIndexCount = rows * cols * 6;
+    fIndices = new uint16_t[fIndexCount];
+    
+    SkPoint* pts = fPts;
+    const SkScalar dx = bounds.width() / rows;
+    const SkScalar dy = bounds.height() / cols;
+    SkPoint* tex = fTex;
+    const SkScalar dtx = texture.width() / rows;
+    const SkScalar dty = texture.height() / cols;
+    uint16_t* idx = fIndices;
+    int index = 0;
+    for (int y = 0; y <= cols; y++) {
+        for (int x = 0; x <= rows; x++) {
+            pts->set(bounds.fLeft + x*dx, bounds.fTop + y*dy);
+            pts += 1;
+            tex->set(texture.fLeft + x*dtx, texture.fTop + y*dty);
+            tex += 1;
+            
+            if (y < cols && x < rows) {
+                *idx++ = index;
+                *idx++ = index + rows + 1;
+                *idx++ = index + 1;
+
+                *idx++ = index + 1;
+                *idx++ = index + rows + 1;
+                *idx++ = index + rows + 2;
+                
+                index += 1;
+            }
+        }
+        index += 1;
+    }
+}
+
+void GrMesh::draw(SkCanvas* canvas, const SkPaint& paint) {
+    canvas->drawVertices(SkCanvas::kTriangles_VertexMode, fCount,
+                         fPts, fTex, NULL, NULL, fIndices, fIndexCount,
+                         paint);
+}
+
+/////////////////////////////////////////////
+
+#include "SkBoundaryPatch.h"
+#include "SkMeshUtils.h"
+
+static SkPoint SkPointInterp(const SkPoint& a, const SkPoint& b, SkScalar t) {
+    return SkPoint::Make(SkScalarInterp(a.fX, b.fX, t),
+                         SkScalarInterp(a.fY, b.fY, t));
+}
+
+static void set_cubic(SkPoint pts[4], SkScalar x0, SkScalar y0,
+                      SkScalar x3, SkScalar y3, SkScalar scale = 1) {
+    SkPoint tmp, tmp2;
+    
+    pts[0].set(x0, y0);
+    pts[3].set(x3, y3);
+    
+    tmp = SkPointInterp(pts[0], pts[3], SK_Scalar1/3);
+    tmp2 = pts[0] - tmp;
+    tmp2.rotateCW();
+    tmp2.scale(scale);
+    pts[1] = tmp + tmp2;
+    
+    tmp = SkPointInterp(pts[0], pts[3], 2*SK_Scalar1/3);
+    tmp2 = pts[3] - tmp;
+    tmp2.rotateCW();
+    tmp2.scale(scale);
+    pts[2] = tmp + tmp2;
+}
+
+void test_patch(SkCanvas* canvas, const SkBitmap& bm, SkScalar scale) {
+    const float w = bm.width();
+    const float h = bm.height();
+    SkCubicBoundary cubic;    
+    set_cubic(cubic.fPts + 0, 0, 0, w, 0, scale);
+    set_cubic(cubic.fPts + 3, w, 0, w, h, scale);
+    set_cubic(cubic.fPts + 6, w, h, 0, h, -scale);
+    set_cubic(cubic.fPts + 9, 0, h, 0, 0, scale);
+    
+    SkBoundaryPatch patch;
+    patch.setBoundary(&cubic);
+    
+    const int Rows = 16;
+    const int Cols = 16;
+    SkPoint pts[Rows * Cols];
+    patch.evalPatch(pts, Rows, Cols);
+    
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paint.setFilterBitmap(true);
+
+    SkMeshUtils::Draw(canvas, bm, Rows, Cols, pts, NULL, paint);
+}
+
+
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
new file mode 100644
index 0000000..7973361
--- /dev/null
+++ b/gpu/src/GrDrawTarget.cpp
@@ -0,0 +1,597 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrDrawTarget.h"
+#include "GrGpuVertex.h"
+#include "GrTexture.h"
+
+// recursive helper for creating mask with all the tex coord bits set for
+// one stage
+template <int N>
+static int stage_mask_recur(int stage) {
+    return GrDrawTarget::StageTexCoordVertexLayoutBit(stage, N) |
+           stage_mask_recur<N+1>(stage);
+}
+template<> // linux build doesn't like static on specializations
+int stage_mask_recur<GrDrawTarget::kNumStages>(int) { return 0; }
+
+// mask of all tex coord indices for one stage
+static int stage_tex_coord_mask(int stage) {
+    return stage_mask_recur<0>(stage);
+}
+
+// mask of all bits relevant to one stage
+static int stage_mask(int stage) {
+    return stage_tex_coord_mask(stage) |
+           GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(stage);
+}
+
+// recursive helper for creating mask of with all bits set relevant to one
+// texture coordinate index
+template <int N>
+static int tex_coord_mask_recur(int texCoordIdx) {
+    return GrDrawTarget::StageTexCoordVertexLayoutBit(N, texCoordIdx) |
+           tex_coord_mask_recur<N+1>(texCoordIdx);
+}
+template<> // linux build doesn't like static on specializations
+int tex_coord_mask_recur<GrDrawTarget::kMaxTexCoords>(int) { return 0; }
+
+// mask of all bits relevant to one texture coordinate index
+static int tex_coord_idx_mask(int texCoordIdx) {
+    return tex_coord_mask_recur<0>(texCoordIdx);
+}
+
+bool check_layout(GrVertexLayout layout) {
+    // can only have 1 or 0 bits set for each stage.
+    for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
+        int stageBits = layout & stage_mask(s);
+        if (stageBits && !GrIsPow2(stageBits)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+size_t GrDrawTarget::VertexSize(GrVertexLayout vertexLayout) {
+    GrAssert(check_layout(vertexLayout));
+
+    size_t vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
+                        sizeof(GrGpuTextVertex) :
+                        sizeof(GrPoint);
+
+    size_t size = vecSize; // position
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        if (tex_coord_idx_mask(t) & vertexLayout) {
+            size += vecSize;
+        }
+    }
+    if (vertexLayout & kColor_VertexLayoutBit) {
+        size += sizeof(GrColor);
+    }
+    return size;
+}
+
+int GrDrawTarget::VertexStageCoordOffset(int stage, GrVertexLayout vertexLayout) {
+    GrAssert(check_layout(vertexLayout));
+    if (StagePosAsTexCoordVertexLayoutBit(stage) & vertexLayout) {
+        return 0;
+    }
+    int tcIdx = VertexTexCoordsForStage(stage, vertexLayout);
+    if (tcIdx >= 0) {
+
+        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
+                                    sizeof(GrGpuTextVertex) :
+                                    sizeof(GrPoint);
+        int offset = vecSize; // position
+        // figure out how many tex coordinates are present and precede this one.
+        for (int t = 0; t < tcIdx; ++t) {
+            if (tex_coord_idx_mask(t) & vertexLayout) {
+                offset += vecSize;
+            }
+        }
+        return offset;
+    }
+
+    return -1;
+}
+
+int  GrDrawTarget::VertexColorOffset(GrVertexLayout vertexLayout) {
+    GrAssert(check_layout(vertexLayout));
+
+    if (vertexLayout & kColor_VertexLayoutBit) {
+        int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
+                                    sizeof(GrGpuTextVertex) :
+                                    sizeof(GrPoint);
+        int offset = vecSize; // position
+        // figure out how many tex coordinates are present and precede this one.
+        for (int t = 0; t < kMaxTexCoords; ++t) {
+            if (tex_coord_idx_mask(t) & vertexLayout) {
+                offset += vecSize;
+            }
+        }
+        return offset;
+    }
+    return -1;
+}
+
+int GrDrawTarget::VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
+                                             int texCoordOffsetsByIdx[kMaxTexCoords],
+                                             int* colorOffset) {
+    GrAssert(check_layout(vertexLayout));
+
+    GrAssert(NULL != texCoordOffsetsByIdx);
+    GrAssert(NULL != colorOffset);
+
+    int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
+                                                    sizeof(GrGpuTextVertex) :
+                                                    sizeof(GrPoint);
+    int size = vecSize; // position
+
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        if (tex_coord_idx_mask(t) & vertexLayout) {
+            texCoordOffsetsByIdx[t] = size;
+            size += vecSize;
+        } else {
+            texCoordOffsetsByIdx[t] = -1;
+        }
+    }
+    if (kColor_VertexLayoutBit & vertexLayout) {
+        *colorOffset = size;
+        size += sizeof(GrColor);
+    } else {
+        *colorOffset = -1;
+    }
+    return size;
+}
+
+int GrDrawTarget::VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
+                                              int texCoordOffsetsByStage[kNumStages],
+                                              int* colorOffset) {
+    GrAssert(check_layout(vertexLayout));
+
+    GrAssert(NULL != texCoordOffsetsByStage);
+    GrAssert(NULL != colorOffset);
+
+    int texCoordOffsetsByIdx[kMaxTexCoords];
+    int size = VertexSizeAndOffsetsByIdx(vertexLayout,
+                                         texCoordOffsetsByIdx,
+                                         colorOffset);
+    for (int s = 0; s < kNumStages; ++s) {
+        int tcIdx;
+        if (StagePosAsTexCoordVertexLayoutBit(s) & vertexLayout) {
+            texCoordOffsetsByStage[s] = 0;
+        } else if ((tcIdx = VertexTexCoordsForStage(s, vertexLayout)) >= 0) {
+            texCoordOffsetsByStage[s] = texCoordOffsetsByIdx[tcIdx];
+        } else {
+            texCoordOffsetsByStage[s] = -1;
+        }
+    }
+    return size;
+}
+
+bool GrDrawTarget::VertexUsesStage(int stage, GrVertexLayout vertexLayout) {
+    GrAssert(stage < kNumStages);
+    GrAssert(check_layout(vertexLayout));
+    return !!(stage_mask(stage) & vertexLayout);
+}
+
+bool GrDrawTarget::VertexUsesTexCoordIdx(int coordIndex,
+                                         GrVertexLayout vertexLayout) {
+    GrAssert(coordIndex < kMaxTexCoords);
+    GrAssert(check_layout(vertexLayout));
+    return !!(tex_coord_idx_mask(coordIndex) & vertexLayout);
+}
+
+int GrDrawTarget::VertexTexCoordsForStage(int stage, GrVertexLayout vertexLayout) {
+    GrAssert(stage < kNumStages);
+    GrAssert(check_layout(vertexLayout));
+    int bit = vertexLayout & stage_tex_coord_mask(stage);
+    if (bit) {
+        // figure out which set of texture coordates is used
+        // bits are ordered T0S0, T0S1, T0S2, ..., T1S0, T1S1, ...
+        // and start at bit 0.
+        GR_STATIC_ASSERT(sizeof(GrVertexLayout) <= sizeof(uint32_t));
+        return (32 - Gr_clz(bit) - 1) / kNumStages;
+    }
+    return -1;
+}
+
+void GrDrawTarget::VertexLayoutUnitTest() {
+    // not necessarily exhaustive
+    static bool run;
+    if (!run) {
+        run = true;
+        for (int s = 0; s < kNumStages; ++s) {
+
+            GrAssert(!VertexUsesStage(s, 0));
+            GrAssert(-1 == VertexStageCoordOffset(s, 0));
+            GrVertexLayout stageMask = 0;
+            for (int t = 0; t < kMaxTexCoords; ++t) {
+                stageMask |= StageTexCoordVertexLayoutBit(s,t);
+            }
+            GrAssert(1 == kMaxTexCoords || !check_layout(stageMask));
+            GrAssert(stage_tex_coord_mask(s) == stageMask);
+            stageMask |= StagePosAsTexCoordVertexLayoutBit(s);
+            GrAssert(stage_mask(s) == stageMask);
+            GrAssert(!check_layout(stageMask));
+        }
+        for (int t = 0; t < kMaxTexCoords; ++t) {
+            GrVertexLayout tcMask = 0;
+            GrAssert(!VertexUsesTexCoordIdx(t, 0));
+            for (int s = 0; s < kNumStages; ++s) {
+                tcMask |= StageTexCoordVertexLayoutBit(s,t);
+                GrAssert(VertexUsesStage(s, tcMask));
+                GrAssert(sizeof(GrPoint) == VertexStageCoordOffset(s, tcMask));
+                GrAssert(VertexUsesTexCoordIdx(t, tcMask));
+                GrAssert(2*sizeof(GrPoint) == VertexSize(tcMask));
+                GrAssert(t == VertexTexCoordsForStage(s, tcMask));
+                for (int s2 = s + 1; s2 < kNumStages; ++s2) {
+                    GrAssert(-1 == VertexStageCoordOffset(s2, tcMask));
+                    GrAssert(!VertexUsesStage(s2, tcMask));
+                    GrAssert(-1 == VertexTexCoordsForStage(s2, tcMask));
+
+                #if GR_DEBUG
+                    GrVertexLayout posAsTex = tcMask | StagePosAsTexCoordVertexLayoutBit(s2);
+                #endif
+                    GrAssert(0 == VertexStageCoordOffset(s2, posAsTex));
+                    GrAssert(VertexUsesStage(s2, posAsTex));
+                    GrAssert(2*sizeof(GrPoint) == VertexSize(posAsTex));
+                    GrAssert(-1 == VertexTexCoordsForStage(s2, posAsTex));
+                }
+            #if GR_DEBUG
+                GrVertexLayout withColor = tcMask | kColor_VertexLayoutBit;
+            #endif
+                GrAssert(2*sizeof(GrPoint) == VertexColorOffset(withColor));
+                GrAssert(2*sizeof(GrPoint) + sizeof(GrColor) == VertexSize(withColor));
+            }
+            GrAssert(tex_coord_idx_mask(t) == tcMask);
+            GrAssert(check_layout(tcMask));
+
+            int stageOffsets[kNumStages];
+            int colorOffset;
+            int size;
+            size = VertexSizeAndOffsetsByStage(tcMask, stageOffsets, &colorOffset);
+            GrAssert(2*sizeof(GrPoint) == size);
+            GrAssert(-1 == colorOffset);
+            for (int s = 0; s < kNumStages; ++s) {
+                GrAssert(VertexUsesStage(s, tcMask));
+                GrAssert(sizeof(GrPoint) == stageOffsets[s]);
+                GrAssert(sizeof(GrPoint) == VertexStageCoordOffset(s, tcMask));
+            }
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrDrawTarget::GrDrawTarget() {
+#if GR_DEBUG
+    VertexLayoutUnitTest();
+#endif
+    fReservedGeometry.fLocked = false;
+#if GR_DEBUG
+    fReservedGeometry.fVertexCount  = ~0;
+    fReservedGeometry.fIndexCount   = ~0;
+#endif
+    fGeometrySrc.fVertexSrc = kReserved_GeometrySrcType;
+    fGeometrySrc.fIndexSrc  = kReserved_GeometrySrcType;
+}
+
+void GrDrawTarget::setClip(const GrClip& clip) {
+    clipWillBeSet(clip);
+    fClip = clip;
+}
+
+const GrClip& GrDrawTarget::getClip() const {
+    return fClip;
+}
+
+void GrDrawTarget::setTexture(int stage, GrTexture* tex) {
+    GrAssert(stage >= 0 && stage < kNumStages);
+    fCurrDrawState.fTextures[stage] = tex;
+}
+
+const GrTexture* GrDrawTarget::getTexture(int stage) const {
+    GrAssert(stage >= 0 && stage < kNumStages);
+    return fCurrDrawState.fTextures[stage];
+}
+
+GrTexture* GrDrawTarget::getTexture(int stage) {
+    GrAssert(stage >= 0 && stage < kNumStages);
+    return fCurrDrawState.fTextures[stage];
+}
+
+void GrDrawTarget::setRenderTarget(GrRenderTarget* target) {
+    fCurrDrawState.fRenderTarget = target;
+}
+
+const GrRenderTarget* GrDrawTarget::getRenderTarget() const {
+    return fCurrDrawState.fRenderTarget;
+}
+
+GrRenderTarget* GrDrawTarget::getRenderTarget() {
+    return fCurrDrawState.fRenderTarget;
+}
+
+void GrDrawTarget::setViewMatrix(const GrMatrix& m) {
+    fCurrDrawState.fViewMatrix = m;
+}
+
+void GrDrawTarget::preConcatViewMatrix(const GrMatrix& matrix) {
+    fCurrDrawState.fViewMatrix.preConcat(matrix);
+}
+
+const GrMatrix& GrDrawTarget::getViewMatrix() const {
+    return fCurrDrawState.fViewMatrix;
+}
+
+bool GrDrawTarget::getViewInverse(GrMatrix* matrix) const {
+    // Mike:  Can we cache this somewhere?
+    // Brian: Sure, do we use it often?
+
+    GrMatrix inverse;
+    if (fCurrDrawState.fViewMatrix.invert(&inverse)) {
+        if (matrix) {
+            *matrix = inverse;
+        }
+        return true;
+    }
+    return false;
+}
+
+void GrDrawTarget::setSamplerState(int stage, const GrSamplerState& state) {
+    GrAssert(stage >= 0 && stage < kNumStages);
+    fCurrDrawState.fSamplerStates[stage] = state;
+}
+
+void GrDrawTarget::enableState(uint32_t bits) {
+    fCurrDrawState.fFlagBits |= bits;
+}
+
+void GrDrawTarget::disableState(uint32_t bits) {
+    fCurrDrawState.fFlagBits &= ~(bits);
+}
+
+void GrDrawTarget::setBlendFunc(GrBlendCoeff srcCoef,
+                                GrBlendCoeff dstCoef) {
+    fCurrDrawState.fSrcBlend = srcCoef;
+    fCurrDrawState.fDstBlend = dstCoef;
+}
+
+void GrDrawTarget::setColor(GrColor c) {
+    fCurrDrawState.fColor = c;
+}
+
+void GrDrawTarget::setAlpha(uint8_t a) {
+    this->setColor((a << 24) | (a << 16) | (a << 8) | a);
+}
+
+void GrDrawTarget::saveCurrentDrawState(SavedDrawState* state) const {
+    state->fState = fCurrDrawState;
+}
+
+void GrDrawTarget::restoreDrawState(const SavedDrawState& state) {
+    fCurrDrawState = state.fState;
+}
+
+void GrDrawTarget::copyDrawState(const GrDrawTarget& srcTarget) {
+    fCurrDrawState = srcTarget.fCurrDrawState;
+}
+
+
+bool GrDrawTarget::reserveAndLockGeometry(GrVertexLayout    vertexLayout,
+                                          uint32_t          vertexCount,
+                                          uint32_t          indexCount,
+                                          void**            vertices,
+                                          void**            indices) {
+    GrAssert(!fReservedGeometry.fLocked);
+    fReservedGeometry.fVertexCount  = vertexCount;
+    fReservedGeometry.fIndexCount   = indexCount;
+
+    fReservedGeometry.fLocked = acquireGeometryHelper(vertexLayout,
+                                                      vertices,
+                                                      indices);
+    if (fReservedGeometry.fLocked) {
+        if (vertexCount) {
+            fGeometrySrc.fVertexSrc = kReserved_GeometrySrcType;
+            fGeometrySrc.fVertexLayout = vertexLayout;
+        }
+        if (indexCount) {
+            fGeometrySrc.fIndexSrc = kReserved_GeometrySrcType;
+        }
+    }
+    return fReservedGeometry.fLocked;
+}
+
+bool GrDrawTarget::geometryHints(GrVertexLayout vertexLayout,
+                                 int32_t* vertexCount,
+                                 int32_t* indexCount) const {
+    GrAssert(!fReservedGeometry.fLocked);
+    if (NULL != vertexCount) {
+        *vertexCount = -1;
+    }
+    if (NULL != indexCount) {
+        *indexCount = -1;
+    }
+    return false;
+}
+
+void GrDrawTarget::releaseReservedGeometry() {
+    GrAssert(fReservedGeometry.fLocked);
+    releaseGeometryHelper();
+    fReservedGeometry.fLocked = false;
+}
+
+void GrDrawTarget::setVertexSourceToArray(GrVertexLayout vertexLayout,
+                                          const void* vertexArray,
+                                          int vertexCount) {
+    fGeometrySrc.fVertexSrc = kArray_GeometrySrcType;
+    fGeometrySrc.fVertexLayout = vertexLayout;
+    setVertexSourceToArrayHelper(vertexArray, vertexCount);
+}
+
+void GrDrawTarget::setIndexSourceToArray(const void* indexArray,
+                                         int indexCount) {
+    fGeometrySrc.fIndexSrc = kArray_GeometrySrcType;
+    setIndexSourceToArrayHelper(indexArray, indexCount);
+}
+
+void GrDrawTarget::setVertexSourceToBuffer(GrVertexLayout vertexLayout,
+                                           const GrVertexBuffer* buffer) {
+    fGeometrySrc.fVertexSrc    = kBuffer_GeometrySrcType;
+    fGeometrySrc.fVertexBuffer = buffer;
+    fGeometrySrc.fVertexLayout = vertexLayout;
+}
+
+void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
+    fGeometrySrc.fIndexSrc     = kBuffer_GeometrySrcType;
+    fGeometrySrc.fIndexBuffer  = buffer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool GrDrawTarget::canDisableBlend() const {
+    if ((kOne_BlendCoeff == fCurrDrawState.fSrcBlend) &&
+        (kZero_BlendCoeff == fCurrDrawState.fDstBlend)) {
+            return true;
+    }
+
+    // If we have vertex color without alpha then we can't force blend off
+    if ((fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit) ||
+         0xff != GrColorUnpackA(fCurrDrawState.fColor)) {
+        return false;
+    }
+
+    // If the src coef will always be 1...
+    if (kSA_BlendCoeff != fCurrDrawState.fSrcBlend &&
+        kOne_BlendCoeff != fCurrDrawState.fSrcBlend) {
+        return false;
+    }
+
+    // ...and the dst coef is always 0...
+    if (kISA_BlendCoeff != fCurrDrawState.fDstBlend &&
+        kZero_BlendCoeff != fCurrDrawState.fDstBlend) {
+        return false;
+    }
+
+    // ...and there isn't a texture with an alpha channel...
+    for (int s = 0; s < kNumStages; ++s) {
+        if (VertexUsesStage(s, fGeometrySrc.fVertexLayout)) {
+            GrAssert(NULL != fCurrDrawState.fTextures[s]);
+            GrTexture::PixelConfig config = fCurrDrawState.fTextures[s]->config();
+
+            if (GrTexture::kRGB_565_PixelConfig != config &&
+                GrTexture::kRGBX_8888_PixelConfig != config) {
+                return false;
+            }
+        }
+    }
+
+    // ...then we disable blend.
+    return true;
+}
+///////////////////////////////////////////////////////////////////////////////
+void GrDrawTarget::drawRect(const GrRect& rect, 
+                            const GrMatrix* matrix,
+                            StageBitfield stageEnableBitfield,
+                            const GrRect* srcRects[],
+                            const GrMatrix* srcMatrices[]) {
+    GrVertexLayout layout = GetRectVertexLayout(stageEnableBitfield, srcRects);
+
+    AutoReleaseGeometry geo(this, layout, 4, 0);
+
+    SetRectVertices(rect, matrix, srcRects, 
+                    srcMatrices, layout, geo.vertices());
+
+    drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+}
+
+GrVertexLayout GrDrawTarget::GetRectVertexLayout(StageBitfield stageEnableBitfield, 
+                                                 const GrRect* srcRects[]) {
+    GrVertexLayout layout = 0;
+
+    for (int i = 0; i < kNumStages; ++i) {
+        int numTC = 0;
+        if (stageEnableBitfield & (1 << i)) {
+            if (NULL != srcRects && NULL != srcRects[i]) {
+                layout |= StageTexCoordVertexLayoutBit(i, numTC);
+                ++numTC;
+            } else {
+                layout |= StagePosAsTexCoordVertexLayoutBit(i);
+            }
+        }
+    }
+    return layout;
+}
+void GrDrawTarget::SetRectVertices(const GrRect& rect,
+                                   const GrMatrix* matrix, 
+                                   const GrRect* srcRects[], 
+                                   const GrMatrix* srcMatrices[],
+                                   GrVertexLayout layout, 
+                                   void* vertices) {
+#if GR_DEBUG
+    // check that the layout and srcRects agree
+    for (int i = 0; i < kNumStages; ++i) {
+        if (VertexTexCoordsForStage(i, layout) >= 0) {
+            GR_DEBUGASSERT(NULL != srcRects && NULL != srcRects[i]);
+        } else {
+            GR_DEBUGASSERT(NULL == srcRects || NULL == srcRects[i]);
+        }
+    }
+#endif
+
+    int stageOffsets[kNumStages];
+    int colorOffset;
+    int vsize = VertexSizeAndOffsetsByStage(layout, stageOffsets, &colorOffset);
+    GrAssert(-1 == colorOffset);
+
+    GrTCast<GrPoint*>(vertices)->setRectFan(rect.fLeft, rect.fTop, 
+                                            rect.fRight, rect.fBottom,
+                                            vsize);
+    if (NULL != matrix) {
+        matrix->mapPointsWithStride(GrTCast<GrPoint*>(vertices), vsize, 4);
+    }
+
+    for (int i = 0; i < kNumStages; ++i) {
+        if (stageOffsets[i] > 0) {
+            GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(vertices) + 
+                                                stageOffsets[i]);
+            coords->setRectFan(srcRects[i]->fLeft, srcRects[i]->fTop,
+                               srcRects[i]->fRight, srcRects[i]->fBottom, 
+                               vsize);
+            if (NULL != srcMatrices && NULL != srcMatrices[i]) {
+                srcMatrices[i]->mapPointsWithStride(coords, vsize, 4);
+            }
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target) {
+    fDrawTarget = target;
+    if (NULL != fDrawTarget) {
+        fDrawTarget->saveCurrentDrawState(&fDrawState);
+    }
+}
+
+GrDrawTarget::AutoStateRestore::~AutoStateRestore() {
+    if (NULL != fDrawTarget) {
+        fDrawTarget->restoreDrawState(fDrawState);
+    }
+}
+
diff --git a/gpu/src/GrGLIndexBuffer.cpp b/gpu/src/GrGLIndexBuffer.cpp
new file mode 100644
index 0000000..2dc4154
--- /dev/null
+++ b/gpu/src/GrGLIndexBuffer.cpp
@@ -0,0 +1,125 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrGLIndexBuffer.h"
+#include "GrGpuGL.h"
+
+GrGLIndexBuffer::GrGLIndexBuffer(GLuint id, GrGpuGL* gl, size_t sizeInBytes,
+                                   bool dynamic) :
+                                INHERITED(sizeInBytes, dynamic),
+                                fGL(gl),
+                                fBufferID(id),
+                                fLockPtr(NULL) {
+}
+
+GrGLIndexBuffer::~GrGLIndexBuffer() {
+    // make sure we've not been abandoned
+    if (fBufferID) {
+        fGL->notifyIndexBufferDelete(this);
+        GR_GL(DeleteBuffers(1, &fBufferID));
+    }
+}
+
+void GrGLIndexBuffer::bind() const {
+    GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, fBufferID));
+    fGL->notifyIndexBufferBind(this);
+}
+
+GLuint GrGLIndexBuffer::bufferID() const {
+    return fBufferID;
+}
+
+void GrGLIndexBuffer::abandon() {
+    fBufferID = 0;
+    fGL = NULL;
+    fLockPtr = NULL;
+}
+
+void* GrGLIndexBuffer::lock() {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (fGL->supportsBufferLocking()) {
+        bind();
+        // Let driver know it can discard the old data
+        GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, size(), NULL,
+                         dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW));
+        fLockPtr = GR_GLEXT(fGL->extensions(),
+                            MapBuffer(GL_ELEMENT_ARRAY_BUFFER, GR_WRITE_ONLY));
+
+        return fLockPtr;
+    }
+    return NULL;
+}
+
+void* GrGLIndexBuffer::lockPtr() const {
+    return fLockPtr;
+}
+
+void GrGLIndexBuffer::unlock() {
+    GrAssert(fBufferID);
+    GrAssert(isLocked());
+    GrAssert(fGL->supportsBufferLocking());
+
+    bind();
+    GR_GLEXT(fGL->extensions(), UnmapBuffer(GL_ELEMENT_ARRAY_BUFFER));
+    fLockPtr = NULL;
+}
+
+bool GrGLIndexBuffer::isLocked() const {
+    GrAssert(fBufferID);
+#if GR_DEBUG
+    if (fGL->supportsBufferLocking()) {
+        bind();
+        GLint mapped;
+        GR_GL(GetBufferParameteriv(GL_ELEMENT_ARRAY_BUFFER,
+                                   GR_BUFFER_MAPPED, &mapped));
+        GrAssert(!!mapped == !!fLockPtr);
+    }
+#endif
+    return NULL != fLockPtr;
+}
+
+bool GrGLIndexBuffer::updateData(const void* src, size_t srcSizeInBytes) {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (srcSizeInBytes > size()) {
+        return false;
+    }
+    bind();
+    GLenum usage = dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
+    if (size() == srcSizeInBytes) {
+        GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, srcSizeInBytes, src, usage));
+    } else {
+        GR_GL(BufferData(GL_ELEMENT_ARRAY_BUFFER, size(), NULL, usage));
+        GR_GL(BufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, srcSizeInBytes, src));
+    }
+    return true;
+}
+
+bool GrGLIndexBuffer::updateSubData(const void* src,
+                                    size_t srcSizeInBytes,
+                                    size_t offset) {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (srcSizeInBytes + offset > size()) {
+        return false;
+    }
+    bind();
+    GR_GL(BufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, srcSizeInBytes, src));
+    return true;
+}
+
diff --git a/gpu/src/GrGLTexture.cpp b/gpu/src/GrGLTexture.cpp
new file mode 100644
index 0000000..1acb871
--- /dev/null
+++ b/gpu/src/GrGLTexture.cpp
@@ -0,0 +1,173 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrGLTexture.h"
+#include "GrGpuGL.h"
+
+GrGLRenderTarget::GrGLRenderTarget(const GLRenderTargetIDs& ids,
+                                   GrGLTexID* texID,
+                                   GLuint stencilBits,
+                                   const GrGLIRect& viewport,
+                                   GrGLTexture* texture,
+                                   GrGpuGL* gl) : INHERITED(texture,
+                                                            viewport.fWidth,
+                                                            viewport.fHeight,
+                                                            stencilBits) {
+    fGL                     = gl;
+    fRTFBOID                = ids.fRTFBOID;
+    fTexFBOID               = ids.fTexFBOID;
+    fStencilRenderbufferID  = ids.fStencilRenderbufferID;
+    fMSColorRenderbufferID  = ids.fMSColorRenderbufferID;
+    fNeedsResolve           = false;
+    fViewport               = viewport;
+    fOwnIDs                 = ids.fOwnIDs;
+    fTexIDObj               = texID;
+    GrSafeRef(fTexIDObj);
+}
+
+GrGLRenderTarget::~GrGLRenderTarget() {
+    fGL->notifyRenderTargetDelete(this);
+    if (fOwnIDs) {
+        if (fTexFBOID) {
+            GR_GLEXT(fGL->extensions(), DeleteFramebuffers(1, &fTexFBOID));
+        }
+        if (fRTFBOID && fRTFBOID != fTexFBOID) {
+            GR_GLEXT(fGL->extensions(), DeleteFramebuffers(1, &fRTFBOID));
+        }
+        if (fStencilRenderbufferID) {
+            GR_GLEXT(fGL->extensions(), DeleteRenderbuffers(1, &fStencilRenderbufferID));
+        }
+        if (fMSColorRenderbufferID) {
+            GR_GLEXT(fGL->extensions(), DeleteRenderbuffers(1, &fMSColorRenderbufferID));
+        }
+    }
+    GrSafeUnref(fTexIDObj);
+}
+
+void GrGLRenderTarget::abandon() {
+    fRTFBOID                = 0;
+    fTexFBOID               = 0;
+    fStencilRenderbufferID  = 0;
+    fMSColorRenderbufferID  = 0;
+    if (NULL != fTexIDObj) {
+        fTexIDObj->abandon();
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+const GLenum GrGLTexture::gWrapMode2GLWrap[] = {
+    GL_CLAMP_TO_EDGE,
+    GL_REPEAT,
+#ifdef GL_MIRRORED_REPEAT
+    GL_MIRRORED_REPEAT
+#else
+    GL_REPEAT       // GL_MIRRORED_REPEAT not supported :(
+#endif
+};
+
+
+GrGLTexture::GrGLTexture(const GLTextureDesc& textureDesc,
+                         const GLRenderTargetIDs& rtIDs,
+                         const TexParams& initialTexParams,
+                         GrGpuGL* gl)
+        : INHERITED(textureDesc.fContentWidth, 
+                    textureDesc.fContentHeight, 
+                    textureDesc.fFormat) {
+
+    fTexParams          = initialTexParams;
+    fTexIDObj           = new GrGLTexID(textureDesc.fTextureID);
+    fUploadFormat       = textureDesc.fUploadFormat;
+    fUploadByteCount    = textureDesc.fUploadByteCount;
+    fUploadType         = textureDesc.fUploadType;
+    fOrientation        = textureDesc.fOrientation;
+    fAllocWidth         = textureDesc.fAllocWidth;
+    fAllocHeight        = textureDesc.fAllocHeight;
+    fScaleX             = GrIntToScalar(textureDesc.fContentWidth) /
+                            textureDesc.fAllocWidth;
+    fScaleY             = GrIntToScalar(textureDesc.fContentHeight) /
+                            textureDesc.fAllocHeight;
+    fRenderTarget       = NULL;
+    fGpuGL              = gl;
+
+    GrAssert(0 != textureDesc.fTextureID);
+
+    if (rtIDs.fTexFBOID) {
+        // we render to the top left
+        GrGLIRect vp;
+        vp.fLeft   = 0;
+        vp.fWidth  = textureDesc.fContentWidth;
+        vp.fHeight = textureDesc.fContentHeight;
+        vp.fBottom = textureDesc.fAllocHeight - textureDesc.fContentHeight;
+
+        fRenderTarget = new GrGLRenderTarget(rtIDs, fTexIDObj,
+                                             textureDesc.fStencilBits,
+                                             vp, this, gl);
+    }
+}
+
+GrGLTexture::~GrGLTexture() {
+    fGpuGL->notifyTextureDelete(this);
+    fTexIDObj->unref();
+    GrSafeUnref(fRenderTarget);
+}
+
+void GrGLTexture::abandon() {
+    fTexIDObj->abandon();
+    if (NULL != fRenderTarget) {
+        fRenderTarget->abandon();
+    }
+}
+
+GrRenderTarget* GrGLTexture::asRenderTarget() {
+    return (GrRenderTarget*)fRenderTarget;
+}
+
+void GrGLTexture::releaseRenderTarget() {
+    GrSafeUnref(fRenderTarget);
+    fRenderTarget = NULL;
+}
+
+void GrGLTexture::uploadTextureData(uint32_t x,
+                                    uint32_t y,
+                                    uint32_t width,
+                                    uint32_t height,
+                                    const void* srcData) {
+    
+    fGpuGL->setSpareTextureUnit();
+
+    // glCompressedTexSubImage2D doesn't support any formats
+    // (at least without extensions)
+    GrAssert(fUploadFormat != GR_PALETTE8_RGBA8);
+
+    // If we need to update textures that are created upside down
+    // then we have to modify this code to flip the srcData
+    GrAssert(kTopDown_Orientation == fOrientation);
+    GR_GL(BindTexture(GL_TEXTURE_2D, fTexIDObj->id()));
+    GR_GL(PixelStorei(GL_UNPACK_ALIGNMENT, fUploadByteCount));
+    GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, 
+                        fUploadFormat, fUploadType, srcData));
+
+}
+
+intptr_t GrGLTexture::getTextureHandle() {
+    return fTexIDObj->id();
+}
+
+
+
diff --git a/gpu/src/GrGLUtil.cpp b/gpu/src/GrGLUtil.cpp
new file mode 100644
index 0000000..e128d35
--- /dev/null
+++ b/gpu/src/GrGLUtil.cpp
@@ -0,0 +1,255 @@
+/*
+ Copyright 2010 Google Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#include "GrGLConfig.h"
+#include "GrTypes.h"
+#include <stdio.h>
+
+bool has_gl_extension(const char* ext) {
+    const char* glstr = (const char*) glGetString(GL_EXTENSIONS);
+
+    int extLength = strlen(ext);
+
+    while (true) {
+        int n = strcspn(glstr, " ");
+        if (n == extLength && 0 == strncmp(ext, glstr, n)) {
+            return true;
+        }
+        if (0 == glstr[n]) {
+            return false;
+        }
+        glstr += n+1;
+    }
+}
+
+void gl_version(int* major, int* minor) {
+    const char* v = (const char*) glGetString(GL_VERSION);
+    if (NULL == v) {
+        GrAssert(0);
+        *major = 0;
+        *minor = 0;
+        return;
+    }
+#if GR_SUPPORT_GLDESKTOP
+    int n = sscanf(v, "%d.%d", major, minor);
+    if (n != 2) {
+        GrAssert(0);
+        *major = 0;
+        *minor = 0;
+        return;
+    }
+#else
+    char profile[2];
+    int n = sscanf(v, "OpenGL ES-%c%c %d.%d", profile, profile+1, major, minor);
+    bool ok = 4 == n;
+    if (!ok) {
+        int n = sscanf(v, "OpenGL ES %d.%d", major, minor);
+        ok = 2 == n;
+    }
+    if (!ok) {
+        GrAssert(0);
+        *major = 0;
+        *minor = 0;
+        return;
+    }
+#endif
+}
+
+#if defined(GR_GL_PROC_ADDRESS_HEADER)
+    #include GR_GL_PROC_ADDRESS_HEADER
+#endif
+
+typedef void (*glProc)(void);
+
+#define GET_PROC(EXT_STRUCT, PROC_NAME) \
+    *(GrTCast<glProc*>(&(EXT_STRUCT-> PROC_NAME))) = (glProc)GR_GL_PROC_ADDRESS((gl ## PROC_NAME)); \
+    GrAssert(NULL != EXT_STRUCT-> PROC_NAME)
+
+#define GET_SUFFIX_PROC(EXT_STRUCT, PROC_NAME, SUFFIX) \
+    *(GrTCast<glProc*>(&(EXT_STRUCT-> PROC_NAME))) = (glProc)GR_GL_PROC_ADDRESS((gl ## PROC_NAME ## SUFFIX)); \
+    GrAssert(NULL != EXT_STRUCT-> PROC_NAME)
+
+extern void GrGLInitExtensions(GrGLExts* exts) {
+    exts->GenFramebuffers                   = NULL;
+    exts->BindFramebuffer                   = NULL;
+    exts->FramebufferTexture2D              = NULL;
+    exts->CheckFramebufferStatus            = NULL;
+    exts->DeleteFramebuffers                = NULL;
+    exts->RenderbufferStorage               = NULL;
+    exts->GenRenderbuffers                  = NULL;
+    exts->DeleteRenderbuffers               = NULL;
+    exts->FramebufferRenderbuffer           = NULL;
+    exts->BindRenderbuffer                  = NULL;
+    exts->RenderbufferStorageMultisample    = NULL;
+    exts->BlitFramebuffer                   = NULL;
+    exts->ResolveMultisampleFramebuffer     = NULL;
+    exts->FramebufferTexture2DMultisample   = NULL;
+    exts->MapBuffer                         = NULL;
+    exts->UnmapBuffer                       = NULL;
+
+    GLint major, minor;
+    gl_version(&major, &minor);
+
+    bool fboFound = false;
+#if GR_SUPPORT_GLDESKTOP
+    #if defined(GL_VERSION_3_0) && GL_VERSION_3_0
+    if (!fboFound && major >= 3) { // all of ARB_fbo is in 3.x
+        exts->GenFramebuffers                   = glGenFramebuffers;
+        exts->BindFramebuffer                   = glBindFramebuffer;
+        exts->FramebufferTexture2D              = glFramebufferTexture2D;
+        exts->CheckFramebufferStatus            = glCheckFramebufferStatus;
+        exts->DeleteFramebuffers                = glDeleteFramebuffers;
+        exts->RenderbufferStorage               = glRenderbufferStorage;
+        exts->GenRenderbuffers                  = glGenRenderbuffers;
+        exts->DeleteRenderbuffers               = glDeleteRenderbuffers;
+        exts->FramebufferRenderbuffer           = glFramebufferRenderbuffer;
+        exts->BindRenderbuffer                  = glBindRenderbuffer;
+        exts->RenderbufferStorageMultisample    = glRenderbufferStorageMultisample;
+        exts->BlitFramebuffer                   = glBlitFramebuffer;
+        fboFound = true;
+    }
+    #endif
+    #if GL_ARB_framebuffer_object
+    if (!fboFound && has_gl_extension("GL_ARB_framebuffer_object")) {
+        // GL_ARB_framebuffer_object doesn't use ARB suffix.
+        GET_PROC(exts, GenFramebuffers);
+        GET_PROC(exts, BindFramebuffer);
+        GET_PROC(exts, FramebufferTexture2D);
+        GET_PROC(exts, CheckFramebufferStatus);
+        GET_PROC(exts, DeleteFramebuffers);
+        GET_PROC(exts, RenderbufferStorage);
+        GET_PROC(exts, GenRenderbuffers);
+        GET_PROC(exts, DeleteRenderbuffers);
+        GET_PROC(exts, FramebufferRenderbuffer);
+        GET_PROC(exts, BindRenderbuffer);
+        GET_PROC(exts, RenderbufferStorageMultisample);
+        GET_PROC(exts, BlitFramebuffer);
+        fboFound = true;
+    }
+    #endif
+    // Mac doesn't declare prototypes for EXT FBO extensions
+    #if GL_EXT_framebuffer_object && !GR_MAC_BUILD
+    if (!fboFound && has_gl_extension("GL_EXT_framebuffer_object")) {
+        GET_SUFFIX_PROC(exts, GenFramebuffers, EXT);
+        GET_SUFFIX_PROC(exts, BindFramebuffer, EXT);
+        GET_SUFFIX_PROC(exts, FramebufferTexture2D, EXT);
+        GET_SUFFIX_PROC(exts, CheckFramebufferStatus, EXT);
+        GET_SUFFIX_PROC(exts, DeleteFramebuffers, EXT);
+        GET_SUFFIX_PROC(exts, RenderbufferStorage, EXT);
+        GET_SUFFIX_PROC(exts, GenRenderbuffers, EXT);
+        GET_SUFFIX_PROC(exts, DeleteRenderbuffers, EXT);
+        GET_SUFFIX_PROC(exts, FramebufferRenderbuffer, EXT);
+        GET_SUFFIX_PROC(exts, BindRenderbuffer, EXT);
+        fboFound = true;
+        // check for fbo ms and fbo blit
+        #if GL_EXT_framebuffer_multisample
+        if (has_gl_extension("GL_EXT_framebuffer_multisample")) {
+            GET_SUFFIX_PROC(exts, RenderbufferStorageMultisample, EXT);
+        }
+        #endif
+        #if GL_EXT_framebuffer_blit
+        if (has_gl_extension("GL_EXT_framebuffer_blit")) {
+            GET_SUFFIX_PROC(exts, BlitFramebuffer, EXT);
+        }
+        #endif
+    }
+    #endif
+    if (!fboFound) {
+        // we require some form of FBO
+        GrAssert(!"No FBOs supported?");
+    }
+    // we assume we have at least GL 1.5 or higher (VBOs introduced in 1.5)
+    exts->MapBuffer     = glMapBuffer;
+    exts->UnmapBuffer   = glUnmapBuffer;
+#else // !GR_SUPPORT_GLDESKTOP
+    #if GR_SUPPORT_GLES2
+    if (!fboFound && major >= 2) {// ES 2.0 supports FBO
+        exts->GenFramebuffers                   = glGenFramebuffers;
+        exts->BindFramebuffer                   = glBindFramebuffer;
+        exts->FramebufferTexture2D              = glFramebufferTexture2D;
+        exts->CheckFramebufferStatus            = glCheckFramebufferStatus;
+        exts->DeleteFramebuffers                = glDeleteFramebuffers;
+        exts->RenderbufferStorage               = glRenderbufferStorage;
+        exts->GenRenderbuffers                  = glGenRenderbuffers;
+        exts->DeleteRenderbuffers               = glDeleteRenderbuffers;
+        exts->FramebufferRenderbuffer           = glFramebufferRenderbuffer;
+        exts->BindRenderbuffer                  = glBindRenderbuffer;
+        fboFound = true;
+    }
+    #endif
+    #if GL_OES_framebuffer_object
+    if (!fboFound && has_gl_extension("GL_OES_framebuffer_object")) {
+        GET_SUFFIX_PROC(exts, GenFramebuffers, OES);
+        GET_SUFFIX_PROC(exts, BindFramebuffer, OES);
+        GET_SUFFIX_PROC(exts, FramebufferTexture2D, OES);
+        GET_SUFFIX_PROC(exts, CheckFramebufferStatus, OES);
+        GET_SUFFIX_PROC(exts, DeleteFramebuffers, OES);
+        GET_SUFFIX_PROC(exts, RenderbufferStorage, OES);
+        GET_SUFFIX_PROC(exts, GenRenderbuffers, OES);
+        GET_SUFFIX_PROC(exts, DeleteRenderbuffers, OES);
+        GET_SUFFIX_PROC(exts, FramebufferRenderbuffer, OES);
+        GET_SUFFIX_PROC(exts, BindRenderbuffer, OES);
+    }
+    #endif
+
+    if (!fboFound) {
+        // we require some form of FBO
+        GrAssert(!"No FBOs supported?");
+    }
+
+    #if GL_APPLE_framebuffer_multisample
+    if (has_gl_extension("GL_APPLE_framebuffer_multisample")) {
+        GET_SUFFIX_PROC(exts, ResolveMultisampleFramebuffer, APPLE);
+    }
+    #endif
+
+    #if GL_IMG_multisampled_render_to_texture
+    if (has_gl_extension("GL_IMG_multisampled_render_to_texture")) {
+        GET_SUFFIX_PROC(exts, FramebufferTexture2DMultisample, IMG);
+    }
+    #endif
+
+    #if GL_OES_mapbuffer
+    if (has_gl_extension("GL_OES_mapbuffer")) {
+        GET_SUFFIX_PROC(exts, MapBuffer, OES);
+        GET_SUFFIX_PROC(exts, UnmapBuffer, OES);
+    }
+    #endif
+#endif // !GR_SUPPORT_GLDESKTOP
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrGLCheckErr(const char* location, const char* call) {
+    uint32_t err =  glGetError();
+    if (GL_NO_ERROR != err) {
+        GrPrintf("---- glGetError %x", err);
+        if (NULL != location) {
+            GrPrintf(" at\n\t%s", location);
+        }
+        if (NULL != call) {
+            GrPrintf("\n\t\t%s", call);
+        }
+        GrPrintf("\n");
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool gLogCallsGL = !!(GR_GL_LOG_CALLS_START);
+
+bool gCheckErrorGL = !!(GR_GL_CHECK_ERROR_START);
diff --git a/gpu/src/GrGLVertexBuffer.cpp b/gpu/src/GrGLVertexBuffer.cpp
new file mode 100644
index 0000000..ec48936
--- /dev/null
+++ b/gpu/src/GrGLVertexBuffer.cpp
@@ -0,0 +1,123 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrGLVertexBuffer.h"
+#include "GrGpuGL.h"
+
+GrGLVertexBuffer::GrGLVertexBuffer(GLuint id, GrGpuGL* gl, size_t sizeInBytes,
+                                   bool dynamic) :
+                                   INHERITED(sizeInBytes, dynamic),
+                                   fGL(gl),
+                                   fBufferID(id),
+                                   fLockPtr(NULL) {
+}
+
+GrGLVertexBuffer::~GrGLVertexBuffer() {
+    // make sure we've not been abandoned
+    if (fBufferID) {
+        fGL->notifyVertexBufferDelete(this);
+        GR_GL(DeleteBuffers(1, &fBufferID));
+    }
+}
+
+void GrGLVertexBuffer::bind() const {
+    GR_GL(BindBuffer(GL_ARRAY_BUFFER, fBufferID));
+    fGL->notifyVertexBufferBind(this);
+}
+
+GLuint GrGLVertexBuffer::bufferID() const {
+    return fBufferID;
+}
+
+void GrGLVertexBuffer::abandon() {
+    fBufferID = 0;
+    fGL = NULL;
+    fLockPtr = NULL;
+}
+
+void* GrGLVertexBuffer::lock() {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (fGL->supportsBufferLocking()) {
+        bind();
+        // Let driver know it can discard the old data
+        GR_GL(BufferData(GL_ARRAY_BUFFER, size(), NULL,
+                         dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW));
+        fLockPtr = GR_GLEXT(fGL->extensions(),
+                            MapBuffer(GL_ARRAY_BUFFER, GR_WRITE_ONLY));
+        return fLockPtr;
+    }
+    return NULL;
+}
+
+void* GrGLVertexBuffer::lockPtr() const {
+    return fLockPtr;
+}
+
+void GrGLVertexBuffer::unlock() {
+    GrAssert(fBufferID);
+    GrAssert(isLocked());
+    GrAssert(fGL->supportsBufferLocking());
+
+    bind();
+    GR_GLEXT(fGL->extensions(), UnmapBuffer(GL_ARRAY_BUFFER));
+    fLockPtr = NULL;
+}
+
+bool GrGLVertexBuffer::isLocked() const {
+    GrAssert(fBufferID);
+#if GR_DEBUG
+    if (fGL->supportsBufferLocking()) {
+        GLint mapped;
+        bind();
+        GR_GL(GetBufferParameteriv(GL_ARRAY_BUFFER, GR_BUFFER_MAPPED, &mapped));
+        GrAssert(!!mapped == !!fLockPtr);
+    }
+#endif
+    return NULL != fLockPtr;
+}
+
+bool GrGLVertexBuffer::updateData(const void* src, size_t srcSizeInBytes) {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (srcSizeInBytes > size()) {
+        return false;
+    }
+    bind();
+    GLenum usage = dynamic() ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;
+    if (size() == srcSizeInBytes) {
+        GR_GL(BufferData(GL_ARRAY_BUFFER, srcSizeInBytes, src, usage));
+    } else {
+        GR_GL(BufferData(GL_ARRAY_BUFFER, size(), NULL, usage));
+        GR_GL(BufferSubData(GL_ARRAY_BUFFER, 0, srcSizeInBytes, src));
+    }
+    return true;
+}
+
+bool GrGLVertexBuffer::updateSubData(const void* src,
+                                     size_t srcSizeInBytes,
+                                     size_t offset) {
+    GrAssert(fBufferID);
+    GrAssert(!isLocked());
+    if (srcSizeInBytes + offset > size()) {
+        return false;
+    }
+    bind();
+    GR_GL(BufferSubData(GL_ARRAY_BUFFER, offset, srcSizeInBytes, src));
+    return true;
+}
+
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
new file mode 100644
index 0000000..d41005b
--- /dev/null
+++ b/gpu/src/GrGpu.cpp
@@ -0,0 +1,689 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#include "GrGpu.h"
+#include "GrMemory.h"
+#include "GrTextStrike.h"
+#include "GrTextureCache.h"
+#include "GrClipIterator.h"
+#include "GrIndexBuffer.h"
+#include "GrVertexBuffer.h"
+#include "GrBufferAllocPool.h"
+#include "GrPathRenderer.h"
+
+// probably makes no sense for this to be less than a page
+static const size_t VERTEX_POOL_VB_SIZE = 1 << 12;
+static const int VERTEX_POOL_VB_COUNT = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+
+size_t GrTexture::BytesPerPixel(PixelConfig config) {
+    switch (config) {
+        case kAlpha_8_PixelConfig:
+        case kIndex_8_PixelConfig:
+            return 1;
+        case kRGB_565_PixelConfig:
+        case kRGBA_4444_PixelConfig:
+            return 2;
+        case kRGBA_8888_PixelConfig:
+        case kRGBX_8888_PixelConfig:
+            return 4;
+        default:
+            return 0;
+    }
+}
+
+bool GrTexture::PixelConfigIsOpaque(PixelConfig config) {
+    switch (config) {
+        case GrTexture::kRGB_565_PixelConfig:
+        case GrTexture::kRGBX_8888_PixelConfig:
+            return true;
+        default:
+            return false;
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+extern void gr_run_unittests();
+
+GrGpu::GrGpu() : f8bitPaletteSupport(false),
+                 fCurrPoolVertexBuffer(NULL),
+                 fCurrPoolStartVertex(0),
+                 fCurrPoolIndexBuffer(NULL),
+                 fCurrPoolStartIndex(0),
+                 fVertexPool(NULL),
+                 fIndexPool(NULL),
+                 fQuadIndexBuffer(NULL),
+                 fUnitSquareVertexBuffer(NULL),
+                 fPathRenderer(NULL),
+                 fContextIsDirty(true),
+                 fVertexPoolInUse(false),
+                 fIndexPoolInUse(false) {
+#if GR_DEBUG
+    //gr_run_unittests();
+#endif
+    resetStats();
+}
+
+GrGpu::~GrGpu() {
+    GrSafeUnref(fQuadIndexBuffer);
+    GrSafeUnref(fUnitSquareVertexBuffer);
+    delete fVertexPool;
+    delete fIndexPool;
+    delete fPathRenderer;
+}
+
+void GrGpu::resetContext() {
+}
+
+void GrGpu::unimpl(const char msg[]) {
+#if GR_DEBUG
+    GrPrintf("--- GrGpu unimplemented(\"%s\")\n", msg);
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrTexture* GrGpu::createTexture(const TextureDesc& desc,
+                                const void* srcData, size_t rowBytes) {
+    this->handleDirtyContext();
+    return this->createTextureHelper(desc, srcData, rowBytes);
+}
+
+GrRenderTarget* GrGpu::createPlatformRenderTarget(intptr_t platformRenderTarget,
+                                                  int stencilBits,
+                                                  int width, int height) {
+    this->handleDirtyContext();
+    return this->createPlatformRenderTargetHelper(platformRenderTarget,
+                                                  stencilBits,
+                                                  width, height);
+}
+
+GrRenderTarget* GrGpu::createRenderTargetFrom3DApiState() {
+    this->handleDirtyContext();
+    return this->createRenderTargetFrom3DApiStateHelper();
+}
+
+GrVertexBuffer* GrGpu::createVertexBuffer(uint32_t size, bool dynamic) {
+    this->handleDirtyContext();
+    return this->createVertexBufferHelper(size, dynamic);
+}
+
+GrIndexBuffer* GrGpu::createIndexBuffer(uint32_t size, bool dynamic) {
+    this->handleDirtyContext();
+    return this->createIndexBufferHelper(size, dynamic);
+}
+
+void GrGpu::eraseColor(GrColor color) {
+    this->handleDirtyContext();
+    this->eraseColorHelper(color);
+}
+
+void GrGpu::forceRenderTargetFlush() {
+    this->handleDirtyContext();
+    this->forceRenderTargetFlushHelper();
+}
+
+bool GrGpu::readPixels(int left, int top, int width, int height,
+                       GrTexture::PixelConfig config, void* buffer) {
+    this->handleDirtyContext();
+    return this->readPixelsHelper(left, top, width, height, config, buffer);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static const int MAX_QUADS = 1 << 12; // max possible: (1 << 14) - 1;
+
+GR_STATIC_ASSERT(4 * MAX_QUADS <= 65535);
+
+static inline void fill_indices(uint16_t* indices, int quadCount) {
+    for (int i = 0; i < quadCount; ++i) {
+        indices[6 * i + 0] = 4 * i + 0;
+        indices[6 * i + 1] = 4 * i + 1;
+        indices[6 * i + 2] = 4 * i + 2;
+        indices[6 * i + 3] = 4 * i + 0;
+        indices[6 * i + 4] = 4 * i + 2;
+        indices[6 * i + 5] = 4 * i + 3;
+    }
+}
+
+const GrIndexBuffer* GrGpu::getQuadIndexBuffer() const {
+    if (NULL == fQuadIndexBuffer) {
+        static const int SIZE = sizeof(uint16_t) * 6 * MAX_QUADS;
+        GrGpu* me = const_cast<GrGpu*>(this);
+        fQuadIndexBuffer = me->createIndexBuffer(SIZE, false);
+        if (NULL != fQuadIndexBuffer) {
+            uint16_t* indices = (uint16_t*)fQuadIndexBuffer->lock();
+            if (NULL != indices) {
+                fill_indices(indices, MAX_QUADS);
+                fQuadIndexBuffer->unlock();
+            } else {
+                indices = (uint16_t*)GrMalloc(SIZE);
+                fill_indices(indices, MAX_QUADS);
+                if (!fQuadIndexBuffer->updateData(indices, SIZE)) {
+                    fQuadIndexBuffer->unref();
+                    fQuadIndexBuffer = NULL;
+                    GrCrash("Can't get indices into buffer!");
+                }
+                GrFree(indices);
+            }
+        }
+    }
+
+    return fQuadIndexBuffer;
+}
+
+const GrVertexBuffer* GrGpu::getUnitSquareVertexBuffer() const {
+    if (NULL == fUnitSquareVertexBuffer) {
+
+        static const GrPoint DATA[] = {
+            GrPoint(0,         0),
+            GrPoint(GR_Scalar1,0),
+            GrPoint(GR_Scalar1,GR_Scalar1),
+            GrPoint(0,         GR_Scalar1)
+        };
+        static const size_t SIZE = sizeof(DATA);
+
+        GrGpu* me = const_cast<GrGpu*>(this);
+        fUnitSquareVertexBuffer = me->createVertexBuffer(SIZE, false);
+        if (NULL != fUnitSquareVertexBuffer) {
+            if (!fUnitSquareVertexBuffer->updateData(DATA, SIZE)) {
+                fUnitSquareVertexBuffer->unref();
+                fUnitSquareVertexBuffer = NULL;
+                GrCrash("Can't get vertices into buffer!");
+            }
+        }
+    }
+
+    return fUnitSquareVertexBuffer;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrGpu::clipWillBeSet(const GrClip& newClip) {
+    if (newClip != fClip) {
+        fClipState.fClipIsDirty = true;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// stencil settings to use when clip is in stencil
+const GrStencilSettings GrGpu::gClipStencilSettings = {
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc, kAlwaysIfInClip_StencilFunc,
+    0,                           0,
+    0,                           0,
+    0,                           0
+};
+
+// mapping of clip-respecting stencil funcs to normal stencil funcs
+// mapping depends on whether stencil-clipping is in effect.
+static const GrStencilFunc gGrClipToNormalStencilFunc[2][kClipStencilFuncCount] = {
+    {// Stencil-Clipping is DISABLED, effectively always inside the clip
+        // In the Clip Funcs
+        kAlways_StencilFunc,          // kAlwaysIfInClip_StencilFunc
+        kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
+        kLess_StencilFunc,            // kLessIfInClip_StencilFunc
+        kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
+        // Special in the clip func that forces user's ref to be 0.
+        kNotEqual_StencilFunc,        // kNonZeroIfInClip_StencilFunc
+                                      // make ref 0 and do normal nequal.
+    },
+    {// Stencil-Clipping is ENABLED
+        // In the Clip Funcs
+        kEqual_StencilFunc,           // kAlwaysIfInClip_StencilFunc
+                                      // eq stencil clip bit, mask
+                                      // out user bits.
+
+        kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
+                                      // add stencil bit to mask and ref
+
+        kLess_StencilFunc,            // kLessIfInClip_StencilFunc
+        kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
+                                      // for both of these we can add
+                                      // the clip bit to the mask and
+                                      // ref and compare as normal
+        // Special in the clip func that forces user's ref to be 0.
+        kLess_StencilFunc,            // kNonZeroIfInClip_StencilFunc
+                                      // make ref have only the clip bit set
+                                      // and make comparison be less
+                                      // 10..0 < 1..user_bits..
+    }
+};
+
+GrStencilFunc GrGpu::ConvertStencilFunc(bool stencilInClip, GrStencilFunc func) {
+    GrAssert(func >= 0);
+    if (func >= kBasicStencilFuncCount) {
+        GrAssert(func < kStencilFuncCount);
+        func = gGrClipToNormalStencilFunc[stencilInClip ? 1 : 0][func - kBasicStencilFuncCount];
+        GrAssert(func >= 0 && func < kBasicStencilFuncCount);
+    }
+    return func;
+}
+
+void GrGpu::ConvertStencilFuncAndMask(GrStencilFunc func,
+                                      bool clipInStencil,
+                                      unsigned int clipBit,
+                                      unsigned int userBits,
+                                      unsigned int* ref,
+                                      unsigned int* mask) {
+    if (func < kBasicStencilFuncCount) {
+        *mask &= userBits;
+        *ref &= userBits;
+    } else {
+        if (clipInStencil) {
+            switch (func) {
+                case kAlwaysIfInClip_StencilFunc:
+                    *mask = clipBit;
+                    *ref = clipBit;
+                    break;
+                case kEqualIfInClip_StencilFunc:
+                case kLessIfInClip_StencilFunc:
+                case kLEqualIfInClip_StencilFunc:
+                    *mask = (*mask & userBits) | clipBit;
+                    *ref = (*ref & userBits) | clipBit;
+                    break;
+                case kNonZeroIfInClip_StencilFunc:
+                    *mask = (*mask & userBits) | clipBit;
+                    *ref = clipBit;
+                    break;
+                default:
+                    GrCrash("Unknown stencil func");
+            }
+        } else {
+            *mask &= userBits;
+            *ref &= userBits;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define VISUALIZE_COMPLEX_CLIP 0
+
+#if VISUALIZE_COMPLEX_CLIP
+    #include "GrRandom.h"
+    GrRandom gRandom;
+    #define SET_RANDOM_COLOR this->setColor(0xff000000 | gRandom.nextU());
+#else
+    #define SET_RANDOM_COLOR
+#endif
+
+bool GrGpu::setupClipAndFlushState(GrPrimitiveType type) {
+    const GrIRect* r = NULL;
+    GrIRect clipRect;
+
+    // we check this early because we need a valid
+    // render target to setup stencil clipping
+    // before even going into flushGraphicsState
+    if (NULL == fCurrDrawState.fRenderTarget) {
+        GrAssert(!"No render target bound.");
+        return false;
+    }
+
+    if (fCurrDrawState.fFlagBits & kClip_StateBit) {
+        GrRenderTarget& rt = *fCurrDrawState.fRenderTarget;
+
+        GrRect bounds;
+        GrRect rtRect;
+        rtRect.setLTRB(0, 0,
+                       GrIntToScalar(rt.width()), GrIntToScalar(rt.height()));
+        if (fClip.hasConservativeBounds()) {
+            bounds = fClip.getConservativeBounds();
+            bounds.intersectWith(rtRect);
+        } else {
+            bounds = rtRect;
+        }
+
+        bounds.roundOut(&clipRect);
+        if  (clipRect.isEmpty()) {
+            clipRect.setLTRB(0,0,0,0);
+        }
+        r = &clipRect;
+
+        fClipState.fClipInStencil = !fClip.isRect() &&
+                                    !fClip.isEmpty() &&
+                                    !bounds.isEmpty();
+
+        if (fClipState.fClipInStencil &&
+            (fClipState.fClipIsDirty ||
+             fClip != rt.fLastStencilClip)) {
+
+            rt.fLastStencilClip = fClip;
+            // we set the current clip to the bounds so that our recursive
+            // draws are scissored to them. We use the copy of the complex clip
+            // in the rt to render
+            const GrClip& clip = rt.fLastStencilClip;
+            fClip.setFromRect(bounds);
+
+            AutoStateRestore asr(this);
+            AutoInternalDrawGeomRestore aidgr(this);
+
+            this->setViewMatrix(GrMatrix::I());
+            this->eraseStencilClip(clipRect);
+            this->flushScissor(NULL);
+#if !VISUALIZE_COMPLEX_CLIP
+            this->enableState(kNoColorWrites_StateBit);
+#else
+            this->disableState(kNoColorWrites_StateBit);
+#endif
+            int count = clip.getElementCount();
+            int clipBit = rt.stencilBits();
+            clipBit = (1 << (clipBit-1));
+
+            // often we'll see the first two elements of the clip are
+            // the full rt size and another element intersected with it.
+            // We can skip the first full-size rect and save a big rect draw.
+            int firstElement = 0;
+            if (clip.getElementCount() > 1 &&
+                kRect_ClipType == clip.getElementType(0) &&
+                kIntersect_SetOp == clip.getOp(1)&&
+                clip.getRect(0).contains(bounds)) {
+                firstElement = 1;
+            }
+
+            // walk through each clip element and perform its set op
+            // with the existing clip.
+            for (int c = firstElement; c < count; ++c) {
+                GrPathFill fill;
+                // enabled at bottom of loop
+                this->disableState(kModifyStencilClip_StateBit);
+
+                bool canDrawDirectToClip;
+                if (kRect_ClipType == clip.getElementType(c)) {
+                    canDrawDirectToClip = true;
+                    fill = kEvenOdd_PathFill;
+                } else {
+                    fill = clip.getPathFill(c);
+                    GrPathRenderer* pr = this->getPathRenderer();
+                    canDrawDirectToClip = pr->requiresStencilPass(this, clip.getPath(c), fill);
+                }
+
+                GrSetOp op = firstElement == c ? kReplace_SetOp : clip.getOp(c);
+                int passes;
+                GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses];
+
+                canDrawDirectToClip = GrStencilSettings::GetClipPasses(op, canDrawDirectToClip,
+                                                                       clipBit, IsFillInverted(fill),
+                                                                       &passes, stencilSettings);
+
+                // draw the element to the client stencil bits if necessary
+                if (!canDrawDirectToClip) {
+                    if (kRect_ClipType == clip.getElementType(c)) {
+                        static const GrStencilSettings gDrawToStencil = {
+                            kIncClamp_StencilOp, kIncClamp_StencilOp,
+                            kIncClamp_StencilOp, kIncClamp_StencilOp,
+                            kAlways_StencilFunc, kAlways_StencilFunc,
+                            0xffffffff,          0xffffffff,
+                            0x00000000,          0x00000000,
+                            0xffffffff,          0xffffffff,
+                        };
+                        this->setStencil(gDrawToStencil);
+                        SET_RANDOM_COLOR
+                        this->drawSimpleRect(clip.getRect(c), NULL, 0);
+                    } else {
+                        SET_RANDOM_COLOR
+                        getPathRenderer()->drawPathToStencil(this, clip.getPath(c),
+                                                             NonInvertedFill(fill),
+                                                             NULL);
+                    }
+                }
+
+                // now we modify the clip bit by rendering either the clip
+                // element directly or a bounding rect of the entire clip.
+                this->enableState(kModifyStencilClip_StateBit);
+                for (int p = 0; p < passes; ++p) {
+                    this->setStencil(stencilSettings[p]);
+                    if (canDrawDirectToClip) {
+                        if (kRect_ClipType == clip.getElementType(c)) {
+                            SET_RANDOM_COLOR
+                            this->drawSimpleRect(clip.getRect(c), NULL, 0);
+                        } else {
+                            SET_RANDOM_COLOR
+                            getPathRenderer()->drawPath(this, 0,
+                                                        clip.getPath(c),
+                                                        fill, NULL);
+                        }
+                    } else {
+                        SET_RANDOM_COLOR
+                        this->drawSimpleRect(bounds, 0, NULL);
+                    }
+                }
+            }
+            fClip = clip;
+            // recusive draws would have disabled this.
+            fClipState.fClipInStencil = true;
+        }
+
+        fClipState.fClipIsDirty = false;
+    }
+
+    // Must flush the scissor after graphics state
+    if (!this->flushGraphicsState(type)) {
+        return false;
+    }
+    this->flushScissor(r);
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrGpu::drawIndexed(GrPrimitiveType type,
+                        int startVertex,
+                        int startIndex,
+                        int vertexCount,
+                        int indexCount) {
+    GrAssert(kReserved_GeometrySrcType != fGeometrySrc.fVertexSrc ||
+             fReservedGeometry.fLocked);
+    GrAssert(kReserved_GeometrySrcType != fGeometrySrc.fIndexSrc ||
+             fReservedGeometry.fLocked);
+
+    this->handleDirtyContext();
+
+    if (!this->setupClipAndFlushState(type)) {
+        return;
+    }
+
+#if GR_COLLECT_STATS
+    fStats.fVertexCnt += vertexCount;
+    fStats.fIndexCnt  += indexCount;
+    fStats.fDrawCnt   += 1;
+#endif
+
+    int sVertex = startVertex;
+    int sIndex = startIndex;
+    setupGeometry(&sVertex, &sIndex, vertexCount, indexCount);
+
+    drawIndexedHelper(type, sVertex, sIndex,
+                      vertexCount, indexCount);
+}
+
+void GrGpu::drawNonIndexed(GrPrimitiveType type,
+                           int startVertex,
+                           int vertexCount) {
+    GrAssert(kReserved_GeometrySrcType != fGeometrySrc.fVertexSrc ||
+             fReservedGeometry.fLocked);
+
+    this->handleDirtyContext();
+
+    if (!this->setupClipAndFlushState(type)) {
+        return;
+    }
+#if GR_COLLECT_STATS
+    fStats.fVertexCnt += vertexCount;
+    fStats.fDrawCnt   += 1;
+#endif
+
+    int sVertex = startVertex;
+    setupGeometry(&sVertex, NULL, vertexCount, 0);
+
+    drawNonIndexedHelper(type, sVertex, vertexCount);
+}
+
+void GrGpu::finalizeReservedVertices() {
+    GrAssert(NULL != fVertexPool);
+    fVertexPool->unlock();
+}
+
+void GrGpu::finalizeReservedIndices() {
+    GrAssert(NULL != fIndexPool);
+    fIndexPool->unlock();
+}
+
+void GrGpu::prepareVertexPool() {
+    if (NULL == fVertexPool) {
+        fVertexPool = new GrVertexBufferAllocPool(this, true,
+                                                  VERTEX_POOL_VB_SIZE,
+                                                  VERTEX_POOL_VB_COUNT);
+    } else if (!fVertexPoolInUse) {
+        // the client doesn't have valid data in the pool
+        fVertexPool->reset();
+    }
+}
+
+void GrGpu::prepareIndexPool() {
+    if (NULL == fVertexPool) {
+        fIndexPool = new GrIndexBufferAllocPool(this, true, 0, 1);
+    } else if (!fIndexPoolInUse) {
+        // the client doesn't have valid data in the pool
+        fIndexPool->reset();
+    }
+}
+
+bool GrGpu::acquireGeometryHelper(GrVertexLayout vertexLayout,
+                                  void**         vertices,
+                                  void**         indices) {
+    GrAssert(!fReservedGeometry.fLocked);
+    size_t reservedVertexSpace = 0;
+
+    if (fReservedGeometry.fVertexCount) {
+        GrAssert(NULL != vertices);
+
+        this->prepareVertexPool();
+
+        *vertices = fVertexPool->makeSpace(vertexLayout,
+                                           fReservedGeometry.fVertexCount,
+                                           &fCurrPoolVertexBuffer,
+                                           &fCurrPoolStartVertex);
+        if (NULL == *vertices) {
+            return false;
+        }
+        reservedVertexSpace = VertexSize(vertexLayout) *
+                              fReservedGeometry.fVertexCount;
+    }
+    if (fReservedGeometry.fIndexCount) {
+        GrAssert(NULL != indices);
+
+        this->prepareIndexPool();
+
+        *indices = fIndexPool->makeSpace(fReservedGeometry.fIndexCount,
+                                         &fCurrPoolIndexBuffer,
+                                         &fCurrPoolStartIndex);
+        if (NULL == *indices) {
+            fVertexPool->putBack(reservedVertexSpace);
+            fCurrPoolVertexBuffer = NULL;
+            return false;
+        }
+    }
+    return true;
+}
+
+void GrGpu::releaseGeometryHelper() {}
+
+void GrGpu::setVertexSourceToArrayHelper(const void* vertexArray, int vertexCount) {
+    GrAssert(!fReservedGeometry.fLocked || !fReservedGeometry.fVertexCount);
+    prepareVertexPool();
+#if GR_DEBUG
+    bool success =
+#endif
+    fVertexPool->appendVertices(fGeometrySrc.fVertexLayout,
+                                vertexCount,
+                                vertexArray,
+                                &fCurrPoolVertexBuffer,
+                                &fCurrPoolStartVertex);
+    GR_DEBUGASSERT(success);
+}
+
+void GrGpu::setIndexSourceToArrayHelper(const void* indexArray, int indexCount) {
+    GrAssert(!fReservedGeometry.fLocked || !fReservedGeometry.fIndexCount);
+    prepareIndexPool();
+#if GR_DEBUG
+    bool success =
+#endif
+    fIndexPool->appendIndices(indexCount,
+                              indexArray,
+                              &fCurrPoolIndexBuffer,
+                              &fCurrPoolStartIndex);
+    GR_DEBUGASSERT(success);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrPathRenderer* GrGpu::getPathRenderer() {
+    if (NULL == fPathRenderer) {
+        fPathRenderer = new GrDefaultPathRenderer(this->supportsTwoSidedStencil(),
+                                                  this->supportsStencilWrapOps());
+    }
+    return fPathRenderer;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+const GrGpu::Stats& GrGpu::getStats() const {
+    return fStats;
+}
+
+void GrGpu::resetStats() {
+    memset(&fStats, 0, sizeof(fStats));
+}
+
+void GrGpu::printStats() const {
+    if (GR_COLLECT_STATS) {
+     GrPrintf(
+     "-v-------------------------GPU STATS----------------------------v-\n"
+     "Stats collection is: %s\n"
+     "Draws: %04d, Verts: %04d, Indices: %04d\n"
+     "ProgChanges: %04d, TexChanges: %04d, RTChanges: %04d\n"
+     "TexCreates: %04d, RTCreates:%04d\n"
+     "-^--------------------------------------------------------------^-\n",
+     (GR_COLLECT_STATS ? "ON" : "OFF"),
+    fStats.fDrawCnt, fStats.fVertexCnt, fStats.fIndexCnt,
+    fStats.fProgChngCnt, fStats.fTextureChngCnt, fStats.fRenderTargetChngCnt,
+    fStats.fTextureCreateCnt, fStats.fRenderTargetCreateCnt);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrTexture::~GrTexture() {
+    // use this to set a break-point if needed
+//    Gr_clz(3);
+}
+
+const GrSamplerState GrSamplerState::gClampNoFilter(
+    GrSamplerState::kClamp_WrapMode,
+    GrSamplerState::kClamp_WrapMode,
+    GrSamplerState::kNormal_SampleMode,
+    GrMatrix::I(),
+    false);
+
+
+
+
diff --git a/gpu/src/GrGpuFactory.cpp b/gpu/src/GrGpuFactory.cpp
new file mode 100644
index 0000000..2298776
--- /dev/null
+++ b/gpu/src/GrGpuFactory.cpp
@@ -0,0 +1,69 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrTypes.h"
+
+// must be before GrGLConfig.h
+#if GR_WIN32_BUILD
+//    #include "GrGpuD3D9.h"
+#endif
+
+#include "GrGLConfig.h"
+
+
+#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP
+    #include "GrGpuGLFixed.h"
+#endif
+
+#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP
+    #include "GrGpuGLShaders2.h"
+#endif
+
+#include "GrGpu.h"
+
+GrGpu* GrGpu::Create(Engine engine, Platform3DContext context3D) {
+    GrGpu* gpu = NULL;
+
+    switch (engine) {
+        case kOpenGL_Shaders_Engine:
+            GrAssert(NULL == context3D);
+#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP
+            gpu = new GrGpuGLShaders2;
+#endif
+            break;
+        case kOpenGL_Fixed_Engine:
+            GrAssert(NULL == context3D);
+#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP
+            gpu = new GrGpuGLFixed;
+#endif
+            break;
+        case kDirect3D9_Engine:
+            GrAssert(NULL != context3D);
+#if GR_WIN32_BUILD
+//            gpu = new GrGpuD3D9((IDirect3DDevice9*)context3D);
+#endif
+            break;
+        default:
+            GrAssert(!"unknown engine");
+            break;
+    }
+
+    return gpu;
+}
+
+
+
diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp
new file mode 100644
index 0000000..dc9b92d
--- /dev/null
+++ b/gpu/src/GrGpuGL.cpp
@@ -0,0 +1,1871 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#include "GrGpuGL.h"
+#include "GrMemory.h"
+#if GR_WIN32_BUILD
+    // need to get wglGetProcAddress
+    #undef WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN 1
+    #include <windows.h>
+    #undef WIN32_LEAN_AND_MEAN
+#endif
+
+
+static const GLuint GR_MAX_GLUINT = ~0;
+static const GLint  GR_INVAL_GLINT = ~0;
+
+// we use a spare texture unit to avoid
+// mucking with the state of any of the stages.
+static const int SPARE_TEX_UNIT = GrGpuGL::kNumStages;
+
+#define SKIP_CACHE_CHECK    true
+
+static const GLenum gXfermodeCoeff2Blend[] = {
+    GL_ZERO,
+    GL_ONE,
+    GL_SRC_COLOR,
+    GL_ONE_MINUS_SRC_COLOR,
+    GL_DST_COLOR,
+    GL_ONE_MINUS_DST_COLOR,
+    GL_SRC_ALPHA,
+    GL_ONE_MINUS_SRC_ALPHA,
+    GL_DST_ALPHA,
+    GL_ONE_MINUS_DST_ALPHA,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrGpuGL::AdjustTextureMatrix(const GrGLTexture* texture,
+                                  GrSamplerState::SampleMode mode,
+                                  GrMatrix* matrix) {
+    GrAssert(NULL != texture);
+    GrAssert(NULL != matrix);
+    if (GR_Scalar1 != texture->contentScaleX() ||
+        GR_Scalar1 != texture->contentScaleY()) {
+        if (GrSamplerState::kRadial_SampleMode == mode) {
+            GrMatrix scale;
+            scale.setScale(texture->contentScaleX(), texture->contentScaleX());
+            matrix->postConcat(scale);
+        } else if (GrSamplerState::kNormal_SampleMode == mode) {
+            GrMatrix scale;
+            scale.setScale(texture->contentScaleX(), texture->contentScaleY());
+            matrix->postConcat(scale);
+        } else {
+            GrPrintf("We haven't handled NPOT adjustment for other sample modes!");
+        }
+    }
+    GrGLTexture::Orientation orientation = texture->orientation();
+    if (GrGLTexture::kBottomUp_Orientation == orientation) {
+        GrMatrix invY;
+        invY.setAll(GR_Scalar1, 0,           0,
+                    0,          -GR_Scalar1, GR_Scalar1,
+                    0,          0,           GrMatrix::I()[8]);
+        matrix->postConcat(invY);
+    } else {
+        GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
+    }
+}
+
+bool GrGpuGL::TextureMatrixIsIdentity(const GrGLTexture* texture,
+                                      const GrSamplerState& sampler) {
+    GrAssert(NULL != texture);
+    if (!sampler.getMatrix().isIdentity()) {
+        return false;
+    }
+    if (GR_Scalar1 != texture->contentScaleX() ||
+        GR_Scalar1 != texture->contentScaleY()) {
+        return false;
+    }
+    GrGLTexture::Orientation orientation = texture->orientation();
+    if (GrGLTexture::kBottomUp_Orientation == orientation) {
+        return false;
+    } else {
+        GrAssert(GrGLTexture::kTopDown_Orientation == orientation);
+    }
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool gPrintStartupSpew;
+
+
+static bool fbo_test(GrGLExts exts, int w, int h) {
+
+    GLint savedFBO;
+    GLint savedTexUnit;
+    GR_GL_GetIntegerv(GL_ACTIVE_TEXTURE, &savedTexUnit);
+    GR_GL_GetIntegerv(GR_FRAMEBUFFER_BINDING, &savedFBO);
+
+    GR_GL(ActiveTexture(GL_TEXTURE0 + SPARE_TEX_UNIT));
+
+    GLuint testFBO;
+    GR_GLEXT(exts, GenFramebuffers(1, &testFBO));
+    GR_GLEXT(exts, BindFramebuffer(GR_FRAMEBUFFER, testFBO));
+    GLuint testRTTex;
+    GR_GL(GenTextures(1, &testRTTex));
+    GR_GL(BindTexture(GL_TEXTURE_2D, testRTTex));
+    // some implementations require texture to be mip-map complete before
+    // FBO with level 0 bound as color attachment will be framebuffer complete.
+    GR_GL(TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
+    GR_GL(TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h,
+                     0, GL_RGBA, GL_UNSIGNED_BYTE, NULL));
+    GR_GL(BindTexture(GL_TEXTURE_2D, 0));
+    GR_GLEXT(exts, FramebufferTexture2D(GR_FRAMEBUFFER, GR_COLOR_ATTACHMENT0,
+                                        GL_TEXTURE_2D, testRTTex, 0));
+    GLenum status = GR_GLEXT(exts, CheckFramebufferStatus(GR_FRAMEBUFFER));
+    GR_GLEXT(exts, DeleteFramebuffers(1, &testFBO));
+    GR_GL(DeleteTextures(1, &testRTTex));
+
+    GR_GL(ActiveTexture(savedTexUnit));
+    GR_GLEXT(exts, BindFramebuffer(GR_FRAMEBUFFER, savedFBO));
+
+    return status == GR_FRAMEBUFFER_COMPLETE;
+}
+
+GrGpuGL::GrGpuGL() {
+
+    if (gPrintStartupSpew) {
+        GrPrintf("------------------------- create GrGpuGL %p --------------\n",
+                 this);
+        GrPrintf("------ VENDOR %s\n", glGetString(GL_VENDOR));
+        GrPrintf("------ RENDERER %s\n", glGetString(GL_RENDERER));
+        GrPrintf("------ VERSION %s\n", glGetString(GL_VERSION));
+        GrPrintf("------ EXTENSIONS\n %s \n", glGetString(GL_EXTENSIONS));
+    }
+
+    GrGLClearErr();
+
+    GrGLInitExtensions(&fExts);
+
+    resetDirtyFlags();
+
+    GLint maxTextureUnits;
+    // check FS and fixed-function texture unit limits
+    // we only use textures in the fragment stage currently.
+    // checks are > to make sure we have a spare unit.
+#if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES2
+    GR_GL_GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
+    GrAssert(maxTextureUnits > kNumStages);
+#endif
+#if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES1
+    GR_GL_GetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTextureUnits);
+    GrAssert(maxTextureUnits > kNumStages);
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Check for supported features.
+
+    int major, minor;
+    gl_version(&major, &minor);
+
+    GLint numFormats;
+    GR_GL_GetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
+    GrAutoSTMalloc<10, GLint> formats(numFormats);
+    GR_GL_GetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
+    for (int i = 0; i < numFormats; ++i) {
+        if (formats[i] == GR_PALETTE8_RGBA8) {
+            f8bitPaletteSupport = true;
+            break;
+        }
+    }
+
+    if (gPrintStartupSpew) {
+        GrPrintf("Palette8 support: %s\n", (f8bitPaletteSupport ? "YES" : "NO"));
+    }
+
+    GR_STATIC_ASSERT(0 == kNone_AALevel);
+    GR_STATIC_ASSERT(1 == kLow_AALevel);
+    GR_STATIC_ASSERT(2 == kMed_AALevel);
+    GR_STATIC_ASSERT(3 == kHigh_AALevel);
+
+    memset(fAASamples, 0, sizeof(fAASamples));
+    fMSFBOType = kNone_MSFBO;
+    if (has_gl_extension("GL_IMG_multisampled_render_to_texture")) {
+        fMSFBOType = kIMG_MSFBO;
+        if (gPrintStartupSpew) {
+            GrPrintf("MSAA Support: IMG ES EXT.\n");
+        }
+    }
+    else if (has_gl_extension("GL_APPLE_framebuffer_multisample")) {
+        fMSFBOType = kApple_MSFBO;
+        if (gPrintStartupSpew) {
+            GrPrintf("MSAA Support: APPLE ES EXT.\n");
+        }
+    }
+#if GR_SUPPORT_GLDESKTOP
+    else if ((major >= 3) ||
+             has_gl_extension("GL_ARB_framebuffer_object") ||
+             (has_gl_extension("GL_EXT_framebuffer_multisample") &&
+              has_gl_extension("GL_EXT_framebuffer_blit"))) {
+        fMSFBOType = kDesktop_MSFBO;
+         if (gPrintStartupSpew) {
+             GrPrintf("MSAA Support: DESKTOP\n");
+         }
+    }
+#endif
+    else {
+        if (gPrintStartupSpew) {
+            GrPrintf("MSAA Support: NONE\n");
+        }
+    }
+
+    if (kNone_MSFBO != fMSFBOType) {
+        GLint maxSamples;
+        GLenum maxSampleGetter = (kIMG_MSFBO == fMSFBOType) ?
+                                                            GR_MAX_SAMPLES_IMG :
+                                                            GR_MAX_SAMPLES;
+        GR_GL_GetIntegerv(maxSampleGetter, &maxSamples);
+        if (maxSamples > 1 ) {
+            fAASamples[kNone_AALevel] = 0;
+            fAASamples[kLow_AALevel] = GrMax(2,
+                                             GrFixedFloorToInt((GR_FixedHalf) *
+                                                             maxSamples));
+            fAASamples[kMed_AALevel] = GrMax(2,
+                                             GrFixedFloorToInt(((GR_Fixed1*3)/4) *
+                                                             maxSamples));
+            fAASamples[kHigh_AALevel] = maxSamples;
+        }
+        if (gPrintStartupSpew) {
+            GrPrintf("\tMax Samples: %d\n", maxSamples);
+        }
+    }
+
+#if GR_SUPPORT_GLDESKTOP
+    fHasStencilWrap = (major >= 2 || (major == 1 && minor >= 4)) ||
+                      has_gl_extension("GL_EXT_stencil_wrap");
+#else
+    fHasStencilWrap = (major >= 2) || has_gl_extension("GL_OES_stencil_wrap");
+#endif
+    if (gPrintStartupSpew) {
+        GrPrintf("Stencil Wrap: %s\n", (fHasStencilWrap ? "YES" : "NO"));
+    }
+
+#if GR_SUPPORT_GLDESKTOP
+    // we could also look for GL_ATI_separate_stencil extension or
+    // GL_EXT_stencil_two_side but they use different function signatures
+    // than GL2.0+ (and than each other).
+    fTwoSidedStencilSupport = (major >= 2);
+    // supported on GL 1.4 and higher or by extension
+    fStencilWrapOpsSupport = (major > 1) ||
+                             ((1 == major) && (minor >= 4)) ||
+                              has_gl_extension("GL_EXT_stencil_wrap");
+#else
+    // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be
+    // an ES1 extension.
+    fTwoSidedStencilSupport = (major >= 2);
+    // stencil wrap support is in ES2, ES1 requires extension.
+    fStencilWrapOpsSupport = (major > 1) ||
+                              has_gl_extension("GL_OES_stencil_wrap");
+
+#endif
+    if (gPrintStartupSpew) {
+        GrPrintf("Stencil Caps: TwoSide: %s, Wrap: %s\n",
+                (fTwoSidedStencilSupport ? "YES" : "NO"),
+                (fStencilWrapOpsSupport ? "YES" : "NO"));
+    }
+
+#if GR_SUPPORT_GLDESKTOP
+    fRGBA8Renderbuffer = true;
+#else
+    fRGBA8Renderbuffer = has_gl_extension("GL_OES_rgb8_rgba8");
+#endif
+    if (gPrintStartupSpew) {
+        GrPrintf("RGBA Renderbuffer: %s\n", (fRGBA8Renderbuffer ? "YES" : "NO"));
+    }
+
+#if GR_SUPPORT_GLES
+    if (GR_GL_32BPP_COLOR_FORMAT == GR_BGRA) {
+        GrAssert(has_gl_extension("GL_EXT_texture_format_BGRA8888"));
+    }
+#endif
+
+#if GR_SUPPORT_GLDESKTOP
+    fBufferLockSupport = true; // we require VBO support and the desktop VBO
+                               // extension includes glMapBuffer.
+#else
+    fBufferLockSupport = has_gl_extension("GL_OES_mapbuffer");
+#endif
+
+    if (gPrintStartupSpew) {
+        GrPrintf("Map Buffer: %s\n", (fBufferLockSupport ? "YES" : "NO"));
+    }
+
+#if GR_SUPPORT_GLDESKTOP
+    if (major >= 2 || has_gl_extension("GL_ARB_texture_non_power_of_two")) {
+        fNPOTTextureTileSupport = true;
+        fNPOTTextureSupport = true;
+    } else {
+        fNPOTTextureTileSupport = false;
+        fNPOTTextureSupport = false;
+    }
+#else
+    if (major >= 2) {
+        fNPOTTextureSupport = true;
+        fNPOTTextureTileSupport = has_gl_extension("GL_OES_texture_npot");
+    } else {
+        fNPOTTextureSupport = has_gl_extension("GL_APPLE_texture_2D_limited_npot");
+        fNPOTTextureTileSupport = false;
+    }
+#endif
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Experiments to determine limitations that can't be queried. TODO: Make
+    // these a preprocess that generate some compile time constants.
+
+    // sanity check to make sure we can at least create an FBO from a POT texture
+
+    bool simpleFBOSuccess = fbo_test(fExts, 128, 128);
+    if (gPrintStartupSpew) {
+        if (!simpleFBOSuccess) {
+            GrPrintf("FBO Sanity Test: FAILED\n");
+        } else {
+            GrPrintf("FBO Sanity Test: PASSED\n");
+        }
+    }
+    GrAssert(simpleFBOSuccess);
+
+    /* Experimentation has found that some GLs that support NPOT textures
+       do not support FBOs with a NPOT texture. They report "unsupported" FBO
+       status. I don't know how to explicitly query for this. Do an
+       experiment. Note they may support NPOT with a renderbuffer but not a
+       texture. Presumably, the implementation bloats the renderbuffer
+       internally to the next POT.
+     */
+    bool fNPOTRenderTargetSupport = false;
+    if (fNPOTTextureSupport) {
+        fNPOTRenderTargetSupport = fbo_test(fExts, 200, 200);
+    }
+
+    if (gPrintStartupSpew) {
+        if (fNPOTTextureSupport) {
+            GrPrintf("NPOT textures supported\n");
+            if (fNPOTTextureTileSupport) {
+                GrPrintf("NPOT texture tiling supported\n");
+            } else {
+                GrPrintf("NPOT texture tiling NOT supported\n");
+            }
+            if (fNPOTRenderTargetSupport) {
+                GrPrintf("NPOT render targets supported\n");
+            } else {
+                GrPrintf("NPOT render targets NOT supported\n");
+            }
+        } else {
+            GrPrintf("NPOT textures NOT supported\n");
+        }
+    }
+
+    /* The iPhone 4 has a restriction that for an FBO with texture color
+       attachment with height <= 8 then the width must be <= height. Here
+       we look for such a limitation.
+     */
+    fMinRenderTargetHeight = GR_INVAL_GLINT;
+    GLint maxRenderSize;
+    GR_GL_GetIntegerv(GR_MAX_RENDERBUFFER_SIZE, &maxRenderSize);
+
+    if (gPrintStartupSpew) {
+        GrPrintf("Small height FBO texture experiments\n");
+    }
+
+    for (GLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? ++i : i *= 2) {
+        GLuint w = maxRenderSize;
+        GLuint h = i;
+        if (fbo_test(fExts, w, h)) {
+            if (gPrintStartupSpew) {
+                GrPrintf("\t[%d, %d]: PASSED\n", w, h);
+            }
+            fMinRenderTargetHeight = i;
+            break;
+        } else {
+            if (gPrintStartupSpew) {
+                GrPrintf("\t[%d, %d]: FAILED\n", w, h);
+            }
+        }
+    }
+    GrAssert(GR_INVAL_GLINT != fMinRenderTargetHeight);
+
+    if (gPrintStartupSpew) {
+        GrPrintf("Small width FBO texture experiments\n");
+    }
+    fMinRenderTargetWidth = GR_MAX_GLUINT;
+    for (GLuint i = 1; i <= 256; fNPOTRenderTargetSupport ? i *= 2 : ++i) {
+        GLuint w = i;
+        GLuint h = maxRenderSize;
+        if (fbo_test(fExts, w, h)) {
+            if (gPrintStartupSpew) {
+                GrPrintf("\t[%d, %d]: PASSED\n", w, h);
+            }
+            fMinRenderTargetWidth = i;
+            break;
+        } else {
+            if (gPrintStartupSpew) {
+                GrPrintf("\t[%d, %d]: FAILED\n", w, h);
+            }
+        }
+    }
+    GrAssert(GR_INVAL_GLINT != fMinRenderTargetWidth);
+
+    GR_GL_GetIntegerv(GL_MAX_TEXTURE_SIZE, &fMaxTextureDimension);
+}
+
+GrGpuGL::~GrGpuGL() {
+}
+
+void GrGpuGL::resetContext() {
+    // We detect cases when blending is effectively off
+    fHWBlendDisabled = false;
+    GR_GL(Enable(GL_BLEND));
+
+    // we don't use the zb at all
+    GR_GL(Disable(GL_DEPTH_TEST));
+    GR_GL(DepthMask(GL_FALSE));
+
+    GR_GL(Disable(GL_CULL_FACE));
+    GR_GL(FrontFace(GL_CCW));
+    fHWDrawState.fDrawFace = kBoth_DrawFace;
+
+    GR_GL(Disable(GL_DITHER));
+#if GR_SUPPORT_GLDESKTOP
+    GR_GL(Disable(GL_LINE_SMOOTH));
+    GR_GL(Disable(GL_POINT_SMOOTH));
+    GR_GL(Disable(GL_MULTISAMPLE));
+#endif
+
+    GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
+    fHWDrawState.fFlagBits = 0;
+
+    // we only ever use lines in hairline mode
+    GR_GL(LineWidth(1));
+
+    // invalid
+    fActiveTextureUnitIdx = -1;
+
+    // illegal values
+    fHWDrawState.fSrcBlend = (GrBlendCoeff)-1;
+    fHWDrawState.fDstBlend = (GrBlendCoeff)-1;
+    fHWDrawState.fColor = GrColor_ILLEGAL;
+
+    fHWDrawState.fViewMatrix = GrMatrix::InvalidMatrix();
+
+    for (int s = 0; s < kNumStages; ++s) {
+        fHWDrawState.fTextures[s] = NULL;
+        fHWDrawState.fSamplerStates[s].setRadial2Params(-GR_ScalarMax,
+                                                        -GR_ScalarMax,
+                                                        true);
+
+        fHWDrawState.fSamplerStates[s].setMatrix(GrMatrix::InvalidMatrix());
+    }
+
+    fHWBounds.fScissorRect.invalidate();
+    fHWBounds.fScissorEnabled = false;
+    GR_GL(Disable(GL_SCISSOR_TEST));
+    fHWBounds.fViewportRect.invalidate();
+
+    fHWDrawState.fStencilSettings.invalidate();
+    fHWStencilClip = false;
+    fClipState.fClipIsDirty = true;
+
+    fHWGeometryState.fIndexBuffer = NULL;
+    fHWGeometryState.fVertexBuffer = NULL;
+    GR_GL(BindBuffer(GL_ARRAY_BUFFER, 0));
+    GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+    fHWGeometryState.fArrayPtrsDirty = true;
+
+    GR_GL(ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
+    fHWDrawState.fRenderTarget = NULL;
+}
+
+GrRenderTarget* GrGpuGL::createPlatformRenderTargetHelper(
+                                                intptr_t platformRenderTarget,
+                                                int stencilBits,
+                                                int width,
+                                                int height) {
+    GrGLRenderTarget::GLRenderTargetIDs rtIDs;
+    rtIDs.fStencilRenderbufferID = 0;
+    rtIDs.fMSColorRenderbufferID = 0;
+    rtIDs.fTexFBOID              = 0;
+    rtIDs.fOwnIDs                = false;
+    GrGLIRect viewport;
+
+    // viewport is in GL coords (top >= bottom)
+    viewport.fLeft      = 0;
+    viewport.fBottom    = 0;
+    viewport.fWidth     = width;
+    viewport.fHeight    = height;
+
+    rtIDs.fRTFBOID  = (GLuint)platformRenderTarget;
+    rtIDs.fTexFBOID = (GLuint)platformRenderTarget;
+
+    return new GrGLRenderTarget(rtIDs, NULL, stencilBits, viewport, NULL, this);
+}
+
+GrRenderTarget* GrGpuGL::createRenderTargetFrom3DApiStateHelper() {
+
+    GrGLRenderTarget::GLRenderTargetIDs rtIDs;
+
+    GR_GL_GetIntegerv(GR_FRAMEBUFFER_BINDING, (GLint*)&rtIDs.fRTFBOID);
+    rtIDs.fTexFBOID = rtIDs.fRTFBOID;
+    rtIDs.fMSColorRenderbufferID = 0;
+    rtIDs.fStencilRenderbufferID = 0;
+
+    GrGLIRect viewport;
+    viewport.setFromGLViewport();
+    GLuint stencilBits;
+    GR_GL_GetIntegerv(GL_STENCIL_BITS, (GLint*)&stencilBits);
+
+    rtIDs.fOwnIDs = false;
+
+    return new GrGLRenderTarget(rtIDs, NULL, stencilBits, viewport, NULL, this);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const GLuint UNKNOWN_BITS = ~0;
+
+// defines stencil formats from more to less preferred
+static const struct {
+    GLenum  fEnum;
+    GLuint  fBits;
+} gStencilFormats[] = {
+    {GR_STENCIL_INDEX8,     8},
+
+#if GR_SUPPORT_GLDESKTOP
+    {GR_STENCIL_INDEX16,    16},
+#endif
+
+    {GR_DEPTH24_STENCIL8,   8},
+    {GR_STENCIL_INDEX4,     4},
+
+#if GR_SUPPORT_GLDESKTOP
+    {GL_STENCIL_INDEX,      UNKNOWN_BITS},
+    {GR_DEPTH_STENCIL,      UNKNOWN_BITS}
+#endif
+};
+
+// good to set a break-point here to know when createTexture fails
+static GrTexture* return_null_texture() {
+//    GrAssert(!"null texture");
+    return NULL;
+}
+
+#if GR_DEBUG
+static size_t as_size_t(int x) {
+    return x;
+}
+#endif
+
+GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc,
+                                        const void* srcData,
+                                        size_t rowBytes) {
+
+#if GR_COLLECT_STATS
+    ++fStats.fTextureCreateCnt;
+#endif
+
+    setSpareTextureUnit();
+
+    static const GrGLTexture::TexParams DEFAULT_PARAMS = {
+        GL_NEAREST,
+        GL_CLAMP_TO_EDGE,
+        GL_CLAMP_TO_EDGE
+    };
+
+    GrGLTexture::GLTextureDesc glDesc;
+    GLenum internalFormat;
+
+    glDesc.fContentWidth  = desc.fWidth;
+    glDesc.fContentHeight = desc.fHeight;
+    glDesc.fAllocWidth    = desc.fWidth;
+    glDesc.fAllocHeight   = desc.fHeight;
+    glDesc.fStencilBits   = 0;
+    glDesc.fFormat        = desc.fFormat;
+
+    bool renderTarget = 0 != (desc.fFlags & kRenderTarget_TextureFlag);
+    if (!canBeTexture(desc.fFormat,
+                      &internalFormat,
+                      &glDesc.fUploadFormat,
+                      &glDesc.fUploadType)) {
+        return return_null_texture();
+    }
+
+    GrAssert(as_size_t(desc.fAALevel) < GR_ARRAY_COUNT(fAASamples));
+    GLint samples = fAASamples[desc.fAALevel];
+    if (kNone_MSFBO == fMSFBOType && desc.fAALevel != kNone_AALevel) {
+        GrPrintf("AA RT requested but not supported on this platform.");
+    }
+
+    GR_GL(GenTextures(1, &glDesc.fTextureID));
+    if (!glDesc.fTextureID) {
+        return return_null_texture();
+    }
+
+    glDesc.fUploadByteCount = GrTexture::BytesPerPixel(desc.fFormat);
+
+    /*
+     *  check if our srcData has extra bytes past each row. If so, we need
+     *  to trim those off here, since GL doesn't let us pass the rowBytes as
+     *  a parameter to glTexImage2D
+     */
+#if GR_SUPPORT_GLDESKTOP
+    if (srcData) {
+        GR_GL(PixelStorei(GL_UNPACK_ROW_LENGTH,
+                          rowBytes / glDesc.fUploadByteCount));
+    }
+#else
+    GrAutoSMalloc<128 * 128> trimStorage;
+    size_t trimRowBytes = desc.fWidth * glDesc.fUploadByteCount;
+    if (srcData && (trimRowBytes < rowBytes)) {
+        size_t trimSize = desc.fHeight * trimRowBytes;
+        trimStorage.realloc(trimSize);
+        // now copy the data into our new storage, skipping the trailing bytes
+        const char* src = (const char*)srcData;
+        char* dst = (char*)trimStorage.get();
+        for (uint32_t y = 0; y < desc.fHeight; y++) {
+            memcpy(dst, src, trimRowBytes);
+            src += rowBytes;
+            dst += trimRowBytes;
+        }
+        // now point srcData to our trimmed version
+        srcData = trimStorage.get();
+    }
+#endif
+
+    if (renderTarget) {
+        if (!this->npotRenderTargetSupport()) {
+            glDesc.fAllocWidth  = GrNextPow2(desc.fWidth);
+            glDesc.fAllocHeight = GrNextPow2(desc.fHeight);
+        }
+
+        glDesc.fAllocWidth = GrMax<int>(fMinRenderTargetWidth,
+                                        glDesc.fAllocWidth);
+        glDesc.fAllocHeight = GrMax<int>(fMinRenderTargetHeight,
+                                         glDesc.fAllocHeight);
+    } else if (!this->npotTextureSupport()) {
+        glDesc.fAllocWidth  = GrNextPow2(desc.fWidth);
+        glDesc.fAllocHeight = GrNextPow2(desc.fHeight);
+    }
+
+    GR_GL(BindTexture(GL_TEXTURE_2D, glDesc.fTextureID));
+    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                        GL_TEXTURE_MAG_FILTER,
+                        DEFAULT_PARAMS.fFilter));
+    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                        GL_TEXTURE_MIN_FILTER,
+                        DEFAULT_PARAMS.fFilter));
+    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                        GL_TEXTURE_WRAP_S,
+                        DEFAULT_PARAMS.fWrapS));
+    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                        GL_TEXTURE_WRAP_T,
+                        DEFAULT_PARAMS.fWrapT));
+
+    GR_GL(PixelStorei(GL_UNPACK_ALIGNMENT, glDesc.fUploadByteCount));
+    if (GrTexture::kIndex_8_PixelConfig == desc.fFormat &&
+        supports8BitPalette()) {
+        // ES only supports CompressedTexImage2D, not CompressedTexSubimage2D
+        GrAssert(desc.fWidth == glDesc.fAllocWidth);
+        GrAssert(desc.fHeight == glDesc.fAllocHeight);
+        GLsizei imageSize = glDesc.fAllocWidth * glDesc.fAllocHeight +
+                            kColorTableSize;
+        GR_GL(CompressedTexImage2D(GL_TEXTURE_2D, 0, glDesc.fUploadFormat,
+                                   glDesc.fAllocWidth, glDesc.fAllocHeight,
+                                   0, imageSize, srcData));
+        GrGL_RestoreResetRowLength();
+    } else {
+        if (NULL != srcData && (glDesc.fAllocWidth != desc.fWidth ||
+                                glDesc.fAllocHeight != desc.fHeight)) {
+            GR_GL(TexImage2D(GL_TEXTURE_2D, 0, internalFormat,
+                             glDesc.fAllocWidth, glDesc.fAllocHeight,
+                             0, glDesc.fUploadFormat, glDesc.fUploadType, NULL));
+            GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, desc.fWidth,
+                                desc.fHeight, glDesc.fUploadFormat,
+                                glDesc.fUploadType, srcData));
+            GrGL_RestoreResetRowLength();
+
+            uint32_t extraW = glDesc.fAllocWidth  - desc.fWidth;
+            uint32_t extraH = glDesc.fAllocHeight - desc.fHeight;
+            uint32_t maxTexels = extraW * extraH;
+            maxTexels = GrMax(extraW * desc.fHeight, maxTexels);
+            maxTexels = GrMax(desc.fWidth * extraH, maxTexels);
+
+            GrAutoSMalloc<128*128> texels(glDesc.fUploadByteCount * maxTexels);
+
+            uint32_t rowSize = desc.fWidth * glDesc.fUploadByteCount;
+            if (extraH) {
+                uint8_t* lastRowStart = (uint8_t*) srcData +
+                                        (desc.fHeight - 1) * rowSize;
+                uint8_t* extraRowStart = (uint8_t*)texels.get();
+
+                for (uint32_t i = 0; i < extraH; ++i) {
+                    memcpy(extraRowStart, lastRowStart, rowSize);
+                    extraRowStart += rowSize;
+                }
+                GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, 0, desc.fHeight, desc.fWidth,
+                                    extraH, glDesc.fUploadFormat, glDesc.fUploadType,
+                                    texels.get()));
+            }
+            if (extraW) {
+                uint8_t* edgeTexel = (uint8_t*)srcData + rowSize - glDesc.fUploadByteCount;
+                uint8_t* extraTexel = (uint8_t*)texels.get();
+                for (uint32_t j = 0; j < desc.fHeight; ++j) {
+                    for (uint32_t i = 0; i < extraW; ++i) {
+                        memcpy(extraTexel, edgeTexel, glDesc.fUploadByteCount);
+                        extraTexel += glDesc.fUploadByteCount;
+                    }
+                    edgeTexel += rowSize;
+                }
+                GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, desc.fWidth, 0, extraW,
+                                    desc.fHeight, glDesc.fUploadFormat,
+                                    glDesc.fUploadType, texels.get()));
+            }
+            if (extraW && extraH) {
+                uint8_t* cornerTexel = (uint8_t*)srcData + desc.fHeight * rowSize
+                                       - glDesc.fUploadByteCount;
+                uint8_t* extraTexel = (uint8_t*)texels.get();
+                for (uint32_t i = 0; i < extraW*extraH; ++i) {
+                    memcpy(extraTexel, cornerTexel, glDesc.fUploadByteCount);
+                    extraTexel += glDesc.fUploadByteCount;
+                }
+                GR_GL(TexSubImage2D(GL_TEXTURE_2D, 0, desc.fWidth, desc.fHeight,
+                                    extraW, extraH, glDesc.fUploadFormat,
+                                    glDesc.fUploadType, texels.get()));
+            }
+
+        } else {
+            GR_GL(TexImage2D(GL_TEXTURE_2D, 0, internalFormat, glDesc.fAllocWidth,
+                             glDesc.fAllocHeight, 0, glDesc.fUploadFormat,
+                             glDesc.fUploadType, srcData));
+            GrGL_RestoreResetRowLength();
+        }
+    }
+
+    glDesc.fOrientation = GrGLTexture::kTopDown_Orientation;
+
+    GrGLRenderTarget::GLRenderTargetIDs rtIDs;
+    rtIDs.fStencilRenderbufferID = 0;
+    rtIDs.fMSColorRenderbufferID = 0;
+    rtIDs.fRTFBOID = 0;
+    rtIDs.fTexFBOID = 0;
+    rtIDs.fOwnIDs = true;
+    GLenum msColorRenderbufferFormat = -1;
+
+    if (renderTarget) {
+#if GR_COLLECT_STATS
+        ++fStats.fRenderTargetCreateCnt;
+#endif
+        bool failed = true;
+        GLenum status;
+        GLint err;
+
+        // If need have both RT flag and srcData we have
+        // to invert the data before uploading because FBO
+        // will be rendered bottom up
+        GrAssert(NULL == srcData);
+        glDesc.fOrientation =  GrGLTexture::kBottomUp_Orientation;
+
+        GR_GLEXT(fExts, GenFramebuffers(1, &rtIDs.fTexFBOID));
+        GrAssert(rtIDs.fTexFBOID);
+
+        // If we are using multisampling and any extension other than the IMG
+        // one we will create two FBOs. We render to one and then resolve to
+        // the texture bound to the other. The IMG extension does an implicit
+        // resolve.
+        if (samples > 1 && kIMG_MSFBO != fMSFBOType && kNone_MSFBO != fMSFBOType) {
+            GR_GLEXT(fExts, GenFramebuffers(1, &rtIDs.fRTFBOID));
+            GrAssert(0 != rtIDs.fRTFBOID);
+            GR_GLEXT(fExts, GenRenderbuffers(1, &rtIDs.fMSColorRenderbufferID));
+            GrAssert(0 != rtIDs.fMSColorRenderbufferID);
+            if (!fboInternalFormat(desc.fFormat, &msColorRenderbufferFormat)) {
+                GR_GLEXT(fExts,
+                         DeleteRenderbuffers(1, &rtIDs.fMSColorRenderbufferID));
+                GR_GL(DeleteTextures(1, &glDesc.fTextureID));
+                GR_GLEXT(fExts, DeleteFramebuffers(1, &rtIDs.fTexFBOID));
+                GR_GLEXT(fExts, DeleteFramebuffers(1, &rtIDs.fRTFBOID));
+                return return_null_texture();
+            }
+        } else {
+            rtIDs.fRTFBOID = rtIDs.fTexFBOID;
+        }
+        int attempts = 1;
+        if (!(kNoPathRendering_TextureFlag & desc.fFlags)) {
+            GR_GLEXT(fExts, GenRenderbuffers(1, &rtIDs.fStencilRenderbufferID));
+            GrAssert(0 != rtIDs.fStencilRenderbufferID);
+            attempts = GR_ARRAY_COUNT(gStencilFormats);
+        }
+
+        // someone suggested that some systems might require
+        // unbinding the texture before we call FramebufferTexture2D
+        // (seems unlikely)
+        GR_GL(BindTexture(GL_TEXTURE_2D, 0));
+
+        err = ~GL_NO_ERROR;
+        for (int i = 0; i < attempts; ++i) {
+            if (rtIDs.fStencilRenderbufferID) {
+                GR_GLEXT(fExts, BindRenderbuffer(GR_RENDERBUFFER,
+                                                 rtIDs.fStencilRenderbufferID));
+                if (samples > 1) {
+                    GR_GLEXT_NO_ERR(fExts, RenderbufferStorageMultisample(
+                                                GR_RENDERBUFFER,
+                                                samples,
+                                                gStencilFormats[i].fEnum,
+                                                glDesc.fAllocWidth,
+                                                glDesc.fAllocHeight));
+                } else {
+                    GR_GLEXT_NO_ERR(fExts, RenderbufferStorage(
+                                                GR_RENDERBUFFER,
+                                                gStencilFormats[i].fEnum,
+                                                glDesc.fAllocWidth,
+                                                glDesc.fAllocHeight));
+                }
+                err = glGetError();
+                if (err != GL_NO_ERROR) {
+                    continue;
+                }
+            }
+            if (rtIDs.fRTFBOID != rtIDs.fTexFBOID) {
+                GrAssert(samples > 1);
+                GR_GLEXT(fExts, BindRenderbuffer(GR_RENDERBUFFER,
+                                                 rtIDs.fMSColorRenderbufferID));
+                GR_GLEXT_NO_ERR(fExts, RenderbufferStorageMultisample(
+                                                   GR_RENDERBUFFER,
+                                                   samples,
+                                                   msColorRenderbufferFormat,
+                                                   glDesc.fAllocWidth,
+                                                   glDesc.fAllocHeight));
+                err = glGetError();
+                if (err != GL_NO_ERROR) {
+                    continue;
+                }
+            }
+            GR_GLEXT(fExts, BindFramebuffer(GR_FRAMEBUFFER, rtIDs.fTexFBOID));
+
+#if GR_COLLECT_STATS
+            ++fStats.fRenderTargetChngCnt;
+#endif
+            if (kIMG_MSFBO == fMSFBOType && samples > 1) {
+                GR_GLEXT(fExts, FramebufferTexture2DMultisample(
+                                                         GR_FRAMEBUFFER,
+                                                         GR_COLOR_ATTACHMENT0,
+                                                         GL_TEXTURE_2D,
+                                                         glDesc.fTextureID,
+                                                         0,
+                                                         samples));
+
+            } else {
+                GR_GLEXT(fExts, FramebufferTexture2D(GR_FRAMEBUFFER,
+                                                     GR_COLOR_ATTACHMENT0,
+                                                     GL_TEXTURE_2D,
+                                                     glDesc.fTextureID, 0));
+            }
+            if (rtIDs.fRTFBOID != rtIDs.fTexFBOID) {
+                GLenum status = GR_GLEXT(fExts,
+                                         CheckFramebufferStatus(GR_FRAMEBUFFER));
+                if (status != GR_FRAMEBUFFER_COMPLETE) {
+                    GrPrintf("-- glCheckFramebufferStatus %x %d %d\n",
+                             status, desc.fWidth, desc.fHeight);
+                    continue;
+                }
+                GR_GLEXT(fExts, BindFramebuffer(GR_FRAMEBUFFER, rtIDs.fRTFBOID));
+            #if GR_COLLECT_STATS
+                ++fStats.fRenderTargetChngCnt;
+            #endif
+                GR_GLEXT(fExts, FramebufferRenderbuffer(GR_FRAMEBUFFER,
+                                                 GR_COLOR_ATTACHMENT0,
+                                                 GR_RENDERBUFFER,
+                                                 rtIDs.fMSColorRenderbufferID));
+
+            }
+            if (rtIDs.fStencilRenderbufferID) {
+                // bind the stencil to rt fbo if present, othewise the tex fbo
+                GR_GLEXT(fExts, FramebufferRenderbuffer(GR_FRAMEBUFFER,
+                                                 GR_STENCIL_ATTACHMENT,
+                                                 GR_RENDERBUFFER,
+                                                 rtIDs.fStencilRenderbufferID));
+            }
+            status = GR_GLEXT(fExts, CheckFramebufferStatus(GR_FRAMEBUFFER));
+
+#if GR_SUPPORT_GLDESKTOP
+            // On some implementations you have to be bound as DEPTH_STENCIL.
+            // (Even binding to DEPTH and STENCIL separately with the same
+            // buffer doesn't work.)
+            if (rtIDs.fStencilRenderbufferID &&
+                status != GR_FRAMEBUFFER_COMPLETE) {
+                GR_GLEXT(fExts, FramebufferRenderbuffer(GR_FRAMEBUFFER,
+                                                        GR_STENCIL_ATTACHMENT,
+                                                        GR_RENDERBUFFER,
+                                                        0));
+                GR_GLEXT(fExts,
+                         FramebufferRenderbuffer(GR_FRAMEBUFFER,
+                                                 GR_DEPTH_STENCIL_ATTACHMENT,
+                                                 GR_RENDERBUFFER,
+                                                 rtIDs.fStencilRenderbufferID));
+                status = GR_GLEXT(fExts, CheckFramebufferStatus(GR_FRAMEBUFFER));
+            }
+#endif
+            if (status != GR_FRAMEBUFFER_COMPLETE) {
+                GrPrintf("-- glCheckFramebufferStatus %x %d %d\n",
+                         status, desc.fWidth, desc.fHeight);
+#if GR_SUPPORT_GLDESKTOP
+                if (rtIDs.fStencilRenderbufferID) {
+                    GR_GLEXT(fExts, FramebufferRenderbuffer(GR_FRAMEBUFFER,
+                                                     GR_DEPTH_STENCIL_ATTACHMENT,
+                                                     GR_RENDERBUFFER,
+                                                     0));
+                }
+#endif
+                continue;
+            }
+            // we're successful!
+            failed = false;
+            if (rtIDs.fStencilRenderbufferID) {
+                if (UNKNOWN_BITS == gStencilFormats[i].fBits) {
+                    GR_GL_GetIntegerv(GL_STENCIL_BITS, (GLint*)&glDesc.fStencilBits);
+                } else {
+                    glDesc.fStencilBits = gStencilFormats[i].fBits;
+                }
+            }
+            break;
+        }
+        if (failed) {
+            if (rtIDs.fStencilRenderbufferID) {
+                GR_GLEXT(fExts,
+                         DeleteRenderbuffers(1, &rtIDs.fStencilRenderbufferID));
+            }
+            if (rtIDs.fMSColorRenderbufferID) {
+                GR_GLEXT(fExts,
+                         DeleteRenderbuffers(1, &rtIDs.fMSColorRenderbufferID));
+            }
+            if (rtIDs.fRTFBOID != rtIDs.fTexFBOID) {
+                GR_GLEXT(fExts, DeleteFramebuffers(1, &rtIDs.fRTFBOID));
+            }
+            if (rtIDs.fTexFBOID) {
+                GR_GLEXT(fExts, DeleteFramebuffers(1, &rtIDs.fTexFBOID));
+            }
+            GR_GL(DeleteTextures(1, &glDesc.fTextureID));
+            return return_null_texture();
+        }
+    }
+#ifdef TRACE_TEXTURE_CREATION
+    GrPrintf("--- new texture [%d] size=(%d %d) bpp=%d\n",
+             tex->fTextureID, width, height, tex->fUploadByteCount);
+#endif
+    GrGLTexture* tex = new GrGLTexture(glDesc, rtIDs, DEFAULT_PARAMS, this);
+
+    if (0 != rtIDs.fTexFBOID) {
+        GrRenderTarget* rt = tex->asRenderTarget();
+        // We've messed with FBO state but may not have set the correct viewport
+        // so just dirty the rendertarget state to force a resend.
+        fHWDrawState.fRenderTarget = NULL;
+
+        // clear the new stencil buffer if we have one
+        if (!(desc.fFlags & kNoPathRendering_TextureFlag)) {
+            GrRenderTarget* rtSave = fCurrDrawState.fRenderTarget;
+            fCurrDrawState.fRenderTarget = rt;
+            eraseStencil(0, ~0);
+            fCurrDrawState.fRenderTarget = rtSave;
+        }
+    }
+    return tex;
+}
+
+GrVertexBuffer* GrGpuGL::createVertexBufferHelper(uint32_t size, bool dynamic) {
+    GLuint id;
+    GR_GL(GenBuffers(1, &id));
+    if (id) {
+        GR_GL(BindBuffer(GL_ARRAY_BUFFER, id));
+        fHWGeometryState.fArrayPtrsDirty = true;
+        GrGLClearErr();
+        // make sure driver can allocate memory for this buffer
+        GR_GL_NO_ERR(BufferData(GL_ARRAY_BUFFER, size, NULL,
+                                dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW));
+        if (glGetError() != GL_NO_ERROR) {
+            GR_GL(DeleteBuffers(1, &id));
+            // deleting bound buffer does implicit bind to 0
+            fHWGeometryState.fVertexBuffer = NULL;
+            return NULL;
+        }
+        GrGLVertexBuffer* vertexBuffer = new GrGLVertexBuffer(id, this,
+                                                              size, dynamic);
+        fHWGeometryState.fVertexBuffer = vertexBuffer;
+        return vertexBuffer;
+    }
+    return NULL;
+}
+
+GrIndexBuffer* GrGpuGL::createIndexBufferHelper(uint32_t size, bool dynamic) {
+    GLuint id;
+    GR_GL(GenBuffers(1, &id));
+    if (id) {
+        GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, id));
+        GrGLClearErr();
+        // make sure driver can allocate memory for this buffer
+        GR_GL_NO_ERR(BufferData(GL_ELEMENT_ARRAY_BUFFER, size, NULL,
+                                dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW));
+        if (glGetError() != GL_NO_ERROR) {
+            GR_GL(DeleteBuffers(1, &id));
+            // deleting bound buffer does implicit bind to 0
+            fHWGeometryState.fIndexBuffer = NULL;
+            return NULL;
+        }
+        GrIndexBuffer* indexBuffer = new GrGLIndexBuffer(id, this,
+                                                         size, dynamic);
+        fHWGeometryState.fIndexBuffer = indexBuffer;
+        return indexBuffer;
+    }
+    return NULL;
+}
+
+void GrGpuGL::flushScissor(const GrIRect* rect) {
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+    const GrGLIRect& vp =
+            ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getViewport();
+
+    GrGLIRect scissor;
+    if (NULL != rect) {
+        scissor.setRelativeTo(vp, rect->fLeft, rect->fTop,
+                              rect->width(), rect->height());
+        if (scissor.contains(vp)) {
+            rect = NULL;
+        }
+    }
+
+    if (NULL != rect) {
+        if (fHWBounds.fScissorRect != scissor) {
+            scissor.pushToGLScissor();
+            fHWBounds.fScissorRect = scissor;
+        }
+        if (!fHWBounds.fScissorEnabled) {
+            GR_GL(Enable(GL_SCISSOR_TEST));
+            fHWBounds.fScissorEnabled = true;
+        }
+    } else {
+        if (fHWBounds.fScissorEnabled) {
+            GR_GL(Disable(GL_SCISSOR_TEST));
+            fHWBounds.fScissorEnabled = false;
+        }
+    }
+}
+
+void GrGpuGL::eraseColorHelper(GrColor color) {
+    if (NULL == fCurrDrawState.fRenderTarget) {
+        return;
+    }
+    flushRenderTarget();
+    if (fHWBounds.fScissorEnabled) {
+        GR_GL(Disable(GL_SCISSOR_TEST));
+        fHWBounds.fScissorEnabled = false;
+    }
+    GR_GL(ColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE));
+    fHWDrawState.fFlagBits &= ~kNoColorWrites_StateBit;
+    GR_GL(ClearColor(GrColorUnpackR(color)/255.f,
+                     GrColorUnpackG(color)/255.f,
+                     GrColorUnpackB(color)/255.f,
+                     GrColorUnpackA(color)/255.f));
+    GR_GL(Clear(GL_COLOR_BUFFER_BIT));
+}
+
+void GrGpuGL::eraseStencil(uint32_t value, uint32_t mask) {
+    if (NULL == fCurrDrawState.fRenderTarget) {
+        return;
+    }
+    flushRenderTarget();
+    if (fHWBounds.fScissorEnabled) {
+        GR_GL(Disable(GL_SCISSOR_TEST));
+        fHWBounds.fScissorEnabled = false;
+    }
+    GR_GL(StencilMask(mask));
+    GR_GL(ClearStencil(value));
+    GR_GL(Clear(GL_STENCIL_BUFFER_BIT));
+    fHWDrawState.fStencilSettings.invalidate();
+}
+
+void GrGpuGL::eraseStencilClip(const GrIRect& rect) {
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+#if 0
+    GLint stencilBitCount = fCurrDrawState.fRenderTarget->stencilBits();
+    GrAssert(stencilBitCount > 0);
+    GLint clipStencilMask  = (1 << (stencilBitCount - 1));
+#else
+    // we could just clear the clip bit but when we go through
+    // angle a partial stencil mask will cause clears to be
+    // turned into draws. Our contract on GrDrawTarget says that
+    // changing the clip between stencil passes may or may not
+    // zero the client's clip bits. So we just clear the whole thing.
+    static const GLint clipStencilMask  = ~0;
+#endif
+    flushRenderTarget();
+    flushScissor(&rect);
+    GR_GL(StencilMask(clipStencilMask));
+    GR_GL(ClearStencil(0));
+    GR_GL(Clear(GL_STENCIL_BUFFER_BIT));
+    fHWDrawState.fStencilSettings.invalidate();
+}
+
+void GrGpuGL::forceRenderTargetFlushHelper() {
+    flushRenderTarget();
+}
+
+bool GrGpuGL::readPixelsHelper(int left, int top, int width, int height,
+                               GrTexture::PixelConfig config, void* buffer) {
+    GLenum internalFormat;  // we don't use this for glReadPixels
+    GLenum format;
+    GLenum type;
+    if (!this->canBeTexture(config, &internalFormat, &format, &type)) {
+        return false;
+    }
+
+    if (NULL == fCurrDrawState.fRenderTarget) {
+        return false;
+    }
+    flushRenderTarget();
+
+    const GrGLIRect& glvp = ((GrGLRenderTarget*)fCurrDrawState.fRenderTarget)->getViewport();
+
+    // the read rect is viewport-relative
+    GrGLIRect readRect;
+    readRect.setRelativeTo(glvp, left, top, width, height);
+    GR_GL(ReadPixels(readRect.fLeft, readRect.fBottom,
+                     readRect.fWidth, readRect.fHeight,
+                     format, type, buffer));
+
+    // now reverse the order of the rows, since GL's are bottom-to-top, but our
+    // API presents top-to-bottom
+    {
+        size_t stride = width * GrTexture::BytesPerPixel(config);
+        GrAutoMalloc rowStorage(stride);
+        void* tmp = rowStorage.get();
+
+        const int halfY = height >> 1;
+        char* top = reinterpret_cast<char*>(buffer);
+        char* bottom = top + (height - 1) * stride;
+        for (int y = 0; y < halfY; y++) {
+            memcpy(tmp, top, stride);
+            memcpy(top, bottom, stride);
+            memcpy(bottom, tmp, stride);
+            top += stride;
+            bottom -= stride;
+        }
+    }
+    return true;
+}
+
+void GrGpuGL::flushRenderTarget() {
+
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+
+    if (fHWDrawState.fRenderTarget != fCurrDrawState.fRenderTarget) {
+        GrGLRenderTarget* rt = (GrGLRenderTarget*)fCurrDrawState.fRenderTarget;
+        GR_GLEXT(fExts, BindFramebuffer(GR_FRAMEBUFFER, rt->renderFBOID()));
+    #if GR_COLLECT_STATS
+        ++fStats.fRenderTargetChngCnt;
+    #endif
+        rt->setDirty(true);
+    #if GR_DEBUG
+        GLenum status = GR_GLEXT(fExts, CheckFramebufferStatus(GR_FRAMEBUFFER));
+        if (status != GR_FRAMEBUFFER_COMPLETE) {
+            GrPrintf("-- glCheckFramebufferStatus %x\n", status);
+        }
+    #endif
+        fDirtyFlags.fRenderTargetChanged = true;
+        fHWDrawState.fRenderTarget = fCurrDrawState.fRenderTarget;
+        const GrGLIRect& vp = rt->getViewport();
+        if (fHWBounds.fViewportRect != vp) {
+            vp.pushToGLViewport();
+            fHWBounds.fViewportRect = vp;
+        }
+    }
+}
+
+GLenum gPrimitiveType2GLMode[] = {
+    GL_TRIANGLES,
+    GL_TRIANGLE_STRIP,
+    GL_TRIANGLE_FAN,
+    GL_POINTS,
+    GL_LINES,
+    GL_LINE_STRIP
+};
+
+#define SWAP_PER_DRAW 0
+
+#if SWAP_PER_DRAW
+    #if GR_MAC_BUILD
+        #include <AGL/agl.h>
+    #elif GR_WIN32_BUILD
+        void SwapBuf() {
+            DWORD procID = GetCurrentProcessId();
+            HWND hwnd = GetTopWindow(GetDesktopWindow());
+            while(hwnd) {
+                DWORD wndProcID = 0;
+                GetWindowThreadProcessId(hwnd, &wndProcID);
+                if(wndProcID == procID) {
+                    SwapBuffers(GetDC(hwnd));
+                }
+                hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
+            }
+         }
+    #endif
+#endif
+
+void GrGpuGL::drawIndexedHelper(GrPrimitiveType type,
+                                uint32_t startVertex,
+                                uint32_t startIndex,
+                                uint32_t vertexCount,
+                                uint32_t indexCount) {
+    GrAssert((size_t)type < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
+
+    GLvoid* indices = (GLvoid*)(sizeof(uint16_t) * startIndex);
+
+    GrAssert(NULL != fHWGeometryState.fIndexBuffer);
+    GrAssert(NULL != fHWGeometryState.fVertexBuffer);
+
+    // our setupGeometry better have adjusted this to zero since
+    // DrawElements always draws from the begining of the arrays for idx 0.
+    GrAssert(0 == startVertex);
+
+    GR_GL(DrawElements(gPrimitiveType2GLMode[type], indexCount,
+                       GL_UNSIGNED_SHORT, indices));
+#if SWAP_PER_DRAW
+    glFlush();
+    #if GR_MAC_BUILD
+        aglSwapBuffers(aglGetCurrentContext());
+        int set_a_break_pt_here = 9;
+        aglSwapBuffers(aglGetCurrentContext());
+    #elif GR_WIN32_BUILD
+        SwapBuf();
+        int set_a_break_pt_here = 9;
+        SwapBuf();
+    #endif
+#endif
+}
+
+void GrGpuGL::drawNonIndexedHelper(GrPrimitiveType type,
+                                   uint32_t startVertex,
+                                   uint32_t vertexCount) {
+    GrAssert((size_t)type < GR_ARRAY_COUNT(gPrimitiveType2GLMode));
+
+    GrAssert(NULL != fHWGeometryState.fVertexBuffer);
+
+    // our setupGeometry better have adjusted this to zero.
+    // DrawElements doesn't take an offset so we always adjus the startVertex.
+    GrAssert(0 == startVertex);
+
+    // pass 0 for parameter first. We have to adjust gl*Pointer() to
+    // account for startVertex in the DrawElements case. So we always
+    // rely on setupGeometry to have accounted for startVertex.
+    GR_GL(DrawArrays(gPrimitiveType2GLMode[type], 0, vertexCount));
+#if SWAP_PER_DRAW
+    glFlush();
+    #if GR_MAC_BUILD
+        aglSwapBuffers(aglGetCurrentContext());
+        int set_a_break_pt_here = 9;
+        aglSwapBuffers(aglGetCurrentContext());
+    #elif GR_WIN32_BUILD
+        SwapBuf();
+        int set_a_break_pt_here = 9;
+        SwapBuf();
+    #endif
+#endif
+}
+
+void GrGpuGL::resolveTextureRenderTarget(GrGLTexture* texture) {
+    GrGLRenderTarget* rt = (GrGLRenderTarget*) texture->asRenderTarget();
+
+    if (NULL != rt && rt->needsResolve()) {
+        GrAssert(kNone_MSFBO != fMSFBOType);
+        GrAssert(rt->textureFBOID() != rt->renderFBOID());
+        GR_GLEXT(fExts, BindFramebuffer(GR_READ_FRAMEBUFFER,
+                                        rt->renderFBOID()));
+        GR_GLEXT(fExts, BindFramebuffer(GR_DRAW_FRAMEBUFFER,
+                                        rt->textureFBOID()));
+    #if GR_COLLECT_STATS
+        ++fStats.fRenderTargetChngCnt;
+    #endif
+        // make sure we go through set render target
+        fHWDrawState.fRenderTarget = NULL;
+
+        GLint left = 0;
+        GLint right = texture->width();
+        // we will have rendered to the top of the FBO.
+        GLint top = texture->allocHeight();
+        GLint bottom = texture->allocHeight() - texture->height();
+        if (kApple_MSFBO == fMSFBOType) {
+            GR_GL(Enable(GL_SCISSOR_TEST));
+            GR_GL(Scissor(left, bottom, right-left, top-bottom));
+            GR_GLEXT(fExts, ResolveMultisampleFramebuffer());
+            fHWBounds.fScissorRect.invalidate();
+            fHWBounds.fScissorEnabled = true;
+        } else {
+            GR_GLEXT(fExts, BlitFramebuffer(left, bottom, right, top,
+                                     left, bottom, right, top,
+                                     GL_COLOR_BUFFER_BIT, GL_NEAREST));
+        }
+        rt->setDirty(false);
+
+    }
+}
+
+static const GLenum grToGLStencilFunc[] = {
+    GL_ALWAYS,           // kAlways_StencilFunc
+    GL_NEVER,            // kNever_StencilFunc
+    GL_GREATER,          // kGreater_StencilFunc
+    GL_GEQUAL,           // kGEqual_StencilFunc
+    GL_LESS,             // kLess_StencilFunc
+    GL_LEQUAL,           // kLEqual_StencilFunc,
+    GL_EQUAL,            // kEqual_StencilFunc,
+    GL_NOTEQUAL,         // kNotEqual_StencilFunc,
+};
+GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilFunc) == kBasicStencilFuncCount);
+GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
+GR_STATIC_ASSERT(1 == kNever_StencilFunc);
+GR_STATIC_ASSERT(2 == kGreater_StencilFunc);
+GR_STATIC_ASSERT(3 == kGEqual_StencilFunc);
+GR_STATIC_ASSERT(4 == kLess_StencilFunc);
+GR_STATIC_ASSERT(5 == kLEqual_StencilFunc);
+GR_STATIC_ASSERT(6 == kEqual_StencilFunc);
+GR_STATIC_ASSERT(7 == kNotEqual_StencilFunc);
+
+static const GLenum grToGLStencilOp[] = {
+    GL_KEEP,        // kKeep_StencilOp
+    GL_REPLACE,     // kReplace_StencilOp
+    GL_INCR_WRAP,   // kIncWrap_StencilOp
+    GL_INCR,        // kIncClamp_StencilOp
+    GL_DECR_WRAP,   // kDecWrap_StencilOp
+    GL_DECR,        // kDecClamp_StencilOp
+    GL_ZERO,        // kZero_StencilOp
+    GL_INVERT,      // kInvert_StencilOp
+};
+GR_STATIC_ASSERT(GR_ARRAY_COUNT(grToGLStencilOp) == kStencilOpCount);
+GR_STATIC_ASSERT(0 == kKeep_StencilOp);
+GR_STATIC_ASSERT(1 == kReplace_StencilOp);
+GR_STATIC_ASSERT(2 == kIncWrap_StencilOp);
+GR_STATIC_ASSERT(3 == kIncClamp_StencilOp);
+GR_STATIC_ASSERT(4 == kDecWrap_StencilOp);
+GR_STATIC_ASSERT(5 == kDecClamp_StencilOp);
+GR_STATIC_ASSERT(6 == kZero_StencilOp);
+GR_STATIC_ASSERT(7 == kInvert_StencilOp);
+
+void GrGpuGL::flushStencil() {
+    const GrStencilSettings* settings = &fCurrDrawState.fStencilSettings;
+
+    // use stencil for clipping if clipping is enabled and the clip
+    // has been written into the stencil.
+    bool stencilClip = fClipState.fClipInStencil &&
+                       (kClip_StateBit & fCurrDrawState.fFlagBits);
+    bool stencilChange = fHWStencilClip != stencilClip  ||
+                         fHWDrawState.fStencilSettings != *settings ||
+                         ((fHWDrawState.fFlagBits & kModifyStencilClip_StateBit) !=
+                          (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit));
+
+    if (stencilChange) {
+
+        // we can't simultaneously perform stencil-clipping and modify the stencil clip
+        GrAssert(!stencilClip || !(fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit));
+
+        if (settings->isDisabled()) {
+            if (stencilClip) {
+                settings = &gClipStencilSettings;
+            }
+        }
+
+        if (settings->isDisabled()) {
+            GR_GL(Disable(GL_STENCIL_TEST));
+        } else {
+            GR_GL(Enable(GL_STENCIL_TEST));
+    #if GR_DEBUG
+            if (!fStencilWrapOpsSupport) {
+                GrAssert(settings->fFrontPassOp != kIncWrap_StencilOp);
+                GrAssert(settings->fFrontPassOp != kDecWrap_StencilOp);
+                GrAssert(settings->fFrontFailOp != kIncWrap_StencilOp);
+                GrAssert(settings->fBackFailOp != kDecWrap_StencilOp);
+                GrAssert(settings->fBackPassOp != kIncWrap_StencilOp);
+                GrAssert(settings->fBackPassOp != kDecWrap_StencilOp);
+                GrAssert(settings->fBackFailOp != kIncWrap_StencilOp);
+                GrAssert(settings->fFrontFailOp != kDecWrap_StencilOp);
+            }
+    #endif
+            int stencilBits = fCurrDrawState.fRenderTarget->stencilBits();
+            GrAssert(stencilBits ||
+                     (GrStencilSettings::gDisabled ==
+                      fCurrDrawState.fStencilSettings));
+            GLuint clipStencilMask = 1 << (stencilBits - 1);
+            GLuint userStencilMask = clipStencilMask - 1;
+
+            unsigned int frontRef  = settings->fFrontFuncRef;
+            unsigned int frontMask = settings->fFrontFuncMask;
+            unsigned int frontWriteMask = settings->fFrontWriteMask;
+            GLenum frontFunc;
+
+            if (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit) {
+
+                GrAssert(settings->fFrontFunc < kBasicStencilFuncCount);
+                frontFunc = grToGLStencilFunc[settings->fFrontFunc];
+            } else {
+                frontFunc = grToGLStencilFunc[ConvertStencilFunc(stencilClip, settings->fFrontFunc)];
+
+                ConvertStencilFuncAndMask(settings->fFrontFunc,
+                                          stencilClip,
+                                          clipStencilMask,
+                                          userStencilMask,
+                                          &frontRef,
+                                          &frontMask);
+                frontWriteMask &= userStencilMask;
+            }
+            GrAssert(settings->fFrontFailOp >= 0 &&
+                     settings->fFrontFailOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fFrontPassOp >= 0 &&
+                     settings->fFrontPassOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fBackFailOp >= 0 &&
+                     settings->fBackFailOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            GrAssert(settings->fBackPassOp >= 0 &&
+                     settings->fBackPassOp < GR_ARRAY_COUNT(grToGLStencilOp));
+            if (fTwoSidedStencilSupport) {
+                GLenum backFunc;
+
+                unsigned int backRef  = settings->fBackFuncRef;
+                unsigned int backMask = settings->fBackFuncMask;
+                unsigned int backWriteMask = settings->fBackWriteMask;
+
+
+                if (fCurrDrawState.fFlagBits & kModifyStencilClip_StateBit) {
+                    GrAssert(settings->fBackFunc < kBasicStencilFuncCount);
+                    backFunc = grToGLStencilFunc[settings->fBackFunc];
+                } else {
+                    backFunc = grToGLStencilFunc[ConvertStencilFunc(stencilClip, settings->fBackFunc)];
+                    ConvertStencilFuncAndMask(settings->fBackFunc,
+                                              stencilClip,
+                                              clipStencilMask,
+                                              userStencilMask,
+                                              &backRef,
+                                              &backMask);
+                    backWriteMask &= userStencilMask;
+                }
+
+                GR_GL(StencilFuncSeparate(GL_FRONT, frontFunc, frontRef, frontMask));
+                GR_GL(StencilMaskSeparate(GL_FRONT, frontWriteMask));
+                GR_GL(StencilFuncSeparate(GL_BACK, backFunc, backRef, backMask));
+                GR_GL(StencilMaskSeparate(GL_BACK, backWriteMask));
+                GR_GL(StencilOpSeparate(GL_FRONT, grToGLStencilOp[settings->fFrontFailOp],
+                                                  grToGLStencilOp[settings->fFrontPassOp],
+                                                  grToGLStencilOp[settings->fFrontPassOp]));
+
+                GR_GL(StencilOpSeparate(GL_BACK,  grToGLStencilOp[settings->fBackFailOp],
+                                                  grToGLStencilOp[settings->fBackPassOp],
+                                                  grToGLStencilOp[settings->fBackPassOp]));
+            } else {
+                GR_GL(StencilFunc(frontFunc, frontRef, frontMask));
+                GR_GL(StencilMask(frontWriteMask));
+                GR_GL(StencilOp(grToGLStencilOp[settings->fFrontFailOp],
+                                grToGLStencilOp[settings->fFrontPassOp],
+                                grToGLStencilOp[settings->fFrontPassOp]));
+            }
+        }
+        fHWDrawState.fStencilSettings = fCurrDrawState.fStencilSettings;
+        fHWStencilClip = stencilClip;
+    }
+}
+
+bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) {
+
+    // GrGpu::setupClipAndFlushState should have already checked this
+    // and bailed if not true.
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+
+    for (int s = 0; s < kNumStages; ++s) {
+        bool usingTexture = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
+
+        // bind texture and set sampler state
+        if (usingTexture) {
+            GrGLTexture* nextTexture = (GrGLTexture*)fCurrDrawState.fTextures[s];
+
+            if (NULL != nextTexture) {
+                // if we created a rt/tex and rendered to it without using a
+                // texture and now we're texuring from the rt it will still be
+                // the last bound texture, but it needs resolving. So keep this
+                // out of the "last != next" check.
+                resolveTextureRenderTarget(nextTexture);
+
+                if (fHWDrawState.fTextures[s] != nextTexture) {
+                    setTextureUnit(s);
+                    GR_GL(BindTexture(GL_TEXTURE_2D, nextTexture->textureID()));
+                #if GR_COLLECT_STATS
+                    ++fStats.fTextureChngCnt;
+                #endif
+                    //GrPrintf("---- bindtexture %d\n", nextTexture->textureID());
+                    fHWDrawState.fTextures[s] = nextTexture;
+                }
+
+                const GrSamplerState& sampler = fCurrDrawState.fSamplerStates[s];
+                const GrGLTexture::TexParams& oldTexParams =
+                                                    nextTexture->getTexParams();
+                GrGLTexture::TexParams newTexParams;
+
+                newTexParams.fFilter = sampler.isFilter() ? GL_LINEAR :
+                                                            GL_NEAREST;
+                newTexParams.fWrapS =
+                            GrGLTexture::gWrapMode2GLWrap[sampler.getWrapX()];
+                newTexParams.fWrapT =
+                            GrGLTexture::gWrapMode2GLWrap[sampler.getWrapY()];
+
+                if (newTexParams.fFilter != oldTexParams.fFilter) {
+                    setTextureUnit(s);
+                    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                                        GL_TEXTURE_MAG_FILTER,
+                                        newTexParams.fFilter));
+                    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                                        GL_TEXTURE_MIN_FILTER,
+                                        newTexParams.fFilter));
+                }
+                if (newTexParams.fWrapS != oldTexParams.fWrapS) {
+                    setTextureUnit(s);
+                    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                                        GL_TEXTURE_WRAP_S,
+                                        newTexParams.fWrapS));
+                }
+                if (newTexParams.fWrapT != oldTexParams.fWrapT) {
+                    setTextureUnit(s);
+                    GR_GL(TexParameteri(GL_TEXTURE_2D,
+                                        GL_TEXTURE_WRAP_T,
+                                        newTexParams.fWrapT));
+                }
+                nextTexture->setTexParams(newTexParams);
+
+                // The texture matrix has to compensate for texture width/height
+                // and NPOT-embedded-in-POT
+                fDirtyFlags.fTextureChangedMask |= (1 << s);
+            } else {
+                GrAssert(!"Rendering with texture vert flag set but no texture");
+                return false;
+            }
+        }
+    }
+
+    flushRenderTarget();
+
+    if ((fCurrDrawState.fFlagBits & kDither_StateBit) !=
+        (fHWDrawState.fFlagBits & kDither_StateBit)) {
+        if (fCurrDrawState.fFlagBits & kDither_StateBit) {
+            GR_GL(Enable(GL_DITHER));
+        } else {
+            GR_GL(Disable(GL_DITHER));
+        }
+    }
+
+    if ((fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) !=
+        (fHWDrawState.fFlagBits & kNoColorWrites_StateBit)) {
+        GLenum mask;
+        if (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit) {
+            mask = GL_FALSE;
+        } else {
+            mask = GL_TRUE;
+        }
+        GR_GL(ColorMask(mask, mask, mask, mask));
+    }
+
+#if GR_SUPPORT_GLDESKTOP
+    // ES doesn't support toggling GL_MULTISAMPLE and doesn't have
+    // smooth lines.
+    if (fDirtyFlags.fRenderTargetChanged ||
+        (fCurrDrawState.fFlagBits & kAntialias_StateBit) !=
+        (fHWDrawState.fFlagBits & kAntialias_StateBit)) {
+        GLint msaa = 0;
+        // only perform query if we know MSAA is supported.
+        // calling on non-MSAA target caused a crash in one environment,
+        // though I don't think it should.
+        if (fAASamples[kHigh_AALevel]) {
+            GR_GL_GetIntegerv(GL_SAMPLE_BUFFERS, &msaa);
+        }
+        if (fCurrDrawState.fFlagBits & kAntialias_StateBit) {
+            if (msaa) {
+                GR_GL(Enable(GL_MULTISAMPLE));
+            } else {
+                GR_GL(Enable(GL_LINE_SMOOTH));
+            }
+        } else {
+            if (msaa) {
+                GR_GL(Disable(GL_MULTISAMPLE));
+            }
+            GR_GL(Disable(GL_LINE_SMOOTH));
+        }
+    }
+#endif
+
+    bool blendOff = canDisableBlend();
+    if (fHWBlendDisabled != blendOff) {
+        if (blendOff) {
+            GR_GL(Disable(GL_BLEND));
+        } else {
+            GR_GL(Enable(GL_BLEND));
+        }
+        fHWBlendDisabled = blendOff;
+    }
+
+    if (!blendOff) {
+        if (fHWDrawState.fSrcBlend != fCurrDrawState.fSrcBlend ||
+              fHWDrawState.fDstBlend != fCurrDrawState.fDstBlend) {
+            GR_GL(BlendFunc(gXfermodeCoeff2Blend[fCurrDrawState.fSrcBlend],
+                            gXfermodeCoeff2Blend[fCurrDrawState.fDstBlend]));
+            fHWDrawState.fSrcBlend = fCurrDrawState.fSrcBlend;
+            fHWDrawState.fDstBlend = fCurrDrawState.fDstBlend;
+        }
+    }
+
+    if (fHWDrawState.fDrawFace != fCurrDrawState.fDrawFace) {
+        switch (fCurrDrawState.fDrawFace) {
+            case kCCW_DrawFace:
+                glEnable(GL_CULL_FACE);
+                GR_GL(CullFace(GL_BACK));
+                break;
+            case kCW_DrawFace:
+                GR_GL(Enable(GL_CULL_FACE));
+                GR_GL(CullFace(GL_FRONT));
+                break;
+            case kBoth_DrawFace:
+                GR_GL(Disable(GL_CULL_FACE));
+                break;
+            default:
+                GrCrash("Unknown draw face.");
+        }
+        fHWDrawState.fDrawFace = fCurrDrawState.fDrawFace;
+    }
+
+#if GR_DEBUG
+    // check for circular rendering
+    for (int s = 0; s < kNumStages; ++s) {
+        GrAssert(!VertexUsesStage(s, fGeometrySrc.fVertexLayout) ||
+                 NULL == fCurrDrawState.fRenderTarget ||
+                 NULL == fCurrDrawState.fTextures[s] ||
+                 fCurrDrawState.fTextures[s]->asRenderTarget() !=
+                    fCurrDrawState.fRenderTarget);
+    }
+#endif
+
+    flushStencil();
+
+    // flushStencil may look at the private state bits, so keep it before this.
+    fHWDrawState.fFlagBits = fCurrDrawState.fFlagBits;
+    return true;
+}
+
+void GrGpuGL::notifyVertexBufferBind(const GrGLVertexBuffer* buffer) {
+    if (fHWGeometryState.fVertexBuffer != buffer) {
+        fHWGeometryState.fArrayPtrsDirty = true;
+        fHWGeometryState.fVertexBuffer = buffer;
+    }
+}
+
+void GrGpuGL::notifyVertexBufferDelete(const GrGLVertexBuffer* buffer) {
+    GrAssert(!(kBuffer_GeometrySrcType == fGeometrySrc.fVertexSrc &&
+               buffer == fGeometrySrc.fVertexBuffer));
+
+    if (fHWGeometryState.fVertexBuffer == buffer) {
+        // deleting bound buffer does implied bind to 0
+        fHWGeometryState.fVertexBuffer = NULL;
+        fHWGeometryState.fArrayPtrsDirty = true;
+    }
+}
+
+void GrGpuGL::notifyIndexBufferBind(const GrGLIndexBuffer* buffer) {
+    fGeometrySrc.fIndexBuffer = buffer;
+}
+
+void GrGpuGL::notifyIndexBufferDelete(const GrGLIndexBuffer* buffer) {
+    GrAssert(!(kBuffer_GeometrySrcType == fGeometrySrc.fIndexSrc &&
+               buffer == fGeometrySrc.fIndexBuffer));
+
+    if (fHWGeometryState.fIndexBuffer == buffer) {
+        // deleting bound buffer does implied bind to 0
+        fHWGeometryState.fIndexBuffer = NULL;
+    }
+}
+
+void GrGpuGL::notifyRenderTargetDelete(GrRenderTarget* renderTarget) {
+    GrAssert(NULL != renderTarget);
+    if (fCurrDrawState.fRenderTarget == renderTarget) {
+        fCurrDrawState.fRenderTarget = NULL;
+    }
+    if (fHWDrawState.fRenderTarget == renderTarget) {
+        fHWDrawState.fRenderTarget = NULL;
+    }
+}
+
+void GrGpuGL::notifyTextureDelete(GrGLTexture* texture) {
+    for (int s = 0; s < kNumStages; ++s) {
+        if (fCurrDrawState.fTextures[s] == texture) {
+            fCurrDrawState.fTextures[s] = NULL;
+        }
+        if (fHWDrawState.fTextures[s] == texture) {
+            // deleting bound texture does implied bind to 0
+            fHWDrawState.fTextures[s] = NULL;
+       }
+    }
+}
+
+bool GrGpuGL::canBeTexture(GrTexture::PixelConfig config,
+                           GLenum* internalFormat,
+                           GLenum* format,
+                           GLenum* type) {
+    switch (config) {
+        case GrTexture::kRGBA_8888_PixelConfig:
+        case GrTexture::kRGBX_8888_PixelConfig: // todo: can we tell it our X?
+            *format = GR_GL_32BPP_COLOR_FORMAT;
+#if GR_SUPPORT_GLES
+            // according to GL_EXT_texture_format_BGRA8888 the *internal*
+            // format for a BGRA is BGRA not RGBA (as on desktop)
+            *internalFormat = GR_GL_32BPP_COLOR_FORMAT;
+#else
+            *internalFormat = GL_RGBA;
+#endif
+            *type = GL_UNSIGNED_BYTE;
+            break;
+        case GrTexture::kRGB_565_PixelConfig:
+            *format = GL_RGB;
+            *internalFormat = GL_RGB;
+            *type = GL_UNSIGNED_SHORT_5_6_5;
+            break;
+        case GrTexture::kRGBA_4444_PixelConfig:
+            *format = GL_RGBA;
+            *internalFormat = GL_RGBA;
+            *type = GL_UNSIGNED_SHORT_4_4_4_4;
+            break;
+        case GrTexture::kIndex_8_PixelConfig:
+            if (this->supports8BitPalette()) {
+                *format = GR_PALETTE8_RGBA8;
+                *internalFormat = GR_PALETTE8_RGBA8;
+                *type = GL_UNSIGNED_BYTE;   // unused I think
+            } else {
+                return false;
+            }
+            break;
+        case GrTexture::kAlpha_8_PixelConfig:
+            *format = GL_ALPHA;
+            *internalFormat = GL_ALPHA;
+            *type = GL_UNSIGNED_BYTE;
+            break;
+        default:
+            return false;
+    }
+    return true;
+}
+
+void GrGpuGL::setTextureUnit(int unit) {
+    GrAssert(unit >= 0 && unit < kNumStages);
+    if (fActiveTextureUnitIdx != unit) {
+        GR_GL(ActiveTexture(GL_TEXTURE0 + unit));
+        fActiveTextureUnitIdx = unit;
+    }
+}
+
+void GrGpuGL::setSpareTextureUnit() {
+    if (fActiveTextureUnitIdx != (GL_TEXTURE0 + SPARE_TEX_UNIT)) {
+        GR_GL(ActiveTexture(GL_TEXTURE0 + SPARE_TEX_UNIT));
+        fActiveTextureUnitIdx = SPARE_TEX_UNIT;
+    }
+}
+
+/* On ES the internalFormat and format must match for TexImage and we use
+   GL_RGB, GL_RGBA for color formats. We also generally like having the driver
+   decide the internalFormat. However, on ES internalFormat for
+   RenderBufferStorage* has to be a specific format (not a base format like
+   GL_RGBA).
+ */
+bool GrGpuGL::fboInternalFormat(GrTexture::PixelConfig config, GLenum* format) {
+    switch (config) {
+        case GrTexture::kRGBA_8888_PixelConfig:
+        case GrTexture::kRGBX_8888_PixelConfig:
+            if (fRGBA8Renderbuffer) {
+                *format = GR_RGBA8;
+                return true;
+            } else {
+                return false;
+            }
+#if GR_SUPPORT_GLES // ES2 supports 565. ES1 supports it with FBO extension
+                    // desktop GL has no such internal format
+        case GrTexture::kRGB_565_PixelConfig:
+            *format = GR_RGB565;
+            return true;
+#endif
+        case GrTexture::kRGBA_4444_PixelConfig:
+            *format = GL_RGBA4;
+            return true;
+        default:
+            return false;
+    }
+}
+
+void GrGpuGL::resetDirtyFlags() {
+    Gr_bzero(&fDirtyFlags, sizeof(fDirtyFlags));
+}
+
+void GrGpuGL::setBuffers(bool indexed,
+                         int* extraVertexOffset,
+                         int* extraIndexOffset) {
+
+    GrAssert(NULL != extraVertexOffset);
+
+    GrGLVertexBuffer* vbuf;
+    switch (fGeometrySrc.fVertexSrc) {
+    case kBuffer_GeometrySrcType:
+        *extraVertexOffset = 0;
+        vbuf = (GrGLVertexBuffer*) fGeometrySrc.fVertexBuffer;
+        break;
+    case kArray_GeometrySrcType:
+    case kReserved_GeometrySrcType:
+        finalizeReservedVertices();
+        *extraVertexOffset = fCurrPoolStartVertex;
+        vbuf = (GrGLVertexBuffer*) fCurrPoolVertexBuffer;
+        break;
+    default:
+        vbuf = NULL; // suppress warning
+        GrCrash("Unknown geometry src type!");
+    }
+
+    GrAssert(NULL != vbuf);
+    GrAssert(!vbuf->isLocked());
+    if (fHWGeometryState.fVertexBuffer != vbuf) {
+        GR_GL(BindBuffer(GL_ARRAY_BUFFER, vbuf->bufferID()));
+        fHWGeometryState.fArrayPtrsDirty = true;
+        fHWGeometryState.fVertexBuffer = vbuf;
+    }
+
+    if (indexed) {
+        GrAssert(NULL != extraIndexOffset);
+
+        GrGLIndexBuffer* ibuf;
+        switch (fGeometrySrc.fIndexSrc) {
+        case kBuffer_GeometrySrcType:
+            *extraIndexOffset = 0;
+            ibuf = (GrGLIndexBuffer*)fGeometrySrc.fIndexBuffer;
+            break;
+        case kArray_GeometrySrcType:
+        case kReserved_GeometrySrcType:
+            finalizeReservedIndices();
+            *extraIndexOffset = fCurrPoolStartIndex;
+            ibuf = (GrGLIndexBuffer*) fCurrPoolIndexBuffer;
+            break;
+        default:
+            ibuf = NULL; // suppress warning
+            GrCrash("Unknown geometry src type!");
+        }
+
+        GrAssert(NULL != ibuf);
+        GrAssert(!ibuf->isLocked());
+        if (fHWGeometryState.fIndexBuffer != ibuf) {
+            GR_GL(BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf->bufferID()));
+            fHWGeometryState.fIndexBuffer = ibuf;
+        }
+    }
+}
diff --git a/gpu/src/GrGpuGL.h b/gpu/src/GrGpuGL.h
new file mode 100644
index 0000000..f9a6987
--- /dev/null
+++ b/gpu/src/GrGpuGL.h
@@ -0,0 +1,193 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGpuGL_DEFINED
+#define GrGpuGL_DEFINED
+
+#include "GrGpu.h"
+#include "GrGLConfig.h"
+#include "GrGLIRect.h"
+#include "GrGLTexture.h"
+
+#include "GrGLVertexBuffer.h"
+#include "GrGLIndexBuffer.h"
+
+class GrGpuGL : public GrGpu {
+public:
+            GrGpuGL();
+    virtual ~GrGpuGL();
+
+    /**
+     * Gets the struct containing the GL extensions for the context
+     * underlying the GrGpuGL
+     *
+     * @param struct containing extension function pointers
+     */
+    const GrGLExts& extensions() { return fExts; }
+
+protected:
+    struct {
+        size_t                  fVertexOffset;
+        GrVertexLayout          fVertexLayout;
+        const GrVertexBuffer*   fVertexBuffer;
+        const GrIndexBuffer*    fIndexBuffer;
+        bool                    fArrayPtrsDirty;
+    } fHWGeometryState;
+
+    DrState   fHWDrawState;
+    bool      fHWStencilClip;
+
+    // As flush of GL state proceeds it updates fHDrawState
+    // to reflect the new state. Later parts of the state flush
+    // may perform cascaded changes but cannot refer to fHWDrawState.
+    // These code paths can refer to the dirty flags. Subclass should
+    // call resetDirtyFlags after its flush is complete
+    struct {
+        bool fRenderTargetChanged : 1;
+        int  fTextureChangedMask;
+    } fDirtyFlags;
+    GR_STATIC_ASSERT(8 * sizeof(int) >= kNumStages);
+
+    // clears the dirty flags
+    void resetDirtyFlags();
+
+    // last scissor / viewport scissor state seen by the GL.
+    struct {
+        bool        fScissorEnabled;
+        GrGLIRect   fScissorRect;
+        GrGLIRect   fViewportRect;
+    } fHWBounds;
+
+    GrGLExts fExts;
+
+    // GrGpu overrides
+    // overrides from GrGpu
+    virtual void resetContext();
+
+    virtual GrTexture* createTextureHelper(const TextureDesc& desc,
+                                           const void* srcData,
+                                           size_t rowBytes);
+    virtual GrVertexBuffer* createVertexBufferHelper(uint32_t size,
+                                                     bool dynamic);
+    virtual GrIndexBuffer* createIndexBufferHelper(uint32_t size,
+                                                   bool dynamic);
+
+    virtual GrRenderTarget* createPlatformRenderTargetHelper(
+                                                 intptr_t platformRenderTarget,
+                                                 int stencilBits,
+                                                 int width, int height);
+
+    virtual GrRenderTarget* createRenderTargetFrom3DApiStateHelper();
+
+    virtual void eraseColorHelper(GrColor color);
+
+    virtual void forceRenderTargetFlushHelper();
+
+    virtual bool readPixelsHelper(int left, int top, int width, int height,
+                                  GrTexture::PixelConfig, void* buffer);
+
+    virtual void drawIndexedHelper(GrPrimitiveType type,
+                                   uint32_t startVertex,
+                                   uint32_t startIndex,
+                                   uint32_t vertexCount,
+                                   uint32_t indexCount);
+    virtual void drawNonIndexedHelper(GrPrimitiveType type,
+                                      uint32_t vertexCount,
+                                      uint32_t numVertices);
+    virtual void flushScissor(const GrIRect* rect);
+    void eraseStencil(uint32_t value, uint32_t mask);
+    virtual void eraseStencilClip(const GrIRect& rect);
+
+    // binds texture unit in GL
+    void setTextureUnit(int unitIdx);
+
+    // binds appropriate vertex and index buffers, also returns any extra
+    // extra verts or indices to offset by.
+    void setBuffers(bool indexed,
+                    int* extraVertexOffset,
+                    int* extraIndexOffset);
+
+    // flushes state that is common to fixed and programmable GL
+    // dither
+    // line smoothing
+    // blend func
+    // texture binding
+    // sampler state (filtering, tiling)
+    // FBO binding
+    // line width
+    bool flushGLStateCommon(GrPrimitiveType type);
+
+    // adjusts texture matrix to account for orientation, size, and npotness
+    static void AdjustTextureMatrix(const GrGLTexture* texture,
+                                    GrSamplerState::SampleMode mode,
+                                    GrMatrix* matrix);
+
+    // subclass may try to take advantage of identity tex matrices.
+    // This helper determines if matrix will be identity after all
+    // adjustments are applied.
+    static bool TextureMatrixIsIdentity(const GrGLTexture* texture,
+                                        const GrSamplerState& sampler);
+
+private:
+    // notify callbacks to update state tracking when related
+    // objects are bound to GL or deleted outside of the class
+    void notifyVertexBufferBind(const GrGLVertexBuffer* buffer);
+    void notifyVertexBufferDelete(const GrGLVertexBuffer* buffer);
+    void notifyIndexBufferBind(const GrGLIndexBuffer* buffer);
+    void notifyIndexBufferDelete(const GrGLIndexBuffer* buffer);
+    void notifyTextureDelete(GrGLTexture* texture);
+    void notifyRenderTargetDelete(GrRenderTarget* renderTarget);
+
+    void setSpareTextureUnit();
+
+    void flushRenderTarget();
+    void flushStencil();
+    void resolveTextureRenderTarget(GrGLTexture* texture);
+
+    bool canBeTexture(GrTexture::PixelConfig config,
+                      GLenum* internalFormat,
+                      GLenum* format,
+                      GLenum* type);
+    bool fboInternalFormat(GrTexture::PixelConfig config, GLenum* format);
+
+    friend class GrGLVertexBuffer;
+    friend class GrGLIndexBuffer;
+    friend class GrGLTexture;
+    friend class GrGLRenderTarget;
+
+    bool fHWBlendDisabled;
+
+    GLuint fAASamples[4];
+    enum {
+        kNone_MSFBO = 0,
+        kDesktop_MSFBO,
+        kApple_MSFBO,
+        kIMG_MSFBO
+    } fMSFBOType;
+
+    // Do we have stencil wrap ops.
+    bool fHasStencilWrap;
+
+    // ES requires an extension to support RGBA8 in RenderBufferStorage
+    bool fRGBA8Renderbuffer;
+
+    int fActiveTextureUnitIdx;
+
+    typedef GrGpu INHERITED;
+};
+
+#endif
diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp
new file mode 100644
index 0000000..695b22c
--- /dev/null
+++ b/gpu/src/GrGpuGLFixed.cpp
@@ -0,0 +1,327 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrGLConfig.h"
+
+#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP
+
+#include "GrGpuGLFixed.h"
+#include "GrGpuVertex.h"
+
+#define SKIP_CACHE_CHECK    true
+
+struct GrGpuMatrix {
+    GLfloat    fMat[16];
+
+    void reset() {
+        Gr_bzero(fMat, sizeof(fMat));
+        fMat[0] = fMat[5] = fMat[10] = fMat[15] = GR_Scalar1;
+    }
+
+    void set(const GrMatrix& m) {
+        Gr_bzero(fMat, sizeof(fMat));
+        fMat[0]  = GrScalarToFloat(m[GrMatrix::kScaleX]);
+        fMat[4]  = GrScalarToFloat(m[GrMatrix::kSkewX]);
+        fMat[12] = GrScalarToFloat(m[GrMatrix::kTransX]);
+
+        fMat[1]  = GrScalarToFloat(m[GrMatrix::kSkewY]);
+        fMat[5]  = GrScalarToFloat(m[GrMatrix::kScaleY]);
+        fMat[13] = GrScalarToFloat(m[GrMatrix::kTransY]);
+
+        fMat[3]  = GrScalarToFloat(m[GrMatrix::kPersp0]);
+        fMat[7]  = GrScalarToFloat(m[GrMatrix::kPersp1]);
+        fMat[15] = GrScalarToFloat(m[GrMatrix::kPersp2]);
+
+        fMat[10] = 1.f;    // z-scale
+    }
+};
+
+// these must match the order in the corresponding enum in GrGpu.h
+static const GLenum gMatrixMode2Enum[] = {
+    GL_MODELVIEW, GL_TEXTURE
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrGpuGLFixed::GrGpuGLFixed() {
+}
+
+GrGpuGLFixed::~GrGpuGLFixed() {
+}
+
+void GrGpuGLFixed::resetContext() {
+    INHERITED::resetContext();
+
+    GR_GL(Disable(GL_TEXTURE_2D));
+
+    for (int s = 0; s < kNumStages; ++s) {
+        setTextureUnit(s);
+        GR_GL(EnableClientState(GL_VERTEX_ARRAY));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,   GL_MODULATE));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,      GL_TEXTURE0+s));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,      GL_PREVIOUS));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB,  GL_SRC_COLOR));
+
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE0+s));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS));
+        GR_GL(TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA));
+
+        // color oprand0 changes between GL_SRC_COLR and GL_SRC_ALPHA depending
+        // upon whether we have a (premultiplied) RGBA texture or just an ALPHA
+        // texture, e.g.:
+        //glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB,  GL_SRC_COLOR);
+        fHWRGBOperand0[s] = (TextureEnvRGBOperands) -1;
+    }
+
+    fHWGeometryState.fVertexLayout = 0;
+    fHWGeometryState.fVertexOffset  = ~0;
+    GR_GL(EnableClientState(GL_VERTEX_ARRAY));
+    GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY));
+    GR_GL(ShadeModel(GL_FLAT));
+    GR_GL(DisableClientState(GL_COLOR_ARRAY));
+
+    GR_GL(PointSize(1.f));
+
+    GrGLClearErr();
+    fTextVerts = false;
+
+    fBaseVertex = 0xffffffff;
+}
+
+
+void GrGpuGLFixed::flushProjectionMatrix() {
+    float mat[16];
+    Gr_bzero(mat, sizeof(mat));
+
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+
+    mat[0] = 2.f / fCurrDrawState.fRenderTarget->width();
+    mat[5] = -2.f / fCurrDrawState.fRenderTarget->height();
+    mat[10] = -1.f;
+    mat[15] = 1;
+
+    mat[12] = -1.f;
+    mat[13] = 1.f;
+
+    GR_GL(MatrixMode(GL_PROJECTION));
+    GR_GL(LoadMatrixf(mat));
+}
+
+bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) {
+
+    bool usingTextures[kNumStages];
+
+    for (int s = 0; s < kNumStages; ++s) {
+        usingTextures[s] = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
+
+        if (usingTextures[s] && fCurrDrawState.fSamplerStates[s].isGradient()) {
+            unimpl("Fixed pipe doesn't support radial/sweep gradients");
+            return false;
+        }
+    }
+
+    if (!flushGLStateCommon(type)) {
+        return false;
+    }
+
+    if (fDirtyFlags.fRenderTargetChanged) {
+        flushProjectionMatrix();
+    }
+
+    for (int s = 0; s < kNumStages; ++s) {
+        bool wasUsingTexture = VertexUsesStage(s, fHWGeometryState.fVertexLayout);
+        if (usingTextures[s] != wasUsingTexture) {
+            setTextureUnit(s);
+            if (usingTextures[s]) {
+                GR_GL(Enable(GL_TEXTURE_2D));
+            } else {
+                GR_GL(Disable(GL_TEXTURE_2D));
+            }
+        }
+    }
+
+    uint32_t vertColor = (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit);
+    uint32_t prevVertColor = (fHWGeometryState.fVertexLayout &
+                              kColor_VertexLayoutBit);
+
+    if (vertColor != prevVertColor) {
+        if (vertColor) {
+            GR_GL(ShadeModel(GL_SMOOTH));
+            // invalidate the immediate mode color
+            fHWDrawState.fColor = GrColor_ILLEGAL;
+        } else {
+            GR_GL(ShadeModel(GL_FLAT));
+        }
+    }
+
+
+    if (!vertColor && fHWDrawState.fColor != fCurrDrawState.fColor) {
+        GR_GL(Color4ub(GrColorUnpackR(fCurrDrawState.fColor),
+                       GrColorUnpackG(fCurrDrawState.fColor),
+                       GrColorUnpackB(fCurrDrawState.fColor),
+                       GrColorUnpackA(fCurrDrawState.fColor)));
+        fHWDrawState.fColor = fCurrDrawState.fColor;
+    }
+
+    // set texture environment, decide whether we are modulating by RGB or A.
+    for (int s = 0; s < kNumStages; ++s) {
+        if (usingTextures[s]) {
+            GrGLTexture* texture = (GrGLTexture*)fCurrDrawState.fTextures[s];
+            if (NULL != texture) {
+                TextureEnvRGBOperands nextRGBOperand0 =
+                    (texture->config() == GrTexture::kAlpha_8_PixelConfig) ?
+                        kAlpha_TextureEnvRGBOperand :
+                        kColor_TextureEnvRGBOperand;
+                if (fHWRGBOperand0[s] != nextRGBOperand0) {
+                    setTextureUnit(s);
+                    GR_GL(TexEnvi(GL_TEXTURE_ENV,
+                                  GL_OPERAND0_RGB,
+                                  (nextRGBOperand0==kAlpha_TextureEnvRGBOperand) ?
+                                    GL_SRC_ALPHA :
+                                    GL_SRC_COLOR));
+                    fHWRGBOperand0[s] = nextRGBOperand0;
+                }
+
+                if (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
+                    (fHWDrawState.fSamplerStates[s].getMatrix() !=
+                     getSamplerMatrix(s))) {
+
+                    GrMatrix texMat = getSamplerMatrix(s);
+                    AdjustTextureMatrix(texture,
+                                        GrSamplerState::kNormal_SampleMode,
+                                        &texMat);
+                    GrGpuMatrix glm;
+                    glm.set(texMat);
+                    setTextureUnit(s);
+                    GR_GL(MatrixMode(GL_TEXTURE));
+                    GR_GL(LoadMatrixf(glm.fMat));
+                    recordHWSamplerMatrix(s, getSamplerMatrix(s));
+                }
+            } else {
+                GrAssert(!"Rendering with texture vert flag set but no bound texture");
+                return false;
+            }
+        }
+    }
+
+    if (fHWDrawState.fViewMatrix != fCurrDrawState.fViewMatrix) {
+        GrGpuMatrix glm;
+        glm.set(fCurrDrawState.fViewMatrix);
+        GR_GL(MatrixMode(GL_MODELVIEW));
+        GR_GL(LoadMatrixf(glm.fMat));
+        fHWDrawState.fViewMatrix =
+        fCurrDrawState.fViewMatrix;
+    }
+    resetDirtyFlags();
+    return true;
+}
+
+void GrGpuGLFixed::setupGeometry(int* startVertex,
+                                 int* startIndex,
+                                 int vertexCount,
+                                 int indexCount) {
+
+    int newColorOffset;
+    int newTexCoordOffsets[kNumStages];
+
+    GLsizei newStride = VertexSizeAndOffsetsByStage(fGeometrySrc.fVertexLayout,
+                                                    newTexCoordOffsets,
+                                                    &newColorOffset);
+    int oldColorOffset;
+    int oldTexCoordOffsets[kNumStages];
+    GLsizei oldStride = VertexSizeAndOffsetsByStage(fHWGeometryState.fVertexLayout,
+                                                    oldTexCoordOffsets,
+                                                    &oldColorOffset);
+
+    bool indexed = NULL != startIndex;
+
+    int extraVertexOffset;
+    int extraIndexOffset;
+    setBuffers(indexed, &extraVertexOffset, &extraIndexOffset);
+
+    GLenum scalarType;
+    if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) {
+        scalarType = GrGLTextType;
+    } else {
+        scalarType = GrGLType;
+    }
+
+    size_t vertexOffset = (*startVertex + extraVertexOffset) * newStride;
+    *startVertex = 0;
+    if (indexed) {
+        *startIndex += extraIndexOffset;
+    }
+
+    // all the Pointers must be set if any of these are true
+    bool allOffsetsChange =  fHWGeometryState.fArrayPtrsDirty ||
+                             vertexOffset != fHWGeometryState.fVertexOffset ||
+                             newStride != oldStride;
+
+    // position and tex coord offsets change if above conditions are true
+    // or the type changed based on text vs nontext type coords.
+    bool posAndTexChange = allOffsetsChange ||
+                           ((GrGLTextType != GrGLType) &&
+                                (kTextFormat_VertexLayoutBit &
+                                  (fHWGeometryState.fVertexLayout ^
+                                   fGeometrySrc.fVertexLayout)));
+
+    if (posAndTexChange) {
+        GR_GL(VertexPointer(2, scalarType, newStride, (GLvoid*)vertexOffset));
+        fHWGeometryState.fVertexOffset = vertexOffset;
+    }
+
+    for (int s = 0; s < kNumStages; ++s) {
+        // need to enable array if tex coord offset is 0
+        // (using positions as coords)
+        if (newTexCoordOffsets[s] >= 0) {
+            GLvoid* texCoordOffset = (GLvoid*)(vertexOffset + newTexCoordOffsets[s]);
+            if (oldTexCoordOffsets[s] < 0) {
+                GR_GL(ClientActiveTexture(GL_TEXTURE0+s));
+                GR_GL(EnableClientState(GL_TEXTURE_COORD_ARRAY));
+                GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset));
+            } else if (posAndTexChange ||
+                       newTexCoordOffsets[s] != oldTexCoordOffsets[s]) {
+                GR_GL(ClientActiveTexture(GL_TEXTURE0+s));
+                GR_GL(TexCoordPointer(2, scalarType, newStride, texCoordOffset));
+            }
+        } else if (oldTexCoordOffsets[s] >= 0) {
+            GR_GL(ClientActiveTexture(GL_TEXTURE0+s));
+            GR_GL(DisableClientState(GL_TEXTURE_COORD_ARRAY));
+        }
+    }
+
+    if (newColorOffset > 0) {
+        GLvoid* colorOffset = (GLvoid*)(vertexOffset + newColorOffset);
+        if (oldColorOffset <= 0) {
+            GR_GL(EnableClientState(GL_COLOR_ARRAY));
+            GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorOffset));
+        } else if (allOffsetsChange || newColorOffset != oldColorOffset) {
+            GR_GL(ColorPointer(4, GL_UNSIGNED_BYTE, newStride, colorOffset));
+        }
+    } else if (oldColorOffset > 0) {
+        GR_GL(DisableClientState(GL_COLOR_ARRAY));
+    }
+
+    fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
+    fHWGeometryState.fArrayPtrsDirty = false;
+}
+
+#endif
+
diff --git a/gpu/src/GrGpuGLFixed.h b/gpu/src/GrGpuGLFixed.h
new file mode 100644
index 0000000..077b6e2
--- /dev/null
+++ b/gpu/src/GrGpuGLFixed.h
@@ -0,0 +1,72 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGpuGLFixed_DEFINED
+#define GrGpuGLFixed_DEFINED
+
+#include "GrGpuGL.h"
+
+// Fixed Pipeline OpenGL or OpenGL ES 1.x
+class GrGpuGLFixed : public GrGpuGL {
+public:
+             GrGpuGLFixed();
+    virtual ~GrGpuGLFixed();
+
+protected:
+    // overrides from GrGpu
+    virtual bool flushGraphicsState(GrPrimitiveType type);
+    virtual void setupGeometry(int* startVertex,
+                               int* startIndex,
+                               int vertexCount,
+                               int indexCount);
+
+private:
+    virtual void resetContext();
+
+    // Helpers to make code more readable
+    const GrMatrix& getHWSamplerMatrix(int stage) const {
+        return fHWDrawState.fSamplerStates[stage].getMatrix();
+    }
+    const void recordHWSamplerMatrix(int stage, const GrMatrix& matrix) {
+        fHWDrawState.fSamplerStates[stage].setMatrix(matrix);
+    }
+
+    // when the texture is GL_RGBA we set the GL_COMBINE texture
+    // environment rgb operand 0 to be GL_COLOR to modulate each incoming
+    // R,G, & B by the texture's R, G, & B. When the texture is alpha-only we
+    // set the operand to GL_ALPHA so that the incoming frag's R, G, &B are all
+    // modulated by the texture's A.
+    enum TextureEnvRGBOperands {
+        kAlpha_TextureEnvRGBOperand,
+        kColor_TextureEnvRGBOperand,
+    };
+    TextureEnvRGBOperands fHWRGBOperand0[kNumStages];
+
+    void flushProjectionMatrix();
+
+    // are the currently bound vertex buffers/arrays laid
+    // out for text or other drawing.
+    bool fTextVerts;
+
+    // On GL we have to build the base vertex offset into the
+    // glVertexPointer/glTexCoordPointer/etc
+    int fBaseVertex;
+
+    typedef GrGpuGL INHERITED;
+};
+
+#endif
diff --git a/gpu/src/GrGpuGLShaders2.cpp b/gpu/src/GrGpuGLShaders2.cpp
new file mode 100644
index 0000000..f79e9c8
--- /dev/null
+++ b/gpu/src/GrGpuGLShaders2.cpp
@@ -0,0 +1,1406 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrGLConfig.h"
+
+#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP
+
+#include "GrGpuGLShaders2.h"
+#include "GrGpuVertex.h"
+#include "GrMemory.h"
+#include "GrStringBuilder.h"
+
+
+#define ATTRIBUTE_MATRIX        0
+
+#define PRINT_SHADERS           0
+
+#define SKIP_CACHE_CHECK    true
+
+#if GR_SUPPORT_GLES2
+    #define GR_PRECISION                "mediump"
+    const char GR_SHADER_PRECISION[] =  "precision mediump float;\n";
+#else
+    #define GR_PRECISION                ""
+    const char GR_SHADER_PRECISION[] =  "";
+#endif
+
+
+#define POS_ATTR_LOCATION 0
+#define TEX_ATTR_LOCATION(X) (1 + X)
+#define COL_ATTR_LOCATION (2 + GrDrawTarget::kMaxTexCoords)
+#if ATTRIBUTE_MATRIX
+#define VIEWMAT_ATTR_LOCATION (3 + GrDrawTarget::kMaxTexCoords)
+#define TEXMAT_ATTR_LOCATION(X) (6 + GrDrawTarget::kMaxTexCoords + 3 * (X))
+#define BOGUS_MATRIX_UNI_LOCATION 1000
+#endif
+
+#define GR_UINT32_MAX   static_cast<uint32_t>(-1)
+
+struct GrGpuGLShaders2::StageUniLocations {
+    GLint fTextureMatrixUni;
+    GLint fSamplerUni;
+    GLint fRadial2Uni;
+};
+
+struct GrGpuGLShaders2::UniLocations {
+    GLint fViewMatrixUni;
+    StageUniLocations fStages[kNumStages];
+};
+
+// Records per-program information
+// we can specify the attribute locations so that they are constant
+// across our shaders. But the driver determines the uniform locations
+// at link time. We don't need to remember the sampler uniform location
+// because we will bind a texture slot to it and never change it
+// Uniforms are program-local so we can't rely on fHWState to hold the
+// previous uniform state after a program change.
+struct  GrGpuGLShaders2::Program {
+    // IDs
+    GLuint    fVShaderID;
+    GLuint    fFShaderID;
+    GLuint    fProgramID;
+
+    // shader uniform locations (-1 if shader doesn't use them)
+    UniLocations fUniLocations;
+
+    // these reflect the current values of uniforms
+    // (GL uniform values travel with program)
+    GrMatrix                    fViewMatrix;
+    GrMatrix                    fTextureMatrices[kNumStages];
+    GrScalar                    fRadial2CenterX1[kNumStages];
+    GrScalar                    fRadial2Radius0[kNumStages];
+    bool                        fRadial2PosRoot[kNumStages];
+
+};
+
+// must be tightly packed
+struct GrGpuGLShaders2::StageDesc {
+    enum OptFlagBits {
+        kNoPerspective_OptFlagBit  = 0x1,
+        kIdentityMatrix_OptFlagBit = 0x2,
+    };
+    unsigned fOptFlags : 8;
+
+    unsigned fEnabled : 8;
+
+    enum Modulation {
+        kColor_Modulation,
+        kAlpha_Modulation,
+    } fModulation : 8;
+
+    enum CoordMapping {
+        kIdentity_CoordMapping,
+        kRadialGradient_CoordMapping,
+        kSweepGradient_CoordMapping,
+        kRadial2Gradient_CoordMapping,
+    } fCoordMapping : 8;
+};
+
+// must be tightly packed
+struct GrGpuGLShaders2::ProgramDesc {
+    GrVertexLayout fVertexLayout;
+    GR_STATIC_ASSERT(2 == sizeof(GrVertexLayout)); // pack with next field
+
+    enum {
+        kNotPoints_OptFlagBit = 0x1,
+        kVertexColorAllOnes_OptFlagBit = 0x2,
+    };
+    // we're assuming optflags and layout pack into 32 bits
+    // VS 2010 seems to require short rather than just unsigned
+    // for this to pack
+    unsigned short fOptFlags : 16;
+
+    StageDesc fStages[kNumStages];
+
+    bool operator == (const ProgramDesc& desc) const {
+        // keep 4-byte aligned and tightly packed
+        GR_STATIC_ASSERT(4 == sizeof(StageDesc));
+        GR_STATIC_ASSERT(2 + 2 + 4 * kNumStages == sizeof(ProgramDesc));
+        return 0 == memcmp(this, &desc, sizeof(ProgramDesc));
+    }
+};
+
+#include "GrTHashCache.h"
+
+class GrGpuGLShaders2::ProgramCache : public ::GrNoncopyable {
+private:
+    struct Entry;
+    class HashKey {
+    public:
+        HashKey();
+        HashKey(const ProgramDesc& desc);
+        static const HashKey& GetKey(const Entry&);
+        static bool EQ(const Entry&, const HashKey&);
+        static bool LT(const Entry&, const HashKey&);
+        bool operator <(const HashKey& key) const;
+        bool operator ==(const HashKey& key) const;
+        uint32_t getHash() const;
+    private:
+        ProgramDesc fDesc;
+        uint32_t fHash;
+    };
+
+    struct Entry {
+        Program     fProgram;
+        HashKey     fKey;
+        uint32_t    fLRUStamp;
+    };
+
+    // if hash bits is changed, need to change hash function
+    GrTHashTable<Entry, HashKey, 8> fHashCache;
+
+    static const int MAX_ENTRIES = 16;
+    Entry        fEntries[MAX_ENTRIES];
+    int          fCount;
+    uint32_t     fCurrLRUStamp;
+
+public:
+    ProgramCache() {
+        fCount        = 0;
+        fCurrLRUStamp = 0;
+    }
+
+    ~ProgramCache() {
+        for (int i = 0; i < fCount; ++i) {
+            GrGpuGLShaders2::DeleteProgram(&fEntries[i].fProgram);
+        }
+    }
+
+    void abandon() {
+        fCount = 0;
+    }
+
+    void invalidateViewMatrices() {
+        for (int i = 0; i < fCount; ++i) {
+            // set to illegal matrix
+            fEntries[i].fProgram.fViewMatrix = GrMatrix::InvalidMatrix();
+        }
+    }
+
+    Program* getProgram(const ProgramDesc& desc) {
+        HashKey key(desc);
+        Entry* entry = fHashCache.find(key);
+        if (NULL == entry) {
+            if (fCount < MAX_ENTRIES) {
+                entry = fEntries + fCount;
+                ++fCount;
+            } else {
+                GrAssert(MAX_ENTRIES == fCount);
+                entry = fEntries;
+                for (int i = 1; i < MAX_ENTRIES; ++i) {
+                    if (fEntries[i].fLRUStamp < entry->fLRUStamp) {
+                        entry = fEntries + i;
+                    }
+                }
+                fHashCache.remove(entry->fKey, entry);
+                GrGpuGLShaders2::DeleteProgram(&entry->fProgram);
+            }
+            entry->fKey = key;
+            GrGpuGLShaders2::GenProgram(desc, &entry->fProgram);
+            fHashCache.insert(entry->fKey, entry);
+        }
+
+        entry->fLRUStamp = fCurrLRUStamp;
+        if (GR_UINT32_MAX == fCurrLRUStamp) {
+            // wrap around! just trash our LRU, one time hit.
+            for (int i = 0; i < fCount; ++i) {
+                fEntries[i].fLRUStamp = 0;
+            }
+        }
+        ++fCurrLRUStamp;
+        return &entry->fProgram;
+    }
+};
+
+GrGpuGLShaders2::ProgramCache::HashKey::HashKey() {
+}
+
+static uint32_t ror(uint32_t x) {
+    return (x >> 8) | (x << 24);
+}
+
+static uint32_t rol(uint32_t x) {
+    return (x << 8) | (x >> 24);
+}
+
+GrGpuGLShaders2::ProgramCache::HashKey::HashKey(const ProgramDesc& desc) {
+    fDesc = desc;
+    // if you change the size of the desc, need to update the hash function
+    GR_STATIC_ASSERT(12 == sizeof(ProgramDesc));
+
+    uint32_t* d = GrTCast<uint32_t*>(&fDesc);
+    fHash = d[0] ^ ror(d[1]) ^ rol(d[2]);
+}
+
+bool GrGpuGLShaders2::ProgramCache::HashKey::EQ(const Entry& entry,
+                                                const HashKey& key) {
+    return entry.fKey == key;
+}
+
+bool GrGpuGLShaders2::ProgramCache::HashKey::LT(const Entry& entry,
+                                                const HashKey& key) {
+    return entry.fKey < key;
+}
+
+bool GrGpuGLShaders2::ProgramCache::HashKey::operator ==(const HashKey& key) const {
+    return fDesc == key.fDesc;
+}
+
+bool GrGpuGLShaders2::ProgramCache::HashKey::operator <(const HashKey& key) const {
+    return memcmp(&fDesc, &key.fDesc, sizeof(HashKey)) < 0;
+}
+
+uint32_t GrGpuGLShaders2::ProgramCache::HashKey::getHash() const {
+    return fHash;
+}
+
+struct GrGpuGLShaders2::ShaderCodeSegments {
+    GrSStringBuilder<256> fVSUnis;
+    GrSStringBuilder<256> fVSAttrs;
+    GrSStringBuilder<256> fVaryings;
+    GrSStringBuilder<256> fFSUnis;
+    GrSStringBuilder<512> fVSCode;
+    GrSStringBuilder<512> fFSCode;
+};
+// for variable names etc
+typedef GrSStringBuilder<16> GrTokenString;
+
+#if ATTRIBUTE_MATRIX
+    #define VIEW_MATRIX_NAME "aViewM"
+#else
+    #define VIEW_MATRIX_NAME "uViewM"
+#endif
+
+#define POS_ATTR_NAME "aPosition"
+#define COL_ATTR_NAME "aColor"
+
+static inline void tex_attr_name(int coordIdx, GrStringBuilder* s) {
+    *s = "aTexCoord";
+    s->appendInt(coordIdx);
+}
+
+static inline const char* float_vector_type(int count) {
+    static const char* FLOAT_VECS[] = {"ERROR", "float", "vec2", "vec3", "vec4"};
+    GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(FLOAT_VECS));
+    return FLOAT_VECS[count];
+}
+
+static inline const char* vector_homog_coord(int count) {
+    static const char* HOMOGS[] = {"ERROR", "", ".y", ".z", ".w"};
+    GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(HOMOGS));
+    return HOMOGS[count];
+}
+
+static inline const char* vector_nonhomog_coords(int count) {
+    static const char* NONHOMOGS[] = {"ERROR", "", ".x", ".xy", ".xyz"};
+    GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(NONHOMOGS));
+    return NONHOMOGS[count];
+}
+
+static inline const char* vector_all_coords(int count) {
+    static const char* ALL[] = {"ERROR", "", ".xy", ".xyz", ".xyzw"};
+    GrAssert(count >= 1 && count < (int)GR_ARRAY_COUNT(ALL));
+    return ALL[count];
+}
+
+static void tex_matrix_name(int stage, GrStringBuilder* s) {
+#if ATTRIBUTE_MATRIX
+    *s = "aTexM";
+#else
+    *s = "uTexM";
+#endif
+    s->appendInt(stage);
+}
+
+static void sampler_name(int stage, GrStringBuilder* s) {
+    *s = "uSampler";
+    s->appendInt(stage);
+}
+
+static void stage_varying_name(int stage, GrStringBuilder* s) {
+    *s = "vStage";
+    s->appendInt(stage);
+}
+
+static void radial2_param_name(int stage, GrStringBuilder* s) {
+    *s = "uRadial2Params";
+    s->appendInt(stage);
+}
+
+static void radial2_varying_name(int stage, GrStringBuilder* s) {
+    *s = "vB";
+    s->appendInt(stage);
+}
+
+#include "GrRandom.h"
+
+void GrGpuGLShaders2::ProgramUnitTest() {
+    static const int PROG_OPTS[] = {
+        0,
+        ProgramDesc::kNotPoints_OptFlagBit,
+        ProgramDesc::kVertexColorAllOnes_OptFlagBit,
+        ProgramDesc::kNotPoints_OptFlagBit | ProgramDesc::kVertexColorAllOnes_OptFlagBit
+    };
+    static const int STAGE_OPTS[] = {
+        0,
+        StageDesc::kNoPerspective_OptFlagBit,
+        StageDesc::kIdentity_CoordMapping
+    };
+    static const int STAGE_MODULATES[] = {
+        StageDesc::kColor_Modulation,
+        StageDesc::kAlpha_Modulation
+    };
+    static const int STAGE_COORD_MAPPINGS[] = {
+        StageDesc::kIdentity_CoordMapping,
+        StageDesc::kRadialGradient_CoordMapping,
+        StageDesc::kSweepGradient_CoordMapping,
+        StageDesc::kRadial2Gradient_CoordMapping
+    };
+    ProgramDesc pdesc;
+    memset(&pdesc, 0, sizeof(pdesc));
+
+    static const int NUM_TESTS = 512;
+
+    // GrRandoms nextU() values have patterns in the low bits
+    // So using nextU() % array_count might never take some values.
+    GrRandom random;
+    for (int t = 0; t < NUM_TESTS; ++t) {
+
+        pdesc.fVertexLayout = 0;
+        for (int s = 0; s < kNumStages; ++s) {
+            // enable the stage?
+            if (random.nextF() > .5f) {
+                // use separate tex coords?
+                if (random.nextF() > .5f) {
+                    int t = (int)(random.nextF() * kMaxTexCoords);
+                    pdesc.fVertexLayout |= StageTexCoordVertexLayoutBit(s, t);
+                } else {
+                    pdesc.fVertexLayout |= StagePosAsTexCoordVertexLayoutBit(s);
+                }
+            }
+            // use text-formatted verts?
+            if (random.nextF() > .5f) {
+                pdesc.fVertexLayout |= kTextFormat_VertexLayoutBit;
+            }
+        }
+
+        int x = (int)(random.nextF() * GR_ARRAY_COUNT(PROG_OPTS));
+        pdesc.fOptFlags = PROG_OPTS[x];
+        for (int s = 0; s < kNumStages; ++s) {
+            pdesc.fStages[s].fEnabled = VertexUsesStage(s, pdesc.fVertexLayout);
+            x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_OPTS));
+            pdesc.fStages[s].fOptFlags = STAGE_OPTS[x];
+            x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_MODULATES));
+            pdesc.fStages[s].fModulation = (StageDesc::Modulation) STAGE_MODULATES[x];
+            x = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_COORD_MAPPINGS));
+            pdesc.fStages[s].fCoordMapping = (StageDesc::CoordMapping) STAGE_COORD_MAPPINGS[x];
+        }
+        Program program;
+        GenProgram(pdesc, &program);
+        DeleteProgram(&program);
+    }
+}
+
+void GrGpuGLShaders2::GenStageCode(int stageNum,
+                                   const StageDesc& desc,
+                                   const char* fsInColor, // NULL means no incoming color
+                                   const char* fsOutColor,
+                                   const char* vsInCoord,
+                                   ShaderCodeSegments* segments,
+                                   StageUniLocations* locations) {
+
+    GrAssert(stageNum >= 0 && stageNum <= 9);
+
+    GrTokenString varyingName;
+    stage_varying_name(stageNum, &varyingName);
+
+    // First decide how many coords are needed to access the texture
+    // Right now it's always 2 but we could start using 1D textures for
+    // gradients.
+    static const int coordDims = 2;
+    int varyingDims;
+    /// Vertex Shader Stuff
+
+    // decide whether we need a matrix to transform texture coords
+    // and whether the varying needs a perspective coord.
+    GrTokenString texMName;
+    tex_matrix_name(stageNum, &texMName);
+    if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) {
+        varyingDims = coordDims;
+    } else {
+    #if ATTRIBUTE_MATRIX
+        segments->fVSAttrs += "attribute mat3 ";
+        segments->fVSAttrs += texMName;
+        segments->fVSAttrs += ";\n";
+    #else
+        segments->fVSUnis += "uniform mat3 ";
+        segments->fVSUnis += texMName;
+        segments->fVSUnis += ";\n";
+        locations->fTextureMatrixUni = 1;
+    #endif
+        if (desc.fOptFlags & StageDesc::kNoPerspective_OptFlagBit) {
+            varyingDims = coordDims;
+        } else {
+            varyingDims = coordDims + 1;
+        }
+    }
+
+    GrTokenString samplerName;
+    sampler_name(stageNum, &samplerName);
+    segments->fFSUnis += "uniform sampler2D ";
+    segments->fFSUnis += samplerName;
+    segments->fFSUnis += ";\n";
+    locations->fSamplerUni = 1;
+
+    segments->fVaryings += "varying ";
+    segments->fVaryings += float_vector_type(varyingDims);
+    segments->fVaryings += " ";
+    segments->fVaryings += varyingName;
+    segments->fVaryings += ";\n";
+
+    if (desc.fOptFlags & StageDesc::kIdentityMatrix_OptFlagBit) {
+        GrAssert(varyingDims == coordDims);
+        segments->fVSCode += "\t";
+        segments->fVSCode += varyingName;
+        segments->fVSCode += " = ";
+        segments->fVSCode += vsInCoord;
+        segments->fVSCode += ";\n";
+    } else {
+        segments->fVSCode += "\t";
+        segments->fVSCode += varyingName;
+        segments->fVSCode += " = (";
+        segments->fVSCode += texMName;
+        segments->fVSCode += " * vec3(";
+        segments->fVSCode += vsInCoord;
+        segments->fVSCode += ", 1))";
+        segments->fVSCode += vector_all_coords(varyingDims);
+        segments->fVSCode += ";\n";
+    }
+
+    GrTokenString radial2ParamsName;
+    radial2_param_name(stageNum, &radial2ParamsName);
+    // for radial grads without perspective we can pass the linear
+    // part of the quadratic as a varying.
+    GrTokenString radial2VaryingName;
+    radial2_varying_name(stageNum, &radial2VaryingName);
+
+    if (StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping) {
+
+        segments->fVSUnis += "uniform " GR_PRECISION " float ";
+        segments->fVSUnis += radial2ParamsName;
+        segments->fVSUnis += "[6];\n";
+
+        segments->fFSUnis += "uniform " GR_PRECISION " float ";
+        segments->fFSUnis += radial2ParamsName;
+        segments->fFSUnis += "[6];\n";
+        locations->fRadial2Uni = 1;
+
+        // if there is perspective we don't interpolate this
+        if (varyingDims == coordDims) {
+            GrAssert(2 == coordDims);
+            segments->fVaryings += "varying float ";
+            segments->fVaryings += radial2VaryingName;
+            segments->fVaryings += ";\n";
+
+            segments->fVSCode += "\t";
+            segments->fVSCode += radial2VaryingName;
+            segments->fVSCode += " = 2.0 * (";
+            segments->fVSCode += radial2ParamsName;
+            segments->fVSCode += "[2] * ";
+            segments->fVSCode += varyingName;
+            segments->fVSCode += ".x ";
+            segments->fVSCode += " - ";
+            segments->fVSCode += radial2ParamsName;
+            segments->fVSCode += "[3]);\n";
+        }
+    }
+
+    /// Fragment Shader Stuff
+    GrTokenString fsCoordName;
+    // function used to access the shader, may be made projective
+    GrTokenString texFunc("texture2D");
+    if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
+                          StageDesc::kNoPerspective_OptFlagBit)) {
+        GrAssert(varyingDims == coordDims);
+        fsCoordName = varyingName;
+    } else {
+        // if we have to do some non-matrix op on the varyings to get
+        // our final tex coords then when in perspective we have to
+        // do an explicit divide
+        if  (StageDesc::kIdentity_CoordMapping == desc.fCoordMapping) {
+            texFunc += "Proj";
+            fsCoordName = varyingName;
+        } else {
+            fsCoordName = "tCoord";
+            fsCoordName.appendInt(stageNum);
+
+            segments->fFSCode += "\t";
+            segments->fFSCode += float_vector_type(coordDims);
+            segments->fFSCode += " ";
+            segments->fFSCode += fsCoordName;
+            segments->fFSCode += " = ";
+            segments->fFSCode += varyingName;
+            segments->fFSCode += vector_nonhomog_coords(varyingDims);
+            segments->fFSCode += " / ";
+            segments->fFSCode += varyingName;
+            segments->fFSCode += vector_homog_coord(varyingDims);
+            segments->fFSCode += ";\n";
+        }
+    }
+
+    GrSStringBuilder<96> sampleCoords;
+    switch (desc.fCoordMapping) {
+    case StageDesc::kIdentity_CoordMapping:
+        sampleCoords = fsCoordName;
+        break;
+    case StageDesc::kSweepGradient_CoordMapping:
+        sampleCoords = "vec2(atan(-";
+        sampleCoords += fsCoordName;
+        sampleCoords += ".y, -";
+        sampleCoords += fsCoordName;
+        sampleCoords += ".x)*0.1591549430918 + 0.5, 0.5)";
+        break;
+    case StageDesc::kRadialGradient_CoordMapping:
+        sampleCoords = "vec2(length(";
+        sampleCoords += fsCoordName;
+        sampleCoords += ".xy), 0.5)";
+        break;
+    case StageDesc::kRadial2Gradient_CoordMapping: {
+        GrTokenString cName    = "c";
+        GrTokenString ac4Name  = "ac4";
+        GrTokenString rootName = "root";
+
+        cName.appendInt(stageNum);
+        ac4Name.appendInt(stageNum);
+        rootName.appendInt(stageNum);
+
+        GrTokenString bVar;
+        if (coordDims == varyingDims) {
+            bVar = radial2VaryingName;
+            GrAssert(2 == varyingDims);
+        } else {
+            GrAssert(3 == varyingDims);
+            bVar = "b";
+            bVar.appendInt(stageNum);
+            segments->fFSCode += "\tfloat ";
+            segments->fFSCode += bVar;
+            segments->fFSCode += " = 2.0 * (";
+            segments->fFSCode += radial2ParamsName;
+            segments->fFSCode += "[2] * ";
+            segments->fFSCode += fsCoordName;
+            segments->fFSCode += ".x ";
+            segments->fFSCode += " - ";
+            segments->fFSCode += radial2ParamsName;
+            segments->fFSCode += "[3]);\n";
+        }
+
+        segments->fFSCode += "\tfloat ";
+        segments->fFSCode += cName;
+        segments->fFSCode += " = dot(";
+        segments->fFSCode += fsCoordName;
+        segments->fFSCode += ", ";
+        segments->fFSCode += fsCoordName;
+        segments->fFSCode += ") + ";
+        segments->fFSCode += " - ";
+        segments->fFSCode += radial2ParamsName;
+        segments->fFSCode += "[4];\n";
+
+        segments->fFSCode += "\tfloat ";
+        segments->fFSCode += ac4Name;
+        segments->fFSCode += " = ";
+        segments->fFSCode += radial2ParamsName;
+        segments->fFSCode += "[0] * 4.0 * ";
+        segments->fFSCode += cName;
+        segments->fFSCode += ";\n";
+
+        segments->fFSCode += "\tfloat ";
+        segments->fFSCode += rootName;
+        segments->fFSCode += " = sqrt(abs(";
+        segments->fFSCode += bVar;
+        segments->fFSCode += " * ";
+        segments->fFSCode += bVar;
+        segments->fFSCode += " - ";
+        segments->fFSCode += ac4Name;
+        segments->fFSCode += "));\n";
+
+        sampleCoords = "vec2((-";
+        sampleCoords += bVar;
+        sampleCoords += " + ";
+        sampleCoords += radial2ParamsName;
+        sampleCoords += "[5] * ";
+        sampleCoords += rootName;
+        sampleCoords += ") * ";
+        sampleCoords += radial2ParamsName;
+        sampleCoords += "[1], 0.5)\n";
+        break;}
+    };
+
+    segments->fFSCode += "\t";
+    segments->fFSCode += fsOutColor;
+    segments->fFSCode += " = ";
+    if (NULL != fsInColor) {
+        segments->fFSCode += fsInColor;
+        segments->fFSCode += " * ";
+    }
+    segments->fFSCode += texFunc;
+    segments->fFSCode += "(";
+    segments->fFSCode += samplerName;
+    segments->fFSCode += ", ";
+    segments->fFSCode += sampleCoords;
+    segments->fFSCode += ")";
+    if (desc.fModulation == StageDesc::kAlpha_Modulation) {
+        segments->fFSCode += ".aaaa";
+    }
+    segments->fFSCode += ";\n";
+
+}
+
+void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc,
+                                 Program* program) {
+
+    ShaderCodeSegments segments;
+    const uint32_t& layout = desc.fVertexLayout;
+
+    memset(&program->fUniLocations, 0, sizeof(UniLocations));
+
+    bool haveColor = !(ProgramDesc::kVertexColorAllOnes_OptFlagBit &
+                       desc.fOptFlags);
+
+#if ATTRIBUTE_MATRIX
+    segments.fVSAttrs = "attribute mat3 " VIEW_MATRIX_NAME ";\n";
+#else
+    segments.fVSUnis  = "uniform mat3 " VIEW_MATRIX_NAME ";\n";
+    segments.fVSAttrs = "";
+#endif
+    segments.fVSAttrs += "attribute vec2 " POS_ATTR_NAME ";\n";
+    if (haveColor) {
+        segments.fVSAttrs += "attribute vec4 " COL_ATTR_NAME ";\n";
+        segments.fVaryings = "varying vec4 vColor;\n";
+    } else {
+        segments.fVaryings = "";
+    }
+
+    segments.fVSCode   = "void main() {\n"
+                         "\tvec3 pos3 = " VIEW_MATRIX_NAME " * vec3(" POS_ATTR_NAME ", 1);\n"
+                         "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n";
+    if (haveColor) {
+        segments.fVSCode += "\tvColor = " COL_ATTR_NAME ";\n";
+    }
+
+    if (!(desc.fOptFlags & ProgramDesc::kNotPoints_OptFlagBit)){
+        segments.fVSCode += "\tgl_PointSize = 1.0;\n";
+    }
+    segments.fFSCode   = "void main() {\n";
+
+    // add texture coordinates that are used to the list of vertex attr decls
+    GrTokenString texCoordAttrs[kMaxTexCoords];
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        if (VertexUsesTexCoordIdx(t, layout)) {
+            tex_attr_name(t, texCoordAttrs + t);
+
+            segments.fVSAttrs += "attribute vec2 ";
+            segments.fVSAttrs += texCoordAttrs[t];
+            segments.fVSAttrs += ";\n";
+        }
+    }
+
+    // for each enabled stage figure out what the input coordinates are
+    // and count the number of stages in use.
+    const char* stageInCoords[kNumStages];
+    int numActiveStages = 0;
+
+    for (int s = 0; s < kNumStages; ++s) {
+        if (desc.fStages[s].fEnabled) {
+            if (StagePosAsTexCoordVertexLayoutBit(s) & layout) {
+                stageInCoords[s] = POS_ATTR_NAME;
+            } else {
+                int tcIdx = VertexTexCoordsForStage(s, layout);
+                 // we better have input tex coordinates if stage is enabled.
+                GrAssert(tcIdx >= 0);
+                GrAssert(texCoordAttrs[tcIdx].length());
+                stageInCoords[s] = texCoordAttrs[tcIdx].cstr();
+            }
+            ++numActiveStages;
+        }
+    }
+
+    GrTokenString inColor = "vColor";
+
+    // if we have active stages string them together, feeding the output color
+    // of each to the next and generating code for each stage.
+    if (numActiveStages) {
+        int currActiveStage = 0;
+        for (int s = 0; s < kNumStages; ++s) {
+            if (desc.fStages[s].fEnabled) {
+                GrTokenString outColor;
+                if (currActiveStage < (numActiveStages - 1)) {
+                    outColor = "color";
+                    outColor.appendInt(currActiveStage);
+                    segments.fFSCode += "\tvec4 ";
+                    segments.fFSCode += outColor;
+                    segments.fFSCode += ";\n";
+                } else {
+                    outColor = "gl_FragColor";
+                }
+                GenStageCode(s,
+                             desc.fStages[s],
+                             haveColor ? inColor.cstr() : NULL,
+                             outColor.cstr(),
+                             stageInCoords[s],
+                             &segments,
+                             &program->fUniLocations.fStages[s]);
+                ++currActiveStage;
+                inColor = outColor;
+                haveColor = true;
+            }
+        }
+    } else {
+        segments.fFSCode += "\tgl_FragColor = ";
+        if (haveColor) {
+            segments.fFSCode += inColor;
+        } else {
+            segments.fFSCode += "vec4(1,1,1,1)";
+        }
+        segments.fFSCode += ";\n";
+    }
+    segments.fFSCode += "}\n";
+    segments.fVSCode += "}\n";
+
+
+    const char* strings[4];
+    int lengths[4];
+    int stringCnt = 0;
+
+    if (segments.fVSUnis.length()) {
+        strings[stringCnt] = segments.fVSUnis.cstr();
+        lengths[stringCnt] = segments.fVSUnis.length();
+        ++stringCnt;
+    }
+    if (segments.fVSAttrs.length()) {
+        strings[stringCnt] = segments.fVSAttrs.cstr();
+        lengths[stringCnt] = segments.fVSAttrs.length();
+        ++stringCnt;
+    }
+    if (segments.fVaryings.length()) {
+        strings[stringCnt] = segments.fVaryings.cstr();
+        lengths[stringCnt] = segments.fVaryings.length();
+        ++stringCnt;
+    }
+
+    GrAssert(segments.fVSCode.length());
+    strings[stringCnt] = segments.fVSCode.cstr();
+    lengths[stringCnt] = segments.fVSCode.length();
+    ++stringCnt;
+
+#if PRINT_SHADERS
+    GrPrintf("%s%s%s%s\n",
+             segments.fVSUnis.cstr(),
+             segments.fVSAttrs.cstr(),
+             segments.fVaryings.cstr(),
+             segments.fVSCode.cstr());
+#endif
+    program->fVShaderID = CompileShader(GL_VERTEX_SHADER,
+                                        stringCnt,
+                                        strings,
+                                        lengths);
+
+    stringCnt = 0;
+
+    if (GR_ARRAY_COUNT(GR_SHADER_PRECISION) > 1) {
+        strings[stringCnt] = GR_SHADER_PRECISION;
+        lengths[stringCnt] = GR_ARRAY_COUNT(GR_SHADER_PRECISION) - 1;
+        ++stringCnt;
+    }
+    if (segments.fFSUnis.length()) {
+        strings[stringCnt] = segments.fFSUnis.cstr();
+        lengths[stringCnt] = segments.fFSUnis.length();
+        ++stringCnt;
+    }
+    if (segments.fVaryings.length()) {
+        strings[stringCnt] = segments.fVaryings.cstr();
+        lengths[stringCnt] = segments.fVaryings.length();
+        ++stringCnt;
+    }
+
+    GrAssert(segments.fFSCode.length());
+    strings[stringCnt] = segments.fFSCode.cstr();
+    lengths[stringCnt] = segments.fFSCode.length();
+    ++stringCnt;
+
+#if PRINT_SHADERS
+    GrPrintf("%s%s%s%s\n",
+             GR_SHADER_PRECISION,
+             segments.fFSUnis.cstr(),
+             segments.fVaryings.cstr(),
+             segments.fFSCode.cstr());
+#endif
+    program->fFShaderID = CompileShader(GL_FRAGMENT_SHADER,
+                                        stringCnt,
+                                        strings,
+                                        lengths);
+
+    program->fProgramID = GR_GL(CreateProgram());
+    const GLint& progID = program->fProgramID;
+
+    GR_GL(AttachShader(progID, program->fVShaderID));
+    GR_GL(AttachShader(progID, program->fFShaderID));
+
+    // Bind the attrib locations to same values for all shaders
+    GR_GL(BindAttribLocation(progID, POS_ATTR_LOCATION, POS_ATTR_NAME));
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        if (texCoordAttrs[t].length()) {
+            GR_GL(BindAttribLocation(progID,
+                                     TEX_ATTR_LOCATION(t),
+                                     texCoordAttrs[t].cstr()));
+        }
+    }
+
+#if ATTRIBUTE_MATRIX
+    // set unis to a bogus value so that checks against -1 before
+    // flushing will pass.
+    GR_GL(BindAttribLocation(progID,
+                             VIEWMAT_ATTR_LOCATION,
+                             VIEW_MATRIX_NAME));
+
+    program->fUniLocations.fViewMatrixUni = BOGUS_MATRIX_UNI_LOCATION;
+
+    for (int s = 0; s < kNumStages; ++s) {
+        if (desc.fStages[s].fEnabled) {
+            GrStringBuilder matName;
+            tex_matrix_name(s, &matName);
+            GR_GL(BindAttribLocation(progID,
+                                     TEXMAT_ATTR_LOCATION(s),
+                                     matName.cstr()));
+            program->fUniLocations.fStages[s].fTextureMatrixUni =
+                                                    BOGUS_MATRIX_UNI_LOCATION;
+        }
+    }
+#endif
+
+    GR_GL(BindAttribLocation(progID, COL_ATTR_LOCATION, COL_ATTR_NAME));
+
+    GR_GL(LinkProgram(progID));
+
+    GLint linked = GR_GL_INIT_ZERO;
+    GR_GL(GetProgramiv(progID, GL_LINK_STATUS, &linked));
+    if (!linked) {
+        GLint infoLen = GR_GL_INIT_ZERO;
+        GR_GL(GetProgramiv(progID, GL_INFO_LOG_LENGTH, &infoLen));
+        GrAutoMalloc log(sizeof(char)*(infoLen+1));  // outside if for debugger
+        if (infoLen > 0) {
+            GR_GL(GetProgramInfoLog(progID,
+                                    infoLen+1,
+                                    NULL,
+                                    (char*)log.get()));
+            GrPrintf((char*)log.get());
+        }
+        GrAssert(!"Error linking program");
+        GR_GL(DeleteProgram(progID));
+        program->fProgramID = 0;
+        return;
+    }
+
+    // Get uniform locations
+#if !ATTRIBUTE_MATRIX
+    program->fUniLocations.fViewMatrixUni =
+                    GR_GL(GetUniformLocation(progID, VIEW_MATRIX_NAME));
+    GrAssert(-1 != program->fUniLocations.fViewMatrixUni);
+#endif
+    for (int s = 0; s < kNumStages; ++s) {
+        StageUniLocations& locations = program->fUniLocations.fStages[s];
+        if (desc.fStages[s].fEnabled) {
+#if !ATTRIBUTE_MATRIX
+            if (locations.fTextureMatrixUni) {
+                GrTokenString texMName;
+                tex_matrix_name(s, &texMName);
+                locations.fTextureMatrixUni = GR_GL(GetUniformLocation(
+                                                progID,
+                                                texMName.cstr()));
+                GrAssert(-1 != locations.fTextureMatrixUni);
+            } else {
+                locations.fTextureMatrixUni = -1;
+
+            }
+#endif
+
+            if (locations.fSamplerUni) {
+                GrTokenString samplerName;
+                sampler_name(s, &samplerName);
+                locations.fSamplerUni = GR_GL(GetUniformLocation(
+                                                     progID,
+                                                     samplerName.cstr()));
+                GrAssert(-1 != locations.fSamplerUni);
+            } else {
+                locations.fSamplerUni = -1;
+            }
+
+            if (locations.fRadial2Uni) {
+                GrTokenString radial2ParamName;
+                radial2_param_name(s, &radial2ParamName);
+                locations.fRadial2Uni = GR_GL(GetUniformLocation(
+                                             progID,
+                                             radial2ParamName.cstr()));
+                GrAssert(-1 != locations.fRadial2Uni);
+            } else {
+                locations.fRadial2Uni = -1;
+            }
+        } else {
+            locations.fSamplerUni = -1;
+            locations.fRadial2Uni = -1;
+            locations.fTextureMatrixUni = -1;
+        }
+    }
+    GR_GL(UseProgram(progID));
+
+    // init sampler unis and set bogus values for state tracking
+    for (int s = 0; s < kNumStages; ++s) {
+        if (-1 != program->fUniLocations.fStages[s].fSamplerUni) {
+            GR_GL(Uniform1i(program->fUniLocations.fStages[s].fSamplerUni, s));
+        }
+        program->fTextureMatrices[s] = GrMatrix::InvalidMatrix();
+        program->fRadial2CenterX1[s] = GR_ScalarMax;
+        program->fRadial2Radius0[s] = -GR_ScalarMax;
+    }
+    program->fViewMatrix = GrMatrix::InvalidMatrix();
+}
+
+void GrGpuGLShaders2::getProgramDesc(GrPrimitiveType primType, ProgramDesc* desc) {
+
+    // Must initialize all fields or cache will have false negatives!
+    desc->fVertexLayout = fGeometrySrc.fVertexLayout;
+
+    desc->fOptFlags = 0;
+    if (kPoints_PrimitiveType != primType) {
+        desc->fOptFlags |= ProgramDesc::kNotPoints_OptFlagBit;
+    }
+#if GR_AGGRESSIVE_SHADER_OPTS
+    if (!(desc->fVertexLayout & kColor_VertexLayoutBit) &&
+        (0xffffffff == fCurrDrawState.fColor)) {
+        desc->fOptFlags |= ProgramDesc::kVertexColorAllOnes_OptFlagBit;
+    }
+#endif
+
+    for (int s = 0; s < kNumStages; ++s) {
+        StageDesc& stage = desc->fStages[s];
+
+        stage.fEnabled = VertexUsesStage(s, fGeometrySrc.fVertexLayout);
+
+        if (stage.fEnabled) {
+            GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
+            GrAssert(NULL != texture);
+            // we matrix to invert when orientation is TopDown, so make sure
+            // we aren't in that case before flagging as identity.
+            if (TextureMatrixIsIdentity(texture, fCurrDrawState.fSamplerStates[s])) {
+                stage.fOptFlags = StageDesc::kIdentityMatrix_OptFlagBit;
+            } else if (!getSamplerMatrix(s).hasPerspective()) {
+                stage.fOptFlags = StageDesc::kNoPerspective_OptFlagBit;
+            } else {
+                stage.fOptFlags = 0;
+            }
+            switch (fCurrDrawState.fSamplerStates[s].getSampleMode()) {
+            case GrSamplerState::kNormal_SampleMode:
+                stage.fCoordMapping = StageDesc::kIdentity_CoordMapping;
+                break;
+            case GrSamplerState::kRadial_SampleMode:
+                stage.fCoordMapping = StageDesc::kRadialGradient_CoordMapping;
+                break;
+            case GrSamplerState::kRadial2_SampleMode:
+                stage.fCoordMapping = StageDesc::kRadial2Gradient_CoordMapping;
+                break;
+            case GrSamplerState::kSweep_SampleMode:
+                stage.fCoordMapping = StageDesc::kSweepGradient_CoordMapping;
+                break;
+            default:
+                GrAssert(!"Unexpected sample mode!");
+                break;
+            }
+            if (GrTexture::kAlpha_8_PixelConfig == texture->config()) {
+                stage.fModulation = StageDesc::kAlpha_Modulation;
+            } else {
+                stage.fModulation = StageDesc::kColor_Modulation;
+            }
+        } else {
+            stage.fOptFlags     = 0;
+            stage.fCoordMapping = (StageDesc::CoordMapping)0;
+            stage.fModulation   = (StageDesc::Modulation)0;
+        }
+    }
+}
+
+GLuint GrGpuGLShaders2::CompileShader(GLenum type,
+                                      int stringCnt,
+                                      const char** strings,
+                                      int* stringLengths) {
+    GLuint shader = GR_GL(CreateShader(type));
+    if (0 == shader) {
+        return 0;
+    }
+
+    GLint compiled = GR_GL_INIT_ZERO;
+    GR_GL(ShaderSource(shader, stringCnt, strings, stringLengths));
+    GR_GL(CompileShader(shader));
+    GR_GL(GetShaderiv(shader, GL_COMPILE_STATUS, &compiled));
+
+    if (!compiled) {
+        GLint infoLen = GR_GL_INIT_ZERO;
+        GR_GL(GetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen));
+        GrAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
+        if (infoLen > 0) {
+            GR_GL(GetShaderInfoLog(shader, infoLen+1, NULL, (char*)log.get()));
+            for (int i = 0; i < stringCnt; ++i) {
+                if (NULL == stringLengths || stringLengths[i] < 0) {
+                    GrPrintf(strings[i]);
+                } else {
+                    GrPrintf("%.*s", stringLengths[i], strings[i]);
+                }
+            }
+            GrPrintf("\n%s", log.get());
+        }
+        GrAssert(!"Shader compilation failed!");
+        GR_GL(DeleteShader(shader));
+        return 0;
+    }
+    return shader;
+}
+
+void GrGpuGLShaders2::DeleteProgram(Program* program) {
+    GR_GL(DeleteShader(program->fVShaderID));
+    GR_GL(DeleteShader(program->fFShaderID));
+    GR_GL(DeleteProgram(program->fProgramID));
+    GR_DEBUGCODE(memset(program, 0, sizeof(Program)));
+}
+
+
+GrGpuGLShaders2::GrGpuGLShaders2() {
+
+    fProgram = NULL;
+    fProgramCache = new ProgramCache();
+
+#if 0
+    ProgramUnitTest();
+#endif
+}
+
+GrGpuGLShaders2::~GrGpuGLShaders2() {
+    delete fProgramCache;
+}
+
+const GrMatrix& GrGpuGLShaders2::getHWSamplerMatrix(int stage) {
+#if ATTRIBUTE_MATRIX
+    return fHWDrawState.fSamplerStates[stage].getMatrix();
+#else
+    return fProgram->fTextureMatrices[stage];
+#endif
+}
+
+void GrGpuGLShaders2::recordHWSamplerMatrix(int stage, const GrMatrix& matrix){
+#if ATTRIBUTE_MATRIX
+    fHWDrawState.fSamplerStates[stage].setMatrix(matrix);
+#else
+    fProgram->fTextureMatrices[stage] = matrix;
+#endif
+}
+
+void GrGpuGLShaders2::resetContext() {
+
+    INHERITED::resetContext();
+
+    fHWGeometryState.fVertexLayout = 0;
+    fHWGeometryState.fVertexOffset  = ~0;
+    GR_GL(DisableVertexAttribArray(COL_ATTR_LOCATION));
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        GR_GL(DisableVertexAttribArray(TEX_ATTR_LOCATION(t)));
+    }
+    GR_GL(EnableVertexAttribArray(POS_ATTR_LOCATION));
+
+    fHWProgramID = 0;
+}
+
+void GrGpuGLShaders2::flushViewMatrix() {
+    GrAssert(NULL != fCurrDrawState.fRenderTarget);
+    GrMatrix m (
+        GrIntToScalar(2) / fCurrDrawState.fRenderTarget->width(), 0, -GR_Scalar1,
+        0,-GrIntToScalar(2) / fCurrDrawState.fRenderTarget->height(), GR_Scalar1,
+        0, 0, GrMatrix::I()[8]);
+    m.setConcat(m, fCurrDrawState.fViewMatrix);
+
+    // ES doesn't allow you to pass true to the transpose param,
+    // so do our own transpose
+    GrScalar mt[]  = {
+        m[GrMatrix::kScaleX],
+        m[GrMatrix::kSkewY],
+        m[GrMatrix::kPersp0],
+        m[GrMatrix::kSkewX],
+        m[GrMatrix::kScaleY],
+        m[GrMatrix::kPersp1],
+        m[GrMatrix::kTransX],
+        m[GrMatrix::kTransY],
+        m[GrMatrix::kPersp2]
+    };
+#if ATTRIBUTE_MATRIX
+    GR_GL(VertexAttrib4fv(VIEWMAT_ATTR_LOCATION+0, mt+0));
+    GR_GL(VertexAttrib4fv(VIEWMAT_ATTR_LOCATION+1, mt+3));
+    GR_GL(VertexAttrib4fv(VIEWMAT_ATTR_LOCATION+2, mt+6));
+#else
+    GR_GL(UniformMatrix3fv(fProgram->fUniLocations.fViewMatrixUni,1,false,mt));
+#endif
+}
+
+void GrGpuGLShaders2::flushTextureMatrix(int stage) {
+    GrAssert(NULL != fCurrDrawState.fTextures[stage]);
+
+    GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[stage];
+
+    GrMatrix m = getSamplerMatrix(stage);
+    GrSamplerState::SampleMode mode = 
+        fCurrDrawState.fSamplerStates[0].getSampleMode();
+    AdjustTextureMatrix(texture, mode, &m);
+
+    // ES doesn't allow you to pass true to the transpose param,
+    // so do our own transpose
+    GrScalar mt[]  = {
+        m[GrMatrix::kScaleX],
+        m[GrMatrix::kSkewY],
+        m[GrMatrix::kPersp0],
+        m[GrMatrix::kSkewX],
+        m[GrMatrix::kScaleY],
+        m[GrMatrix::kPersp1],
+        m[GrMatrix::kTransX],
+        m[GrMatrix::kTransY],
+        m[GrMatrix::kPersp2]
+    };
+#if ATTRIBUTE_MATRIX
+    GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+0, mt+0));
+    GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+1, mt+3));
+    GR_GL(VertexAttrib4fv(TEXMAT_ATTR_LOCATION(0)+2, mt+6));
+#else
+    GR_GL(UniformMatrix3fv(fProgram->fUniLocations.fStages[stage].fTextureMatrixUni,
+                           1, false, mt));
+#endif
+}
+
+void GrGpuGLShaders2::flushRadial2(int stage) {
+
+    const GrSamplerState& sampler = fCurrDrawState.fSamplerStates[stage];
+
+    GrScalar centerX1 = sampler.getRadial2CenterX1();
+    GrScalar radius0 = sampler.getRadial2Radius0();
+
+    GrScalar a = GrMul(centerX1, centerX1) - GR_Scalar1;
+
+    float unis[6] = {
+        GrScalarToFloat(a),
+        1 / (2.f * unis[0]),
+        GrScalarToFloat(centerX1),
+        GrScalarToFloat(radius0),
+        GrScalarToFloat(GrMul(radius0, radius0)),
+        sampler.isRadial2PosRoot() ? 1.f : -1.f
+    };
+    GR_GL(Uniform1fv(fProgram->fUniLocations.fStages[stage].fRadial2Uni,
+                     6,
+                     unis));
+}
+
+void GrGpuGLShaders2::flushProgram(GrPrimitiveType type) {
+    ProgramDesc desc;
+    getProgramDesc(type, &desc);
+    fProgram = fProgramCache->getProgram(desc);
+
+    if (fHWProgramID != fProgram->fProgramID) {
+        GR_GL(UseProgram(fProgram->fProgramID));
+        fHWProgramID = fProgram->fProgramID;
+#if GR_COLLECT_STATS
+        ++fStats.fProgChngCnt;
+#endif
+    }
+}
+
+bool GrGpuGLShaders2::flushGraphicsState(GrPrimitiveType type) {
+
+    if (!flushGLStateCommon(type)) {
+        return false;
+    }
+
+    if (fDirtyFlags.fRenderTargetChanged) {
+        // our coords are in pixel space and the GL matrices map to NDC
+        // so if the viewport changed, our matrix is now wrong.
+#if ATTRIBUTE_MATRIX
+        fHWDrawState.fViewMatrix = GrMatrix::InvalidMatrix();
+#else
+        // we assume all shader matrices may be wrong after viewport changes
+        fProgramCache->invalidateViewMatrices();
+#endif
+    }
+
+    flushProgram(type);
+
+    if (fGeometrySrc.fVertexLayout & kColor_VertexLayoutBit) {
+        // invalidate the immediate mode color
+        fHWDrawState.fColor = GrColor_ILLEGAL;
+    } else {
+        if (fHWDrawState.fColor != fCurrDrawState.fColor &&
+            (!GR_AGGRESSIVE_SHADER_OPTS || 0xffffffff != fCurrDrawState.fColor)) {
+            // avoid pushing the color attrib if the shader will optimize it out
+
+            // OpenGL ES only supports the float varities of glVertexAttrib
+            float c[] = {
+                GrColorUnpackR(fCurrDrawState.fColor) / 255.f,
+                GrColorUnpackG(fCurrDrawState.fColor) / 255.f,
+                GrColorUnpackB(fCurrDrawState.fColor) / 255.f,
+                GrColorUnpackA(fCurrDrawState.fColor) / 255.f
+            };
+            GR_GL(VertexAttrib4fv(COL_ATTR_LOCATION, c));
+            fHWDrawState.fColor = fCurrDrawState.fColor;
+        }
+    }
+
+#if ATTRIBUTE_MATRIX
+    GrMatrix& currViewMatrix = fHWDrawState.fViewMatrix;
+#else
+    GrMatrix& currViewMatrix = fProgram->fViewMatrix;
+#endif
+
+    if (currViewMatrix != fCurrDrawState.fViewMatrix) {
+        flushViewMatrix();
+        currViewMatrix = fCurrDrawState.fViewMatrix;
+    }
+
+    for (int s = 0; s < kNumStages; ++s) {
+        GrGLTexture* texture = (GrGLTexture*) fCurrDrawState.fTextures[s];
+        if (NULL != texture) {
+            if (-1 != fProgram->fUniLocations.fStages[s].fTextureMatrixUni &&
+                (((1 << s) & fDirtyFlags.fTextureChangedMask) ||
+                getHWSamplerMatrix(s) != getSamplerMatrix(s))) {
+                flushTextureMatrix(s);
+                recordHWSamplerMatrix(s, getSamplerMatrix(s));
+            }
+        }
+
+        const GrSamplerState& sampler = fCurrDrawState.fSamplerStates[s];
+        if (-1 != fProgram->fUniLocations.fStages[s].fRadial2Uni &&
+            (fProgram->fRadial2CenterX1[s] != sampler.getRadial2CenterX1() ||
+             fProgram->fRadial2Radius0[s]  != sampler.getRadial2Radius0()  ||
+             fProgram->fRadial2PosRoot[s]  != sampler.isRadial2PosRoot())) {
+
+            flushRadial2(s);
+
+            fProgram->fRadial2CenterX1[s] = sampler.getRadial2CenterX1();
+            fProgram->fRadial2Radius0[s]  = sampler.getRadial2Radius0();
+            fProgram->fRadial2PosRoot[s]  = sampler.isRadial2PosRoot();
+        }
+    }
+    resetDirtyFlags();
+    return true;
+}
+
+void GrGpuGLShaders2::setupGeometry(int* startVertex,
+                                    int* startIndex,
+                                    int vertexCount,
+                                    int indexCount) {
+
+    int newColorOffset;
+    int newTexCoordOffsets[kMaxTexCoords];
+
+    GLsizei newStride = VertexSizeAndOffsetsByIdx(fGeometrySrc.fVertexLayout,
+                                                  newTexCoordOffsets,
+                                                  &newColorOffset);
+    int oldColorOffset;
+    int oldTexCoordOffsets[kMaxTexCoords];
+    GLsizei oldStride = VertexSizeAndOffsetsByIdx(fHWGeometryState.fVertexLayout,
+                                                  oldTexCoordOffsets,
+                                                  &oldColorOffset);
+    bool indexed = NULL != startIndex;
+
+    int extraVertexOffset;
+    int extraIndexOffset;
+    setBuffers(indexed, &extraVertexOffset, &extraIndexOffset);
+
+    GLenum scalarType;
+    bool texCoordNorm;
+    if (fGeometrySrc.fVertexLayout & kTextFormat_VertexLayoutBit) {
+        scalarType = GrGLTextType;
+        texCoordNorm = GR_GL_TEXT_TEXTURE_NORMALIZED;
+    } else {
+        scalarType = GrGLType;
+        texCoordNorm = false;
+    }
+
+    size_t vertexOffset = (*startVertex + extraVertexOffset) * newStride;
+    *startVertex = 0;
+    if (indexed) {
+        *startIndex += extraIndexOffset;
+    }
+
+    // all the Pointers must be set if any of these are true
+    bool allOffsetsChange =  fHWGeometryState.fArrayPtrsDirty ||
+                             vertexOffset != fHWGeometryState.fVertexOffset ||
+                             newStride != oldStride;
+
+    // position and tex coord offsets change if above conditions are true
+    // or the type/normalization changed based on text vs nontext type coords.
+    bool posAndTexChange = allOffsetsChange ||
+                           (((GrGLTextType != GrGLType) || GR_GL_TEXT_TEXTURE_NORMALIZED) &&
+                                (kTextFormat_VertexLayoutBit &
+                                  (fHWGeometryState.fVertexLayout ^
+                                   fGeometrySrc.fVertexLayout)));
+
+    if (posAndTexChange) {
+        GR_GL(VertexAttribPointer(POS_ATTR_LOCATION, 2, scalarType,
+                                  false, newStride, (GLvoid*)vertexOffset));
+        fHWGeometryState.fVertexOffset = vertexOffset;
+    }
+
+    for (int t = 0; t < kMaxTexCoords; ++t) {
+        if (newTexCoordOffsets[t] > 0) {
+            GLvoid* texCoordOffset = (GLvoid*)(vertexOffset + newTexCoordOffsets[t]);
+            if (oldTexCoordOffsets[t] <= 0) {
+                GR_GL(EnableVertexAttribArray(TEX_ATTR_LOCATION(t)));
+                GR_GL(VertexAttribPointer(TEX_ATTR_LOCATION(t), 2, scalarType,
+                                          texCoordNorm, newStride, texCoordOffset));
+            } else if (posAndTexChange ||
+                       newTexCoordOffsets[t] != oldTexCoordOffsets[t]) {
+                GR_GL(VertexAttribPointer(TEX_ATTR_LOCATION(t), 2, scalarType,
+                                          texCoordNorm, newStride, texCoordOffset));
+            }
+        } else if (oldTexCoordOffsets[t] > 0) {
+            GR_GL(DisableVertexAttribArray(TEX_ATTR_LOCATION(t)));
+        }
+    }
+
+    if (newColorOffset > 0) {
+        GLvoid* colorOffset = (int8_t*)(vertexOffset + newColorOffset);
+        if (oldColorOffset <= 0) {
+            GR_GL(EnableVertexAttribArray(COL_ATTR_LOCATION));
+            GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4,
+                                      GL_UNSIGNED_BYTE,
+                                      true, newStride, colorOffset));
+        } else if (allOffsetsChange || newColorOffset != oldColorOffset) {
+            GR_GL(VertexAttribPointer(COL_ATTR_LOCATION, 4,
+                                      GL_UNSIGNED_BYTE,
+                                      true, newStride, colorOffset));
+        }
+    } else if (oldColorOffset > 0) {
+        GR_GL(DisableVertexAttribArray(COL_ATTR_LOCATION));
+    }
+
+    fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout;
+    fHWGeometryState.fArrayPtrsDirty = false;
+}
+#endif
+
+
diff --git a/gpu/src/GrGpuGLShaders2.h b/gpu/src/GrGpuGLShaders2.h
new file mode 100644
index 0000000..4c501be
--- /dev/null
+++ b/gpu/src/GrGpuGLShaders2.h
@@ -0,0 +1,102 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrGpuGLShaders2_DEFINED
+#define GrGpuGLShaders2_DEFINED
+
+#include "GrGpuGL.h"
+
+// Programmable OpenGL or OpenGL ES 2.0
+class GrGpuGLShaders2 : public GrGpuGL {
+public:
+             GrGpuGLShaders2();
+    virtual ~GrGpuGLShaders2();
+
+protected:
+    // overrides from GrGpu
+    virtual bool flushGraphicsState(GrPrimitiveType type);
+    virtual void setupGeometry(int* startVertex,
+                               int* startIndex,
+                               int vertexCount,
+                               int indexCount);
+
+private:
+
+    virtual void resetContext();
+
+    // Helpers to make code more readable
+    const GrMatrix& getHWSamplerMatrix(int stage);
+    void recordHWSamplerMatrix(int stage, const GrMatrix& matrix);
+
+    // sets the texture matrix uniform for currently bound program
+    void flushTextureMatrix(int stage);
+
+    // sets the MVP matrix uniform for currently bound program
+    void flushViewMatrix();
+
+    // flushes the parameters to two point radial gradient
+    void flushRadial2(int stage);
+
+    // called at flush time to setup the appropriate program
+    void flushProgram(GrPrimitiveType type);
+
+    struct Program;
+
+    struct StageDesc;
+    struct ProgramDesc;
+
+    struct UniLocations;
+    struct StageUniLocations;
+
+    struct ShaderCodeSegments;
+
+    class ProgramCache;
+
+    // gets a description of needed shader
+    void getProgramDesc(GrPrimitiveType primType, ProgramDesc* desc);
+
+    // generates and compiles a program from a description and vertex layout
+    // will change GL's bound program
+    static void GenProgram(const ProgramDesc& desc, Program* program);
+
+    // generates code for a stage of the shader
+    static void GenStageCode(int stageNum,
+                             const StageDesc& desc,
+                             const char* psInColor,
+                             const char* psOutColor,
+                             const char* vsInCoord,
+                             ShaderCodeSegments* segments,
+                             StageUniLocations* locations);
+
+    // Compiles a GL shader, returns shader ID or 0 if failed
+    // params have same meaning as glShaderSource
+    static GLuint CompileShader(GLenum type, int stringCnt,
+                                             const char** strings,
+                                             int* stringLengths);
+    static void DeleteProgram(Program* program);
+
+    void ProgramUnitTest();
+
+    ProgramCache*   fProgramCache;
+    Program*        fProgram;
+    GLuint          fHWProgramID;
+
+    typedef GrGpuGL INHERITED;
+};
+
+#endif
+
diff --git a/gpu/src/GrInOrderDrawBuffer.cpp b/gpu/src/GrInOrderDrawBuffer.cpp
new file mode 100644
index 0000000..8225425
--- /dev/null
+++ b/gpu/src/GrInOrderDrawBuffer.cpp
@@ -0,0 +1,521 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrInOrderDrawBuffer.h"
+#include "GrTexture.h"
+#include "GrBufferAllocPool.h"
+#include "GrIndexBuffer.h"
+#include "GrVertexBuffer.h"
+#include "GrGpu.h"
+
+GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrVertexBufferAllocPool* vertexPool,
+                                         GrIndexBufferAllocPool* indexPool) :
+        fDraws(DRAWS_BLOCK_SIZE, fDrawsStorage),
+        fStates(STATES_BLOCK_SIZE, fStatesStorage),
+        fClips(CLIPS_BLOCK_SIZE, fClipsStorage),
+        fClipSet(true),
+
+        fLastRectVertexLayout(0),
+        fQuadIndexBuffer(NULL),
+        fMaxQuads(0),
+        fCurrQuad(0),
+
+        fVertexPool(*vertexPool),
+        fCurrPoolVertexBuffer(NULL),
+        fCurrPoolStartVertex(0),
+        fIndexPool(*indexPool),
+        fCurrPoolIndexBuffer(NULL),
+        fCurrPoolStartIndex(0),
+        fReservedVertexBytes(0),
+        fReservedIndexBytes(0),
+        fUsedReservedVertexBytes(0),
+        fUsedReservedIndexBytes(0) {
+    GrAssert(NULL != vertexPool);
+    GrAssert(NULL != indexPool);
+}
+
+GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
+    this->reset();
+    GrSafeUnref(fQuadIndexBuffer);
+}
+
+void GrInOrderDrawBuffer::initializeDrawStateAndClip(const GrDrawTarget& target) {
+    this->copyDrawState(target);
+    this->setClip(target.getClip());
+}
+
+void GrInOrderDrawBuffer::setQuadIndexBuffer(const GrIndexBuffer* indexBuffer) {
+    bool newIdxBuffer = fQuadIndexBuffer != indexBuffer;
+    if (newIdxBuffer) {
+        GrSafeUnref(fQuadIndexBuffer);
+        fQuadIndexBuffer = indexBuffer;
+        GrSafeRef(fQuadIndexBuffer);
+        fCurrQuad = 0;
+        fMaxQuads = (NULL == indexBuffer) ? 0 : indexBuffer->maxQuads();
+    } else {
+        GrAssert((NULL == indexBuffer && 0 == fMaxQuads) ||
+                 (indexBuffer->maxQuads() == fMaxQuads));
+    }
+}
+
+void GrInOrderDrawBuffer::drawRect(const GrRect& rect,
+                                   const GrMatrix* matrix,
+                                   StageBitfield stageEnableBitfield,
+                                   const GrRect* srcRects[],
+                                   const GrMatrix* srcMatrices[]) {
+
+    GrAssert(!(NULL == fQuadIndexBuffer && fCurrQuad));
+    GrAssert(!(fDraws.empty() && fCurrQuad));
+    GrAssert(!(0 != fMaxQuads && NULL == fQuadIndexBuffer));
+
+    // if we have a quad IB then either append to the previous run of
+    // rects or start a new run
+    if (fMaxQuads) {
+
+        bool appendToPreviousDraw = false;
+        GrVertexLayout layout = GetRectVertexLayout(stageEnableBitfield, srcRects);
+        AutoReleaseGeometry geo(this, layout, 4, 0);
+        AutoViewMatrixRestore avmr(this);
+        GrMatrix combinedMatrix = this->getViewMatrix();
+        this->setViewMatrix(GrMatrix::I());
+        if (NULL != matrix) {
+            combinedMatrix.preConcat(*matrix);
+        }
+
+        SetRectVertices(rect, &combinedMatrix, srcRects, srcMatrices, layout, geo.vertices());
+
+        // we don't want to miss an opportunity to batch rects together
+        // simply because the clip has changed if the clip doesn't affect
+        // the rect.
+        bool disabledClip = false;
+        if (this->isClipState() && fClip.isRect()) {
+
+            GrRect clipRect = fClip.getRect(0);
+            // If the clip rect touches the edge of the viewport, extended it
+            // out (close) to infinity to avoid bogus intersections.
+            // We might consider a more exact clip to viewport if this
+            // conservative test fails.
+            const GrRenderTarget* target = this->getRenderTarget();
+            if (0 >= clipRect.fLeft) {
+                clipRect.fLeft = GR_ScalarMin;
+            }
+            if (target->width() <= clipRect.fRight) {
+                clipRect.fRight = GR_ScalarMax;
+            }
+            if (0 >= clipRect.top()) {
+                clipRect.fTop = GR_ScalarMin;
+            }
+            if (target->height() <= clipRect.fBottom) {
+                clipRect.fBottom = GR_ScalarMax;
+            }
+            int stride = VertexSize(layout);
+            bool insideClip = true;
+            for (int v = 0; v < 4; ++v) {
+                const GrPoint& p = *GetVertexPoint(geo.vertices(), v, stride);
+                if (!clipRect.contains(p)) {
+                    insideClip = false;
+                    break;
+                }
+            }
+            if (insideClip) {
+                this->disableState(kClip_StateBit);
+                disabledClip = true;
+            }
+        }
+        if (!needsNewClip() && !needsNewState() && fCurrQuad > 0 &&
+            fCurrQuad < fMaxQuads && layout == fLastRectVertexLayout) {
+
+            int vsize = VertexSize(layout);
+
+            Draw& lastDraw = fDraws.back();
+
+            GrAssert(lastDraw.fIndexBuffer == fQuadIndexBuffer);
+            GrAssert(kTriangles_PrimitiveType == lastDraw.fPrimitiveType);
+            GrAssert(0 == lastDraw.fVertexCount % 4);
+            GrAssert(0 == lastDraw.fIndexCount % 6);
+            GrAssert(0 == lastDraw.fStartIndex);
+
+            appendToPreviousDraw = lastDraw.fVertexBuffer == fCurrPoolVertexBuffer &&
+                                   (fCurrQuad * 4 + lastDraw.fStartVertex) == fCurrPoolStartVertex;
+            if (appendToPreviousDraw) {
+                lastDraw.fVertexCount += 4;
+                lastDraw.fIndexCount += 6;
+                fCurrQuad += 1;
+                GrAssert(0 == fUsedReservedVertexBytes);
+                fUsedReservedVertexBytes = 4 * vsize;
+            }
+        }
+        if (!appendToPreviousDraw) {
+            this->setIndexSourceToBuffer(fQuadIndexBuffer);
+            drawIndexed(kTriangles_PrimitiveType, 0, 0, 4, 6);
+            fCurrQuad = 1;
+            fLastRectVertexLayout = layout;
+        }
+        if (disabledClip) {
+            this->enableState(kClip_StateBit);
+        }
+    } else {
+        INHERITED::drawRect(rect, matrix, stageEnableBitfield, srcRects, srcMatrices);
+    }
+}
+
+void GrInOrderDrawBuffer::drawIndexed(GrPrimitiveType primitiveType,
+                                      int startVertex,
+                                      int startIndex,
+                                      int vertexCount,
+                                      int indexCount) {
+
+    if (!vertexCount || !indexCount) {
+        return;
+    }
+
+    fCurrQuad = 0;
+
+    Draw& draw = fDraws.push_back();
+    draw.fPrimitiveType = primitiveType;
+    draw.fStartVertex   = startVertex;
+    draw.fStartIndex    = startIndex;
+    draw.fVertexCount   = vertexCount;
+    draw.fIndexCount    = indexCount;
+
+    draw.fClipChanged = this->needsNewClip();
+    if (draw.fClipChanged) {
+       this->pushClip();
+    }
+
+    draw.fStateChanged = this->needsNewState();
+    if (draw.fStateChanged) {
+        this->pushState();
+    }
+
+    draw.fVertexLayout = fGeometrySrc.fVertexLayout;
+    switch (fGeometrySrc.fVertexSrc) {
+    case kBuffer_GeometrySrcType:
+        draw.fVertexBuffer = fGeometrySrc.fVertexBuffer;
+        break;
+    case kReserved_GeometrySrcType: {
+        size_t vertexBytes = (vertexCount + startVertex) *
+        VertexSize(fGeometrySrc.fVertexLayout);
+        fUsedReservedVertexBytes = GrMax(fUsedReservedVertexBytes, vertexBytes);
+    } // fallthrough
+    case kArray_GeometrySrcType:
+        draw.fVertexBuffer = fCurrPoolVertexBuffer;
+        draw.fStartVertex += fCurrPoolStartVertex;
+        break;
+    default:
+        GrCrash("unknown geom src type");
+    }
+    draw.fVertexBuffer->ref();
+
+    switch (fGeometrySrc.fIndexSrc) {
+    case kBuffer_GeometrySrcType:
+        draw.fIndexBuffer = fGeometrySrc.fIndexBuffer;
+        break;
+    case kReserved_GeometrySrcType: {
+        size_t indexBytes = (indexCount + startIndex) * sizeof(uint16_t);
+        fUsedReservedIndexBytes = GrMax(fUsedReservedIndexBytes, indexBytes);
+    } // fallthrough
+    case kArray_GeometrySrcType:
+        draw.fIndexBuffer = fCurrPoolIndexBuffer;
+        draw.fStartIndex += fCurrPoolStartVertex;
+        break;
+    default:
+        GrCrash("unknown geom src type");
+    }
+    draw.fIndexBuffer->ref();
+}
+
+void GrInOrderDrawBuffer::drawNonIndexed(GrPrimitiveType primitiveType,
+                                         int startVertex,
+                                         int vertexCount) {
+    if (!vertexCount) {
+        return;
+    }
+
+    fCurrQuad = 0;
+
+    Draw& draw = fDraws.push_back();
+    draw.fPrimitiveType = primitiveType;
+    draw.fStartVertex   = startVertex;
+    draw.fStartIndex    = 0;
+    draw.fVertexCount   = vertexCount;
+    draw.fIndexCount    = 0;
+
+    draw.fClipChanged = this->needsNewClip();
+    if (draw.fClipChanged) {
+        this->pushClip();
+    }
+
+    draw.fStateChanged = this->needsNewState();
+    if (draw.fStateChanged) {
+        this->pushState();
+    }
+
+    draw.fVertexLayout = fGeometrySrc.fVertexLayout;
+    switch (fGeometrySrc.fVertexSrc) {
+    case kBuffer_GeometrySrcType:
+        draw.fVertexBuffer = fGeometrySrc.fVertexBuffer;
+        break;
+    case kReserved_GeometrySrcType: {
+        size_t vertexBytes = (vertexCount + startVertex) *
+        VertexSize(fGeometrySrc.fVertexLayout);
+        fUsedReservedVertexBytes = GrMax(fUsedReservedVertexBytes,
+                                         vertexBytes);
+    } // fallthrough
+    case kArray_GeometrySrcType:
+        draw.fVertexBuffer = fCurrPoolVertexBuffer;
+        draw.fStartVertex += fCurrPoolStartVertex;
+        break;
+    default:
+        GrCrash("unknown geom src type");
+    }
+    draw.fVertexBuffer->ref();
+    draw.fIndexBuffer = NULL;
+}
+
+void GrInOrderDrawBuffer::reset() {
+    GrAssert(!fReservedGeometry.fLocked);
+    uint32_t numStates = fStates.count();
+    for (uint32_t i = 0; i < numStates; ++i) {
+        const DrState& dstate = this->accessSavedDrawState(fStates[i]);
+        for (int s = 0; s < kNumStages; ++s) {
+            GrSafeUnref(dstate.fTextures[s]);
+        }
+        GrSafeUnref(dstate.fRenderTarget);
+    }
+    int numDraws = fDraws.count();
+    for (int d = 0; d < numDraws; ++d) {
+        // we always have a VB, but not always an IB
+        GrAssert(NULL != fDraws[d].fVertexBuffer);
+        fDraws[d].fVertexBuffer->unref();
+        GrSafeUnref(fDraws[d].fIndexBuffer);
+    }
+    fDraws.reset();
+    fStates.reset();
+
+    fVertexPool.reset();
+    fIndexPool.reset();
+
+    fClips.reset();
+
+    fCurrQuad = 0;
+}
+
+void GrInOrderDrawBuffer::playback(GrDrawTarget* target) {
+    GrAssert(NULL != target);
+    GrAssert(target != this); // not considered and why?
+
+    uint32_t numDraws = fDraws.count();
+    if (!numDraws) {
+        return;
+    }
+
+    fVertexPool.unlock();
+    fIndexPool.unlock();
+
+    GrDrawTarget::AutoStateRestore asr(target);
+    GrDrawTarget::AutoClipRestore acr(target);
+    // important to not mess with reserve/lock geometry in the target with this
+    // on the stack.
+    GrDrawTarget::AutoGeometrySrcRestore agsr(target);
+
+    uint32_t currState = ~0;
+    uint32_t currClip  = ~0;
+
+    for (uint32_t i = 0; i < numDraws; ++i) {
+        const Draw& draw = fDraws[i];
+        if (draw.fStateChanged) {
+            ++currState;
+            target->restoreDrawState(fStates[currState]);
+        }
+        if (draw.fClipChanged) {
+            ++currClip;
+            target->setClip(fClips[currClip]);
+        }
+        uint32_t vertexReserveCount = 0;
+        uint32_t indexReserveCount = 0;
+
+        target->setVertexSourceToBuffer(draw.fVertexLayout, draw.fVertexBuffer);
+
+        if (draw.fIndexCount) {
+            target->setIndexSourceToBuffer(draw.fIndexBuffer);
+        }
+
+        if (draw.fIndexCount) {
+            target->drawIndexed(draw.fPrimitiveType,
+                                draw.fStartVertex,
+                                draw.fStartIndex,
+                                draw.fVertexCount,
+                                draw.fIndexCount);
+        } else {
+            target->drawNonIndexed(draw.fPrimitiveType,
+                                   draw.fStartVertex,
+                                   draw.fVertexCount);
+        }
+        if (vertexReserveCount || indexReserveCount) {
+            target->releaseReservedGeometry();
+        }
+    }
+}
+
+bool GrInOrderDrawBuffer::geometryHints(GrVertexLayout vertexLayout,
+                                        int* vertexCount,
+                                        int* indexCount) const {
+    // we will recommend a flush if the data could fit in a single
+    // preallocated buffer but none are left and it can't fit
+    // in the current buffer (which may not be prealloced).
+    bool flush = false;
+    if (NULL != indexCount) {
+        int32_t currIndices = fIndexPool.currentBufferIndices();
+        if (*indexCount > currIndices &&
+            (!fIndexPool.preallocatedBuffersRemaining() &&
+             *indexCount <= fIndexPool.preallocatedBufferIndices())) {
+
+            flush = true;
+        }
+        *indexCount = currIndices;
+    }
+    if (NULL != vertexCount) {
+        int32_t currVertices = fVertexPool.currentBufferVertices(vertexLayout);
+        if (*vertexCount > currVertices &&
+            (!fVertexPool.preallocatedBuffersRemaining() &&
+             *vertexCount <= fVertexPool.preallocatedBufferVertices(vertexLayout))) {
+
+            flush = true;
+        }
+        *vertexCount = currVertices;
+    }
+    return flush;
+}
+
+bool GrInOrderDrawBuffer::acquireGeometryHelper(GrVertexLayout vertexLayout,
+                                                void**         vertices,
+                                                void**         indices) {
+    GrAssert(!fReservedGeometry.fLocked);
+    if (fReservedGeometry.fVertexCount) {
+        GrAssert(NULL != vertices);
+        GrAssert(0 == fReservedVertexBytes);
+        GrAssert(0 == fUsedReservedVertexBytes);
+
+        fReservedVertexBytes = VertexSize(vertexLayout) *
+                               fReservedGeometry.fVertexCount;
+        *vertices = fVertexPool.makeSpace(vertexLayout,
+                                          fReservedGeometry.fVertexCount,
+                                          &fCurrPoolVertexBuffer,
+                                          &fCurrPoolStartVertex);
+        if (NULL == *vertices) {
+            return false;
+        }
+    }
+    if (fReservedGeometry.fIndexCount) {
+        GrAssert(NULL != indices);
+        GrAssert(0 == fReservedIndexBytes);
+        GrAssert(0 == fUsedReservedIndexBytes);
+
+        *indices = fIndexPool.makeSpace(fReservedGeometry.fIndexCount,
+                                        &fCurrPoolIndexBuffer,
+                                        &fCurrPoolStartIndex);
+        if (NULL == *indices) {
+            fVertexPool.putBack(fReservedVertexBytes);
+            fReservedVertexBytes = 0;
+            fCurrPoolVertexBuffer = NULL;
+            return false;
+        }
+    }
+    return true;
+}
+
+void GrInOrderDrawBuffer::releaseGeometryHelper() {
+    GrAssert(fUsedReservedVertexBytes <= fReservedVertexBytes);
+    GrAssert(fUsedReservedIndexBytes <= fReservedIndexBytes);
+
+    size_t vertexSlack = fReservedVertexBytes - fUsedReservedVertexBytes;
+    fVertexPool.putBack(vertexSlack);
+
+    size_t indexSlack = fReservedIndexBytes - fUsedReservedIndexBytes;
+    fIndexPool.putBack(indexSlack);
+
+    fReservedVertexBytes = 0;
+    fReservedIndexBytes  = 0;
+    fUsedReservedVertexBytes = 0;
+    fUsedReservedIndexBytes  = 0;
+    fCurrPoolVertexBuffer = 0;
+    fCurrPoolStartVertex = 0;
+
+}
+
+void GrInOrderDrawBuffer::setVertexSourceToArrayHelper(const void* vertexArray,
+                                                       int vertexCount) {
+    GrAssert(!fReservedGeometry.fLocked || !fReservedGeometry.fVertexCount);
+#if GR_DEBUG
+    bool success =
+#endif
+    fVertexPool.appendVertices(fGeometrySrc.fVertexLayout,
+                               vertexCount,
+                               vertexArray,
+                               &fCurrPoolVertexBuffer,
+                               &fCurrPoolStartVertex);
+    GR_DEBUGASSERT(success);
+}
+
+void GrInOrderDrawBuffer::setIndexSourceToArrayHelper(const void* indexArray,
+                                                      int indexCount) {
+    GrAssert(!fReservedGeometry.fLocked || !fReservedGeometry.fIndexCount);
+#if GR_DEBUG
+    bool success =
+#endif
+    fIndexPool.appendIndices(indexCount,
+                             indexArray,
+                             &fCurrPoolIndexBuffer,
+                             &fCurrPoolStartIndex);
+    GR_DEBUGASSERT(success);
+}
+
+bool GrInOrderDrawBuffer::needsNewState() const {
+     if (fStates.empty()) {
+        return true;
+     } else {
+         const DrState& old = this->accessSavedDrawState(fStates.back());
+        return old != fCurrDrawState;
+     }
+}
+
+void GrInOrderDrawBuffer::pushState() {
+    for (int s = 0; s < kNumStages; ++s) {
+        GrSafeRef(fCurrDrawState.fTextures[s]);
+    }
+    GrSafeRef(fCurrDrawState.fRenderTarget);
+    this->saveCurrentDrawState(&fStates.push_back());
+ }
+
+bool GrInOrderDrawBuffer::needsNewClip() const {
+   if (fCurrDrawState.fFlagBits & kClip_StateBit) {
+       if (fClips.empty() || (fClipSet && fClips.back() != fClip)) {
+           return true;
+       }
+    }
+    return false;
+}
+
+void GrInOrderDrawBuffer::pushClip() {
+    fClips.push_back() = fClip;
+    fClipSet = false;
+}
+
+void GrInOrderDrawBuffer::clipWillBeSet(const GrClip& newClip)  {
+    fClipSet = true;
+}
diff --git a/gpu/src/GrMatrix.cpp b/gpu/src/GrMatrix.cpp
new file mode 100644
index 0000000..0a2d1b2
--- /dev/null
+++ b/gpu/src/GrMatrix.cpp
@@ -0,0 +1,729 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrMatrix.h"
+#include "GrRect.h"
+#include <stddef.h>
+
+#if GR_SCALAR_IS_FLOAT
+    const GrScalar GrMatrix::gRESCALE(GR_Scalar1);
+#else
+    GR_STATIC_ASSERT(GR_SCALAR_IS_FIXED);
+    // fixed point isn't supported right now
+    GR_STATIC_ASSERT(false);
+const GrScalar GrMatrix::gRESCALE(1 << 30);
+#endif
+
+const GrMatrix::MapProc GrMatrix::gMapProcs[] = {
+// Scales are not both zero
+    &GrMatrix::mapIdentity,
+    &GrMatrix::mapScale,
+    &GrMatrix::mapTranslate,
+    &GrMatrix::mapScaleAndTranslate,
+    &GrMatrix::mapSkew,
+    &GrMatrix::mapScaleAndSkew,
+    &GrMatrix::mapSkewAndTranslate,
+    &GrMatrix::mapNonPerspective,
+    // no optimizations for perspective matrices
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapPerspective,
+
+// Scales are zero (every other is invalid because kScale_TypeBit must be set if
+// kZeroScale_TypeBit is set)
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapZero,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapSetToTranslate,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapSwappedScale,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapSwappedScaleAndTranslate,
+
+    // no optimizations for perspective matrices
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapZero,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapPerspective,
+    &GrMatrix::mapInvalid,
+    &GrMatrix::mapPerspective,
+};
+
+void GrMatrix::setIdentity() {
+    fM[0] = GR_Scalar1; fM[1] = 0;          fM[2] = 0;
+    fM[3] = 0;          fM[4] = GR_Scalar1; fM[5] = 0;
+    fM[6] = 0;          fM[7] = 0;          fM[8] = gRESCALE;
+    fTypeMask = 0;
+}
+
+void GrMatrix::setTranslate(GrScalar dx, GrScalar dy) {
+    fM[0] = GR_Scalar1; fM[1] = 0;          fM[2] = dx;
+    fM[3] = 0;          fM[4] = GR_Scalar1; fM[5] = dy;
+    fM[6] = 0;          fM[7] = 0;          fM[8] = gRESCALE;
+    fTypeMask = (0 != dx || 0 != dy) ? kTranslate_TypeBit : 0;
+}
+
+void GrMatrix::setScale(GrScalar sx, GrScalar sy) {
+    fM[0] = sx; fM[1] = 0;  fM[2] = 0;
+    fM[3] = 0;  fM[4] = sy; fM[5] = 0;
+    fM[6] = 0;  fM[7] = 0;  fM[8] = gRESCALE;
+    fTypeMask = (GR_Scalar1 != sx || GR_Scalar1 != sy) ? kScale_TypeBit : 0;
+}
+
+void GrMatrix::setSkew(GrScalar skx, GrScalar sky) {
+    fM[0] = GR_Scalar1; fM[1] = skx;        fM[2] = 0;
+    fM[3] = sky;        fM[4] = GR_Scalar1; fM[5] = 0;
+    fM[6] = 0;          fM[7] = 0;          fM[8] = gRESCALE;
+    fTypeMask = (0 != skx || 0 != sky) ? kSkew_TypeBit : 0;
+}
+
+void GrMatrix::setConcat(const GrMatrix& a, const GrMatrix& b) {
+    if (a.isIdentity()) {
+        if (this != &b) {
+            for (int i = 0; i < 9; ++i) {
+                fM[i] = b.fM[i];
+            }
+            fTypeMask = b.fTypeMask;
+        }
+        return;
+    }
+
+    if (b.isIdentity()) {
+        GrAssert(!a.isIdentity());
+        if (this != &a) {
+            for (int i = 0; i < 9; ++i) {
+                    fM[i] = a.fM[i];
+            }
+            fTypeMask = a.fTypeMask;
+        }
+        return;
+    }
+
+    // a and/or b could be this
+    GrMatrix tmp;
+
+    // could do more optimizations based on type bits. Hopefully this call is
+    // low frequency.
+    // TODO: make this work for fixed point
+    if (!((b.fTypeMask | a.fTypeMask) & kPerspective_TypeBit)) {
+        tmp.fM[0] = a.fM[0] * b.fM[0] + a.fM[1] * b.fM[3];
+        tmp.fM[1] = a.fM[0] * b.fM[1] + a.fM[1] * b.fM[4];
+        tmp.fM[2] = a.fM[0] * b.fM[2] + a.fM[1] * b.fM[5] + a.fM[2] * gRESCALE;
+
+        tmp.fM[3] = a.fM[3] * b.fM[0] + a.fM[4] * b.fM[3];
+        tmp.fM[4] = a.fM[3] * b.fM[1] + a.fM[4] * b.fM[4];
+        tmp.fM[5] = a.fM[3] * b.fM[2] + a.fM[4] * b.fM[5] + a.fM[5] * gRESCALE;
+
+        tmp.fM[6] = 0;
+        tmp.fM[7] = 0;
+        tmp.fM[8] = gRESCALE * gRESCALE;
+    } else {
+        tmp.fM[0] = a.fM[0] * b.fM[0] + a.fM[1] * b.fM[3] + a.fM[2] * b.fM[6];
+        tmp.fM[1] = a.fM[0] * b.fM[1] + a.fM[1] * b.fM[4] + a.fM[2] * b.fM[7];
+        tmp.fM[2] = a.fM[0] * b.fM[2] + a.fM[1] * b.fM[5] + a.fM[2] * b.fM[8];
+
+        tmp.fM[3] = a.fM[3] * b.fM[0] + a.fM[4] * b.fM[3] + a.fM[5] * b.fM[6];
+        tmp.fM[4] = a.fM[3] * b.fM[1] + a.fM[4] * b.fM[4] + a.fM[5] * b.fM[7];
+        tmp.fM[5] = a.fM[3] * b.fM[2] + a.fM[4] * b.fM[5] + a.fM[5] * b.fM[8];
+
+        tmp.fM[6] = a.fM[6] * b.fM[0] + a.fM[7] * b.fM[3] + a.fM[8] * b.fM[6];
+        tmp.fM[7] = a.fM[6] * b.fM[1] + a.fM[7] * b.fM[4] + a.fM[8] * b.fM[7];
+        tmp.fM[8] = a.fM[6] * b.fM[2] + a.fM[7] * b.fM[5] + a.fM[8] * b.fM[8];
+    }
+    *this = tmp;
+    this->computeTypeMask();
+}
+
+void GrMatrix::preConcat(const GrMatrix& m) {
+    setConcat(*this, m);
+}
+
+void GrMatrix::postConcat(const GrMatrix& m) {
+    setConcat(m, *this);
+}
+
+double GrMatrix::determinant() const {
+    if (fTypeMask & kPerspective_TypeBit) {
+        return  fM[0]*((double)fM[4]*fM[8] - (double)fM[5]*fM[7]) +
+                fM[1]*((double)fM[5]*fM[6] - (double)fM[3]*fM[8]) +
+                fM[2]*((double)fM[3]*fM[7] - (double)fM[4]*fM[6]);
+    } else {
+        return (double)fM[0]*fM[4]*gRESCALE -
+               (double)fM[1]*fM[3]*gRESCALE;
+    }
+}
+
+bool GrMatrix::invert(GrMatrix* inverted) const {
+
+    if (isIdentity()) {
+        if (inverted != this) {
+            inverted->setIdentity();
+        }
+        return true;
+    }
+    static const double MIN_DETERMINANT_SQUARED = 1.e-16;
+
+    // could do more optimizations based on type bits. Hopefully this call is
+    // low frequency.
+
+    double det = determinant();
+
+    // check if we can't be inverted
+    if (det*det <= MIN_DETERMINANT_SQUARED) {
+        return false;
+    } else if (NULL == inverted) {
+        return true;
+    }
+
+    double t[9];
+
+    if (fTypeMask & kPerspective_TypeBit) {
+        t[0] = ((double)fM[4]*fM[8] - (double)fM[5]*fM[7]);
+        t[1] = ((double)fM[2]*fM[7] - (double)fM[1]*fM[8]);
+        t[2] = ((double)fM[1]*fM[5] - (double)fM[2]*fM[4]);
+        t[3] = ((double)fM[5]*fM[6] - (double)fM[3]*fM[8]);
+        t[4] = ((double)fM[0]*fM[8] - (double)fM[2]*fM[6]);
+        t[5] = ((double)fM[2]*fM[3] - (double)fM[0]*fM[5]);
+        t[6] = ((double)fM[3]*fM[7] - (double)fM[4]*fM[6]);
+        t[7] = ((double)fM[1]*fM[6] - (double)fM[0]*fM[7]);
+        t[8] = ((double)fM[0]*fM[4] - (double)fM[1]*fM[3]);
+        det = 1.0 / det;
+        for (int i = 0; i < 9; ++i) {
+            inverted->fM[i] = (GrScalar)(t[i] * det);
+        }
+    } else {
+        t[0] =  (double)fM[4]*gRESCALE;
+        t[1] = -(double)fM[1]*gRESCALE;
+        t[2] =  (double)fM[1]*fM[5] - (double)fM[2]*fM[4];
+        t[3] = -(double)fM[3]*gRESCALE;
+        t[4] =  (double)fM[0]*gRESCALE;
+        t[5] =  (double)fM[2]*fM[3] - (double)fM[0]*fM[5];
+        //t[6] = 0.0;
+        //t[7] = 0.0;
+        t[8] = (double)fM[0]*fM[4] - (double)fM[1]*fM[3];
+        det = 1.0 / det;
+        for (int i = 0; i < 6; ++i) {
+            inverted->fM[i] = (GrScalar)(t[i] * det);
+        }
+        inverted->fM[6] = 0;
+        inverted->fM[7] = 0;
+        inverted->fM[8] = (GrScalar)(t[8] * det);
+    }
+    inverted->computeTypeMask();
+    return true;
+}
+
+void GrMatrix::mapRect(GrRect* dst, const GrRect& src) const {
+    GrPoint srcPts[4], dstPts[4];
+    srcPts[0].set(src.fLeft, src.fTop);
+    srcPts[1].set(src.fRight, src.fTop);
+    srcPts[2].set(src.fRight, src.fBottom);
+    srcPts[3].set(src.fLeft, src.fBottom);
+    this->mapPoints(dstPts, srcPts, 4);
+    dst->setBounds(dstPts, 4);
+}
+
+bool GrMatrix::hasPerspective() const {
+    GrAssert(!!(kPerspective_TypeBit & fTypeMask) ==
+             (fM[kPersp0] != 0 || fM[kPersp1] != 0 || fM[kPersp2] != gRESCALE));
+    return 0 != (kPerspective_TypeBit & fTypeMask);
+}
+
+bool GrMatrix::isIdentity() const {
+    GrAssert((0 == fTypeMask) ==
+             (GR_Scalar1 == fM[kScaleX] && 0          == fM[kSkewX]  && 0          == fM[kTransX] &&
+              0          == fM[kSkewY]  && GR_Scalar1 == fM[kScaleY] && 0          == fM[kTransY] &&
+              0          == fM[kPersp0] && 0          == fM[kPersp1] && gRESCALE == fM[kPersp2]));
+    return (0 == fTypeMask);
+}
+
+
+GrScalar GrMatrix::getMaxStretch() const {
+
+    if (fTypeMask & kPerspective_TypeBit) {
+        return -GR_Scalar1;
+    }
+
+    GrScalar stretch;
+
+    if (isIdentity()) {
+        stretch = GR_Scalar1;
+    } else if (!(fTypeMask & kSkew_TypeBit)) {
+        stretch = GrMax(GrScalarAbs(fM[kScaleX]), GrScalarAbs(fM[kScaleY]));
+    } else if (fTypeMask & kZeroScale_TypeBit) {
+        stretch = GrMax(GrScalarAbs(fM[kSkewX]), GrScalarAbs(fM[kSkewY]));
+    } else {
+        // ignore the translation part of the matrix, just look at 2x2 portion.
+        // compute singular values, take largest abs value.
+        // [a b; b c] = A^T*A
+        GrScalar a = GrMul(fM[kScaleX], fM[kScaleX]) + GrMul(fM[kSkewY],  fM[kSkewY]);
+        GrScalar b = GrMul(fM[kScaleX], fM[kSkewX]) +  GrMul(fM[kScaleY], fM[kSkewY]);
+        GrScalar c = GrMul(fM[kSkewX],  fM[kSkewX]) +  GrMul(fM[kScaleY], fM[kScaleY]);
+        // eigenvalues of A^T*A are the squared singular values of A.
+        // characteristic equation is det((A^T*A) - l*I) = 0
+        // l^2 - (a + c)l + (ac-b^2)
+        // solve using quadratic equation (divisor is non-zero since l^2 has 1 coeff
+        // and roots are guaraunteed to be pos and real).
+        GrScalar largerRoot;
+        GrScalar bSqd = GrMul(b,b);
+        // TODO: fixed point tolerance value.
+        if (bSqd < 1e-10) { // will be true if upper left 2x2 is orthogonal, which is common, so save some math
+            largerRoot = GrMax(a, c);
+        } else {
+            GrScalar aminusc = a - c;
+            GrScalar apluscdiv2 = (a + c) / 2;
+            GrScalar x = sqrtf(GrMul(aminusc,aminusc) + GrMul(4,(bSqd))) / 2;
+            largerRoot = apluscdiv2 + x;
+        }
+
+        stretch = sqrtf(largerRoot);
+    }
+#if GR_DEBUG && 0
+    // test a bunch of vectors. None should be scaled by more than stretch
+    // (modulo some error) and we should find a vector that is scaled by almost
+    // stretch.
+    GrPoint pt;
+    GrScalar max = 0;
+    for (int i = 0; i < 1000; ++i) {
+        GrScalar x = (float)rand() / RAND_MAX;
+        GrScalar y = sqrtf(1 - (x*x));
+        pt.fX = fM[kScaleX]*x + fM[kSkewX]*y;
+        pt.fY = fM[kSkewY]*x + fM[kScaleY]*y;
+        GrScalar d = pt.distanceToOrigin();
+        GrAssert(d <= (1.0001 * stretch));
+        max = GrMax(max, pt.distanceToOrigin());
+    }
+    GrAssert((stretch - max) < .05*stretch);
+#endif
+    return stretch;
+}
+
+bool GrMatrix::operator == (const GrMatrix& m) const {
+    if (fTypeMask != m.fTypeMask) {
+        return false;
+    }
+    if (!fTypeMask) {
+        return true;
+    }
+    for (int i = 0; i < 9; ++i) {
+        if (m.fM[i] != fM[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool GrMatrix::operator != (const GrMatrix& m) const {
+    return !(*this == m);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Matrix transformation procs
+//////
+
+void GrMatrix::mapIdentity(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i] = src[i];
+        }
+    }
+}
+
+void GrMatrix::mapScale(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    for (uint32_t i = 0; i < count; ++i) {
+        dst[i].fX = GrMul(src[i].fX, fM[kScaleX]);
+        dst[i].fY = GrMul(src[i].fY, fM[kScaleY]);
+    }
+}
+
+
+void GrMatrix::mapTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    for (uint32_t i = 0; i < count; ++i) {
+        dst[i].fX = src[i].fX + fM[kTransX];
+        dst[i].fY = src[i].fY + fM[kTransY];
+    }
+}
+
+void GrMatrix::mapScaleAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    for (uint32_t i = 0; i < count; ++i) {
+        dst[i].fX = GrMul(src[i].fX, fM[kScaleX]) + fM[kTransX];
+        dst[i].fY = GrMul(src[i].fY, fM[kScaleY]) + fM[kTransY];
+    }
+}
+
+void GrMatrix::mapSkew(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = src[i].fX + GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = src[i].fY + GrMul(src[i].fX, fM[kSkewY]);
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = src[i].fX + GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = src[i].fY + GrMul(src[i].fX, fM[kSkewY]);
+            dst[i].fX = newX;
+        }
+    }
+}
+
+void GrMatrix::mapScaleAndSkew(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = GrMul(src[i].fX, fM[kScaleX]) + GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = GrMul(src[i].fY, fM[kScaleY]) + GrMul(src[i].fX, fM[kSkewY]);
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = GrMul(src[i].fX, fM[kScaleX]) + GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = GrMul(src[i].fY, fM[kScaleY]) + GrMul(src[i].fX, fM[kSkewY]);
+            dst[i].fX = newX;
+        }
+    }
+}
+
+void GrMatrix::mapSkewAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = src[i].fX + GrMul(src[i].fY, fM[kSkewX]) + fM[kTransX];
+            dst[i].fY = src[i].fY + GrMul(src[i].fX, fM[kSkewY]) + fM[kTransY];
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = src[i].fX + GrMul(src[i].fY, fM[kSkewX]) + fM[kTransX];
+            dst[i].fY = src[i].fY + GrMul(src[i].fX, fM[kSkewY]) + fM[kTransY];
+            dst[i].fX = newX;
+        }
+    }
+}
+
+void GrMatrix::mapNonPerspective(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = GrMul(fM[kScaleX], src[i].fX) + GrMul(fM[kSkewX], src[i].fY) + fM[kTransX];
+            dst[i].fY = GrMul(fM[kSkewY], src[i].fX) + GrMul(fM[kScaleY], src[i].fY) + fM[kTransY];
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = GrMul(fM[kScaleX], src[i].fX) + GrMul(fM[kSkewX], src[i].fY) + fM[kTransX];
+            dst[i].fY = GrMul(fM[kSkewY], src[i].fX) + GrMul(fM[kScaleY], src[i].fY) + fM[kTransY];
+            dst[i].fX = newX;
+        }
+    }
+}
+
+void GrMatrix::mapPerspective(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    for (uint32_t i = 0; i < count; ++i) {
+        GrScalar x, y, w;
+        x = GrMul(fM[kScaleX], src[i].fX) + GrMul(fM[kSkewX], src[i].fY) + fM[kTransX];
+        y = GrMul(fM[kSkewY], src[i].fX) + GrMul(fM[kScaleY], src[i].fY) + fM[kTransY];
+        w = GrMul(fM[kPersp0], src[i].fX) + GrMul(fM[kPersp1], src[i].fY) + fM[kPersp2];
+        // TODO need fixed point invert
+        if (w) {
+            w = 1 / w;
+        }
+        dst[i].fX = GrMul(x, w);
+        dst[i].fY = GrMul(y, w);
+    }
+}
+
+void GrMatrix::mapInvalid(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    GrAssert(0);
+}
+
+void GrMatrix::mapZero(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    memset(dst, 0, sizeof(GrPoint)*count);
+}
+
+void GrMatrix::mapSetToTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    for (uint32_t i = 0; i < count; ++i) {
+        dst[i].fX = fM[kTransX];
+        dst[i].fY = fM[kTransY];
+    }
+}
+
+void GrMatrix::mapSwappedScale(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = GrMul(src[i].fX, fM[kSkewY]);
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = GrMul(src[i].fY, fM[kSkewX]);
+            dst[i].fY = GrMul(src[i].fX, fM[kSkewY]);
+            dst[i].fX = newX;
+        }
+    }
+}
+
+void GrMatrix::mapSwappedScaleAndTranslate(GrPoint* dst, const GrPoint* src, uint32_t count) const {
+    if (src != dst) {
+        for (uint32_t i = 0; i < count; ++i) {
+            dst[i].fX = GrMul(src[i].fY, fM[kSkewX]) + fM[kTransX];
+            dst[i].fY = GrMul(src[i].fX, fM[kSkewY]) + fM[kTransY];
+        }
+    } else {
+        for (uint32_t i = 0; i < count; ++i) {
+            GrScalar newX = GrMul(src[i].fY, fM[kSkewX]) + fM[kTransX];
+            dst[i].fY = GrMul(src[i].fX, fM[kSkewY]) + fM[kTransY];
+            dst[i].fX = newX;
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Unit test
+//////
+
+#include "GrRandom.h"
+
+#if GR_DEBUG
+enum MatrixType {
+    kRotate_MatrixType,
+    kScaleX_MatrixType,
+    kScaleY_MatrixType,
+    kSkewX_MatrixType,
+    kSkewY_MatrixType,
+    kTranslateX_MatrixType,
+    kTranslateY_MatrixType,
+    kSwapScaleXY_MatrixType,
+    kPersp_MatrixType,
+
+    kMatrixTypeCount
+};
+
+static void create_matrix(GrMatrix* matrix, GrRandom& rand) {
+    MatrixType type = (MatrixType)(rand.nextU() % kMatrixTypeCount);
+    switch (type) {
+        case kRotate_MatrixType: {
+            float angle = rand.nextF() * 2 *3.14159265358979323846f;
+            GrScalar cosa = GrFloatToScalar(cosf(angle));
+            GrScalar sina = GrFloatToScalar(sinf(angle));
+            matrix->setAll(cosa,      -sina,           0,
+                           sina,       cosa,           0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kScaleX_MatrixType: {
+            GrScalar scale = GrFloatToScalar(rand.nextF(-2, 2));
+            matrix->setAll(scale,      0,              0,
+                           0,          GR_Scalar1,     0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kScaleY_MatrixType: {
+            GrScalar scale = GrFloatToScalar(rand.nextF(-2, 2));
+            matrix->setAll(GR_Scalar1, 0,              0,
+                           0,          scale,          0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kSkewX_MatrixType: {
+            GrScalar skew = GrFloatToScalar(rand.nextF(-2, 2));
+            matrix->setAll(GR_Scalar1, skew,           0,
+                           0,          GR_Scalar1,     0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kSkewY_MatrixType: {
+            GrScalar skew = GrFloatToScalar(rand.nextF(-2, 2));
+            matrix->setAll(GR_Scalar1, 0,              0,
+                           skew,       GR_Scalar1,     0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kTranslateX_MatrixType: {
+            GrScalar trans = GrFloatToScalar(rand.nextF(-10, 10));
+            matrix->setAll(GR_Scalar1, 0,              trans,
+                           0,          GR_Scalar1,     0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kTranslateY_MatrixType: {
+            GrScalar trans = GrFloatToScalar(rand.nextF(-10, 10));
+            matrix->setAll(GR_Scalar1, 0,              0,
+                           0,          GR_Scalar1,     trans,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kSwapScaleXY_MatrixType: {
+            GrScalar xy = GrFloatToScalar(rand.nextF(-2, 2));
+            GrScalar yx = GrFloatToScalar(rand.nextF(-2, 2));
+            matrix->setAll(0,          xy,             0,
+                           yx,         0,              0,
+                           0,          0,              GrMatrix::I()[8]);
+        } break;
+        case kPersp_MatrixType: {
+            GrScalar p0 = GrFloatToScalar(rand.nextF(-2, 2));
+            GrScalar p1 = GrFloatToScalar(rand.nextF(-2, 2));
+            GrScalar p2 = GrFloatToScalar(rand.nextF(-0.5f, 0.75f));
+            matrix->setAll(GR_Scalar1, 0,              0,
+                           0,          GR_Scalar1,     0,
+                           p0,         p1,             GrMul(p2,GrMatrix::I()[8]));
+        } break;
+        default:
+            GrAssert(0);
+            break;
+    }
+}
+#endif
+
+void GrMatrix::UnitTest() {
+    GrRandom rand;
+
+    // Create a bunch of matrices and test point mapping, max stretch calc,
+    // inversion and multiply-by-inverse.
+#if GR_DEBUG
+    for (int i = 0; i < 10000; ++i) {
+        GrMatrix a, b;
+        a.setIdentity();
+        int num = rand.nextU() % 6;
+        // force testing of I and swapXY
+        if (0 == i) {
+            num = 0;
+            GrAssert(a.isIdentity());
+        } else if (1 == i) {
+            num = 0;
+            a.setAll(0, GR_Scalar1, 0,
+                     GR_Scalar1, 0, 0,
+                     0, 0, I()[8]);
+        }
+        for (int j = 0; j < num; ++j) {
+            create_matrix(&b, rand);
+            a.preConcat(b);
+        }
+
+        GrScalar maxStretch = a.getMaxStretch();
+        if (maxStretch > 0) {
+            maxStretch = GrMul(GR_Scalar1 + GR_Scalar1 / 100, maxStretch);
+        }
+        GrPoint origin = a.mapPoint(GrPoint(0,0));
+
+        for (int j = 0; j < 9; ++j) {
+            int mask, origMask = a.fTypeMask;
+            GrScalar old = a[j];
+
+            a.set(j, GR_Scalar1);
+            mask = a.fTypeMask;
+            a.computeTypeMask();
+            GrAssert(mask == a.fTypeMask);
+
+            a.set(j, 0);
+            mask = a.fTypeMask;
+            a.computeTypeMask();
+            GrAssert(mask == a.fTypeMask);
+
+            a.set(j, 10 * GR_Scalar1);
+            mask = a.fTypeMask;
+            a.computeTypeMask();
+            GrAssert(mask == a.fTypeMask);
+
+            a.set(j, old);
+            GrAssert(a.fTypeMask == origMask);
+        }
+
+        for (int j = 0; j < 100; ++j) {
+            GrPoint pt;
+            pt.fX = GrFloatToScalar(rand.nextF(-10, 10));
+            pt.fY = GrFloatToScalar(rand.nextF(-10, 10));
+
+            GrPoint t0, t1, t2;
+            t0 = a.mapPoint(pt);             // map to a new point
+            t1 = pt;
+            a.mapPoints(&t1, &t1, 1);        // in place
+            a.mapPerspective(&t2, &pt, 1);   // full mult
+            GrAssert(t0 == t1 && t1 == t2);
+            if (maxStretch >= 0.f) {
+                GrVec vec;
+                vec.setBetween(t0, origin);
+                GrScalar stretch = vec.length() / pt.distanceToOrigin();
+                GrAssert(stretch <= maxStretch);
+            }
+        }
+        double det = a.determinant();
+        if (fabs(det) > 1e-3 && a.invert(&b)) {
+            GrMatrix c;
+            c.setConcat(a,b);
+            for (int i = 0; i < 9; ++i) {
+                GrScalar diff = GrScalarAbs(c[i] - I()[i]);
+                GrAssert(diff < (5*GR_Scalar1 / 100));
+            }
+        }
+    }
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int Gr_clz(uint32_t n) {
+    if (0 == n) {
+        return 32;
+    }
+
+    int count = 0;
+    if (0 == (n & 0xFFFF0000)) {
+        count += 16;
+        n <<= 16;
+    }
+    if (0 == (n & 0xFF000000)) {
+        count += 8;
+        n <<= 8;
+    }
+    if (0 == (n & 0xF0000000)) {
+        count += 4;
+        n <<= 4;
+    }
+    if (0 == (n & 0xC0000000)) {
+        count += 2;
+        n <<= 2;
+    }
+    if (0 == (n & 0x80000000)) {
+        count += 1;
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#include "GrRect.h"
+
+void GrRect::setBounds(const GrPoint pts[], int count) {
+    if (count <= 0) {
+        this->setEmpty();
+    } else {
+        GrScalar L, R, T, B;
+        L = R = pts[0].fX;
+        T = B = pts[0].fY;
+        for (int i = 1; i < count; i++) {
+            GrScalar x = pts[i].fX;
+            GrScalar y = pts[i].fY;
+            if (x < L) {
+                L = x;
+            } else if (x > R) {
+                R = x;
+            }
+            if (y < T) {
+                T = y;
+            } else if (y > B) {
+                B = y;
+            }
+        }
+        this->setLTRB(L, T, R, B);
+    }
+}
+
+
+
diff --git a/gpu/src/GrMemory.cpp b/gpu/src/GrMemory.cpp
new file mode 100644
index 0000000..3da924a
--- /dev/null
+++ b/gpu/src/GrMemory.cpp
@@ -0,0 +1,36 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrMemory.h"
+
+#include <stdlib.h>
+
+void* GrMalloc(size_t bytes) {
+    void* ptr = ::malloc(bytes);
+    if (NULL == ptr) {
+        ::exit(-1);
+    }
+    return ptr;
+}
+
+void GrFree(void* ptr) {
+    if (ptr) {
+        ::free(ptr);
+    }
+}
+
+
diff --git a/gpu/src/GrPath.cpp b/gpu/src/GrPath.cpp
new file mode 100644
index 0000000..a740dfc
--- /dev/null
+++ b/gpu/src/GrPath.cpp
@@ -0,0 +1,488 @@
+#include "GrPath.h"
+
+GrPath::GrPath() {
+    fConvexHint = kNone_ConvexHint;
+}
+
+GrPath::GrPath(const GrPath& src) : INHERITED() {
+    GrPath::Iter iter(src);
+    this->resetFromIter(&iter);
+}
+
+GrPath::GrPath(GrPathIter& iter) {
+    this->resetFromIter(&iter);
+}
+
+GrPath::~GrPath() {
+}
+
+bool GrPath::operator ==(const GrPath& path) const {
+    if (fCmds.count() != path.fCmds.count() ||
+        fPts.count() != path.fPts.count()) {
+        return false;
+    }
+
+    for (int v = 0; v < fCmds.count(); ++v) {
+        if (fCmds[v] != path.fCmds[v]) {
+            return false;
+        }
+    }
+
+    for (int p = 0; p < fPts.count(); ++p) {
+        if (fPts[p] != path.fPts[p]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void GrPath::ensureMoveTo() {
+    if (fCmds.isEmpty() || this->wasLastVerb(kClose_PathCmd)) {
+        *fCmds.append() = kMove_PathCmd;
+        fPts.append()->set(0, 0);
+    }
+}
+
+void GrPath::moveTo(GrScalar x, GrScalar y) {
+    if (this->wasLastVerb(kMove_PathCmd)) {
+        // overwrite prev kMove value
+        fPts[fPts.count() - 1].set(x, y);
+    } else {
+        *fCmds.append() = kMove_PathCmd;
+        fPts.append()->set(x, y);
+    }
+}
+
+void GrPath::lineTo(GrScalar x, GrScalar y) {
+    this->ensureMoveTo();
+    *fCmds.append() = kLine_PathCmd;
+    fPts.append()->set(x, y);
+}
+
+void GrPath::quadTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1) {
+    this->ensureMoveTo();
+    *fCmds.append() = kQuadratic_PathCmd;
+    fPts.append()->set(x0, y0);
+    fPts.append()->set(x1, y1);
+}
+
+void GrPath::cubicTo(GrScalar x0, GrScalar y0, GrScalar x1, GrScalar y1,
+                     GrScalar x2, GrScalar y2) {
+    this->ensureMoveTo();
+    *fCmds.append() = kCubic_PathCmd;
+    fPts.append()->set(x0, y0);
+    fPts.append()->set(x1, y1);
+    fPts.append()->set(x2, y2);
+}
+
+void GrPath::close() {
+    if (!fCmds.isEmpty() && !this->wasLastVerb(kClose_PathCmd)) {
+        // should we allow kMove followed by kClose?
+        *fCmds.append() = kClose_PathCmd;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrPath::offset(GrScalar tx, GrScalar ty) {
+    if (!tx && !ty) {
+        return; // nothing to do
+    }
+
+    GrPoint* iter = fPts.begin();
+    GrPoint* stop = fPts.end();
+    while (iter < stop) {
+        iter->offset(tx, ty);
+        ++iter;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool check_two_vecs(const GrVec& prevVec,
+                           const GrVec& currVec,
+                           GrScalar turnDir,
+                           int* xDir,
+                           int* yDir,
+                           int* flipX,
+                           int* flipY) {
+    if (currVec.fX * *xDir < 0) {
+        ++*flipX;
+        if (*flipX > 2) {
+            return false;
+        }
+        *xDir = -*xDir;
+    }
+    if (currVec.fY * *yDir < 0) {
+        ++*flipY;
+        if (*flipY > 2) {
+            return false;
+        }
+        *yDir = -*yDir;
+    }
+    GrScalar d = prevVec.cross(currVec);
+    return (d * turnDir) >= 0;
+}
+
+static void init_from_two_vecs(const GrVec& firstVec,
+                               const GrVec& secondVec,
+                               GrScalar* turnDir,
+                               int* xDir, int* yDir) {
+    *turnDir = firstVec.cross(secondVec);
+    if (firstVec.fX > 0) {
+        *xDir = 1;
+    } else if (firstVec.fX < 0) {
+        *xDir = -1;
+    } else {
+        *xDir = 0;
+    }
+    if (firstVec.fY > 0) {
+        *yDir = 1;
+    } else if (firstVec.fY < 0) {
+        *yDir = -1;
+    } else {
+        *yDir = 0;
+    }
+}
+
+void GrPath::resetFromIter(GrPathIter* iter) {
+    fPts.reset();
+    fCmds.reset();
+
+    fConvexHint = iter->convexHint();
+
+    // first point of the subpath
+    GrPoint firstPt(0,0);
+    // first edge of the subpath
+    GrVec firstVec(0,0);
+    // vec of most recently processed edge, that wasn't degenerate
+    GrVec previousVec(0,0);
+    // most recently processed point
+    GrPoint previousPt(0,0);
+
+    // sign indicates whether we're bending left or right
+    GrScalar turnDir = 0;
+    // number of times the direction has flipped in x or y
+
+    // we track which direction we are moving in x/y and the
+    // number of times it changes.
+    int xDir = 0;
+    int yDir = 0;
+    int flipX = 0;
+    int flipY = 0;
+
+    // counts number of sub path pts that didn't add a degenerate edge.
+    int subPathPts = 0;
+    bool subPathClosed = false;
+
+    int numSubPaths = 0;
+    iter->rewind();
+    GrPathCmd cmd;
+    GrPoint pts[4];
+    do {
+        cmd = iter->next(pts);
+        // If the convexity test is ever updated to handle multiple subpaths
+        // the loop has to be adjusted to handle moving to a new subpath without
+        // closing the previous one. Currently the implicit closing vectors for a
+        // filled path would never be examined.
+        switch (cmd) {
+            case kMove_PathCmd:
+                this->moveTo(pts[0].fX, pts[0].fY);
+                subPathPts = 0;
+                subPathClosed = false;
+                break;
+            case kLine_PathCmd:
+                this->lineTo(pts[1].fX, pts[1].fY);
+                break;
+            case kQuadratic_PathCmd:
+                this->quadTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
+                break;
+            case kCubic_PathCmd:
+                this->cubicTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY,
+                              pts[3].fX, pts[3].fY);
+                break;
+            case kClose_PathCmd:
+                this->close();
+                subPathClosed = true;
+                break;
+            case kEnd_PathCmd:
+                break;
+        }
+        int n = NumPathCmdPoints(cmd);
+        if (0 == subPathPts && n > 0) {
+            previousPt = pts[0];
+            firstPt = previousPt;
+            flipX = 0;
+            flipY = 0;
+            turnDir = 0;
+            subPathPts = 1;
+            ++numSubPaths;
+        }
+        // either we skip the first pt because it is redundant with
+        // last point of the previous subpath cmd or we just ate it
+        // in the above if.
+        int consumed = 1;
+        if (numSubPaths < 2 && kNone_ConvexHint == fConvexHint) {
+            while (consumed < n) {
+                GrAssert(pts[consumed-1] == previousPt);
+                GrVec vec;
+                vec.setBetween(previousPt, pts[consumed]);
+                if (vec.fX || vec.fY) {
+                    if (subPathPts >= 2) {
+                        if (0 == turnDir) {
+                            firstVec = previousVec;
+                            init_from_two_vecs(firstVec, vec,
+                                               &turnDir, &xDir, &yDir);
+                            // here we aren't checking whether the x/y dirs
+                            // change between the first and second edge. It
+                            // gets covered when the path is closed.
+                        } else {
+                            if (!check_two_vecs(previousVec, vec, turnDir,
+                                                &xDir, &yDir,
+                                                &flipX, &flipY)) {
+                                fConvexHint = kConcave_ConvexHint;
+                                break;
+                            }
+                        }
+                    }
+                    previousVec = vec;
+                    previousPt = pts[consumed];
+                    ++subPathPts;
+                }
+                ++consumed;
+            }
+            if (subPathPts > 2 && (kClose_PathCmd == cmd ||
+                        (!subPathClosed && kEnd_PathCmd == cmd ))) {
+                // if an additional vector is needed to close the loop check
+                // that it validates against the previous vector.
+                GrVec vec;
+                vec.setBetween(previousPt, firstPt);
+                if (vec.fX || vec.fY) {
+                    if (!check_two_vecs(previousVec, vec, turnDir,
+                                        &xDir, &yDir, &flipX, &flipY)) {
+                        fConvexHint = kConcave_ConvexHint;
+                        break;
+                    }
+                    previousVec = vec;
+                }
+                // check that closing vector validates against the first vector.
+                if (!check_two_vecs(previousVec, firstVec, turnDir,
+                                    &xDir, &yDir, &flipX, &flipY)) {
+                    fConvexHint = kConcave_ConvexHint;
+                    break;
+                }
+            }
+        }
+    } while (cmd != kEnd_PathCmd);
+    if (kNone_ConvexHint == fConvexHint && numSubPaths < 2) {
+        fConvexHint = kConvex_ConvexHint;
+    } else {
+        bool recurse = false;
+        if (recurse) {
+            this->resetFromIter(iter);
+        }
+    }
+}
+
+void GrPath::ConvexUnitTest() {
+    GrPath testPath;
+    GrPath::Iter testIter;
+
+    GrPath pt;
+    pt.moveTo(0, 0);
+    pt.close();
+
+    testIter.reset(pt);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath line;
+    line.moveTo(GrIntToScalar(12), GrIntToScalar(20));
+    line.lineTo(GrIntToScalar(-12), GrIntToScalar(-20));
+    line.close();
+
+    testIter.reset(line);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath triLeft;
+    triLeft.moveTo(0, 0);
+    triLeft.lineTo(1, 0);
+    triLeft.lineTo(1, 1);
+    triLeft.close();
+
+    testIter.reset(triLeft);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath triRight;
+    triRight.moveTo(0, 0);
+    triRight.lineTo(-1, 0);
+    triRight.lineTo(1, 1);
+    triRight.close();
+
+    testIter.reset(triRight);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath square;
+    square.moveTo(0, 0);
+    square.lineTo(1, 0);
+    square.lineTo(1, 1);
+    square.lineTo(0, 1);
+    square.close();
+
+    testIter.reset(square);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath redundantSquare;
+    square.moveTo(0, 0);
+    square.lineTo(0, 0);
+    square.lineTo(0, 0);
+    square.lineTo(1, 0);
+    square.lineTo(1, 0);
+    square.lineTo(1, 0);
+    square.lineTo(1, 1);
+    square.lineTo(1, 1);
+    square.lineTo(1, 1);
+    square.lineTo(0, 1);
+    square.lineTo(0, 1);
+    square.lineTo(0, 1);
+    square.close();
+
+    testIter.reset(redundantSquare);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConvex_ConvexHint == testPath.getConvexHint());
+
+    GrPath bowTie;
+    bowTie.moveTo(0, 0);
+    bowTie.lineTo(0, 0);
+    bowTie.lineTo(0, 0);
+    bowTie.lineTo(1, 1);
+    bowTie.lineTo(1, 1);
+    bowTie.lineTo(1, 1);
+    bowTie.lineTo(1, 0);
+    bowTie.lineTo(1, 0);
+    bowTie.lineTo(1, 0);
+    bowTie.lineTo(0, 1);
+    bowTie.lineTo(0, 1);
+    bowTie.lineTo(0, 1);
+    bowTie.close();
+
+    testIter.reset(bowTie);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+
+    GrPath spiral;
+    spiral.moveTo(0, 0);
+    spiral.lineTo(1, 0);
+    spiral.lineTo(1, 1);
+    spiral.lineTo(0, 1);
+    spiral.lineTo(0,.5);
+    spiral.lineTo(.5,.5);
+    spiral.lineTo(.5,.75);
+    spiral.close();
+
+    testIter.reset(spiral);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+
+    GrPath dent;
+    dent.moveTo(0, 0);
+    dent.lineTo(1, 1);
+    dent.lineTo(0, 1);
+    dent.lineTo(-.5,2);
+    dent.lineTo(-2, 1);
+    dent.close();
+
+    testIter.reset(dent);
+    testPath.resetFromIter(&testIter);
+    GrAssert(kConcave_ConvexHint == testPath.getConvexHint());
+}
+///////////////////////////////////////////////////////////////////////////////
+
+GrPath::Iter::Iter() : fPath(NULL) {
+}
+
+GrPath::Iter::Iter(const GrPath& path) : fPath(&path) {
+    this->rewind();
+}
+
+GrPathCmd GrPath::Iter::next(GrPoint points[]) {
+    if (fCmdIndex == fPath->fCmds.count()) {
+        GrAssert(fPtIndex == fPath->fPts.count());
+        return kEnd_PathCmd;
+    } else {
+        GrAssert(fCmdIndex < fPath->fCmds.count());
+    }
+
+    GrPathCmd cmd = fPath->fCmds[fCmdIndex++];
+    const GrPoint* srcPts = fPath->fPts.begin() + fPtIndex;
+
+    switch (cmd) {
+        case kMove_PathCmd:
+            if (points) {
+                points[0] = srcPts[0];
+            }
+            fLastPt = srcPts[0];
+            GrAssert(fPtIndex <= fPath->fPts.count() + 1);
+            fPtIndex += 1;
+            break;
+        case kLine_PathCmd:
+            if (points) {
+                points[0] = fLastPt;
+                points[1] = srcPts[0];
+            }
+            fLastPt = srcPts[0];
+            GrAssert(fPtIndex <= fPath->fPts.count() + 1);
+            fPtIndex += 1;
+            break;
+        case kQuadratic_PathCmd:
+            if (points) {
+                points[0] = fLastPt;
+                points[1] = srcPts[0];
+                points[2] = srcPts[1];
+            }
+            fLastPt = srcPts[1];
+            GrAssert(fPtIndex <= fPath->fPts.count() + 2);
+            fPtIndex += 2;
+            break;
+        case kCubic_PathCmd:
+            if (points) {
+                points[0] = fLastPt;
+                points[1] = srcPts[0];
+                points[2] = srcPts[1];
+                points[3] = srcPts[2];
+            }
+            fLastPt = srcPts[2];
+            GrAssert(fPtIndex <= fPath->fPts.count() + 3);
+            fPtIndex += 3;
+            break;
+        case kClose_PathCmd:
+            break;
+        default:
+            GrAssert(!"unknown grpath cmd");
+            break;
+    }
+    return cmd;
+}
+
+GrConvexHint GrPath::Iter::convexHint() const {
+    return fPath->getConvexHint();
+}
+
+GrPathCmd GrPath::Iter::next() {
+    return this->next(NULL);
+}
+
+void GrPath::Iter::rewind() {
+    this->reset(*fPath);
+}
+
+void GrPath::Iter::reset(const GrPath& path) {
+    fPath = &path;
+    fCmdIndex = fPtIndex = 0;
+}
+
+
diff --git a/gpu/src/GrPathRenderer.cpp b/gpu/src/GrPathRenderer.cpp
new file mode 100644
index 0000000..6d7aabb
--- /dev/null
+++ b/gpu/src/GrPathRenderer.cpp
@@ -0,0 +1,569 @@
+#include "GrPathRenderer.h"
+
+#include "GrPoint.h"
+#include "GrDrawTarget.h"
+#include "GrPathIter.h"
+#include "GrMemory.h"
+#include "GrTexture.h"
+
+GrDefaultPathRenderer::GrDefaultPathRenderer(bool separateStencilSupport,
+                                             bool stencilWrapOpsSupport)
+    : fSeparateStencil(separateStencilSupport),
+      fStencilWrapOps(stencilWrapOpsSupport) {
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Stencil rules for paths
+
+////// Even/Odd
+
+static const GrStencilSettings gEOStencilPass = {
+    kInvert_StencilOp,           kInvert_StencilOp,
+    kKeep_StencilOp,             kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc, kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                  0xffffffff,
+    0xffffffff,                  0xffffffff,
+    0xffffffff,                  0xffffffff
+};
+
+// ok not to check clip b/c stencil pass only wrote inside clip
+static const GrStencilSettings gEOColorPass = {
+    kZero_StencilOp,          kZero_StencilOp,
+    kZero_StencilOp,          kZero_StencilOp,
+    kNotEqual_StencilFunc,    kNotEqual_StencilFunc,
+    0xffffffff,               0xffffffff,
+    0x0,                      0x0,
+    0xffffffff,               0xffffffff
+};
+
+// have to check clip b/c outside clip will always be zero.
+static const GrStencilSettings gInvEOColorPass = {
+    kZero_StencilOp,            kZero_StencilOp,
+    kZero_StencilOp,            kZero_StencilOp,
+    kEqualIfInClip_StencilFunc, kEqualIfInClip_StencilFunc,
+    0xffffffff,                 0xffffffff,
+    0x0,                        0x0,
+    0xffffffff,                 0xffffffff
+};
+
+////// Winding
+
+// when we have separate stencil we increment front faces / decrement back faces
+// when we don't have wrap incr and decr we use the stencil test to simulate
+// them.
+
+static const GrStencilSettings gWindStencilSeparateWithWrap = {
+    kIncWrap_StencilOp,             kDecWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+
+// if inc'ing the max value, invert to make 0
+// if dec'ing zero invert to make all ones.
+// we can't avoid touching the stencil on both passing and
+// failing, so we can't resctrict ourselves to the clip.
+static const GrStencilSettings gWindStencilSeparateNoWrap = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kIncClamp_StencilOp,            kDecClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0x0,
+    0xffffffff,                     0xffffffff
+};
+
+// When there are no separate faces we do two passes to setup the winding rule
+// stencil. First we draw the front faces and inc, then we draw the back faces
+// and dec. These are same as the above two split into the incrementing and
+// decrementing passes.
+static const GrStencilSettings gWindSingleStencilWithWrapInc = {
+    kIncWrap_StencilOp,             kIncWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilWithWrapDec = {
+    kDecWrap_StencilOp,             kDecWrap_StencilOp,
+    kKeep_StencilOp,                kKeep_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilNoWrapInc = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kIncClamp_StencilOp,            kIncClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff,
+    0xffffffff,                     0xffffffff
+};
+static const GrStencilSettings gWindSingleStencilNoWrapDec = {
+    kInvert_StencilOp,              kInvert_StencilOp,
+    kDecClamp_StencilOp,            kDecClamp_StencilOp,
+    kEqual_StencilFunc,             kEqual_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+static const GrStencilSettings gWindColorPass = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kZero_StencilOp,                kZero_StencilOp,
+    kNonZeroIfInClip_StencilFunc,   kNonZeroIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+static const GrStencilSettings gInvWindColorPass = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kZero_StencilOp,                kZero_StencilOp,
+    kEqualIfInClip_StencilFunc,     kEqualIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+////// Normal render to stencil
+
+// Sometimes the default path renderer can draw a path directly to the stencil
+// buffer without having to first resolve the interior / exterior.
+static const GrStencilSettings gDirectToStencil = {
+    kZero_StencilOp,                kZero_StencilOp,
+    kIncClamp_StencilOp,            kIncClamp_StencilOp,
+    kAlwaysIfInClip_StencilFunc,    kAlwaysIfInClip_StencilFunc,
+    0xffffffff,                     0xffffffff,
+    0x0,                            0x0,
+    0xffffffff,                     0xffffffff
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Helpers for drawPath
+
+#define STENCIL_OFF     0   // Always disable stencil (even when needed)
+static const GrScalar gTolerance = GR_Scalar1;
+
+static const uint32_t MAX_POINTS_PER_CURVE = 1 << 10;
+
+static uint32_t quadratic_point_count(const GrPoint points[], GrScalar tol) {
+    GrScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
+    if (d < tol) {
+        return 1;
+    } else {
+        // Each time we subdivide, d should be cut in 4. So we need to
+        // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
+        // points.
+        // 2^(log4(x)) = sqrt(x);
+        d = ceilf(sqrtf(d/tol));
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+    }
+}
+
+static uint32_t generate_quadratic_points(const GrPoint& p0,
+                                          const GrPoint& p1,
+                                          const GrPoint& p2,
+                                          GrScalar tolSqd,
+                                          GrPoint** points,
+                                          uint32_t pointsLeft) {
+    if (pointsLeft < 2 ||
+        (p1.distanceToLineSegmentBetweenSqd(p0, p2)) < tolSqd) {
+        (*points)[0] = p2;
+        *points += 1;
+        return 1;
+    }
+
+    GrPoint q[] = {
+        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
+        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
+    };
+    GrPoint r(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY));
+
+    pointsLeft >>= 1;
+    uint32_t a = generate_quadratic_points(p0, q[0], r, tolSqd, points, pointsLeft);
+    uint32_t b = generate_quadratic_points(r, q[1], p2, tolSqd, points, pointsLeft);
+    return a + b;
+}
+
+static uint32_t cubic_point_count(const GrPoint points[], GrScalar tol) {
+    GrScalar d = GrMax(points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
+                       points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
+    d = sqrtf(d);
+    if (d < tol) {
+        return 1;
+    } else {
+        d = ceilf(sqrtf(d/tol));
+        return GrMin(GrNextPow2((uint32_t)d), MAX_POINTS_PER_CURVE);
+    }
+}
+
+static uint32_t generate_cubic_points(const GrPoint& p0,
+                                      const GrPoint& p1,
+                                      const GrPoint& p2,
+                                      const GrPoint& p3,
+                                      GrScalar tolSqd,
+                                      GrPoint** points,
+                                      uint32_t pointsLeft) {
+    if (pointsLeft < 2 ||
+        (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
+         p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
+            (*points)[0] = p3;
+            *points += 1;
+            return 1;
+        }
+    GrPoint q[] = {
+        GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
+        GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
+        GrPoint(GrScalarAve(p2.fX, p3.fX), GrScalarAve(p2.fY, p3.fY))
+    };
+    GrPoint r[] = {
+        GrPoint(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY)),
+        GrPoint(GrScalarAve(q[1].fX, q[2].fX), GrScalarAve(q[1].fY, q[2].fY))
+    };
+    GrPoint s(GrScalarAve(r[0].fX, r[1].fX), GrScalarAve(r[0].fY, r[1].fY));
+    pointsLeft >>= 1;
+    uint32_t a = generate_cubic_points(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
+    uint32_t b = generate_cubic_points(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
+    return a + b;
+}
+
+static int worst_case_point_count(GrPathIter* path,
+                                  int* subpaths,
+                                  GrScalar tol) {
+    int pointCount = 0;
+    *subpaths = 1;
+
+    bool first = true;
+
+    GrPathCmd cmd;
+
+    GrPoint pts[4];
+    while ((cmd = path->next(pts)) != kEnd_PathCmd) {
+
+        switch (cmd) {
+            case kLine_PathCmd:
+                pointCount += 1;
+                break;
+            case kQuadratic_PathCmd:
+                pointCount += quadratic_point_count(pts, tol);
+                break;
+            case kCubic_PathCmd:
+                pointCount += cubic_point_count(pts, tol);
+                break;
+            case kMove_PathCmd:
+                pointCount += 1;
+                if (!first) {
+                    ++(*subpaths);
+                }
+                break;
+            default:
+                break;
+        }
+        first = false;
+    }
+    return pointCount;
+}
+
+static inline bool single_pass_path(const GrDrawTarget& target,
+                                    const GrPathIter& path,
+                                    GrPathFill fill) {
+#if STENCIL_OFF
+    return true;
+#else
+    if (kEvenOdd_PathFill == fill) {
+        GrConvexHint hint = path.convexHint();
+        return hint == kConvex_ConvexHint ||
+               hint == kNonOverlappingConvexPieces_ConvexHint;
+    } else if (kWinding_PathFill == fill) {
+        GrConvexHint hint = path.convexHint();
+        return hint == kConvex_ConvexHint ||
+               hint == kNonOverlappingConvexPieces_ConvexHint ||
+               (hint == kSameWindingConvexPieces_ConvexHint &&
+                target.canDisableBlend() && !target.isDitherState());
+
+    }
+    return false;
+#endif
+}
+
+bool GrDefaultPathRenderer::requiresStencilPass(const GrDrawTarget* target,
+                                                GrPathIter* path, 
+                                                GrPathFill fill) const {
+    return single_pass_path(*target, *path, fill);
+}
+
+void GrDefaultPathRenderer::drawPathHelper(GrDrawTarget* target,
+                                           GrDrawTarget::StageBitfield stages,
+                                           GrPathIter* path,
+                                           GrPathFill fill,
+                                           const GrPoint* translate,
+                                           bool stencilOnly) {
+
+    GrDrawTarget::AutoStateRestore asr(target);
+    bool colorWritesWereDisabled = target->isColorWriteDisabled();
+    // face culling doesn't make sense here
+    GrAssert(GrDrawTarget::kBoth_DrawFace == target->getDrawFace());
+
+    GrMatrix viewM = target->getViewMatrix();
+    // In order to tesselate the path we get a bound on how much the matrix can
+    // stretch when mapping to screen coordinates.
+    GrScalar stretch = viewM.getMaxStretch();
+    bool useStretch = stretch > 0;
+    GrScalar tol = gTolerance;
+
+    if (!useStretch) {
+        // TODO: deal with perspective in some better way.
+        tol /= 10;
+    } else {
+        GrScalar sinv = GR_Scalar1 / stretch;
+        tol = GrMul(tol, sinv);
+    }
+    GrScalar tolSqd = GrMul(tol, tol);
+
+    path->rewind();
+
+    int subpathCnt;
+    int maxPts = worst_case_point_count(path,
+                                        &subpathCnt,
+                                        tol);
+
+    GrVertexLayout layout = 0;
+    for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
+        if ((1 << s) & stages) {
+            layout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(s);
+        }
+    }
+
+    // add 4 to hold the bounding rect
+    GrDrawTarget::AutoReleaseGeometry arg(target, layout, maxPts + 4, 0);
+
+    GrPoint* base = (GrPoint*) arg.vertices();
+    GrPoint* vert = base;
+    GrPoint* subpathBase = base;
+
+    GrAutoSTMalloc<8, uint16_t> subpathVertCount(subpathCnt);
+
+    path->rewind();
+
+    // TODO: use primitve restart if available rather than multiple draws
+    GrPrimitiveType             type;
+    int                         passCount = 0;
+    const GrStencilSettings*    passes[3];
+    GrDrawTarget::DrawFace      drawFace[3];
+    bool                        reverse = false;
+    bool                        lastPassIsBounds;
+
+    if (kHairLine_PathFill == fill) {
+        type = kLineStrip_PrimitiveType;
+        passCount = 1;
+        if (stencilOnly) {
+            passes[0] = &gDirectToStencil;
+        } else {
+            passes[0] = NULL;
+        }
+        lastPassIsBounds = false;
+        drawFace[0] = GrDrawTarget::kBoth_DrawFace;
+    } else {
+        type = kTriangleFan_PrimitiveType;
+        if (single_pass_path(*target, *path, fill)) {
+            passCount = 1;
+            if (stencilOnly) {
+                passes[0] = &gDirectToStencil;
+            } else {
+                passes[0] = NULL;
+            }
+            drawFace[0] = GrDrawTarget::kBoth_DrawFace;
+            lastPassIsBounds = false;
+        } else {
+            switch (fill) {
+                case kInverseEvenOdd_PathFill:
+                    reverse = true;
+                    // fallthrough
+                case kEvenOdd_PathFill:
+                    passes[0] = &gEOStencilPass;
+                    if (stencilOnly) {
+                        passCount = 1;
+                        lastPassIsBounds = false;
+                    } else {
+                        passCount = 2;
+                        lastPassIsBounds = true;
+                        if (reverse) {
+                            passes[1] = &gInvEOColorPass;
+                        } else {
+                            passes[1] = &gEOColorPass;
+                        }
+                    }
+                    drawFace[0] = drawFace[1] = GrDrawTarget::kBoth_DrawFace;
+                    break;
+
+                case kInverseWinding_PathFill:
+                    reverse = true;
+                    // fallthrough
+                case kWinding_PathFill:
+                    if (fSeparateStencil) {
+                        if (fStencilWrapOps) {
+                            passes[0] = &gWindStencilSeparateWithWrap;
+                        } else {
+                            passes[0] = &gWindStencilSeparateNoWrap;
+                        }
+                        passCount = 2;
+                        drawFace[0] = GrDrawTarget::kBoth_DrawFace;
+                    } else {
+                        if (fStencilWrapOps) {
+                            passes[0] = &gWindSingleStencilWithWrapInc;
+                            passes[1] = &gWindSingleStencilWithWrapDec;
+                        } else {
+                            passes[0] = &gWindSingleStencilNoWrapInc;
+                            passes[1] = &gWindSingleStencilNoWrapDec;
+                        }
+                        // which is cw and which is ccw is arbitrary.
+                        drawFace[0] = GrDrawTarget::kCW_DrawFace;
+                        drawFace[1] = GrDrawTarget::kCCW_DrawFace;
+                        passCount = 3;
+                    }
+                    if (stencilOnly) {
+                        lastPassIsBounds = false;
+                        --passCount;
+                    } else {
+                        lastPassIsBounds = true;
+                        drawFace[passCount-1] = GrDrawTarget::kBoth_DrawFace;
+                        if (reverse) {
+                            passes[passCount-1] = &gInvWindColorPass;
+                        } else {
+                            passes[passCount-1] = &gWindColorPass;
+                        }
+                    }
+                    break;
+                default:
+                    GrAssert(!"Unknown path fill!");
+                    return;
+            }
+        }
+    }
+
+    GrPoint pts[4];
+
+    bool first = true;
+    int subpath = 0;
+
+    for (;;) {
+        GrPathCmd cmd = path->next(pts);
+        switch (cmd) {
+            case kMove_PathCmd:
+                if (!first) {
+                    subpathVertCount[subpath] = vert-subpathBase;
+                    subpathBase = vert;
+                    ++subpath;
+                }
+                *vert = pts[0];
+                vert++;
+                break;
+            case kLine_PathCmd:
+                *vert = pts[1];
+                vert++;
+                break;
+            case kQuadratic_PathCmd: {
+                generate_quadratic_points(pts[0], pts[1], pts[2],
+                                          tolSqd, &vert,
+                                          quadratic_point_count(pts, tol));
+                break;
+            }
+            case kCubic_PathCmd: {
+                generate_cubic_points(pts[0], pts[1], pts[2], pts[3],
+                                      tolSqd, &vert,
+                                      cubic_point_count(pts, tol));
+                break;
+            }
+            case kClose_PathCmd:
+                break;
+            case kEnd_PathCmd:
+                subpathVertCount[subpath] = vert-subpathBase;
+                ++subpath; // this could be only in debug
+                goto FINISHED;
+        }
+        first = false;
+    }
+FINISHED:
+    GrAssert(subpath == subpathCnt);
+    GrAssert((vert - base) <= maxPts);
+
+    if (translate) {
+        int count = vert - base;
+        for (int i = 0; i < count; i++) {
+            base[i].offset(translate->fX, translate->fY);
+        }
+    }
+
+    // if we're stenciling we will follow with a pass that draws
+    // a bounding rect to set the color. We're stenciling when
+    // passCount > 1.
+    const int& boundVertexStart = maxPts;
+    GrPoint* boundsVerts = base + boundVertexStart;
+    if (lastPassIsBounds) {
+        GrRect bounds;
+        if (reverse) {
+            GrAssert(NULL != target->getRenderTarget());
+            // draw over the whole world.
+            bounds.setLTRB(0, 0,
+                           GrIntToScalar(target->getRenderTarget()->width()),
+                           GrIntToScalar(target->getRenderTarget()->height()));
+            GrMatrix vmi;
+            if (target->getViewInverse(&vmi)) {
+                vmi.mapRect(&bounds);
+            }
+        } else {
+            bounds.setBounds((GrPoint*)base, vert - base);
+        }
+        boundsVerts[0].setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight,
+                                  bounds.fBottom);
+    }
+
+    for (int p = 0; p < passCount; ++p) {
+        target->setDrawFace(drawFace[p]);
+        if (NULL != passes[p]) {
+            target->setStencil(*passes[p]);
+        }
+
+        if (lastPassIsBounds && (p == passCount-1)) {
+            if (!colorWritesWereDisabled) {
+                target->disableState(GrDrawTarget::kNoColorWrites_StateBit);
+            }
+            target->drawNonIndexed(kTriangleFan_PrimitiveType,
+                                   boundVertexStart, 4);
+
+        } else {
+            if (passCount > 1) {
+                target->enableState(GrDrawTarget::kNoColorWrites_StateBit);
+            }
+            int baseVertex = 0;
+            for (int sp = 0; sp < subpathCnt; ++sp) {
+                target->drawNonIndexed(type,
+                                      baseVertex,
+                                      subpathVertCount[sp]);
+                baseVertex += subpathVertCount[sp];
+            }
+        }
+    }
+}
+
+void GrDefaultPathRenderer::drawPath(GrDrawTarget* target,
+                                     GrDrawTarget::StageBitfield stages,
+                                     GrPathIter* path,
+                                     GrPathFill fill,
+                                     const GrPoint* translate) {
+    this->drawPathHelper(target, stages, path, fill, translate, false);
+}
+
+void GrDefaultPathRenderer::drawPathToStencil(GrDrawTarget* target,
+                                              GrPathIter* path,
+                                              GrPathFill fill,
+                                              const GrPoint* translate) {
+     GrAssert(kInverseEvenOdd_PathFill != fill);
+     GrAssert(kInverseWinding_PathFill != fill);
+     this->drawPathHelper(target, 0, path, fill, translate, true);
+ }
diff --git a/gpu/src/GrPathRenderer.h b/gpu/src/GrPathRenderer.h
new file mode 100644
index 0000000..19e284f
--- /dev/null
+++ b/gpu/src/GrPathRenderer.h
@@ -0,0 +1,157 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrPathRenderer_DEFINED
+#define GrPathRenderer_DEFINED
+
+#include "GrDrawTarget.h"
+
+class GrPathIter;
+struct GrPoint;
+
+/**
+ *  Base class for drawing paths into a GrDrawTarget.
+ */
+class GrPathRenderer {
+public:
+    virtual ~GrPathRenderer() { };
+
+    /**
+     * Draws a path into the draw target. The target will already have its draw
+     * state configured for the draw.
+     * @param target                the target to draw into.
+     * @param stages                indicates which stages the are already
+     *                              in use. All enabled stages expect positions
+     *                              as texture coordinates. The path renderer
+     *                              use the remaining stages for its path
+     *                              filling algorithm.
+     * @param path                  the path to draw.
+     * @param fill                  the fill rule to apply.
+     * @param translate             optional additional translation to apply to
+     *                              the path. NULL means (0,0).
+     */
+    virtual void drawPath(GrDrawTarget* target,
+                          GrDrawTarget::StageBitfield stages,
+                          GrPathIter* path,
+                          GrPathFill fill,
+                          const GrPoint* translate) = 0;
+
+    void drawPath(GrDrawTarget* target,
+                  GrDrawTarget::StageBitfield stages,
+                  const GrPath& path,
+                  GrPathFill fill,
+                  const GrPoint* translate) {
+            GrPath::Iter iter(path);
+            this->drawPath(target, stages, &iter, fill, translate);
+    }
+
+    /**
+     * For complex clips Gr uses the stencil buffer. The path renderer must be
+     * able to render paths into the stencil buffer. However, the path renderer
+     * itself may require the stencil buffer to resolve the path fill rule. This
+     * function queries whether the path render needs its own stencil
+     * pass. If this returns false then drawPath() should not modify the
+     * the target's stencil settings but use those already set on target.
+     *
+     * @param target target that the path will be rendered to
+     * @param path   the path that will be drawn
+     * @param fill   the fill rule that will be used
+     *
+     * @return false if this path renderer can generate interior-only fragments
+     *         without changing the stencil settings on the target. If it
+     *         returns true the drawPathToStencil will be used when rendering
+     *         clips.
+     */
+    virtual bool requiresStencilPass(const GrDrawTarget* target,
+                                     GrPathIter* path,
+                                     GrPathFill fill) const { return false; }
+
+    bool requiresStencilPass(const GrDrawTarget* target,
+                             const GrPath& path,
+                             GrPathFill fill) const {
+        GrPath::Iter iter(path);
+        return requiresStencilPass(target, &iter, fill);
+    }
+
+    /**
+     * Draws a path to the stencil buffer. Assume the writable stencil bits
+     * are already initialized to zero. Fill will always be either
+     * kWinding_PathFill or kEvenOdd_PathFill.
+     *
+     * Only called if requiresStencilPass returns true for the same combo of
+     * target, path, and fill (or inverse of the fill).
+     *
+     * The default implementation assumes the path filling algorithm doesn't
+     * require a separate stencil pass and so crashes.
+     *
+     *
+     * @param target                the target to draw into.
+     * @param path                  the path to draw.
+     * @param fill                  the fill rule to apply.
+     * @param translate             optional additional translation to apply to
+     *                              the path. NULL means (0,0).
+     */
+    virtual void drawPathToStencil(GrDrawTarget* target,
+                                   GrPathIter* path,
+                                   GrPathFill fill,
+                                   const GrPoint* translate) {
+        GrCrash("Unexpected call to drawPathToStencil.");
+    }
+
+    void drawPathToStencil(GrDrawTarget* target,
+                           const GrPath& path,
+                           GrPathFill fill,
+                           const GrPoint* translate) {
+        GrPath::Iter iter(path);
+        this->drawPathToStencil(target, &iter, fill, translate);
+    }
+};
+
+/**
+ *  Subclass that renders the path using the stencil buffer to resolve fill
+ *  rules (e.g. winding, even-odd)
+ */
+class GrDefaultPathRenderer : public GrPathRenderer {
+public:
+    GrDefaultPathRenderer(bool separateStencilSupport,
+                          bool stencilWrapOpsSupport);
+
+    virtual void drawPath(GrDrawTarget* target,
+                          GrDrawTarget::StageBitfield stages,
+                          GrPathIter* path,
+                          GrPathFill fill,
+                          const GrPoint* translate);
+    virtual bool requiresStencilPass(const GrDrawTarget* target,
+                                     GrPathIter* path,
+                                     GrPathFill fill) const;
+    virtual void drawPathToStencil(GrDrawTarget* target,
+                                   GrPathIter* path,
+                                   GrPathFill fill,
+                                   const GrPoint* translate);
+private:
+
+    void drawPathHelper(GrDrawTarget* target,
+                        GrDrawTarget::StageBitfield stages,
+                        GrPathIter* path,
+                        GrPathFill fill,
+                        const GrPoint* translate,
+                        bool stencilOnly);
+
+    bool    fSeparateStencil;
+    bool    fStencilWrapOps;
+};
+
+#endif
diff --git a/gpu/src/GrPrintf_printf.cpp b/gpu/src/GrPrintf_printf.cpp
new file mode 100644
index 0000000..ad239ec
--- /dev/null
+++ b/gpu/src/GrPrintf_printf.cpp
@@ -0,0 +1,36 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrTypes.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+void GrPrintf(const char format[], ...) {
+    const size_t MAX_BUFFER_SIZE = 2048;
+
+    char buffer[MAX_BUFFER_SIZE + 1];
+    va_list args;
+
+    va_start(args, format);
+    vsnprintf(buffer, MAX_BUFFER_SIZE, format, args);
+    va_end(args);
+
+    printf("%s", buffer);
+}
+
+
diff --git a/gpu/src/GrRectanizer.cpp b/gpu/src/GrRectanizer.cpp
new file mode 100644
index 0000000..cb6576a
--- /dev/null
+++ b/gpu/src/GrRectanizer.cpp
@@ -0,0 +1,130 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrRectanizer.h"
+#include "GrTBSearch.h"
+
+#define MIN_HEIGHT_POW2     2
+
+class GrRectanizerPow2 : public GrRectanizer {
+public:
+    GrRectanizerPow2(int w, int h) : GrRectanizer(w, h) {
+        fNextStripY = 0;
+        fAreaSoFar = 0;
+        Gr_bzero(fRows, sizeof(fRows));
+    }
+
+    virtual ~GrRectanizerPow2() {
+    }
+
+    virtual bool addRect(int w, int h, GrIPoint16* loc);
+
+    virtual float percentFull() const {
+        return fAreaSoFar / ((float)this->width() * this->height());
+    }
+
+    virtual int stripToPurge(int height) const { return -1; }
+    virtual void purgeStripAtY(int yCoord) { }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct Row {
+        GrIPoint16  fLoc;
+        int         fRowHeight;
+        
+        bool canAddWidth(int width, int containerWidth) const {
+            return fLoc.fX + width <= containerWidth;
+        }
+    };
+
+    Row fRows[16];
+
+    static int HeightToRowIndex(int height) {
+        GrAssert(height >= MIN_HEIGHT_POW2);
+        return 32 - Gr_clz(height - 1);
+    }
+
+    int fNextStripY;
+    int32_t fAreaSoFar;
+
+    bool canAddStrip(int height) const {
+        return fNextStripY + height <= this->height();
+    }
+
+    void initRow(Row* row, int rowHeight) {
+        row->fLoc.set(0, fNextStripY);
+        row->fRowHeight = rowHeight;
+        fNextStripY += rowHeight;
+    }
+};
+
+bool GrRectanizerPow2::addRect(int width, int height, GrIPoint16* loc) {
+    if ((unsigned)width > (unsigned)this->width() ||
+        (unsigned)height > (unsigned)this->height()) {
+        return false;
+    }
+
+    int32_t area = width * height;
+
+    /*
+        We use bsearch, but there may be more than one row with the same height,
+        so we actually search for height-1, which can only be a pow2 itself if
+        height == 2. Thus we set a minimum height.
+     */
+    height = GrNextPow2(height);
+    if (height < MIN_HEIGHT_POW2) {
+        height = MIN_HEIGHT_POW2;
+    }
+
+    Row* row = &fRows[HeightToRowIndex(height)];
+    GrAssert(row->fRowHeight == 0 || row->fRowHeight == height);
+
+    if (0 == row->fRowHeight) {
+        if (!this->canAddStrip(height)) {
+            return false;
+        }
+        this->initRow(row, height);
+    } else {
+        if (!row->canAddWidth(width, this->width())) {
+            if (!this->canAddStrip(height)) {
+                return false;
+            }
+            // that row is now "full", so retarget our Row record for
+            // another one
+            this->initRow(row, height);
+        }
+    }
+
+    GrAssert(row->fRowHeight == height);
+    GrAssert(row->canAddWidth(width, this->width()));
+    *loc = row->fLoc;
+    row->fLoc.fX += width;
+
+    GrAssert(row->fLoc.fX <= this->width());
+    GrAssert(row->fLoc.fY <= this->height());
+    GrAssert(fNextStripY <= this->height());
+    fAreaSoFar += area;
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrRectanizer* GrRectanizer::Factory(int width, int height) {
+    return new GrRectanizerPow2(width, height);
+}
+
+
diff --git a/gpu/src/GrRectanizer_fifo.cpp b/gpu/src/GrRectanizer_fifo.cpp
new file mode 100644
index 0000000..6b1cad2
--- /dev/null
+++ b/gpu/src/GrRectanizer_fifo.cpp
@@ -0,0 +1,130 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrRectanizer.h"
+#include "GrTBSearch.h"
+
+#define MIN_HEIGHT_POW2     2
+
+class GrRectanizerFIFO : public GrRectanizer {
+public:
+    GrRectanizerFIFO(int w, int h) : GrRectanizer(w, h) {
+        fNextStripY = 0;
+        fAreaSoFar = 0;
+        Gr_bzero(fRows, sizeof(fRows));
+    }
+    
+    virtual ~GrRectanizerFIFO() {
+    }
+    
+    virtual bool addRect(int w, int h, GrIPoint16* loc);
+    
+    virtual float percentFull() const {
+        return fAreaSoFar / ((float)this->width() * this->height());
+    }
+    
+    virtual int stripToPurge(int height) const { return -1; }
+    virtual void purgeStripAtY(int yCoord) { }
+    
+    ///////////////////////////////////////////////////////////////////////////
+    
+    struct Row {
+        GrIPoint16  fLoc;
+        int         fRowHeight;
+        
+        bool canAddWidth(int width, int containerWidth) const {
+            return fLoc.fX + width <= containerWidth;
+        }
+    };
+    
+    Row fRows[16];
+    
+    static int HeightToRowIndex(int height) {
+        GrAssert(height >= MIN_HEIGHT_POW2);
+        return 32 - Gr_clz(height - 1);
+    }
+    
+    int fNextStripY;
+    int32_t fAreaSoFar;
+    
+    bool canAddStrip(int height) const {
+        return fNextStripY + height <= this->height();
+    }
+    
+    void initRow(Row* row, int rowHeight) {
+        row->fLoc.set(0, fNextStripY);
+        row->fRowHeight = rowHeight;
+        fNextStripY += rowHeight;
+    }
+};
+
+bool GrRectanizerFIFO::addRect(int width, int height, GrIPoint16* loc) {
+    if ((unsigned)width > (unsigned)this->width() ||
+        (unsigned)height > (unsigned)this->height()) {
+        return false;
+    }
+    
+    int32_t area = width * height;
+    
+    /*
+     We use bsearch, but there may be more than one row with the same height,
+     so we actually search for height-1, which can only be a pow2 itself if
+     height == 2. Thus we set a minimum height.
+     */
+    height = GrNextPow2(height);
+    if (height < MIN_HEIGHT_POW2) {
+        height = MIN_HEIGHT_POW2;
+    }
+    
+    Row* row = &fRows[HeightToRowIndex(height)];
+    GrAssert(row->fRowHeight == 0 || row->fRowHeight == height);
+    
+    if (0 == row->fRowHeight) {
+        if (!this->canAddStrip(height)) {
+            return false;
+        }
+        this->initRow(row, height);
+    } else {
+        if (!row->canAddWidth(width, this->width())) {
+            if (!this->canAddStrip(height)) {
+                return false;
+            }
+            // that row is now "full", so retarget our Row record for
+            // another one
+            this->initRow(row, height);
+        }
+    }
+    
+    GrAssert(row->fRowHeight == height);
+    GrAssert(row->canAddWidth(width, this->width()));
+    *loc = row->fLoc;
+    row->fLoc.fX += width;
+    
+    GrAssert(row->fLoc.fX <= this->width());
+    GrAssert(row->fLoc.fY <= this->height());
+    GrAssert(fNextStripY <= this->height());
+    fAreaSoFar += area;
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrRectanizer* GrRectanizer::Factory(int width, int height) {
+    return new GrRectanizerFIFO(width, height);
+}
+
+
diff --git a/gpu/src/GrRedBlackTree.h b/gpu/src/GrRedBlackTree.h
new file mode 100644
index 0000000..7ba326f
--- /dev/null
+++ b/gpu/src/GrRedBlackTree.h
@@ -0,0 +1,1125 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef GrRedBlackTree_DEFINED
+#define GrRedBlackTree_DEFINED
+
+#include "GrNoncopyable.h"
+
+template <typename T>
+class GrLess {
+public:
+    bool operator()(const T& a, const T& b) const { return a < b; }
+};
+
+template <typename T>
+class GrLess<T*> {
+public:
+    bool operator()(const T* a, const T* b) const { return *a < *b; }
+};
+
+/**
+ * In debug build this will cause full traversals of the tree when the validate
+ * is called on insert and remove. Useful for debugging but very slow.
+ */
+#define DEEP_VALIDATE 0
+
+/**
+ * A sorted tree that uses the red-black tree algorithm. Allows duplicate
+ * entries. Data is of type T and is compared using functor C. A single C object
+ * will be created and used for all comparisons.
+ */
+template <typename T, typename C = GrLess<T> >
+class GrRedBlackTree : public GrNoncopyable {
+public:
+    /**
+     * Creates an empty tree.
+     */
+    GrRedBlackTree();
+    virtual ~GrRedBlackTree();
+
+    /**
+     * Class used to iterater through the tree. The valid range of the tree
+     * is given by [begin(), end()). It is legal to dereference begin() but not
+     * end(). The iterator has preincrement and predecrement operators, it is
+     * legal to decerement end() if the tree is not empty to get the last
+     * element. However, a last() helper is provided.
+     */
+    class Iter;
+
+    /**
+     * Add an element to the tree. Duplicates are allowed.
+     * @param t     the item to add.
+     * @return  an iterator to the item.
+     */
+    Iter insert(const T& t);
+
+    /**
+     * Removes all items in the tree.
+     */
+    void reset();
+
+    /**
+     * @return true if there are no items in the tree, false otherwise.
+     */
+    bool empty() const {return 0 == fCount;}
+
+    /**
+     * @return the number of items in the tree.
+     */
+    int  count() const {return fCount;}
+
+    /**
+     * @return  an iterator to the first item in sorted order, or end() if empty
+     */
+    Iter begin();
+    /**
+     * Gets the last valid iterator. This is always valid, even on an empty.
+     * However, it can never be dereferenced. Useful as a loop terminator.
+     * @return  an iterator that is just beyond the last item in sorted order.
+     */
+    Iter end();
+    /**
+     * @return  an iterator that to the last item in sorted order, or end() if
+     * empty.
+     */
+    Iter last();
+
+    /**
+     * Finds an occurrence of an item.
+     * @param t     the item to find.
+     * @return an iterator to a tree element equal to t or end() if none exists.
+     */
+    Iter find(const T& t);
+    /**
+     * Finds the first of an item in iterator order.
+     * @param t     the item to find.
+     * @return  an iterator to the first element equal to t or end() if
+     *          none exists.
+     */
+    Iter findFirst(const T& t);
+    /**
+     * Finds the last of an item in iterator order.
+     * @param t     the item to find.
+     * @return  an iterator to the last element equal to t or end() if
+     *          none exists.
+     */
+    Iter findLast(const T& t);
+    /**
+     * Gets the number of items in the tree equal to t.
+     * @param t     the item to count.
+     * @return  number of items equal to t in the tree
+     */
+    int countOf(const T& t) const;
+
+    /**
+     * Removes the item indicated by an iterator. The iterator will not be valid
+     * afterwards.
+     *
+     * @param iter      iterator of item to remove. Must be valid (not end()).
+     */
+    void remove(const Iter& iter) { deleteAtNode(iter.fN); }
+
+    static void UnitTest();
+
+private:
+    enum Color {
+        kRed_Color,
+        kBlack_Color
+    };
+
+    enum Child {
+        kLeft_Child  = 0,
+        kRight_Child = 1
+    };
+
+    struct Node {
+        T       fItem;
+        Color   fColor;
+
+        Node*   fParent;
+        Node*   fChildren[2];
+    };
+
+    void rotateRight(Node* n);
+    void rotateLeft(Node* n);
+
+    static Node* SuccessorNode(Node* x);
+    static Node* PredecessorNode(Node* x);
+
+    void deleteAtNode(Node* x);
+    static void RecursiveDelete(Node* x);
+
+    int countOfHelper(const Node* n, const T& t) const;
+
+#if GR_DEBUG
+    void validate() const;
+    int checkNode(Node* n, int* blackHeight) const;
+    // checks relationship between a node and its children. allowRedRed means
+    // node may be in an intermediate state where a red parent has a red child.
+    bool validateChildRelations(const Node* n, bool allowRedRed) const;
+    // place to stick break point if validateChildRelations is failing.
+    bool validateChildRelationsFailed() const { return false; }
+#else
+    void validate() const {}
+#endif
+
+    int     fCount;
+    Node*   fRoot;
+    Node*   fFirst;
+    Node*   fLast;
+
+    const C fComp;
+};
+
+template <typename T, typename C>
+class GrRedBlackTree<T,C>::Iter {
+public:
+    Iter() {};
+    Iter(const Iter& i) {fN = i.fN; fTree = i.fTree;}
+    Iter& operator =(const Iter& i) {
+        fN = i.fN;
+        fTree = i.fTree;
+        return *this;
+    }
+    // altering the sort value of the item using this method will cause
+    // errors.
+    T& operator *() const { return fN->fItem; }
+    bool operator ==(const Iter& i) const {
+        return fN == i.fN && fTree == i.fTree;
+    }
+    bool operator !=(const Iter& i) const { return !(*this == i); }
+    Iter& operator ++() {
+        GrAssert(*this != fTree->end());
+        fN = SuccessorNode(fN);
+        return *this;
+    }
+    Iter& operator --() {
+        GrAssert(*this != fTree->begin());
+        if (NULL != fN) {
+            fN = PredecessorNode(fN);
+        } else {
+            *this = fTree->last();
+        }
+        return *this;
+    }
+
+private:
+    friend class GrRedBlackTree;
+    explicit Iter(Node* n, GrRedBlackTree* tree) {
+        fN = n;
+        fTree = tree;
+    }
+    Node* fN;
+    GrRedBlackTree* fTree;
+};
+
+template <typename T, typename C>
+GrRedBlackTree<T,C>::GrRedBlackTree() : fComp() {
+    fRoot = NULL;
+    fFirst = NULL;
+    fLast = NULL;
+    fCount = 0;
+    validate();
+}
+
+template <typename T, typename C>
+GrRedBlackTree<T,C>::~GrRedBlackTree() {
+    RecursiveDelete(fRoot);
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::begin() {
+    return Iter(fFirst, this);
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::end() {
+    return Iter(NULL, this);
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::last() {
+    return Iter(fLast, this);
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::find(const T& t) {
+    Node* n = fRoot;
+    while (NULL != n) {
+        if (fComp(t, n->fItem)) {
+            n = n->fChildren[kLeft_Child];
+        } else {
+            if (!fComp(n->fItem, t)) {
+                return Iter(n, this);
+            }
+            n = n->fChildren[kRight_Child];
+        }
+    }
+    return end();
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::findFirst(const T& t) {
+    Node* n = fRoot;
+    Node* leftMost = NULL;
+    while (NULL != n) {
+        if (fComp(t, n->fItem)) {
+            n = n->fChildren[kLeft_Child];
+        } else {
+            if (!fComp(n->fItem, t)) {
+                // found one. check if another in left subtree.
+                leftMost = n;
+                n = n->fChildren[kLeft_Child];
+            } else {
+                n = n->fChildren[kRight_Child];
+            }
+        }
+    }
+    return Iter(leftMost, this);
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::findLast(const T& t) {
+    Node* n = fRoot;
+    Node* rightMost = NULL;
+    while (NULL != n) {
+        if (fComp(t, n->fItem)) {
+            n = n->fChildren[kLeft_Child];
+        } else {
+            if (!fComp(n->fItem, t)) {
+                // found one. check if another in right subtree.
+                rightMost = n;
+            }
+            n = n->fChildren[kRight_Child];
+        }
+    }
+    return Iter(rightMost, this);
+}
+
+template <typename T, typename C>
+int GrRedBlackTree<T,C>::countOf(const T& t) const {
+    return countOfHelper(fRoot, t);
+}
+
+template <typename T, typename C>
+int GrRedBlackTree<T,C>::countOfHelper(const Node* n, const T& t) const {
+    // this is count*log(n) :(
+    while (NULL != n) {
+        if (fComp(t, n->fItem)) {
+            n = n->fChildren[kLeft_Child];
+        } else {
+            if (!fComp(n->fItem, t)) {
+                int count = 1;
+                count += countOfHelper(n->fChildren[kLeft_Child], t);
+                count += countOfHelper(n->fChildren[kRight_Child], t);
+                return count;
+            }
+            n = n->fChildren[kRight_Child];
+        }
+    }
+    return 0;
+
+}
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::reset() {
+    RecursiveDelete(fRoot);
+    fRoot = NULL;
+    fFirst = NULL;
+    fLast = NULL;
+    fCount = 0;
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Iter GrRedBlackTree<T,C>::insert(const T& t) {
+    validate();
+
+    ++fCount;
+
+    Node* x = new Node;
+    x->fChildren[kLeft_Child] = NULL;
+    x->fChildren[kRight_Child] = NULL;
+    x->fItem = t;
+
+    Node* returnNode = x;
+
+    Node* gp = NULL;
+    Node* p = NULL;
+    Node* n = fRoot;
+    Child pc = kLeft_Child; // suppress uninit warning
+    Child gpc;
+
+    bool first = true;
+    bool last = true;
+    while (NULL != n) {
+        gpc = pc;
+        pc = fComp(x->fItem, n->fItem) ? kLeft_Child : kRight_Child;
+        first = first && kLeft_Child == pc;
+        last = last && kRight_Child == pc;
+        gp = p;
+        p = n;
+        n = p->fChildren[pc];
+    }
+    if (last) {
+        fLast = x;
+    }
+    if (first) {
+        fFirst = x;
+    }
+
+    if (NULL == p) {
+        fRoot = x;
+        x->fColor = kBlack_Color;
+        x->fParent = NULL;
+        GrAssert(1 == fCount);
+        return Iter(returnNode, this);
+    }
+    p->fChildren[pc] = x;
+    x->fColor = kRed_Color;
+    x->fParent = p;
+
+    do {
+        // assumptions at loop start.
+        GrAssert(NULL != x);
+        GrAssert(kRed_Color == x->fColor);
+        // can't have a grandparent but no parent.
+        GrAssert(!(NULL != gp && NULL == p));
+        // make sure pc and gpc are correct
+        GrAssert(NULL == p  || p->fChildren[pc] == x);
+        GrAssert(NULL == gp || gp->fChildren[gpc] == p);
+
+        // if x's parent is black then we didn't violate any of the
+        // red/black properties when we added x as red.
+        if (kBlack_Color == p->fColor) {
+            return Iter(returnNode, this);
+        }
+        // gp must be valid because if p was the root then it is black
+        GrAssert(NULL != gp);
+        // gp must be black since it's child, p, is red.
+        GrAssert(kBlack_Color == gp->fColor);
+
+
+        // x and its parent are red, violating red-black property.
+        Node* u = gp->fChildren[1-gpc];
+        // if x's uncle (p's sibling) is also red then we can flip
+        // p and u to black and make gp red. But then we have to recurse
+        // up to gp since it's parent may also be red.
+        if (NULL != u && kRed_Color == u->fColor) {
+            p->fColor = kBlack_Color;
+            u->fColor = kBlack_Color;
+            gp->fColor = kRed_Color;
+            x = gp;
+            p = x->fParent;
+            if (NULL == p) {
+                // x (prev gp) is the root, color it black and be done.
+                GrAssert(fRoot == x);
+                x->fColor = kBlack_Color;
+                validate();
+                return Iter(returnNode, this);
+            }
+            gp = p->fParent;
+            pc = (p->fChildren[kLeft_Child] == x) ? kLeft_Child :
+                                                    kRight_Child;
+            if (NULL != gp) {
+                gpc = (gp->fChildren[kLeft_Child] == p) ? kLeft_Child :
+                                                          kRight_Child;
+            }
+            continue;
+        } break;
+    } while (true);
+    // Here p is red but u is black and we still have to resolve the fact
+    // that x and p are both red.
+    GrAssert(NULL == gp->fChildren[1-gpc] || kBlack_Color == gp->fChildren[1-gpc]->fColor);
+    GrAssert(kRed_Color == x->fColor);
+    GrAssert(kRed_Color == p->fColor);
+    GrAssert(kBlack_Color == gp->fColor);
+
+    // make x be on the same side of p as p is of gp. If it isn't already
+    // the case then rotate x up to p and swap their labels.
+    if (pc != gpc) {
+        if (kRight_Child == pc) {
+            rotateLeft(p);
+            Node* temp = p;
+            p = x;
+            x = temp;
+            pc = kLeft_Child;
+        } else {
+            rotateRight(p);
+            Node* temp = p;
+            p = x;
+            x = temp;
+            pc = kRight_Child;
+        }
+    }
+    // we now rotate gp down, pulling up p to be it's new parent.
+    // gp's child, u, that is not affected we know to be black. gp's new
+    // child is p's previous child (x's pre-rotation sibling) which must be
+    // black since p is red.
+    GrAssert(NULL == p->fChildren[1-pc] ||
+             kBlack_Color == p->fChildren[1-pc]->fColor);
+    // Since gp's two children are black it can become red if p is made
+    // black. This leaves the black-height of both of p's new subtrees
+    // preserved and removes the red/red parent child relationship.
+    p->fColor = kBlack_Color;
+    gp->fColor = kRed_Color;
+    if (kLeft_Child == pc) {
+        rotateRight(gp);
+    } else {
+        rotateLeft(gp);
+    }
+    validate();
+    return Iter(returnNode, this);
+}
+
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::rotateRight(Node* n) {
+    /*            d?              d?
+     *           /               /
+     *          n               s
+     *         / \     --->    / \
+     *        s   a?          c?  n
+     *       / \                 / \
+     *      c?  b?              b?  a?
+     */
+    Node* d = n->fParent;
+    Node* s = n->fChildren[kLeft_Child];
+    GrAssert(NULL != s);
+    Node* b = s->fChildren[kRight_Child];
+
+    if (NULL != d) {
+        Child c = d->fChildren[kLeft_Child] == n ? kLeft_Child :
+                                             kRight_Child;
+        d->fChildren[c] = s;
+    } else {
+        GrAssert(fRoot == n);
+        fRoot = s;
+    }
+    s->fParent = d;
+    s->fChildren[kRight_Child] = n;
+    n->fParent = s;
+    n->fChildren[kLeft_Child] = b;
+    if (NULL != b) {
+        b->fParent = n;
+    }
+
+    GR_DEBUGASSERT(validateChildRelations(d, true));
+    GR_DEBUGASSERT(validateChildRelations(s, true));
+    GR_DEBUGASSERT(validateChildRelations(n, false));
+    GR_DEBUGASSERT(validateChildRelations(n->fChildren[kRight_Child], true));
+    GR_DEBUGASSERT(validateChildRelations(b, true));
+    GR_DEBUGASSERT(validateChildRelations(s->fChildren[kLeft_Child], true));
+}
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::rotateLeft(Node* n) {
+
+    Node* d = n->fParent;
+    Node* s = n->fChildren[kRight_Child];
+    GrAssert(NULL != s);
+    Node* b = s->fChildren[kLeft_Child];
+
+    if (NULL != d) {
+        Child c = d->fChildren[kRight_Child] == n ? kRight_Child :
+                                                   kLeft_Child;
+        d->fChildren[c] = s;
+    } else {
+        GrAssert(fRoot == n);
+        fRoot = s;
+    }
+    s->fParent = d;
+    s->fChildren[kLeft_Child] = n;
+    n->fParent = s;
+    n->fChildren[kRight_Child] = b;
+    if (NULL != b) {
+        b->fParent = n;
+    }
+
+    GR_DEBUGASSERT(validateChildRelations(d, true));
+    GR_DEBUGASSERT(validateChildRelations(s, true));
+    GR_DEBUGASSERT(validateChildRelations(n, true));
+    GR_DEBUGASSERT(validateChildRelations(n->fChildren[kLeft_Child], true));
+    GR_DEBUGASSERT(validateChildRelations(b, true));
+    GR_DEBUGASSERT(validateChildRelations(s->fChildren[kRight_Child], true));
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Node* GrRedBlackTree<T,C>::SuccessorNode(Node* x) {
+    GrAssert(NULL != x);
+    if (NULL != x->fChildren[kRight_Child]) {
+        x = x->fChildren[kRight_Child];
+        while (NULL != x->fChildren[kLeft_Child]) {
+            x = x->fChildren[kLeft_Child];
+        }
+        return x;
+    }
+    while (NULL != x->fParent && x == x->fParent->fChildren[kRight_Child]) {
+        x = x->fParent;
+    }
+    return x->fParent;
+}
+
+template <typename T, typename C>
+typename GrRedBlackTree<T,C>::Node* GrRedBlackTree<T,C>::PredecessorNode(Node* x) {
+    GrAssert(NULL != x);
+    if (NULL != x->fChildren[kLeft_Child]) {
+        x = x->fChildren[kLeft_Child];
+        while (NULL != x->fChildren[kRight_Child]) {
+            x = x->fChildren[kRight_Child];
+        }
+        return x;
+    }
+    while (NULL != x->fParent && x == x->fParent->fChildren[kLeft_Child]) {
+        x = x->fParent;
+    }
+    return x->fParent;
+}
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::deleteAtNode(Node* x) {
+    GrAssert(NULL != x);
+    validate();
+    --fCount;
+
+    bool hasLeft =  NULL != x->fChildren[kLeft_Child];
+    bool hasRight = NULL != x->fChildren[kRight_Child];
+    Child c = hasLeft ? kLeft_Child : kRight_Child;
+
+    if (hasLeft && hasRight) {
+        // first and last can't have two children.
+        GrAssert(fFirst != x);
+        GrAssert(fLast != x);
+        // if x is an interior node then we find it's successor
+        // and swap them.
+        Node* s = x->fChildren[kRight_Child];
+        while (NULL != s->fChildren[kLeft_Child]) {
+            s = s->fChildren[kLeft_Child];
+        }
+        GrAssert(NULL != s);
+        // this might be expensive relative to swapping node ptrs around.
+        // depends on T.
+        x->fItem = s->fItem;
+        x = s;
+        c = kRight_Child;
+    } else if (NULL == x->fParent) {
+        // if x was the root we just replace it with its child and make
+        // the new root (if the tree is not empty) black.
+        GrAssert(fRoot == x);
+        fRoot = x->fChildren[c];
+        if (NULL != fRoot) {
+            fRoot->fParent = NULL;
+            fRoot->fColor = kBlack_Color;
+            if (x == fLast) {
+                GrAssert(c == kLeft_Child);
+                fLast = fRoot;
+            } else if (x == fFirst) {
+                GrAssert(c == kRight_Child);
+                fFirst = fRoot;
+            }
+        } else {
+            GrAssert(fFirst == fLast && x == fFirst);
+            fFirst = NULL;
+            fLast = NULL;
+            GrAssert(0 == fCount);
+        }
+        delete x;
+        validate();
+        return;
+    }
+
+    Child pc;
+    Node* p = x->fParent;
+    pc = p->fChildren[kLeft_Child] == x ? kLeft_Child : kRight_Child;
+
+    if (NULL == x->fChildren[c]) {
+        if (fLast == x) {
+            fLast = p;
+            GrAssert(p == PredecessorNode(x));
+        } else if (fFirst == x) {
+            fFirst = p;
+            GrAssert(p == SuccessorNode(x));
+        }
+        // x has two implicit black children.
+        Color xcolor = x->fColor;
+        p->fChildren[pc] = NULL;
+        delete x;
+        x = NULL;
+        // when x is red it can be with an implicit black leaf without
+        // violating any of the red-black tree properties.
+        if (kRed_Color == xcolor) {
+            validate();
+            return;
+        }
+        // s is p's other child (x's sibling)
+        Node* s = p->fChildren[1-pc];
+
+        //s cannot be an implicit black node because the original
+        // black-height at x was >= 2 and s's black-height must equal the
+        // initial black height of x.
+        GrAssert(NULL != s);
+        GrAssert(p == s->fParent);
+
+        // assigned in loop
+        Node* sl;
+        Node* sr;
+        bool slRed;
+        bool srRed;
+
+        do {
+            // When we start this loop x may already be deleted it is/was
+            // p's child on its pc side. x's children are/were black. The
+            // first time through the loop they are implict children.
+            // On later passes we will be walking up the tree and they will
+            // be real nodes.
+            // The x side of p has a black-height that is one less than the
+            // s side. It must be rebalanced.
+            GrAssert(NULL != s);
+            GrAssert(p == s->fParent);
+            GrAssert(NULL == x || x->fParent == p);
+
+            //sl and sr are s's children, which may be implicit.
+            sl = s->fChildren[kLeft_Child];
+            sr = s->fChildren[kRight_Child];
+
+            // if the s is red we will rotate s and p, swap their colors so
+            // that x's new sibling is black
+            if (kRed_Color == s->fColor) {
+                // if s is red then it's parent must be black.
+                GrAssert(kBlack_Color == p->fColor);
+                // s's children must also be black since s is red. They can't
+                // be implicit since s is red and it's black-height is >= 2.
+                GrAssert(NULL != sl && kBlack_Color == sl->fColor);
+                GrAssert(NULL != sr && kBlack_Color == sr->fColor);
+                p->fColor = kRed_Color;
+                s->fColor = kBlack_Color;
+                if (kLeft_Child == pc) {
+                    rotateLeft(p);
+                    s = sl;
+                } else {
+                    rotateRight(p);
+                    s = sr;
+                }
+                sl = s->fChildren[kLeft_Child];
+                sr = s->fChildren[kRight_Child];
+            }
+            // x and s are now both black.
+            GrAssert(kBlack_Color == s->fColor);
+            GrAssert(NULL == x || kBlack_Color == x->fColor);
+            GrAssert(p == s->fParent);
+            GrAssert(NULL == x || p == x->fParent);
+
+            // when x is deleted its subtree will have reduced black-height.
+            slRed = (NULL != sl && kRed_Color == sl->fColor);
+            srRed = (NULL != sr && kRed_Color == sr->fColor);
+            if (!slRed && !srRed) {
+                // if s can be made red that will balance out x's removal
+                // to make both subtrees of p have the same black-height.
+                if (kBlack_Color == p->fColor) {
+                    s->fColor = kRed_Color;
+                    // now subtree at p has black-height of one less than
+                    // p's parent's other child's subtree. We move x up to
+                    // p and go through the loop again. At the top of loop
+                    // we assumed x and x's children are black, which holds
+                    // by above ifs.
+                    // if p is the root there is no other subtree to balance
+                    // against.
+                    x = p;
+                    p = x->fParent;
+                    if (NULL == p) {
+                        GrAssert(fRoot == x);
+                        validate();
+                        return;
+                    } else {
+                        pc = p->fChildren[kLeft_Child] == x ? kLeft_Child :
+                                                              kRight_Child;
+
+                    }
+                    s = p->fChildren[1-pc];
+                    GrAssert(NULL != s);
+                    GrAssert(p == s->fParent);
+                    continue;
+                } else if (kRed_Color == p->fColor) {
+                    // we can make p black and s red. This balance out p's
+                    // two subtrees and keep the same black-height as it was
+                    // before the delete.
+                    s->fColor = kRed_Color;
+                    p->fColor = kBlack_Color;
+                    validate();
+                    return;
+                }
+            }
+            break;
+        } while (true);
+        // if we made it here one or both of sl and sr is red.
+        // s and x are black. We make sure that a red child is on
+        // the same side of s as s is of p.
+        GrAssert(slRed || srRed);
+        if (kLeft_Child == pc && !srRed) {
+            s->fColor = kRed_Color;
+            sl->fColor = kBlack_Color;
+            rotateRight(s);
+            sr = s;
+            s = sl;
+            //sl = s->fChildren[kLeft_Child]; don't need this
+        } else if (kRight_Child == pc && !slRed) {
+            s->fColor = kRed_Color;
+            sr->fColor = kBlack_Color;
+            rotateLeft(s);
+            sl = s;
+            s = sr;
+            //sr = s->fChildren[kRight_Child]; don't need this
+        }
+        // now p is either red or black, x and s are red and s's 1-pc
+        // child is red.
+        // We rotate p towards x, pulling s up to replace p. We make
+        // p be black and s takes p's old color.
+        // Whether p was red or black, we've increased its pc subtree
+        // rooted at x by 1 (balancing the imbalance at the start) and
+        // we've also its subtree rooted at s's black-height by 1. This
+        // can be balanced by making s's red child be black.
+        s->fColor = p->fColor;
+        p->fColor = kBlack_Color;
+        if (kLeft_Child == pc) {
+            GrAssert(NULL != sr && kRed_Color == sr->fColor);
+            sr->fColor = kBlack_Color;
+            rotateLeft(p);
+        } else {
+            GrAssert(NULL != sl && kRed_Color == sl->fColor);
+            sl->fColor = kBlack_Color;
+            rotateRight(p);
+        }
+    }
+    else {
+        // x has exactly one implicit black child. x cannot be red.
+        // Proof by contradiction: Assume X is red. Let c0 be x's implicit
+        // child and c1 be its non-implicit child. c1 must be black because
+        // red nodes always have two black children. Then the two subtrees
+        // of x rooted at c0 and c1 will have different black-heights.
+        GrAssert(kBlack_Color == x->fColor);
+        // So we know x is black and has one implicit black child, c0. c1
+        // must be red, otherwise the subtree at c1 will have a different
+        // black-height than the subtree rooted at c0.
+        GrAssert(kRed_Color == x->fChildren[c]->fColor);
+        // replace x with c1, making c1 black, preserves all red-black tree
+        // props.
+        Node* c1 = x->fChildren[c];
+        if (x == fFirst) {
+            GrAssert(c == kRight_Child);
+            fFirst = c1;
+            while (NULL != fFirst->fChildren[kLeft_Child]) {
+                fFirst = fFirst->fChildren[kLeft_Child];
+            }
+            GrAssert(fFirst == SuccessorNode(x));
+        } else if (x == fLast) {
+            GrAssert(c == kLeft_Child);
+            fLast = c1;
+            while (NULL != fLast->fChildren[kRight_Child]) {
+                fLast = fLast->fChildren[kRight_Child];
+            }
+            GrAssert(fLast == PredecessorNode(x));
+        }
+        c1->fParent = p;
+        p->fChildren[pc] = c1;
+        c1->fColor = kBlack_Color;
+        delete x;
+        validate();
+    }
+    validate();
+}
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::RecursiveDelete(Node* x) {
+    if (NULL != x) {
+        RecursiveDelete(x->fChildren[kLeft_Child]);
+        RecursiveDelete(x->fChildren[kRight_Child]);
+        delete x;
+    }
+}
+
+#if GR_DEBUG
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::validate() const {
+    if (fCount) {
+        GrAssert(NULL == fRoot->fParent);
+        GrAssert(NULL != fFirst);
+        GrAssert(NULL != fLast);
+
+        GrAssert(kBlack_Color == fRoot->fColor);
+        if (1 == fCount) {
+            GrAssert(fFirst == fRoot);
+            GrAssert(fLast == fRoot);
+            GrAssert(0 == fRoot->fChildren[kLeft_Child]);
+            GrAssert(0 == fRoot->fChildren[kRight_Child]);
+        }
+    } else {
+        GrAssert(NULL == fRoot);
+        GrAssert(NULL == fFirst);
+        GrAssert(NULL == fLast);
+    }
+#if DEEP_VALIDATE
+    int bh;
+    int count = checkNode(fRoot, &bh);
+    GrAssert(count == fCount);
+#endif
+}
+
+template <typename T, typename C>
+int GrRedBlackTree<T,C>::checkNode(Node* n, int* bh) const {
+    if (NULL != n) {
+        GrAssert(validateChildRelations(n, false));
+        if (kBlack_Color == n->fColor) {
+            *bh += 1;
+        }
+        GrAssert(!fComp(n->fItem, fFirst->fItem));
+        GrAssert(!fComp(fLast->fItem, n->fItem));
+        int leftBh = *bh;
+        int rightBh = *bh;
+        int cl = checkNode(n->fChildren[kLeft_Child], &leftBh);
+        int cr = checkNode(n->fChildren[kRight_Child], &rightBh);
+        GrAssert(leftBh == rightBh);
+        *bh = leftBh;
+        return 1 + cl + cr;
+    }
+    return 0;
+}
+
+template <typename T, typename C>
+bool GrRedBlackTree<T,C>::validateChildRelations(const Node* n,
+                                                 bool allowRedRed) const {
+    if (NULL != n) {
+        if (NULL != n->fChildren[kLeft_Child] ||
+            NULL != n->fChildren[kRight_Child]) {
+            if (n->fChildren[kLeft_Child] == n->fChildren[kRight_Child]) {
+                return validateChildRelationsFailed();
+            }
+            if (n->fChildren[kLeft_Child] == n->fParent &&
+                NULL != n->fParent) {
+                return validateChildRelationsFailed();
+            }
+            if (n->fChildren[kRight_Child] == n->fParent &&
+                NULL != n->fParent) {
+                return validateChildRelationsFailed();
+            }
+            if (NULL != n->fChildren[kLeft_Child]) {
+                if (!allowRedRed &&
+                    kRed_Color == n->fChildren[kLeft_Child]->fColor &&
+                    kRed_Color == n->fColor) {
+                    return validateChildRelationsFailed();
+                }
+                if (n->fChildren[kLeft_Child]->fParent != n) {
+                    return validateChildRelationsFailed();
+                }
+                if (!(fComp(n->fChildren[kLeft_Child]->fItem, n->fItem) ||
+                      (!fComp(n->fChildren[kLeft_Child]->fItem, n->fItem) &&
+                       !fComp(n->fItem, n->fChildren[kLeft_Child]->fItem)))) {
+                    return validateChildRelationsFailed();
+                }
+            }
+            if (NULL != n->fChildren[kRight_Child]) {
+                if (!allowRedRed &&
+                    kRed_Color == n->fChildren[kRight_Child]->fColor &&
+                    kRed_Color == n->fColor) {
+                    return validateChildRelationsFailed();
+                }
+                if (n->fChildren[kRight_Child]->fParent != n) {
+                    return validateChildRelationsFailed();
+                }
+                if (!(fComp(n->fItem, n->fChildren[kRight_Child]->fItem) ||
+                      (!fComp(n->fChildren[kRight_Child]->fItem, n->fItem) &&
+                       !fComp(n->fItem, n->fChildren[kRight_Child]->fItem)))) {
+                    return validateChildRelationsFailed();
+                }
+            }
+        }
+    }
+    return true;
+}
+#endif
+
+#include "GrRandom.h"
+
+template <typename T, typename C>
+void GrRedBlackTree<T,C>::UnitTest() {
+    GrRedBlackTree<int> tree;
+    typedef GrRedBlackTree<int>::Iter iter;
+
+    GrRandom r;
+
+    int count[100] = {0};
+    // add 10K ints
+    for (int i = 0; i < 10000; ++i) {
+        int x = r.nextU()%100;
+        Iter xi = tree.insert(x);
+        GrAssert(*xi == x);
+        ++count[x];
+    }
+
+    tree.insert(0);
+    ++count[0];
+    tree.insert(99);
+    ++count[99];
+    GrAssert(*tree.begin() == 0);
+    GrAssert(*tree.last() == 99);
+    GrAssert(--(++tree.begin()) == tree.begin());
+    GrAssert(--tree.end() == tree.last());
+    GrAssert(tree.count() == 10002);
+
+    int c = 0;
+    // check that we iterate through the correct number of
+    // elements and they are properly sorted.
+    for (Iter a = tree.begin(); tree.end() != a; ++a) {
+        Iter b = a;
+        ++b;
+        ++c;
+        GrAssert(b == tree.end() || *a <= *b);
+    }
+    GrAssert(c == tree.count());
+
+    // check that the tree reports the correct number of each int
+    // and that we can iterate through them correctly both forward
+    // and backward.
+    for (int i = 0; i < 100; ++i) {
+        int c;
+        c = tree.countOf(i);
+        GrAssert(c == count[i]);
+        c = 0;
+        Iter iter = tree.findFirst(i);
+        while (iter != tree.end() && *iter == i) {
+            ++c;
+            ++iter;
+        }
+        GrAssert(count[i] == c);
+        c = 0;
+        iter = tree.findLast(i);
+        if (iter != tree.end()) {
+            do {
+                if (*iter == i) {
+                    ++c;
+                } else {
+                    break;
+                }
+                if (iter != tree.begin()) {
+                    --iter;
+                } else {
+                    break;
+                }
+            } while (true);
+        }
+        GrAssert(c == count[i]);
+    }
+    // remove all the ints between 25 and 74. Randomly chose to remove
+    // the first, last, or any entry for each.
+    for (int i = 25; i < 75; ++i) {
+        while (0 != tree.countOf(i)) {
+            --count[i];
+            int x = r.nextU() % 3;
+            Iter iter;
+            switch (x) {
+            case 0:
+                iter = tree.findFirst(i);
+                break;
+            case 1:
+                iter = tree.findLast(i);
+                break;
+            case 2:
+            default:
+                iter = tree.find(i);
+                break;
+            }
+            tree.remove(iter);
+        }
+        GrAssert(0 == count[i]);
+        GrAssert(tree.findFirst(i) == tree.end());
+        GrAssert(tree.findLast(i) == tree.end());
+        GrAssert(tree.find(i) == tree.end());
+    }
+    // remove all of the 0 entries. (tests removing begin())
+    GrAssert(*tree.begin() == 0);
+    GrAssert(*(--tree.end()) == 99);
+    while (0 != tree.countOf(0)) {
+        --count[0];
+        tree.remove(tree.find(0));
+    }
+    GrAssert(0 == count[0]);
+    GrAssert(tree.findFirst(0) == tree.end());
+    GrAssert(tree.findLast(0) == tree.end());
+    GrAssert(tree.find(0) == tree.end());
+    GrAssert(0 < *tree.begin());
+
+    // remove all the 99 entries (tests removing last()).
+    while (0 != tree.countOf(99)) {
+        --count[99];
+        tree.remove(tree.find(99));
+    }
+    GrAssert(0 == count[99]);
+    GrAssert(tree.findFirst(99) == tree.end());
+    GrAssert(tree.findLast(99) == tree.end());
+    GrAssert(tree.find(99) == tree.end());
+    GrAssert(99 > *(--tree.end()));
+    GrAssert(tree.last() == --tree.end());
+
+    // Make sure iteration still goes through correct number of entries
+    // and is still sorted correctly.
+    c = 0;
+    for (Iter a = tree.begin(); tree.end() != a; ++a) {
+        Iter b = a;
+        ++b;
+        ++c;
+        GrAssert(b == tree.end() || *a <= *b);
+    }
+    GrAssert(c == tree.count());
+
+    // repeat check that correct number of each entry is in the tree
+    // and iterates correctly both forward and backward.
+    for (int i = 0; i < 100; ++i) {
+        GrAssert(tree.countOf(i) == count[i]);
+        int c = 0;
+        Iter iter = tree.findFirst(i);
+        while (iter != tree.end() && *iter == i) {
+            ++c;
+            ++iter;
+        }
+        GrAssert(count[i] == c);
+        c = 0;
+        iter = tree.findLast(i);
+        if (iter != tree.end()) {
+            do {
+                if (*iter == i) {
+                    ++c;
+                } else {
+                    break;
+                }
+                if (iter != tree.begin()) {
+                    --iter;
+                } else {
+                    break;
+                }
+            } while (true);
+        }
+        GrAssert(count[i] == c);
+    }
+
+    // remove all entries
+    while (!tree.empty()) {
+        tree.remove(tree.begin());
+    }
+
+    // test reset on empty tree.
+    tree.reset();
+}
+
+#endif
diff --git a/gpu/src/GrStencil.cpp b/gpu/src/GrStencil.cpp
new file mode 100644
index 0000000..a1c8c09
--- /dev/null
+++ b/gpu/src/GrStencil.cpp
@@ -0,0 +1,376 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#include "GrStencil.h"
+
+const GrStencilSettings GrStencilSettings::gDisabled = {};
+GR_STATIC_ASSERT(0 == kKeep_StencilOp);
+GR_STATIC_ASSERT(0 == kAlways_StencilFunc);
+
+////////////////////////////////////////////////////////////////////////////////
+// Stencil Rules for Merging user stencil space into clip
+
+// We can't include the clip bit in the ref or mask values because the division
+// between user and clip bits in the stencil depends on the number of stencil
+// bits in the runtime. Comments below indicate what the code should do to
+// incorporate the clip bit into these settings.
+
+///////
+// Replace
+
+// set the ref to be the clip bit, but mask it out for the test
+static const GrStencilSettings gUserToClipReplace = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipReplace = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Intersect
+static const GrStencilSettings gUserToClipIsect = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipIsect = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Difference
+static const GrStencilSettings gUserToClipDiff = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+static const GrStencilSettings gInvUserToClipDiff = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x0,                 0x0,           // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Union
+
+// first pass makes all the passing cases >= just clip bit set.
+static const GrStencilSettings gUserToClipUnionPass0 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kLEqual_StencilFunc, kLEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000001,          0x00000001,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// second pass allows anything greater than just clip bit set to pass
+static const GrStencilSettings gUserToClipUnionPass1 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLEqual_StencilFunc, kLEqual_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// for inverse first pass finds non-zerp user with clip bit set
+// and converts it to just clip bit set
+static const GrStencilSettings gInvUserToClipUnionPass0 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+// second pass lets anything through with a nonzero user portion
+// and writes a ref value with just the clip bit set to it.
+static const GrStencilSettings gInvUserToClipUnionPass1 = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,    // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+///////
+// Xor
+static const GrStencilSettings gUserToClipXorPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gUserToClipXorPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kGreater_StencilFunc, kGreater_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipXorPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kKeep_StencilOp,     kKeep_StencilOp,
+    kEqual_StencilFunc,  kEqual_StencilFunc,
+    0xffffffff,          0xffffffff,    // unset clip bit
+    0x00000000,          0x00000000,
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipXorPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kLess_StencilFunc,    kLess_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+///////
+// Reverse Diff
+static const GrStencilSettings gUserToClipRDiffPass0 = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kLess_StencilFunc,   kLess_StencilFunc,
+    0xffffffff,          0xffffffff,  // unset clip bit
+    0x00000000,          0x00000000,  // set clip bit
+    0xffffffff,          0xffffffff
+};
+
+static const GrStencilSettings gUserToClipRDiffPass1 = {
+    kReplace_StencilOp,   kReplace_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kEqual_StencilFunc,   kEqual_StencilFunc,
+    0x00000000,           0x00000000,   // set clip bit
+    0x00000000,           0x00000000,   // set clip bit
+    0xffffffff,           0xffffffff
+};
+
+static const GrStencilSettings gInvUserToClipRDiff = {
+    kInvert_StencilOp,    kInvert_StencilOp,
+    kZero_StencilOp,      kZero_StencilOp,
+    kEqual_StencilFunc,   kEqual_StencilFunc,
+    0xffffffff,           0xffffffff,
+    0x00000000,           0x00000000, 
+    0x00000000,           0x00000000    // set clip bit
+};
+///////
+// Direct to Stencil
+
+// We can render a clip element directly without first writing to the client
+// portion of the clip when the fill is not inverse and the set operation will
+// only modify the in/out status of samples covered by the clip element.
+
+// this one only works if used right after stencil clip was cleared.
+// Our GrClip doesn't allow midstream replace ops.
+static const GrStencilSettings gReplaceClip = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0x00000000,          0x00000000     // set clipBit
+};
+
+static const GrStencilSettings gUnionClip = {
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kReplace_StencilOp,  kReplace_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,    // set clip bit
+    0x00000000,          0x00000000     // set clip bit
+};
+
+static const GrStencilSettings gXorClip = {
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kInvert_StencilOp,   kInvert_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,
+    0x00000000,          0x00000000     // set clip bit
+};
+
+static const GrStencilSettings gDiffClip = {
+    kZero_StencilOp,     kZero_StencilOp,
+    kZero_StencilOp,     kZero_StencilOp,
+    kAlways_StencilFunc, kAlways_StencilFunc,
+    0xffffffff,          0xffffffff,
+    0x00000000,          0x00000000,
+    0x00000000,          0x00000000     // set clip bit
+};
+
+bool GrStencilSettings::GetClipPasses(GrSetOp op, 
+                                      bool canBeDirect,
+                                      unsigned int stencilClipMask,
+                                      bool invertedFill,
+                                      int* numPasses,
+                                      GrStencilSettings settings[kMaxStencilClipPasses]) {
+    if (canBeDirect) {
+        *numPasses = 0;
+        switch (op) {
+            case kReplace_SetOp:
+                *numPasses = 1;
+                settings[0] = gReplaceClip;
+                break;
+            case kUnion_SetOp:
+                *numPasses = 1;
+                settings[0] = gUnionClip;
+                break;
+            case kXor_SetOp:
+                *numPasses = 1;
+                settings[0] = gXorClip;
+                break;
+            case kDifference_SetOp:
+                *numPasses = 1;
+                settings[0] = gDiffClip;
+                break;
+            default: // suppress warning
+                break;
+        }
+        if (1 == *numPasses) {
+            settings[0].fFrontFuncRef |= stencilClipMask;
+            settings[0].fFrontWriteMask |= stencilClipMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            settings[0].fBackWriteMask = settings[0].fFrontWriteMask;
+            return true;
+        }
+    }
+    switch (op) {
+        // if we make the path renderer go to stencil we always give it a
+        // non-inverted fill and we use the stencil rules on the client->clipbit
+        // pass to select either the zeros or nonzeros.
+        case kReplace_SetOp:
+            *numPasses= 1;
+            settings[0] = invertedFill ? gInvUserToClipReplace : gUserToClipReplace;
+            settings[0].fFrontFuncMask &= ~stencilClipMask;
+            settings[0].fFrontFuncRef |= stencilClipMask;
+            settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            break;
+        case kIntersect_SetOp:
+            *numPasses = 1;
+            settings[0] = invertedFill ? gInvUserToClipIsect : gUserToClipIsect;
+            settings[0].fFrontFuncRef = stencilClipMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            break;
+        case kUnion_SetOp:
+            *numPasses = 2;
+            if (invertedFill) {
+                settings[0] = gInvUserToClipUnionPass0;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncMask;
+
+                settings[1] = gInvUserToClipUnionPass1;
+                settings[1].fFrontFuncMask &= ~stencilClipMask;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncMask = settings[1].fFrontFuncMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+
+            } else {
+                settings[0] = gUserToClipUnionPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+
+                settings[1] = gUserToClipUnionPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        case kXor_SetOp:
+            *numPasses = 2;
+            if (invertedFill) {
+                settings[0] = gInvUserToClipXorPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+
+                settings[1] = gInvUserToClipXorPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            } else {
+                settings[0] = gUserToClipXorPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+
+                settings[1] = gUserToClipXorPass1;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        case kDifference_SetOp:
+            *numPasses = 1;
+            settings[0] = invertedFill ? gInvUserToClipDiff : gUserToClipDiff;
+            settings[0].fFrontFuncRef |= stencilClipMask;
+            settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+            break;
+        case kReverseDifference_SetOp:
+            if (invertedFill) {
+                *numPasses = 1;
+                settings[0] = gInvUserToClipRDiff;
+                settings[0].fFrontWriteMask |= stencilClipMask;
+                settings[0].fBackWriteMask = settings[0].fFrontWriteMask;
+            } else {
+                *numPasses = 2;
+                settings[0] = gUserToClipRDiffPass0;
+                settings[0].fFrontFuncMask &= ~stencilClipMask;
+                settings[0].fBackFuncMask = settings[0].fFrontFuncMask;
+                settings[0].fFrontFuncRef |= stencilClipMask;
+                settings[0].fBackFuncRef = settings[0].fFrontFuncRef;
+
+                settings[1] = gUserToClipRDiffPass1;
+                settings[1].fFrontFuncMask |= stencilClipMask;
+                settings[1].fFrontFuncRef |= stencilClipMask;
+                settings[1].fBackFuncMask = settings[1].fFrontFuncMask;
+                settings[1].fBackFuncRef = settings[1].fFrontFuncRef;
+            }
+            break;
+        default:
+            GrCrash("Unknown set op");
+    }
+    return false;
+}
\ No newline at end of file
diff --git a/gpu/src/GrTextContext.cpp b/gpu/src/GrTextContext.cpp
new file mode 100644
index 0000000..6819bde
--- /dev/null
+++ b/gpu/src/GrTextContext.cpp
@@ -0,0 +1,267 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrTextContext.h"
+#include "GrAtlas.h"
+#include "GrContext.h"
+#include "GrTextStrike.h"
+#include "GrTextStrike_impl.h"
+#include "GrFontScaler.h"
+#include "GrIndexBuffer.h"
+#include "GrGpuVertex.h"
+#include "GrDrawTarget.h"
+
+static const int TEXT_STAGE = 1;
+
+static const GrVertexLayout BASE_VLAYOUT =
+                    GrDrawTarget::kTextFormat_VertexLayoutBit |
+                    GrDrawTarget::StageTexCoordVertexLayoutBit(TEXT_STAGE,0);
+
+void GrTextContext::flushGlyphs() {
+    if (fCurrVertex > 0) {
+        GrDrawTarget::AutoStateRestore asr(fDrawTarget);
+
+        // setup our sampler state for our text texture/atlas
+
+        GrSamplerState sampler(GrSamplerState::kRepeat_WrapMode,
+                               GrSamplerState::kRepeat_WrapMode,
+                               !fExtMatrix.isIdentity());
+        fDrawTarget->setSamplerState(TEXT_STAGE, sampler);
+
+        GrAssert(GrIsALIGN4(fCurrVertex));
+        int nIndices = fCurrVertex + (fCurrVertex >> 1);
+        GrAssert(fCurrTexture);
+        fDrawTarget->setTexture(TEXT_STAGE, fCurrTexture);
+        fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
+
+        fDrawTarget->drawIndexed(kTriangles_PrimitiveType,
+                                 0, 0, fCurrVertex, nIndices);
+        fDrawTarget->releaseReservedGeometry();
+        fVertices = NULL;
+        fMaxVertices = 0;
+        fCurrVertex = 0;
+        fCurrTexture->unref();
+        fCurrTexture = NULL;
+    }
+}
+
+GrTextContext::GrTextContext(GrContext* context,
+                             const GrPaint& paint,
+                             const GrMatrix* extMatrix) : fPaint(paint) {
+    fContext = context;
+    fStrike = NULL;
+
+    fCurrTexture = NULL;
+    fCurrVertex = 0;
+
+    if (NULL != extMatrix) {
+        fExtMatrix = *extMatrix;
+    } else {
+        fExtMatrix = GrMatrix::I();
+    }
+    if (context->getClip().hasConservativeBounds()) {
+        if (!fExtMatrix.isIdentity()) {
+            GrMatrix inverse;
+            GrRect r = context->getClip().getConservativeBounds();
+            if (fExtMatrix.invert(&inverse)) {
+                inverse.mapRect(&r);
+                r.roundOut(&fClipRect);
+            }
+        } else {
+            context->getClip().getConservativeBounds().roundOut(&fClipRect);
+        }
+    } else {
+        fClipRect.setLargest();
+    }
+
+    // save the context's original matrix off and restore in destructor
+    // this must be done before getTextTarget.
+    fOrigViewMatrix = fContext->getMatrix();
+    fContext->setMatrix(fExtMatrix);
+
+    fVertexLayout = BASE_VLAYOUT;
+    if (NULL != paint.getTexture()) {
+        fVertexLayout |= GrDrawTarget::StagePosAsTexCoordVertexLayoutBit(0);
+        GrMatrix inverseViewMatrix;
+        if (fOrigViewMatrix.invert(&inverseViewMatrix)) {
+            fPaint.fSampler.preConcatMatrix(inverseViewMatrix);
+        }
+    }
+
+    fVertices = NULL;
+    fMaxVertices = 0;
+    fDrawTarget = fContext->getTextTarget(fPaint);
+}
+
+GrTextContext::~GrTextContext() {
+    this->flushGlyphs();
+    fContext->setMatrix(fOrigViewMatrix);
+}
+
+void GrTextContext::flush() {
+    this->flushGlyphs();
+}
+
+static inline void setRectFan(GrGpuTextVertex v[4], int l, int t, int r, int b,
+                              int stride) {
+    v[0 * stride].setI(l, t);
+    v[1 * stride].setI(l, b);
+    v[2 * stride].setI(r, b);
+    v[3 * stride].setI(r, t);
+}
+
+void GrTextContext::drawPackedGlyph(GrGlyph::PackedID packed,
+                                    GrFixed vx, GrFixed vy,
+                                    GrFontScaler* scaler) {
+    if (NULL == fStrike) {
+        fStrike = fContext->getFontCache()->getStrike(scaler);
+    }
+
+    GrGlyph* glyph = fStrike->getGlyph(packed, scaler);
+    if (NULL == glyph || glyph->fBounds.isEmpty()) {
+        return;
+    }
+
+    vx += GrIntToFixed(glyph->fBounds.fLeft);
+    vy += GrIntToFixed(glyph->fBounds.fTop);
+
+    // keep them as ints until we've done the clip-test
+    GrFixed width = glyph->fBounds.width();
+    GrFixed height = glyph->fBounds.height();
+
+    // check if we clipped out
+    if (true || NULL == glyph->fAtlas) {
+        int x = vx >> 16;
+        int y = vy >> 16;
+        if (fClipRect.quickReject(x, y, x + width, y + height)) {
+//            Gr_clz(3);    // so we can set a break-point in the debugger
+            return;
+        }
+    }
+
+    if (NULL == glyph->fAtlas) {
+        if (fStrike->getGlyphAtlas(glyph, scaler)) {
+            goto HAS_ATLAS;
+        }
+        // must do this to flush inorder buffering before we purge
+        fContext->flushText();
+
+        // try to purge
+        fContext->getFontCache()->purgeExceptFor(fStrike);
+        if (fStrike->getGlyphAtlas(glyph, scaler)) {
+            goto HAS_ATLAS;
+        }
+
+        // Draw as a path, so we flush any accumulated glyphs first
+        this->flushGlyphs();
+
+        if (NULL == glyph->fPath) {
+
+            GrPath* path = new GrPath;
+            if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
+                // flag the glyph as being dead?
+                delete path;
+                return;
+            }
+            glyph->fPath = path;
+        }
+        GrPath::Iter iter(*glyph->fPath);
+        GrPoint translate;
+        translate.set(GrFixedToScalar(vx - GrIntToFixed(glyph->fBounds.fLeft)),
+                      GrFixedToScalar(vy - GrIntToFixed(glyph->fBounds.fTop)));
+        fContext->drawPath(fPaint, &iter, kWinding_PathFill,
+                           &translate);
+        return;
+    }
+
+HAS_ATLAS:
+    GrAssert(glyph->fAtlas);
+
+    // now promote them to fixed
+    width = GrIntToFixed(width);
+    height = GrIntToFixed(height);
+
+    GrTexture* texture = glyph->fAtlas->texture();
+    GrAssert(texture);
+
+    if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) {
+        this->flushGlyphs();
+        fCurrTexture = texture;
+        fCurrTexture->ref();
+    }
+
+    if (NULL == fVertices) {
+        // If we need to reserve vertices allow the draw target to suggest
+        // a number of verts to reserve and whether to perform a flush.
+        fMaxVertices = kMinRequestedVerts;
+        bool flush = fDrawTarget->geometryHints(fVertexLayout,
+                                               &fMaxVertices,
+                                               NULL);
+        if (flush) {
+            this->flushGlyphs();
+            fContext->flushText();
+            fDrawTarget = fContext->getTextTarget(fPaint);
+            fMaxVertices = kDefaultRequestedVerts;
+            // ignore return, no point in flushing again.
+            fDrawTarget->geometryHints(fVertexLayout,
+                                       &fMaxVertices,
+                                       NULL);
+        }
+
+        int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->size() / (6 * sizeof(uint16_t));
+        if (fMaxVertices < kMinRequestedVerts) {
+            fMaxVertices = kDefaultRequestedVerts;
+        } else if (fMaxVertices > maxQuadVertices) {
+            // don't exceed the limit of the index buffer
+            fMaxVertices = maxQuadVertices;
+        }
+        bool success = fDrawTarget->reserveAndLockGeometry(fVertexLayout,
+                                                           fMaxVertices, 0,
+                                                   GrTCast<void**>(&fVertices),
+                                                           NULL);
+        GrAlwaysAssert(success);
+    }
+
+    GrFixed tx = GrIntToFixed(glyph->fAtlasLocation.fX);
+    GrFixed ty = GrIntToFixed(glyph->fAtlasLocation.fY);
+
+#if GR_GL_TEXT_TEXTURE_NORMALIZED
+    int x = vx >> 16;
+    int y = vy >> 16;
+    int w = width >> 16;
+    int h = height >> 16;
+
+    setRectFan(&fVertices[2*fCurrVertex], x, y, x + w, y + h, 2);
+    setRectFan(&fVertices[2*fCurrVertex+1],
+               texture->normalizeFixedX(tx),
+               texture->normalizeFixedY(ty),
+               texture->normalizeFixedX(tx + width),
+               texture->normalizeFixedY(ty + height),
+               2);
+#else
+    fVertices[2*fCurrVertex].setXRectFan(vx, vy, vx + width, vy + height,
+                                        2 * sizeof(GrGpuTextVertex));
+    fVertices[2*fCurrVertex+1].setXRectFan(texture->normalizeFixedX(tx),
+                                          texture->normalizeFixedY(ty),
+                                          texture->normalizeFixedX(tx + width),
+                                          texture->normalizeFixedY(ty + height),
+                                          2 * sizeof(GrGpuTextVertex));
+#endif
+    fCurrVertex += 4;
+}
+
+
diff --git a/gpu/src/GrTextStrike.cpp b/gpu/src/GrTextStrike.cpp
new file mode 100644
index 0000000..c2d81d5
--- /dev/null
+++ b/gpu/src/GrTextStrike.cpp
@@ -0,0 +1,204 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrAtlas.h"
+#include "GrGpu.h"
+#include "GrMemory.h"
+#include "GrRectanizer.h"
+#include "GrTextStrike.h"
+#include "GrTextStrike_impl.h"
+#include "GrRect.h"
+
+GrFontCache::GrFontCache(GrGpu* gpu) : fGpu(gpu) {
+    gpu->ref();
+    fAtlasMgr = NULL;
+
+    fHead = fTail = NULL;
+}
+
+GrFontCache::~GrFontCache() {
+    fCache.deleteAll();
+    delete fAtlasMgr;
+    fGpu->unref();
+}
+
+GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler,
+                                          const Key& key) {
+    if (NULL == fAtlasMgr) {
+        fAtlasMgr = new GrAtlasMgr(fGpu);
+    }
+    GrTextStrike* strike = new GrTextStrike(this, scaler->getKey(), fAtlasMgr);
+    fCache.insert(key, strike);
+
+    if (fHead) {
+        fHead->fPrev = strike;
+    } else {
+        GrAssert(NULL == fTail);
+        fTail = strike;
+    }
+    strike->fPrev = NULL;
+    strike->fNext = fHead;
+    fHead = strike;
+
+    return strike;
+}
+
+void GrFontCache::abandonAll() {
+    fCache.deleteAll();
+    if (fAtlasMgr) {
+        fAtlasMgr->abandonAll();
+        delete fAtlasMgr;
+        fAtlasMgr = NULL;
+    }
+}
+
+void GrFontCache::freeAll() {
+    fCache.deleteAll();
+    delete fAtlasMgr;
+    fAtlasMgr = NULL;
+}
+
+void GrFontCache::purgeExceptFor(GrTextStrike* preserveStrike) {
+    GrTextStrike* strike = fTail;
+    if (strike == preserveStrike) {
+        strike = strike->fPrev;
+    }
+    if (strike) {
+        int index = fCache.slowFindIndex(strike);
+        GrAssert(index >= 0);
+        fCache.removeAt(index, strike->fFontScalerKey->getHash());
+        this->detachStrikeFromList(strike);
+        delete strike;
+    }
+}
+
+#if GR_DEBUG
+void GrFontCache::validate() const {
+    int count = fCache.count();
+    if (0 == count) {
+        GrAssert(!fHead);
+        GrAssert(!fTail);
+    } else if (1 == count) {
+        GrAssert(fHead == fTail);
+    } else {
+        GrAssert(fHead != fTail);
+    }
+
+    int count2 = 0;
+    const GrTextStrike* strike = fHead;
+    while (strike) {
+        count2 += 1;
+        strike = strike->fNext;
+    }
+    GrAssert(count == count2);
+
+    count2 = 0;
+    strike = fTail;
+    while (strike) {
+        count2 += 1;
+        strike = strike->fPrev;
+    }
+    GrAssert(count == count2);
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if GR_DEBUG
+    static int gCounter;
+#endif
+
+/*
+    The text strike is specific to a given font/style/matrix setup, which is
+    represented by the GrHostFontScaler object we are given in getGlyph().
+
+    We map a 32bit glyphID to a GrGlyph record, which in turn points to a
+    atlas and a position within that texture.
+ */
+
+GrTextStrike::GrTextStrike(GrFontCache* cache, const GrKey* key,
+                           GrAtlasMgr* atlasMgr) : fPool(64) {
+    fFontScalerKey = key;
+    fFontScalerKey->ref();
+
+    fFontCache = cache;     // no need to ref, it won't go away before we do
+    fAtlasMgr = atlasMgr;   // no need to ref, it won't go away before we do
+    fAtlas = NULL;
+
+#if GR_DEBUG
+    GrPrintf(" GrTextStrike %p %d\n", this, gCounter);
+    gCounter += 1;
+#endif
+}
+
+static void FreeGlyph(GrGlyph*& glyph) { glyph->free(); }
+
+GrTextStrike::~GrTextStrike() {
+    GrAtlas::FreeLList(fAtlas);
+    fFontScalerKey->unref();
+    fCache.getArray().visit(FreeGlyph);
+
+#if GR_DEBUG
+    gCounter -= 1;
+    GrPrintf("~GrTextStrike %p %d\n", this, gCounter);
+#endif
+}
+
+GrGlyph* GrTextStrike::generateGlyph(GrGlyph::PackedID packed,
+                                     GrFontScaler* scaler) {
+    GrIRect bounds;
+    if (!scaler->getPackedGlyphBounds(packed, &bounds)) {
+        return NULL;
+    }
+
+    GrGlyph* glyph = fPool.alloc();
+    glyph->init(packed, bounds);
+    fCache.insert(packed, glyph);
+    return glyph;
+}
+
+bool GrTextStrike::getGlyphAtlas(GrGlyph* glyph, GrFontScaler* scaler) {
+    GrAssert(glyph);
+    GrAssert(scaler);
+    GrAssert(fCache.contains(glyph));
+    if (glyph->fAtlas) {
+        return true;
+    }
+
+    GrAutoRef ar(scaler);
+    
+    size_t size = glyph->fBounds.area();
+    GrAutoSMalloc<1024> storage(size);
+    if (!scaler->getPackedGlyphImage(glyph->fPackedID, glyph->width(),
+                                     glyph->height(), glyph->width(),
+                                     storage.get())) {
+        return false;
+    }
+
+    GrAtlas* atlas = fAtlasMgr->addToAtlas(fAtlas, glyph->width(),
+                                           glyph->height(), storage.get(),
+                                           &glyph->fAtlasLocation);
+    if (NULL == atlas) {
+        return false;
+    }
+
+    // update fAtlas as well, since they may be chained in a linklist
+    glyph->fAtlas = fAtlas = atlas;
+    return true;
+}
+
+
diff --git a/gpu/src/GrTextStrike_impl.h b/gpu/src/GrTextStrike_impl.h
new file mode 100644
index 0000000..7e03e2a
--- /dev/null
+++ b/gpu/src/GrTextStrike_impl.h
@@ -0,0 +1,113 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef GrTextStrike_impl_DEFINED
+#define GrTextStrike_impl_DEFINED
+
+class GrFontCache::Key {
+public:
+    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;
+};
+
+void GrFontCache::detachStrikeFromList(GrTextStrike* strike) {
+    if (strike->fPrev) {
+        GrAssert(fHead != strike);
+        strike->fPrev->fNext = strike->fNext;
+    } else {
+        GrAssert(fHead == strike);
+        fHead = strike->fNext;
+    }
+
+    if (strike->fNext) {
+        GrAssert(fTail != strike);
+        strike->fNext->fPrev = strike->fPrev;
+    } else {
+        GrAssert(fTail == strike);
+        fTail = strike->fPrev;
+    }
+}
+
+GrTextStrike* GrFontCache::getStrike(GrFontScaler* scaler) {
+    this->validate();
+    
+    Key key(scaler);
+    GrTextStrike* strike = fCache.find(key);
+    if (NULL == strike) {
+        strike = this->generateStrike(scaler, key);
+    } else if (strike->fPrev) {
+        // Need to put the strike at the head of its dllist, since that is how
+        // we age the strikes for purging (we purge from the back of the list
+        this->detachStrikeFromList(strike);
+        // attach at the head
+        fHead->fPrev = strike;
+        strike->fNext = fHead;
+        strike->fPrev = NULL;
+        fHead = strike;
+    }
+
+    this->validate();
+    return strike;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  This Key just wraps a glyphID, and matches the protocol need for
+ *  GrTHashTable
+ */
+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;
+};
+
+GrGlyph* GrTextStrike::getGlyph(GrGlyph::PackedID packed,
+                                GrFontScaler* scaler) {
+    GrGlyph* glyph = fCache.find(packed);
+    if (NULL == glyph) {
+        glyph = this->generateGlyph(packed, scaler);
+    }
+    return glyph;
+}
+
+#endif
+
diff --git a/gpu/src/GrTextureCache.cpp b/gpu/src/GrTextureCache.cpp
new file mode 100644
index 0000000..fe3ff68
--- /dev/null
+++ b/gpu/src/GrTextureCache.cpp
@@ -0,0 +1,319 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrTextureCache.h"
+#include "GrTexture.h"
+
+GrTextureEntry::GrTextureEntry(const GrTextureKey& key, GrTexture* texture)
+        : fKey(key), fTexture(texture) {
+    fLockCount = 0;
+    fPrev = fNext = NULL;
+
+    // we assume ownership of the texture, and will unref it when we die
+    GrAssert(texture);
+}
+
+GrTextureEntry::~GrTextureEntry() {
+    fTexture->unref();
+}
+
+#if GR_DEBUG
+void GrTextureEntry::validate() const {
+    GrAssert(fLockCount >= 0);
+    GrAssert(fTexture);
+    fTexture->validate();
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrTextureCache::GrTextureCache(int maxCount, size_t maxBytes) :
+        fMaxCount(maxCount),
+        fMaxBytes(maxBytes) {
+    fEntryCount          = 0;
+    fEntryBytes          = 0;
+    fClientDetachedCount = 0;
+    fClientDetachedBytes = 0;
+
+    fHead = fTail = NULL;
+}
+
+GrTextureCache::~GrTextureCache() {
+    GrAutoTextureCacheValidate atcv(this);
+
+    this->deleteAll(kFreeTexture_DeleteMode);
+}
+
+void GrTextureCache::getLimits(int* maxTextures, size_t* maxTextureBytes) const{
+    if (maxTextures) {
+        *maxTextures = fMaxCount;
+    }
+    if (maxTextureBytes) {
+        *maxTextureBytes = fMaxBytes;
+    }
+}
+
+void GrTextureCache::setLimits(int maxTextures, size_t maxTextureBytes) {
+    bool smaller = (maxTextures < fMaxCount) || (maxTextureBytes < fMaxBytes);
+
+    fMaxCount = maxTextures;
+    fMaxBytes = maxTextureBytes;
+
+    if (smaller) {
+        this->purgeAsNeeded();
+    }
+}
+
+void GrTextureCache::internalDetach(GrTextureEntry* entry,
+                                    bool clientDetach) {
+    GrTextureEntry* prev = entry->fPrev;
+    GrTextureEntry* next = entry->fNext;
+
+    if (prev) {
+        prev->fNext = next;
+    } else {
+        fHead = next;
+    }
+    if (next) {
+        next->fPrev = prev;
+    } else {
+        fTail = prev;
+    }
+
+    // update our stats
+    if (clientDetach) {
+        fClientDetachedCount += 1;
+        fClientDetachedBytes += entry->texture()->sizeInBytes();
+    } else {
+        fEntryCount -= 1;
+        fEntryBytes -= entry->texture()->sizeInBytes();
+    }
+}
+
+void GrTextureCache::attachToHead(GrTextureEntry* entry,
+                                  bool clientReattach) {
+    entry->fPrev = NULL;
+    entry->fNext = fHead;
+    if (fHead) {
+        fHead->fPrev = entry;
+    }
+    fHead = entry;
+    if (NULL == fTail) {
+        fTail = entry;
+    }
+
+    // update our stats
+    if (clientReattach) {
+        fClientDetachedCount -= 1;
+        fClientDetachedBytes -= entry->texture()->sizeInBytes();
+    } else {
+        fEntryCount += 1;
+        fEntryBytes += entry->texture()->sizeInBytes();
+    }
+}
+
+class GrTextureCache::Key {
+    typedef GrTextureEntry T;
+
+    const GrTextureKey& fKey;
+public:
+    Key(const GrTextureKey& key) : fKey(key) {}
+
+    uint32_t getHash() const { return fKey.hashIndex(); }
+
+    static bool LT(const T& entry, const Key& key) {
+        return entry.key() < key.fKey;
+    }
+    static bool EQ(const T& entry, const Key& key) {
+        return entry.key() == key.fKey;
+    }
+#if GR_DEBUG
+    static uint32_t GetHash(const T& entry) {
+        return entry.key().hashIndex();
+    }
+    static bool LT(const T& a, const T& b) {
+        return a.key() < b.key();
+    }
+    static bool EQ(const T& a, const T& b) {
+        return a.key() == b.key();
+    }
+#endif
+};
+
+GrTextureEntry* GrTextureCache::findAndLock(const GrTextureKey& key) {
+    GrAutoTextureCacheValidate atcv(this);
+
+    GrTextureEntry* entry = fCache.find(key);
+    if (entry) {
+        this->internalDetach(entry, false);
+        this->attachToHead(entry, false);
+        // mark the entry as "busy" so it doesn't get purged
+        entry->lock();
+    }
+    return entry;
+}
+
+GrTextureEntry* GrTextureCache::createAndLock(const GrTextureKey& key,
+                                              GrTexture* texture) {
+    GrAutoTextureCacheValidate atcv(this);
+
+    GrTextureEntry* entry = new GrTextureEntry(key, texture);
+
+    this->attachToHead(entry, false);
+    fCache.insert(key, entry);
+
+#if GR_DUMP_TEXTURE_UPLOAD
+    GrPrintf("--- add texture to cache %p, count=%d bytes= %d %d\n",
+             entry, fEntryCount, texture->sizeInBytes(), fEntryBytes);
+#endif
+
+    // mark the entry as "busy" so it doesn't get purged
+    entry->lock();
+    this->purgeAsNeeded();
+    return entry;
+}
+
+void GrTextureCache::detach(GrTextureEntry* entry) {
+    internalDetach(entry, true);
+    fCache.remove(entry->fKey, entry);
+}
+
+void GrTextureCache::reattachAndUnlock(GrTextureEntry* entry) {
+    attachToHead(entry, true);
+    fCache.insert(entry->key(), entry);
+    unlock(entry);
+}
+
+void GrTextureCache::unlock(GrTextureEntry* entry) {
+    GrAutoTextureCacheValidate atcv(this);
+
+    GrAssert(entry);
+    GrAssert(entry->isLocked());
+    GrAssert(fCache.find(entry->key()));
+
+    entry->unlock();
+    this->purgeAsNeeded();
+}
+
+void GrTextureCache::purgeAsNeeded() {
+    GrAutoTextureCacheValidate atcv(this);
+
+    GrTextureEntry* entry = fTail;
+    while (entry) {
+        if (fEntryCount <= fMaxCount && fEntryBytes <= fMaxBytes) {
+            break;
+        }
+
+        GrTextureEntry* prev = entry->fPrev;
+        if (!entry->isLocked()) {
+            // remove from our cache
+            fCache.remove(entry->fKey, entry);
+
+            // remove from our llist
+            this->internalDetach(entry, false);
+
+#if GR_DUMP_TEXTURE_UPLOAD
+            GrPrintf("--- ~texture from cache %p [%d %d]\n", entry->texture(),
+                     entry->texture()->width(),
+                     entry->texture()->height());
+#endif
+            delete entry;
+        }
+        entry = prev;
+    }
+}
+
+void GrTextureCache::deleteAll(DeleteMode mode) {
+    GrAssert(!fClientDetachedCount);
+    GrAssert(!fClientDetachedBytes);
+
+    GrTextureEntry* entry = fHead;
+    while (entry) {
+        GrAssert(!entry->isLocked());
+
+        GrTextureEntry* next = entry->fNext;
+        if (kAbandonTexture_DeleteMode == mode) {
+            entry->texture()->abandon();
+        }
+        delete entry;
+        entry = next;
+    }
+
+    fCache.removeAll();
+    fHead = fTail = NULL;
+    fEntryCount = 0;
+    fEntryBytes = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if GR_DEBUG
+static int countMatches(const GrTextureEntry* head, const GrTextureEntry* target) {
+    const GrTextureEntry* entry = head;
+    int count = 0;
+    while (entry) {
+        if (target == entry) {
+            count += 1;
+        }
+        entry = entry->next();
+    }
+    return count;
+}
+
+#if GR_DEBUG
+static bool both_zero_or_nonzero(int count, size_t bytes) {
+    return (count == 0 && bytes == 0) || (count > 0 && bytes > 0);
+}
+#endif
+
+void GrTextureCache::validate() const {
+    GrAssert(!fHead == !fTail);
+    GrAssert(both_zero_or_nonzero(fEntryCount, fEntryBytes));
+    GrAssert(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
+    GrAssert(fClientDetachedBytes <= fEntryBytes);
+    GrAssert(fClientDetachedCount <= fEntryCount);
+    GrAssert((fEntryCount - fClientDetachedCount) == fCache.count());
+
+    fCache.validate();
+
+    GrTextureEntry* entry = fHead;
+    int count = 0;
+    size_t bytes = 0;
+    while (entry) {
+        entry->validate();
+        GrAssert(fCache.find(entry->key()));
+        count += 1;
+        bytes += entry->texture()->sizeInBytes();
+        entry = entry->fNext;
+    }
+    GrAssert(count == fEntryCount - fClientDetachedCount);
+    GrAssert(bytes == fEntryBytes  - fClientDetachedBytes);
+
+    count = 0;
+    for (entry = fTail; entry; entry = entry->fPrev) {
+        count += 1;
+    }
+    GrAssert(count == fEntryCount - fClientDetachedCount);
+
+    for (int i = 0; i < count; i++) {
+        int matches = countMatches(fHead, fCache.getArray()[i]);
+        GrAssert(1 == matches);
+    }
+}
+#endif
+
+
diff --git a/gpu/src/GrTouchGesture.cpp b/gpu/src/GrTouchGesture.cpp
new file mode 100644
index 0000000..0eaedc7
--- /dev/null
+++ b/gpu/src/GrTouchGesture.cpp
@@ -0,0 +1,243 @@
+#include "GrTouchGesture.h"
+#include "SkMatrix.h"
+#include "SkTime.h"
+
+#include <math.h>
+
+static const SkMSec MAX_DBL_TAP_INTERVAL = 300;
+static const float MAX_DBL_TAP_DISTANCE = 100;
+static const float MAX_JITTER_RADIUS = 2;
+
+// if true, then ignore the touch-move, 'cause its probably just jitter
+static bool close_enough_for_jitter(float x0, float y0, float x1, float y1) {
+    return  sk_float_abs(x0 - x1) <= MAX_JITTER_RADIUS &&
+            sk_float_abs(y0 - y1) <= MAX_JITTER_RADIUS;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrTouchGesture::GrTouchGesture() {
+    this->reset();
+}
+
+GrTouchGesture::~GrTouchGesture() {
+}
+
+void GrTouchGesture::reset() {
+    fTouches.reset();
+    fState = kEmpty_State;
+    fLocalM.reset();
+    fGlobalM.reset();
+
+    fLastUpT = SkTime::GetMSecs() - 2*MAX_DBL_TAP_INTERVAL;
+    fLastUpP.set(0, 0);
+}
+
+void GrTouchGesture::flushLocalM() {
+    fGlobalM.postConcat(fLocalM);
+    fLocalM.reset();
+}
+
+const SkMatrix& GrTouchGesture::localM() {
+    if (fFlinger.isActive()) {
+        if (!fFlinger.evaluateMatrix(&fLocalM)) {
+            this->flushLocalM();
+        }
+    }
+    return fLocalM;
+}
+
+void GrTouchGesture::appendNewRec(void* owner, float x, float y) {
+    Rec* rec = fTouches.append();
+    rec->fOwner = owner;
+    rec->fStartX = rec->fPrevX = rec->fLastX = x;
+    rec->fStartY = rec->fPrevY = rec->fLastY = y;
+    rec->fLastT = rec->fPrevT = SkTime::GetMSecs();
+}
+
+void GrTouchGesture::touchBegin(void* owner, float x, float y) {
+//    GrPrintf("--- %d touchBegin %p %g %g\n", fTouches.count(), owner, x, y);
+
+    int index = this->findRec(owner);
+    if (index >= 0) {
+        this->flushLocalM();
+        fTouches.removeShuffle(index);
+        GrPrintf("---- already exists, removing\n");
+    }
+
+    if (fTouches.count() == 2) {
+        return;
+    }
+
+    this->flushLocalM();
+    fFlinger.stop();
+
+    this->appendNewRec(owner, x, y);
+
+    switch (fTouches.count()) {
+        case 1:
+            fState = kTranslate_State;
+            break;
+        case 2:
+            fState = kZoom_State;
+            break;
+        default:
+            break;
+    }
+}
+
+int GrTouchGesture::findRec(void* owner) const {
+    for (int i = 0; i < fTouches.count(); i++) {
+        if (owner == fTouches[i].fOwner) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static float center(float pos0, float pos1) {
+    return (pos0 + pos1) * 0.5f;
+}
+
+static const float MAX_ZOOM_SCALE = 4;
+static const float MIN_ZOOM_SCALE = 0.25f;
+
+float GrTouchGesture::limitTotalZoom(float scale) const {
+    // this query works 'cause we know that we're square-scale w/ no skew/rotation
+    const float curr = fGlobalM[0];
+    
+    if (scale > 1 && curr * scale > MAX_ZOOM_SCALE) {
+        scale = MAX_ZOOM_SCALE / curr;
+    } else if (scale < 1 && curr * scale < MIN_ZOOM_SCALE) {
+        scale = MIN_ZOOM_SCALE / curr;
+    }
+    return scale;
+}
+
+void GrTouchGesture::touchMoved(void* owner, float x, float y) {
+//    GrPrintf("--- %d touchMoved %p %g %g\n", fTouches.count(), owner, x, y);
+
+    GrAssert(kEmpty_State != fState);
+
+    int index = this->findRec(owner);
+    if (index < 0) {
+        // not found, so I guess we should add it...
+        GrPrintf("---- add missing begin\n");
+        this->appendNewRec(owner, x, y);
+        index = fTouches.count() - 1;
+    }
+
+    Rec& rec = fTouches[index];
+
+    // not sure how valuable this is
+    if (fTouches.count() == 2) {
+        if (close_enough_for_jitter(rec.fLastX, rec.fLastY, x, y)) {
+//            GrPrintf("--- drop touchMove, withing jitter tolerance %g %g\n", rec.fLastX - x, rec.fLastY - y);
+            return;
+        }
+    }
+
+    rec.fPrevX = rec.fLastX; rec.fLastX = x;
+    rec.fPrevY = rec.fLastY; rec.fLastY = y;
+    rec.fPrevT = rec.fLastT; rec.fLastT = SkTime::GetMSecs();
+
+    switch (fTouches.count()) {
+        case 1: {
+            float dx = rec.fLastX - rec.fStartX;
+            float dy = rec.fLastY - rec.fStartY;
+            dx = (float)sk_float_round2int(dx);
+            dy = (float)sk_float_round2int(dy);
+            fLocalM.setTranslate(dx, dy);
+        } break;
+        case 2: {
+            GrAssert(kZoom_State == fState);
+            const Rec& rec0 = fTouches[0];
+            const Rec& rec1 = fTouches[1];
+            
+            float scale = this->computePinch(rec0, rec1);
+            scale = this->limitTotalZoom(scale);
+
+            fLocalM.setTranslate(-center(rec0.fStartX, rec1.fStartX),
+                                 -center(rec0.fStartY, rec1.fStartY));
+            fLocalM.postScale(scale, scale);
+            fLocalM.postTranslate(center(rec0.fLastX, rec1.fLastX),
+                                  center(rec0.fLastY, rec1.fLastY));
+        } break;
+        default:
+            break;
+    }
+}
+
+void GrTouchGesture::touchEnd(void* owner) {
+//    GrPrintf("--- %d touchEnd   %p\n", fTouches.count(), owner);
+
+    int index = this->findRec(owner);
+    if (index < 0) {
+        GrPrintf("--- not found\n");
+        return;
+    }
+
+    const Rec& rec = fTouches[index];
+    if (this->handleDblTap(rec.fLastX, rec.fLastY)) {
+        return;
+    }
+
+    // count() reflects the number before we removed the owner
+    switch (fTouches.count()) {
+        case 1: {
+            this->flushLocalM();
+            float dx = rec.fLastX - rec.fPrevX;
+            float dy = rec.fLastY - rec.fPrevY;
+            float dur = (rec.fLastT - rec.fPrevT) * 0.001f;
+            if (dur > 0) {
+                fFlinger.reset(dx / dur, dy / dur);
+            }
+            fState = kEmpty_State;
+        } break;
+        case 2:
+            this->flushLocalM();
+            GrAssert(kZoom_State == fState);
+            fState = kEmpty_State;
+            break;
+        default:
+            GrAssert(kZoom_State == fState);
+            break;
+    }
+
+    fTouches.removeShuffle(index);
+}
+
+float GrTouchGesture::computePinch(const Rec& rec0, const Rec& rec1) {
+    double dx = rec0.fStartX - rec1.fStartX;
+    double dy = rec0.fStartY - rec1.fStartY;
+    double dist0 = sqrt(dx*dx + dy*dy);
+
+    dx = rec0.fLastX - rec1.fLastX;
+    dy = rec0.fLastY - rec1.fLastY;
+    double dist1 = sqrt(dx*dx + dy*dy);
+
+    double scale = dist1 / dist0;
+    return (float)scale;
+}
+
+bool GrTouchGesture::handleDblTap(float x, float y) {
+    bool found = false;
+    SkMSec now = SkTime::GetMSecs();
+    if (now - fLastUpT <= MAX_DBL_TAP_INTERVAL) {
+        if (SkPoint::Length(fLastUpP.fX - x,
+                            fLastUpP.fY - y) <= MAX_DBL_TAP_DISTANCE) {
+            fFlinger.stop();
+            fLocalM.reset();
+            fGlobalM.reset();
+            fTouches.reset();
+            fState = kEmpty_State;
+            found = true;
+        }
+    }
+
+    fLastUpT = now;
+    fLastUpP.set(x, y);
+    return found;
+}
+
+
diff --git a/gpu/src/app-android.cpp b/gpu/src/app-android.cpp
new file mode 100644
index 0000000..eea9a4d
--- /dev/null
+++ b/gpu/src/app-android.cpp
@@ -0,0 +1,387 @@
+#include <jni.h>
+#include <sys/time.h>
+#include <time.h>
+#include <android/log.h>
+#include <stdint.h>
+
+#include "GrContext.h"
+#include "SkGpuCanvas.h"
+#include "SkPaint.h"
+#include "SkString.h"
+#include "SkTime.h"
+
+#include "GrGLConfig.h"
+
+static GrContext* make_context() {
+    SkDebugf("---- before create\n");
+    GrContext* ctx = GrContext::Create(GrGpu::kOpenGL_Shaders_Engine, NULL);
+//    GrContext* ctx = GrContext::Create(GrGpu::kOpenGL_Fixed_Engine, NULL);
+    SkDebugf("---- after create %p\n", ctx);
+    return ctx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void gr_run_unittests() {}
+
+#include "FlingState.h"
+#include "GrTouchGesture.h"
+#include "SkView.h"
+
+typedef SkView* (*SkViewFactory)();
+
+// these values must match those in Ganesh.java
+enum TouchState {
+    kUnknown_TouchState,
+    kDown_TouchState,
+    kMoved_TouchState,
+    kUp_TouchState
+};
+
+struct State {
+    State();
+    ~State();
+
+    int countSlides() const { return fFactory.count(); }
+    const char* getSlideTitle(int index) const;
+    void chooseSlide(int index) {
+        SkDebugf("----- index %d\n", index);
+        if (index < fFactory.count()) {
+            this->setView(fFactory[index]());
+        }
+    }
+
+    void setViewport(int w, int h);
+    int getWidth() const { return fViewport.fX; }
+    int getHeight() const { return fViewport.fY; }
+    
+    void handleTouch(void*, TouchState, float x, float y);
+    void applyMatrix(SkCanvas*);
+
+    SkView* getView() const { return fView; }
+
+private:
+    SkView*     fView;
+    SkIPoint    fViewport;
+    
+    GrTouchGesture fGesture;
+
+    SkTDArray<SkViewFactory> fFactory;
+
+    void setView(SkView* view) {
+        SkSafeUnref(fView);
+        fView = view;
+
+        view->setVisibleP(true);
+        view->setClipToBounds(false);
+        view->setSize(SkIntToScalar(fViewport.fX),
+                      SkIntToScalar(fViewport.fY));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SampleCode.h"
+
+SkViewRegister* SkViewRegister::gHead;
+SkViewRegister::SkViewRegister(SkViewFactory fact) : fFact(fact) {
+    static bool gOnce;
+    if (!gOnce) {
+        gHead = NULL;
+        gOnce = true;
+    }
+    
+    fChain = gHead;
+    gHead = this;
+}
+
+static const char gCharEvtName[] = "SampleCode_Char_Event";
+static const char gKeyEvtName[] = "SampleCode_Key_Event";
+static const char gTitleEvtName[] = "SampleCode_Title_Event";
+static const char gPrefSizeEvtName[] = "SampleCode_PrefSize_Event";
+static const char gFastTextEvtName[] = "SampleCode_FastText_Event";
+
+bool SampleCode::CharQ(const SkEvent& evt, SkUnichar* outUni) {
+    if (evt.isType(gCharEvtName, sizeof(gCharEvtName) - 1)) {
+        if (outUni) {
+            *outUni = evt.getFast32();
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SampleCode::KeyQ(const SkEvent& evt, SkKey* outKey) {
+    if (evt.isType(gKeyEvtName, sizeof(gKeyEvtName) - 1)) {
+        if (outKey) {
+            *outKey = (SkKey)evt.getFast32();
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SampleCode::TitleQ(const SkEvent& evt) {
+    return evt.isType(gTitleEvtName, sizeof(gTitleEvtName) - 1);
+}
+
+void SampleCode::TitleR(SkEvent* evt, const char title[]) {
+    GrAssert(evt && TitleQ(*evt));
+    evt->setString(gTitleEvtName, title);
+}
+
+bool SampleCode::PrefSizeQ(const SkEvent& evt) {
+    return evt.isType(gPrefSizeEvtName, sizeof(gPrefSizeEvtName) - 1);
+}
+
+void SampleCode::PrefSizeR(SkEvent* evt, SkScalar width, SkScalar height) {
+    GrAssert(evt && PrefSizeQ(*evt));
+    SkScalar size[2];
+    size[0] = width;
+    size[1] = height;
+    evt->setScalars(gPrefSizeEvtName, 2, size);
+}
+
+bool SampleCode::FastTextQ(const SkEvent& evt) {
+    return evt.isType(gFastTextEvtName, sizeof(gFastTextEvtName) - 1);
+}
+
+static SkMSec gAnimTime;
+static SkMSec gAnimTimePrev;
+
+SkMSec SampleCode::GetAnimTime() { return gAnimTime; }
+SkMSec SampleCode::GetAnimTimeDelta() { return gAnimTime - gAnimTimePrev; }
+SkScalar SampleCode::GetAnimSecondsDelta() {
+    return SkDoubleToScalar(GetAnimTimeDelta() / 1000.0);
+}
+
+SkScalar SampleCode::GetAnimScalar(SkScalar speed, SkScalar period) {
+    // since gAnimTime can be up to 32 bits, we can't convert it to a float
+    // or we'll lose the low bits. Hence we use doubles for the intermediate
+    // calculations
+    double seconds = (double)gAnimTime / 1000.0;
+    double value = SkScalarToDouble(speed) * seconds;
+    if (period) {
+        value = ::fmod(value, SkScalarToDouble(period));
+    }
+    return SkDoubleToScalar(value);
+}
+
+static void drawIntoCanvas(State* state, SkCanvas* canvas) {
+    gAnimTime = SkTime::GetMSecs();
+    SkView* view = state->getView();
+    view->draw(canvas);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void resetGpuState();
+
+State::State() {
+    fViewport.set(0, 0);
+
+    const SkViewRegister* reg = SkViewRegister::Head();
+    while (reg) {
+        *fFactory.append() = reg->factory();
+        reg = reg->next();
+    }
+
+    SkDebugf("----- %d slides\n", fFactory.count());
+    fView = NULL;
+    this->chooseSlide(0);
+}
+
+State::~State() {
+    SkSafeUnref(fView);
+}
+
+void State::setViewport(int w, int h) {
+    fViewport.set(w, h);
+    if (fView) {
+        fView->setSize(SkIntToScalar(w), SkIntToScalar(h));
+    }
+    resetGpuState();
+}
+
+const char* State::getSlideTitle(int index) const {
+    SkEvent evt(gTitleEvtName);
+    evt.setFast32(index);
+    {
+        SkView* view = fFactory[index]();
+        view->doQuery(&evt);
+        view->unref();
+    }
+    return evt.findString(gTitleEvtName);
+}
+
+void State::handleTouch(void* owner, TouchState state, float x, float y) {
+    switch (state) {
+        case kDown_TouchState:
+            fGesture.touchBegin(owner, x, y);
+            break;
+        case kMoved_TouchState:
+            fGesture.touchMoved(owner, x, y);
+            break;
+        case kUp_TouchState:
+            fGesture.touchEnd(owner);
+            break;
+    }
+}
+
+void State::applyMatrix(SkCanvas* canvas) {
+    const SkMatrix& localM = fGesture.localM();
+    if (localM.getType() & SkMatrix::kScale_Mask) {
+        canvas->setExternalMatrix(&localM);
+    }
+    canvas->concat(localM);
+    canvas->concat(fGesture.globalM());
+}
+
+static State* get_state() {
+    static State* gState;
+    if (NULL == gState) {
+        gState = new State;
+    }
+    return gState;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static GrContext* gContext;
+static int gWidth;
+static int gHeight;
+static float gX, gY;
+
+static void resetGpuState() {
+    if (NULL == gContext) {
+        SkDebugf("creating context for first time\n");
+        gContext = make_context();
+    } else {
+        SkDebugf("------ gContext refcnt=%d\n", gContext->refcnt());
+        gContext->abandonAllTextures();
+        gContext->unref();
+        gContext = make_context();
+    }
+}
+
+static void doDraw() {
+    if (NULL == gContext) {
+        gContext = make_context();
+    }
+
+    State* state = get_state();
+    SkBitmap viewport;
+    viewport.setConfig(SkBitmap::kARGB_8888_Config,
+                       state->getWidth(), state->getHeight());
+
+    SkGpuCanvas canvas(gContext);
+
+    canvas.setBitmapDevice(viewport);
+    state->applyMatrix(&canvas);
+
+    drawIntoCanvas(state, &canvas);
+
+    GrGLCheckErr();
+    GrGLClearErr();
+//    gContext->checkError();
+//    gContext->clearError();
+
+    if (true) {
+        static const int FRAME_COUNT = 32;
+        static SkMSec gDuration;
+
+        static SkMSec gNow;
+        static int gFrameCounter;
+        if (++gFrameCounter == FRAME_COUNT) {
+            gFrameCounter = 0;
+            SkMSec now = SkTime::GetMSecs();
+
+            gDuration = now - gNow;
+            gNow = now;
+        }
+
+        int fps = (FRAME_COUNT * 1000) / gDuration;
+        SkString str;
+        str.printf("FPS=%3d MS=%3d", fps, gDuration / FRAME_COUNT);
+        
+        SkGpuCanvas c(gContext);
+        c.setBitmapDevice(viewport);
+
+        SkPaint p;
+        p.setAntiAlias(true);
+        SkRect r = { 0, 0, 110, 16 };
+        p.setColor(SK_ColorWHITE);
+        c.drawRect(r, p);
+        p.setColor(SK_ColorBLACK);
+        c.drawText(str.c_str(), str.size(), 4, 12, p);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+extern "C" {
+    JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeSurfaceCreated(
+                                                           JNIEnv*, jobject);
+    JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeViewport(JNIEnv*, jobject,
+                                                                             jint w, jint h);
+    JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeDrawFrame(JNIEnv*, jobject);
+    JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeTouch(JNIEnv*, jobject,
+                                        jint id, jint type, jfloat x, jfloat y);
+
+    JNIEXPORT int JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeCountSlides(JNIEnv*, jobject);
+    JNIEXPORT jobject JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeGetSlideTitle(JNIEnv*, jobject, jint index);
+    JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeChooseSlide(JNIEnv*, jobject, jint index);
+}
+
+JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeSurfaceCreated(
+                                                            JNIEnv*, jobject) {
+    SkDebugf("------ nativeSurfaceCreated\n");
+    resetGpuState();
+    SkDebugf("------ end nativeSurfaceCreated\n");
+}
+
+JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeViewport(JNIEnv*, jobject,
+                                                       jint w, jint h) {
+    State* state = get_state();
+    SkDebugf("---- state.setviewport %p %d %d\n", state, w, h);
+    state->setViewport(w, h);
+    SkDebugf("---- end setviewport\n");
+}
+
+JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeDrawFrame(JNIEnv*, jobject) {
+    doDraw();
+}
+
+union IntPtr {
+    jint    fInt;
+    void*   fPtr;
+};
+static void* int2ptr(jint n) {
+    IntPtr data;
+    data.fInt = n;
+    return data.fPtr;
+}
+
+JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeTouch(JNIEnv*, jobject,
+                                      jint id, jint type, jfloat x, jfloat y) {
+    get_state()->handleTouch(int2ptr(id), (TouchState)type, x, y);
+}
+
+////////////
+
+JNIEXPORT int JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeCountSlides(JNIEnv*, jobject) {
+    return get_state()->countSlides();
+}
+
+JNIEXPORT jobject JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeGetSlideTitle(JNIEnv* env, jobject, jint index) {
+    return env->NewStringUTF(get_state()->getSlideTitle(index));
+}
+
+JNIEXPORT void JNICALL Java_com_tetrark_ganesh_MyRenderer_nativeChooseSlide(JNIEnv*, jobject, jint index) {
+    get_state()->chooseSlide(index);
+}
+
+
+
+
+
diff --git a/gpu/src/gr_files.mk b/gpu/src/gr_files.mk
new file mode 100644
index 0000000..d0f41e7
--- /dev/null
+++ b/gpu/src/gr_files.mk
@@ -0,0 +1,26 @@
+SOURCE := \
+    GrAllocPool.cpp \
+    GrAtlas.cpp \
+    GrClip.cpp \
+    GrContext.cpp \
+    GrDrawTarget.cpp \
+    GrGLIndexBuffer.cpp	\
+    GrGLTexture.cpp \
+    GrGLVertexBuffer.cpp \
+    GrGpu.cpp \
+    GrGpuGLShaders2.cpp \
+    GrGpuGLFixed.cpp \
+    GrGpuFactory.cpp \
+    GrGLUtil.cpp \
+    GrGpuGL.cpp \
+    GrInOrderDrawBuffer.cpp \
+    GrMatrix.cpp \
+    GrMemory.cpp \
+    GrPath.cpp \
+    GrRectanizer_fifo.cpp \
+    GrTextureCache.cpp \
+    GrTextContext.cpp \
+    GrTextStrike.cpp \
+    GrBufferAllocPool.cpp\
+    GrPathRenderer.cpp \
+    GrStencil.cpp
diff --git a/gpu/src/gr_hello_world.cpp b/gpu/src/gr_hello_world.cpp
new file mode 100644
index 0000000..5638e19
--- /dev/null
+++ b/gpu/src/gr_hello_world.cpp
@@ -0,0 +1,30 @@
+#include "SkGLCanvas.h"
+#include "SkBitmap.h"
+#include "SkPaint.h"
+#include "SkGpuGLShaders.h"
+
+extern "C" {
+    void gr_hello_world();
+}
+
+void gr_hello_world() {
+    static GrGpu* gGpu;
+    if (NULL == gGpu) {
+        gGpu = new SkGpuGLShaders;
+    }
+
+    SkGLCanvas canvas(gGpu);
+    SkBitmap bm;
+
+    bm.setConfig(SkBitmap::kARGB_8888_Config, WIDTH, HEIGHT);
+    canvas.setBitmapDevice(bm);
+
+    canvas.drawColor(SK_ColorWHITE);
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    paint.setTextSize(30);
+    canvas.drawText("Hello Kno", 9, 40, 40, paint);
+}
+
+
diff --git a/gpu/src/gr_unittests.cpp b/gpu/src/gr_unittests.cpp
new file mode 100644
index 0000000..16fd9dc
--- /dev/null
+++ b/gpu/src/gr_unittests.cpp
@@ -0,0 +1,86 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrDrawTarget.h"
+#include "GrTDArray.h"
+#include "GrTBSearch.h"
+#include "GrMatrix.h"
+#include "GrRedBlackTree.h"
+#include "GrPath.h"
+
+static void dump(const GrTDArray<int>& array) {
+#if 0
+    for (int i = 0; i < array.count(); i++) {
+        printf(" %d", array[i]);
+    }
+    printf("\n");
+#endif
+}
+
+static void test_tdarray() {
+    GrTDArray<int> array;
+
+    *array.append() = 0; dump(array);
+    *array.append() = 2; dump(array);
+    *array.append() = 4; dump(array);
+    *array.append() = 6; dump(array);
+    GrAssert(array.count() == 4);
+
+    *array.insert(0) = -1; dump(array);
+    *array.insert(2) = 1; dump(array);
+    *array.insert(4) = 3; dump(array);
+    *array.insert(7) = 7; dump(array);
+    GrAssert(array.count() == 8);
+    array.remove(3); dump(array);
+    array.remove(0); dump(array);
+    array.removeShuffle(4); dump(array);
+    array.removeShuffle(1); dump(array);
+    GrAssert(array.count() == 4);
+}
+
+static bool LT(const int& elem, int value) {
+    return elem < value;
+}
+static bool EQ(const int& elem, int value) {
+    return elem == value;
+}
+
+static void test_bsearch() {
+    const int array[] = {
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99
+    };
+
+    for (size_t n = 0; n < GR_ARRAY_COUNT(array); n++) {
+        for (size_t i = 0; i < n; i++) {
+            int index = GrTBSearch<int, int>(array, n, array[i]);
+            GrAssert(index == i);
+            index = GrTBSearch<int, int>(array, n, -array[i]);
+            GrAssert(index < 0);
+        }
+    }
+}
+
+void gr_run_unittests() {
+    test_tdarray();
+    test_bsearch();
+    GrMatrix::UnitTest();
+    GrRedBlackTree<int>::UnitTest();
+    GrPath::ConvexUnitTest();
+    GrDrawTarget::VertexLayoutUnitTest();
+}
+
+
diff --git a/gpu/src/skia/SkUIView.mm b/gpu/src/skia/SkUIView.mm
new file mode 100644
index 0000000..667a474
--- /dev/null
+++ b/gpu/src/skia/SkUIView.mm
@@ -0,0 +1,858 @@
+#import "SkUIView.h"
+#include <QuartzCore/QuartzCore.h>
+
+#include "SkGpuCanvas.h"
+#include "SkCGUtils.h"
+#include "GrContext.h"
+
+#define SKWIND_CONFIG       SkBitmap::kRGB_565_Config
+//#define SKWIND_CONFIG       SkBitmap::kARGB_8888_Config
+#define SKGL_CONFIG         kEAGLColorFormatRGB565
+//#define SKGL_CONFIG         kEAGLColorFormatRGBA8
+
+#define SHOW_FPS
+#define FORCE_REDRAW
+//#define DUMP_FPS_TO_PRINTF
+
+//#define USE_ACCEL_TO_ROTATE
+
+//#define SHOULD_COUNTER_INIT 334
+static int gShouldCounter;
+static bool should_draw() {
+    if (--gShouldCounter == 0) {
+   //     printf("\n");
+    }
+    return true;
+    return gShouldCounter >= 0;
+}
+#ifdef SHOULD_COUNTER_INIT
+    bool (*gShouldDrawProc)() = should_draw;
+#else
+    bool (*gShouldDrawProc)() = NULL;
+#endif
+
+//#define USE_GL_1
+#define USE_GL_2
+
+#if defined(USE_GL_1) || defined(USE_GL_2)
+    #define USE_GL
+#endif
+
+@implementation SkUIView
+
+
+@synthesize fWind;
+@synthesize fTitleLabel;
+@synthesize fBackend;
+@synthesize fComplexClip;
+@synthesize fUseWarp;
+
+#include "SkWindow.h"
+#include "SkEvent.h"
+
+static float gScreenScale = 1;
+
+extern SkOSWindow* create_sk_window(void* hwnd);
+
+#define kREDRAW_UIVIEW_GL "sk_redraw_uiview_gl_iOS"
+
+#define TITLE_HEIGHT  44
+
+static const float SCALE_FOR_ZOOM_LENS = 4.0;
+#define Y_OFFSET_FOR_ZOOM_LENS           200
+#define SIZE_FOR_ZOOM_LENS               250
+
+static const float MAX_ZOOM_SCALE = 4.0;
+static const float MIN_ZOOM_SCALE = 2.0 / MAX_ZOOM_SCALE;
+
+extern bool gDoTraceDraw;
+#define DO_TRACE_DRAW_MAX   100
+
+#ifdef SHOW_FPS
+struct FPSState {
+    static const int FRAME_COUNT = 60;
+
+    CFTimeInterval fNow0, fNow1;
+    CFTimeInterval fTime0, fTime1, fTotalTime;
+    int fFrameCounter;
+    int fDrawCounter;
+
+    FPSState() {
+        fTime0 = fTime1 = fTotalTime = 0;
+        fFrameCounter = 0;
+    }
+
+    void startDraw() {
+        fNow0 = CACurrentMediaTime();
+        
+        if (0 == fDrawCounter && false) {
+            gDoTraceDraw = true;
+            SkDebugf("\n");
+        }
+    }
+    
+    void endDraw() {
+        fNow1 = CACurrentMediaTime();
+
+        if (0 == fDrawCounter) {
+            gDoTraceDraw = true;
+        }
+        if (DO_TRACE_DRAW_MAX == ++fDrawCounter) {
+            fDrawCounter = 0;
+        }
+    }
+        
+    void flush(SkOSWindow* wind) {
+        CFTimeInterval now2 = CACurrentMediaTime();
+
+        fTime0 += fNow1 - fNow0;
+        fTime1 += now2 - fNow1;
+        
+        if (++fFrameCounter == FRAME_COUNT) {
+            CFTimeInterval totalNow = CACurrentMediaTime();
+            fTotalTime = totalNow - fTotalTime;
+            
+            SkMSec ms0 = (int)(1000 * fTime0 / FRAME_COUNT);
+            SkMSec msTotal = (int)(1000 * fTotalTime / FRAME_COUNT);
+            
+            SkString str;
+            str.printf("ms: %d [%d], fps: %3.1f", msTotal, ms0,
+                       FRAME_COUNT / fTotalTime);
+#ifdef DUMP_FPS_TO_PRINTF
+            SkDebugf("%s\n", str.c_str());
+#else
+            wind->setTitle(str.c_str());
+#endif
+
+            fTotalTime = totalNow;
+            fTime0 = fTime1 = 0;
+            fFrameCounter = 0;
+        }
+    }
+};
+
+static FPSState gFPS;
+
+    #define FPS_StartDraw() gFPS.startDraw()
+    #define FPS_EndDraw()   gFPS.endDraw()
+    #define FPS_Flush(wind)     gFPS.flush(wind)
+#else
+    #define FPS_StartDraw()
+    #define FPS_EndDraw()
+    #define FPS_Flush(wind)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef USE_GL
++ (Class) layerClass
+{
+	return [CAEAGLLayer class];
+}
+#endif
+
+- (id)initWithMyDefaults {
+    fBackend = kGL_Backend;
+    fUseWarp = false;
+    fRedrawRequestPending = false;
+    fWind = create_sk_window(self);
+    fWind->setConfig(SKWIND_CONFIG);
+    fMatrix.reset();
+    fLocalMatrix.reset();
+    fNeedGestureEnded = false;
+    fNeedFirstPinch = true;
+    fZoomAround = false;
+    fComplexClip = false;
+
+    [self initGestures];
+
+#ifdef USE_GL
+    CAEAGLLayer *eaglLayer = (CAEAGLLayer *)self.layer;
+    eaglLayer.opaque = TRUE;
+    eaglLayer.drawableProperties = [NSDictionary dictionaryWithObjectsAndKeys:
+                                        [NSNumber numberWithBool:NO],
+                                        kEAGLDrawablePropertyRetainedBacking,
+                                        SKGL_CONFIG,
+                                        kEAGLDrawablePropertyColorFormat,
+                                        nil];
+
+#ifdef USE_GL_1
+    fGL.fContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
+#else
+    fGL.fContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
+#endif
+
+    if (!fGL.fContext || ![EAGLContext setCurrentContext:fGL.fContext])
+    {
+        [self release];
+        return nil;
+    }
+    
+    // Create default framebuffer object. The backing will be allocated for the current layer in -resizeFromLayer
+    glGenFramebuffersOES(1, &fGL.fFramebuffer);
+    glBindFramebufferOES(GL_FRAMEBUFFER_OES, fGL.fFramebuffer);
+
+    glGenRenderbuffersOES(1, &fGL.fRenderbuffer);
+    glGenRenderbuffersOES(1, &fGL.fStencilbuffer);
+
+    glBindRenderbufferOES(GL_RENDERBUFFER_OES, fGL.fRenderbuffer);
+    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, fGL.fRenderbuffer);
+
+    glBindRenderbufferOES(GL_RENDERBUFFER_OES, fGL.fStencilbuffer);
+    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, GL_STENCIL_ATTACHMENT_OES, GL_RENDERBUFFER_OES, fGL.fStencilbuffer);
+#endif
+
+#ifdef USE_ACCEL_TO_ROTATE
+    fRotateMatrix.reset();
+    [UIAccelerometer sharedAccelerometer].delegate = self;
+    [UIAccelerometer sharedAccelerometer].updateInterval = 1 / 30.0;
+#endif
+    return self;
+}
+
+- (id)initWithCoder:(NSCoder*)coder {
+    if ((self = [super initWithCoder:coder])) {
+        self = [self initWithMyDefaults];
+    }
+    return self;
+}
+
+- (id)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        self = [self initWithMyDefaults];
+    }
+    return self;
+}
+
+#include "SkImageDecoder.h"
+#include "SkStream_NSData.h"
+
+static void zoom_around(SkCanvas* canvas, float cx, float cy, float zoom) {
+    float clipW = SIZE_FOR_ZOOM_LENS;
+    float clipH = SIZE_FOR_ZOOM_LENS;
+
+    SkRect r;
+    r.set(0, 0, clipW, clipH);
+    r.offset(cx - clipW/2, cy - clipH/2);
+
+    SkPaint paint;
+    paint.setColor(0xFF66AAEE);
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(10);
+
+    // draw our "frame" around the zoom lens
+    canvas->drawRect(r, paint);
+
+    // now clip and scale the lens
+    canvas->clipRect(r);
+    canvas->translate(cx, cy);
+    canvas->scale(zoom, zoom);
+    canvas->translate(-cx, -cy);
+}
+
+- (void)drawWithCanvas:(SkCanvas*)canvas {
+    if (fComplexClip) {
+        canvas->drawColor(SK_ColorBLUE);
+
+        SkPath path;
+        static const SkRect r[] = {
+            { 50, 50, 250, 250 },
+            { 150, 150, 500, 600 }
+        };
+        for (size_t i = 0; i < GR_ARRAY_COUNT(r); i++) {
+            path.addRect(r[i]);
+        }
+        canvas->clipPath(path);
+    }
+    
+    // This is to consolidate multiple inval requests
+    fRedrawRequestPending = false;
+
+    if (fFlingState.isActive()) {
+        if (!fFlingState.evaluateMatrix(&fLocalMatrix)) {
+            [self flushLocalMatrix];
+        }
+    }
+
+    SkMatrix localMatrix = fLocalMatrix;
+#ifdef USE_ACCEL_TO_ROTATE
+    localMatrix.preConcat(fRotateMatrix);
+#endif
+
+    SkMatrix matrix;
+    matrix.setConcat(localMatrix, fMatrix);
+
+    const SkMatrix* localM = NULL;
+    if (localMatrix.getType() & SkMatrix::kScale_Mask) {
+        localM = &localMatrix;
+    }
+#ifdef USE_ACCEL_TO_ROTATE
+    localM = &localMatrix;
+#endif
+    canvas->setExternalMatrix(localM);
+
+#ifdef SHOULD_COUNTER_INIT
+    gShouldCounter = SHOULD_COUNTER_INIT;
+#endif
+
+    {
+        int saveCount = canvas->save();
+        canvas->concat(matrix);
+//        SkRect r = { 10, 10, 500, 600 }; canvas->clipRect(r);
+        fWind->draw(canvas);
+        canvas->restoreToCount(saveCount);
+    }
+
+    if (fZoomAround) {
+        zoom_around(canvas, fZoomAroundX, fZoomAroundY, SCALE_FOR_ZOOM_LENS);
+        canvas->concat(matrix);
+        fWind->draw(canvas);
+    }
+    
+#ifdef FORCE_REDRAW
+    fWind->inval(NULL);
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+- (void)layoutSubviews {
+    int W, H;
+
+    gScreenScale = [UIScreen mainScreen].scale;
+
+#ifdef USE_GL
+    
+    CAEAGLLayer* eaglLayer = (CAEAGLLayer*)self.layer;
+    if ([self respondsToSelector:@selector(setContentScaleFactor:)]) {
+        self.contentScaleFactor = gScreenScale;
+    }
+    // Allocate color buffer backing based on the current layer size
+    glBindRenderbufferOES(GL_RENDERBUFFER_OES, fGL.fRenderbuffer);
+    [fGL.fContext renderbufferStorage:GL_RENDERBUFFER_OES fromDrawable:eaglLayer];
+    
+    glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_WIDTH_OES, &fGL.fWidth);
+    glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES, GL_RENDERBUFFER_HEIGHT_OES, &fGL.fHeight);
+
+    if (glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES) != GL_FRAMEBUFFER_COMPLETE_OES)
+    {
+        NSLog(@"Failed to make complete framebuffer object %x", glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES));
+    }
+
+    glBindRenderbufferOES(GL_RENDERBUFFER_OES, fGL.fStencilbuffer);
+    glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_STENCIL_INDEX8_OES, fGL.fWidth, fGL.fHeight);
+
+    W = fGL.fWidth;
+    H = fGL.fHeight;
+#else
+    CGRect rect = [self bounds];
+    W = (int)CGRectGetWidth(rect);
+    H = (int)CGRectGetHeight(rect) - TITLE_HEIGHT;
+#endif
+
+    printf("---- layoutSubviews %d %d\n", W, H);
+    fWind->resize(W, H);
+    fWind->inval(NULL);
+}
+
+#ifdef USE_GL
+
+static GrContext* gCtx;
+static GrContext* get_global_grctx() {
+    // should be pthread-local at least
+    if (NULL == gCtx) {        
+#ifdef USE_GL_1
+        gCtx = GrContext::Create(GrGpu::kOpenGL_Fixed_Engine, NULL);
+#else
+        gCtx = GrContext::Create(GrGpu::kOpenGL_Shaders_Engine, NULL);
+#endif
+    }
+    return gCtx;
+}
+
+#include "SkDevice.h"
+#include "SkShader.h"
+#include "SkGrTexturePixelRef.h"
+#include "GrMesh.h"
+#include "SkRandom.h"
+
+#include "GrAtlas.h"
+#include "GrTextStrike.h"
+
+static void show_fontcache(GrContext* ctx, SkCanvas* canvas) {
+#if 0
+    SkPaint paint;
+    const int SIZE = 64;
+    GrAtlas* plot[64][64];
+
+    paint.setAntiAlias(true);
+    paint.setTextSize(24);
+    paint.setTextAlign(SkPaint::kCenter_Align);
+
+    Gr_bzero(plot, sizeof(plot));
+
+    GrFontCache* cache = ctx->getFontCache();
+    GrTextStrike* strike = cache->getHeadStrike();
+    int count = 0;
+    while (strike) {
+        GrAtlas* atlas = strike->getAtlas();
+        while (atlas) {
+            int x = atlas->getPlotX();
+            int y = atlas->getPlotY();
+
+            SkRandom rand((intptr_t)strike);
+            SkColor c = rand.nextU() | 0x80808080;
+            paint.setColor(c);
+            paint.setAlpha(0x80);
+
+            SkRect r;
+            r.set(x * SIZE, y * SIZE, (x + 1)*SIZE, (y+1)*SIZE);
+            r.inset(1, 1);
+            canvas->drawRect(r, paint);
+            
+            paint.setColor(0xFF660000);
+            SkString label;
+            label.printf("%d", count);
+            canvas->drawText(label.c_str(), label.size(), r.centerX(),
+                             r.fTop + r.height() * 2 / 3, paint);
+            
+            atlas = atlas->nextAtlas();
+        }
+        strike = strike->fNext;
+        count += 1;
+    }
+#endif
+}
+
+void test_patch(SkCanvas* canvas, const SkBitmap& bm, SkScalar scale);
+
+static void draw_mesh(SkCanvas* canvas, const SkBitmap& bm) {
+    GrMesh fMesh;
+
+    SkRect r;
+    r.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()));
+    
+    //        fMesh.init(bounds, fBitmap.width() / 40, fBitmap.height() / 40, texture);
+    fMesh.init(r, bm.width()/16, bm.height()/16, r);
+
+    SkPaint paint;
+    SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+    paint.setShader(s)->unref();
+    fMesh.draw(canvas, paint);
+}
+
+static void scale_about(SkCanvas* canvas, float sx, float sy, float px, float py) {
+    canvas->translate(px, py);
+    canvas->scale(sx, sy);
+    canvas->translate(-px, -py);
+}
+
+static float grInterp(float v0, float v1, float percent) {
+    return v0 + percent * (v1 - v0);
+}
+
+static void draw_device(SkCanvas* canvas, SkDevice* dev, float w, float h, float warp) {
+    canvas->save();
+    float s = grInterp(1, 0.8, warp);
+    scale_about(canvas, s, s, w/2, h/2);
+    test_patch(canvas, dev->accessBitmap(false), warp);
+    canvas->restore();
+}
+
+- (void)drawInGL {
+//    printf("------ drawInGL\n");
+    // This application only creates a single context which is already set current at this point.
+    // This call is redundant, but needed if dealing with multiple contexts.
+    [EAGLContext setCurrentContext:fGL.fContext];
+    
+    // This application only creates a single default framebuffer which is already bound at this point.
+    // This call is redundant, but needed if dealing with multiple framebuffers.
+    glBindFramebufferOES(GL_FRAMEBUFFER_OES, fGL.fFramebuffer);
+    
+    GLint scissorEnable;
+    glGetIntegerv(GL_SCISSOR_TEST, &scissorEnable);
+    glDisable(GL_SCISSOR_TEST);
+    glClearColor(0,0,0,0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    if (scissorEnable) {
+        glEnable(GL_SCISSOR_TEST);
+    }
+    
+    GrContext* ctx = get_global_grctx();
+    SkGpuCanvas origCanvas(ctx);
+    origCanvas.setBitmapDevice(fWind->getBitmap());
+    
+    //    gl->reset();
+    SkGpuCanvas glCanvas(ctx);
+    SkCanvas   rasterCanvas;
+
+    SkCanvas* canvas;
+    SkDevice* dev = NULL;
+    
+    switch (fBackend) {
+        case kRaster_Backend:
+            canvas = &rasterCanvas;
+            break;
+        case kGL_Backend:
+            canvas = &glCanvas;
+            break;
+    }
+
+    if (fUseWarp || fWarpState.isActive()) {
+        if (kGL_Backend == fBackend) {
+            dev = origCanvas.createDevice(fWind->getBitmap(), true);
+            canvas->setDevice(dev)->unref();
+        } else {
+            canvas->setBitmapDevice(fWind->getBitmap());
+            dev = canvas->getDevice();
+        }
+    } else {
+        canvas->setBitmapDevice(fWind->getBitmap());
+        dev = NULL;
+    }
+    
+    canvas->translate(0, TITLE_HEIGHT);
+
+    // if we're not "retained", then we have to always redraw everything.
+    // This call forces us to ignore the fDirtyRgn, and draw everywhere.
+    // If we are "retained", we can skip this call (as the raster case does)
+    fWind->forceInvalAll();
+
+    FPS_StartDraw();
+    [self drawWithCanvas:canvas];
+    FPS_EndDraw();
+
+    if (dev) {
+        draw_device(&origCanvas, dev, fWind->width(), fWind->height(),
+                    fWarpState.evaluate());
+    } else {
+        if (kRaster_Backend == fBackend) {
+            origCanvas.drawBitmap(fWind->getBitmap(), 0, 0, NULL);
+        }
+        // else GL - we're already on screen
+    }
+
+    show_fontcache(ctx, canvas);
+    ctx->flush(false);
+        
+    // This application only creates a single color renderbuffer which is already bound at this point.
+    // This call is redundant, but needed if dealing with multiple renderbuffers.
+    glBindRenderbufferOES(GL_RENDERBUFFER_OES, fGL.fRenderbuffer);
+    [fGL.fContext presentRenderbuffer:GL_RENDERBUFFER_OES];
+    
+#if GR_COLLECT_STATS
+    static int frame = 0;
+    if (!(frame % 100)) {
+        get_global_grctx()->printStats();
+    }
+    get_global_grctx()->resetStats();
+    ++frame;
+#endif
+    
+    FPS_Flush(fWind);
+
+#if 0
+    gCtx->deleteAllTextures(GrTextureCache::kAbandonTexture_DeleteMode);
+    gCtx->unref();
+    gCtx = NULL;
+#endif
+}
+
+#else   // raster case
+
+- (void)drawRect:(CGRect)rect {
+    CGContextRef cg = UIGraphicsGetCurrentContext();
+    SkCanvas* canvas = NULL;
+
+    FPS_StartDraw();
+    [self drawWithCanvas:canvas];
+
+    FPS_EndDraw();
+    SkCGDrawBitmap(cg, fWind->getBitmap(), 0, TITLE_HEIGHT);
+
+    FPS_Flush(fWind);
+
+}
+#endif
+
+- (void)setWarpState:(bool)useWarp {
+    fWarpState.stop();  // we should reverse from where we are if active...
+
+    const float duration = 0.5;
+    fUseWarp = useWarp;
+    if (useWarp) {
+        fWarpState.start(0, 1, duration);
+    } else {
+        fWarpState.start(1, 0, duration);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+- (void)flushLocalMatrix {
+    fMatrix.postConcat(fLocalMatrix);
+    fLocalMatrix.reset();
+    fFlingState.stop();
+    fNeedGestureEnded = false;
+    fNeedFirstPinch = true;
+}
+
+- (void)localMatrixWithGesture:(UIGestureRecognizer*)gesture {
+    fNeedGestureEnded = true;
+
+    switch (gesture.state) {
+        case UIGestureRecognizerStateCancelled:
+        case UIGestureRecognizerStateEnded:
+            [self flushLocalMatrix];
+            break;
+        case UIGestureRecognizerStateChanged: {
+            SkMatrix matrix;
+            matrix.setConcat(fLocalMatrix, fMatrix);
+        } break;
+        default:
+            break;
+    }
+}
+
+- (void)commonHandleGesture:(UIGestureRecognizer*)sender {
+    if (fFlingState.isActive()) {
+        [self flushLocalMatrix];
+    }
+
+    switch (sender.state) {
+        case UIGestureRecognizerStateBegan:
+            [self flushLocalMatrix];
+            break;
+        default:
+            break;
+    }
+}
+
+- (void)handleDTapGesture:(UIGestureRecognizer*)sender {
+    [self flushLocalMatrix];
+    fMatrix.reset();
+}
+
+static float discretize(float x) {
+    return (int)x;
+}
+
+- (void)handlePanGesture:(UIPanGestureRecognizer*)sender {
+    [self commonHandleGesture:sender];
+
+    CGPoint delta = [sender translationInView:self];
+    delta.x *= gScreenScale;
+    delta.y *= gScreenScale;
+    // avoid flickering where the drawing might toggle in and out of a pixel
+    // center if translated by a fractional value
+    delta.x = discretize(delta.x);
+    delta.y = discretize(delta.y);
+    fLocalMatrix.setTranslate(delta.x, delta.y);
+    [self localMatrixWithGesture:sender];
+
+    if (UIGestureRecognizerStateEnded == sender.state) {
+        CGPoint velocity = [sender velocityInView:self];
+        fFlingState.reset(velocity.x, velocity.y);
+        fNeedGestureEnded = true;
+    }
+}
+
+- (float)limitTotalZoom:(float)scale {
+    // this query works 'cause we know that we're square-scale w/ no skew/rotation
+    const float curr = fMatrix[0];
+
+    if (scale > 1 && curr * scale > MAX_ZOOM_SCALE) {
+        scale = MAX_ZOOM_SCALE / curr;
+    } else if (scale < 1 && curr * scale < MIN_ZOOM_SCALE) {
+        scale = MIN_ZOOM_SCALE / curr;
+    }
+    return scale;
+}
+
+- (void)handleScaleGesture:(UIPinchGestureRecognizer*)sender {
+    [self commonHandleGesture:sender];
+
+    if ([sender numberOfTouches] == 2) {
+        float scale = sender.scale;
+        CGPoint p0 = [sender locationOfTouch:0 inView:self];
+        CGPoint p1 = [sender locationOfTouch:0 inView:self];
+        float cx = (p0.x + p1.x) * 0.5;
+        float cy = (p0.y + p1.y) * 0.5;
+
+        if (fNeedFirstPinch) {
+            fFirstPinchX = cx;
+            fFirstPinchY = cy;
+            fNeedFirstPinch = false;
+        }
+
+        scale = [self limitTotalZoom:scale];
+
+        fLocalMatrix.setTranslate(-fFirstPinchX, -fFirstPinchY);
+        fLocalMatrix.postScale(scale, scale);
+        fLocalMatrix.postTranslate(cx, cy);
+        [self localMatrixWithGesture:sender];
+    } else {
+        [self flushLocalMatrix];
+    }
+}
+
+- (void)handleLongPressGesture:(UILongPressGestureRecognizer*)sender {
+    [self commonHandleGesture:sender];
+
+    if ([sender numberOfTouches] == 0) {
+        fZoomAround = false;
+        return;
+    }
+
+    CGPoint pt = [sender locationOfTouch:0 inView:self];
+    switch (sender.state) {
+        case UIGestureRecognizerStateBegan:
+        case UIGestureRecognizerStateChanged:
+            fZoomAround = true;
+            fZoomAroundX = pt.x;
+            fZoomAroundY = pt.y - Y_OFFSET_FOR_ZOOM_LENS;
+            break;
+        case UIGestureRecognizerStateEnded:
+        case UIGestureRecognizerStateCancelled:
+            fZoomAround = false;
+            break;
+        default:
+            break;
+    }
+}
+
+- (void)addAndReleaseGesture:(UIGestureRecognizer*)gesture {
+    [self addGestureRecognizer:gesture];
+    [gesture release];
+}
+
+- (void)initGestures {
+    UITapGestureRecognizer* tapG = [UITapGestureRecognizer alloc];
+    [tapG initWithTarget:self action:@selector(handleDTapGesture:)];
+    tapG.numberOfTapsRequired = 2;
+    [self addAndReleaseGesture:tapG];
+
+    UIPanGestureRecognizer* panG = [UIPanGestureRecognizer alloc];
+    [panG initWithTarget:self action:@selector(handlePanGesture:)];
+    [self addAndReleaseGesture:panG];
+    
+    UIPinchGestureRecognizer* pinchG = [UIPinchGestureRecognizer alloc];
+    [pinchG initWithTarget:self action:@selector(handleScaleGesture:)];
+    [self addAndReleaseGesture:pinchG];
+
+    UILongPressGestureRecognizer* longG = [UILongPressGestureRecognizer alloc];
+    [longG initWithTarget:self action:@selector(handleLongPressGesture:)];
+    [self addAndReleaseGesture:longG];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static float abs(float x) { return x < 0 ? -x : x; }
+
+static bool normalize(UIAcceleration* acc, float xy[]) {
+    float mag2 = acc.x*acc.x + acc.y*acc.y + acc.z*acc.z;
+    if (mag2 < 0.000001) {
+        return false;
+    }
+    if (abs((float)acc.z) > 0.9 * sqrt(mag2)) {
+        return false;
+    }
+
+    mag2 = acc.x*acc.x + acc.y*acc.y;
+    if (mag2 < 0.000001) {
+        return false;
+    }
+    float scale = 1 / sqrt(mag2);
+    xy[0] = acc.x * scale;
+    xy[1] = acc.y * scale;
+    return true;
+}
+
+static void normalize(float xy[]) {
+    float scale = 1 / sqrt(xy[0]*xy[0] + xy[1]*xy[1]);
+    xy[0] *= scale;
+    xy[1] *= scale;
+}
+
+static float weighted_average(float newv, float oldv) {
+    return newv * 0.25 + oldv * 0.75;
+}
+
+- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:(UIAcceleration *)acc {
+
+    float norm[2];
+    if (normalize(acc, norm)) {
+        float sinv = -norm[0];
+        float cosv = -norm[1];
+        // smooth
+        norm[0] = weighted_average(sinv, -fRotateMatrix[1]);
+        norm[1] = weighted_average(cosv, fRotateMatrix[0]);
+        normalize(norm);
+        fRotateMatrix.setSinCos(norm[0], norm[1], 400, 400);
+    }
+#if 0
+    NSDate *now = [NSDate date];
+    NSTimeInterval intervalDate = [now timeIntervalSinceDate:now_prev];
+    
+    velX += (acceleration.x * intervalDate);
+    distX += (velX * intervalDate);
+    //do other axis here too
+    
+    // setup for next UIAccelerometer event
+    now_prev = now;
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+- (void)setSkTitle:(const char *)title {
+    if (fTitleLabel) {
+        fTitleLabel.text = [NSString stringWithUTF8String:title];
+        [fTitleLabel setNeedsDisplay];
+    }
+}
+
+- (BOOL)onHandleEvent:(const SkEvent&)evt {
+    if (evt.isType(kREDRAW_UIVIEW_GL)) {
+        [self drawInGL];
+        return true;
+    }
+    return false;
+}
+
+- (void)postInvalWithRect:(const SkIRect*)r {
+#ifdef USE_GL
+
+#if 1
+    if (!fRedrawRequestPending) {
+        fRedrawRequestPending = true;
+        /*
+            performSelectorOnMainThread seems to starve updating other views
+            (e.g. our FPS view in the titlebar), so we use the afterDelay
+            version
+         */
+        if (0) {
+            [self performSelectorOnMainThread:@selector(drawInGL) withObject:nil waitUntilDone:NO];
+        } else {
+            [self performSelector:@selector(drawInGL) withObject:nil afterDelay:0];
+        }
+    }
+#else
+    if (!fRedrawRequestPending) {
+        SkEvent* evt = new SkEvent(kREDRAW_UIVIEW_GL);
+        evt->post(fWind->getSinkID());
+        fRedrawRequestPending = true;
+    }
+#endif
+
+#else
+    if (r) {
+        [self setNeedsDisplayInRect:CGRectMake(r->fLeft, r->fTop,
+                                               r->width(), r->height())];
+    } else {
+        [self setNeedsDisplay];
+    }
+#endif
+}
+
+@end
diff --git a/include/config/SkUserConfig.h b/include/config/SkUserConfig.h
deleted file mode 100644
index c0bbb4b..0000000
--- a/include/config/SkUserConfig.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkUserConfig_DEFINED
-#define SkUserConfig_DEFINED
-
-/*  SkTypes.h, the root of the public header files, does the following trick:
-
-    #include "SkPreConfig.h"
-    #include "SkUserConfig.h"
-    #include "SkPostConfig.h"
-
-    SkPreConfig.h runs first, and it is responsible for initializing certain
-    skia defines.
-
-    SkPostConfig.h runs last, and its job is to just check that the final
-    defines are consistent (i.e. that we don't have mutually conflicting
-    defines).
-
-    SkUserConfig.h (this file) runs in the middle. It gets to change or augment
-    the list of flags initially set in preconfig, and then postconfig checks
-    that everything still makes sense.
-
-    Below are optional defines that add, subtract, or change default behavior
-    in Skia. Your port can locally edit this file to enable/disable flags as
-    you choose, or these can be delared on your command line (i.e. -Dfoo).
-
-    By default, this include file will always default to having all of the flags
-    commented out, so including it will have no effect.
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-
-/*  Scalars (the fractional value type in skia) can be implemented either as
-    floats or 16.16 integers (fixed). Exactly one of these two symbols must be
-    defined.
-*/
-//#define SK_SCALAR_IS_FLOAT
-//#define SK_SCALAR_IS_FIXED
-
-
-/*  Somewhat independent of how SkScalar is implemented, Skia also wants to know
-    if it can use floats at all. Naturally, if SK_SCALAR_IS_FLOAT is defined,
-    then so muse SK_CAN_USE_FLOAT, but if scalars are fixed, SK_CAN_USE_FLOAT
-    can go either way.
- */
-//#define SK_CAN_USE_FLOAT
-
-/*  For some performance-critical scalar operations, skia will optionally work
-    around the standard float operators if it knows that the CPU does not have
-    native support for floats. If your environment uses software floating point,
-    define this flag.
- */
-//#define SK_SOFTWARE_FLOAT
-
-
-/*  Skia has lots of debug-only code. Often this is just null checks or other
-    parameter checking, but sometimes it can be quite intrusive (e.g. check that
-    each 32bit pixel is in premultiplied form). This code can be very useful
-    during development, but will slow things down in a shipping product.
-
-    By default, these mutually exclusive flags are defined in SkPreConfig.h,
-    based on the presence or absence of NDEBUG, but that decision can be changed
-    here.
- */
-//#define SK_DEBUG
-//#define SK_RELEASE
-
-
-/*  If, in debugging mode, Skia needs to stop (presumably to invoke a debugger)
-    it will call SK_CRASH(). If this is not defined it, it is defined in
-    SkPostConfig.h to write to an illegal address
- */
-//#define SK_CRASH() *(int *)(uintptr_t)0 = 0
-
-
-/*  preconfig will have attempted to determine the endianness of the system,
-    but you can change these mutually exclusive flags here.
- */
-//#define SK_CPU_BENDIAN
-//#define SK_CPU_LENDIAN
-
-
-/*  Some compilers don't support long long for 64bit integers. If yours does
-    not, define this to the appropriate type.
- */
-//#define SkLONGLONG int64_t
-
-
-/*  Some envorinments do not suport writable globals (eek!). If yours does not,
-    define this flag.
- */
-//#define SK_USE_RUNTIME_GLOBALS
-
-
-/*  To write debug messages to a console, skia will call SkDebugf(...) following
-    printf conventions (e.g. const char* format, ...). If you want to redirect
-    this to something other than printf, define yours here
- */
-//#define SkDebugf(...)  MyFunction(__VA_ARGS__)
-
-/*  To enable additional blitters (and fontscaler code) to support separate
-    alpha channels for R G B channels, define SK_SUPPORT_LCDTEXT
- */
-//#define SK_SUPPORT_LCDTEXT
-
-/*  If zlib is available and you want to support the flate compression
-    algorithm (used in PDF generation), define SK_ZLIB_INCLUDE to be the
-    include path.
- */
-//#define SK_ZLIB_INCLUDE <zlib.h>
-
-/*  Define this to remove dimension checks on bitmaps. Not all blits will be
-    correct yet, so this is mostly for debugging the implementation.
- */
-//#define SK_ALLOW_OVER_32K_BITMAPS
-
-/*  If SK_DEBUG is defined, then you can optionally define SK_SUPPORT_UNITTEST
-    which will run additional self-tests at startup. These can take a long time,
-    so this flag is optional.
- */
-#ifdef SK_DEBUG
-//#define SK_SUPPORT_UNITTEST
-#endif
-
-#endif
-
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 64a2a5b..1d21a2f 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -401,6 +401,13 @@ public:
     */
     void* getAddr(int x, int y) const;
 
+    /** Return the SkColor of the specified pixel.  In most cases this will
+        require un-premultiplying the color.  Alpha only configs (A1 and A8)
+        return black with the appropriate alpha set.  The value is undefined
+        for kNone_Config or if x or y are out of bounds.
+    */
+    SkColor getColor(int x, int y) const;
+
     /** Returns the address of the pixel specified by x,y for 32bit pixels.
     */
     inline uint32_t* getAddr32(int x, int y) const;
@@ -461,18 +468,18 @@ public:
     */
     int extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy);
 
-    void extractAlpha(SkBitmap* dst) const {
-        this->extractAlpha(dst, NULL, NULL, NULL);
+    bool extractAlpha(SkBitmap* dst) const {
+        return this->extractAlpha(dst, NULL, NULL, NULL);
     }
 
-    void extractAlpha(SkBitmap* dst, const SkPaint* paint,
+    bool extractAlpha(SkBitmap* dst, const SkPaint* paint,
                       SkIPoint* offset) const {
-        this->extractAlpha(dst, paint, NULL, offset);
+        return this->extractAlpha(dst, paint, NULL, offset);
     }
 
     /** Set dst to contain alpha layer of this bitmap. If destination bitmap
         fails to be initialized, e.g. because allocator can't allocate pixels
-        for it, dst will be resetted (zero width and height, no pixels).
+        for it, dst will not be modified and false will be returned.
 
         @param dst The bitmap to be filled with alpha layer
         @param paint The paint to draw with
@@ -483,7 +490,7 @@ public:
                       the returned bitmap so that it visually lines up with the
                       original
     */
-    void extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator,
+    bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator,
                       SkIPoint* offset) const;
 
     void flatten(SkFlattenableWriteBuffer&) const;
diff --git a/include/core/SkBlitRow.h b/include/core/SkBlitRow.h
index 2b652c2..bb8cbc2 100644
--- a/include/core/SkBlitRow.h
+++ b/include/core/SkBlitRow.h
@@ -18,9 +18,9 @@ public:
     /** Function pointer that reads a scanline of src SkPMColors, and writes
         a corresponding scanline of 16bit colors (specific format based on the
         config passed to the Factory.
-     
+
         The x,y params are useful just for dithering
-     
+
         @param alpha A global alpha to be applied to all of the src colors
         @param x The x coordinate of the beginning of the scanline
         @param y THe y coordinate of the scanline
@@ -29,7 +29,7 @@ public:
                          const SkPMColor* SK_RESTRICT src,
                          int count, U8CPU alpha, int x, int y);
 
-   /** Function pointer that blends a single color with a row of 32-bit colors 
+   /** Function pointer that blends a single color with a row of 32-bit colors
        onto a 32-bit destination
    */
    typedef void (*ColorProc)(SkPMColor* dst, const SkPMColor* src, int count,
@@ -56,12 +56,12 @@ public:
                          int count, U8CPU alpha);
 
     static Proc32 Factory32(unsigned flags32);
-    
+
     /** Blend a single color onto a row of S32 pixels, writing the result
         into a row of D32 pixels. src and dst may be the same memory, but
         if they are not, they may not overlap.
      */
-    static void Color32(SkPMColor dst[], const SkPMColor src[], 
+    static void Color32(SkPMColor dst[], const SkPMColor src[],
                         int count, SkPMColor color);
 
     static ColorProc ColorProcFactory();
@@ -84,4 +84,29 @@ private:
     };
 };
 
+/**
+ *  Factory for blitmask procs
+ */
+class SkBlitMask {
+public:
+    /**
+     *  Function pointer that blits the mask into a device (dst) colorized
+     *  by color. The number of pixels to blit is specified by width and height,
+     *  but each scanline is offset by dstRB (rowbytes) and srcRB respectively.
+     */
+    typedef void (*Proc)(void* dst, size_t dstRB, SkBitmap::Config dstConfig,
+                        const uint8_t* mask, size_t maskRB, SkColor color,
+                        int width, int height);
+
+    /* Public entry-point to return a blitmask function ptr
+     */
+    static Proc Factory(SkBitmap::Config dstConfig, SkColor color);
+
+    /* return either platform specific optimized blitmask function-ptr,
+     * or NULL if no optimized
+     */
+    static Proc PlatformProcs(SkBitmap::Config dstConfig, SkColor color);
+};
+
+
 #endif
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 103507c..5aecacb 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -626,6 +626,7 @@ public:
                                 const SkPath& path, const SkMatrix* matrix,
                                 const SkPaint& paint);
 
+#ifdef ANDROID
     /** Draw the text on path, with each character/glyph origin specified by the pos[]
         array. The origin is interpreted by the Align setting in the paint.
         @param text The text to be drawn
@@ -638,6 +639,7 @@ public:
     void drawPosTextOnPath(const void* text, size_t byteLength,
                            const SkPoint pos[], const SkPaint& paint,
                            const SkPath& path, const SkMatrix* matrix);
+#endif
 
     /** Draw the picture into this canvas. This method effective brackets the
         playback of the picture's draw calls with save/restore, so the state
@@ -740,6 +742,12 @@ public:
     */
     const SkRegion& getTotalClip() const;
 
+    /**
+     *  Return the current clipstack. This mirrors the result in getTotalClip()
+     *  but is represented as a stack of geometric clips + region-ops.
+     */
+    const SkClipStack& getTotalClipStack() const;
+
     void setExternalMatrix(const SkMatrix* = NULL);
 
     ///////////////////////////////////////////////////////////////////////////
@@ -801,7 +809,8 @@ private:
     SkDevice*   fLastDeviceToGainFocus;
     SkDeviceFactory* fDeviceFactory;
 
-    void prepareForDeviceDraw(SkDevice*, const SkMatrix&, const SkRegion&);
+    void prepareForDeviceDraw(SkDevice*, const SkMatrix&, const SkRegion&,
+                              const SkClipStack& clipStack);
 
     bool fDeviceCMDirty;            // cleared by updateDeviceCMCache()
     void updateDeviceCMCache();
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index fb94155..db42e4d 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -29,6 +29,11 @@ public:
 
     class B2FIter {
     public:
+        /**
+         * Creates an uninitialized iterator. Must be reset()
+         */
+        B2FIter();
+
         B2FIter(const SkClipStack& stack);
 
         struct Clip {
@@ -48,6 +53,11 @@ public:
          */
         const Clip* next();
 
+        /**
+         * Restarts the iterator on a clip stack.
+         */
+        void reset(const SkClipStack& stack);
+
     private:
         Clip             fClip;
         SkDeque::F2BIter fIter;
diff --git a/include/core/SkColorShader.h b/include/core/SkColorShader.h
index 44a6148..f7251ff 100644
--- a/include/core/SkColorShader.h
+++ b/include/core/SkColorShader.h
@@ -47,17 +47,20 @@ public:
     virtual void shadeSpan16(int x, int y, uint16_t span[], int count);
     virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count);
 
-    virtual BitmapType asABitmap(SkBitmap* outTexture, 
+    virtual BitmapType asABitmap(SkBitmap* outTexture,
                                  SkMatrix* outMatrix,
-                                 TileMode xy[2], 
-                                 SkScalar* twoPointRadialParams);
+                                 TileMode xy[2],
+                                 SkScalar* twoPointRadialParams) const;
+
+    virtual GradientType asAGradient(GradientInfo* info) const;
+
 protected:
     SkColorShader(SkFlattenableReadBuffer& );
     virtual void flatten(SkFlattenableWriteBuffer& );
     virtual Factory getFactory() { return CreateProc; }
 private:
-    static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { 
-        return SkNEW_ARGS(SkColorShader, (buffer)); 
+    static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
+        return SkNEW_ARGS(SkColorShader, (buffer));
     }
     SkColor     fColor;         // ignored if fInheritColor is true
     SkPMColor   fPMColor;       // cached after setContext()
@@ -66,7 +69,7 @@ private:
     SkBool8     fInheritColor;
 
     // deferred allocation, used for asABitmap()
-    SkPixelRef* fAsABitmapPixelRef;
+    mutable SkPixelRef* fAsABitmapPixelRef;
 
     typedef SkShader INHERITED;
 };
diff --git a/include/core/SkDeque.h b/include/core/SkDeque.h
index 99c8dd4..92d5153 100644
--- a/include/core/SkDeque.h
+++ b/include/core/SkDeque.h
@@ -52,9 +52,16 @@ private:
 public:
     class F2BIter {
     public:
+        /**
+         * Creates an uninitialized iterator. Must be reset()
+         */
+        F2BIter();
+
         F2BIter(const SkDeque& d);
         void* next();
 
+        void reset(const SkDeque& d);
+
     private:
         SkDeque::Head*  fHead;
         char*           fPos;
diff --git a/include/core/SkDevice.h b/include/core/SkDevice.h
index 7791f34..55d823b 100644
--- a/include/core/SkDevice.h
+++ b/include/core/SkDevice.h
@@ -81,6 +81,13 @@ public:
     /** Return the height of the device (in pixels).
     */
     virtual int height() const { return fBitmap.height(); }
+
+    /**
+     *  Return the device's origin: its offset in device coordinates from
+     *  the default origin in its canvas' matrix/clip
+     */
+    const SkIPoint& getOrigin() const { return fOrigin; }
+
     /** Return the bitmap config of the device's pixels
     */
     SkBitmap::Config config() const { return fBitmap.getConfig(); }
@@ -141,7 +148,8 @@ public:
     /** Called when this device gains focus (i.e becomes the current device
         for drawing).
     */
-    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&) {}
+    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
+                           const SkClipStack&) {}
 
     /** Causes any deferred drawing to the device to be completed.
      */
@@ -189,9 +197,11 @@ public:
     virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
                                 const SkPath& path, const SkMatrix* matrix,
                                 const SkPaint& paint);
+#ifdef ANDROID
     virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
                                    const SkPoint pos[], const SkPaint& paint,
                                    const SkPath& path, const SkMatrix* matrix);
+#endif
     virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
                               const SkPoint verts[], const SkPoint texs[],
                               const SkColor colors[], SkXfermode* xmode,
@@ -219,9 +229,14 @@ protected:
     }
 
 private:
+    friend class SkCanvas;
+    // just called by SkCanvas when built as a layer
+    void setOrigin(int x, int y) { fOrigin.set(x, y); }
+
     SkCanvas*   fCanvas;
     SkBitmap    fBitmap;
     SkRefDict   fRefDict;
+    SkIPoint    fOrigin;
 };
 
 #endif
diff --git a/include/core/SkDraw.h b/include/core/SkDraw.h
index fb2f292..99ab342 100644
--- a/include/core/SkDraw.h
+++ b/include/core/SkDraw.h
@@ -26,6 +26,7 @@
 #include "SkAutoKern.h"
 
 class SkBounder;
+class SkClipStack;
 class SkDevice;
 class SkPath;
 class SkRegion;
@@ -54,15 +55,17 @@ public:
                         int scalarsPerPosition, const SkPaint& paint) const;
     void    drawTextOnPath(const char text[], size_t byteLength,
                         const SkPath&, const SkMatrix*, const SkPaint&) const;
+#ifdef ANDROID
     void    drawPosTextOnPath(const char text[], size_t byteLength,
                               const SkPoint pos[], const SkPaint& paint,
                               const SkPath& path, const SkMatrix* matrix) const;
+#endif
     void    drawVertices(SkCanvas::VertexMode mode, int count,
                          const SkPoint vertices[], const SkPoint textures[],
                          const SkColor colors[], SkXfermode* xmode,
                          const uint16_t indices[], int ptCount,
                          const SkPaint& paint) const;
-        
+
     void drawPath(const SkPath& src, const SkPaint& paint) const {
         this->drawPath(src, paint, NULL, false);
     }
@@ -87,6 +90,7 @@ public:
     const SkMatrix* fMatrix;        // required
     const SkRegion* fClip;          // required
 
+    const SkClipStack* fClipStack;  // optional
     SkDevice*       fDevice;        // optional
     SkBounder*      fBounder;       // optional
     SkDrawProcs*    fProcs;         // optional
diff --git a/include/core/SkFontHost.h b/include/core/SkFontHost.h
index d70ba65..3c69251 100644
--- a/include/core/SkFontHost.h
+++ b/include/core/SkFontHost.h
@@ -279,6 +279,7 @@ public:
     static void SetSubpixelOrder(LCDOrder order);
     static LCDOrder GetSubpixelOrder();
 
+#ifdef ANDROID
     ///////////////////////////////////////////////////////////////////////////
 
     /**
@@ -288,6 +289,7 @@ public:
      * @return the number of font units per em or 0 on error.
      */
     static uint32_t GetUnitsPerEm(SkFontID fontID);
+#endif
 };
 
 #endif
diff --git a/include/core/SkMask.h b/include/core/SkMask.h
index 58a2493..4d48376 100644
--- a/include/core/SkMask.h
+++ b/include/core/SkMask.h
@@ -47,6 +47,7 @@ struct SkMask {
         kHorizontalLCD_Format,  //!< 4 bytes/pixel: a/r/g/b
         kVerticalLCD_Format,    //!< 4 bytes/pixel: a/r/g/b
         kARGB32_Format,         //!< SkPMColor
+        kLCD16_Format           //!< 565 alpha for r/g/b
     };
 
     enum {
@@ -96,6 +97,19 @@ struct SkMask {
         return fImage + x - fBounds.fLeft + (y - fBounds.fTop) * fRowBytes;
     }
 
+    /**
+     *  Return the address of the specified 16bit mask. In the debug build,
+     *  this asserts that the mask's format is kLCD16_Format, and that (x,y)
+     *  are contained in the mask's fBounds.
+     */
+    uint16_t* getAddrLCD16(int x, int y) const {
+        SkASSERT(kLCD16_Format == fFormat);
+        SkASSERT(fBounds.contains(x, y));
+        SkASSERT(fImage != NULL);
+        uint16_t* row = (uint16_t*)(fImage + (y - fBounds.fTop) * fRowBytes);
+        return row + (x - fBounds.fLeft);
+    }
+
     /** Return an address into the 32-bit plane of an LCD or VerticalLCD mask
         for the given position.
     */
@@ -120,7 +134,7 @@ struct SkMask {
 
     static uint8_t* AllocImage(size_t bytes);
     static void FreeImage(void* image);
-    
+
     enum CreateMode {
         kJustComputeBounds_CreateMode,      //!< compute bounds and return
         kJustRenderImage_CreateMode,        //!< render into preallocate mask
@@ -128,7 +142,8 @@ struct SkMask {
     };
 
     static bool FormatIsLCD(Format fm) {
-        return kHorizontalLCD_Format == fm || kVerticalLCD_Format == fm;
+        return kHorizontalLCD_Format == fm || kVerticalLCD_Format == fm ||
+               kLCD16_Format == fm;
     }
 };
 
diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h
index c0259af..177ecec 100644
--- a/include/core/SkPixelRef.h
+++ b/include/core/SkPixelRef.h
@@ -39,7 +39,7 @@ class SkGpuTexture;
 class SkPixelRef : public SkRefCnt {
 public:
     explicit SkPixelRef(SkMutex* mutex = NULL);
-    
+
     /** Return the pixel memory returned from lockPixels, or null if the
         lockCount is 0.
     */
@@ -63,13 +63,13 @@ public:
         memory (if the subclass implements caching/deferred-decoding.)
     */
     void unlockPixels();
-    
+
     /** Returns a non-zero, unique value corresponding to the pixels in this
         pixelref. Each time the pixels are changed (and notifyPixelsChanged is
         called), a different generation ID will be returned.
     */
     uint32_t getGenerationID() const;
-    
+
     /** Call this if you have changed the contents of the pixels. This will in-
         turn cause a different generation ID value to be returned from
         getGenerationID().
@@ -80,7 +80,7 @@ public:
         contents of its pixels will not change for the lifetime of the pixelref.
     */
     bool isImmutable() const { return fIsImmutable; }
-    
+
     /** Marks this pixelref is immutable, meaning that the contents of its
         pixels will not change for the lifetime of the pixelref. This state can
         be set on a pixelref, but it cannot be cleared once it is set.
@@ -97,13 +97,13 @@ public:
     void setURI(const char uri[]) {
         fURI.set(uri);
     }
-    
+
     /** Copy a URI string to this pixelref
      */
     void setURI(const char uri[], size_t len) {
         fURI.set(uri, len);
     }
-    
+
     /** Assign a URI string to this pixelref.
     */
     void setURI(const SkString& uri) { fURI = uri; }
@@ -119,22 +119,26 @@ public:
     virtual Factory getFactory() const { return NULL; }
     virtual void flatten(SkFlattenableWriteBuffer&) const;
 
-    /** Acquire a "global" ref on this object.
-    * The default implementation just calls ref(), but subclasses can override
-    * this method to implement additional behavior.
-    */
+#ifdef ANDROID
+    /**
+     *  Acquire a "global" ref on this object.
+     *  The default implementation just calls ref(), but subclasses can override
+     *  this method to implement additional behavior.
+     */
     virtual void globalRef(void* data=NULL);
 
-    /** Release a "global" ref on this object.
-    * The default implementation just calls unref(), but subclasses can override
-    * this method to implement additional behavior.
-    */
+    /**
+     *  Release a "global" ref on this object.
+     *  The default implementation just calls unref(), but subclasses can override
+     *  this method to implement additional behavior.
+     */
     virtual void globalUnref();
+#endif
 
     static Factory NameToFactory(const char name[]);
     static const char* FactoryToName(Factory);
     static void Register(const char name[], Factory);
-    
+
     class Registrar {
     public:
         Registrar(const char name[], Factory factory) {
@@ -165,9 +169,9 @@ private:
     void*           fPixels;
     SkColorTable*   fColorTable;    // we do not track ownership, subclass does
     int             fLockCount;
-    
+
     mutable uint32_t fGenerationID;
-    
+
     SkString    fURI;
 
     // can go from false to true, but never from true to false
diff --git a/include/core/SkPoint.h b/include/core/SkPoint.h
index bdb30d9..79ca58c 100644
--- a/include/core/SkPoint.h
+++ b/include/core/SkPoint.h
@@ -26,13 +26,28 @@
 */
 struct SkIPoint {
     int32_t fX, fY;
-    
+
     static SkIPoint Make(int32_t x, int32_t y) {
         SkIPoint pt;
         pt.set(x, y);
         return pt;
     }
 
+    int32_t x() const { return fX; }
+    int32_t y() const { return fY; }
+    void setX(int32_t x) { fX = x; }
+    void setY(int32_t y) { fY = y; }
+
+    /**
+     *  Returns true iff fX and fY are both zero.
+     */
+    bool isZero() const { return (fX | fY) == 0; }
+
+    /**
+     *  Set both fX and fY to zero. Same as set(0, 0)
+     */
+    void setZero() { fX = fY = 0; }
+
     /** Set the x and y values of the point. */
     void set(int32_t x, int32_t y) { fX = x; fY = y; }
 
@@ -55,11 +70,11 @@ struct SkIPoint {
         the point
     */
     void rotateCCW() { this->rotateCCW(this); }
-    
+
     /** Negate the X and Y coordinates of the point.
     */
     void negate() { fX = -fX; fY = -fY; }
-    
+
     /** Return a new point whose X and Y coordinates are the negative of the
         original point's
     */
@@ -75,7 +90,7 @@ struct SkIPoint {
         fX += v.fX;
         fY += v.fY;
     }
-    
+
     /** Subtract v's coordinates from this point's */
     void operator-=(const SkIPoint& v) {
         fX -= v.fX;
@@ -90,7 +105,7 @@ struct SkIPoint {
     friend bool operator==(const SkIPoint& a, const SkIPoint& b) {
         return a.fX == b.fX && a.fY == b.fY;
     }
-    
+
     friend bool operator!=(const SkIPoint& a, const SkIPoint& b) {
         return a.fX != b.fX || a.fY != b.fY;
     }
@@ -111,7 +126,7 @@ struct SkIPoint {
         v.set(a.fX + b.fX, a.fY + b.fY);
         return v;
     }
-    
+
     /** Returns the dot product of a and b, treating them as 2D vectors
     */
     static int32_t DotProduct(const SkIPoint& a, const SkIPoint& b) {
@@ -133,10 +148,10 @@ struct SkPoint {
         pt.set(x, y);
         return pt;
     }
-    
+
     /** Set the point's X and Y coordinates */
     void set(SkScalar x, SkScalar y) { fX = x; fY = y; }
-    
+
     /** Set the point's X and Y coordinates by automatically promoting (x,y) to
         SkScalar values.
     */
@@ -144,7 +159,7 @@ struct SkPoint {
         fX = SkIntToScalar(x);
         fY = SkIntToScalar(y);
     }
-    
+
     /** Set the point's X and Y coordinates by automatically promoting p's
         coordinates to SkScalar values.
     */
@@ -163,19 +178,19 @@ struct SkPoint {
         return true.
     */
     bool normalize();
-    
+
     /** Set the point (vector) to be unit-length in the same direction as the
         x,y params. If the vector (x,y) has a degenerate length (i.e. nearly 0)
         then return false and do nothing, otherwise return true.
     */
     bool setNormalize(SkScalar x, SkScalar y);
-    
+
     /** Scale the point (vector) to have the specified length, and return that
         length. If the original length is degenerately small (nearly zero),
         do nothing and return false, otherwise return true.
     */
     bool setLength(SkScalar length);
-    
+
     /** Set the point (vector) to have the specified length in the same
      direction as (x,y). If the vector (x,y) has a degenerate length
      (i.e. nearly 0) then return false and do nothing, otherwise return true.
@@ -186,7 +201,7 @@ struct SkPoint {
         It is legal for dst == this.
     */
     void scale(SkScalar scale, SkPoint* dst) const;
-    
+
     /** Scale the point's coordinates by scale, writing the answer back into
         the point.
     */
@@ -196,29 +211,29 @@ struct SkPoint {
         It is legal for dst == this.
     */
     void rotateCW(SkPoint* dst) const;
-    
+
     /** Rotate the point clockwise by 90 degrees, writing the answer back into
         the point.
     */
     void rotateCW() { this->rotateCW(this); }
-    
+
     /** Rotate the point counter-clockwise by 90 degrees, writing the answer
         into dst. It is legal for dst == this.
     */
     void rotateCCW(SkPoint* dst) const;
-    
+
     /** Rotate the point counter-clockwise by 90 degrees, writing the answer
         back into the point.
     */
     void rotateCCW() { this->rotateCCW(this); }
-    
+
     /** Negate the point's coordinates
     */
     void negate() {
         fX = -fX;
         fY = -fY;
     }
-    
+
     /** Returns a new point whose coordinates are the negative of the point's
     */
     SkPoint operator-() const {
@@ -234,7 +249,7 @@ struct SkPoint {
         fX += v.fX;
         fY += v.fY;
     }
-    
+
     /** Subtract v's coordinates from the point's
     */
     void operator-=(const SkPoint& v) {
@@ -249,7 +264,7 @@ struct SkPoint {
     friend bool operator==(const SkPoint& a, const SkPoint& b) {
         return a.fX == b.fX && a.fY == b.fY;
     }
-    
+
     friend bool operator!=(const SkPoint& a, const SkPoint& b) {
         return a.fX != b.fX || a.fY != b.fY;
     }
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index b6caad5..114d1f9 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -95,6 +95,13 @@ struct SkIRect {
         fBottom = bottom;
     }
 
+    void setXYWH(int32_t x, int32_t y, int32_t width, int32_t height) {
+        fLeft = x;
+        fTop = y;
+        fRight = x + width;
+        fBottom = y + height;
+    }
+    
     /** Offset set the rectangle by adding dx to its left and right,
         and adding dy to its top and bottom.
     */
@@ -348,6 +355,13 @@ struct SkRect {
     */
     void set(const SkPoint pts[], int count);
 
+    void setXYWH(SkScalar x, SkScalar y, SkScalar width, SkScalar height) {
+        fLeft = x;
+        fTop = y;
+        fRight = x + width;
+        fBottom = y + height;
+    }
+
     /** Offset set the rectangle by adding dx to its left and right,
         and adding dy to its top and bottom.
     */
diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index f109ead..b9b2c98 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -67,36 +67,35 @@ private:
     mutable int32_t fRefCnt;
 };
 
-/** \class SkAutoUnref
-
-    SkAutoUnref is a stack-helper class that will automatically call unref() on
-    the object it points to when the SkAutoUnref object goes out of scope.
-    If obj is null, do nothing.
-*/
-class SkAutoUnref : SkNoncopyable {
+/**
+ *  Utility class that simply unref's its argument in the destructor.
+ */
+template <typename T> class SkAutoTUnref : SkNoncopyable {
 public:
-    SkAutoUnref(SkRefCnt* obj) : fObj(obj) {}
-    ~SkAutoUnref();
-
-    SkRefCnt*   get() const { return fObj; }
-
-    /** If the hosted object is null, do nothing and return false, else call
-        ref() on it and return true
-    */
-    bool        ref();
+    SkAutoTUnref(T* obj) : fObj(obj) {}
+    ~SkAutoTUnref() { SkSafeUnref(fObj); }
 
-    /** If the hosted object is null, do nothing and return false, else call
-        unref() on it, set its reference to null, and return true
-    */
-    bool        unref();
+    T* get() const { return fObj; }
 
-    /** If the hosted object is null, do nothing and return NULL, else call
-        unref() on it, set its reference to null, and return the object
-    */
-    SkRefCnt*   detach();
+    /**
+     *  Return the hosted object (which may be null), transferring ownership.
+     *  The reference count is not modified, and the internal ptr is set to NULL
+     *  so unref() will not be called in our destructor. A subsequent call to
+     *  detach() will do nothing and return null.
+     */
+    T* detach() {
+        T* obj = fObj;
+        fObj = NULL;
+        return obj;
+    }
 
 private:
-    SkRefCnt*   fObj;
+    T*  fObj;
+};
+
+class SkAutoUnref : public SkAutoTUnref<SkRefCnt> {
+public:
+    SkAutoUnref(SkRefCnt* obj) : SkAutoTUnref<SkRefCnt>(obj) {}
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -148,32 +147,18 @@ public:
         return *this;
     }
 
-    bool operator==(const SkRefPtr& rp) const { return fObj == rp.fObj; }
-    bool operator==(const T* obj) const { return fObj == obj; }
-    bool operator!=(const SkRefPtr& rp) const { return fObj != rp.fObj; }
-    bool operator!=(const T* obj) const { return fObj != obj; }
-
     T* get() const { return fObj; }
     T& operator*() const { return *fObj; }
     T* operator->() const { return fObj; }
-    bool operator!() const { return !fObj; }
 
     typedef T* SkRefPtr::*unspecified_bool_type;
-    operator unspecified_bool_type() const { return fObj ? &SkRefPtr::fObj : NULL; }
+    operator unspecified_bool_type() const {
+        return fObj ? &SkRefPtr::fObj : NULL;
+    }
 
 private:
     T* fObj;
 };
 
-template <typename T>
-inline bool operator==(T* obj, const SkRefPtr<T>& rp) {
-    return obj == rp.get();
-}
-
-template <typename T>
-inline bool operator!=(T* obj, const SkRefPtr<T>& rp) {
-    return obj != rp.get();
-}
-
 #endif
 
diff --git a/include/core/SkRegion.h b/include/core/SkRegion.h
index d8c4e00..7ddf087 100644
--- a/include/core/SkRegion.h
+++ b/include/core/SkRegion.h
@@ -249,9 +249,11 @@ public:
     */
     bool op(const SkRegion& rgna, const SkRegion& rgnb, Op op);
 
+#ifdef ANDROID
     /** Returns a new char* containing the list of rectangles in this region
      */
     char* toString();
+#endif
 
     /** Returns the sequence of rectangles, sorted in Y and X, that make up
         this region.
@@ -264,7 +266,7 @@ public:
         bool rewind();
         // reset the iterator, using the new region
         void reset(const SkRegion&);
-        bool done() { return fDone; }
+        bool done() const { return fDone; }
         void next();
         const SkIRect& rect() const { return fRect; }
         // may return null
diff --git a/include/core/SkScalerContext.h b/include/core/SkScalerContext.h
index 5937819..584b86b 100644
--- a/include/core/SkScalerContext.h
+++ b/include/core/SkScalerContext.h
@@ -53,18 +53,27 @@ struct SkGlyph {
         fMaskFormat     = MASK_FORMAT_UNKNOWN;
     }
 
-    unsigned rowBytes() const {
-        unsigned rb = fWidth;
-        if (SkMask::kBW_Format == fMaskFormat) {
+    /**
+     *  Compute the rowbytes for the specified width and mask-format.
+     */
+    static unsigned ComputeRowBytes(unsigned width, SkMask::Format format) {
+        unsigned rb = width;
+        if (SkMask::kBW_Format == format) {
             rb = (rb + 7) >> 3;
-		} else if (SkMask::kARGB32_Format == fMaskFormat) {
+		} else if (SkMask::kARGB32_Format == format) {
 			rb <<= 2;
+		} else if (SkMask::kLCD16_Format == format) {
+			rb = SkAlign4(rb << 1);
         } else {
             rb = SkAlign4(rb);
         }
         return rb;
     }
 
+    unsigned rowBytes() const {
+        return ComputeRowBytes(fWidth, (SkMask::Format)fMaskFormat);
+    }
+
     bool isJustAdvance() const {
         return MASK_FORMAT_JUST_ADVANCE == fMaskFormat;
     }
@@ -230,7 +239,7 @@ public:
     */
     SkUnichar glyphIDToChar(uint16_t glyphID);
 
-    unsigned    getGlyphCount() const { return this->generateGlyphCount(); }
+    unsigned    getGlyphCount() { return this->generateGlyphCount(); }
     void        getAdvance(SkGlyph*);
     void        getMetrics(SkGlyph*);
     void        getImage(const SkGlyph&);
@@ -245,7 +254,7 @@ protected:
     Rec         fRec;
     unsigned    fBaseGlyphCount;
 
-    virtual unsigned generateGlyphCount() const = 0;
+    virtual unsigned generateGlyphCount() = 0;
     virtual uint16_t generateCharToGlyph(SkUnichar) = 0;
     virtual void generateAdvance(SkGlyph*) = 0;
     virtual void generateMetrics(SkGlyph*) = 0;
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index 1cdbf17..c59cc59 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -80,7 +80,7 @@ public:
             shadeSpan().
          */
         kConstInY32_Flag = 0x08,
-        
+
         /** same as kConstInY32_Flag, but is set if this is true for shadeSpan16
             which may not always be the case, since shadeSpan16 may be
             predithered, which would mean it was not const in Y, even though
@@ -101,7 +101,7 @@ public:
         kHasSpan16_Flag is not set, this value is meaningless.
     */
     virtual uint8_t getSpan16Alpha() const { return fPaintAlpha; }
-    
+
     /** Called once before drawing, with the current paint and
         device matrix. Return true if your shader supports these
         parameters, or false if not. If false is returned, nothing
@@ -144,7 +144,7 @@ public:
     */
     virtual void beginSession();
     virtual void endSession();
-    
+
     /**
      Gives method bitmap should be read to implement a shader.
      Also determines number and interpretation of "extra" parameters returned
@@ -152,34 +152,35 @@ public:
      */
     enum BitmapType {
         kNone_BitmapType,   //<! Shader is not represented as a bitmap
-        kDefault_BitmapType,//<! Access bitmap using local coords transformed 
+        kDefault_BitmapType,//<! Access bitmap using local coords transformed
                             //   by matrix. No extras
-        kRadial_BitmapType, //<! Access bitmap by transforming local coordinates 
-                            //   by the matrix and taking the distance of result 
-                            //   from  (0,0) as bitmap column. Bitmap is 1 pixel 
+        kRadial_BitmapType, //<! Access bitmap by transforming local coordinates
+                            //   by the matrix and taking the distance of result
+                            //   from  (0,0) as bitmap column. Bitmap is 1 pixel
                             //   tall. No extras
-        kSweep_BitmapType,  //<! Access bitmap by transforming local coordinates 
+        kSweep_BitmapType,  //<! Access bitmap by transforming local coordinates
                             //   by the matrix and taking the angle of result
                             //   to (0,0) as bitmap x coord, where angle = 0 is
-                            //   bitmap left edge of bitmap = 2pi is the 
+                            //   bitmap left edge of bitmap = 2pi is the
                             //   right edge. Bitmap is 1 pixel tall. No extras
-        kTwoPointRadial_BitmapType
-                            //<! Matrix transforms to space where (0,0) is 
+        kTwoPointRadial_BitmapType,
+                            //<! Matrix transforms to space where (0,0) is
                             //   the center of the starting circle.  The second
-                            //   circle will be centered (x, 0) where x  may be 
-                            //   0. The post-matrix space is normalized such 
+                            //   circle will be centered (x, 0) where x  may be
+                            //   0. The post-matrix space is normalized such
                             //   that 1 is the second radius - first radius.
                             //   Three extra parameters are returned:
-                            //      0: x-offset of second circle center 
+                            //      0: x-offset of second circle center
                             //         to first.
-                            //      1: radius of first circle in post-matrix 
+                            //      1: radius of first circle in post-matrix
                             //         space
                             //      2: the second radius minus the first radius
-                            //         in pre-transformed space.        
-        
+                            //         in pre-transformed space.
+
+       kLast_BitmapType = kTwoPointRadial_BitmapType
     };
     /** Optional methods for shaders that can pretend to be a bitmap/texture
-        to play along with opengl. Default just returns kNone_BitmapType and 
+        to play along with opengl. Default just returns kNone_BitmapType and
         ignores the out parameters.
 
         @param outTexture if non-NULL will be the bitmap representing the shader
@@ -194,7 +195,60 @@ public:
                                     about the first point.
     */
     virtual BitmapType asABitmap(SkBitmap* outTexture, SkMatrix* outMatrix,
-                                 TileMode xy[2], SkScalar* twoPointRadialParams);
+                                 TileMode xy[2], SkScalar* twoPointRadialParams) const;
+
+    /**
+     *  If the shader subclass can be represented as a gradient, asAGradient
+     *  returns the matching GradientType enum (or kNone_GradientType if it
+     *  cannot). Also, if info is not null, asAGradient populates info with
+     *  the relevant (see below) parameters for the gradient.  fColorCount
+     *  is both an input and output parameter.  On input, it indicates how
+     *  many entries in fColors and fColorOffsets can be used, if they are
+     *  non-NULL.  After asAGradient has run, fColorCount indicates how
+     *  many color-offset pairs there are in the gradient.  If there is
+     *  insufficient space to store all of the color-offset pairs, fColors
+     *  and fColorOffsets will not be altered.  fColorOffsets specifies
+     *  where on the range of 0 to 1 to transition to the given color.
+     *  The meaning of fPoint and fRadius is dependant on the type of gradient.
+     *
+     *  None:
+     *      info is ignored.
+     *  Color:
+     *      fColorOffsets[0] is meaningless.
+     *  Linear:
+     *      fPoint[0] and fPoint[1] are the end-points of the gradient
+     *  Radial:
+     *      fPoint[0] and fRadius[0] are the center and radius
+     *  Radial2:
+     *      fPoint[0] and fRadius[0] are the center and radius of the 1st circle
+     *      fPoint[1] and fRadius[1] are the center and radius of the 2nd circle
+     *  Sweep:
+     *      fPoint[0] is the center of the sweep.
+     */
+
+    enum GradientType {
+        kNone_GradientType,
+        kColor_GradientType,
+        kLinear_GradientType,
+        kRadial_GradientType,
+        kRadial2_GradientType,
+        kSweep_GradientType,
+        kLast_GradientType = kSweep_GradientType
+    };
+
+    struct GradientInfo {
+        int         fColorCount;    //!< In-out parameter, specifies passed size
+                                    //   of fColors/fColorOffsets on input, and
+                                    //   actual number of colors/offsets on
+                                    //   output.
+        SkColor*    fColors;        //!< The colors in the gradient.
+        SkScalar*   fColorOffsets;  //!< The unit offset for color transitions.
+        SkPoint     fPoint[2];      //!< Type specific, see above.
+        SkScalar    fRadius[2];     //!< Type specific, see above.
+        TileMode    fTileMode;      //!< The tile mode used.
+    };
+
+    virtual GradientType asAGradient(GradientInfo* info) const;
 
     //////////////////////////////////////////////////////////////////////////
     //  Factory methods for stock shaders
diff --git a/include/core/SkString.h b/include/core/SkString.h
index 4498bba..eb25e15 100644
--- a/include/core/SkString.h
+++ b/include/core/SkString.h
@@ -30,8 +30,33 @@ int SkStrStartsWithOneOf(const char string[], const char prefixes[]);
 char*   SkStrAppendS32(char buffer[], int32_t);
 #define SkStrAppendS64_MaxSize  20
 char*   SkStrAppendS64(char buffer[], int64_t, int minDigits);
-#define SkStrAppendScalar_MaxSize  11
-char*   SkStrAppendScalar(char buffer[], SkScalar);
+
+/**
+ *  Floats have at most 8 significant digits, so we limit our %g to that.
+ *  However, the total string could be 15 characters: -1.2345678e-005
+ *
+ *  In theory we should only expect up to 2 digits for the exponent, but on
+ *  some platforms we have seen 3 (as in the example above).
+ */
+#define SkStrAppendScalar_MaxSize  15
+
+/**
+ *  Write the scaler in decimal format into buffer, and return a pointer to
+ *  the next char after the last one written. Note: a terminating 0 is not
+ *  written into buffer, which must be at least SkStrAppendScalar_MaxSize.
+ *  Thus if the caller wants to add a 0 at the end, buffer must be at least
+ *  SkStrAppendScalar_MaxSize + 1 bytes large.
+ */
+#ifdef SK_SCALAR_IS_FLOAT
+    #define SkStrAppendScalar SkStrAppendFloat
+#else
+    #define SkStrAppendScalar SkStrAppendFixed
+#endif
+
+#ifdef SK_CAN_USE_FLOAT
+char* SkStrAppendFloat(char buffer[], float);
+#endif
+char* SkStrAppendFixed(char buffer[], SkFixed);
 
 /** \class SkString
 
@@ -127,7 +152,7 @@ public:
         to never fail or throw.
     */
     void    swap(SkString& other);
-    
+
 private:
     struct Rec {
     public:
diff --git a/include/core/SkTypeface.h b/include/core/SkTypeface.h
index 728ba31..f4b9507 100644
--- a/include/core/SkTypeface.h
+++ b/include/core/SkTypeface.h
@@ -58,7 +58,7 @@ public:
     bool isItalic() const { return (fStyle & kItalic) != 0; }
 
     /** Returns true if the typeface is fixed-width
-    */
+     */
     bool isFixedWidth() const { return fIsFixedWidth; }
 
     /** Return a 32bit value for this typeface, unique for the underlying font
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index 8dbd51b..93f054e 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -403,21 +403,70 @@ public:
     }
 };
 
+/**
+ *  Manage an allocated block of memory. If the requested size is <= kSize, then
+ *  the allocation will come from the stack rather than the heap. This object
+ *  is the sole manager of the lifetime of the block, so the caller must not
+ *  call sk_free() or delete on the block.
+ */
 template <size_t kSize> class SkAutoSMalloc : SkNoncopyable {
 public:
-    explicit SkAutoSMalloc(size_t size)
-    {
-        if (size <= kSize)
-            fPtr = fStorage;
-        else
-            fPtr = sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_TEMP);
+    /**
+     *  Creates initially empty storage. get() returns a ptr, but it is to
+     *  a zero-byte allocation. Must call realloc(size) to return an allocated
+     *  block.
+     */
+    SkAutoSMalloc() {
+        fPtr = fStorage;
     }
-    ~SkAutoSMalloc()
-    {
-        if (fPtr != (void*)fStorage)
+
+    /**
+     *  Allocate a block of the specified size. If size <= kSize, then the
+     *  allocation will come from the stack, otherwise it will be dynamically
+     *  allocated.
+     */
+    explicit SkAutoSMalloc(size_t size) {
+        fPtr = fStorage;
+        this->realloc(size);
+    }
+
+    /**
+     *  Free the allocated block (if any). If the block was small enought to
+     *  have been allocated on the stack (size <= kSize) then this does nothing.
+     */
+    ~SkAutoSMalloc() {
+        if (fPtr != (void*)fStorage) {
             sk_free(fPtr);
+        }
     }
+
+    /**
+     *  Return the allocated block. May return non-null even if the block is
+     *  of zero size. Since this may be on the stack or dynamically allocated,
+     *  the caller must not call sk_free() on it, but must rely on SkAutoSMalloc
+     *  to manage it.
+     */
     void* get() const { return fPtr; }
+
+    /**
+     *  Return a new block of the requested size, freeing (as necessary) any
+     *  previously allocated block. As with the constructor, if size <= kSize
+     *  then the return block may be allocated locally, rather than from the
+     *  heap.
+     */
+    void* realloc(size_t size) {
+        if (fPtr != (void*)fStorage) {
+            sk_free(fPtr);
+        }
+
+        if (size <= kSize) {
+            fPtr = fStorage;
+        } else {
+            fPtr = sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_TEMP);
+        }
+        return fPtr;
+    }
+
 private:
     void*       fPtr;
     uint32_t    fStorage[(kSize + 3) >> 2];
diff --git a/include/core/SkUserConfig.h b/include/core/SkUserConfig.h
index a72aa1a..2140a15 100644
--- a/include/core/SkUserConfig.h
+++ b/include/core/SkUserConfig.h
@@ -18,18 +18,18 @@
 #define SkUserConfig_DEFINED
 
 /*  SkTypes.h, the root of the public header files, does the following trick:
- 
+
     #include "SkPreConfig.h"
     #include "SkUserConfig.h"
     #include "SkPostConfig.h"
- 
+
     SkPreConfig.h runs first, and it is responsible for initializing certain
     skia defines.
- 
+
     SkPostConfig.h runs last, and its job is to just check that the final
     defines are consistent (i.e. that we don't have mutually conflicting
     defines).
- 
+
     SkUserConfig.h (this file) runs in the middle. It gets to change or augment
     the list of flags initially set in preconfig, and then postconfig checks
     that everything still makes sense.
@@ -85,7 +85,7 @@
     parameter checking, but sometimes it can be quite intrusive (e.g. check that
     each 32bit pixel is in premultiplied form). This code can be very useful
     during development, but will slow things down in a shipping product.
- 
+
     By default, these mutually exclusive flags are defined in SkPreConfig.h,
     based on the presence or absence of NDEBUG, but that decision can be changed
     here.
@@ -134,6 +134,26 @@
 void Android_SkDebugf(const char* file, int line, 
                       const char* function, const char* format, ...);
 
+/*  To enable additional blitters (and fontscaler code) to support separate
+    alpha channels for R G B channels, define SK_SUPPORT_LCDTEXT
+ */
+//#define SK_SUPPORT_LCDTEXT
+
+/*  If zlib is available and you want to support the flate compression
+    algorithm (used in PDF generation), define SK_ZLIB_INCLUDE to be the
+    include path.
+ */
+//#define SK_ZLIB_INCLUDE <zlib.h>
+
+/*  Define this to allow PDF scalars above 32k.  The PDF/A spec doesn't allow
+    them, but modern PDF interpreters should handle them just fine.
+ */
+//#define SK_ALLOW_LARGE_PDF_SCALARS
+
+/*  Define this to remove dimension checks on bitmaps. Not all blits will be
+    correct yet, so this is mostly for debugging the implementation.
+ */
+//#define SK_ALLOW_OVER_32K_BITMAPS
 
 /*  If SK_DEBUG is defined, then you can optionally define SK_SUPPORT_UNITTEST
     which will run additional self-tests at startup. These can take a long time,
diff --git a/include/effects/SkPorterDuff.h b/include/effects/SkPorterDuff.h
index 4d7fb31..54f81ea 100644
--- a/include/effects/SkPorterDuff.h
+++ b/include/effects/SkPorterDuff.h
@@ -52,7 +52,9 @@ public:
         kMultiply_Mode, //!< [Sa * Da, Sc * Dc]
         kScreen_Mode,   //!< [Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]
         kAdd_Mode,      //!< Saturate(S + D)
+#ifdef ANDROID
         kOverlay_Mode,
+#endif
 
         kModeCount
     };
diff --git a/include/gpu/SkGpuCanvas.h b/include/gpu/SkGpuCanvas.h
new file mode 100644
index 0000000..57a4b1b
--- /dev/null
+++ b/include/gpu/SkGpuCanvas.h
@@ -0,0 +1,68 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGpuCanvas_DEFINED
+#define SkGpuCanvas_DEFINED
+
+#include "SkCanvas.h"
+
+class GrContext;
+class GrRenderTarget;
+
+/**
+ *  Subclass of canvas that creates devices compatible with the GrContext pass
+ *  to the canvas' constructor.
+ */
+class SkGpuCanvas : public SkCanvas {
+public:
+    /**
+     *  The GrContext object is reference counted. When passed to our
+     *  constructor, its reference count is incremented. In our destructor, the
+     *  GrGpu's reference count will be decremented.
+     *  GrRenderTarget represents the rendering destination in the underlying
+     *  3D API. Its reference count is incremented in the constructor and
+     *  decremented in the destructor.
+     *  SkGpuDevice::Current3DApiRenderTarget() can be passed as a special
+     *  value that will cause the factory to create a render target object
+     *  that reflects the state of the underlying 3D API at the time of
+     *  construction.
+     */
+    explicit SkGpuCanvas(GrContext*, GrRenderTarget*);
+    virtual ~SkGpuCanvas();
+
+    /**
+     *  Override from SkCanvas. Returns true, and if not-null, sets size to
+     *  be the width/height of our viewport.
+     */
+    virtual bool getViewport(SkIPoint* size) const;
+
+#if 0
+    virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
+                          SaveFlags flags = kARGB_ClipLayer_SaveFlag) {
+        return this->save(flags);
+    }
+#endif
+
+private:
+    GrContext* fContext;
+
+    typedef SkCanvas INHERITED;
+};
+
+#endif
+
+
diff --git a/include/gpu/SkGpuDevice.h b/include/gpu/SkGpuDevice.h
new file mode 100644
index 0000000..3fed99a
--- /dev/null
+++ b/include/gpu/SkGpuDevice.h
@@ -0,0 +1,184 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGpuDevice_DEFINED
+#define SkGpuDevice_DEFINED
+
+#include "SkGr.h"
+#include "SkDevice.h"
+#include "SkRegion.h"
+
+struct SkDrawProcs;
+struct GrSkDrawProcs;
+class GrTextContext;
+
+/**
+ *  Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
+ *  canvas.
+ */
+class SkGpuDevice : public SkDevice {
+public:
+    /**
+     * The SkGpuDevice will render to the GrRenderTarget, or if the paremeter is
+     * null it will create its own render target and manage that target's
+     * lifetime.
+     */
+    SkGpuDevice(GrContext*,
+                const SkBitmap& bitmap,
+                GrRenderTarget* renderTargetOrNull);
+
+    /**
+     * Magic value that can be passed to constructor. Causes
+     * the device to infer rendertarget from underlying 3D API (e.g. GL or D3D).
+     * This isn't a valid pointer, don't attempt to dereference.
+     */
+    static GrRenderTarget* Current3DApiRenderTarget();
+
+    virtual ~SkGpuDevice();
+
+    GrContext* context() const { return fContext; }
+
+    /**
+     *  If this device was built for rendering as a layer (i.e. offscreen),
+     *  then this will return the platform-specific handle to that GPU resource.
+     *  For example, in OpenGL, this will return the FBO's texture ID.
+     *  If this device was not built for rendering as a layer, then 0
+     *  is returned.
+     */
+    intptr_t getLayerTextureHandle() const;
+
+    // call to set the clip to the specified rect
+    void scissor(const SkIRect&);
+
+    /**
+     *  Override from SkGpuDevice, so we can set our FBO to be the render target
+     *  The canvas parameter must be a SkGpuCanvas
+     */
+    virtual void gainFocus(SkCanvas*, const SkMatrix&, const SkRegion&,
+                           const SkClipStack& clipStack);
+
+    virtual SkGpuTexture* accessTexture() { return (SkGpuTexture*)fTexture; }
+
+    // overrides from SkDevice
+
+    virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
+    virtual void writePixels(const SkBitmap& bitmap, int x, int y);
+
+    virtual void setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
+                               const SkClipStack&);
+
+    virtual void drawPaint(const SkDraw&, const SkPaint& paint);
+    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
+                            const SkPoint[], const SkPaint& paint);
+    virtual void drawRect(const SkDraw&, const SkRect& r,
+                          const SkPaint& paint);
+    virtual void drawPath(const SkDraw&, const SkPath& path,
+                          const SkPaint& paint, const SkMatrix* prePathMatrix,
+                          bool pathIsMutable);
+    virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
+                            const SkIRect* srcRectOrNull,
+                            const SkMatrix& matrix, const SkPaint& paint);
+    virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
+                            int x, int y, const SkPaint& paint);
+    virtual void drawText(const SkDraw&, const void* text, size_t len,
+                          SkScalar x, SkScalar y, const SkPaint& paint);
+    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
+                             const SkScalar pos[], SkScalar constY,
+                             int scalarsPerPos, const SkPaint& paint);
+    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
+                                const SkPath& path, const SkMatrix* matrix,
+                                const SkPaint& paint);
+    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
+                              const SkPoint verts[], const SkPoint texs[],
+                              const SkColor colors[], SkXfermode* xmode,
+                              const uint16_t indices[], int indexCount,
+                              const SkPaint& paint);
+    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
+                            const SkPaint&);
+
+    virtual void flush() { fContext->flush(false); }
+
+    /**
+     * Make's this device's rendertarget current in the underlying 3D API.
+     * Also implicitly flushes.
+     */
+    virtual void makeRenderTargetCurrent();
+
+protected:
+    class TexCache;
+    TexCache* lockCachedTexture(const SkBitmap& bitmap,
+                                const GrSamplerState& sampler,
+                                GrTexture** texture,
+                                bool forDeviceRenderTarget = false);
+    void unlockCachedTexture(TexCache*);
+
+    class SkAutoCachedTexture {
+    public:
+        SkAutoCachedTexture();
+        SkAutoCachedTexture(SkGpuDevice* device,
+                            const SkBitmap& bitmap,
+                            const GrSamplerState& sampler,
+                            GrTexture** texture);
+        ~SkAutoCachedTexture();
+
+        GrTexture* set(SkGpuDevice*, const SkBitmap&, const GrSamplerState&);
+
+    private:
+        SkGpuDevice*    fDevice;
+        TexCache*       fTex;
+    };
+    friend class SkAutoTexCache;
+
+private:
+    GrContext*      fContext;
+
+    GrSkDrawProcs*  fDrawProcs;
+
+    // state for our offscreen render-target
+    TexCache*       fCache;
+    GrTexture*      fTexture;
+    GrRenderTarget* fRenderTarget;
+    bool            fNeedClear;
+    bool            fNeedPrepareRenderTarget;
+
+    // doesn't set the texture/sampler/matrix state
+    // caller needs to null out GrPaint's texture if
+    // non-textured drawing is desired.
+    bool skPaint2GrPaintNoShader(const SkPaint& skPaint,
+                                 bool justAlpha,
+                                 GrPaint* grPaint);
+
+    // uses the SkShader to setup paint, act used to
+    // hold lock on cached texture and free it when
+    // destroyed.
+    bool skPaint2GrPaintShader(const SkPaint& skPaint,
+                               SkAutoCachedTexture* act,
+                               const SkMatrix& ctm,
+                               GrPaint* grPaint);
+
+    SkDrawProcs* initDrawForText(GrTextContext*);
+    bool bindDeviceAsTexture(GrPaint* paint);
+
+    void prepareRenderTarget(const SkDraw&);
+    void internalDrawBitmap(const SkDraw&, const SkBitmap&,
+                            const SkIRect&, const SkMatrix&, GrPaint* grPaint);
+
+    typedef SkDevice INHERITED;
+};
+
+#endif
+
diff --git a/include/gpu/SkGpuDeviceFactory.h b/include/gpu/SkGpuDeviceFactory.h
new file mode 100644
index 0000000..5dcba6a
--- /dev/null
+++ b/include/gpu/SkGpuDeviceFactory.h
@@ -0,0 +1,49 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+#ifndef SkGpuDeviceFactory_DEFINED
+#define SkGpuDeviceFactory_DEFINED
+
+#include "SkDevice.h"
+
+class GrContext;
+
+class SkGpuDeviceFactory : public SkDeviceFactory {
+public:
+    /**
+     *  The constructor will ref() the context, passing it to each device
+     *  that it creates. It will be unref()'d in the destructor
+     *  Non-layered devices created by the factory will draw to the
+     *  rootRenderTarget. rootRenderTarget is ref-counted by the factory.
+     *  SkGpuDevice::Current3DApiRenderTarget() can be passed as a special
+     *  value that will cause the factory to create a render target object
+     *  that reflects the state of the underlying 3D API at the time of
+     *  construction.
+     */
+    SkGpuDeviceFactory(GrContext*, GrRenderTarget* rootRenderTarget);
+
+    virtual ~SkGpuDeviceFactory();
+
+    virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
+                                int height, bool isOpaque, bool isLayer);
+
+private:
+    GrContext* fContext;
+    GrRenderTarget* fRootRenderTarget;
+};
+
+#endif
+
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
new file mode 100644
index 0000000..6f5ebfe
--- /dev/null
+++ b/include/gpu/SkGr.h
@@ -0,0 +1,298 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGr_DEFINED
+#define SkGr_DEFINED
+
+#include <stddef.h>
+
+// Gr headers
+#include "GrConfig.h"
+#include "GrContext.h"
+#include "GrFontScaler.h"
+#include "GrPathIter.h"
+#include "GrClipIterator.h"
+
+// skia headers
+#include "SkBitmap.h"
+#include "SkPath.h"
+#include "SkPoint.h"
+#include "SkRegion.h"
+#include "SkShader.h"
+#include "SkClipStack.h"
+
+#if (GR_DEBUG && defined(SK_RELEASE)) || (GR_RELEASE && defined(SK_DEBUG))
+//    #error "inconsistent GR_DEBUG and SK_DEBUG"
+#endif
+
+#if GR_SCALAR_IS_FIXED
+    #ifdef SK_SCALAR_IS_FIXED
+        #define SK_SCALAR_IS_GR_SCALAR  1
+    #else
+        #define SK_SCALAR_IS_GR_SCALAR  0
+    #endif
+    #define SkScalarToGrScalar(x)       SkScalarToFixed(x)
+
+#elif GR_SCALAR_IS_FLOAT
+
+    #ifdef SK_SCALAR_IS_FLOAT
+        #define SK_SCALAR_IS_GR_SCALAR  1
+    #else
+        #define SK_SCALAR_IS_GR_SCALAR  0
+    #endif
+    #define SkScalarToGrScalar(x)       SkScalarToFloat(x)
+
+#else
+    #error "Ganesh scalar type not defined"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Sk to Gr Type conversions
+
+// Verify that SkPoint and GrPoint are compatible if using the same scalar type
+#if 0/*SK_SCALAR_IS_GR_SCALAR*/
+    GR_STATIC_ASSERT(sizeof(SkPoint) == sizeof(GrPoint));
+    GR_STATIC_ASSERT(offsetof(SkPoint,fX) == offsetof(GrPoint,fX)));
+    GR_STATIC_ASSERT(offsetof(SkPoint,fY) == offsetof(GrPoint,fY)));
+#endif
+
+GR_STATIC_ASSERT((int)GrSamplerState::kClamp_WrapMode == (int)SkShader::kClamp_TileMode);
+GR_STATIC_ASSERT((int)GrSamplerState::kRepeat_WrapMode ==(
+                 int)SkShader::kRepeat_TileMode);
+GR_STATIC_ASSERT((int)GrSamplerState::kMirror_WrapMode ==
+                 (int)SkShader::kMirror_TileMode);
+
+#define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
+
+GR_STATIC_ASSERT((int)kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
+GR_STATIC_ASSERT((int)kOne_BlendCoeff  == (int)SkXfermode::kOne_Coeff);
+GR_STATIC_ASSERT((int)kSC_BlendCoeff   == (int)SkXfermode::kSC_Coeff);
+GR_STATIC_ASSERT((int)kISC_BlendCoeff  == (int)SkXfermode::kISC_Coeff);
+GR_STATIC_ASSERT((int)kDC_BlendCoeff   == (int)SkXfermode::kDC_Coeff);
+GR_STATIC_ASSERT((int)kIDC_BlendCoeff  == (int)SkXfermode::kIDC_Coeff);
+GR_STATIC_ASSERT((int)kSA_BlendCoeff   == (int)SkXfermode::kSA_Coeff);
+GR_STATIC_ASSERT((int)kISA_BlendCoeff  == (int)SkXfermode::kISA_Coeff);
+GR_STATIC_ASSERT((int)kDA_BlendCoeff   == (int)SkXfermode::kDA_Coeff);
+GR_STATIC_ASSERT((int)kIDA_BlendCoeff  == (int)SkXfermode::kIDA_Coeff);
+
+#define sk_blend_to_grblend(X) ((GrBlendCoeff)(X))
+
+GR_STATIC_ASSERT((int)SkPath::kMove_Verb  == (int)kMove_PathCmd);
+GR_STATIC_ASSERT((int)SkPath::kLine_Verb  == (int)kLine_PathCmd);
+GR_STATIC_ASSERT((int)SkPath::kQuad_Verb  == (int)kQuadratic_PathCmd);
+GR_STATIC_ASSERT((int)SkPath::kCubic_Verb == (int)kCubic_PathCmd);
+GR_STATIC_ASSERT((int)SkPath::kClose_Verb == (int)kClose_PathCmd);
+GR_STATIC_ASSERT((int)SkPath::kDone_Verb  == (int)kEnd_PathCmd);
+
+#define sk_path_verb_to_gr_path_command(X) ((GrPathCmd)(X))
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkColorPriv.h"
+
+static inline GrRect Sk2Gr(const SkRect& src) {
+    return GrRect(SkScalarToGrScalar(src.fLeft),
+                  SkScalarToGrScalar(src.fTop),
+                  SkScalarToGrScalar(src.fRight),
+                  SkScalarToGrScalar(src.fBottom));
+}
+
+class SkGr {
+public:
+    static inline SkIRect& SetIRect(SkIRect* dst, const GrIRect& src) {
+        GR_STATIC_ASSERT(sizeof(*dst) == sizeof(src));
+        memcpy(dst, &src, sizeof(*dst));
+        return *dst;
+    }
+
+    static inline GrIRect& SetIRect(GrIRect* dst, const SkIRect& src) {
+        GR_STATIC_ASSERT(sizeof(*dst) == sizeof(src));
+        memcpy(dst, &src, sizeof(*dst));
+        return *dst;
+    }
+
+    /**
+     *  Convert the SkBitmap::Config to the corresponding PixelConfig, or
+     *  kUnknown_PixelConfig if the conversion cannot be done.
+     */
+    static GrTexture::PixelConfig BitmapConfig2PixelConfig(SkBitmap::Config,
+                                                        bool isOpaque);
+
+    static GrTexture::PixelConfig Bitmap2PixelConfig(const SkBitmap& bm) {
+        return BitmapConfig2PixelConfig(bm.config(), bm.isOpaque());
+    }
+
+    static void SkMatrix2GrMatrix(const SkMatrix& m, GrMatrix* g) {
+        g->setAll(SkScalarToGrScalar(m[0]),
+                  SkScalarToGrScalar(m[1]),
+                  SkScalarToGrScalar(m[2]),
+                  SkScalarToGrScalar(m[3]),
+                  SkScalarToGrScalar(m[4]),
+                  SkScalarToGrScalar(m[5]),
+                  SkScalarToGrScalar(m[6]),
+                  SkScalarToGrScalar(m[7]),
+                  SkScalarToGrScalar(m[8]));
+    }
+
+    static GrColor SkColor2GrColor(SkColor c) {
+        SkPMColor pm = SkPreMultiplyColor(c);
+        unsigned r = SkGetPackedR32(pm);
+        unsigned g = SkGetPackedG32(pm);
+        unsigned b = SkGetPackedB32(pm);
+        unsigned a = SkGetPackedA32(pm);
+        return GrColorPackRGBA(r, g, b, a);
+    }
+
+    /**
+     *  This abandons all texture caches (for bitmaps and text) associated with
+     *  the gpu, and frees any associated skia caches. It differs from
+     *  deleteAllTextures in that it assumes that the gpu has lots its context,
+     *  and thus the associated HW textures are no longer valid
+     */
+    static void AbandonAllTextures(GrContext*);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Classes
+
+class SkGrPathIter : public GrPathIter {
+public:
+    SkGrPathIter() { fPath = NULL; }
+    SkGrPathIter(const SkPath& path) { reset(path); }
+    virtual GrPathCmd next(GrPoint pts[]);
+    virtual GrPathCmd next();
+    virtual void rewind();
+    virtual GrConvexHint convexHint() const;
+
+    void reset(const SkPath& path) {
+        fPath = &path;
+        fIter.setPath(path, false);
+    }
+private:
+
+#if !SK_SCALAR_IS_GR_SCALAR
+    SkPoint             fPoints[4];
+#endif
+    SkPath::Iter        fIter;
+    const SkPath*       fPath;
+};
+
+class SkGrClipIterator : public GrClipIterator {
+public:
+    SkGrClipIterator() { fClipStack = NULL;  fCurr = NULL; }
+    SkGrClipIterator(const SkClipStack& clipStack) { this->reset(clipStack); }
+
+    void reset(const SkClipStack& clipStack);
+
+    // overrides
+    virtual bool isDone() const { return NULL == fCurr; }
+    virtual void next() { fCurr = fIter.next(); }
+    virtual void rewind() { this->reset(*fClipStack); }
+    virtual GrClipType getType() const;
+
+    virtual GrSetOp getOp() const;
+
+    virtual void getRect(GrRect* rect) const {
+        *rect = Sk2Gr(*fCurr->fRect);
+    }
+
+    virtual GrPathIter* getPathIter() {
+        fPathIter.reset(*fCurr->fPath);
+        return &fPathIter;
+    }
+
+    virtual GrPathFill getPathFill() const;
+
+private:
+    const SkClipStack*                  fClipStack;
+    SkClipStack::B2FIter                fIter;
+    SkGrPathIter                        fPathIter;
+    // SkClipStack's auto advances on each get
+    // so we store the current pos here.
+    const SkClipStack::B2FIter::Clip*   fCurr;
+};
+
+class SkGrRegionIterator : public GrClipIterator {
+public:
+    SkGrRegionIterator() {}
+    SkGrRegionIterator(const SkRegion& region) { this->reset(region); }
+
+    void reset(const SkRegion& region) { 
+        fRegion = &region;
+        fIter.reset(region);
+    }
+
+    // overrides
+    virtual bool isDone() const { return fIter.done(); }
+    virtual void next() { fIter.next(); }
+    virtual void rewind() { this->reset(*fRegion); }
+    virtual GrClipType getType() const { return kRect_ClipType; }
+
+    virtual GrSetOp getOp() const { return kUnion_SetOp; }
+
+    virtual void getRect(GrRect* rect) const {
+        const SkIRect& r = fIter.rect();
+        rect->fLeft   = GrIntToScalar(r.fLeft);
+        rect->fTop    = GrIntToScalar(r.fTop);
+        rect->fRight  = GrIntToScalar(r.fRight);
+        rect->fBottom = GrIntToScalar(r.fBottom);
+    }
+
+    virtual GrPathIter* getPathIter() {
+        SkASSERT(0);
+        return NULL;
+    }
+
+    virtual GrPathFill getPathFill() const {
+        SkASSERT(0);
+        return kWinding_PathFill;
+    }
+private:
+    const SkRegion*     fRegion;
+    SkRegion::Iterator  fIter;
+};
+
+class SkGlyphCache;
+
+class SkGrFontScaler : public GrFontScaler {
+public:
+    explicit SkGrFontScaler(SkGlyphCache* strike);
+    virtual ~SkGrFontScaler();
+
+    // overrides
+    virtual const GrKey* getKey();
+    virtual bool getPackedGlyphBounds(GrGlyph::PackedID, GrIRect* bounds);
+    virtual bool getPackedGlyphImage(GrGlyph::PackedID, int width, int height,
+                                     int rowBytes, void* image);
+    virtual bool getGlyphPath(uint16_t glyphID, GrPath*);
+
+private:
+    SkGlyphCache* fStrike;
+    GrKey*  fKey;
+//    DECLARE_INSTANCE_COUNTER(SkGrFontScaler);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper functions
+
+GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx,
+                                            GrTextureKey* key,
+                                            const GrSamplerState& sampler,
+                                            const SkBitmap& bitmap);
+
+
+#endif
diff --git a/include/gpu/SkGrTexturePixelRef.h b/include/gpu/SkGrTexturePixelRef.h
new file mode 100644
index 0000000..1f5133f
--- /dev/null
+++ b/include/gpu/SkGrTexturePixelRef.h
@@ -0,0 +1,50 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkGrTexturePixelRef_DEFINED
+#define SkGrTexturePixelRef_DEFINED
+
+#include "SkPixelRef.h"
+#include "GrGpu.h"
+
+class SkGrTexturePixelRef : public SkPixelRef {
+public:
+            SkGrTexturePixelRef(GrTexture*);
+    virtual ~SkGrTexturePixelRef();
+
+    // override from SkPixelRef
+    virtual SkGpuTexture* getTexture() { return (SkGpuTexture*)fTexture; }
+
+protected:
+    // override from SkPixelRef
+    virtual void* onLockPixels(SkColorTable** ptr) {
+        if (ptr) {
+            *ptr = NULL;
+        }
+        return NULL;
+    }
+
+    // override from SkPixelRef
+    virtual void onUnlockPixels() {}
+
+private:
+    GrTexture*  fTexture;
+    typedef SkPixelRef INHERITED;
+};
+
+#endif
+
diff --git a/include/graphics/DoxygenMain.dox b/include/graphics/DoxygenMain.dox
deleted file mode 100644
index 9751862..0000000
--- a/include/graphics/DoxygenMain.dox
+++ /dev/null
@@ -1,3 +0,0 @@
-/** \mainpage notitle

-*   \htmlinclude "SGL Spec. rev 9.htm"

-*/
\ No newline at end of file
diff --git a/include/ports/SkTypeface_win.h b/include/ports/SkTypeface_win.h
new file mode 100644
index 0000000..95a7b8c
--- /dev/null
+++ b/include/ports/SkTypeface_win.h
@@ -0,0 +1,31 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#ifndef SkTypeface_win_DEFINED
+#define SkTypeface_win_DEFINED
+
+#include "SkTypeface.h"
+
+/**
+ *  Like the other Typeface create methods, this returns a new reference to the
+ *  corresponding typeface for the specified logfont. The caller is responsible
+ *  for calling unref() when it is finished.
+ */
+extern SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT&);
+
+#endif
+
diff --git a/include/svg/SkSVGAttribute.h b/include/svg/SkSVGAttribute.h
deleted file mode 100644
index 810d11c..0000000
--- a/include/svg/SkSVGAttribute.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSVGAttribute_DEFINED
-#define SkSVGAttribute_DEFINED
-
-#include "SkTypes.h"
-
-struct SkSVGAttribute {
-    const char* fName;
-#ifdef SK_DEBUG
-    size_t fOffset;
-#endif
-};
-
-#ifndef SK_OFFSETOF
-#define SK_OFFSETOF(a, b) (((size_t) (&(((a*) 1)->b)))-1)
-#endif
-
-#ifdef SK_DEBUG
-#define SVG_ATTRIBUTE(attr) { #attr, SK_OFFSETOF(BASE_CLASS, f_##attr) }
-#define SVG_LITERAL_ATTRIBUTE(svgAttr, cAttr) { #svgAttr, SK_OFFSETOF(BASE_CLASS, cAttr) }
-#else
-#define SVG_ATTRIBUTE(attr) { #attr }
-#define SVG_LITERAL_ATTRIBUTE(svgAttr, cAttr) { #svgAttr }
-#endif
-
-#define SVG_ADD_ATTRIBUTE(attr) \
-    if (f_##attr.size() > 0) \
-        parser._addAttributeLen(#attr, f_##attr.c_str(), f_##attr.size())
-
-#define SVG_ADD_ATTRIBUTE_ALIAS(attr, alias) \
-    if (f_##alias.size() > 0) \
-        parser._addAttributeLen(#attr, f_##alias.c_str(), f_##alias.size())
-
-#endif // SkSVGAttribute_DEFINED
diff --git a/include/svg/SkSVGBase.h b/include/svg/SkSVGBase.h
deleted file mode 100644
index 4d24aed..0000000
--- a/include/svg/SkSVGBase.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSVGBase_DEFINED
-#define SkSVGBase_DEFINED
-
-#include "SkSVGAttribute.h"
-
-class SkSVGParser;
-
-class SkSVGBase {
-public:
-    virtual ~SkSVGBase();
-    virtual void addAttribute(SkSVGParser& parser, int attrIndex, 
-        const char* attrValue, size_t attrLength);
-    virtual int getAttributes(const SkSVGAttribute** attrPtr) = 0;
-};
-
-#endif // SkSVGBase_DEFINEDes(const SkSVGAttribute** attrPtr) = 0;
-
diff --git a/include/svg/SkSVGPaintState.h b/include/svg/SkSVGPaintState.h
deleted file mode 100644
index f3f74e1..0000000
--- a/include/svg/SkSVGPaintState.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSVGPaintState_DEFINED
-#define SkSVGPaintState_DEFINED
-
-#include "SkSVGBase.h"
-#include "SkString.h"
-
-class SkSVGPaint : public SkSVGBase {
-public:
-    enum Field {
-        kInitial = -1,
-        kClipPath,
-        kClipRule,
-        kEnableBackground,
-        kFill,
-        kFillRule,
-        kFilter,
-        kFontFamily,
-        kFontSize,
-        kLetterSpacing,
-        kMask,
-        kOpacity,
-        kStopColor,
-        kStopOpacity,
-        kStroke,
-        kStroke_Dasharray,
-        kStroke_Linecap,
-        kStroke_Linejoin,
-        kStroke_Miterlimit,
-        kStroke_Width,
-        kStyle,
-        kTransform,
-        kTerminal
-    };
-
-    SkSVGPaint();
-    virtual void addAttribute(SkSVGParser& parser, int attrIndex, 
-        const char* attrValue, size_t attrLength);
-    bool flush(SkSVGParser& , bool isFlushable, bool isDef);
-    virtual int getAttributes(const SkSVGAttribute** attrPtr); 
-    static void Push(SkSVGPaint** head, SkSVGPaint* add);
-    static void Pop(SkSVGPaint** head);
-    SkString* operator[](int index);
-    SkString fInitial;
-    SkString f_clipPath;
-    SkString f_clipRule;
-    SkString f_enableBackground;
-    SkString f_fill;
-    SkString f_fillRule;
-    SkString f_filter;
-    SkString f_fontFamily;
-    SkString f_fontSize;
-    SkString f_letterSpacing;
-    SkString f_mask;
-    SkString f_opacity;
-    SkString f_stopColor;
-    SkString f_stopOpacity;
-    SkString f_stroke;
-    SkString f_strokeDasharray;
-    SkString f_strokeLinecap;
-    SkString f_strokeLinejoin;
-    SkString f_strokeMiterlimit;
-    SkString f_strokeWidth;
-    SkString f_style; // unused, but allows array access to the rest
-    SkString f_transform;
-#ifdef SK_DEBUG
-    SkString fTerminal;
-#endif
-    SkString fTransformID;
-    static SkSVGAttribute gAttributes[];
-    static const int kAttributesSize;
-private:
-    void setSave(SkSVGParser& );
-    bool writeChangedAttributes(SkSVGParser& , SkSVGPaint& , bool* changed);
-    bool writeChangedElements(SkSVGParser& , SkSVGPaint& , bool* changed);
-    SkSVGPaint* fNext;
-    friend class SkSVGParser;
-    typedef SkSVGPaint BASE_CLASS;
-};
-
-#endif // SkSVGPaintState_DEFINED
diff --git a/include/svg/SkSVGParser.h b/include/svg/SkSVGParser.h
deleted file mode 100644
index 83b120d..0000000
--- a/include/svg/SkSVGParser.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSVGParser_DEFINED
-#define SkSVGParser_DEFINED
-
-#include "SkMatrix.h"
-#include "SkTDict.h"
-#include "SkTDStack.h"
-#include "SkSVGPaintState.h"
-#include "SkSVGTypes.h"
-#include "SkStream.h"
-#include "SkString.h"
-#include "SkXMLParser.h"
-#include "SkXMLWriter.h"
-
-class SkSVGBase;
-class SkSVGElement;
-
-class SkSVGParser : public SkXMLParser {
-public:
-    SkSVGParser(SkXMLParserError* err = NULL);
-    virtual ~SkSVGParser();
-    void _addAttribute(const char* attrName, const char* attrValue) {
-        fXMLWriter.addAttribute(attrName, attrValue); }
-    void _addAttribute(const char* attrName, SkString& attrValue) {
-        fXMLWriter.addAttribute(attrName, attrValue.c_str()); }
-    void _addAttributeLen(const char* attrName, const char* attrValue, size_t len) {
-        fXMLWriter.addAttributeLen(attrName, attrValue, len); }
-    void _endElement() { fXMLWriter.endElement(); }
-    int findAttribute(SkSVGBase* , const char* attrValue, size_t len, bool isPaint);
-    const char* getFinal();
-    SkTDict<SkSVGElement*>& getIDs() { return fIDs; }
-    SkString& getPaintLast(SkSVGPaint::Field field);
-    void _startElement(const char name[]) { fXMLWriter.startElement(name); }
-    void translate(SkSVGElement*, bool isDef);
-    void translateMatrix(SkString& , SkString* id);
-    static void ConvertToArray(SkString& vals);
-protected:
-    virtual bool onAddAttribute(const char name[], const char value[]);
-    bool onAddAttributeLen(const char name[], const char value[], size_t len);
-    virtual bool onEndElement(const char elem[]);
-    virtual bool onStartElement(const char elem[]);
-    bool onStartElementLen(const char elem[], size_t len);
-    virtual bool onText(const char text[], int len);
-private:
-    bool isStrokeAndFill(SkSVGPaint** stroke, SkSVGPaint** fill);
-    static SkSVGElement* CreateElement(SkSVGTypes type, SkSVGElement* parent);
-    static void Delete(SkTDArray<SkSVGElement*>& fChildren);
-    static SkSVGTypes GetType(const char name[], size_t len);
-    SkSVGPaint* fHead;
-    SkSVGPaint fEmptyPaint; 
-    SkSVGPaint fLastFlush;
-    SkString fLastColor;
-    SkMatrix fLastTransform;
-    SkTDArray<SkSVGElement*> fChildren;
-    SkTDict<SkSVGElement*> fIDs;
-    SkTDArray<SkSVGElement*> fParents;
-    SkDynamicMemoryWStream fStream;
-    SkXMLStreamWriter fXMLWriter;
-    SkSVGElement*   fCurrElement;
-    SkBool8 fInSVG;
-    SkBool8 fSuppressPaint;
-    friend class SkSVGPaint;
-    friend class SkSVGGradient;
-};
-
-#endif // SkSVGParser_DEFINED
diff --git a/include/svg/SkSVGTypes.h b/include/svg/SkSVGTypes.h
deleted file mode 100644
index 99d8ca1..0000000
--- a/include/svg/SkSVGTypes.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSVGTypes_DEFINED
-#define SkSVGTypes_DEFINED
-
-enum SkSVGTypes {
-    SkSVGType_Circle,
-    SkSVGType_ClipPath,
-    SkSVGType_Defs,
-    SkSVGType_Ellipse,
-    SkSVGType_FeColorMatrix,
-    SkSVGType_Filter,
-    SkSVGType_G,
-    SkSVGType_Image,
-    SkSVGType_Line,
-    SkSVGType_LinearGradient,
-    SkSVGType_Mask,
-    SkSVGType_Metadata,
-    SkSVGType_Path,
-    SkSVGType_Polygon,
-    SkSVGType_Polyline,
-    SkSVGType_RadialGradient,
-    SkSVGType_Rect,
-    SkSVGType_SVG,
-    SkSVGType_Stop,
-    SkSVGType_Symbol,
-    SkSVGType_Text,
-    SkSVGType_Tspan,
-	SkSVGType_Unknown,
-    SkSVGType_Use
-};
-
-#endif // SkSVGTypes_DEFINED
diff --git a/include/utils/SkCamera.h b/include/utils/SkCamera.h
index 96eacb3..6d76018 100644
--- a/include/utils/SkCamera.h
+++ b/include/utils/SkCamera.h
@@ -157,7 +157,9 @@ public:
     void rotateY(SkScalar deg);
     void rotateZ(SkScalar deg);
 
+#ifdef ANDROID
     void setCameraLocation(SkScalar x, SkScalar y, SkScalar z);
+#endif
 
     void getMatrix(SkMatrix*) const;
     void applyToCanvas(SkCanvas*) const;
diff --git a/include/views/SkApplication.h b/include/views/SkApplication.h
deleted file mode 100644
index 4c4a4fb..0000000
--- a/include/views/SkApplication.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkApplication_DEFINED
-#define SkApplication_DEFINED
-
-class SkOSWindow;
-
-extern SkOSWindow* create_sk_window(void* hwnd);
-extern void application_init();
-extern void application_term();
-
-#endif // SkApplication_DEFINED
diff --git a/include/views/SkBGViewArtist.h b/include/views/SkBGViewArtist.h
deleted file mode 100644
index 1bca42f..0000000
--- a/include/views/SkBGViewArtist.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkBGViewArtist_DEFINED
-#define SkBGViewArtist_DEFINED
-
-#include "SkView.h"
-#include "SkPaint.h"
-
-class SkBGViewArtist : public SkView::Artist {
-public:
-            SkBGViewArtist(SkColor c = SK_ColorWHITE);
-    virtual ~SkBGViewArtist();
-
-    const SkPaint&  paint() const { return fPaint; }
-    SkPaint&        paint() { return fPaint; }
-
-protected:
-    // overrides
-    virtual void onDraw(SkView*, SkCanvas*);
-    virtual void onInflate(const SkDOM&, const SkDOM::Node*);
-
-private:
-    SkPaint fPaint;
-};
-
-#endif
-
diff --git a/include/views/SkBorderView.h b/include/views/SkBorderView.h
deleted file mode 100644
index 94ccc1f..0000000
--- a/include/views/SkBorderView.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkBorderView_DEFINED
-#define SkBorderView_DEFINED
-
-#include "SkView.h"
-#include "SkWidgetViews.h"
-#include "SkAnimator.h"
-
-class SkBorderView : public SkWidgetView {
-public:
-    SkBorderView();
-    ~SkBorderView();
-    void setSkin(const char skin[]);
-    SkScalar getLeft() const { return fLeft; }
-    SkScalar getRight() const { return fRight; }
-    SkScalar getTop() const { return fTop; }
-    SkScalar getBottom() const { return fBottom; }
-protected:
-    //overrides
-    virtual void onInflate(const SkDOM& dom,  const SkDOM::Node* node);
-    virtual void onSizeChange();
-    virtual void onDraw(SkCanvas* canvas);
-    virtual bool onEvent(const SkEvent& evt);
-private:
-    SkAnimator fAnim;
-    SkScalar fLeft, fRight, fTop, fBottom;  //margin on each side
-    SkRect fMargin;
-
-    typedef SkWidgetView INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkEvent.h b/include/views/SkEvent.h
deleted file mode 100644
index f6719d6..0000000
--- a/include/views/SkEvent.h
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkEvent_DEFINED
-#define SkEvent_DEFINED
-
-#include "SkDOM.h"
-#include "SkMetaData.h"
-#include "SkString.h"
-
-/** Unique 32bit id used to identify an instance of SkEventSink. When events are
-    posted, they are posted to a specific sinkID. When it is time to dispatch the
-    event, the sinkID is used to find the specific SkEventSink object. If it is found,
-    its doEvent() method is called with the event.
-*/
-typedef uint32_t SkEventSinkID;
-
-/** \class SkEvent
-
-    SkEvents are used to communicate type-safe information to SkEventSinks.
-    SkEventSinks (including SkViews) each have a unique ID, which is stored
-    in an event. This ID is used to target the event once it has been "posted".
-*/
-class SkEvent {
-public:
-    /** Default construct, creating an empty event.
-    */
-    SkEvent();
-    /** Construct a new event with the specified type.
-    */
-    explicit SkEvent(const SkString& type);
-    /** Construct a new event with the specified type.
-    */
-    explicit SkEvent(const char type[]);
-    /** Construct a new event by copying the fields from the src event.
-    */
-    SkEvent(const SkEvent& src);
-    ~SkEvent();
-
-//  /** Return the event's type (will never be null) */
-//  const char* getType() const;
-    /** Copy the event's type into the specified SkString parameter */
-    void    getType(SkString* str) const;
-    /** Returns true if the event's type matches exactly the specified type (case sensitive) */
-    bool    isType(const SkString& str) const;
-    /** Returns true if the event's type matches exactly the specified type (case sensitive) */
-    bool    isType(const char type[], size_t len = 0) const;
-    /** Set the event's type to the specified string.
-        In XML, use the "type" attribute.
-    */
-    void    setType(const SkString&);
-    /** Set the event's type to the specified string.
-        In XML, use the "type" attribute.
-    */
-    void    setType(const char type[], size_t len = 0);
-
-    /** Return the event's unnamed 32bit field. Default value is 0 */
-    uint32_t getFast32() const { return f32; }
-    /** Set the event's unnamed 32bit field. In XML, use
-        the subelement <data fast32=... />
-    */
-    void    setFast32(uint32_t x) { f32 = x; }
-
-    /** Return true if the event contains the named 32bit field, and return the field
-        in value (if value is non-null). If there is no matching named field, return false
-        and ignore the value parameter.
-    */
-    bool    findS32(const char name[], int32_t* value = NULL) const { return fMeta.findS32(name, value); }
-    /** Return true if the event contains the named SkScalar field, and return the field
-        in value (if value is non-null). If there is no matching named field, return false
-        and ignore the value parameter.
-    */
-    bool    findScalar(const char name[], SkScalar* value = NULL) const { return fMeta.findScalar(name, value); }
-    /** Return true if the event contains the named SkScalar field, and return the fields
-        in value[] (if value is non-null), and return the number of SkScalars in count (if count is non-null).
-        If there is no matching named field, return false and ignore the value and count parameters.
-    */
-    const SkScalar* findScalars(const char name[], int* count, SkScalar values[] = NULL) const { return fMeta.findScalars(name, count, values); }
-    /** Return the value of the named string field, or if no matching named field exists, return null.
-    */
-    const char* findString(const char name[]) const { return fMeta.findString(name); }
-    /** Return true if the event contains the named pointer field, and return the field
-        in value (if value is non-null). If there is no matching named field, return false
-        and ignore the value parameter.
-    */
-    bool    findPtr(const char name[], void** value) const { return fMeta.findPtr(name, value); }
-    bool    findBool(const char name[], bool* value) const { return fMeta.findBool(name, value); }
-    const void* findData(const char name[], size_t* byteCount = NULL) const {
-        return fMeta.findData(name, byteCount);
-    }
-
-    /** Returns true if ethe event contains the named 32bit field, and if it equals the specified value */
-    bool    hasS32(const char name[], int32_t value) const { return fMeta.hasS32(name, value); }
-    /** Returns true if ethe event contains the named SkScalar field, and if it equals the specified value */
-    bool    hasScalar(const char name[], SkScalar value) const { return fMeta.hasScalar(name, value); }
-    /** Returns true if ethe event contains the named string field, and if it equals (using strcmp) the specified value */
-    bool    hasString(const char name[], const char value[]) const { return fMeta.hasString(name, value); }
-    /** Returns true if ethe event contains the named pointer field, and if it equals the specified value */
-    bool    hasPtr(const char name[], void* value) const { return fMeta.hasPtr(name, value); }
-    bool    hasBool(const char name[], bool value) const { return fMeta.hasBool(name, value); }
-    bool hasData(const char name[], const void* data, size_t byteCount) const {
-        return fMeta.hasData(name, data, byteCount);
-    }
-
-    /** Add/replace the named 32bit field to the event. In XML use the subelement <data name=... s32=... /> */
-    void    setS32(const char name[], int32_t value) { fMeta.setS32(name, value); }
-    /** Add/replace the named SkScalar field to the event. In XML use the subelement <data name=... scalar=... /> */
-    void    setScalar(const char name[], SkScalar value) { fMeta.setScalar(name, value); }
-    /** Add/replace the named SkScalar[] field to the event. */
-    SkScalar* setScalars(const char name[], int count, const SkScalar values[] = NULL) { return fMeta.setScalars(name, count, values); }
-    /** Add/replace the named string field to the event. In XML use the subelement <data name=... string=... */
-    void    setString(const char name[], const SkString& value) { fMeta.setString(name, value.c_str()); }
-    /** Add/replace the named string field to the event. In XML use the subelement <data name=... string=... */
-    void    setString(const char name[], const char value[]) { fMeta.setString(name, value); }
-    /** Add/replace the named pointer field to the event. There is no XML equivalent for this call */
-    void    setPtr(const char name[], void* value) { fMeta.setPtr(name, value); }
-    void    setBool(const char name[], bool value) { fMeta.setBool(name, value); }
-    void setData(const char name[], const void* data, size_t byteCount) {
-        fMeta.setData(name, data, byteCount);
-    }
-
-    /** Return the underlying metadata object */
-    SkMetaData&         getMetaData() { return fMeta; }
-    /** Return the underlying metadata object */
-    const SkMetaData&   getMetaData() const { return fMeta; }
-
-    void tron() { SkDEBUGCODE(fDebugTrace = true;) }
-    void troff() { SkDEBUGCODE(fDebugTrace = false;) }
-    bool isDebugTrace() const
-    {
-#ifdef SK_DEBUG
-        return fDebugTrace;
-#else
-        return false;
-#endif
-    }
-
-    /** Call this to initialize the event from the specified XML node */
-    void    inflate(const SkDOM&, const SkDOM::Node*);
-
-    SkDEBUGCODE(void dump(const char title[] = NULL);)
-
-    /** Post the specified event to the event queue, targeting the specified eventsink, with an optional
-        delay. The event must be dynamically allocated for this. It cannot be a global or on the stack.
-        After this call, ownership is transfered to the system, so the caller must not retain
-        the event's ptr. Returns false if the event could not be posted (which means it will have been deleted).
-    */
-    static bool Post(SkEvent* evt, SkEventSinkID targetID, SkMSec delay = 0);
-    /** Post the specified event to the event queue, targeting the specified eventsink, to be delivered on/after the
-        specified millisecond time. The event must be dynamically allocated for this. It cannot be a global or on the stack.
-        After this call, ownership is transfered to the system, so the caller must not retain
-        the event's ptr. Returns false if the event could not be posted (which means it will have been deleted).
-    */
-    static bool PostTime(SkEvent* evt, SkEventSinkID targetID, SkMSec time);
-
-    /** Helper method for calling SkEvent::PostTime(this, ...), where the caller specifies a delay.
-        The real "time" will be computed automatically by sampling the clock and adding its value
-        to delay.
-    */
-    bool post(SkEventSinkID sinkID, SkMSec delay = 0)
-    {
-        return SkEvent::Post(this, sinkID, delay);
-    }
-
-    void postTime(SkEventSinkID sinkID, SkMSec time)
-    {
-        SkEvent::PostTime(this, sinkID, time);
-    }
-
-    ///////////////////////////////////////////////
-    /** Porting layer must call these functions **/
-    ///////////////////////////////////////////////
-
-    /** Global initialization function for the SkEvent system. Should be called exactly
-        once before any other event method is called, and should be called after the
-        call to SkGraphics::Init().
-    */
-    static void     Init();
-    /** Global cleanup function for the SkEvent system. Should be called exactly once after
-        all event methods have been called, and should be called before calling SkGraphics::Term().
-    */
-    static void     Term();
-
-    /** Call this to process one event from the queue. If it returns true, there are more events
-        to process.
-    */
-    static bool     ProcessEvent();
-    /** Call this whenever the requested timer has expired (requested by a call to SetQueueTimer).
-        It will post any delayed events whose time as "expired" onto the event queue.
-        It may also call SignalQueueTimer() and SignalNonEmptyQueue().
-    */
-    static void     ServiceQueueTimer();
-
-    /** Return the number of queued events. note that this value may be obsolete
-        upon return, since another thread may have called ProcessEvent() or
-        Post() after the count was made.
-     */
-    static int CountEventsOnQueue();
-
-    ////////////////////////////////////////////////////
-    /** Porting layer must implement these functions **/
-    ////////////////////////////////////////////////////
-
-    /** Called whenever an SkEvent is posted to an empty queue, so that the OS
-        can be told to later call Dequeue().
-    */
-    static void SignalNonEmptyQueue();
-    /** Called whenever the delay until the next delayed event changes. If zero is
-        passed, then there are no more queued delay events.
-    */
-    static void SignalQueueTimer(SkMSec delay);
-
-#ifndef SK_USE_WXWIDGETS
-#ifdef SK_BUILD_FOR_WIN
-    static bool WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
-#elif defined(SK_BUILD_FOR_UNIXx)
-  static uint32_t HandleTimer(uint32_t, void*);
-  static bool WndProc(Display*, Window, XEvent&);
-#endif
-#else
-    // Don't know yet what this will be
-    //static bool CustomEvent();
-#endif
-
-private:
-    SkMetaData      fMeta;
-    mutable char*   fType;  // may be characters with low bit set to know that it is not a pointer
-    uint32_t        f32;
-    SkDEBUGCODE(bool fDebugTrace;)
-
-    // these are for our implementation of the event queue
-    SkEventSinkID   fTargetID;
-    SkMSec          fTime;
-    SkEvent*        fNextEvent; // either in the delay or normal event queue
-    void initialize(const char* type, size_t typeLen);
-
-    static bool Enqueue(SkEvent* evt);
-    static SkMSec EnqueueTime(SkEvent* evt, SkMSec time);
-    static SkEvent* Dequeue(SkEventSinkID* targetID);
-    static bool     QHasEvents();
-};
-
-#endif
-
diff --git a/include/views/SkEventSink.h b/include/views/SkEventSink.h
deleted file mode 100644
index 27a6743..0000000
--- a/include/views/SkEventSink.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkEventSink_DEFINED
-#define SkEventSink_DEFINED
-
-#include "SkRefCnt.h"
-#include "SkEvent.h"
-
-struct SkTagList;
-
-/** \class SkEventSink
-
-    SkEventSink is the base class for all objects that receive SkEvents.
-*/
-class SkEventSink : public SkRefCnt {
-public:
-            SkEventSink();
-    virtual ~SkEventSink();
-
-    /** Returns this eventsink's unique ID. Use this to post SkEvents to
-        this eventsink.
-    */
-    SkEventSinkID getSinkID() const { return fID; }
-
-    /** Call this to pass an event to this object for processing. Returns true if the
-        event was handled.
-    */
-    bool doEvent(const SkEvent&);
-    /** Returns true if the sink (or one of its subclasses) understands the event as a query.
-        If so, the sink may modify the event to communicate its "answer".
-    */
-    bool doQuery(SkEvent* query);
-
-    /** Add sinkID to the list of listeners, to receive events from calls to sendToListeners()
-        and postToListeners(). If sinkID already exists in the listener list, no change is made.
-    */
-    void    addListenerID(SkEventSinkID sinkID);
-    /** Copy listeners from one event sink to another, typically from parent to child.
-        @param from the event sink to copy the listeners from
-    */
-    void copyListeners(const SkEventSink& from);
-    /** Remove sinkID from the list of listeners. If sinkID does not appear in the list,
-        no change is made.
-    */
-    void    removeListenerID(SkEventSinkID);
-    /** Returns true if there are 1 or more listeners attached to this eventsink
-    */
-    bool    hasListeners() const;
-    /** Posts a copy of evt to each of the eventsinks in the lisener list.
-    */
-    void    postToListeners(const SkEvent& evt, SkMSec delay = 0);
-
-    enum EventResult {
-        kHandled_EventResult,       //!< the eventsink returned true from its doEvent method
-        kNotHandled_EventResult,    //!< the eventsink returned false from its doEvent method
-        kSinkNotFound_EventResult   //!< no matching eventsink was found for the event's getSink().
-    };
-    /** DoEvent handles searching for an eventsink object that matches the targetID.
-        If one is found, it calls the sink's doEvent method, returning
-        either kHandled_EventResult or kNotHandled_EventResult. If no matching
-        eventsink is found, kSinkNotFound_EventResult is returned.
-    */
-    static EventResult DoEvent(const SkEvent&, SkEventSinkID targetID);
-
-    /** Returns the matching eventsink, or null if not found
-    */
-    static SkEventSink* FindSink(SkEventSinkID);
-
-protected:
-    /** Override this to handle events in your subclass. Be sure to call the inherited version
-        for events that you don't handle.
-    */
-    virtual bool onEvent(const SkEvent&);
-    virtual bool onQuery(SkEvent*);
-
-    SkTagList*  findTagList(U8CPU tag) const;
-    void        addTagList(SkTagList*);
-    void        removeTagList(U8CPU tag);
-
-private:
-    SkEventSinkID   fID;
-    SkTagList*      fTagHead;
-
-    // for our private link-list
-    SkEventSink*    fNextSink;
-};
-
-#endif
-
diff --git a/include/views/SkImageView.h b/include/views/SkImageView.h
deleted file mode 100644
index 57215c9..0000000
--- a/include/views/SkImageView.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkImageView_DEFINED
-#define SkImageView_DEFINED
-
-#include "SkView.h"
-#include "SkString.h"
-
-class SkAnimator;
-class SkBitmap;
-class SkMatrix;
-
-class SkImageView : public SkView {
-public:
-            SkImageView();
-    virtual ~SkImageView();
-
-    void    getUri(SkString*) const;
-    void    setUri(const char []);
-    void    setUri(const SkString&);
-    
-
-    enum ScaleType {
-        kMatrix_ScaleType,
-        kFitXY_ScaleType,
-        kFitStart_ScaleType,
-        kFitCenter_ScaleType,
-        kFitEnd_ScaleType
-    };
-    ScaleType   getScaleType() const { return (ScaleType)fScaleType; }
-    void        setScaleType(ScaleType);
-    
-    bool    getImageMatrix(SkMatrix*) const;
-    void    setImageMatrix(const SkMatrix*);
-
-protected:
-    // overrides
-    virtual bool    onEvent(const SkEvent&);
-    virtual void    onDraw(SkCanvas*);
-    virtual void    onInflate(const SkDOM&, const SkDOMNode*);
-    
-private:
-    SkString    fUri;
-    SkMatrix*   fMatrix;    // null or copy of caller's matrix ,,,,,
-    union {
-        SkAnimator* fAnim;
-        SkBitmap* fBitmap;
-    } fData;
-    uint8_t     fScaleType;
-    SkBool8     fDataIsAnim;    // as opposed to bitmap
-    SkBool8     fUriIsValid;
-    
-    void    onUriChange();
-    bool    getDataBounds(SkRect* bounds);
-    bool    freeData();
-    bool    ensureUriIsLoaded();
-
-    typedef SkView INHERITED;
-};
-
-#endif
diff --git a/include/views/SkKey.h b/include/views/SkKey.h
deleted file mode 100644
index 3fd5114..0000000
--- a/include/views/SkKey.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkKey_DEFINED
-#define SkKey_DEFINED
-
-#include "SkTypes.h"
-
-enum SkKey {
-    //reordering these to match android.app.KeyEvent 
-    kNONE_SkKey,    //corresponds to android's UNKNOWN
-    
-    kLeftSoftKey_SkKey,
-    kRightSoftKey_SkKey,
-
-    kHome_SkKey,    //!< the home key - added to match android
-    kBack_SkKey,    //!< (CLR)
-    kSend_SkKey,    //!< the green (talk) key
-    kEnd_SkKey,     //!< the red key
-    
-    k0_SkKey,
-    k1_SkKey,
-    k2_SkKey,
-    k3_SkKey,
-    k4_SkKey,
-    k5_SkKey,
-    k6_SkKey,
-    k7_SkKey,
-    k8_SkKey,
-    k9_SkKey,
-    kStar_SkKey,    //!< the * key
-    kHash_SkKey,    //!< the # key
-
-    kUp_SkKey,
-    kDown_SkKey,
-    kLeft_SkKey,
-    kRight_SkKey,
-
-    kOK_SkKey,      //!< the center key
-
-    kVolUp_SkKey,   //!< volume up - match android
-    kVolDown_SkKey, //!< volume down - same
-    kPower_SkKey,   //!< power button - same
-    kCamera_SkKey,  //!< camera         - same
-
-    kSkKeyCount
-};
-
-#endif
-
diff --git a/include/views/SkMetaData.h b/include/views/SkMetaData.h
deleted file mode 100644
index 9509710..0000000
--- a/include/views/SkMetaData.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkMetaData_DEFINED
-#define SkMetaData_DEFINED
-
-#include "SkScalar.h"
-
-class SkMetaData {
-public:
-    SkMetaData();
-    SkMetaData(const SkMetaData& src);
-    ~SkMetaData();
-
-    SkMetaData& operator=(const SkMetaData& src);
-
-    void    reset();
-
-    bool    findS32(const char name[], int32_t* value = NULL) const;
-    bool    findScalar(const char name[], SkScalar* value = NULL) const;
-    const SkScalar* findScalars(const char name[], int* count, SkScalar values[] = NULL) const;
-    const char* findString(const char name[]) const;
-    bool    findPtr(const char name[], void** value = NULL) const;
-    bool    findBool(const char name[], bool* value = NULL) const;
-    const void* findData(const char name[], size_t* byteCount = NULL) const;
-
-    bool    hasS32(const char name[], int32_t value) const
-    {
-        int32_t v;
-        return this->findS32(name, &v) && v == value;
-    }
-    bool    hasScalar(const char name[], SkScalar value) const
-    {
-        SkScalar    v;
-        return this->findScalar(name, &v) && v == value;
-    }
-    bool    hasString(const char name[], const char value[]) const
-    {
-        const char* v = this->findString(name);
-        return  v == NULL && value == NULL ||
-                v != NULL && value != NULL && !strcmp(v, value);
-    }
-    bool    hasPtr(const char name[], void* value) const
-    {
-        void*   v;
-        return this->findPtr(name, &v) && v == value;
-    }
-    bool    hasBool(const char name[], bool value) const
-    {
-        bool    v;
-        return this->findBool(name, &v) && v == value;
-    }
-    bool hasData(const char name[], const void* data, size_t byteCount) const {
-        size_t len;
-        const void* ptr = this->findData(name, &len);
-        return NULL != ptr && len == byteCount && !memcmp(ptr, data, len);
-    }
-
-    void    setS32(const char name[], int32_t value);
-    void    setScalar(const char name[], SkScalar value);
-    SkScalar* setScalars(const char name[], int count, const SkScalar values[] = NULL);
-    void    setString(const char name[], const char value[]);
-    void    setPtr(const char name[], void* value);
-    void    setBool(const char name[], bool value);
-    // the data is copied from the input pointer.
-    void    setData(const char name[], const void* data, size_t byteCount);
-
-    bool    removeS32(const char name[]);
-    bool    removeScalar(const char name[]);
-    bool    removeString(const char name[]);
-    bool    removePtr(const char name[]);
-    bool    removeBool(const char name[]);
-    bool    removeData(const char name[]);
-
-    SkDEBUGCODE(static void UnitTest();)
-
-    enum Type {
-        kS32_Type,
-        kScalar_Type,
-        kString_Type,
-        kPtr_Type,
-        kBool_Type,
-        kData_Type,
-
-        kTypeCount
-    };
-
-    struct Rec;
-    class Iter;
-    friend class Iter;
-
-    class Iter {
-    public:
-        Iter() : fRec(NULL) {}
-        Iter(const SkMetaData&);
-
-        /** Reset the iterator, so that calling next() will return the first
-            data element. This is done implicitly in the constructor.
-        */
-        void    reset(const SkMetaData&);
-
-        /** Each time next is called, it returns the name of the next data element,
-            or null when there are no more elements. If non-null is returned, then the
-            element's type is returned (if not null), and the number of data values
-            is returned in count (if not null).
-        */
-        const char* next(Type*, int* count);
-
-    private:
-        Rec* fRec;
-    };
-
-public:
-    struct Rec {
-        Rec*        fNext;
-        uint16_t    fDataCount; // number of elements
-        uint8_t     fDataLen;   // sizeof a single element
-#ifdef SK_DEBUG
-        Type        fType;
-#else
-        uint8_t     fType;
-#endif
-
-#ifdef SK_DEBUG
-        const char* fName;
-        union {
-            int32_t     fS32;
-            SkScalar    fScalar;
-            const char* fString;
-            void*       fPtr;
-            bool        fBool;
-        } fData;
-#endif
-
-        const void* data() const { return (this + 1); }
-        void*       data() { return (this + 1); }
-        const char* name() const { return (const char*)this->data() + fDataLen * fDataCount; }
-        char*       name() { return (char*)this->data() + fDataLen * fDataCount; }
-
-        static Rec* Alloc(size_t);
-        static void Free(Rec*);
-    };
-    Rec*    fRec;
-
-    const Rec* find(const char name[], Type) const;
-    void* set(const char name[], const void* data, size_t len, Type, int count);
-    bool remove(const char name[], Type);
-};
-
-#endif
-
diff --git a/include/views/SkOSMenu.h b/include/views/SkOSMenu.h
deleted file mode 100644
index 433a601..0000000
--- a/include/views/SkOSMenu.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkOSMenu_DEFINED
-#define SkOSMenu_DEFINED
-
-#include "SkEvent.h"
-#include "SkTDArray.h"
-
-class SkOSMenu {
-public:
-    explicit SkOSMenu(const char title[]);
-    ~SkOSMenu();
-
-    const char* getTitle() const { return fTitle; }
-
-    void    appendItem(const char title[], const char eventType[], int32_t eventData);
-
-    // called by SkOSWindow when it receives an OS menu event
-    int         countItems() const;
-    const char* getItem(int index, uint32_t* cmdID) const;
-
-    SkEvent* createEvent(uint32_t os_cmd);
-
-private:
-    const char* fTitle;
-
-    struct Item {
-        const char* fTitle;
-        const char* fEventType;
-        uint32_t    fEventData;
-        uint32_t    fOSCmd; // internal
-    };
-    SkTDArray<Item> fItems;
-
-    // illegal
-    SkOSMenu(const SkOSMenu&);
-    SkOSMenu& operator=(const SkOSMenu&);
-};
-
-#endif
-
diff --git a/include/views/SkOSWindow_Mac.h b/include/views/SkOSWindow_Mac.h
deleted file mode 100644
index 3a26d5a..0000000
--- a/include/views/SkOSWindow_Mac.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkOSWindow_Mac_DEFINED
-#define SkOSWindow_Mac_DEFINED
-
-#include <Carbon/Carbon.h>
-#include "SkWindow.h"
-
-class SkOSWindow : public SkWindow {
-public:
-    SkOSWindow(void* hwnd);
-
-    void*   getHWND() const { return fHWND; }
-    void*   getHVIEW() const { return fHVIEW; }
-    void    updateSize();
-
-    static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
-
-    static OSStatus EventHandler(EventHandlerCallRef inHandler,
-                                 EventRef inEvent, void* userData);
-
-    void   doPaint(void* ctx);
-
-
-    bool attachGL(const SkBitmap* offscreen);
-    void detachGL();
-    void presentGL();
-
-protected:
-    // overrides from SkEventSink
-    virtual bool onEvent(const SkEvent& evt);
-    // overrides from SkWindow
-    virtual void onHandleInval(const SkIRect&);
-    // overrides from SkView
-    virtual void onAddMenu(const SkOSMenu*);
-    virtual void onSetTitle(const char[]);
-    
-
-private:
-    void*   fHWND;
-    void*   fHVIEW;
-    void*   fAGLCtx;
-
-    typedef SkWindow INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkOSWindow_SDL.h b/include/views/SkOSWindow_SDL.h
deleted file mode 100644
index 0ff24f3..0000000
--- a/include/views/SkOSWindow_SDL.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkOSWindow_SDL_DEFINED
-#define SkOSWindow_SDL_DEFINED
-
-#include "SDL.h"
-#include "SkWindow.h"
-
-class SkGLCanvas;
-
-class SkOSWindow : public SkWindow {
-public:
-    SkOSWindow(void* screen);
-    virtual ~SkOSWindow();
-
-    static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
-
-    void handleSDLEvent(const SDL_Event& event);
-
-protected:
-    // overrides from SkWindow
-    virtual void onHandleInval(const SkIRect&);
-    // overrides from SkView
-    virtual void onAddMenu(const SkOSMenu*);
-    virtual void onSetTitle(const char[]);
-
-private:
-    SDL_Surface* fScreen;
-    SDL_Surface* fSurface;
-    SkGLCanvas* fGLCanvas;
-
-    void doDraw();
-
-    typedef SkWindow INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkOSWindow_Unix.h b/include/views/SkOSWindow_Unix.h
deleted file mode 100644
index 26f51be..0000000
--- a/include/views/SkOSWindow_Unix.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkOSWindow_Unix_DEFINED
-#define SkOSWindow_Unix_DEFINED
-
-#include "SkWindow.h"
-#include <X11/Xlib.h>
-
-struct SkUnixWindow {
-  Display* fDisplay;
-  Window fWin;
-  size_t fOSWin;
-};
-
-class SkOSWindow : public SkWindow {
-public:
-    SkOSWindow(Display* display, Window win);
-
-    void*   getHWND() const { return (void*)fUnixWindow.fWin; }
-  void* getDisplay() const { return (void*)fUnixWindow.fDisplay; }
-  void* getUnixWindow() const { return (void*)&fUnixWindow; }
-  void  setSize(int width, int height);
-    void    updateSize();
-
-    static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
-
-    static bool WndProc(SkUnixWindow* w,  XEvent &e);
-
-protected:
-    // overrides from SkWindow
-    virtual void onHandleInval(const SkIRect&);
-    // overrides from SkView
-    virtual void onAddMenu(const SkOSMenu*);
-
-private:
-    SkUnixWindow  fUnixWindow;
-
-    void    doPaint();
-
-    void*   fMBar;
-
-    typedef SkWindow INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkOSWindow_Win.h b/include/views/SkOSWindow_Win.h
deleted file mode 100644
index 09f0c5c..0000000
--- a/include/views/SkOSWindow_Win.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkOSWindow_Win_DEFINED
-#define SkOSWindow_Win_DEFINED
-
-#include "SkWindow.h"
-
-class SkOSWindow : public SkWindow {
-public:
-    SkOSWindow(void* hwnd);
-    virtual ~SkOSWindow();
-
-    void*   getHWND() const { return fHWND; }
-    void    setSize(int width, int height);
-    void    updateSize();
-
-    static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
-    
-    bool attachGL(const SkBitmap* offscreen);
-    void detachGL();
-    void presentGL();
-
-    bool attachD3D9();
-    void detachD3D9();
-    void presentD3D9();
-
-    void* d3d9Device() { return fD3D9Device; }
-
-    bool wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
-    static bool QuitOnDeactivate(HWND hWnd);
-
-    enum {
-        SK_WM_SkEvent = WM_APP + 1000,
-        SK_WM_SkTimerID = 0xFFFF    // just need a non-zero value
-    };
-
-protected:
-    virtual bool quitOnDeactivate() { return true; }
-
-    // overrides from SkWindow
-    virtual void onHandleInval(const SkIRect&);
-    // overrides from SkView
-    virtual void onAddMenu(const SkOSMenu*);
-
-    virtual void onSetTitle(const char title[]);
-
-private:
-    void*               fHWND;
-    
-    void                doPaint(void* ctx);
-
-    void*               fHGLRC;
-
-    bool                fGLAttached;
-
-    void*               fD3D9Device;
-    bool                fD3D9Attached;
-
-    HMENU               fMBar;
-
-    typedef SkWindow INHERITED; 
-};
-
-#endif
-
diff --git a/include/views/SkOSWindow_wxwidgets.h b/include/views/SkOSWindow_wxwidgets.h
deleted file mode 100644
index c5dfc7c..0000000
--- a/include/views/SkOSWindow_wxwidgets.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- *  SkOSWindow_wxwidgets.h
- *  wxwidgets
- *
- *  Copyright 2005 __MyCompanyName__. All rights reserved.
- *
- */
-
-#ifndef SkOSWindow_wxwidgets_DEFINED
-#define SkOSWindow_wxwidgets_DEFINED
-
-#include "SkWindow.h"
-#include "wx/frame.h"
-
-class SkOSWindow: public SkWindow
-{
-public:
-    SkOSWindow();
-    SkOSWindow(const wxString& title, int x, int y, int width, int height);
-    ~SkOSWindow();
-    
-    wxFrame* getWXFrame() const { return fFrame; }
-    
-    void updateSize();
-    
-protected:
-    virtual void onHandleInval(const SkIRect&);
-    virtual void onAddMenu(const SkOSMenu*);
-    
-private:
-    wxFrame* fFrame;
-    typedef SkWindow INHERITED;
-    
-};
-
-#endifpedef SkWindow INHERITED;
diff --git a/include/views/SkProgressBarView.h b/include/views/SkProgressBarView.h
deleted file mode 100644
index 6341fcb..0000000
--- a/include/views/SkProgressBarView.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkProgressBarView_DEFINED
-#define SkProgressBarView_DEFINED
-
-#include "SkView.h"
-#include "SkWidgetViews.h"
-#include "SkAnimator.h"
-
-class SkProgressBarView : public SkWidgetView {
-    public:
-        SkProgressBarView();
-        //SkProgressBarView(int max);
-                
-        //inflate: "sk-progress"
-    
-        void reset();   //reset progress to zero
-        void setProgress(int progress);
-        void changeProgress(int diff);
-        void setMax(int max);
-        
-        int getProgress() const { return fProgress; }
-        int getMax() const { return fMax; }
-    
-    protected:
-        //overrides
-        virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-        virtual void onSizeChange();
-        virtual void onDraw(SkCanvas* canvas);
-        virtual bool onEvent(const SkEvent& evt);
-    
-    private:
-        SkAnimator  fAnim;
-        int         fProgress;
-        int         fMax;
-        
-        typedef SkWidgetView INHERITED;
-};
-
-
-
-
-#endif
diff --git a/include/views/SkScrollBarView.h b/include/views/SkScrollBarView.h
deleted file mode 100644
index b8a5209..0000000
--- a/include/views/SkScrollBarView.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkScrollBarView_DEFINED
-#define SkScrollBarView_DEFINED
-
-#include "SkView.h"
-#include "SkWidgetViews.h"
-#include "SkAnimator.h"
-
-class SkScrollBarView : public SkWidgetView {
-public:
-    SkScrollBarView();
-
-    unsigned getStart() const { return fStartPoint; }
-    unsigned getShown() const { return fShownLength; }
-    unsigned getTotal() const { return fTotalLength; }
-
-    void setStart(unsigned start);  
-    void setShown(unsigned shown);
-    void setTotal(unsigned total);
-    
-protected:
-    //overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-    virtual void onSizeChange();
-    virtual void onDraw(SkCanvas* canvas);
-    virtual bool onEvent(const SkEvent& evt);
-
-private:
-    SkAnimator  fAnim;
-    unsigned    fTotalLength, fStartPoint, fShownLength;
-    
-    void adjust();
-    
-    typedef SkWidgetView INHERITED;
-};
-#endif
-
diff --git a/include/views/SkStackViewLayout.h b/include/views/SkStackViewLayout.h
deleted file mode 100644
index 8000319..0000000
--- a/include/views/SkStackViewLayout.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkStackViewLayout_DEFINED
-#define SkStackViewLayout_DEFINED
-
-#include "SkView.h"
-
-class SkStackViewLayout : public SkView::Layout {
-public:
-    SkStackViewLayout();
-
-    enum Orient {
-        kHorizontal_Orient,
-        kVertical_Orient,
-
-        kOrientCount
-    };
-    Orient  getOrient() const { return (Orient)fOrient; }
-    void    setOrient(Orient);
-
-    void        getMargin(SkRect*) const;
-    void        setMargin(const SkRect&);
-
-    SkScalar    getSpacer() const { return fSpacer; }
-    void        setSpacer(SkScalar);
-
-    /** Controls the posititioning in the same direction as the orientation
-    */
-    enum Pack {
-        kStart_Pack,
-        kCenter_Pack,
-        kEnd_Pack,
-        
-        kPackCount
-    };
-    Pack    getPack() const { return (Pack)fPack; }
-    void    setPack(Pack);
-
-    /** Controls the posititioning at right angles to the orientation
-    */
-    enum Align {
-        kStart_Align,
-        kCenter_Align,
-        kEnd_Align,
-        kStretch_Align,
-
-        kAlignCount
-    };
-    Align   getAlign() const { return (Align)fAlign; }
-    void    setAlign(Align);
-
-    bool    getRound() const { return SkToBool(fRound); }
-    void    setRound(bool);
-
-protected:
-    virtual void onLayoutChildren(SkView* parent);
-    virtual void onInflate(const SkDOM&, const SkDOM::Node*);
-
-private:
-    SkRect      fMargin;
-    SkScalar    fSpacer;
-    uint8_t     fOrient, fPack, fAlign, fRound;
-};
-
-class SkFillViewLayout : public SkView::Layout {
-public:
-            SkFillViewLayout();
-    void    getMargin(SkRect*) const;
-    void    setMargin(const SkRect&);
-
-protected:
-    // overrides;
-    virtual void onLayoutChildren(SkView* parent);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    SkRect  fMargin;
-    typedef SkView::Layout INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkSystemEventTypes.h b/include/views/SkSystemEventTypes.h
deleted file mode 100644
index 8dfe8be..0000000
--- a/include/views/SkSystemEventTypes.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkSystemEventTypes_DEFINED
-#define SkSystemEventTypes_DEFINED
-
-/*
-    The goal of these strings is two-fold:
-    1) make funny strings (containing at least one char < 32) to avoid colliding with "user" strings
-    2) keep them <= 4 bytes, so we can avoid an allocation in SkEvent::setType()
-*/
-#define SK_EventType_Delay      "\xd" "lay"
-#define SK_EventType_Inval      "nv" "\xa" "l"
-#define SK_EventType_Key        "key" "\x1" 
-#define SK_EventType_OnEnd "on" "\xe" "n"
-#define SK_EventType_Unichar    "\xc" "har"
-#define SK_EventType_KeyUp      "key" "\xf"
-
-#endif
diff --git a/include/views/SkView.h b/include/views/SkView.h
deleted file mode 100644
index d3633db..0000000
--- a/include/views/SkView.h
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkView_DEFINED
-#define SkView_DEFINED
-
-#include "SkEventSink.h"
-#include "SkRect.h"
-#include "SkDOM.h"
-#include "SkTDict.h"
-
-class SkCanvas;
-class SkLayerView;
-
-/** \class SkView
-
-    SkView is the base class for screen management. All widgets and controls inherit
-    from SkView.
-*/
-class SkView : public SkEventSink {
-public:
-    enum Flag_Shift {
-        kVisible_Shift,
-        kEnabled_Shift,
-        kFocusable_Shift,
-        kFlexH_Shift,
-        kFlexV_Shift,
-        kNoClip_Shift,
-
-        kFlagShiftCount
-    };
-    enum Flag_Mask {
-        kVisible_Mask   = 1 << kVisible_Shift,      //!< set if the view is visible
-        kEnabled_Mask   = 1 << kEnabled_Shift,      //!< set if the view is enabled
-        kFocusable_Mask = 1 << kFocusable_Shift,    //!< set if the view can receive focus
-        kFlexH_Mask     = 1 << kFlexH_Shift,        //!< set if the view's width is stretchable
-        kFlexV_Mask     = 1 << kFlexV_Shift,        //!< set if the view's height is stretchable
-        kNoClip_Mask    = 1 << kNoClip_Shift,        //!< set if the view is not clipped to its bounds
-
-        kAllFlagMasks   = (uint32_t)(0 - 1) >> (32 - kFlagShiftCount)
-    };
-
-                SkView(uint32_t flags = 0);
-    virtual     ~SkView();
-
-    /** Return the flags associated with the view
-    */
-    uint32_t    getFlags() const { return fFlags; }
-    /** Set the flags associated with the view
-    */
-    void        setFlags(uint32_t flags);
-
-    /** Helper that returns non-zero if the kVisible_Mask bit is set in the view's flags
-    */
-    int         isVisible() const { return fFlags & kVisible_Mask; }
-    int         isEnabled() const { return fFlags & kEnabled_Mask; }
-    int         isFocusable() const { return fFlags & kFocusable_Mask; }
-    int         isClipToBounds() const { return !(fFlags & kNoClip_Mask); }
-    /** Helper to set/clear the view's kVisible_Mask flag */
-    void        setVisibleP(bool);
-    void        setEnabledP(bool);
-    void        setFocusableP(bool);
-    void        setClipToBounds(bool);
-
-    /** Return the view's width */
-    SkScalar    width() const { return fWidth; }
-    /** Return the view's height */
-    SkScalar    height() const { return fHeight; }
-    /** Set the view's width and height. These must both be >= 0. This does not affect the view's loc */
-    void        setSize(SkScalar width, SkScalar height);
-    void        setSize(const SkPoint& size) { this->setSize(size.fX, size.fY); }
-    void        setWidth(SkScalar width) { this->setSize(width, fHeight); }
-    void        setHeight(SkScalar height) { this->setSize(fWidth, height); }
-    /** Return a rectangle set to [0, 0, width, height] */
-    void        getLocalBounds(SkRect* bounds) const;
-
-    /** Return the view's left edge */
-    SkScalar    locX() const { return fLoc.fX; }
-    /** Return the view's top edge */
-    SkScalar    locY() const { return fLoc.fY; }
-    /** Set the view's left and top edge. This does not affect the view's size */
-    void        setLoc(SkScalar x, SkScalar y);
-    void        setLoc(const SkPoint& loc) { this->setLoc(loc.fX, loc.fY); }
-    void        setLocX(SkScalar x) { this->setLoc(x, fLoc.fY); }
-    void        setLocY(SkScalar y) { this->setLoc(fLoc.fX, y); }
-    /** Offset (move) the view by the specified dx and dy. This does not affect the view's size */
-    void        offset(SkScalar dx, SkScalar dy);
-
-    /** Call this to have the view draw into the specified canvas. */
-    virtual void draw(SkCanvas* canvas);
-
-    /** Call this to invalidate part of all of a view, requesting that the view's
-        draw method be called. The rectangle parameter specifies the part of the view
-        that should be redrawn. If it is null, it specifies the entire view bounds.
-    */
-    void        inval(SkRect* rectOrNull);
-
-    //  Focus management
-
-    SkView* getFocusView() const;
-    bool    hasFocus() const;
-
-    enum FocusDirection {
-        kNext_FocusDirection,
-        kPrev_FocusDirection,
-
-        kFocusDirectionCount
-    };
-    bool    acceptFocus();
-    SkView* moveFocus(FocusDirection);
-
-    //  Click handling
-
-    class Click {
-    public:
-        Click(SkView* target);
-        virtual ~Click();
-
-        const char* getType() const { return fType; }
-        bool        isType(const char type[]) const;
-        void        setType(const char type[]);     // does NOT make a copy of the string
-        void        copyType(const char type[]);    // makes a copy of the string
-
-        enum State {
-            kDown_State,
-            kMoved_State,
-            kUp_State
-        };
-        SkPoint     fOrig, fPrev, fCurr;
-        SkIPoint    fIOrig, fIPrev, fICurr;
-        State       fState;
-    private:
-        SkEventSinkID   fTargetID;
-        char*           fType;
-        bool            fWeOwnTheType;
-
-        void resetType();
-
-        friend class SkView;
-    };
-    Click*  findClickHandler(SkScalar x, SkScalar y);
-
-    static void DoClickDown(Click*, int x, int y);
-    static void DoClickMoved(Click*, int x, int y);
-    static void DoClickUp(Click*, int x, int y);
-
-    /** Send the event to the view's parent, and its parent etc. until one of them
-        returns true from its onEvent call. This view is returned. If no parent handles
-        the event, null is returned.
-     */
-    SkView*     sendEventToParents(const SkEvent&);
-    /** Send the query to the view's parent, and its parent etc. until one of them
-        returns true from its onQuery call. This view is returned. If no parent handles
-        the query, null is returned.
-     */
-    SkView* sendQueryToParents(SkEvent*);
-
-    /** Depricated helper function. Just call event->post(sinkID, delay);
-    */
-    bool    postEvent(SkEvent* evt, SkEventSinkID sinkID, SkMSec delay) { return evt->post(sinkID, delay); }
-
-    //  View hierarchy management
-
-    /** Return the view's parent, or null if it has none. This does not affect the parent's reference count. */
-    SkView*     getParent() const { return fParent; }
-    SkView*     attachChildToFront(SkView* child);
-    /** Attach the child view to this view, and increment the child's reference count. The child view is added
-        such that it will be drawn before all other child views.
-        The child view parameter is returned.
-    */
-    SkView*     attachChildToBack(SkView* child);
-    /** If the view has a parent, detach the view from its parent and decrement the view's reference count.
-        If the parent was the only owner of the view, this will cause the view to be deleted.
-    */
-    void        detachFromParent();
-    /** Attach the child view to this view, and increment the child's reference count. The child view is added
-        such that it will be drawn after all other child views.
-        The child view parameter is returned.
-    */
-    /** Detach all child views from this view. */
-    void        detachAllChildren();
-
-    /** Convert the specified point from global coordinates into view-local coordinates
-    */
-    void        globalToLocal(SkPoint* pt) const { if (pt) this->globalToLocal(pt->fX, pt->fY, pt); }
-    /** Convert the specified x,y from global coordinates into view-local coordinates, returning
-        the answer in the local parameter.
-    */
-    void        globalToLocal(SkScalar globalX, SkScalar globalY, SkPoint* local) const;
-
-    /** \class F2BIter
-    
-        Iterator that will return each of this view's children, in
-        front-to-back order (the order used for clicking). The first
-        call to next() returns the front-most child view. When
-        next() returns null, there are no more child views.
-    */
-    class F2BIter {
-    public:
-        F2BIter(const SkView* parent);
-        SkView* next();
-    private:
-        SkView* fFirstChild, *fChild;
-    };
-
-    /** \class B2FIter
-    
-        Iterator that will return each of this view's children, in
-        back-to-front order (the order they are drawn). The first
-        call to next() returns the back-most child view. When
-        next() returns null, there are no more child views.
-    */
-    class B2FIter {
-    public:
-        B2FIter(const SkView* parent);
-        SkView* next();
-    private:
-        SkView* fFirstChild, *fChild;
-    };
-
-    /** \class Artist
-    
-        Install a subclass of this in a view (calling setArtist()), and then the
-        default implementation of that view's onDraw() will invoke this object
-        automatically.
-    */
-    class Artist : public SkRefCnt {
-    public:
-        void draw(SkView*, SkCanvas*);
-        void inflate(const SkDOM&, const SkDOM::Node*);
-    protected:
-        virtual void onDraw(SkView*, SkCanvas*) = 0;
-        virtual void onInflate(const SkDOM&, const SkDOM::Node*);
-    };
-    /** Return the artist attached to this view (or null). The artist's reference
-        count is not affected.
-    */
-    Artist* getArtist() const;
-    /** Attach the specified artist (or null) to the view, replacing any existing
-        artist. If the new artist is not null, its reference count is incremented.
-        The artist parameter is returned.
-    */
-    Artist* setArtist(Artist* artist);
-
-    /** \class Layout
-    
-        Install a subclass of this in a view (calling setLayout()), and then the
-        default implementation of that view's onLayoutChildren() will invoke
-        this object automatically.
-    */
-    class Layout : public SkRefCnt {
-    public:
-        void layoutChildren(SkView* parent);
-        void inflate(const SkDOM&, const SkDOM::Node*);
-    protected:
-        virtual void onLayoutChildren(SkView* parent) = 0;
-        virtual void onInflate(const SkDOM&, const SkDOM::Node*);
-    };
-
-    /** Return the layout attached to this view (or null). The layout's reference
-        count is not affected.
-    */
-    Layout* getLayout() const;
-    /** Attach the specified layout (or null) to the view, replacing any existing
-        layout. If the new layout is not null, its reference count is incremented.
-        The layout parameter is returned.
-    */
-    Layout* setLayout(Layout*, bool invokeLayoutNow = true);
-    /** If a layout is attached to this view, call its layoutChildren() method
-    */
-    void    invokeLayout();
-
-    /** Call this to initialize this view based on the specified XML node
-    */
-    void    inflate(const SkDOM& dom, const SkDOM::Node* node);
-    /** After a view hierarchy is inflated, this may be called with a dictionary
-        containing pairs of <name, view*>, where the name string was the view's
-        "id" attribute when it was inflated.
-
-        This will call the virtual onPostInflate for this view, and the recursively
-        call postInflate on all of the view's children.
-    */
-    void    postInflate(const SkTDict<SkView*>& ids);
-
-    SkDEBUGCODE(void dump(bool recurse) const;)
-
-protected:
-    /** Override this to draw inside the view. Be sure to call the inherited version too */
-    virtual void    onDraw(SkCanvas*);
-    /** Override this to be notified when the view's size changes. Be sure to call the inherited version too */
-    virtual void    onSizeChange();
-    /** Override this if you want to handle an inval request from this view or one of its children.
-        Tyically this is only overridden by the by the "window". If your subclass does handle the
-        request, return true so the request will not continue to propogate to the parent.
-    */
-    virtual bool    handleInval(const SkRect*);
-    //! called once before all of the children are drawn (or clipped/translated)
-    virtual SkCanvas* beforeChildren(SkCanvas* c) { return c; }
-    //! called once after all of the children are drawn (or clipped/translated)
-    virtual void afterChildren(SkCanvas* orig) {}
-
-    //! called right before this child's onDraw is called
-    virtual void beforeChild(SkView* child, SkCanvas* canvas) {}
-    //! called right after this child's onDraw is called
-    virtual void afterChild(SkView* child, SkCanvas* canvas) {}
-
-    /** Override this if you might handle the click
-    */
-    virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
-    /** Override this to decide if your children are targets for a click.
-        The default returns true, in which case your children views will be
-        candidates for onFindClickHandler. Returning false wil skip the children
-        and just call your onFindClickHandler.
-     */
-    virtual bool onSendClickToChildren(SkScalar x, SkScalar y);
-    /** Override this to track clicks, returning true as long as you want to track
-        the pen/mouse.
-    */
-    virtual bool    onClick(Click*);
-    /** Override this to initialize your subclass from the XML node. Be sure to call the inherited version too */
-    virtual void    onInflate(const SkDOM& dom, const SkDOM::Node* node);
-    /** Override this if you want to perform post initialization work based on the ID dictionary built
-        during XML parsing. Be sure to call the inherited version too.
-    */
-    virtual void    onPostInflate(const SkTDict<SkView*>&);
-
-public:
-    // default action is to inval the view
-    virtual void    onFocusChange(bool gainFocusP);
-protected:
-
-    // override these if you're acting as a layer/host
-    virtual bool    onGetFocusView(SkView**) const { return false; }
-    virtual bool    onSetFocusView(SkView*) { return false; }
-
-private:
-    SkScalar    fWidth, fHeight;
-    SkPoint     fLoc;
-    SkView*     fParent;
-    SkView*     fFirstChild;
-    SkView*     fNextSibling;
-    SkView*     fPrevSibling;
-    uint8_t     fFlags;
-    uint8_t     fContainsFocus;
-
-    friend class B2FIter;
-    friend class F2BIter;
-    
-    friend class SkLayerView;
-
-    bool    setFocusView(SkView* fvOrNull);
-    SkView* acceptFocus(FocusDirection);
-    void    detachFromParent_NoLayout();
-};
-
-#endif
-
diff --git a/include/views/SkViewInflate.h b/include/views/SkViewInflate.h
deleted file mode 100644
index 3ec65a6..0000000
--- a/include/views/SkViewInflate.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkViewInflate_DEFINED
-#define SkViewInflate_DEFINED
-
-#include "SkDOM.h"
-#include "SkTDict.h"
-#include "SkEvent.h"
-
-class SkView;
-
-class SkViewInflate {
-public: 
-            SkViewInflate();
-    virtual ~SkViewInflate();
-
-    /** Return the tree of inflated views. If root is null, create the root element
-        as a view, otherwise assume root is that view, and just "inflate" it.
-
-        Returns null if the tree cannot be built.
-    */
-    SkView* inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root = NULL);
-    SkView* inflate(const char xml[], size_t len, SkView* root = NULL);
-
-    /** Given an id attribute value, return the corresponding view, or null
-        if no match is found.
-    */
-    SkView* findViewByID(const char id[]) const;
-    
-    SkDEBUGCODE(void dump() const;)
-
-protected:
-    /*  Override this in your subclass to handle instantiating views
-        Call the inherited version for nodes you don't recognize.
-
-        Do not call "inflate" on the view, just return it. This will
-        get called automatically after createView returns.
-    */
-    virtual SkView* createView(const SkDOM& dom, const SkDOM::Node* node);
-    /** Base implementation calls view->inflate(dom, node). Subclasses may override this
-        to perform additional initializations to view, either before or after calling
-        the inherited version.
-    */
-    virtual void inflateView(SkView* view, const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    enum {
-        kMinIDStrAlloc = 64
-    };
-    SkTDict<SkView*> fIDs;
-
-    struct IDStr {
-        SkView* fView;
-        char*   fStr;
-    };
-    SkTDArray<IDStr>    fListenTo, fBroadcastTo;
-    SkChunkAlloc        fStrings;
-
-    void addIDStr(SkTDArray<IDStr>* list, SkView*, const char* str);
-
-    void    rInflate(const SkDOM& dom, const SkDOM::Node* node, SkView* parent);
-};
-
-#endif
-
diff --git a/include/views/SkWidget.h b/include/views/SkWidget.h
deleted file mode 100644
index db85f01..0000000
--- a/include/views/SkWidget.h
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkWidget_DEFINED
-#define SkWidget_DEFINED
-
-#include "SkView.h"
-#include "SkBitmap.h"
-#include "SkDOM.h"
-#include "SkPaint.h"
-#include "SkString.h"
-#include "SkTDArray.h"
-
-//////////////////////////////////////////////////////////////////////////////
-
-class SkWidget : public SkView {
-public:
-    SkWidget(uint32_t flags = 0) : SkView(flags | kFocusable_Mask | kEnabled_Mask) {}
-
-    /** Call this to post the widget's event to its listeners */
-    void    postWidgetEvent();
-
-    static void Init();
-    static void Term();
-protected:
-    // override to add slots to an event before posting
-    virtual void prepareWidgetEvent(SkEvent*);
-    virtual void onEnabledChange();
-
-    // <event ...> to initialize the event from XML
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    SkEvent fEvent;
-    typedef SkView INHERITED;
-};
-
-class SkHasLabelWidget : public SkWidget {
-public:
-    SkHasLabelWidget(uint32_t flags = 0) : SkWidget(flags) {}
-
-    size_t  getLabel(SkString* label = NULL) const;
-    size_t  getLabel(char lable[] = NULL) const;
-    void    setLabel(const SkString&);
-    void    setLabel(const char label[]);
-    void    setLabel(const char label[], size_t len);
-
-protected:
-    // called when the label changes
-    virtual void onLabelChange();
-
-    // overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    SkString    fLabel;
-    typedef SkWidget INHERITED;
-};
-
-class SkButtonWidget : public SkHasLabelWidget {
-public:
-    SkButtonWidget(uint32_t flags = 0) : SkHasLabelWidget(flags), fState(kOff_State) {}
-
-    enum State {
-        kOff_State,     //!< XML: buttonState="off"
-        kOn_State,      //!< XML: buttonState="on"
-        kUnknown_State  //!< XML: buttonState="unknown"
-    };
-    State   getButtonState() const { return fState; }
-    void    setButtonState(State);
-
-protected:
-    /** called when the label changes. default behavior is to inval the widget */
-    virtual void onButtonStateChange();
-
-    // overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    State   fState;
-    typedef SkHasLabelWidget INHERITED;
-};
-
-class SkPushButtonWidget : public SkButtonWidget {
-public:
-    SkPushButtonWidget(uint32_t flags = 0) : SkButtonWidget(flags) {}
-
-protected:
-    virtual bool onEvent(const SkEvent&);
-    virtual void onDraw(SkCanvas*);
-    virtual Click* onFindClickHandler(SkScalar x, SkScalar y);
-    virtual bool onClick(Click* click);
-
-private:
-    typedef SkButtonWidget INHERITED;
-};
-
-class SkCheckBoxWidget : public SkButtonWidget {
-public:
-    SkCheckBoxWidget(uint32_t flags = 0);
-
-protected:
-    virtual bool onEvent(const SkEvent&);
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    typedef SkButtonWidget INHERITED;
-};
-
-#include "SkTextBox.h"
-
-class SkStaticTextView : public SkView {
-public:
-            SkStaticTextView(uint32_t flags = 0);
-    virtual ~SkStaticTextView();
-
-    enum Mode {
-        kFixedSize_Mode,
-        kAutoWidth_Mode,
-        kAutoHeight_Mode,
-
-        kModeCount
-    };
-    Mode    getMode() const { return (Mode)fMode; }
-    void    setMode(Mode);
-
-    SkTextBox::SpacingAlign getSpacingAlign() const { return (SkTextBox::SpacingAlign)fSpacingAlign; }
-    void    setSpacingAlign(SkTextBox::SpacingAlign);
-
-    void    getMargin(SkPoint* margin) const;
-    void    setMargin(SkScalar dx, SkScalar dy);
-
-    size_t  getText(SkString* text = NULL) const;
-    size_t  getText(char text[] = NULL) const;
-    void    setText(const SkString&);
-    void    setText(const char text[]);
-    void    setText(const char text[], size_t len);
-
-    void    getPaint(SkPaint*) const;
-    void    setPaint(const SkPaint&);
-
-protected:
-    // overrides
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    SkPoint     fMargin;
-    SkString    fText;
-    SkPaint     fPaint;
-    uint8_t     fMode;
-    uint8_t     fSpacingAlign;
-
-    void computeSize();
-
-    typedef SkView INHERITED;
-};
-
-class SkBitmapView : public SkView {
-public:
-            SkBitmapView(uint32_t flags = 0);
-    virtual ~SkBitmapView();
-
-    bool    getBitmap(SkBitmap*) const;
-    void    setBitmap(const SkBitmap*, bool viewOwnsPixels);
-    bool    loadBitmapFromFile(const char path[]);
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM&, const SkDOM::Node*);
-
-private:
-    SkBitmap    fBitmap;
-    typedef SkView INHERITED;
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
-class SkShader;
-class SkInterpolator;
-
-class SkWidgetView : public SkView {
-public:
-            SkWidgetView(uint32_t flags = 0);
-    virtual ~SkWidgetView();
-
-    static const char*  GetEventType();
-};
-
-class SkSliderView : public SkWidgetView {
-public:
-    SkSliderView(uint32_t flags = 0);
-
-    uint16_t    getValue() const { return fValue; }
-    uint16_t    getMax() const { return fMax; }
-
-    void    setMax(U16CPU max);
-    void    setValue(U16CPU value);
-
-protected:
-    virtual void    onDraw(SkCanvas*);
-    virtual Click*  onFindClickHandler(SkScalar x, SkScalar y);
-    virtual bool    onClick(Click*);
-
-private:
-    uint16_t fValue, fMax;
-
-    typedef SkWidgetView INHERITED;
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-class SkHasLabelView : public SkView {
-public:
-    void    getLabel(SkString*) const;
-    void    setLabel(const SkString&);
-    void    setLabel(const char label[]);
-
-protected:
-    SkString    fLabel;
-
-    // called when the label changes
-    virtual void onLabelChange();
-
-    // overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-};
-
-class SkPushButtonView : public SkHasLabelView {
-public:
-    SkPushButtonView(uint32_t flags = 0);
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-};
-
-class SkCheckBoxView : public SkHasLabelView {
-public:
-    SkCheckBoxView(uint32_t flags = 0);
-
-    enum State {
-        kOff_State,
-        kOn_State,
-        kMaybe_State
-    };
-    State   getState() const { return fState; }
-    void    setState(State);
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    State   fState;
-};
-
-class SkProgressView : public SkView {
-public:
-    SkProgressView(uint32_t flags = 0);
-    virtual ~SkProgressView();
-
-    uint16_t    getValue() const { return fValue; }
-    uint16_t    getMax() const { return fMax; }
-
-    void    setMax(U16CPU max);
-    void    setValue(U16CPU value);
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    uint16_t    fValue, fMax;
-    SkShader*   fOnShader, *fOffShader;
-    SkInterpolator* fInterp;
-    bool fDoInterp;
-
-    typedef SkView INHERITED;
-};
-
-class SkTextView : public SkView {
-public:
-            SkTextView(uint32_t flags = 0);
-    virtual ~SkTextView();
-
-    enum AnimaDir {
-        kNeutral_AnimDir,
-        kForward_AnimDir,
-        kBackward_AnimDir,
-        kAnimDirCount
-    };
-
-    void    getText(SkString*) const;
-    void    setText(const SkString&, AnimaDir dir = kNeutral_AnimDir);
-    void    setText(const char text[], AnimaDir dir = kNeutral_AnimDir);
-    void    setText(const char text[], size_t len, AnimaDir dir = kNeutral_AnimDir);
-
-    void    getMargin(SkPoint* margin) const;
-    void    setMargin(const SkPoint&);
-
-    SkPaint&    paint() { return fPaint; }
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    SkString fText;
-    SkPaint  fPaint;
-    SkPoint  fMargin;
-
-    class Interp;
-    Interp* fInterp;
-    bool    fDoInterp;
-    // called by the other setText methods. This guy does not check for !=
-    // before doing the assign, so the caller must check for us
-    void privSetText(const SkString&, AnimaDir dir);
-
-    typedef SkView INHERITED;
-};
-
-//////////////////////////////////////////////////////////
-
-class SkEvent;
-
-class SkListSource : public SkEventSink {
-public:
-    virtual int countRows() = 0;
-    virtual void getRow(int index, SkString* left, SkString* right) = 0;
-    virtual SkEvent* getEvent(int index);
-
-    static SkListSource* CreateFromDir(const char path[], const char suffix[],
-                                        const char targetPrefix[]);
-    static SkListSource* CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node);
-};
-
-class SkListView : public SkWidgetView {
-public:
-            SkListView(uint32_t flags = 0);
-    virtual ~SkListView();
-
-    SkScalar    getRowHeight() const { return fRowHeight; }
-    void        setRowHeight(SkScalar);
-
-    /** Return the index of the selected row, or -1 if none
-    */
-    int     getSelection() const { return fCurrIndex; }
-    /** Set the index of the selected row, or -1 for none
-    */
-    void    setSelection(int);
-
-    void    moveSelectionUp();
-    void    moveSelectionDown();
-
-    enum Attr {
-        kBG_Attr,
-        kNormalText_Attr,
-        kHiliteText_Attr,
-        kHiliteCell_Attr,
-        kAttrCount
-    };
-    SkPaint&    paint(Attr);
-
-    SkListSource*   getListSource() const { return fSource; }
-    SkListSource*   setListSource(SkListSource*);
-
-#if 0
-    enum Action {
-        kSelectionChange_Action,
-        kSelectionPicked_Action,
-        kActionCount
-    };
-    /** If event is not null, it is retained by the view, and a copy
-        of the event will be posted to its listeners when the specified
-        action occurs. If event is null, then no event will be posted for
-        the specified action.
-    */
-    void    setActionEvent(Action, SkEvent* event);
-#endif
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onSizeChange();
-    virtual bool onEvent(const SkEvent&);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    SkPaint         fPaint[kAttrCount];
-    SkListSource*   fSource;
-    SkScalar        fRowHeight;
-    int             fCurrIndex;     // logical index
-    int             fScrollIndex;   // logical index of top-most visible row
-    int             fVisibleRowCount;
-    SkString*       fStrCache;
-
-    void    dirtyStrCache();
-    void    ensureStrCache(int visibleCount);
-
-    int     logicalToVisualIndex(int index) const { return index - fScrollIndex; }
-    void    invalSelection();
-    bool    getRowRect(int index, SkRect*) const;
-    void    ensureSelectionIsVisible();
-
-    typedef SkWidgetView INHERITED;
-};
-
-//////////////////////////////////////////////////////////
-
-class SkGridView : public SkWidgetView {
-public:
-            SkGridView(uint32_t flags = 0);
-    virtual ~SkGridView();
-
-    void    getCellSize(SkPoint*) const;
-    void    setCellSize(SkScalar x, SkScalar y);
-
-    /** Return the index of the selected item, or -1 if none
-    */
-    int     getSelection() const { return fCurrIndex; }
-    /** Set the index of the selected row, or -1 for none
-    */
-    void    setSelection(int);
-
-    void    moveSelectionUp();
-    void    moveSelectionDown();
-
-    enum Attr {
-        kBG_Attr,
-        kHiliteCell_Attr,
-        kAttrCount
-    };
-    SkPaint&    paint(Attr);
-
-    SkListSource*   getListSource() const { return fSource; }
-    SkListSource*   setListSource(SkListSource*);
-
-protected:
-    virtual void onDraw(SkCanvas*);
-    virtual void onSizeChange();
-    virtual bool onEvent(const SkEvent&);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-
-private:
-    SkView*         fScrollBar;
-    SkPaint         fPaint[kAttrCount];
-    SkListSource*   fSource;
-    int             fCurrIndex;     // logical index
-
-    SkPoint         fCellSize;
-    SkIPoint        fVisibleCount;
-
-    int     logicalToVisualIndex(int index) const { return index; }
-    void    invalSelection();
-    bool    getCellRect(int index, SkRect*) const;
-    void    ensureSelectionIsVisible();
-
-    typedef SkWidgetView INHERITED;
-};
-
-#endif
-
diff --git a/include/views/SkWidgetViews.h b/include/views/SkWidgetViews.h
deleted file mode 100644
index 4dd8866..0000000
--- a/include/views/SkWidgetViews.h
+++ /dev/null
@@ -1,310 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkWidgetViews_DEFINED
-#define SkWidgetViews_DEFINED
-
-#include "SkView.h"
-
-
-enum SkWidgetEnum {
-    kBorder_WidgetEnum,         //!< <sk-border>
-    kButton_WidgetEnum,         //!< <sk-button>
-    kImage_WidgetEnum,          //!< <sk-image>
-    kList_WidgetEnum,           //!< <sk-list>
-    kProgress_WidgetEnum,       //!< <sk-progress>
-    kScroll_WidgetEnum,         //!< <sk-scroll>
-    kText_WidgetEnum,           //!< <sk-text>
-    
-    kWidgetEnumCount
-};
-
-//determines which skin to use
-enum SkinEnum {
-    kBorder_SkinEnum,
-    kButton_SkinEnum,
-    kProgress_SkinEnum,
-    kScroll_SkinEnum,
-    kStaticText_SkinEnum,
-    
-    kSkinEnumCount
-};
-
-#include "SkAnimator.h"
-//used for inflates
-const char* get_skin_enum_path(SkinEnum se);
-void init_skin_anim(const char path[], SkAnimator* anim);
-void init_skin_anim(SkinEnum se, SkAnimator* anim);
-void init_skin_paint(SkinEnum se, SkPaint* paint);
-void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint);
-
-/** Given an enum value, return an instance of the specified widget.
-    If the enum is out of range, returns null
-*/
-SkView* SkWidgetFactory(SkWidgetEnum);
-/** Given the inflate/element name of a widget, return an instance of
-    the specified widget, or null if name does not match any known
-    widget type.
-*/
-SkView* SkWidgetFactory(const char name[]);
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-class SkWidgetView : public SkView {
-public:
-    SkWidgetView();
-
-    const char* getLabel() const;
-    void        getLabel(SkString* label) const;
-
-    void        setLabel(const char[]);
-    void        setLabel(const char[], size_t len);
-    void        setLabel(const SkString&);
-
-    SkEvent&        event() { return fEvent; }
-    const SkEvent&  event() const { return fEvent; }
-
-    /** Returns true if the widget can post its event to its listeners.
-    */
-    bool    postWidgetEvent();
-    
-    /** Returns the sinkID of the widgetview that posted the event, or 0
-    */
-    static SkEventSinkID GetWidgetEventSinkID(const SkEvent&);
-
-protected:
-    /** called when the label changes. override in subclasses. default action invals the view's bounds.
-        called with the old and new labels, before the label has actually changed.
-    */
-    virtual void onLabelChange(const char oldLabel[], const char newLabel[]);
-    /** called before posting the event to our listeners. Override to add slots to the event
-        before posting. Return true to proceed with posting, or false to not post the event to any
-        listener. Note: the event passed in may not be the same as calling this->event().
-        Be sure to call your INHERITED method as well, so that all classes in the hierarchy get a shot
-        at modifying the event (and possibly returning false to abort).
-    */
-    virtual bool onPrepareWidgetEvent(SkEvent* evt);
-
-    // overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-    
-private:
-    SkString    fLabel;
-    SkEvent     fEvent;
-    
-    typedef SkView INHERITED;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-class SkButtonView : public SkWidgetView {
-public:
-    // inflate: "sk-button"
-    
-protected:
-    // overrides
-    virtual bool onEvent(const SkEvent&);
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-class SkCheckButtonView : public SkWidgetView {
-public:
-    SkCheckButtonView();
-
-    // inflate: "sk-checkbutton"
-    
-    enum CheckState {
-        kOff_CheckState,        //!< inflate: check-state="off"
-        kOn_CheckState,         //!< inflate: check-state="on"
-        kUnknown_CheckState     //!< inflate: check-state="unknown"
-    };
-    CheckState  getCheckState() const { return (CheckState)fCheckState; }
-    void        setCheckState(CheckState);
-
-    /** use this to extract the CheckState from an event (i.e. one that as posted
-        by a SkCheckButtonView). Returns true if the proper slot was present in the event,
-        and sets state to that value. If no proper slot is found, returns false and does not
-        modify state.
-    */
-    static bool GetWidgetEventCheckState(const SkEvent&, CheckState* state);
-
-protected:
-    // called when the check-state is about to change, but before it actually has
-    virtual void onCheckStateChange(CheckState oldState, CheckState newState);
-
-    // overrides
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-    virtual bool onPrepareWidgetEvent(SkEvent* evt);
-    
-private:
-    uint8_t  fCheckState;
-    
-    typedef SkWidgetView INHERITED;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-#include "SkTextBox.h"
-
-class SkStaticTextView : public SkView {
-public:
-            SkStaticTextView();
-    virtual ~SkStaticTextView();
-
-    enum Mode {
-        kFixedSize_Mode,
-        kAutoWidth_Mode,
-        kAutoHeight_Mode,
-
-        kModeCount
-    };
-    Mode    getMode() const { return (Mode)fMode; }
-    void    setMode(Mode);
-
-    SkTextBox::SpacingAlign getSpacingAlign() const { return (SkTextBox::SpacingAlign)fSpacingAlign; }
-    void    setSpacingAlign(SkTextBox::SpacingAlign);
-
-    void    getMargin(SkPoint* margin) const;
-    void    setMargin(SkScalar dx, SkScalar dy);
-
-    size_t  getText(SkString* text = NULL) const;
-    size_t  getText(char text[] = NULL) const;
-    void    setText(const SkString&);
-    void    setText(const char text[]);
-    void    setText(const char text[], size_t len);
-
-    void    getPaint(SkPaint*) const;
-    void    setPaint(const SkPaint&);
-
-protected:
-    // overrides
-    virtual void onDraw(SkCanvas*);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node*);
-
-private:
-    SkPoint     fMargin;
-    SkString    fText;
-    SkPaint     fPaint;
-    uint8_t     fMode;
-    uint8_t     fSpacingAlign;
-
-    void computeSize();
-
-    typedef SkView INHERITED;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-class SkAnimator;
-class SkListSource;
-class SkScrollBarView;
-
-class SkListView : public SkWidgetView {
-public:
-            SkListView();
-    virtual ~SkListView();
-
-    bool    hasScrollBar() const { return fScrollBar != NULL; }
-    void    setHasScrollBar(bool);
-    
-    /** Return the number of visible rows
-    */
-    int     getVisibleRowCount() const { return fVisibleRowCount; }
-    /** Return the index of the selected row, or -1 if none
-    */
-    int     getSelection() const { return fCurrIndex; }
-    /** Set the index of the selected row, or -1 for none
-    */
-    void    setSelection(int);
-    /** If possible, move the selection up and return true,
-        else do nothing and return false
-        If nothing is selected, select the last item (unless there are no items).
-    */
-    bool    moveSelectionUp();
-    /** If possible, move the selection down and return true,
-        else do nothing and return false.
-        If nothing is selected, select the first item (unless there are no items).
-    */
-    bool    moveSelectionDown();
-
-    SkListSource*   getListSource() const { return fSource; }
-    SkListSource*   setListSource(SkListSource*);
-
-    /** Call this in your event handler. If the specified event is from a SkListView,
-        then it returns the index of the selected item in this list, otherwise it
-        returns -1
-    */
-    static int GetWidgetEventListIndex(const SkEvent&);
-
-protected:
-    // overrides
-    virtual void onDraw(SkCanvas*);
-    virtual void onSizeChange();
-    virtual bool onEvent(const SkEvent&);
-    virtual void onInflate(const SkDOM& dom, const SkDOM::Node* node);
-    virtual bool onPrepareWidgetEvent(SkEvent*);
-
-private:
-    enum DirtyFlags {
-        kAnimCount_DirtyFlag    = 0x01,
-        kAnimContent_DirtyFlag  = 0x02
-    };
-    void    dirtyCache(unsigned dirtyFlags);
-    bool    ensureCache();
-
-    int     logicalToVisualIndex(int index) const { return index - fScrollIndex; }
-    void    invalSelection();
-    SkScalar getContentWidth() const;
-    bool    getRowRect(int index, SkRect*) const;
-    void    ensureSelectionIsVisible();
-    void    ensureVisibleRowCount();
-
-    struct BindingRec;
-
-    enum Heights {
-        kNormal_Height,
-        kSelected_Height
-    };
-    SkListSource*   fSource;
-    SkScrollBarView*    fScrollBar;
-    SkAnimator*     fAnims;
-    BindingRec*     fBindings;
-    SkString        fSkinName;
-    SkScalar        fHeights[2];
-    int16_t         fScrollIndex, fCurrIndex;
-    uint16_t        fVisibleRowCount, fBindingCount;
-    SkBool8         fAnimContentDirty;
-    SkBool8         fAnimFocusDirty;
-
-    typedef SkWidgetView INHERITED;
-};
-
-class SkListSource : public SkRefCnt {
-public:
-    virtual int countFields();
-    virtual void getFieldName(int index, SkString* field);
-    /** Return the index of the named field, or -1 if not found */
-    virtual int findFieldIndex(const char field[]);
-
-    virtual int countRecords();
-    virtual void getRecord(int rowIndex, int fieldIndex, SkString* data);
-
-    virtual bool prepareWidgetEvent(SkEvent*, int rowIndex);
-    
-    static SkListSource* Factory(const char name[]);
-};
-
-#endif
diff --git a/include/views/SkWindow.h b/include/views/SkWindow.h
deleted file mode 100644
index 5deefd5..0000000
--- a/include/views/SkWindow.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2006 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SkWindow_DEFINED
-#define SkWindow_DEFINED
-
-#include "SkView.h"
-#include "SkBitmap.h"
-#include "SkMatrix.h"
-#include "SkRegion.h"
-#include "SkEvent.h"
-#include "SkKey.h"
-#include "SkTDArray.h"
-
-#ifdef SK_BUILD_FOR_WINCEx
-    #define SHOW_FPS
-#endif
-//#define USE_GX_SCREEN
-
-class SkCanvas;
-
-class SkOSMenu;
-
-class SkWindow : public SkView {
-public:
-            SkWindow();
-    virtual ~SkWindow();
-
-    const SkBitmap& getBitmap() const { return fBitmap; }
-
-    void    setConfig(SkBitmap::Config);
-    void    resize(int width, int height, SkBitmap::Config config = SkBitmap::kNo_Config);
-    void    eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
-    void    eraseRGB(U8CPU r, U8CPU g, U8CPU b);
-
-    bool    isDirty() const { return !fDirtyRgn.isEmpty(); }
-    bool    update(SkIRect* updateArea, SkCanvas* = NULL);
-    // does not call through to onHandleInval(), but does force the fDirtyRgn
-    // to be wide open. Call before update() to ensure we redraw everything.
-    void    forceInvalAll();
-    // return the bounds of the dirty/inval rgn, or [0,0,0,0] if none
-    const SkIRect& getDirtyBounds() const { return fDirtyRgn.getBounds(); }
-
-    bool    handleClick(int x, int y, Click::State);
-    bool    handleChar(SkUnichar);
-    bool    handleKey(SkKey);
-    bool    handleKeyUp(SkKey);
-    bool    handleMenu(uint32_t os_cmd);
-
-    void    addMenu(SkOSMenu*);
-    
-    const char* getTitle() const { return fTitle.c_str(); }
-    void    setTitle(const char title[]);
-
-    const SkMatrix& getMatrix() const { return fMatrix; }
-    void    setMatrix(const SkMatrix&);
-    void    preConcat(const SkMatrix&);
-    void    postConcat(const SkMatrix&);
-
-protected:
-    virtual bool onEvent(const SkEvent&);
-
-    // called if part of our bitmap is invalidated
-    virtual void onHandleInval(const SkIRect&);
-    virtual bool onHandleChar(SkUnichar);
-    virtual bool onHandleKey(SkKey);
-    virtual bool onHandleKeyUp(SkKey);
-    virtual void onAddMenu(const SkOSMenu*) {}
-    virtual void onSetTitle(const char title[]) {}
-
-    // overrides from SkView
-    virtual bool handleInval(const SkRect*);
-    virtual bool onGetFocusView(SkView** focus) const;
-    virtual bool onSetFocusView(SkView* focus);
-
-private:
-    SkBitmap::Config    fConfig;
-    SkBitmap    fBitmap;
-    SkRegion    fDirtyRgn;
-    Click*      fClick; // to track clicks
-
-    SkTDArray<SkOSMenu*>    fMenus;
-
-    SkView* fFocusView;
-    bool    fWaitingOnInval;
-    
-    SkString    fTitle;
-    SkMatrix    fMatrix;
-
-    typedef SkView INHERITED;
-};
-
-///////////////////////////////////////////////////////////
-
-#ifdef SK_USE_WXWIDGETS
-    #include "SkOSWindow_wxwidgets.h"
-#elif defined(SK_BUILD_FOR_MAC)
-    #include "SkOSWindow_Mac.h"
-#elif defined(SK_BUILD_FOR_WIN)
-    #include "SkOSWindow_Win.h"
-#elif defined(SK_BUILD_FOR_UNIXx)
-  #include "SkOSWindow_Unix.h"
-#elif defined(SK_BUILD_FOR_SDL)
-    #include "SkOSWindow_SDL.h"
-#elif defined(SK_BUILD_FOR_IOS)
-    #include "SkOSWindow_iOS.h"
-#endif
-
-#endif
-
diff --git a/src/core/SkAdvancedTypefaceMetrics.cpp b/src/core/SkAdvancedTypefaceMetrics.cpp
index 0c5ad8d..731478b 100644
--- a/src/core/SkAdvancedTypefaceMetrics.cpp
+++ b/src/core/SkAdvancedTypefaceMetrics.cpp
@@ -80,10 +80,7 @@ SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* getAdvanceData(
     int repeats = 0;
     for (int gId = 0; gId < num_glyphs; gId++) {
         Data advance;
-        if (!getAdvance(fontHandle, gId, &advance)) {
-            num_glyphs = (gId > 0) ? gId - 1 : 0;
-            break;
-        }
+        SkAssertResult(getAdvance(fontHandle, gId, &advance));
         if (advance == lastAdvance) {
             repeats++;
         } else if (curRange->fAdvance.count() == repeats + 1) {
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 9e6f993..a5f7d57 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -22,6 +22,7 @@
 #include "SkMask.h"
 #include "SkPixelRef.h"
 #include "SkThread.h"
+#include "SkUnPreMultiply.h"
 #include "SkUtils.h"
 #include "SkPackBits.h"
 #include <new>
@@ -598,6 +599,57 @@ void* SkBitmap::getAddr(int x, int y) const {
     return base;
 }
 
+SkColor SkBitmap::getColor(int x, int y) const {
+    SkASSERT((unsigned)x < (unsigned)this->width());
+    SkASSERT((unsigned)y < (unsigned)this->height());
+
+    switch (this->config()) {
+        case SkBitmap::kA1_Config: {
+            uint8_t* addr = getAddr1(x, y);
+            uint8_t mask = 1 << (7  - (x % 8));
+            if (addr[0] & mask) {
+                return SK_ColorBLACK;
+            } else {
+                return 0;
+            }
+        }
+        case SkBitmap::kA8_Config: {
+            uint8_t* addr = getAddr8(x, y);
+            return SkColorSetA(0, addr[0]);
+        }
+        case SkBitmap::kIndex8_Config: {
+            SkPMColor c = getIndex8Color(x, y);
+            return SkUnPreMultiply::PMColorToColor(c);
+        }
+        case SkBitmap::kRGB_565_Config: {
+            uint16_t* addr = getAddr16(x, y);
+            return SkPixel16ToColor(addr[0]);
+        }
+        case SkBitmap::kARGB_4444_Config: {
+            uint16_t* addr = getAddr16(x, y);
+            SkPMColor c = SkPixel4444ToPixel32(addr[0]);
+            return SkUnPreMultiply::PMColorToColor(c);
+        }
+        case SkBitmap::kARGB_8888_Config: {
+            uint32_t* addr = getAddr32(x, y);
+            return SkUnPreMultiply::PMColorToColor(addr[0]);
+        }
+        case kRLE_Index8_Config: {
+            uint8_t dst;
+            const SkBitmap::RLEPixels* rle =
+                (const SkBitmap::RLEPixels*) getPixels();
+            SkPackBits::Unpack8(&dst, x, 1, rle->packedAtY(y));
+            return SkUnPreMultiply::PMColorToColor((*fColorTable)[dst]);
+        }
+        case kNo_Config:
+        case kConfigCount:
+            SkASSERT(false);
+            return 0;
+    }
+    SkASSERT(false);  // Not reached.
+    return 0;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1185,10 +1237,11 @@ static bool GetBitmapAlpha(const SkBitmap& src, uint8_t SK_RESTRICT alpha[],
 #include "SkMaskFilter.h"
 #include "SkMatrix.h"
 
-void SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
+bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
                             Allocator *allocator, SkIPoint* offset) const {
     SkDEBUGCODE(this->validate();)
 
+    SkBitmap    tmpBitmap;
     SkMatrix    identity;
     SkMask      srcM, dstM;
 
@@ -1208,25 +1261,20 @@ void SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
         dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
     } else {
     NO_FILTER_CASE:
-        dst->setConfig(SkBitmap::kA8_Config, this->width(), this->height(),
+        tmpBitmap.setConfig(SkBitmap::kA8_Config, this->width(), this->height(),
                        srcM.fRowBytes);
-        if (dst->allocPixels(allocator, NULL)) {
-            GetBitmapAlpha(*this, dst->getAddr8(0, 0), srcM.fRowBytes);
-            if (offset) {
-                offset->set(0, 0);
-            }
-            return;
+        if (!tmpBitmap.allocPixels(allocator, NULL)) {
+            // Allocation of pixels for alpha bitmap failed.
+            SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
+                    tmpBitmap.width(), tmpBitmap.height());
+            return false;
         }
-    ALLOC_ERR:
-        // Allocation of pixels for alpha bitmap failed.
-        SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
-                 dst->width(), dst->height());
-        // When pixels can't be allocated, reset destination bitmap
-        dst->reset();
+        GetBitmapAlpha(*this, tmpBitmap.getAddr8(0, 0), srcM.fRowBytes);
         if (offset) {
             offset->set(0, 0);
         }
-        return;
+        tmpBitmap.swap(*dst);
+        return true;
     }
 
     SkAutoMaskImage srcCleanup(&srcM, true);
@@ -1238,16 +1286,22 @@ void SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
 
     SkAutoMaskImage dstCleanup(&dstM, false);
 
-    dst->setConfig(SkBitmap::kA8_Config, dstM.fBounds.width(),
+    tmpBitmap.setConfig(SkBitmap::kA8_Config, dstM.fBounds.width(),
                    dstM.fBounds.height(), dstM.fRowBytes);
-    if (!dst->allocPixels(allocator, NULL)) {
-        goto ALLOC_ERR;
+    if (!tmpBitmap.allocPixels(allocator, NULL)) {
+        // Allocation of pixels for alpha bitmap failed.
+        SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
+                tmpBitmap.width(), tmpBitmap.height());
+        return false;
     }
-    memcpy(dst->getPixels(), dstM.fImage, dstM.computeImageSize());
+    memcpy(tmpBitmap.getPixels(), dstM.fImage, dstM.computeImageSize());
     if (offset) {
         offset->set(dstM.fBounds.fLeft, dstM.fBounds.fTop);
     }
-    SkDEBUGCODE(dst->validate();)
+    SkDEBUGCODE(tmpBitmap.validate();)
+
+    tmpBitmap.swap(*dst);
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1436,3 +1490,4 @@ void SkBitmap::validate() const {
 #endif
 }
 #endif
+
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index 1eaa46d..a16e96a 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -44,10 +44,10 @@ void SkBitmapProcShader::endSession() {
     this->INHERITED::endSession();
 }
 
-SkShader::BitmapType SkBitmapProcShader::asABitmap(SkBitmap* texture, 
-                                                   SkMatrix* texM, 
+SkShader::BitmapType SkBitmapProcShader::asABitmap(SkBitmap* texture,
+                                                   SkMatrix* texM,
                                                    TileMode xy[],
-                                                   SkScalar* twoPointRadialParams) {
+                                       SkScalar* twoPointRadialParams) const {
     if (texture) {
         *texture = fRawBitmap;
     }
@@ -95,7 +95,7 @@ bool SkBitmapProcShader::setContext(const SkBitmap& device,
 
     const SkBitmap& bitmap = *fState.fBitmap;
     bool bitmapIsOpaque = bitmap.isOpaque();
-    
+
     // update fFlags
     uint32_t flags = 0;
     if (bitmapIsOpaque && (255 == this->getPaintAlpha())) {
@@ -182,7 +182,7 @@ void SkBitmapProcShader::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
         }
 #endif
         sproc(state, buffer, n, dstC);
-        
+
         if ((count -= n) == 0) {
             break;
         }
@@ -198,7 +198,7 @@ void SkBitmapProcShader::shadeSpan16(int x, int y, uint16_t dstC[], int count) {
         state.fShaderProc16(state, x, y, dstC, count);
         return;
     }
-    
+
     uint32_t buffer[BUF_MAX];
     SkBitmapProcState::MatrixProc   mproc = state.fMatrixProc;
     SkBitmapProcState::SampleProc16 sproc = state.fSampleProc16;
@@ -215,7 +215,7 @@ void SkBitmapProcShader::shadeSpan16(int x, int y, uint16_t dstC[], int count) {
         }
         mproc(state, buffer, n, x, y);
         sproc(state, buffer, n, dstC);
-        
+
         if ((count -= n) == 0) {
             break;
         }
@@ -287,7 +287,7 @@ bool SkBitmapProcShader::toDumpString(SkString* str) const {
     str->printf("BitmapShader: [%d %d %d",
                 fRawBitmap.width(), fRawBitmap.height(),
                 fRawBitmap.bytesPerPixel());
-    
+
     // add the pixelref
     SkPixelRef* pr = fRawBitmap.pixelRef();
     if (pr) {
@@ -296,7 +296,7 @@ bool SkBitmapProcShader::toDumpString(SkString* str) const {
             str->appendf(" \"%s\"", uri);
         }
     }
-    
+
     // add the (optional) matrix
     {
         SkMatrix m;
@@ -306,7 +306,7 @@ bool SkBitmapProcShader::toDumpString(SkString* str) const {
             str->appendf(" %s", info.c_str());
         }
     }
-    
+
     str->appendf(" [%s %s]]",
                  gTileModeName[fState.fTileModeX],
                  gTileModeName[fState.fTileModeY]);
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 88598fc..bd19b75 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -32,12 +32,12 @@ public:
     virtual void shadeSpan16(int x, int y, uint16_t dstC[], int count);
     virtual void beginSession();
     virtual void endSession();
-    virtual BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*, 
-                                 SkScalar* twoPointRadialParams);
+    virtual BitmapType asABitmap(SkBitmap*, SkMatrix*, TileMode*,
+                                 SkScalar* twoPointRadialParams) const;
 
     static bool CanDo(const SkBitmap&, TileMode tx, TileMode ty);
 
-    static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { 
+    static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW_ARGS(SkBitmapProcShader, (buffer));
     }
 
@@ -53,7 +53,7 @@ protected:
     SkBitmapProcState fState;
     uint32_t          fFlags;
 
-private:    
+private:
     typedef SkShader INHERITED;
 };
 
diff --git a/src/core/SkBlitRow_D32.cpp b/src/core/SkBlitRow_D32.cpp
index f500778..642fe7f 100644
--- a/src/core/SkBlitRow_D32.cpp
+++ b/src/core/SkBlitRow_D32.cpp
@@ -128,7 +128,7 @@ SkBlitRow::Proc32 SkBlitRow::Factory32(unsigned flags) {
     SkASSERT(flags < SK_ARRAY_COUNT(gDefault_Procs32));
     // just so we don't crash
     flags &= kFlags32_Mask;
-    
+
     SkBlitRow::Proc32 proc = PlatformProcs32(flags);
     if (NULL == proc) {
         proc = gDefault_Procs32[flags];
@@ -146,7 +146,7 @@ SkBlitRow::Proc32 SkBlitRow::ColorProcFactory() {
     return proc;
 }
 
-void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[], 
+void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[],
                         int count, SkPMColor color) {
     if (count > 0) {
         if (0 == color) {
@@ -168,5 +168,84 @@ void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[],
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+static void D32_Mask_Color(void* dst, size_t dstRB, SkBitmap::Config,
+                           const uint8_t* mask, size_t maskRB, SkColor color,
+                           int width, int height) {
+    SkPMColor pmc = SkPreMultiplyColor(color);
+    size_t dstOffset = dstRB - (width << 2);
+    size_t maskOffset = maskRB - width;
+    SkPMColor *device = (SkPMColor *)dst;
+    do {
+        int w = width;
+        do {
+            unsigned aa = *mask++;
+            *device = SkBlendARGB32(pmc, *device, aa);
+            device += 1;
+        } while (--w != 0);
+        device = (uint32_t*)((char*)device + dstOffset);
+        mask += maskOffset;
+    } while (--height != 0);
+}
+
+static void D32_Mask_Opaque(void* dst, size_t dstRB, SkBitmap::Config,
+                            const uint8_t* mask, size_t maskRB, SkColor color,
+                            int width, int height) {
+    SkPMColor pmc = SkPreMultiplyColor(color);
+    uint32_t* device = (uint32_t*)dst;
+
+    maskRB -= width;
+    dstRB -= (width << 2);
+    do {
+        int w = width;
+        do {
+            unsigned aa = *mask++;
+            *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa)) + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
+            device += 1;
+        } while (--w != 0);
+        device = (uint32_t*)((char*)device + dstRB);
+        mask += maskRB;
+    } while (--height != 0);
+}
+
+static void D32_Mask_Black(void* dst, size_t dstRB, SkBitmap::Config,
+                           const uint8_t* mask, size_t maskRB, SkColor,
+                           int width, int height) {
+    uint32_t* device = (uint32_t*)dst;
 
+    maskRB -= width;
+    dstRB -= (width << 2);
+    do {
+        int w = width;
+        do {
+            unsigned aa = *mask++;
+            *device = (aa << SK_A32_SHIFT) + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
+            device += 1;
+        } while (--w != 0);
+        device = (uint32_t*)((char*)device + dstRB);
+        mask += maskRB;
+    } while (--height != 0);
+}
+
+SkBlitMask::Proc SkBlitMask::Factory(SkBitmap::Config config, SkColor color) {
+    SkBlitMask::Proc proc = PlatformProcs(config, color);
+    proc = NULL;
+    if (NULL == proc) {
+        switch (config) {
+            case SkBitmap::kARGB_8888_Config:
+                if (SK_ColorBLACK == color) {
+                    proc = D32_Mask_Black;
+                } else if (0xFF == SkColorGetA(color)) {
+                    proc = D32_Mask_Opaque;
+                } else {
+                    proc = D32_Mask_Color;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return proc;
+}
 
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index a775adb..d923315 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -38,6 +38,74 @@ extern uint32_t BlendLCDPixelWithBlack(const uint32_t alphaPixel, const uint32_t
 using namespace skia_blitter_support;
 #endif
 
+///////////////////////////////////////////////////////////////////////////////
+
+static int upscale31To256(int value) {
+    SkASSERT((unsigned)value <= 31);
+    // 0..31 -> 0..255
+    value = (value << 3) | (value >> 2);
+    // 0..255 -> 0..256
+    value += (value >> 7);
+    SkASSERT((unsigned)value <= 256);
+    return value;
+}
+
+static void blit_lcd16_opaque(SkPMColor dst[], const uint16_t src[],
+                              SkPMColor color, int width) {
+    int srcR = SkGetPackedR32(color);
+    int srcG = SkGetPackedG32(color);
+    int srcB = SkGetPackedB32(color);
+
+    for (int i = 0; i < width; i++) {
+        uint16_t mask = src[i];
+        if (0 == mask) {
+            continue;
+        }
+
+        /*  We want all of these in 5bits, hence the shifts in case one of them
+         *  (green) is 6bits.
+         */
+        int maskR = SkGetPackedR16(mask) >> (SK_R16_BITS - 5);
+        int maskG = SkGetPackedG16(mask) >> (SK_G16_BITS - 5);
+        int maskB = SkGetPackedB16(mask) >> (SK_B16_BITS - 5);
+
+        // Now upscale them to 0..256, so we can use SkAlphaBlend
+        maskR = upscale31To256(maskR);
+        maskG = upscale31To256(maskG);
+        maskB = upscale31To256(maskB);
+
+        int maskA = SkMax32(SkMax32(maskR, maskG), maskB);
+
+        SkPMColor d = dst[i];
+        int dstA = SkGetPackedA32(d);
+        int dstR = SkGetPackedR32(d);
+        int dstG = SkGetPackedG32(d);
+        int dstB = SkGetPackedB32(d);
+
+        dst[i] = SkPackARGB32(SkAlphaBlend(0xFF, dstA, maskA),
+                              SkAlphaBlend(srcR, dstR, maskR),
+                              SkAlphaBlend(srcG, dstG, maskG),
+                              SkAlphaBlend(srcB, dstB, maskB));
+    }
+}
+
+static void blitmask_lcd16(const SkBitmap& device, const SkMask& mask,
+                           const SkIRect& clip, SkPMColor srcColor) {
+    int x = clip.fLeft;
+    int y = clip.fTop;
+    int width = clip.width();
+    int height = clip.height();
+
+    SkPMColor*		dstRow = device.getAddr32(x, y);
+    const uint16_t* srcRow = mask.getAddrLCD16(x, y);
+
+    do {
+        blit_lcd16_opaque(dstRow, srcRow, srcColor, width);
+        dstRow = (SkPMColor*)((char*)dstRow + device.rowBytes());
+        srcRow = (const uint16_t*)((const char*)srcRow + mask.fRowBytes);
+    } while (--height != 0);
+}
+
 //////////////////////////////////////////////////////////////////////////////////////
 
 static void SkARGB32_Blit32(const SkBitmap& device, const SkMask& mask,
@@ -68,7 +136,8 @@ static void SkARGB32_Blit32(const SkBitmap& device, const SkMask& mask,
 
 SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
         : INHERITED(device) {
-    uint32_t color = paint.getColor();
+    SkColor color = paint.getColor();
+    fColor = color;
 
     fSrcA = SkColorGetA(color);
     unsigned scale = SkAlpha255To256(fSrcA);
@@ -78,6 +147,9 @@ SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
 
     fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
     fColor32Proc = SkBlitRow::ColorProcFactory();
+
+    // init the pro for blitmask
+    fBlitMaskProc = SkBlitMask::Factory(SkBitmap::kARGB_8888_Config, color);
 }
 
 const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
@@ -185,29 +257,18 @@ void SkARGB32_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
     } else if (SkMask::kARGB32_Format == mask.fFormat) {
 		SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
 		return;
+    } else if (SkMask::kLCD16_Format == mask.fFormat) {
+        blitmask_lcd16(fDevice, mask, clip, fPMColor);
+        return;
     }
 
     int x = clip.fLeft;
     int y = clip.fTop;
-    int width = clip.width();
-    int height = clip.height();
-
-    uint32_t*       device = fDevice.getAddr32(x, y);
-    const uint8_t*  alpha = mask.getAddr(x, y);
-    uint32_t        srcColor = fPMColor;
-    unsigned        devRB = fDevice.rowBytes() - (width << 2);
-    unsigned        maskRB = mask.fRowBytes - width;
 
-    do {
-        int w = width;
-        do {
-            unsigned aa = *alpha++;
-            *device = SkBlendARGB32(srcColor, *device, aa);
-            device += 1;
-        } while (--w != 0);
-        device = (uint32_t*)((char*)device + devRB);
-        alpha += maskRB;
-    } while (--height != 0);
+    fBlitMaskProc(fDevice.getAddr32(x, y), fDevice.rowBytes(),
+                  SkBitmap::kARGB_8888_Config,
+                  mask.getAddr(x, y), mask.fRowBytes,
+                  fColor, clip.width(), clip.height());
 }
 
 void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask,
@@ -220,6 +281,9 @@ void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask,
     } else if (SkMask::kARGB32_Format == mask.fFormat) {
 		SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
 		return;
+    } else if (SkMask::kLCD16_Format == mask.fFormat) {
+        blitmask_lcd16(fDevice, mask, clip, fPMColor);
+        return;
 	}
 
     int x = clip.fLeft;
@@ -233,7 +297,7 @@ void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask,
 #endif
 
     // In LCD mode the masks have either an extra couple of rows or columns on the edges.
-    uint32_t        srcColor = fPMColor;
+    SkPMColor srcColor = fPMColor;
 
 #if defined(SK_SUPPORT_LCDTEXT)
     if (lcdMode || verticalLCDMode) {
@@ -262,20 +326,9 @@ void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask,
     }
 #endif
 
-    uint32_t*      device = fDevice.getAddr32(x, y);
-    const uint8_t* alpha = mask.getAddr(x, y);
-    unsigned       maskRB = mask.fRowBytes - width;
-    unsigned       devRB = fDevice.rowBytes() - (width << 2);
-    do {
-        int w = width;
-        do {
-            unsigned aa = *alpha++;
-            *device = SkAlphaMulQ(srcColor, SkAlpha255To256(aa)) + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
-            device += 1;
-        } while (--w != 0);
-        device = (uint32_t*)((char*)device + devRB);
-        alpha += maskRB;
-    } while (--height != 0);
+    fBlitMaskProc(fDevice.getAddr32(x, y), fDevice.rowBytes(),
+                  SkBitmap::kARGB_8888_Config,
+                  mask.getAddr(x, y), mask.fRowBytes, fColor, width, height);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
@@ -340,6 +393,8 @@ void SkARGB32_Black_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
         SkARGB32_BlitBW(fDevice, mask, clip, black);
     } else if (SkMask::kARGB32_Format == mask.fFormat) {
 		SkARGB32_Blit32(fDevice, mask, clip, fPMColor);
+    } else if (SkMask::kLCD16_Format == mask.fFormat) {
+        blitmask_lcd16(fDevice, mask, clip, fPMColor);
     } else {
 #if defined(SK_SUPPORT_LCDTEXT)
         const bool      lcdMode = mask.fFormat == SkMask::kHorizontalLCD_Format;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 43634ef..2b7d588 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -72,8 +72,7 @@ struct DeviceCM {
     SkDevice*           fDevice;
     SkRegion            fClip;
     const SkMatrix*     fMatrix;
-	SkPaint*			fPaint;	// may be null (in the future)
-    int16_t             fX, fY; // relative to base matrix/clip
+    SkPaint*            fPaint; // may be null (in the future)
     // optional, related to canvas' external matrix
     const SkMatrix*     fMVMatrix;
     const SkMatrix*     fExtMatrix;
@@ -85,8 +84,6 @@ struct DeviceCM {
             device->lockPixels();
         }
         fDevice = device;
-        fX = SkToS16(x);
-        fY = SkToS16(y);
         fPaint = paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL;
 	}
 
@@ -100,8 +97,8 @@ struct DeviceCM {
 
     void updateMC(const SkMatrix& totalMatrix, const SkRegion& totalClip,
                   const SkClipStack& clipStack, SkRegion* updateClip) {
-        int x = fX;
-        int y = fY;
+        int x = fDevice->getOrigin().x();
+        int y = fDevice->getOrigin().y();
         int width = fDevice->width();
         int height = fDevice->height();
 
@@ -147,12 +144,6 @@ struct DeviceCM {
         fExtMatrix = &extM; // assumes extM has long life-time (owned by canvas)
     }
 
-    void translateClip() {
-        if (fX | fY) {
-            fClip.translate(fX, fY);
-        }
-    }
-
 private:
     SkMatrix    fMatrixStorage, fMVMatrixStorage;
 };
@@ -230,6 +221,7 @@ public:
         fCanvas = canvas;
         canvas->updateDeviceCMCache();
 
+        fClipStack = &canvas->getTotalClipStack();
         fBounder = canvas->getBounder();
         fCurrLayer = canvas->fMCRec->fTopLayer;
         fSkipEmptyClips = skipEmptyClips;
@@ -250,8 +242,6 @@ public:
             fClip   = &rec->fClip;
             fDevice = rec->fDevice;
             fBitmap = &fDevice->accessBitmap(true);
-            fLayerX = rec->fX;
-            fLayerY = rec->fY;
             fPaint  = rec->fPaint;
             fMVMatrix = rec->fMVMatrix;
             fExtMatrix = rec->fExtMatrix;
@@ -263,24 +253,23 @@ public:
             }
             // fCurrLayer may be NULL now
 
-            fCanvas->prepareForDeviceDraw(fDevice, *fMatrix, *fClip);
+            fCanvas->prepareForDeviceDraw(fDevice, *fMatrix, *fClip, *fClipStack);
             return true;
         }
         return false;
     }
 
-    int getX() const { return fLayerX; }
-    int getY() const { return fLayerY; }
     SkDevice* getDevice() const { return fDevice; }
+    int getX() const { return fDevice->getOrigin().x(); }
+    int getY() const { return fDevice->getOrigin().y(); }
     const SkMatrix& getMatrix() const { return *fMatrix; }
     const SkRegion& getClip() const { return *fClip; }
     const SkPaint* getPaint() const { return fPaint; }
+
 private:
     SkCanvas*       fCanvas;
     const DeviceCM* fCurrLayer;
     const SkPaint*  fPaint;     // May be null.
-    int             fLayerX;
-    int             fLayerY;
     SkBool8         fSkipEmptyClips;
 
     typedef SkDraw INHERITED;
@@ -631,10 +620,11 @@ void SkCanvas::updateDeviceCMCache() {
 }
 
 void SkCanvas::prepareForDeviceDraw(SkDevice* device, const SkMatrix& matrix,
-                                    const SkRegion& clip) {
+                                    const SkRegion& clip,
+                                    const SkClipStack& clipStack) {
     SkASSERT(device);
     if (fLastDeviceToGainFocus != device) {
-        device->gainFocus(this, matrix, clip);
+        device->gainFocus(this, matrix, clip, clipStack);
         fLastDeviceToGainFocus = device;
     }
 }
@@ -746,6 +736,7 @@ int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
 
     SkDevice* device = this->createDevice(config, ir.width(), ir.height(),
                                           isOpaque, true);
+    device->setOrigin(ir.fLeft, ir.fTop);
     DeviceCM* layer = SkNEW_ARGS(DeviceCM, (device, ir.fLeft, ir.fTop, paint));
     device->unref();
 
@@ -798,7 +789,8 @@ void SkCanvas::internalRestore() {
     */
     if (NULL != layer) {
         if (layer->fNext) {
-            this->drawDevice(layer->fDevice, layer->fX, layer->fY,
+            const SkIPoint& origin = layer->fDevice->getOrigin();
+            this->drawDevice(layer->fDevice, origin.x(), origin.y(),
                              layer->fPaint);
             // reset this, since drawDevice will have set it to true
             fDeviceCMDirty = true;
@@ -952,10 +944,23 @@ bool SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op) {
 
 static bool clipPathHelper(const SkCanvas* canvas, SkRegion* currRgn,
                            const SkPath& devPath, SkRegion::Op op) {
+    // base is used to limit the size (and therefore memory allocation) of the
+    // region that results from scan converting devPath.
+    SkRegion base;
+
     if (SkRegion::kIntersect_Op == op) {
-        return currRgn->setPath(devPath, *currRgn);
+        // since we are intersect, we can do better (tighter) with currRgn's
+        // bounds, than just using the device. However, if currRgn is complex,
+        // our region blitter may hork, so we do that case in two steps.
+        if (currRgn->isRect()) {
+            return currRgn->setPath(devPath, *currRgn);
+        } else {
+            base.setRect(currRgn->getBounds());
+            SkRegion rgn;
+            rgn.setPath(devPath, base);
+            return currRgn->op(rgn, op);
+        }
     } else {
-        SkRegion base;
         const SkBitmap& bm = canvas->getDevice()->accessBitmap(false);
         base.setRect(0, 0, bm.width(), bm.height());
 
@@ -1016,13 +1021,15 @@ void SkCanvas::validateClip() const {
             clip->fRect->round(&ir);
             clipRgn.op(ir, clip->fOp);
         } else {
-            break;
+            clipRgn.setEmpty();
         }
     }
 
+#if 0   // enable this locally for testing
     // now compare against the current rgn
     const SkRegion& rgn = this->getTotalClip();
     SkASSERT(rgn == clipRgn);
+#endif
 }
 #endif
 
@@ -1149,6 +1156,10 @@ const SkRegion& SkCanvas::getTotalClip() const {
     return *fMCRec->fRegion;
 }
 
+const SkClipStack& SkCanvas::getTotalClipStack() const {
+    return fClipStack;
+}
+
 void SkCanvas::setExternalMatrix(const SkMatrix* matrix) {
     if (NULL == matrix || matrix->isIdentity()) {
         if (fUseExternalMatrix) {
@@ -1390,6 +1401,7 @@ void SkCanvas::drawTextOnPath(const void* text, size_t byteLength,
     ITER_END
 }
 
+#ifdef ANDROID
 void SkCanvas::drawPosTextOnPath(const void* text, size_t byteLength,
                                  const SkPoint pos[], const SkPaint& paint,
                                  const SkPath& path, const SkMatrix* matrix) {
@@ -1403,6 +1415,7 @@ void SkCanvas::drawPosTextOnPath(const void* text, size_t byteLength,
 
     ITER_END
 }
+#endif
 
 void SkCanvas::drawVertices(VertexMode vmode, int vertexCount,
                             const SkPoint verts[], const SkPoint texs[],
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 2b63aea..864f23a 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -116,7 +116,11 @@ void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op) {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkClipStack::B2FIter::B2FIter(const SkClipStack& stack) : fIter(stack.fDeque) {
+SkClipStack::B2FIter::B2FIter() {
+}
+
+SkClipStack::B2FIter::B2FIter(const SkClipStack& stack) {
+    this->reset(stack);
 }
 
 const SkClipStack::B2FIter::Clip* SkClipStack::B2FIter::next() {
@@ -142,3 +146,7 @@ const SkClipStack::B2FIter::Clip* SkClipStack::B2FIter::next() {
     fClip.fOp = rec->fOp;
     return &fClip;
 }
+
+void SkClipStack::B2FIter::reset(const SkClipStack& stack) {
+    fIter.reset(stack.fDeque);
+}
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 32e8035..b8724c2 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -101,8 +101,10 @@ public:
     virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
 
 protected:
-    SkColor                fPMColor;
+    SkColor                fColor;
+    SkPMColor              fPMColor;
     SkBlitRow::ColorProc   fColor32Proc;
+    SkBlitMask::Proc       fBlitMaskProc;
 
 private:
     unsigned fSrcA, fSrcR, fSrcG, fSrcB;
@@ -165,7 +167,7 @@ private:
 
     // illegal
     SkA1_Blitter& operator=(const SkA1_Blitter&);
-    
+
     typedef SkRasterBlitter INHERITED;
 };
 
@@ -175,7 +177,7 @@ private:
 
     Currently, they make the following assumptions about the state of the
     paint:
- 
+
     1. If there is an xfermode, there will also be a shader
     2. If there is a colorfilter, there will be a shader that itself handles
        calling the filter, so the blitter can always ignore the colorfilter obj
diff --git a/src/core/SkDeque.cpp b/src/core/SkDeque.cpp
index 2c6ce64..9d685ee 100644
--- a/src/core/SkDeque.cpp
+++ b/src/core/SkDeque.cpp
@@ -225,12 +225,12 @@ void SkDeque::pop_back() {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkDeque::F2BIter::F2BIter(const SkDeque& d) : fElemSize(d.fElemSize) {
-    fHead = d.fFront;
-    while (fHead != NULL && fHead->fBegin == NULL) {
-        fHead = fHead->fNext;
-    }
-    fPos = fHead ? fHead->fBegin : NULL;
+SkDeque::F2BIter::F2BIter() {
+    fPos = NULL;
+}
+
+SkDeque::F2BIter::F2BIter(const SkDeque& d) {
+    this->reset(d);
 }
 
 void* SkDeque::F2BIter::next() {
@@ -250,3 +250,11 @@ void* SkDeque::F2BIter::next() {
     return pos;
 }
 
+void SkDeque::F2BIter::reset(const SkDeque& d) {
+    fElemSize = d.fElemSize;
+    fHead = d.fFront;
+    while (fHead != NULL && fHead->fBegin == NULL) {
+        fHead = fHead->fNext;
+    }
+    fPos = fHead ? fHead->fBegin : NULL;
+}
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 2921be0..619a371 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -4,10 +4,13 @@
 
 SkDeviceFactory::~SkDeviceFactory() {}
 
-SkDevice::SkDevice(SkCanvas* canvas) : fCanvas(canvas) {}
+SkDevice::SkDevice(SkCanvas* canvas) : fCanvas(canvas) {
+    fOrigin.setZero();
+}
 
 SkDevice::SkDevice(SkCanvas* canvas, const SkBitmap& bitmap, bool isForLayer)
         : fCanvas(canvas), fBitmap(bitmap) {
+    fOrigin.setZero();
     // auto-allocate if we're for offscreen drawing
     if (isForLayer) {
         if (NULL == fBitmap.getPixels() && NULL == fBitmap.pixelRef()) {
@@ -150,11 +153,13 @@ void SkDevice::drawTextOnPath(const SkDraw& draw, const void* text,
     draw.drawTextOnPath((const char*)text, len, path, matrix, paint);
 }
 
+#ifdef ANDROID
 void SkDevice::drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
                                      const SkPoint pos[], const SkPaint& paint,
                                      const SkPath& path, const SkMatrix* matrix) {
     draw.drawPosTextOnPath((const char*)text, len, pos, paint, path, matrix);
 }
+#endif
 
 void SkDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
                                 int vertexCount,
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 05e249a..ce0fa9b 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -1940,6 +1940,7 @@ void SkDraw::drawTextOnPath(const char text[], size_t byteLength,
     }
 }
 
+#ifdef ANDROID
 void SkDraw::drawPosTextOnPath(const char text[], size_t byteLength,
                                const SkPoint pos[], const SkPaint& paint,
                                const SkPath& path, const SkMatrix* matrix) const {
@@ -2001,6 +2002,7 @@ void SkDraw::drawPosTextOnPath(const char text[], size_t byteLength,
     // re-attach cache
     SkGlyphCache::AttachCache(cache);
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp
index 199ac14..b97699c 100644
--- a/src/core/SkGlyphCache.cpp
+++ b/src/core/SkGlyphCache.cpp
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -37,7 +37,7 @@
     static void RecordHashCollisionIf(bool pred) {
         if (pred) {
             gHashCollision += 1;
-            
+
             uint32_t total = gHashSuccess + gHashCollision;
             SkDebugf("Font Cache Hash success rate: %d%%\n",
                      100 * gHashSuccess / total);
@@ -68,9 +68,9 @@ SkGlyphCache::SkGlyphCache(const SkDescriptor* desc)
     memset(fGlyphHash, 0, sizeof(fGlyphHash));
     // init with 0xFF so that the charCode field will be -1, which is invalid
     memset(fCharToGlyphHash, 0xFF, sizeof(fCharToGlyphHash));
-    
+
     fMemoryUsed = sizeof(*this) + kMinGlphAlloc + kMinImageAlloc;
-    
+
     fGlyphArray.setReserve(METRICS_RESERVE_COUNT);
 
     fMetricsCount = 0;
@@ -105,7 +105,7 @@ uint16_t SkGlyphCache::unicharToGlyph(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
     const CharGlyphRec& rec = fCharToGlyphHash[ID2HashIndex(id)];
-    
+
     if (rec.fID == id) {
         return rec.fGlyph->getGlyphID();
     } else {
@@ -117,13 +117,17 @@ SkUnichar SkGlyphCache::glyphToUnichar(uint16_t glyphID) {
     return fScalerContext->glyphIDToChar(glyphID);
 }
 
+unsigned SkGlyphCache::getGlyphCount() {
+    return fScalerContext->getGlyphCount();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkGlyph& SkGlyphCache::getUnicharAdvance(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
     CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
-    
+
     if (rec->fID != id) {
         // this ID is based on the UniChar
         rec->fID = id;
@@ -153,7 +157,7 @@ const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode) {
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode);
     CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
-    
+
     if (rec->fID != id) {
         RecordHashCollisionIf(rec->fGlyph != NULL);
         // this ID is based on the UniChar
@@ -176,7 +180,7 @@ const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode,
     VALIDATE();
     uint32_t id = SkGlyph::MakeID(charCode, x, y);
     CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)];
-    
+
     if (rec->fID != id) {
         RecordHashCollisionIf(rec->fGlyph != NULL);
         // this ID is based on the UniChar
@@ -199,7 +203,7 @@ const SkGlyph& SkGlyphCache::getGlyphIDMetrics(uint16_t glyphID) {
     uint32_t id = SkGlyph::MakeID(glyphID);
     unsigned index = ID2HashIndex(id);
     SkGlyph* glyph = fGlyphHash[index];
-    
+
     if (NULL == glyph || glyph->fID != id) {
         RecordHashCollisionIf(glyph != NULL);
         glyph = this->lookupMetrics(glyphID, kFull_MetricsType);
@@ -275,7 +279,7 @@ SkGlyph* SkGlyphCache::lookupMetrics(uint32_t id, MetricsType mtype) {
                                         SkChunkAlloc::kThrow_AllocFailType);
     glyph->init(id);
     *fGlyphArray.insert(hi) = glyph;
-    
+
     if (kJustAdvance_MetricsType == mtype) {
         fScalerContext->getAdvance(glyph);
         fAdvanceCount += 1;
@@ -294,8 +298,11 @@ const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
             size_t  size = glyph.computeImageSize();
             const_cast<SkGlyph&>(glyph).fImage = fImageAlloc.alloc(size,
                                         SkChunkAlloc::kReturnNil_AllocFailType);
-            fScalerContext->getImage(glyph);
-            fMemoryUsed += size;
+            // check that alloc() actually succeeded
+            if (glyph.fImage) {
+                fScalerContext->getImage(glyph);
+                fMemoryUsed += size;
+            }
         }
     }
     return glyph.fImage;
@@ -391,7 +398,7 @@ void SkGlyphCache::invokeAndRemoveAuxProcs() {
     #define HASH_BITCOUNT   6
     #define HASH_COUNT      (1 << HASH_BITCOUNT)
     #define HASH_MASK       (HASH_COUNT - 1)
-    
+
     static unsigned desc_to_hashindex(const SkDescriptor* desc)
     {
         SkASSERT(HASH_MASK < 256);  // since our munging reduces to 8 bits
@@ -446,9 +453,9 @@ void SkGlyphCache::VisitAllCaches(bool (*proc)(SkGlyphCache*, void*),
     SkGlyphCache_Globals& globals = FIND_GC_GLOBALS();
     SkAutoMutexAcquire    ac(globals.fMutex);
     SkGlyphCache*         cache;
-    
+
     globals.validate();
-    
+
     for (cache = globals.fHead; cache != NULL; cache = cache->fNext) {
         if (proc(cache, context)) {
             break;
@@ -560,7 +567,7 @@ void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
 size_t SkGlyphCache::GetCacheUsed() {
     SkGlyphCache_Globals& globals = FIND_GC_GLOBALS();
     SkAutoMutexAcquire  ac(globals.fMutex);
-    
+
     return SkGlyphCache::ComputeMemoryUsed(globals.fHead);
 }
 
@@ -570,7 +577,7 @@ bool SkGlyphCache::SetCacheUsed(size_t bytesUsed) {
     if (curr > bytesUsed) {
         SkGlyphCache_Globals& globals = FIND_GC_GLOBALS();
         SkAutoMutexAcquire  ac(globals.fMutex);
-    
+
         return InternalFreeCache(&globals, curr - bytesUsed) > 0;
     }
     return false;
@@ -589,7 +596,7 @@ SkGlyphCache* SkGlyphCache::FindTail(SkGlyphCache* cache) {
 
 size_t SkGlyphCache::ComputeMemoryUsed(const SkGlyphCache* head) {
     size_t size = 0;
-    
+
     while (head != NULL) {
         size += head->fMemoryUsed;
         head = head->fNext;
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index 16330f8..d6b4fd6 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -77,6 +77,10 @@ public:
     */
     SkUnichar glyphToUnichar(uint16_t);
 
+    /** Returns the number of glyphs for this strike.
+    */
+    unsigned getGlyphCount();
+
     /** Return the image associated with the glyph. If it has not been generated
         this will trigger that.
     */
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 845896a..fa886c8 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -246,8 +246,9 @@ void SkPaint::setStyle(Style style)
         }
     }
 #ifdef SK_DEBUG
-    else
+    else {
         SkDebugf("SkPaint::setStyle(%d) out of range\n", style);
+    }
 #endif
 }
 
@@ -286,8 +287,9 @@ void SkPaint::setStrokeWidth(SkScalar width)
         }
     }
 #ifdef SK_DEBUG
-    else
+    else {
         SkDebugf("SkPaint::setStrokeWidth() called with negative value\n");
+    }
 #endif
 }
 
@@ -300,8 +302,9 @@ void SkPaint::setStrokeMiter(SkScalar limit)
         }
     }
 #ifdef SK_DEBUG
-    else
+    else {
         SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");
+    }
 #endif
 }
 
@@ -1251,6 +1254,22 @@ static void add_flattenable(SkDescriptor* desc, uint32_t tag,
     buffer->flatten(desc->addEntry(tag, buffer->size(), NULL));
 }
 
+static bool canSupportLCD16(const SkPaint& paint) {
+#if 0
+    return  !paint.getShader() &&
+            !paint.getXfermode() && // unless its srcover
+            !paint.getMaskFilter() &&
+            !paint.getRasterizer() &&
+            !paint.getColorFilter() &&
+            !paint.getPathEffect() &&
+            !paint.isFakeBoldText() &&
+            paint.getStyle() == SkPaint::kFill_Style;
+#else
+    // disable for now, while we test more
+    return false;
+#endif
+}
+
 static SkMask::Format computeMaskFormat(const SkPaint& paint) {
     uint32_t flags = paint.getFlags();
 
@@ -1258,6 +1277,12 @@ static SkMask::Format computeMaskFormat(const SkPaint& paint) {
     if (!(flags & SkPaint::kAntiAlias_Flag))
         return SkMask::kBW_Format;
 
+    if (flags & SkPaint::kLCDRenderText_Flag) {
+        if (canSupportLCD16(paint)) {
+            return SkMask::kLCD16_Format;
+        }
+    }
+
 #if defined(SK_SUPPORT_LCDTEXT)
     if (flags & SkPaint::kLCDRenderText_Flag) {
         return SkFontHost::GetSubpixelOrientation() == SkFontHost::kHorizontal_LCDOrientation ?
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 4962239..867aac5 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -157,6 +157,7 @@ void SkPath::reset() {
     fVerbs.reset();
     fGenerationID++;
     fBoundsIsDirty = true;
+    fIsConvex = false;  // really should be kUnknown
 }
 
 void SkPath::rewind() {
@@ -166,6 +167,7 @@ void SkPath::rewind() {
     fVerbs.rewind();
     fGenerationID++;
     fBoundsIsDirty = true;
+    fIsConvex = false;  // really should be kUnknown
 }
 
 bool SkPath::isEmpty() const {
diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp
index c376412..f558f52 100644
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -35,7 +35,7 @@ void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
 
 void SkPixelRef::lockPixels() {
     SkAutoMutexAcquire  ac(*fMutex);
-    
+
     if (1 == ++fLockCount) {
         fPixels = this->onLockPixels(&fColorTable);
     }
@@ -43,7 +43,7 @@ void SkPixelRef::lockPixels() {
 
 void SkPixelRef::unlockPixels() {
     SkAutoMutexAcquire  ac(*fMutex);
-    
+
     SkASSERT(fLockCount > 0);
     if (0 == --fLockCount) {
         this->onUnlockPixels();
@@ -94,15 +94,15 @@ static Pair gPairs[MAX_PAIR_COUNT];
 void SkPixelRef::Register(const char name[], Factory factory) {
     SkASSERT(name);
     SkASSERT(factory);
-    
+
     static bool gOnce;
     if (!gOnce) {
         gCount = 0;
         gOnce = true;
     }
-    
+
     SkASSERT(gCount < MAX_PAIR_COUNT);
-    
+
     gPairs[gCount].fName = name;
     gPairs[gCount].fFactory = factory;
     gCount += 1;
@@ -128,6 +128,9 @@ const char* SkPixelRef::FactoryToName(Factory fact) {
     return NULL;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef ANDROID
 void SkPixelRef::globalRef(void* data) {
     this->ref();
 }
@@ -135,3 +138,4 @@ void SkPixelRef::globalRef(void* data) {
 void SkPixelRef::globalUnref() {
     this->unref();
 }
+#endif
diff --git a/src/core/SkRefCnt.cpp b/src/core/SkRefCnt.cpp
deleted file mode 100644
index fea1005..0000000
--- a/src/core/SkRefCnt.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/* libs/graphics/sgl/SkRefCnt.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkRefCnt.h"
-
-SkAutoUnref::~SkAutoUnref() {
-    if (fObj) {
-        fObj->unref();
-    }
-}
-
-bool SkAutoUnref::ref() {
-    if (fObj) {
-        fObj->ref();
-        return true;
-    }
-    return false;
-}
-
-bool SkAutoUnref::unref() {
-    if (fObj) {
-        fObj->unref();
-        fObj = NULL;
-        return true;
-    }
-    return false;
-}
-
-SkRefCnt* SkAutoUnref::detach() {
-    SkRefCnt* obj = fObj;
-    fObj = NULL;
-    return obj;
-}
-
diff --git a/src/core/SkRegion.cpp b/src/core/SkRegion.cpp
index dfb3aa0..18dafb0 100644
--- a/src/core/SkRegion.cpp
+++ b/src/core/SkRegion.cpp
@@ -18,7 +18,10 @@
 #include "SkRegionPriv.h"
 #include "SkTemplates.h"
 #include "SkThread.h"
+
+#ifdef ANDROID
 #include <stdio.h>
+#endif
 
 SkDEBUGCODE(int32_t gRgnAllocCounter;)
 
@@ -191,6 +194,7 @@ bool SkRegion::op(const SkRegion& rgn, const SkIRect& rect, Op op)
 
 //////////////////////////////////////////////////////////////////////////////////////
 
+#ifdef ANDROID
 char* SkRegion::toString()
 {
     Iterator iter(*this);
@@ -215,6 +219,7 @@ char* SkRegion::toString()
     count += sprintf(result+count, ")");
     return result;
 }
+#endif
 
 //////////////////////////////////////////////////////////////////////////////////////
 
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 697917a..ff8e168 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -497,6 +497,7 @@ void SkScalerContext::getImage(const SkGlyph& origGlyph) {
 
     if (NULL == fMaskFilter &&
         fRec.fMaskFormat != SkMask::kBW_Format &&
+        fRec.fMaskFormat != SkMask::kLCD16_Format &&
         (fRec.fFlags & (kGammaForBlack_Flag | kGammaForWhite_Flag)) != 0)
     {
         const uint8_t* table = (fRec.fFlags & kGammaForBlack_Flag) ? gBlackGammaTable : gWhiteGammaTable;
@@ -645,7 +646,7 @@ public:
     SkScalerContext_Empty(const SkDescriptor* desc) : SkScalerContext(desc) {}
 
 protected:
-    virtual unsigned generateGlyphCount() const {
+    virtual unsigned generateGlyphCount() {
         return 0;
     }
     virtual uint16_t generateCharToGlyph(SkUnichar uni) {
diff --git a/src/core/SkScanPriv.h b/src/core/SkScanPriv.h
index 74c2ee7..e78feed 100644
--- a/src/core/SkScanPriv.h
+++ b/src/core/SkScanPriv.h
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -40,9 +40,9 @@ void sk_fill_path(const SkPath& path, const SkIRect* clipRect,
                   SkBlitter* blitter, int start_y, int stop_y, int shiftEdgesUp,
                   const SkRegion& clipRgn);
 
-// blit the rects above and below avoid, clipped to clp
-void sk_blit_above_and_below(SkBlitter* blitter, const SkIRect& avoid,
-                             const SkRegion& clip);
+// blit the rects above and below avoid, clipped to clip
+void sk_blit_above(SkBlitter*, const SkIRect& avoid, const SkRegion& clip);
+void sk_blit_below(SkBlitter*, const SkIRect& avoid, const SkRegion& clip);
 
 #endif
 
diff --git a/src/core/SkScan_AntiPath.cpp b/src/core/SkScan_AntiPath.cpp
index fb33ab0..90a1f68 100644
--- a/src/core/SkScan_AntiPath.cpp
+++ b/src/core/SkScan_AntiPath.cpp
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -56,12 +56,12 @@ protected:
 BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                                    const SkRegion& clip) {
     fRealBlitter = realBlitter;
-    
+
     // take the union of the ir bounds and clip, since we may be called with an
     // inverse filltype
     const int left = SkMin32(ir.fLeft, clip.getBounds().fLeft);
     const int right = SkMax32(ir.fRight, clip.getBounds().fRight);
-    
+
     fLeft = left;
     fSuperLeft = left << SHIFT;
     fWidth = right - left;
@@ -153,7 +153,7 @@ void SuperBlitter::blitH(int x, int y, int width)
 //  int maxValue = (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT);
 
 #if 0
-    SkAntiRun<SHIFT>    arun;   
+    SkAntiRun<SHIFT>    arun;
     arun.set(x, x + width);
     fRuns.add(x >> SHIFT, arun.getStartAlpha(), arun.getMiddleCount(), arun.getStopAlpha(), maxValue);
 #else
@@ -215,11 +215,11 @@ public:
     {
         int width = bounds.width();
         int rb = SkAlign4(width);
-        
+
         return (width <= MaskSuperBlitter::kMAX_WIDTH) &&
         (rb * bounds.height() <= MaskSuperBlitter::kMAX_STORAGE);
     }
-    
+
 private:
     enum {
         kMAX_WIDTH = 32,    // so we don't try to do very wide things, where the RLE blitter would be faster
@@ -242,10 +242,10 @@ MaskSuperBlitter::MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
     fMask.fBounds   = ir;
     fMask.fRowBytes = ir.width();
     fMask.fFormat   = SkMask::kA8_Format;
-    
+
     fClipRect = ir;
     fClipRect.intersect(clip.getBounds());
-    
+
     // For valgrind, write 1 extra byte at the end so we don't read
     // uninitialized memory. See comment in add_aa_span and fStorage[].
     memset(fStorage, 0, fMask.fBounds.height() * fMask.fRowBytes + 1);
@@ -292,7 +292,7 @@ static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount, U8CPU
 void MaskSuperBlitter::blitH(int x, int y, int width)
 {
     int iy = (y >> SHIFT);
-    
+
     SkASSERT(iy >= fMask.fBounds.fTop && iy < fMask.fBounds.fBottom);
     iy -= fMask.fBounds.fTop;   // make it relative to 0
 
@@ -309,7 +309,7 @@ void MaskSuperBlitter::blitH(int x, int y, int width)
         SkASSERT(ix >= fMask.fBounds.fLeft && ix < fMask.fBounds.fRight);
     }
 #endif
-    
+
     x -= (fMask.fBounds.fLeft << SHIFT);
 
     // hack, until I figure out why my cubics (I think) go beyond the bounds
@@ -397,12 +397,12 @@ void SkScan::AntiFillPath(const SkPath& path, const SkRegion& clip,
         }
         return;
     }
-    
+
     // now use the (possibly wrapped) blitter
     blitter = clipper.getBlitter();
 
     if (path.isInverseFillType()) {
-        sk_blit_above_and_below(blitter, ir, clip);
+        sk_blit_above(blitter, ir, clip);
     }
 
     SkIRect superRect, *superClipRect = NULL;
@@ -429,4 +429,8 @@ void SkScan::AntiFillPath(const SkPath& path, const SkRegion& clip,
         SuperBlitter    superBlit(blitter, ir, clip);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, clip);
     }
+
+    if (path.isInverseFillType()) {
+        sk_blit_below(blitter, ir, clip);
+    }
 }
diff --git a/src/core/SkScan_Path.cpp b/src/core/SkScan_Path.cpp
index b1ba7df..c5088a1 100644
--- a/src/core/SkScan_Path.cpp
+++ b/src/core/SkScan_Path.cpp
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -75,7 +75,7 @@ static void backward_insert_edge_based_on_x(SkEdge* edge SkDECLAREPARAM(int, cur
     for (;;)
     {
         SkEdge* prev = edge->fPrev;
-        
+
         // add 1 to curr_y since we may have added new edges (built from curves)
         // that start on the next scanline
         SkASSERT(prev && prev->fFirstY <= curr_y + 1);
@@ -145,11 +145,11 @@ static void walk_edges(SkEdge* prevHead, SkPath::FillType fillType,
         SkFixed prevX = prevHead->fX;
 
         validate_edges_for_y(currE, curr_y);
-        
+
         if (proc) {
             proc(blitter, curr_y, PREPOST_START);    // pre-proc
         }
-        
+
         while (currE->fFirstY <= curr_y)
         {
             SkASSERT(currE->fLastY >= curr_y);
@@ -181,7 +181,7 @@ static void walk_edges(SkEdge* prevHead, SkPath::FillType fillType,
                     if (((SkCubicEdge*)currE)->updateCubic())
                     {
                         SkASSERT(currE->fFirstY == curr_y + 1);
-                        
+
                         newX = currE->fX;
                         goto NEXT_X;
                     }
@@ -210,7 +210,7 @@ static void walk_edges(SkEdge* prevHead, SkPath::FillType fillType,
             currE = next;
             SkASSERT(currE);
         }
-        
+
         if (proc) {
             proc(blitter, curr_y, PREPOST_END);    // post-proc
         }
@@ -257,7 +257,7 @@ public:
         }
         fPrevX = x + width;
     }
-    
+
     // we do not expect to get called with these entrypoints
     virtual void blitAntiH(int, int, const SkAlpha[], const int16_t runs[]) {
         SkASSERT(!"blitAntiH unexpected");
@@ -275,7 +275,7 @@ public:
         SkASSERT(!"justAnOpaqueColor unexpected");
         return NULL;
     }
-    
+
 private:
     SkBlitter*  fBlitter;
     int         fFirstX, fLastX, fPrevX;
@@ -313,7 +313,7 @@ static int build_edges(SkEdge edge[], const SkPath& path,
     SkPath::Iter    iter(path, true);
     SkPoint         pts[4];
     SkPath::Verb    verb;
-    
+
     SkQuadClipper qclipper;
     if (clipRect) {
         SkIRect r;
@@ -355,7 +355,7 @@ static int build_edges(SkEdge edge[], const SkPath& path,
             case SkPath::kCubic_Verb: {
                 SkPoint tmp[10];
                 SkPoint* p = tmp;
-                int     count = SkChopCubicAtYExtrema(pts, tmp);                
+                int     count = SkChopCubicAtYExtrema(pts, tmp);
                 SkASSERT(count >= 0 && count <= 2);
 
                 do {
@@ -417,7 +417,7 @@ static int worst_case_edge_count(const SkPath& path, size_t* storage)
 */
 static int cheap_worst_case_edge_count(const SkPath& path, size_t* storage) {
     int ptCount = path.getPoints(NULL, 0);
-    // worst case is curve, close, curve, close, as that is 
+    // worst case is curve, close, curve, close, as that is
     //     2 lines per pt, or             : pts * 2
     //     2 quads + 1 line per 2 pts, or : pts * 3 / 2
     //     3 cubics + 1 line per 3 pts    : pts * 4 / 3
@@ -442,15 +442,15 @@ extern "C" {
     static int edge_compare(const void* a, const void* b) {
         const SkEdge* edgea = *(const SkEdge**)a;
         const SkEdge* edgeb = *(const SkEdge**)b;
-        
+
         int valuea = edgea->fFirstY;
         int valueb = edgeb->fFirstY;
-        
+
         if (valuea == valueb) {
             valuea = edgea->fX;
             valueb = edgeb->fX;
         }
-        
+
         // this overflows if valuea >>> valueb or vice-versa
         //     return valuea - valueb;
         // do perform the slower but safe compares
@@ -460,13 +460,13 @@ extern "C" {
 
 static SkEdge* sort_edges(SkEdge* list[], int count, SkEdge** last) {
     qsort(list, count, sizeof(SkEdge*), edge_compare);
-    
+
     // now make the edges linked in sorted order
     for (int i = 1; i < count; i++) {
         list[i - 1]->fNext = list[i];
         list[i]->fPrev = list[i - 1];
     }
-    
+
     *last = list[count - 1];
     return list[0];
 }
@@ -483,7 +483,7 @@ void sk_fill_path(const SkPath& path, const SkIRect* clipRect, SkBlitter* blitte
 
 #ifdef USE_NEW_BUILDER
     SkEdgeBuilder   builder;
-    
+
     int count = builder.build(path, clipRect, shiftEdgesUp);
     SkEdge**    list = builder.edgeList();
 #else
@@ -494,7 +494,7 @@ void sk_fill_path(const SkPath& path, const SkIRect* clipRect, SkBlitter* blitte
     {
         size_t  size2;
         int     maxCount2 = worst_case_edge_count(path, &size2);
-        
+
         SkASSERT(maxCount >= maxCount2 && size >= size2);
     }
 #endif
@@ -557,20 +557,25 @@ void sk_fill_path(const SkPath& path, const SkIRect* clipRect, SkBlitter* blitte
     walk_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, proc);
 }
 
-void sk_blit_above_and_below(SkBlitter* blitter, const SkIRect& ir,
-                             const SkRegion& clip) {
+void sk_blit_above(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
     const SkIRect& cr = clip.getBounds();
     SkIRect tmp;
-    
+
     tmp.fLeft = cr.fLeft;
     tmp.fRight = cr.fRight;
-
     tmp.fTop = cr.fTop;
     tmp.fBottom = ir.fTop;
     if (!tmp.isEmpty()) {
         blitter->blitRectRegion(tmp, clip);
     }
+}
+
+void sk_blit_below(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
+    const SkIRect& cr = clip.getBounds();
+    SkIRect tmp;
 
+    tmp.fLeft = cr.fLeft;
+    tmp.fRight = cr.fRight;
     tmp.fTop = ir.fBottom;
     tmp.fBottom = cr.fBottom;
     if (!tmp.isEmpty()) {
@@ -635,10 +640,15 @@ void SkScan::FillPath(const SkPath& path, const SkRegion& clip,
 
     blitter = clipper.getBlitter();
     if (blitter) {
+        // we have to keep our calls to blitter in sorted order, so we
+        // must blit the above section first, then the middle, then the bottom.
         if (path.isInverseFillType()) {
-            sk_blit_above_and_below(blitter, ir, clip);
+            sk_blit_above(blitter, ir, clip);
         }
         sk_fill_path(path, clipper.getClipRect(), blitter, ir.fTop, ir.fBottom, 0, clip);
+        if (path.isInverseFillType()) {
+            sk_blit_below(blitter, ir, clip);
+        }
     } else {
         // what does it mean to not have a blitter if path.isInverseFillType???
     }
@@ -649,7 +659,7 @@ void SkScan::FillPath(const SkPath& path, const SkRegion& clip,
 static int build_tri_edges(SkEdge edge[], const SkPoint pts[],
                            const SkIRect* clipRect, SkEdge* list[]) {
     SkEdge** start = list;
-    
+
     if (edge->setLine(pts[0], pts[1], clipRect, 0)) {
         *list++ = edge;
         edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
@@ -668,7 +678,7 @@ static int build_tri_edges(SkEdge edge[], const SkPoint pts[],
 static void sk_fill_triangle(const SkPoint pts[], const SkIRect* clipRect,
                              SkBlitter* blitter, const SkIRect& ir) {
     SkASSERT(pts && blitter);
-    
+
     SkEdge edgeStorage[3];
     SkEdge* list[3];
 
@@ -681,18 +691,18 @@ static void sk_fill_triangle(const SkPoint pts[], const SkIRect* clipRect,
 
     // this returns the first and last edge after they're sorted into a dlink list
     SkEdge* edge = sort_edges(list, count, &last);
-    
+
     headEdge.fPrev = NULL;
     headEdge.fNext = edge;
     headEdge.fFirstY = kEDGE_HEAD_Y;
     headEdge.fX = SK_MinS32;
     edge->fPrev = &headEdge;
-    
+
     tailEdge.fPrev = last;
     tailEdge.fNext = NULL;
     tailEdge.fFirstY = kEDGE_TAIL_Y;
     last->fNext = &tailEdge;
-    
+
     // now edge is the head of the sorted linklist
     int stop_y = ir.fBottom;
     if (clipRect && stop_y > clipRect->fBottom) {
@@ -710,7 +720,7 @@ void SkScan::FillTriangle(const SkPoint pts[], const SkRegion* clip,
     if (clip && clip->isEmpty()) {
         return;
     }
-    
+
     SkRect  r;
     SkIRect ir;
     r.set(pts, 3);
@@ -718,9 +728,9 @@ void SkScan::FillTriangle(const SkPoint pts[], const SkRegion* clip,
     if (ir.isEmpty()) {
         return;
     }
-    
+
     SkScanClipper   clipper(blitter, clip, ir);
-    
+
     blitter = clipper.getBlitter();
     if (NULL != blitter) {
         sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 7b3a024..8e469f2 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -2,19 +2,20 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
+#include "SkScalar.h"
 #include "SkShader.h"
 #include "SkPaint.h"
 #include "SkMallocPixelRef.h"
@@ -119,7 +120,7 @@ void SkShader::shadeSpan16(int x, int y, uint16_t span16[], int count) {
 }
 
 #define kTempColorQuadCount 6   // balance between speed (larger) and saving stack-space
-#define kTempColorCount     (kTempColorQuadCount << 2)  
+#define kTempColorCount     (kTempColorQuadCount << 2)
 
 #ifdef SK_CPU_BENDIAN
     #define SkU32BitShiftToByteOffset(shift)    (3 - ((shift) >> 3))
@@ -196,11 +197,15 @@ SkShader::MatrixClass SkShader::ComputeMatrixClass(const SkMatrix& mat) {
 
 //////////////////////////////////////////////////////////////////////////////
 
-SkShader::BitmapType SkShader::asABitmap(SkBitmap*, SkMatrix*, 
-                                         TileMode*, SkScalar*) {
+SkShader::BitmapType SkShader::asABitmap(SkBitmap*, SkMatrix*,
+                                         TileMode*, SkScalar*) const {
     return kNone_BitmapType;
 }
 
+SkShader::GradientType SkShader::asAGradient(GradientInfo* info) const {
+    return kNone_GradientType;
+}
+
 SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
                                        TileMode tmx, TileMode tmy) {
     return SkShader::CreateBitmapShader(src, tmx, tmy, NULL, 0);
@@ -258,20 +263,18 @@ bool SkColorShader::setContext(const SkBitmap& device, const SkPaint& paint,
         return false;
     }
 
-    SkColor c;
     unsigned a;
-    
+
     if (fInheritColor) {
-        c = paint.getColor();
-        a = SkColorGetA(c);
+        fColor = paint.getColor();
+        a = SkColorGetA(fColor);
     } else {
-        c = fColor;
-        a = SkAlphaMul(SkColorGetA(c), SkAlpha255To256(paint.getAlpha()));
+        a = SkAlphaMul(SkColorGetA(fColor), SkAlpha255To256(paint.getAlpha()));
     }
 
-    unsigned r = SkColorGetR(c);
-    unsigned g = SkColorGetG(c);
-    unsigned b = SkColorGetB(c);
+    unsigned r = SkColorGetR(fColor);
+    unsigned g = SkColorGetG(fColor);
+    unsigned b = SkColorGetB(fColor);
 
     // we want this before we apply any alpha
     fColor16 = SkPack888ToRGB16(r, g, b);
@@ -308,8 +311,8 @@ void SkColorShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
 
 // if we had a asAColor method, that would be more efficient...
 SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
-                                              TileMode modes[], 
-                                              SkScalar* twoPointRadialParams) {
+                                              TileMode modes[],
+                                      SkScalar* twoPointRadialParams) const {
     // we cache the pixelref, since its generateID is used in the texture cache
     if (NULL == fAsABitmapPixelRef) {
         SkPMColor* storage = (SkPMColor*)sk_malloc_throw(sizeof(SkPMColor));
@@ -317,7 +320,7 @@ SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix
         fAsABitmapPixelRef = new SkMallocPixelRef(storage, sizeof(SkPMColor),
                                                   NULL);
     }
-        
+
     if (bitmap) {
         bitmap->setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
         bitmap->setPixelRef(fAsABitmapPixelRef);
@@ -331,3 +334,13 @@ SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix
     return kDefault_BitmapType;
 }
 
+SkShader::GradientType SkColorShader::asAGradient(GradientInfo* info) const {
+    if (info) {
+        if (info->fColors && info->fColorCount >= 1) {
+            info->fColors[0] = fColor;
+        }
+        info->fColorCount = 1;
+        info->fTileMode = SkShader::kRepeat_TileMode;
+    }
+    return kColor_GradientType;
+}
diff --git a/src/core/SkString.cpp b/src/core/SkString.cpp
index cdce160..b8f99c7 100644
--- a/src/core/SkString.cpp
+++ b/src/core/SkString.cpp
@@ -2,16 +2,16 @@
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
@@ -19,6 +19,28 @@
 #include "SkFixed.h"
 #include "SkUtils.h"
 #include <stdarg.h>
+#include <stdio.h>
+
+// number of bytes (on the stack) to receive the printf result
+static const size_t kBufferSize = 256;
+
+#ifdef SK_BUILD_FOR_WIN
+    #define VSNPRINTF   _vsnprintf
+    #define SNPRINTF    _snprintf
+#else
+    #define VSNPRINTF   vsnprintf
+    #define SNPRINTF    snprintf
+#endif
+
+#define ARGS_TO_BUFFER(format, buffer, size)        \
+    do {                                            \
+        va_list args;                               \
+        va_start(args, format);                     \
+        VSNPRINTF(buffer, size, format, args);      \
+        va_end(args);                               \
+    } while (0)
+
+///////////////////////////////////////////////////////////////////////////////
 
 bool SkStrStartsWith(const char string[], const char prefix[])
 {
@@ -112,12 +134,23 @@ char* SkStrAppendS64(char string[], int64_t dec, int minDigits)
     return string;
 }
 
-char* SkStrAppendScalar(char string[], SkScalar value)
+#ifdef SK_CAN_USE_FLOAT
+char* SkStrAppendFloat(char string[], float value)
 {
-    SkDEBUGCODE(char* start = string;)
-
-    SkFixed x = SkScalarToFixed(value);
+    // since floats have at most 8 significant digits, we limit our %g to that.
+    static const char gFormat[] = "%.8g";
+    // make it 1 larger for the terminating 0
+    char buffer[SkStrAppendScalar_MaxSize + 1];
+    int len = SNPRINTF(buffer, sizeof(buffer), gFormat, value);
+    memcpy(string, buffer, len);
+    SkASSERT(len <= SkStrAppendScalar_MaxSize);
+    return string + len;
+}
+#endif
 
+char* SkStrAppendFixed(char string[], SkFixed x)
+{
+    SkDEBUGCODE(char* start = string;)
     if (x < 0)
     {
         *string++ = '-';
@@ -151,7 +184,7 @@ char* SkStrAppendScalar(char string[], SkScalar value)
             x %= powerOfTen;
         } while (x != 0);
     }
-    
+
     SkASSERT(string - start <= SkStrAppendScalar_MaxSize);
     return string;
 }
@@ -483,7 +516,7 @@ void SkString::insertS64(size_t offset, int64_t dec, int minDigits)
 void SkString::insertHex(size_t offset, uint32_t hex, int minDigits)
 {
     minDigits = SkPin32(minDigits, 0, 8);
-    
+
     static const char gHex[] = "0123456789ABCDEF";
 
     char    buffer[8];
@@ -508,27 +541,6 @@ void SkString::insertScalar(size_t offset, SkScalar value)
     this->insert(offset, buffer, stop - buffer);
 }
 
-///////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-
-// number of bytes (on the stack) to receive the printf result
-static const size_t kBufferSize = 256;
-
-#ifdef SK_BUILD_FOR_WIN
-    #define VSNPRINTF   _vsnprintf
-#else
-    #define VSNPRINTF   vsnprintf
-#endif
-
-#define ARGS_TO_BUFFER(format, buffer, size)        \
-    do {                                            \
-        va_list args;                               \
-        va_start(args, format);                     \
-        VSNPRINTF(buffer, size, format, args);      \
-        va_end(args);                               \
-    } while (0)
-
 void SkString::printf(const char format[], ...) {
     char    buffer[kBufferSize];
     ARGS_TO_BUFFER(format, buffer, kBufferSize);
@@ -539,20 +551,20 @@ void SkString::printf(const char format[], ...) {
 void SkString::appendf(const char format[], ...) {
     char    buffer[kBufferSize];
     ARGS_TO_BUFFER(format, buffer, kBufferSize);
-    
+
     this->append(buffer, strlen(buffer));
 }
 
 void SkString::prependf(const char format[], ...) {
     char    buffer[kBufferSize];
     ARGS_TO_BUFFER(format, buffer, kBufferSize);
-    
+
     this->prepend(buffer, strlen(buffer));
 }
 
 #undef VSNPRINTF
 
-///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 
 void SkString::remove(size_t offset, size_t length)
 {
diff --git a/src/effects/SkGradientShader.cpp b/src/effects/SkGradientShader.cpp
index 64a78c7..3452212 100644
--- a/src/effects/SkGradientShader.cpp
+++ b/src/effects/SkGradientShader.cpp
@@ -123,12 +123,11 @@ protected:
         kCache32Count   = 1 << kCache32Bits
     };
     virtual void flatten(SkFlattenableWriteBuffer& );
-    const uint16_t*     getCache16();
-    const SkPMColor*    getCache32();
+    const uint16_t*     getCache16() const;
+    const SkPMColor*    getCache32() const;
 
-    SkMallocPixelRef* fCache32PixelRef;
-
-    void commonAsABitmap(SkBitmap*);
+    void commonAsABitmap(SkBitmap*) const;
+    void commonAsAGradient(GradientInfo*) const;
 
 private:
     enum {
@@ -139,10 +138,11 @@ private:
     SkColor     fStorage[(kStorageSize + 3) >> 2];
     SkColor*    fOrigColors;
 
-    uint16_t*   fCache16;   // working ptr. If this is NULL, we need to recompute the cache values
-    SkPMColor*  fCache32;   // working ptr. If this is NULL, we need to recompute the cache values
+    mutable uint16_t*   fCache16;   // working ptr. If this is NULL, we need to recompute the cache values
+    mutable SkPMColor*  fCache32;   // working ptr. If this is NULL, we need to recompute the cache values
 
-    uint16_t*   fCache16Storage;    // storage for fCache16, allocated on demand
+    mutable uint16_t*   fCache16Storage;    // storage for fCache16, allocated on demand
+    mutable SkMallocPixelRef* fCache32PixelRef;
     unsigned    fCacheAlpha;        // the alpha value we used when we computed the cache. larger than 8bits so we can store uninitialized value
 
     static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count);
@@ -535,7 +535,7 @@ static inline U16CPU bitsTo16(unsigned x, const unsigned bits) {
     return 0;
 }
 
-const uint16_t* Gradient_Shader::getCache16() {
+const uint16_t* Gradient_Shader::getCache16() const {
     if (fCache16 == NULL) {
         // double the count for dither entries
         const int entryCount = kCache16Count * 2;
@@ -578,7 +578,7 @@ const uint16_t* Gradient_Shader::getCache16() {
     return fCache16;
 }
 
-const SkPMColor* Gradient_Shader::getCache32() {
+const SkPMColor* Gradient_Shader::getCache32() const {
     if (fCache32 == NULL) {
         // double the count for dither entries
         const int entryCount = kCache32Count * 2;
@@ -635,7 +635,7 @@ const SkPMColor* Gradient_Shader::getCache32() {
  *  colors and positions. Note: we don't try to flatten the fMapper, so if one
  *  is present, we skip the cache for now.
  */
-void Gradient_Shader::commonAsABitmap(SkBitmap* bitmap) {
+void Gradient_Shader::commonAsABitmap(SkBitmap* bitmap) const {
     // don't have a way to put the mapper into our cache-key yet
     if (fMapper) {
         // force our cahce32pixelref to be built
@@ -687,6 +687,28 @@ void Gradient_Shader::commonAsABitmap(SkBitmap* bitmap) {
     }
 }
 
+void Gradient_Shader::commonAsAGradient(GradientInfo* info) const {
+    if (info) {
+        if (info->fColorCount >= fColorCount) {
+            if (info->fColors) {
+                memcpy(info->fColors, fOrigColors,
+                       fColorCount * sizeof(SkColor));
+            }
+            if (info->fColorOffsets) {
+                if (fColorCount == 2) {
+                    info->fColorOffsets[0] = 0;
+                    info->fColorOffsets[1] = SK_Scalar1;
+                } else if (fColorCount > 2) {
+                    for (int i = 0; i < fColorCount; i++)
+                        info->fColorOffsets[i] = SkFixedToScalar(fRecs[i].fPos);
+                }
+            }
+        }
+        info->fColorCount = fColorCount;
+        info->fTileMode = fTileMode;
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 
 static void pts_to_unit_matrix(const SkPoint pts[2], SkMatrix* matrix) {
@@ -707,7 +729,9 @@ public:
     Linear_Gradient(const SkPoint pts[2],
                     const SkColor colors[], const SkScalar pos[], int colorCount,
                     SkShader::TileMode mode, SkUnitMapper* mapper)
-        : Gradient_Shader(colors, pos, colorCount, mode, mapper)
+        : Gradient_Shader(colors, pos, colorCount, mode, mapper),
+          fStart(pts[0]),
+          fEnd(pts[1])
     {
         pts_to_unit_matrix(pts, &fPtsToUnit);
     }
@@ -716,18 +740,33 @@ public:
     virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count);
     virtual void shadeSpan16(int x, int y, uint16_t dstC[], int count);
     virtual BitmapType asABitmap(SkBitmap*, SkMatrix*,
-                                 TileMode*, SkScalar* twoPointRadialParams);
+                             TileMode*, SkScalar* twoPointRadialParams) const;
+    virtual GradientType asAGradient(GradientInfo* info) const;
 
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW_ARGS(Linear_Gradient, (buffer));
     }
 
+    virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+        this->INHERITED::flatten(buffer);
+        buffer.writeScalar(fStart.fX);
+        buffer.writeScalar(fStart.fY);
+        buffer.writeScalar(fEnd.fX);
+        buffer.writeScalar(fEnd.fY);
+    }
+
 protected:
-    Linear_Gradient(SkFlattenableReadBuffer& buffer) : Gradient_Shader(buffer) {}
+    Linear_Gradient(SkFlattenableReadBuffer& buffer)
+        : Gradient_Shader(buffer),
+          fStart(SkPoint::Make(buffer.readScalar(), buffer.readScalar())),
+          fEnd(SkPoint::Make(buffer.readScalar(), buffer.readScalar())) {
+    }
     virtual Factory getFactory() { return CreateProc; }
 
 private:
     typedef Gradient_Shader INHERITED;
+    const SkPoint fStart;
+    const SkPoint fEnd;
 };
 
 bool Linear_Gradient::setContext(const SkBitmap& device, const SkPaint& paint,
@@ -835,7 +874,7 @@ void Linear_Gradient::shadeSpan(int x, int y, SkPMColor dstC[], int count)
 SkShader::BitmapType Linear_Gradient::asABitmap(SkBitmap* bitmap,
                                                 SkMatrix* matrix,
                                                 TileMode xy[],
-                                                SkScalar* twoPointRadialParams) {
+                                        SkScalar* twoPointRadialParams) const {
     if (bitmap) {
         this->commonAsABitmap(bitmap);
     }
@@ -850,6 +889,15 @@ SkShader::BitmapType Linear_Gradient::asABitmap(SkBitmap* bitmap,
     return kDefault_BitmapType;
 }
 
+SkShader::GradientType Linear_Gradient::asAGradient(GradientInfo* info) const {
+    if (info) {
+        commonAsAGradient(info);
+        info->fPoint[0] = fStart;
+        info->fPoint[1] = fEnd;
+    }
+    return kLinear_GradientType;
+}
+
 static void dither_memset16(uint16_t dst[], uint16_t value, uint16_t other,
                             int count) {
     if (reinterpret_cast<uintptr_t>(dst) & 2) {
@@ -989,7 +1037,9 @@ public:
     Radial_Gradient(const SkPoint& center, SkScalar radius,
                     const SkColor colors[], const SkScalar pos[], int colorCount,
                     SkShader::TileMode mode, SkUnitMapper* mapper)
-        : Gradient_Shader(colors, pos, colorCount, mode, mapper)
+        : Gradient_Shader(colors, pos, colorCount, mode, mapper),
+          fCenter(center),
+          fRadius(radius)
     {
         // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE
         SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE);
@@ -1185,7 +1235,7 @@ public:
     virtual BitmapType asABitmap(SkBitmap* bitmap,
                                  SkMatrix* matrix,
                                  TileMode* xy,
-                                 SkScalar* twoPointRadialParams) {
+                                 SkScalar* twoPointRadialParams) const {
         if (bitmap) {
             this->commonAsABitmap(bitmap);
         }
@@ -1199,17 +1249,38 @@ public:
         }
         return kRadial_BitmapType;
     }
+    virtual GradientType asAGradient(GradientInfo* info) const {
+        if (info) {
+            commonAsAGradient(info);
+            info->fPoint[0] = fCenter;
+            info->fRadius[0] = fRadius;
+        }
+        return kRadial_GradientType;
+    }
 
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW_ARGS(Radial_Gradient, (buffer));
     }
 
+    virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+        this->INHERITED::flatten(buffer);
+        buffer.writeScalar(fCenter.fX);
+        buffer.writeScalar(fCenter.fY);
+        buffer.writeScalar(fRadius);
+    }
+
 protected:
-    Radial_Gradient(SkFlattenableReadBuffer& buffer) : Gradient_Shader(buffer) {};
+    Radial_Gradient(SkFlattenableReadBuffer& buffer)
+        : Gradient_Shader(buffer),
+          fCenter(SkPoint::Make(buffer.readScalar(), buffer.readScalar())),
+          fRadius(buffer.readScalar()) {
+    }
     virtual Factory getFactory() { return CreateProc; }
 
 private:
     typedef Gradient_Shader INHERITED;
+    const SkPoint fCenter;
+    const SkScalar fRadius;
 };
 
 /* Two-point radial gradients are specified by two circles, each with a center
@@ -1305,26 +1376,18 @@ public:
                               const SkColor colors[], const SkScalar pos[],
                               int colorCount, SkShader::TileMode mode,
                               SkUnitMapper* mapper)
-        : Gradient_Shader(colors, pos, colorCount, mode, mapper)
-    {
-        fDiff = start - end;
-        fDiffRadius = endRadius - startRadius;
-        SkScalar inv = SkScalarInvert(fDiffRadius);
-        fDiff.fX = SkScalarMul(fDiff.fX, inv);
-        fDiff.fY = SkScalarMul(fDiff.fY, inv);
-        fStartRadius = SkScalarMul(startRadius, inv);
-        fSr2D2 = SkScalarSquare(fStartRadius);
-        fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
-        fOneOverTwoA = SkScalarInvert(fA * 2);
-
-        fPtsToUnit.setTranslate(-start.fX, -start.fY);
-        fPtsToUnit.postScale(inv, inv);
+            : Gradient_Shader(colors, pos, colorCount, mode, mapper),
+              fCenter1(start),
+              fCenter2(end),
+              fRadius1(startRadius),
+              fRadius2(endRadius) {
+        init();
     }
 
     virtual BitmapType asABitmap(SkBitmap* bitmap,
                                  SkMatrix* matrix,
                                  TileMode* xy,
-                                 SkScalar* twoPointRadialParams) {
+                                 SkScalar* twoPointRadialParams) const {
         if (bitmap) {
             this->commonAsABitmap(bitmap);
         }
@@ -1351,6 +1414,17 @@ public:
         return kTwoPointRadial_BitmapType;
     }
 
+    virtual GradientType asAGradient(GradientInfo* info) const {
+        if (info) {
+            commonAsAGradient(info);
+            info->fPoint[0] = fCenter1;
+            info->fPoint[1] = fCenter2;
+            info->fRadius[0] = fRadius1;
+            info->fRadius[1] = fRadius2;
+        }
+        return kRadial2_GradientType;
+    }
+
     virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count)
     {
         SkASSERT(count > 0);
@@ -1468,32 +1542,48 @@ public:
 
     virtual void flatten(SkFlattenableWriteBuffer& buffer) {
         this->INHERITED::flatten(buffer);
-        buffer.writeScalar(fDiff.fX);
-        buffer.writeScalar(fDiff.fY);
-        buffer.writeScalar(fStartRadius);
-        buffer.writeScalar(fDiffRadius);
-        buffer.writeScalar(fSr2D2);
-        buffer.writeScalar(fA);
-        buffer.writeScalar(fOneOverTwoA);
+        buffer.writeScalar(fCenter1.fX);
+        buffer.writeScalar(fCenter1.fY);
+        buffer.writeScalar(fCenter2.fX);
+        buffer.writeScalar(fCenter2.fY);
+        buffer.writeScalar(fRadius1);
+        buffer.writeScalar(fRadius2);
     }
 
 protected:
     Two_Point_Radial_Gradient(SkFlattenableReadBuffer& buffer)
-            : Gradient_Shader(buffer) {
-        fDiff.fX = buffer.readScalar();
-        fDiff.fY = buffer.readScalar();
-        fStartRadius = buffer.readScalar();
-        fDiffRadius = buffer.readScalar();
-        fSr2D2 = buffer.readScalar();
-        fA = buffer.readScalar();
-        fOneOverTwoA = buffer.readScalar();
+            : Gradient_Shader(buffer),
+              fCenter1(SkPoint::Make(buffer.readScalar(), buffer.readScalar())),
+              fCenter2(SkPoint::Make(buffer.readScalar(), buffer.readScalar())),
+              fRadius1(buffer.readScalar()),
+              fRadius2(buffer.readScalar()) {
+        init();
     };
     virtual Factory getFactory() { return CreateProc; }
 
 private:
     typedef Gradient_Shader INHERITED;
+    const SkPoint fCenter1;
+    const SkPoint fCenter2;
+    const SkScalar fRadius1;
+    const SkScalar fRadius2;
     SkPoint fDiff;
     SkScalar fStartRadius, fDiffRadius, fSr2D2, fA, fOneOverTwoA;
+
+    void init() {
+        fDiff = fCenter1 - fCenter2;
+        fDiffRadius = fRadius2 - fRadius1;
+        SkScalar inv = SkScalarInvert(fDiffRadius);
+        fDiff.fX = SkScalarMul(fDiff.fX, inv);
+        fDiff.fY = SkScalarMul(fDiff.fY, inv);
+        fStartRadius = SkScalarMul(fRadius1, inv);
+        fSr2D2 = SkScalarSquare(fStartRadius);
+        fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
+        fOneOverTwoA = SkScalarInvert(fA * 2);
+
+        fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
+        fPtsToUnit.postScale(inv, inv);
+    }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1502,7 +1592,8 @@ class Sweep_Gradient : public Gradient_Shader {
 public:
     Sweep_Gradient(SkScalar cx, SkScalar cy, const SkColor colors[],
                    const SkScalar pos[], int count, SkUnitMapper* mapper)
-    : Gradient_Shader(colors, pos, count, SkShader::kClamp_TileMode, mapper)
+    : Gradient_Shader(colors, pos, count, SkShader::kClamp_TileMode, mapper),
+      fCenter(SkPoint::Make(cx, cy))
     {
         fPtsToUnit.setTranslate(-cx, -cy);
     }
@@ -1512,7 +1603,7 @@ public:
     virtual BitmapType asABitmap(SkBitmap* bitmap,
                                  SkMatrix* matrix,
                                  TileMode* xy,
-                                 SkScalar* twoPointRadialParams) {
+                                 SkScalar* twoPointRadialParams) const {
         if (bitmap) {
             this->commonAsABitmap(bitmap);
         }
@@ -1526,16 +1617,35 @@ public:
         return kSweep_BitmapType;
     }
 
+    virtual GradientType asAGradient(GradientInfo* info) const {
+        if (info) {
+            commonAsAGradient(info);
+            info->fPoint[0] = fCenter;
+        }
+        return kSweep_GradientType;
+    }
+
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW_ARGS(Sweep_Gradient, (buffer));
     }
 
+    virtual void flatten(SkFlattenableWriteBuffer& buffer) {
+        this->INHERITED::flatten(buffer);
+        buffer.writeScalar(fCenter.fX);
+        buffer.writeScalar(fCenter.fY);
+    }
+
 protected:
-    Sweep_Gradient(SkFlattenableReadBuffer& buffer) : Gradient_Shader(buffer) {}
+    Sweep_Gradient(SkFlattenableReadBuffer& buffer)
+        : Gradient_Shader(buffer),
+          fCenter(SkPoint::Make(buffer.readScalar(), buffer.readScalar())) {
+    }
+
     virtual Factory getFactory() { return CreateProc; }
 
 private:
     typedef Gradient_Shader INHERITED;
+    const SkPoint fCenter;
 };
 
 #ifdef COMPUTE_SWEEP_TABLE
diff --git a/src/effects/SkPorterDuff.cpp b/src/effects/SkPorterDuff.cpp
index d0264ba..980ce29 100644
--- a/src/effects/SkPorterDuff.cpp
+++ b/src/effects/SkPorterDuff.cpp
@@ -30,7 +30,9 @@ static const struct Pair {
     MAKE_PAIR(Multiply),
     MAKE_PAIR(Screen),
     { SkPorterDuff::kAdd_Mode, SkXfermode::kPlus_Mode },
+#ifdef ANDROID
     MAKE_PAIR(Overlay),
+#endif
 };
 
 static bool find_pdmode(SkXfermode::Mode src, SkPorterDuff::Mode* dst) {
diff --git a/src/gpu/GrPrintf_skia.cpp b/src/gpu/GrPrintf_skia.cpp
new file mode 100644
index 0000000..fa8b6a7
--- /dev/null
+++ b/src/gpu/GrPrintf_skia.cpp
@@ -0,0 +1,39 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrTypes.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "SkTypes.h"
+
+void GrPrintf(const char format[], ...) {
+    const size_t MAX_BUFFER_SIZE = 512;
+
+    char buffer[MAX_BUFFER_SIZE + 1];
+    va_list args;
+
+    va_start(args, format);
+    vsnprintf(buffer, MAX_BUFFER_SIZE, format, args);
+    va_end(args);
+
+    // skia has already mapped this to do the "right thing"
+    SkDebugf("%s", buffer);
+}
+
+
diff --git a/src/gpu/SkGpuCanvas.cpp b/src/gpu/SkGpuCanvas.cpp
new file mode 100644
index 0000000..9513bbd
--- /dev/null
+++ b/src/gpu/SkGpuCanvas.cpp
@@ -0,0 +1,59 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrContext.h"
+
+#include "SkGpuCanvas.h"
+#include "SkGpuDevice.h"
+#include "SkGpuDeviceFactory.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkDeviceFactory* make_df(GrContext* context, 
+                                GrRenderTarget* renderTarget) {
+    return SkNEW_ARGS(SkGpuDeviceFactory, (context, renderTarget));
+}
+
+SkGpuCanvas::SkGpuCanvas(GrContext* context,
+                         GrRenderTarget* renderTarget) 
+      : SkCanvas(make_df(context, renderTarget)) {
+    SkASSERT(context);
+    fContext = context;
+    fContext->ref();
+}
+
+SkGpuCanvas::~SkGpuCanvas() {
+    // call this now, while our override of restore() is in effect
+    this->restoreToCount(1);
+    fContext->flush(false);
+    fContext->unref();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool SkGpuCanvas::getViewport(SkIPoint* size) const {
+    if (size) {
+        SkDevice* device = this->getDevice();
+        if (device) {
+            size->set(device->width(), device->height());
+        } else {
+            size->set(0, 0);
+        }
+    }
+    return true;
+}
+
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
new file mode 100644
index 0000000..91a6319
--- /dev/null
+++ b/src/gpu/SkGpuDevice.cpp
@@ -0,0 +1,1275 @@
+/*
+    Copyright 2011 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "GrContext.h"
+#include "GrTextContext.h"
+
+#include "SkGpuDevice.h"
+#include "SkGpuDeviceFactory.h"
+#include "SkGrTexturePixelRef.h"
+
+#include "SkDrawProcs.h"
+#include "SkGlyphCache.h"
+
+#define CACHE_LAYER_TEXTURES 1
+
+#if 0
+    extern bool (*gShouldDrawProc)();
+    #define CHECK_SHOULD_DRAW(draw)                             \
+        do {                                                    \
+            if (gShouldDrawProc && !gShouldDrawProc()) return;  \
+            this->prepareRenderTarget(draw);                    \
+        } while (0)
+#else
+    #define CHECK_SHOULD_DRAW(draw) this->prepareRenderTarget(draw)
+#endif
+
+class SkAutoExtMatrix {
+public:
+    SkAutoExtMatrix(const SkMatrix* extMatrix) {
+        if (extMatrix) {
+            SkGr::SkMatrix2GrMatrix(*extMatrix, &fMatrix);
+            fExtMatrix = &fMatrix;
+        } else {
+            fExtMatrix = NULL;
+        }
+    }
+    const GrMatrix* extMatrix() const { return fExtMatrix; }
+
+private:
+    GrMatrix    fMatrix;
+    GrMatrix*   fExtMatrix; // NULL or &fMatrix
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGpuDevice::SkAutoCachedTexture::
+             SkAutoCachedTexture(SkGpuDevice* device,
+                                 const SkBitmap& bitmap,
+                                 const GrSamplerState& sampler,
+                                 GrTexture** texture) {
+    GrAssert(texture);
+    fTex = NULL;
+    *texture = this->set(device, bitmap, sampler);
+}
+
+SkGpuDevice::SkAutoCachedTexture::SkAutoCachedTexture() {
+    fTex = NULL;
+}
+
+GrTexture* SkGpuDevice::SkAutoCachedTexture::set(SkGpuDevice* device,
+                                                 const SkBitmap& bitmap,
+                                                 const GrSamplerState& sampler) {
+    if (fTex) {
+        fDevice->unlockCachedTexture(fTex);
+    }
+    fDevice = device;
+    GrTexture* texture = (GrTexture*)bitmap.getTexture();
+    if (texture) {
+        // return the native texture
+        fTex = NULL;
+    } else {
+        // look it up in our cache
+        fTex = device->lockCachedTexture(bitmap, sampler, &texture, false);
+    }
+    return texture;
+}
+
+SkGpuDevice::SkAutoCachedTexture::~SkAutoCachedTexture() {
+    if (fTex) {
+        fDevice->unlockCachedTexture(fTex);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool gDoTraceDraw;
+
+struct GrSkDrawProcs : public SkDrawProcs {
+public:
+    GrContext* fContext;
+    GrTextContext* fTextContext;
+    GrFontScaler* fFontScaler;  // cached in the skia glyphcache
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrRenderTarget* SkGpuDevice::Current3DApiRenderTarget() {
+    return (GrRenderTarget*) -1;
+}
+
+SkGpuDevice::SkGpuDevice(GrContext* context,
+                         const SkBitmap& bitmap,
+                         GrRenderTarget* renderTargetOrNull)
+        : SkDevice(NULL, bitmap, (NULL == renderTargetOrNull)) {
+
+    fNeedPrepareRenderTarget = false;
+    fDrawProcs = NULL;
+
+    fContext = context;
+    fContext->ref();
+
+    fCache = NULL;
+    fTexture = NULL;
+    fRenderTarget = NULL;
+    fNeedClear = false;
+
+    if (NULL == renderTargetOrNull) {
+        SkBitmap::Config c = bitmap.config();
+        if (c != SkBitmap::kRGB_565_Config) {
+            c = SkBitmap::kARGB_8888_Config;
+        }
+        SkBitmap bm;
+        bm.setConfig(c, this->width(), this->height());
+
+#if CACHE_LAYER_TEXTURES
+
+        fCache = this->lockCachedTexture(bm, GrSamplerState::ClampNoFilter(),
+                       &fTexture, true);
+        if (fCache) {
+            SkASSERT(NULL != fTexture);
+            SkASSERT(NULL != fTexture->asRenderTarget());
+        }
+#else
+        const GrGpu::TextureDesc desc = {
+            GrGpu::kRenderTarget_TextureFlag,
+            GrGpu::kNone_AALevel,
+            this->width(),
+            this->height(),
+            SkGr::Bitmap2PixelConfig(bm)
+        };
+
+        fTexture = fContext->createUncachedTexture(desc, NULL, 0);
+#endif
+        if (NULL != fTexture) {
+            fRenderTarget = fTexture->asRenderTarget();
+
+            GrAssert(NULL != fRenderTarget);
+
+            // we defer the actual clear until our gainFocus()
+            fNeedClear = true;
+
+            // wrap the bitmap with a pixelref to expose our texture
+            SkGrTexturePixelRef* pr = new SkGrTexturePixelRef(fTexture);
+            this->setPixelRef(pr, 0)->unref();
+        } else {
+            GrPrintf("--- failed to create gpu-offscreen [%d %d]\n",
+                     this->width(), this->height());
+            GrAssert(false);
+        }
+    } else if (Current3DApiRenderTarget() == renderTargetOrNull) {
+        fRenderTarget = fContext->createRenderTargetFrom3DApiState();
+    } else {
+        fRenderTarget = renderTargetOrNull;
+        fRenderTarget->ref();
+    }
+}
+
+SkGpuDevice::~SkGpuDevice() {
+    if (fDrawProcs) {
+        delete fDrawProcs;
+    }
+
+    if (fCache) {
+        GrAssert(NULL != fTexture);
+        GrAssert(fRenderTarget == fTexture->asRenderTarget());
+        // IMPORTANT: reattach the rendertarget/tex back to the cache.
+        fContext->reattachAndUnlockCachedTexture((GrTextureEntry*)fCache);
+    } else if (NULL != fTexture) {
+        GrAssert(!CACHE_LAYER_TEXTURES);
+        GrAssert(fRenderTarget == fTexture->asRenderTarget());
+        fTexture->unref();
+    } else if (NULL != fRenderTarget) {
+        fRenderTarget->unref();
+    }
+    fContext->unref();
+}
+
+intptr_t SkGpuDevice::getLayerTextureHandle() const {
+    if (fTexture) {
+        return fTexture->getTextureHandle();
+    } else {
+        return 0;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+void SkGpuDevice::makeRenderTargetCurrent() {
+    fContext->setRenderTarget(fRenderTarget);
+    fContext->flush(true);
+    fNeedPrepareRenderTarget = true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool SkGpuDevice::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
+    SkIRect bounds;
+    bounds.set(0, 0, this->width(), this->height());
+    if (!bounds.intersect(srcRect)) {
+        return false;
+    }
+
+    const int w = bounds.width();
+    const int h = bounds.height();
+    SkBitmap tmp;
+    // note we explicitly specify our rowBytes to be snug (no gap between rows)
+    tmp.setConfig(SkBitmap::kARGB_8888_Config, w, h, w * 4);
+    if (!tmp.allocPixels()) {
+        return false;
+    }
+
+    SkAutoLockPixels alp(tmp);
+    fContext->setRenderTarget(fRenderTarget);
+    // we aren't setting the clip or matrix, so mark as dirty
+    // we don't need to set them for this call and don't have them anyway
+    fNeedPrepareRenderTarget = true;
+
+    if (!fContext->readPixels(bounds.fLeft, bounds.fTop,
+                              bounds.width(), bounds.height(),
+                              GrTexture::kRGBA_8888_PixelConfig,
+                              tmp.getPixels())) {
+        return false;
+    }
+
+    tmp.swap(*bitmap);
+    return true;
+}
+
+void SkGpuDevice::writePixels(const SkBitmap& bitmap, int x, int y) {
+    SkAutoLockPixels alp(bitmap);
+    if (!bitmap.readyToDraw()) {
+        return;
+    }
+    GrTexture::PixelConfig config = SkGr::BitmapConfig2PixelConfig(bitmap.config(),
+                                                                   bitmap.isOpaque());
+    fContext->setRenderTarget(fRenderTarget);
+    // we aren't setting the clip or matrix, so mark as dirty
+    // we don't need to set them for this call and don't have them anyway
+    fNeedPrepareRenderTarget = true;
+
+    fContext->writePixels(x, y, bitmap.width(), bitmap.height(),
+                          config, bitmap.getPixels(), bitmap.rowBytes());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void convert_matrixclip(GrContext* context, const SkMatrix& matrix,
+                               const SkClipStack& clipStack,
+                               const SkRegion& clipRegion,
+                               const SkIPoint& origin) {
+    GrMatrix grmat;
+    SkGr::SkMatrix2GrMatrix(matrix, &grmat);
+    context->setMatrix(grmat);
+
+    SkGrClipIterator iter;
+    iter.reset(clipStack);
+    const SkIRect& skBounds = clipRegion.getBounds();
+    GrRect bounds;
+    bounds.setLTRB(GrIntToScalar(skBounds.fLeft),
+                   GrIntToScalar(skBounds.fTop),
+                   GrIntToScalar(skBounds.fRight),
+                   GrIntToScalar(skBounds.fBottom));
+    GrClip grc(&iter, GrIntToScalar(-origin.x()), GrIntToScalar(-origin.y()),
+               &bounds);
+    context->setClip(grc);
+}
+
+// call this ever each draw call, to ensure that the context reflects our state,
+// and not the state from some other canvas/device
+void SkGpuDevice::prepareRenderTarget(const SkDraw& draw) {
+    if (fNeedPrepareRenderTarget ||
+        fContext->getRenderTarget() != fRenderTarget) {
+
+        fContext->setRenderTarget(fRenderTarget);
+        SkASSERT(draw.fClipStack);
+        convert_matrixclip(fContext, *draw.fMatrix,
+                           *draw.fClipStack, *draw.fClip, this->getOrigin());
+        fNeedPrepareRenderTarget = false;
+    }
+}
+
+void SkGpuDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
+                                const SkClipStack& clipStack) {
+    this->INHERITED::setMatrixClip(matrix, clip, clipStack);
+
+    convert_matrixclip(fContext, matrix, clipStack, clip, this->getOrigin());
+}
+
+void SkGpuDevice::gainFocus(SkCanvas* canvas, const SkMatrix& matrix,
+                            const SkRegion& clip, const SkClipStack& clipStack) {
+
+    fContext->setRenderTarget(fRenderTarget);
+
+    this->INHERITED::gainFocus(canvas, matrix, clip, clipStack);
+
+    convert_matrixclip(fContext, matrix, clipStack, clip, this->getOrigin());
+
+    if (fNeedClear) {
+        fContext->eraseColor(0x0);
+        fNeedClear = false;
+    }
+}
+
+bool SkGpuDevice::bindDeviceAsTexture(GrPaint* paint) {
+    if (NULL != fTexture) {
+        paint->setTexture(fTexture);
+        return true;
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
+SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch);
+SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch);
+SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch);
+SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4,
+                  shader_type_mismatch);
+SK_COMPILE_ASSERT(SkShader::kLast_BitmapType == 4, shader_type_mismatch);
+
+static const GrSamplerState::SampleMode sk_bmp_type_to_sample_mode[] = {
+    (GrSamplerState::SampleMode) -1,                    // kNone_BitmapType
+    GrSamplerState::kNormal_SampleMode,                 // kDefault_BitmapType
+    GrSamplerState::kRadial_SampleMode,                 // kRadial_BitmapType
+    GrSamplerState::kSweep_SampleMode,                  // kSweep_BitmapType
+    GrSamplerState::kRadial2_SampleMode,                // kTwoPointRadial_BitmapType
+};
+
+bool SkGpuDevice::skPaint2GrPaintNoShader(const SkPaint& skPaint,
+                                          bool justAlpha,
+                                          GrPaint* grPaint) {
+
+    grPaint->fDither    = skPaint.isDither();
+    grPaint->fAntiAlias = skPaint.isAntiAlias();
+
+    SkXfermode::Coeff sm = SkXfermode::kOne_Coeff;
+    SkXfermode::Coeff dm = SkXfermode::kISA_Coeff;
+
+    SkXfermode* mode = skPaint.getXfermode();
+    if (mode) {
+        if (!mode->asCoeff(&sm, &dm)) {
+            SkDEBUGCODE(SkDebugf("Unsupported xfer mode.\n");)
+#if 0
+            return false;
+#endif
+        }
+    }
+    grPaint->fSrcBlendCoeff = sk_blend_to_grblend(sm);
+    grPaint->fDstBlendCoeff = sk_blend_to_grblend(dm);
+
+    if (justAlpha) {
+        uint8_t alpha = skPaint.getAlpha();
+        grPaint->fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
+    } else {
+        grPaint->fColor = SkGr::SkColor2GrColor(skPaint.getColor());
+        grPaint->setTexture(NULL);
+    }
+    return true;
+}
+
+bool SkGpuDevice::skPaint2GrPaintShader(const SkPaint& skPaint,
+                                        SkAutoCachedTexture* act,
+                                        const SkMatrix& ctm,
+                                        GrPaint* grPaint) {
+
+    SkASSERT(NULL != act);
+
+    SkShader* shader = skPaint.getShader();
+    if (NULL == shader) {
+        return this->skPaint2GrPaintNoShader(skPaint, false, grPaint);
+        grPaint->setTexture(NULL);
+        return true;
+    } else if (!this->skPaint2GrPaintNoShader(skPaint, true, grPaint)) {
+        return false;
+    }
+
+    SkPaint noAlphaPaint(skPaint);
+    noAlphaPaint.setAlpha(255);
+    shader->setContext(this->accessBitmap(false), noAlphaPaint, ctm);
+
+    SkBitmap bitmap;
+    SkMatrix matrix;
+    SkShader::TileMode tileModes[2];
+    SkScalar twoPointParams[3];
+    SkShader::BitmapType bmptype = shader->asABitmap(&bitmap, &matrix,
+                                                     tileModes, twoPointParams);
+
+    GrSamplerState::SampleMode sampleMode = sk_bmp_type_to_sample_mode[bmptype];
+    if (-1 == sampleMode) {
+        SkDebugf("shader->asABitmap() == kNone_BitmapType\n");
+        return false;
+    }
+    grPaint->fSampler.setSampleMode(sampleMode);
+    grPaint->fSampler.setFilter(skPaint.isFilterBitmap());
+    grPaint->fSampler.setWrapX(sk_tile_mode_to_grwrap(tileModes[0]));
+    grPaint->fSampler.setWrapY(sk_tile_mode_to_grwrap(tileModes[1]));
+    if (GrSamplerState::kRadial2_SampleMode == sampleMode) {
+        grPaint->fSampler.setRadial2Params(twoPointParams[0],
+                                           twoPointParams[1],
+                                           twoPointParams[2] < 0);
+    }
+
+    GrTexture* texture = act->set(this, bitmap, grPaint->fSampler);
+    if (NULL == texture) {
+        SkDebugf("Couldn't convert bitmap to texture.\n");
+        return false;
+    }
+    grPaint->setTexture(texture);
+
+    // since our texture coords will be in local space, we wack the texture
+    // matrix to map them back into 0...1 before we load it
+    SkMatrix localM;
+    if (shader->getLocalMatrix(&localM)) {
+        SkMatrix inverse;
+        if (localM.invert(&inverse)) {
+            matrix.preConcat(inverse);
+        }
+    }
+    if (SkShader::kDefault_BitmapType == bmptype) {
+        GrScalar sx = GrFixedToScalar(GR_Fixed1 / bitmap.width());
+        GrScalar sy = GrFixedToScalar(GR_Fixed1 / bitmap.height());
+        matrix.postScale(sx, sy);
+    } else if (SkShader::kRadial_BitmapType == bmptype) {
+        GrScalar s = GrFixedToScalar(GR_Fixed1 / bitmap.width());
+        matrix.postScale(s, s);
+    }
+    GrMatrix grMat;
+    SkGr::SkMatrix2GrMatrix(matrix, &grMat);
+    grPaint->fSampler.setMatrix(grMat);
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+class SkPositionSource {
+public:
+    SkPositionSource(const SkPoint* points, int count)
+        : fPoints(points), fCount(count) {}
+
+    int count() const { return fCount; }
+
+    void writeValue(int i, GrPoint* dstPosition) const {
+        SkASSERT(i < fCount);
+        dstPosition->fX = SkScalarToGrScalar(fPoints[i].fX);
+        dstPosition->fY = SkScalarToGrScalar(fPoints[i].fY);
+    }
+private:
+    const SkPoint*  fPoints;
+    int             fCount;
+};
+
+class SkTexCoordSource {
+public:
+    SkTexCoordSource(const SkPoint* coords)
+        : fCoords(coords) {}
+
+    void writeValue(int i, GrPoint* dstCoord) const {
+        dstCoord->fX = SkScalarToGrScalar(fCoords[i].fX);
+        dstCoord->fY = SkScalarToGrScalar(fCoords[i].fY);
+    }
+private:
+    const SkPoint*  fCoords;
+};
+
+class SkColorSource {
+public:
+    SkColorSource(const SkColor* colors) : fColors(colors) {}
+
+    void writeValue(int i, GrColor* dstColor) const {
+        *dstColor = SkGr::SkColor2GrColor(fColors[i]);
+    }
+private:
+    const SkColor* fColors;
+};
+
+class SkIndexSource {
+public:
+    SkIndexSource(const uint16_t* indices, int count)
+        : fIndices(indices), fCount(count) {
+    }
+
+    int count() const { return fCount; }
+
+    void writeValue(int i, uint16_t* dstIndex) const {
+        *dstIndex = fIndices[i];
+    }
+
+private:
+    const uint16_t* fIndices;
+    int             fCount;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if 0 // not currently being used so don't compile,
+
+// can be used for positions or texture coordinates
+
+class SkRectFanSource {
+public:
+    SkRectFanSource(const SkRect& rect) : fRect(rect) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+        dstPoint->fX = SkScalarToGrScalar((i % 3) ? fRect.fRight :
+                                                    fRect.fLeft);
+        dstPoint->fY = SkScalarToGrScalar((i < 2) ? fRect.fTop  :
+                                                    fRect.fBottom);
+    }
+private:
+    const SkRect&   fRect;
+};
+
+class SkIRectFanSource {
+public:
+    SkIRectFanSource(const SkIRect& rect) : fRect(rect) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+        dstPoint->fX = (i % 3) ? GrIntToScalar(fRect.fRight) :
+                                 GrIntToScalar(fRect.fLeft);
+        dstPoint->fY = (i < 2) ? GrIntToScalar(fRect.fTop)  :
+                                 GrIntToScalar(fRect.fBottom);
+    }
+private:
+    const SkIRect&   fRect;
+};
+
+class SkMatRectFanSource {
+public:
+    SkMatRectFanSource(const SkRect& rect, const SkMatrix& matrix)
+        : fRect(rect), fMatrix(matrix) {}
+
+    int count() const { return 4; }
+
+    void writeValue(int i, GrPoint* dstPoint) const {
+        SkASSERT(i < 4);
+
+#if SK_SCALAR_IS_GR_SCALAR
+        fMatrix.mapXY((i % 3) ? fRect.fRight : fRect.fLeft,
+                      (i < 2) ? fRect.fTop   : fRect.fBottom,
+                      (SkPoint*)dstPoint);
+#else
+        SkPoint dst;
+        fMatrix.mapXY((i % 3) ? fRect.fRight : fRect.fLeft,
+                      (i < 2) ? fRect.fTop   : fRect.fBottom,
+                      &dst);
+        dstPoint->fX = SkScalarToGrScalar(dst.fX);
+        dstPoint->fY = SkScalarToGrScalar(dst.fY);
+#endif
+    }
+private:
+    const SkRect&   fRect;
+    const SkMatrix& fMatrix;
+};
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+        return;
+    }
+
+    fContext->drawPaint(grPaint);
+}
+
+// must be in SkCanvas::PointMode order
+static const GrPrimitiveType gPointMode2PrimtiveType[] = {
+    kPoints_PrimitiveType,
+    kLines_PrimitiveType,
+    kLineStrip_PrimitiveType
+};
+
+void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
+                             size_t count, const SkPoint pts[], const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    SkScalar width = paint.getStrokeWidth();
+    if (width < 0) {
+        return;
+    }
+
+    // we only handle hairlines here, else we let the SkDraw call our drawPath()
+    if (width > 0) {
+        draw.drawPoints(mode, count, pts, paint, true);
+        return;
+    }
+
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+        return;
+    }
+
+#if SK_SCALAR_IS_GR_SCALAR
+    fContext->drawVertices(grPaint,
+                           gPointMode2PrimtiveType[mode],
+                           count,
+                           (GrPoint*)pts,
+                           NULL,
+                           NULL,
+                           NULL,
+                           0);
+#else
+    fContext->drawCustomVertices(grPaint,
+                                 gPointMode2PrimtiveType[mode],
+                                 SkPositionSource(pts, count));
+#endif
+}
+
+void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect,
+                          const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    bool doStroke = paint.getStyle() == SkPaint::kStroke_Style;
+    SkScalar width = paint.getStrokeWidth();
+
+    /*
+        We have special code for hairline strokes, miter-strokes, and fills.
+        Anything else we just call our path code.
+     */
+    bool usePath = doStroke && width > 0 &&
+                    paint.getStrokeJoin() != SkPaint::kMiter_Join;
+    // another reason we might need to call drawPath...
+    if (paint.getMaskFilter()) {
+        usePath = true;
+    }
+
+    if (usePath) {
+        SkPath path;
+        path.addRect(rect);
+        this->drawPath(draw, path, paint, NULL, true);
+        return;
+    }
+
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix,  &grPaint)) {
+        return;
+    }
+    fContext->drawRect(grPaint, Sk2Gr(rect), doStroke ? width : -1);
+}
+
+#include "SkMaskFilter.h"
+#include "SkBounder.h"
+
+static bool drawWithMaskFilter(GrContext* context, const SkPath& path,
+                               SkMaskFilter* filter, const SkMatrix& matrix,
+                               const SkRegion& clip, SkBounder* bounder,
+                               GrPaint* grp) {
+    SkMask  srcM, dstM;
+
+    if (!SkDraw::DrawToMask(path, &clip.getBounds(), filter, &matrix, &srcM,
+                            SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
+        return false;
+    }
+
+    SkAutoMaskImage autoSrc(&srcM, false);
+
+    if (!filter->filterMask(&dstM, srcM, matrix, NULL)) {
+        return false;
+    }
+    // this will free-up dstM when we're done (allocated in filterMask())
+    SkAutoMaskImage autoDst(&dstM, false);
+
+    if (clip.quickReject(dstM.fBounds)) {
+        return false;
+    }
+    if (bounder && !bounder->doIRect(dstM.fBounds)) {
+        return false;
+    }
+
+    // we now have a device-aligned 8bit mask in dstM, ready to be drawn using
+    // the current clip (and identity matrix) and grpaint settings
+
+    GrAutoMatrix avm(context, GrMatrix::I());
+
+    const GrGpu::TextureDesc desc = {
+        0,
+        GrGpu::kNone_AALevel,
+        dstM.fBounds.width(),
+        dstM.fBounds.height(),
+        GrTexture::kAlpha_8_PixelConfig
+    };
+
+    GrTexture* texture = context->createUncachedTexture(desc, dstM.fImage,
+                                                        dstM.fRowBytes);
+    if (NULL == texture) {
+        return false;
+    }
+
+    grp->setTexture(texture);
+    texture->unref();
+    grp->fSampler.setClampNoFilter();
+
+    GrRect d;
+    d.setLTRB(GrIntToScalar(dstM.fBounds.fLeft),
+              GrIntToScalar(dstM.fBounds.fTop),
+              GrIntToScalar(dstM.fBounds.fRight),
+              GrIntToScalar(dstM.fBounds.fBottom));
+    GrRect s;
+    s.setLTRB(0, 0, GR_Scalar1, GR_Scalar1);
+    context->drawRectToRect(*grp, d, s);
+    return true;
+}
+
+void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
+                           const SkPaint& paint, const SkMatrix* prePathMatrix,
+                           bool pathIsMutable) {
+    CHECK_SHOULD_DRAW(draw);
+
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+        return;
+    }
+
+    // BEGIN lift from SkDraw::drawPath()
+
+    SkPath*         pathPtr = const_cast<SkPath*>(&origSrcPath);
+    bool            doFill = true;
+    SkPath          tmpPath;
+
+    if (prePathMatrix) {
+        SkPath* result = pathPtr;
+
+        if (!pathIsMutable) {
+            result = &tmpPath;
+            pathIsMutable = true;
+        }
+        // should I push prePathMatrix on our MV stack temporarily, instead
+        // of applying it here? See SkDraw.cpp
+        pathPtr->transform(*prePathMatrix, result);
+        pathPtr = result;
+    }
+    // at this point we're done with prePathMatrix
+    SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
+
+    if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
+        doFill = paint.getFillPath(*pathPtr, &tmpPath);
+        pathPtr = &tmpPath;
+    }
+
+    // END lift from SkDraw::drawPath()
+
+    if (paint.getMaskFilter()) {
+        // avoid possibly allocating a new path in transform if we can
+        SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
+
+        // transform the path into device space
+        pathPtr->transform(*draw.fMatrix, devPathPtr);
+
+        drawWithMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
+                           *draw.fMatrix, *draw.fClip, draw.fBounder, &grPaint);
+        return;
+    }
+
+    GrPathFill fill = kHairLine_PathFill;
+
+    if (doFill) {
+        switch (pathPtr->getFillType()) {
+            case SkPath::kWinding_FillType:
+                fill = kWinding_PathFill;
+                break;
+            case SkPath::kEvenOdd_FillType:
+                fill = kEvenOdd_PathFill;
+                break;
+            case SkPath::kInverseWinding_FillType:
+                fill = kInverseWinding_PathFill;
+                break;
+            case SkPath::kInverseEvenOdd_FillType:
+                fill = kInverseEvenOdd_PathFill;
+                break;
+            default:
+                SkDebugf("Unsupported path fill type\n");
+                return;
+        }
+    }
+
+    SkGrPathIter iter(*pathPtr);
+    fContext->drawPath(grPaint, &iter, fill);
+}
+
+void SkGpuDevice::drawBitmap(const SkDraw& draw,
+                             const SkBitmap& bitmap,
+                             const SkIRect* srcRectPtr,
+                             const SkMatrix& m,
+                             const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    SkIRect srcRect;
+    if (NULL == srcRectPtr) {
+        srcRect.set(0, 0, bitmap.width(), bitmap.height());
+    } else {
+        srcRect = *srcRectPtr;
+    }
+
+    GrPaint grPaint;
+    if (!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
+    }
+    grPaint.fSampler.setFilter(paint.isFilterBitmap());
+
+    const int maxTextureDim = fContext->getMaxTextureDimension();
+    if (bitmap.getTexture() || (bitmap.width() <= maxTextureDim &&
+                                bitmap.height() <= maxTextureDim)) {
+        // take the fast case
+        this->internalDrawBitmap(draw, bitmap, srcRect, m, &grPaint);
+        return;
+    }
+
+    // undo the translate done by SkCanvas
+    int DX = SkMax32(0, srcRect.fLeft);
+    int DY = SkMax32(0, srcRect.fTop);
+    // compute clip bounds in local coordinates
+    SkIRect clipRect;
+    {
+        SkRect r;
+        r.set(draw.fClip->getBounds());
+        SkMatrix matrix, inverse;
+        matrix.setConcat(*draw.fMatrix, m);
+        if (!matrix.invert(&inverse)) {
+            return;
+        }
+        inverse.mapRect(&r);
+        r.roundOut(&clipRect);
+        // apply the canvas' translate to our local clip
+        clipRect.offset(DX, DY);
+    }
+
+    int nx = bitmap.width() / maxTextureDim;
+    int ny = bitmap.height() / maxTextureDim;
+    for (int x = 0; x <= nx; x++) {
+        for (int y = 0; y <= ny; y++) {
+            SkIRect tileR;
+            tileR.set(x * maxTextureDim, y * maxTextureDim,
+                      (x + 1) * maxTextureDim, (y + 1) * maxTextureDim);
+            if (!SkIRect::Intersects(tileR, clipRect)) {
+                continue;
+            }
+
+            SkIRect srcR = tileR;
+            if (!srcR.intersect(srcRect)) {
+                continue;
+            }
+
+            SkBitmap tmpB;
+            if (bitmap.extractSubset(&tmpB, tileR)) {
+                // now offset it to make it "local" to our tmp bitmap
+                srcR.offset(-tileR.fLeft, -tileR.fTop);
+
+                SkMatrix tmpM(m);
+                {
+                    int dx = tileR.fLeft - DX + SkMax32(0, srcR.fLeft);
+                    int dy = tileR.fTop -  DY + SkMax32(0, srcR.fTop);
+                    tmpM.preTranslate(SkIntToScalar(dx), SkIntToScalar(dy));
+                }
+                this->internalDrawBitmap(draw, tmpB, srcR, tmpM, &grPaint);
+            }
+        }
+    }
+}
+
+/*
+ *  This is called by drawBitmap(), which has to handle images that may be too
+ *  large to be represented by a single texture.
+ *
+ *  internalDrawBitmap assumes that the specified bitmap will fit in a texture
+ *  and that non-texture portion of the GrPaint has already been setup.
+ */
+void SkGpuDevice::internalDrawBitmap(const SkDraw& draw,
+                                     const SkBitmap& bitmap,
+                                     const SkIRect& srcRect,
+                                     const SkMatrix& m,
+                                     GrPaint* grPaint) {
+    SkASSERT(bitmap.width() <= fContext->getMaxTextureDimension() &&
+             bitmap.height() <= fContext->getMaxTextureDimension());
+
+    SkAutoLockPixels alp(bitmap);
+    if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
+        return;
+    }
+
+    grPaint->fSampler.setWrapX(GrSamplerState::kClamp_WrapMode);
+    grPaint->fSampler.setWrapY(GrSamplerState::kClamp_WrapMode);
+    grPaint->fSampler.setSampleMode(GrSamplerState::kNormal_SampleMode);
+    grPaint->fSampler.setMatrix(GrMatrix::I());
+
+    GrTexture* texture;
+    SkAutoCachedTexture act(this, bitmap, grPaint->fSampler, &texture);
+    if (NULL == texture) {
+        return;
+    }
+
+    grPaint->setTexture(texture);
+
+    GrRect dstRect(0, 0, GrIntToScalar(srcRect.width()), GrIntToScalar(srcRect.height()));
+    GrRect paintRect;
+    paintRect.setLTRB(GrFixedToScalar((srcRect.fLeft << 16)   / bitmap.width()),
+                      GrFixedToScalar((srcRect.fTop << 16)    / bitmap.height()),
+                      GrFixedToScalar((srcRect.fRight << 16)  / bitmap.width()),
+                      GrFixedToScalar((srcRect.fBottom << 16) / bitmap.height()));
+
+    GrMatrix grMat;
+    SkGr::SkMatrix2GrMatrix(m, &grMat);
+
+    fContext->drawRectToRect(*grPaint, dstRect, paintRect, &grMat);
+}
+
+void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
+                            int left, int top, const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    SkAutoLockPixels alp(bitmap);
+    if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
+        return;
+    }
+
+    GrPaint grPaint;
+    if(!this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
+    }
+
+    GrAutoMatrix avm(fContext, GrMatrix::I());
+
+    GrTexture* texture;
+    grPaint.fSampler.setClampNoFilter();
+    SkAutoCachedTexture act(this, bitmap, grPaint.fSampler, &texture);
+
+    grPaint.setTexture(texture);
+
+    fContext->drawRectToRect(grPaint,
+                             GrRect(GrIntToScalar(left), GrIntToScalar(top),
+                                    GrIntToScalar(left + bitmap.width()),
+                                    GrIntToScalar(top + bitmap.height())),
+                             GrRect(0, 0, GR_Scalar1, GR_Scalar1));
+}
+
+void SkGpuDevice::drawDevice(const SkDraw& draw, SkDevice* dev,
+                            int x, int y, const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    GrPaint grPaint;
+    if (!((SkGpuDevice*)dev)->bindDeviceAsTexture(&grPaint) ||
+        !this->skPaint2GrPaintNoShader(paint, true, &grPaint)) {
+        return;
+    }
+
+    SkASSERT(NULL != grPaint.getTexture());
+
+    const SkBitmap& bm = dev->accessBitmap(false);
+    int w = bm.width();
+    int h = bm.height();
+
+    GrAutoMatrix avm(fContext, GrMatrix::I());
+
+    grPaint.fSampler.setClampNoFilter();
+
+    fContext->drawRectToRect(grPaint,
+                             GrRect(GrIntToScalar(x),
+                                    GrIntToScalar(y),
+                                    GrIntToScalar(x + w),
+                                    GrIntToScalar(y + h)),
+                             GrRect(0, 0, GR_Scalar1, GR_Scalar1));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// must be in SkCanvas::VertexMode order
+static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
+    kTriangles_PrimitiveType,
+    kTriangleStrip_PrimitiveType,
+    kTriangleFan_PrimitiveType,
+};
+
+void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
+                              int vertexCount, const SkPoint vertices[],
+                              const SkPoint texs[], const SkColor colors[],
+                              SkXfermode* xmode,
+                              const uint16_t indices[], int indexCount,
+                              const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    GrPaint grPaint;
+    SkAutoCachedTexture act;
+    // we ignore the shader if texs is null.
+    if (NULL == texs) {
+        if (!this->skPaint2GrPaintNoShader(paint, false, &grPaint)) {
+            return;
+        }
+    } else {
+        if (!this->skPaint2GrPaintShader(paint, &act,
+                                         *draw.fMatrix,
+                                         &grPaint)) {
+            return;
+        }
+    }
+
+    if (NULL != xmode && NULL != texs && NULL != colors) {
+        SkXfermode::Mode mode;
+        if (!SkXfermode::IsMode(xmode, &mode) ||
+            SkXfermode::kMultiply_Mode != mode) {
+            SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
+#if 0
+            return
+#endif
+        }
+    }
+
+#if SK_SCALAR_IS_GR_SCALAR
+    // even if GrColor and SkColor byte offsets match we need
+    // to perform pre-multiply.
+    if (NULL == colors) {
+        fContext->drawVertices(grPaint,
+                               gVertexMode2PrimitiveType[vmode],
+                               vertexCount,
+                               (GrPoint*) vertices,
+                               (GrPoint*) texs,
+                               NULL,
+                               indices,
+                               indexCount);
+    } else
+#endif
+    {
+        SkTexCoordSource texSrc(texs);
+        SkColorSource colSrc(colors);
+        SkIndexSource idxSrc(indices, indexCount);
+
+        fContext->drawCustomVertices(grPaint,
+                                     gVertexMode2PrimitiveType[vmode],
+                                     SkPositionSource(vertices, vertexCount),
+                                     (NULL == texs) ? NULL : &texSrc,
+                                     (NULL == colors) ? NULL : &colSrc,
+                                     (NULL == indices) ? NULL : &idxSrc);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void GlyphCacheAuxProc(void* data) {
+    delete (GrFontScaler*)data;
+}
+
+static GrFontScaler* get_gr_font_scaler(SkGlyphCache* cache) {
+    void* auxData;
+    GrFontScaler* scaler = NULL;
+    if (cache->getAuxProcData(GlyphCacheAuxProc, &auxData)) {
+        scaler = (GrFontScaler*)auxData;
+    }
+    if (NULL == scaler) {
+        scaler = new SkGrFontScaler(cache);
+        cache->setAuxProc(GlyphCacheAuxProc, scaler);
+    }
+    return scaler;
+}
+
+static void SkGPU_Draw1Glyph(const SkDraw1Glyph& state,
+                             SkFixed fx, SkFixed fy,
+                             const SkGlyph& glyph) {
+    SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
+
+    GrSkDrawProcs* procs = (GrSkDrawProcs*)state.fDraw->fProcs;
+
+    if (NULL == procs->fFontScaler) {
+        procs->fFontScaler = get_gr_font_scaler(state.fCache);
+    }
+    procs->fTextContext->drawPackedGlyph(GrGlyph::Pack(glyph.getGlyphID(), fx, 0),
+                                         SkIntToFixed(SkFixedFloor(fx)), fy,
+                                         procs->fFontScaler);
+}
+
+SkDrawProcs* SkGpuDevice::initDrawForText(GrTextContext* context) {
+
+    // deferred allocation
+    if (NULL == fDrawProcs) {
+        fDrawProcs = new GrSkDrawProcs;
+        fDrawProcs->fD1GProc = SkGPU_Draw1Glyph;
+        fDrawProcs->fContext = fContext;
+    }
+
+    // init our (and GL's) state
+    fDrawProcs->fTextContext = context;
+    fDrawProcs->fFontScaler = NULL;
+    return fDrawProcs;
+}
+
+void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
+                          size_t byteLength, SkScalar x, SkScalar y,
+                          const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    if (draw.fMatrix->getType() & SkMatrix::kPerspective_Mask) {
+        // this guy will just call our drawPath()
+        draw.drawText((const char*)text, byteLength, x, y, paint);
+    } else {
+        SkAutoExtMatrix aem(draw.fExtMatrix);
+        SkDraw myDraw(draw);
+
+        GrPaint grPaint;
+        SkAutoCachedTexture act;
+
+        if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+            return;
+        }
+        GrTextContext context(fContext, grPaint, aem.extMatrix());
+        myDraw.fProcs = this->initDrawForText(&context);
+        this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
+    }
+}
+
+void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text,
+                             size_t byteLength, const SkScalar pos[],
+                             SkScalar constY, int scalarsPerPos,
+                             const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    if (draw.fMatrix->getType() & SkMatrix::kPerspective_Mask) {
+        // this guy will just call our drawPath()
+        draw.drawPosText((const char*)text, byteLength, pos, constY,
+                         scalarsPerPos, paint);
+    } else {
+        SkAutoExtMatrix aem(draw.fExtMatrix);
+        SkDraw myDraw(draw);
+
+        GrPaint grPaint;
+        SkAutoCachedTexture act;
+        if (!this->skPaint2GrPaintShader(paint, &act, *draw.fMatrix, &grPaint)) {
+            return;
+        }
+
+        GrTextContext context(fContext, grPaint, aem.extMatrix());
+        myDraw.fProcs = this->initDrawForText(&context);
+        this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
+                                     scalarsPerPos, paint);
+    }
+}
+
+void SkGpuDevice::drawTextOnPath(const SkDraw& draw, const void* text,
+                                size_t len, const SkPath& path,
+                                const SkMatrix* m, const SkPaint& paint) {
+    CHECK_SHOULD_DRAW(draw);
+
+    SkASSERT(draw.fDevice == this);
+    draw.drawTextOnPath((const char*)text, len, path, m, paint);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGpuDevice::TexCache* SkGpuDevice::lockCachedTexture(const SkBitmap& bitmap,
+                                                  const GrSamplerState& sampler,
+                                                  GrTexture** texture,
+                                                  bool forDeviceRenderTarget) {
+    GrContext* ctx = this->context();
+    uint32_t p0, p1;
+    if (forDeviceRenderTarget) {
+        p0 = p1 = -1;
+    } else {
+        p0 = bitmap.getGenerationID();
+        p1 = bitmap.pixelRefOffset();
+    }
+
+    GrTexture* newTexture = NULL;
+    GrTextureKey key(p0, p1, bitmap.width(), bitmap.height());
+    GrTextureEntry* entry = ctx->findAndLockTexture(&key, sampler);
+
+    if (NULL == entry) {
+
+        if (forDeviceRenderTarget) {
+            const GrGpu::TextureDesc desc = {
+                GrGpu::kRenderTarget_TextureFlag,
+                GrGpu::kNone_AALevel,
+                bitmap.width(),
+                bitmap.height(),
+                SkGr::Bitmap2PixelConfig(bitmap)
+            };
+            entry = ctx->createAndLockTexture(&key, sampler, desc, NULL, 0);
+
+        } else {
+            entry = sk_gr_create_bitmap_texture(ctx, &key, sampler, bitmap);
+        }
+        if (NULL == entry) {
+            GrPrintf("---- failed to create texture for cache [%d %d]\n",
+                     bitmap.width(), bitmap.height());
+        }
+    }
+
+    if (NULL != entry) {
+        newTexture = entry->texture();
+        if (texture) {
+            *texture = newTexture;
+        }
+        // IMPORTANT: We can't allow another SkGpuDevice to get this
+        // cache entry until this one is destroyed!
+        if (forDeviceRenderTarget) {
+            ctx->detachCachedTexture(entry);
+        }
+    }
+    return (TexCache*)entry;
+}
+
+void SkGpuDevice::unlockCachedTexture(TexCache* cache) {
+    this->context()->unlockTexture((GrTextureEntry*)cache);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGpuDeviceFactory::SkGpuDeviceFactory(GrContext* context,
+                                       GrRenderTarget* rootRenderTarget)
+        : fContext(context) {
+
+    GrAssert(NULL != context);
+    GrAssert(NULL != rootRenderTarget);
+
+    // check this now rather than passing this value to SkGpuDevice cons.
+    // we want the rt that is bound *now* in the 3D API, not the one
+    // at the time of newDevice.
+    if (SkGpuDevice::Current3DApiRenderTarget() == rootRenderTarget) {
+        fRootRenderTarget = context->createRenderTargetFrom3DApiState();
+    } else {
+        fRootRenderTarget = rootRenderTarget;
+        rootRenderTarget->ref();
+    }
+    context->ref();
+
+}
+
+SkGpuDeviceFactory::~SkGpuDeviceFactory() {
+    fContext->unref();
+    fRootRenderTarget->unref();
+}
+
+SkDevice* SkGpuDeviceFactory::newDevice(SkCanvas*, SkBitmap::Config config,
+                                        int width, int height,
+                                        bool isOpaque, bool isLayer) {
+    SkBitmap bm;
+    bm.setConfig(config, width, height);
+    bm.setIsOpaque(isOpaque);
+    return new SkGpuDevice(fContext, bm, isLayer ?  NULL : fRootRenderTarget);
+}
+
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
new file mode 100644
index 0000000..e57f88a
--- /dev/null
+++ b/src/gpu/SkGr.cpp
@@ -0,0 +1,243 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "SkGr.h"
+
+/*  Fill out buffer with the compressed format Ganesh expects from a colortable
+ based bitmap. [palette (colortable) + indices].
+
+ At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
+ we could detect that the colortable.count is <= 16, and then repack the
+ indices as nibbles to save RAM, but it would take more time (i.e. a lot
+ slower than memcpy), so skipping that for now.
+
+ Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
+ as the colortable.count says it is.
+ */
+static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
+    SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
+
+    SkAutoLockPixels apl(bitmap);
+    if (!bitmap.readyToDraw()) {
+        SkASSERT(!"bitmap not ready to draw!");
+        return;
+    }
+
+    SkColorTable* ctable = bitmap.getColorTable();
+    char* dst = (char*)buffer;
+
+    memcpy(dst, ctable->lockColors(), ctable->count() * sizeof(SkPMColor));
+    ctable->unlockColors(false);
+
+    // always skip a full 256 number of entries, even if we memcpy'd fewer
+    dst += GrGpu::kColorTableSize;
+
+    if (bitmap.width() == bitmap.rowBytes()) {
+        memcpy(dst, bitmap.getPixels(), bitmap.getSize());
+    } else {
+        // need to trim off the extra bytes per row
+        size_t width = bitmap.width();
+        size_t rowBytes = bitmap.rowBytes();
+        const char* src = (const char*)bitmap.getPixels();
+        for (int y = 0; y < bitmap.height(); y++) {
+            memcpy(dst, src, width);
+            src += rowBytes;
+            dst += width;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+GrTextureEntry* sk_gr_create_bitmap_texture(GrContext* ctx,
+                                            GrTextureKey* key,
+                                            const GrSamplerState& sampler,
+                                            const SkBitmap& origBitmap) {
+    SkAutoLockPixels alp(origBitmap);
+    if (!origBitmap.readyToDraw()) {
+        return NULL;
+    }
+
+    SkBitmap tmpBitmap;
+
+    const SkBitmap* bitmap = &origBitmap;
+
+    GrGpu::TextureDesc desc = {
+        0,
+        GrGpu::kNone_AALevel,
+        bitmap->width(),
+        bitmap->height(),
+        SkGr::Bitmap2PixelConfig(*bitmap)
+    };
+
+    if (SkBitmap::kIndex8_Config == bitmap->config()) {
+        // build_compressed_data doesn't do npot->pot expansion
+        // and paletted textures can't be sub-updated
+        if (ctx->supportsIndex8PixelConfig(sampler,
+                                           bitmap->width(), bitmap->height())) {
+            size_t imagesize = bitmap->width() * bitmap->height() +
+                                GrGpu::kColorTableSize;
+            SkAutoMalloc storage(imagesize);
+
+            build_compressed_data(storage.get(), origBitmap);
+
+            // our compressed data will be trimmed, so pass width() for its
+            // "rowBytes", since they are the same now.
+            return ctx->createAndLockTexture(key, sampler, desc, storage.get(),
+                                             bitmap->width());
+
+        } else {
+            origBitmap.copyTo(&tmpBitmap, SkBitmap::kARGB_8888_Config);
+            // now bitmap points to our temp, which has been promoted to 32bits
+            bitmap = &tmpBitmap;
+        }
+    }
+
+    desc.fFormat = SkGr::Bitmap2PixelConfig(*bitmap);
+    return ctx->createAndLockTexture(key, sampler, desc, bitmap->getPixels(),
+                                     bitmap->rowBytes());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+GrPathCmd SkGrPathIter::next(GrPoint pts[]) {
+    GrAssert(NULL != pts);
+#if SK_SCALAR_IS_GR_SCALAR
+    return sk_path_verb_to_gr_path_command(fIter.next((SkPoint*)pts));
+#else
+    Command cmd = sk_path_verb_to_gr_path_command(fIter.next(fPoints));
+    int n = NumCommandPoints(cmd);
+    for (int i = 0; i < n; ++i) {
+        pts[i].fX = SkScalarToGrScalar(fPoints[i].fX);
+        pts[i].fY = SkScalarToGrScalar(fPoints[i].fY);
+    }
+    return cmd;
+#endif
+}
+
+GrPathCmd SkGrPathIter::next() {
+    return sk_path_verb_to_gr_path_command(fIter.next(NULL));
+}
+
+void SkGrPathIter::rewind() {
+    fIter.setPath(*fPath, false);
+}
+
+GrConvexHint SkGrPathIter::convexHint() const {
+    return fPath->isConvex() ? kConvex_ConvexHint :
+                               kNone_ConvexHint;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkGrClipIterator::reset(const SkClipStack& clipStack) {
+    fClipStack = &clipStack;
+    fIter.reset(clipStack);
+    // Gr has no notion of replace, skip to the
+    // last replace in the clip stack.
+    int lastReplace = 0;
+    int curr = 0;
+    while (NULL != (fCurr = fIter.next())) {
+        if (SkRegion::kReplace_Op == fCurr->fOp) {
+            lastReplace = curr;
+        }
+        ++curr;
+    }
+    fIter.reset(clipStack);
+    for (int i = 0; i < lastReplace+1; ++i) {
+        fCurr = fIter.next();
+    }
+}
+
+GrClipType SkGrClipIterator::getType() const {
+    GrAssert(!this->isDone());
+    if (NULL != fCurr->fRect) {
+        return kRect_ClipType;
+    } else {
+        GrAssert(NULL != fCurr->fPath);
+        return kPath_ClipType;
+    }
+}
+
+GrSetOp SkGrClipIterator::getOp() const {
+    // we skipped to the last "replace" op
+    // when this iter was reset.
+    // GrClip doesn't allow replace, so treat it as
+    // intersect.
+    GrSetOp skToGrOps[] = {
+        kDifference_SetOp,         // kDifference_Op
+        kIntersect_SetOp,          // kIntersect_Op
+        kUnion_SetOp,              // kUnion_Op
+        kXor_SetOp,                // kXOR_Op
+        kReverseDifference_SetOp,  // kReverseDifference_Op
+        kIntersect_SetOp           // kReplace_op
+    };
+    GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
+    GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
+    GR_STATIC_ASSERT(2 == SkRegion::kUnion_Op);
+    GR_STATIC_ASSERT(3 == SkRegion::kXOR_Op);
+    GR_STATIC_ASSERT(4 == SkRegion::kReverseDifference_Op);
+    GR_STATIC_ASSERT(5 == SkRegion::kReplace_Op);
+    return skToGrOps[fCurr->fOp];
+}
+
+GrPathFill SkGrClipIterator::getPathFill() const {
+    switch (fCurr->fPath->getFillType()) {
+        case SkPath::kWinding_FillType:
+            return kWinding_PathFill;
+        case SkPath::kEvenOdd_FillType:
+            return  kEvenOdd_PathFill;
+        case SkPath::kInverseWinding_FillType:
+            return kInverseWinding_PathFill;
+        case SkPath::kInverseEvenOdd_FillType:
+            return kInverseEvenOdd_PathFill;
+        default:
+            GrCrash("Unsupported path fill in clip.");
+            return kWinding_PathFill; // suppress warning
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+GrTexture::PixelConfig SkGr::BitmapConfig2PixelConfig(SkBitmap::Config config,
+                                                    bool isOpaque) {
+    switch (config) {
+        case SkBitmap::kA8_Config:
+            return GrTexture::kAlpha_8_PixelConfig;
+        case SkBitmap::kIndex8_Config:
+            return GrTexture::kIndex_8_PixelConfig;
+        case SkBitmap::kRGB_565_Config:
+            return GrTexture::kRGB_565_PixelConfig;
+        case SkBitmap::kARGB_4444_Config:
+            return GrTexture::kRGBA_4444_PixelConfig;
+        case SkBitmap::kARGB_8888_Config:
+            if (isOpaque) {
+                return GrTexture::kRGBX_8888_PixelConfig;
+            } else {
+                return GrTexture::kRGBA_8888_PixelConfig;
+            }
+        default:
+            return GrTexture::kUnknown_PixelConfig;
+    }
+}
+
+void SkGr::AbandonAllTextures(GrContext* ctx) {
+    ctx->abandonAllTextures();
+}
+
+
diff --git a/src/gpu/SkGrFontScaler.cpp b/src/gpu/SkGrFontScaler.cpp
new file mode 100644
index 0000000..3d57aa8
--- /dev/null
+++ b/src/gpu/SkGrFontScaler.cpp
@@ -0,0 +1,142 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "SkGr.h"
+#include "SkDescriptor.h"
+#include "SkGlyphCache.h"
+
+class SkGrDescKey : public GrKey {
+public:
+    explicit SkGrDescKey(const SkDescriptor& desc);
+    virtual ~SkGrDescKey();
+
+protected:
+    // overrides
+    virtual bool lt(const GrKey& rh) const;
+    virtual bool eq(const GrKey& rh) const;
+
+private:
+    SkDescriptor* fDesc;
+    enum {
+        kMaxStorageInts = 16
+    };
+    uint32_t fStorage[kMaxStorageInts];
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGrDescKey::SkGrDescKey(const SkDescriptor& desc) : GrKey(desc.getChecksum()) {
+    size_t size = desc.getLength();
+    if (size <= sizeof(fStorage)) {
+        fDesc = GrTCast<SkDescriptor*>(fStorage);
+    } else {
+        fDesc = SkDescriptor::Alloc(size);
+    }
+    memcpy(fDesc, &desc, size);
+}
+
+SkGrDescKey::~SkGrDescKey() {
+    if (fDesc != GrTCast<SkDescriptor*>(fStorage)) {
+        SkDescriptor::Free(fDesc);
+    }
+}
+
+bool SkGrDescKey::lt(const GrKey& rh) const {
+    const SkDescriptor* srcDesc = ((const SkGrDescKey*)&rh)->fDesc;
+    size_t lenLH = fDesc->getLength();
+    size_t lenRH = srcDesc->getLength();
+    int cmp = memcmp(fDesc, srcDesc, SkMin32(lenLH, lenRH));
+    if (0 == cmp) {
+        return lenLH < lenRH;
+    } else {
+        return cmp < 0;
+    }
+}
+
+bool SkGrDescKey::eq(const GrKey& rh) const {
+    const SkDescriptor* srcDesc = ((const SkGrDescKey*)&rh)->fDesc;
+    return fDesc->equals(*srcDesc);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkGrFontScaler::SkGrFontScaler(SkGlyphCache* strike) {
+    fStrike = strike;
+    fKey = NULL;
+}
+
+SkGrFontScaler::~SkGrFontScaler() {
+    GrSafeUnref(fKey);
+}
+
+const GrKey* SkGrFontScaler::getKey() {
+    if (NULL == fKey) {
+        fKey = new SkGrDescKey(fStrike->getDescriptor());
+    }
+    return fKey;
+}
+
+bool SkGrFontScaler::getPackedGlyphBounds(GrGlyph::PackedID packed,
+                                          GrIRect* bounds) {
+    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
+                                              GrGlyph::UnpackFixedX(packed),
+                                              GrGlyph::UnpackFixedY(packed));
+    bounds->setXYWH(glyph.fLeft, glyph.fTop, glyph.fWidth, glyph.fHeight);
+    return true;
+
+}
+
+bool SkGrFontScaler::getPackedGlyphImage(GrGlyph::PackedID packed,
+                                         int width, int height,
+                                         int dstRB, void* dst) {
+    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(packed),
+                                              GrGlyph::UnpackFixedX(packed),
+                                              GrGlyph::UnpackFixedY(packed));
+    GrAssert(glyph.fWidth == width);
+    GrAssert(glyph.fHeight == height);
+    const void* src = fStrike->findImage(glyph);
+    if (NULL == src) {
+        return false;
+    }
+
+    int srcRB = glyph.rowBytes();
+    if (srcRB == dstRB) {
+        memcpy(dst, src, dstRB * height);
+    } else {
+        for (int y = 0; y < height; y++) {
+            memcpy(dst, src, width);
+            src = (const char*)src + srcRB;
+            dst = (char*)dst + dstRB;
+        }
+    }
+    return true;
+}
+
+bool SkGrFontScaler::getGlyphPath(uint16_t glyphID, GrPath* path) {
+
+    const SkGlyph& glyph = fStrike->getGlyphIDMetrics(glyphID);
+    const SkPath* skPath = fStrike->findPath(glyph);
+    if (skPath) {
+        SkGrPathIter iter(*skPath);
+        path->resetFromIter(&iter);
+        return true;
+    }
+    return false;
+}
+
+
+
diff --git a/src/gpu/SkGrTexturePixelRef.cpp b/src/gpu/SkGrTexturePixelRef.cpp
new file mode 100644
index 0000000..da9ac1a
--- /dev/null
+++ b/src/gpu/SkGrTexturePixelRef.cpp
@@ -0,0 +1,30 @@
+/*
+    Copyright 2010 Google Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+ */
+
+
+#include "SkGrTexturePixelRef.h"
+#include "GrTexture.h"
+
+SkGrTexturePixelRef::SkGrTexturePixelRef(GrTexture* tex) {
+    fTexture = tex;
+    GrSafeRef(tex);
+}
+
+SkGrTexturePixelRef::~SkGrTexturePixelRef() {
+    GrSafeUnref(fTexture);
+}
+
+
diff --git a/src/gpu/skgr_files.mk b/src/gpu/skgr_files.mk
new file mode 100644
index 0000000..7623fca
--- /dev/null
+++ b/src/gpu/skgr_files.mk
@@ -0,0 +1,8 @@
+SOURCE := \
+    SkGpuCanvas.cpp	\
+    SkGpuDevice.cpp \
+    SkGr.cpp \
+    SkGrTexturePixelRef.cpp \
+    SkGrFontScaler.cpp \
+    GrPrintf_skia.cpp
+
diff --git a/src/images/fpdfemb.h b/src/images/fpdfemb.h
deleted file mode 100644
index 3c77116..0000000
--- a/src/images/fpdfemb.h
+++ /dev/null
@@ -1,1765 +0,0 @@
-// FPDFEMB.H - Header file for FPDFEMB SDK
-// Copyright (c) 2007-2008 Foxit Software Company, All Right Reserved.
-
-// Date: 2008-04-07
-
-// Embedded platforms have many different aspects from desktop platforms,
-// among them, the followings are most important for PDF processing:
-//
-// 1.	Embedded platforms have only limited memory, and there is no virtual memory.
-//		PDF is a very complicated format, processing PDF may consumes quite
-//		large amount of memory, even for some smaller PDFs. And, in order to 
-//		increase the performance of PDF parsing and rendering, cache memory
-//		is often used. For some big PDFs with many pages, the cache may grow
-//		while user browing through pages, eventually, for some PDFs, the memory
-//		on the device may run out.
-//
-//		FPDFEMB SDK allows graceful out-of-memory (OOM) handling by returning 
-//		OOM error code for all functions that may involve memory allocation. 
-//		When an application detects OOM situation, it can do one of the followings:
-//
-//			a) Give user some prompt and quit the application or close the document;
-//			b) Or better, try to recover from the error. Sometimes OOM can be caused
-//				by ever-growing cache. For example, when user browses a 1000-page 
-//				document, let's say OOM happen at page #300. In this case, the
-//				application might close the whole document (cache will be gone with
-//				it), reopen the document, then go directly to page #300. It's likely
-//				the process will go through this time. This is called "OOM recovery".
-//				If OOM happens again during a recovery, then, it's not possible to finish
-//				the process, the application must quit of close the document.
-//
-// 2.	Embedded platforms has only limited computing power. Since some PDFs
-//		can be very complicated and require a lot of processing to be displayed,
-//		it may take a lot of time for the process to finish. This may cause
-//		some problem with user experience, especially for devices like mobile
-//		phones, when an application may need to be put on hold any time. Therefore, 
-//		it's important to break lengthy process into small steps which can be 
-//		stopped or resumed at any time. We call this kind of process as 
-//		"progressive process".
-//
-//		FPDFEMB SDK allows progressive page parsing and rendering, the most time-
-//		consuming part of PDF processing.
-//
-// IMPORTANT:
-//		FPDFEMB module is not intended to run in multi-threaded environment.
-
-// Components inside FPDFEMB:
-//		* Library Memory Management
-//		* Document Operations
-//		* Page Basic Operations
-//		* Page Parsing
-//		* Page Rendering
-//		* Coordination Conversion
-//		* Text Search
-//		* Text Information
-//		* Device Independant Bitmap
-//		* Custom Font Handler and CJK Support
-//		* Bookmark Information
-//		* Hyperlink Information
-//		* Graphic Output
-
-#ifndef _FPDFEMB_H_
-#define _FPDFEMB_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Standard return type for many FPDFEMB functions: FPDFERR_SUCCESS for success, otherwise error code
-typedef int FPDFEMB_RESULT;
-
-// Standard boolean type: 0 for false, non-zero for true
-typedef int FPDFEMB_BOOL;
-
-// Unicode character. FPDFEMB uses UTF16LE format for unicode string.
-typedef unsigned short FPDFEMB_WCHAR;
-
-// Error codes
-#define FPDFERR_SUCCESS		0
-#define FPDFERR_MEMORY		1		// Out of memory
-#define FPDFERR_ERROR		2		// Error of any kind, without specific reason
-#define FPDFERR_PASSWORD	3		// Incorrect password
-#define FPDFERR_FORMAT		4		// Not PDF format
-#define FPDFERR_FILE		5		// File access error
-#define FPDFERR_PARAM		6		// Parameter error
-#define FPDFERR_STATUS		7		// Not in correct status
-#define FPDFERR_TOBECONTINUED	8	// To be continued
-#define FPDFERR_NOTFOUND	9		// Search result not found
-
-/********************************************************************************************
-****
-****		Library Memory Management
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_MEMMGR
-//			Including interfaces implemented by host application, providing memory allocation
-//			facilities. All members are required.
-//			A memory manager structure is required to be valid during the entire period
-//			when an application using FPDFEMB module.
-//
-//			IMPORTANT NOTE: using of this interface is strongly not recommended, because
-//			FPDFEMB now internally use FPDFEMB_MEMMGR_EX interface, which allows more
-//			advanced memory management. This interface is retained for backward compatibility
-//			only, and maybe discontinued in the future.
-//
-struct FPDFEMB_MEMMGR {
-	// Interface: Alloc
-	//		Allocate a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		size		-	Number of bytes for the memory block.
-	// Return Value:
-	//		The pointer to allocated memory block. NULL if no memory available.
-	// Comments:
-	//		In order to handle OOM situation, application can use longjmp() inside 
-	//		implementation of this function. If underlying memory manager fails to 
-	//		allocate enough memory, then application can use longjmp() to jump to
-	//		OOM handling codes.
-	//
-	void*	(*Alloc)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);
-
-	// Interface: AllocNL
-	//		Allocate a memory block, without leaving
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		size		-	Number of bytes for the memory block.
-	// Return Value:
-	//		The pointer to allocated memory block. NULL if no memory available.
-	// Comments:
-	//		Implementation MUST return NULL if no memory available, no exception
-	//		or longjmp() can be used.
-	//
-	void*	(*AllocNL)(struct FPDFEMB_MEMMGR* pMgr, unsigned int size);
-
-	// Interfce: Realloc
-	//		Reallocate a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		pointer		-	An existing memory block, or NULL.
-	//		new_size	-	New size (number of bytes) of the memory block. Can be zero.
-	// Return value:
-	//		The pointer of reallocated memory block, it could be a new block, or just
-	//		the previous block with size modified.
-	// Comments:
-	//		If an existing memory block specified, the data in the memory block will
-	//		be copied to the new block, if reallocated.
-	//
-	//		In order to handle OOM situation, application can use longjmp() inside 
-	//		implementation of this function. If underlying memory manager fails to 
-	//		allocate enough memory, then application can use longjmp() to jump to
-	//		OOM handling codes.
-	//
-	void*	(*Realloc)(struct FPDFEMB_MEMMGR* pMgr, void* pointer, unsigned int new_size);
-
-	// Interface: Free
-	//		Free a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		pointer		-	An existing memory block.
-	// Return Value:
-	//		None.
-	//
-	void	(*Free)(struct FPDFEMB_MEMMGR* pMgr, void* pointer);
-};
-
-// Function: FPDFEMB_Init
-//			Initialize the FPDFEMB module
-// Parameters:
-//			mem_mgr		-	Pointer to memory manager structure
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			This function will allocate necessary internal data structure for
-//			the whole module to operate.
-FPDFEMB_RESULT FPDFEMB_Init(FPDFEMB_MEMMGR* mem_mgr);
-
-typedef void (*FPDFEMB_FIXED_OOM_HANDLER)(void* memory, int size);
-
-// Function: FPDFEMB_InitFixedMemory
-//			Initialize the FPDFEMB module, providing a fixed memory heap
-// Parameters:
-//			memory		-	Pointer to a pre-allocated memory block
-//			size		-	Number of bytes in the memory block
-//			oom_handler	-	Pointer to a function which will be called when OOM happens. Can be
-//							NULL if application doesn't want to be notified om OOM.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			In many embedded system, memory usage are predetermined. The application
-//			is assigned with fixed size of available memory, then it can pre-allocate
-//			a memory block with maximum size and pass to this function to initialize
-//			FPDFEMB module. In this case, FPDFEMB won't need any additional memory
-//			allocation.
-//
-//			In case the pre-allocated memory has run out, the "oom_proc" callback
-//			function will be called to notify the application that an OOM recovery
-//			procedure needs to be performed.
-//
-FPDFEMB_RESULT FPDFEMB_InitFixedMemory(void* memory, int size, FPDFEMB_FIXED_OOM_HANDLER oom_handler);
-
-// Memory Management Flags
-#define FPDFEMB_NONLEAVE		1
-#define FPDFEMB_MOVABLE			2
-#define FPDFEMB_DISCARDABLE		4
-
-// Structure: FPDFEMB_MEMMGR_EX
-//			This is an extended version of memory manager interface, allowing advanced
-//			memory management, including movable and discardable memory blocks.
-//
-//			Use this interface with FPDFEMB_InitExt function.
-//
-struct FPDFEMB_MEMMGR_EX {
-	// Interface: Alloc
-	//		Allocate a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		size		-	Number of bytes for the memory block.
-	//		flags		-	A combination of flags defined above.
-	// Return Value:
-	//		The pointer to allocated memory block. NULL if no memory available.
-	//		If FPDFEMB_MOVABLE flag is used, implementation should return a handle
-	//		to the memory block, if it supports movable block allocation.
-	// Comments:
-	//		The implementation should not do any action if no memory available,
-	//		just return NULL. OOM handling can be done in OOM_Handler interface.
-	//
-	void*	(*Alloc)(struct FPDFEMB_MEMMGR_EX* pMgr, unsigned int size, int flags);
-
-	// Interface: OOM_Handler
-	//		OOM (out-of-memory) situation handler
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	// Return Value:
-	//		None.
-	// Comments:
-	//		In order to handle OOM situation, application can use longjmp() inside 
-	//		implementation of this function.
-	//
-	void	(*OOM_Handler)(struct FPDFEMB_MEMMGR_EX* pMgr);
-
-	// Interfce: Realloc
-	//		Reallocate a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		pointer		-	Pointer to an existing memory block, or handle to a movable
-	//						block. Can not be NULL.
-	//		new_size	-	New size (number of bytes) of the memory block. Can not be zero.
-	// Return value:
-	//		The pointer of reallocated memory block, it could be a new block, or just
-	//		the previous block with size modified.
-	//		If FPDFEMB_MOVABLE flag is used, implementation should return a handle
-	//		to the memory block, if it supports movable block allocation.
-	// Comments:
-	//		If an existing memory block specified, the data in the memory block should
-	//		be copied to the new block, if reallocated.
-	//
-	//		The implementation should not do any action if no memory available,
-	//		just return NULL. OOM handling can be done in OOM_Handler interface.
-	//
-	void*	(*Realloc)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, unsigned int new_size, int flags);
-
-	// Interface: Lock
-	//		Lock a movable memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		handle		-	Handle to movable memory block, returned by Alloc or Realloc.
-	// Return Value:
-	//		The pointer of the memory block. NULL if the block was discarded.
-	// Comments:
-	//		This interface is optional, if implementation doesn't support movable memory
-	//		block, then this interface can be set to NULL.
-	//
-	void*	(*Lock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);
-
-	// Interface: Unlock
-	//		Unlock a locked movable memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		handle		-	Handle to movable memory block, returned by Alloc or Realloc.
-	// Return Value:
-	//		None.
-	// Comments:
-	//		This interface is optional, if implementation doesn't support movable memory
-	//		block, then this interface can be set to NULL.
-	//
-	void	(*Unlock)(struct FPDFEMB_MEMMGR_EX* pMgr, void* handle);
-
-	// Interface: Free
-	//		Free a memory block
-	// Parameters:
-	//		pMgr		-	Pointer to the memory manager.
-	//		pointer		-	Pointer to an existing memory block, or handle to a movable block.
-	// Return Value:
-	//		None.
-	//
-	void	(*Free)(struct FPDFEMB_MEMMGR_EX* pMgr, void* pointer, int flags);
-
-	void*	user;		// A user pointer, used by the application
-};
-
-// Function: FPDFEMB_LoadJbig2Decoder
-// Function: FPDFEMB_LoadJpeg2000Decoder
-//			Enable JBIG2 or JPEG2000 image decoder 
-// Parameters:
-//			None.
-// Return Value:
-//			None.
-// Comments:
-//			If you want to display JBIG2 or JPEG2000 encoded images, you need to call 
-//			these functions after FPDFEMB initialized.
-//
-//			Calling these functions will increase code size by about 200K-400K bytes.
-//			Also JPEG2000 decoder may not be available on some platforms.
-//
-void FPDFEMB_LoadJbig2Decoder();
-void FPDFEMB_LoadJpeg2000Decoder();
-
-// Function: FPDFEMB_InitEx
-//			Initialize the FPDFEMB module with the extended memory manager
-// Parameters:
-//			mem_mgr		-	Pointer to memory manager structure
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			This function will allocate necessary internal data structure for
-//			the whole module to operate.
-FPDFEMB_RESULT FPDFEMB_InitEx(FPDFEMB_MEMMGR_EX* mem_mgr);
-
-// Function: FPDFEMB_Exit
-//			Stop using FPDFEMB module and release all resources
-// Parameters:
-//			None.
-// Return Value:
-//			None.
-// Comments:
-//			All loaded documents and pages will become invalid after this call.
-//
-//			This function is useful for OOM recovery: when your application hits
-//			an OOM situation, calling this function will clear all memory allocated
-//			by FPDFEMB module, then you can call one of the initialization functions,
-//			reopen the document and recovery from OOM.
-//
-void FPDFEMB_Exit();
-
-// Function: FPDFEMB_AllocMemory
-//			Allocate memory
-// Parameters:
-//			size		-	Number of bytes
-// Return Value:
-//			The allocated buffer pointer. NULL for out of memory.
-//
-void* FPDFEMB_AllocMemory(unsigned int size);
-
-// Function: FPDFEMB_FreeMemory
-//			Free allocated memory
-// Parameters:
-//			pointer		-	Pointer returned by FPDFEMB_AllocMemory
-// Return Value:
-//			None.
-//
-void FPDFEMB_FreeMemory(void* pointer);
-
-// Function: FPDFEMB_FreeCaches
-//			Free all expendable caches used by FPDFEMB in order to save memory
-// Parameters:
-//			None.
-// Return Value:
-//			None.
-// Comments:
-//			When an application memory manager runs out of memory, before an OOM situation 
-//			is raised, the application can try this 
-//
-void FPDFEMB_FreeCaches();
-
-/********************************************************************************************
-****
-****		Document Operations
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_FILE_ACCESS
-//		Describe the way to access a file (readonly).
-struct FPDFEMB_FILE_ACCESS {
-	// Inteface: GetSize
-	//		Get total size of the file
-	// Parameters:
-	//		file		-	Pointer to this file access structure
-	// Return Value:
-	//		File size, in bytes. Implementation can return 0 for any error.
-	// 
-	unsigned int	(*GetSize)(struct FPDFEMB_FILE_ACCESS* file);
-
-	// Interface: ReadBlock
-	//		Read a data block from the file
-	// Parameters:
-	//		file		-	Pointer to this file access structure
-	//		buffer		-	Pointer to a buffer receiving read data
-	//		offset		-	Byte offset for the block, from beginning of the file
-	//		size		-	Number of bytes for the block.
-	// Return Value:
-	//		Error code, or FPDFERR_SUCCESS for success.
-	//
-	FPDFEMB_RESULT	(*ReadBlock)(struct FPDFEMB_FILE_ACCESS* file, void* buffer, 
-									unsigned int offset, unsigned int size);
-
-	void*		user;		// A user pointer, used by the application
-};
-
-// Structure: FPDFEMB_PAUSE
-//			An interface for pausing a progressive process.
-struct FPDFEMB_PAUSE {
-	// Interface: NeedPauseNow
-	//		Check if we need to pause a progressive proccess now
-	// Parameters:
-	//		pause		-	Pointer to the pause structure
-	// Return Value:
-	//		Non-zero for pause now, 0 for continue.
-	// Comments:
-	//		Typically implementation of this interface compares the current system tick
-	//		with the previous one, if the time elapsed exceeds certain threshold, then
-	//		the implementation returns TRUE, indicating a pause is needed.
-	//
-	FPDFEMB_BOOL (*NeedPauseNow)(struct FPDFEMB_PAUSE* pause);
-
-	void*		user;		// A user pointer, used by the application
-};
-
-typedef void* FPDFEMB_DOCUMENT;
-
-// Function: FPDFEMB_StartLoadDocument
-//			Start loading a PDF document
-// Parameters:
-//			file		-	Pointer to file access structure.
-//							This structure must be kept valid as long as the document is open.
-//			password	-	Pointer to a zero-terminated byte string, for the password.
-//							Or NULL for no password.
-//			document	-	Receiving the document handle
-//			pause		-	A callback mechanism allowing the document loading process
-//							to be paused before it's finished. This can be NULL if you
-//							don't want to pause.
-// Return Value:
-//			FPDFERR_SUCCESS: document successfully loaded.
-//			FPDFERR_TOBECONTINUED: The document loading can't be finished now.
-//					See comments below.
-//			FPDFERR_PASSWORD: incorrect password.
-//			FPDFERR_FORMAT: not a PDF or corrupted PDF.
-//			FPDFERR_FILE: file access error.
-//			FPDFERR_MEMORY: out of memory.
-// Comments:
-//			Document loading is a progressive process. It might take a long time to
-//			load a document, especiall when a file is corrupted, FPDFEMB will try to
-//			recover the document contents by scanning the whole file. If "pause" parameter
-//			is provided, this function may return FPDFERR_TOBECONTINUED any time during
-//			the document loading.
-//
-//			When FPDFERR_TOBECONTINUED is returned, the "document" parameter will
-//			still receive a valid document handle, however, no further operations can
-//			be performed on the document, except the "FPDFEMB_ContineLoadDocument" function
-//			call, which resume the document loading.
-//
-FPDFEMB_RESULT FPDFEMB_StartLoadDocument(FPDFEMB_FILE_ACCESS* file, const char* password, 
-									FPDFEMB_DOCUMENT* document, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueLoadDocument
-//			Continue loading a PDF document
-// Parameters:
-//			document	-	Document handle returned by FPDFEMB_StartLoadDocument function
-//			pause		-	A callback mechanism allowing the document loading process
-//							to be paused before it's finished. This can be NULL if you
-//							don't want to pause.
-// Return Value:
-//			FPDFERR_SUCCESS: document successfully loaded.
-//			FPDFERR_TOBECONTINUED: The document loading can't be finished now.
-//					Further call to this function is needed.
-//			FPDFERR_PASSWORD: incorrect password.
-//			FPDFERR_FORMAT: not a PDF or corrupted PDF.
-//			FPDFERR_FILE: file access error.
-//			FPDFERR_MEMORY: out of memory.
-//			FPDFERR_STATUS: document already loaded.
-//			FPDFERR_PARAM: invalid parameter (like NULL document handle)
-//
-FPDFEMB_RESULT FPDFEMB_ContinueLoadDocument(FPDFEMB_DOCUMENT document, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_CloseDocument
-//			Close a PDF document and free all associated resources
-// Parameters:
-//			document	-	Document handle
-// Return Value:
-//			Error code. FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_CloseDocument(FPDFEMB_DOCUMENT document);
-
-// Function: Get page count
-//			Get number of pages in the document
-// Parameters:
-//			document	-	Document handle
-// Return Value:
-//			Number of pages.
-//
-int FPDFEMB_GetPageCount(FPDFEMB_DOCUMENT document);
-
-// Function: FPDFEMB_SetFileBufferSize
-//			Set size of internal buffer used to read from source file.
-// Parameters:
-//			size		-	Number of bytes
-// Return Value:
-//			None.
-// Comments:
-//			Currently FPDFEMB uses 512 bytes as default buffer size. The new buffer size 
-//			takes effect next time you call FPDFEMB_StartLoadDocument.
-//
-void FPDFEMB_SetFileBufferSize(int size);
-
-/********************************************************************************************
-****
-****		Page Basic Operations
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_PAGE;
-
-// Function: FPDFEMB_LoadPage
-//			Load a page
-// Parameters:
-//			document	-	Document handle
-//			index		-	Page index, starting from zero
-//			page		-	Receiving the loaded page handler
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_LoadPage(FPDFEMB_DOCUMENT document, int index, FPDFEMB_PAGE* page);
-
-// Function: FPDFEMB_ClosePage
-//			Close a page and release all related resources
-// Parameters:
-//			page		-	Page handle
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_ClosePage(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_GetPageSize
-//			Get size of a page
-// Parameters:
-//			page		-	Page handle
-//			width		-	Receiving page width, in hundredth of points
-//			height		-	Receiving page height, in hundredth of points
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetPageSize(FPDFEMB_PAGE page, int* width, int* height);
-
-// Structure: FPDFEMB_RECT
-//			Rectangle area in device or page coordination system
-//
-struct FPDFEMB_RECT
-{
-	// For device system, coordinations are measured in pixels;
-	// For page system, coordinations are measured in hundredth of points.
-	int		left;
-	int		top;
-	int		right;
-	int		bottom;
-};
-
-// Function: FPDFEMB_GetPageBBox
-//			Get displayable area (bounding box) of a page
-// Parameters:
-//			page		-	Page handle
-//			rect		-	Pointer to a structure receiving the rectangle
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetPageBBox(FPDFEMB_PAGE page, FPDFEMB_RECT* rect);
-
-/********************************************************************************************
-****
-****		Page Parsing
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_StartParse
-//			Start parsing a page, so it can get rendered or searched
-// Parameters:
-//			page		-	Page handle
-//			text_only	-	flag for parsing texts only (used for searching)
-//			pause		-	A structure that can pause the parsing process.
-//							Or NULL if you don't want to pause the process.
-// Return Value:
-//			FPDFERR_SUCCESS: parsing successfully finished;
-//			FPDFERR_TOBECONTINUED: parsing started successfully, but not finished;
-//			FPDFERR_STATUS: page already parsed, or parsing already started. 
-//			Other return value: error code.
-// Comments:
-//			Parsing is a progressive process. This function starts the parsing process,
-//			and may return before parsing is finished, if a pause structure is provided.
-//
-//			Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
-//			when return value is FPDFERR_TOBECONTINUED.
-//
-//			There can be only one parsing procedure active for a page, and if a page
-//			has already been parsed, you can't start a parsing again.
-//
-FPDFEMB_RESULT FPDFEMB_StartParse(FPDFEMB_PAGE page, FPDFEMB_BOOL text_only, 
-												FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueParse
-//			Continue the page parsing
-// Parameters:
-//			page		-	Page handle
-//			pause		-	A structure that can pause the parsing process.
-//							Or NULL if you don't want to pause the process.
-// Return Value:
-//			FPDFERR_SUCCESS: parsing successfully finished;
-//			FPDFERR_TOBECONTINUED: parsing performed successfully, but not finished;
-//			FPDFERR_STATUS: page already parsed (or parsing not started). 
-//			Other return value: error code.
-// Comments:
-//			FPDFEMB_StartParse should be called before on the page.
-//
-//			Application should call FPDFEMB_ContinueParse repeatedly to finish the parsing
-//			when return value is FPDFERR_TOBECONTINUED.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueParse(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_GetParseProgress
-//			Get an estimated parsing progress in percentage
-// Parameters:
-//			page		-	Page handle
-// Return Value:
-//			An integer between 0 and 100 (inclusive) indicating the parsing progress.
-//			The result is just a rough estimation.
-//
-int FPDFEMB_GetParseProgress(FPDFEMB_PAGE page);
-
-/********************************************************************************************
-****
-****		Page Rendering
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_BITMAP;
-
-// Function: FPDFEMB_StartQuickDraw
-//			Start drawing a quick preview of a page
-// Parameters:
-//			dib			-	DIB handle, as the rendering device
-//			page		-	Page handle. The page has to be parsed first.
-//			start_x		-	Left pixel position of the display area in the device coordination
-//			start_y		-	Top pixel position of the display area in the device coordination
-//			size_x		-	Horizontal size (in pixels) for displaying the page
-//			size_y		-	Vertical size (in pixels) for displaying the page
-//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//			flags		-	Reserved, must be zero.
-//			pause		-	Pointer to a structure that can pause the rendering process.
-//							Can be NULL if no pausing is needed.
-// Return Value:
-//			FPDFERR_SUCCESS: quickdraw successly finished;
-//			FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
-//							FPDFEMB_ContinueQuickDraw needs to be called to finish the quickdraw;
-//			FPDFERR_STATUS: quickdraw already in progress, or page not parsed;
-//			Other return value: error code.
-// Comments:
-//			It's often useful to present user a quick preview of a page, right after the
-//			page is parsed. This preview renders only a limited set of easy features in the
-//			page, so it'll be rather quick to finish this process.
-//
-FPDFEMB_RESULT FPDFEMB_StartQuickDraw(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
-							int start_x, int start_y, int size_x, int size_y, int rotate,
-							int flags, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueQuickDraw
-//			Continue a quick draw processing
-// Parameters:
-//			page		-	Page handle. The page has to be parsed first.
-//			pause		-	Pointer to a structure that can pause the rendering process.
-//							Can be NULL if no pausing is needed.
-// Return Value:
-//			FPDFERR_SUCCESS: quickdraw successly finished;
-//			FPDFERR_TOBECONTINUED: quickdraw started successfully, but not finished.
-//							more calls to this function needed to finish the quickdraw;
-//			FPDFERR_STATUS: quickdraw not started yet; 
-//			Other return value: error code.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueQuickDraw(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-#define FPDFEMB_ANNOT			0x01		// Set if annotations are to be rendered
-#define FPDFEMB_LCD_TEXT		0x02		// Set if using text rendering optimized for LCD display
-#define FPDFEMB_BGR_STRIPE		0x04		// Set if the device is using BGR LCD stripe
-
-// Function: FPDFEMB_StartRender
-//			Start rendering of a page.
-// Parameter:
-//			dib			-	DIB handle, as the rendering device
-//			page		-	Page handle. The page has to be parsed first.
-//			start_x		-	Left pixel position of the display area in the device coordination
-//			start_y		-	Top pixel position of the display area in the device coordination
-//			size_x		-	Horizontal size (in pixels) for displaying the page
-//			size_y		-	Vertical size (in pixels) for displaying the page
-//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//			flags		-	0 for normal display, or combination of flags defined above
-//			clip		-	Pointer to clip rectangle (in DIB device coordinations),
-//							or NULL if no clipping needed.
-//			pause		-	Pointer to a structure that can pause the rendering process.
-//							Can be NULL if no pausing is needed.
-// Return Value:
-//			FPDFERR_SUCCESS: rendering successfully finished;
-//			FPDFERR_TOBECONTINUED: rendering started successfully, but not finished;
-//			Other return value: error code.
-// Comments:
-//			Rendering is a progressive process. This function starts the rendering process,
-//			and may return before rendering is finished, if a pause structure is provided.
-//
-//			Application should call FPDFEMB_ContinueRender repeatedly to finish the rendering 
-//			when return value is FPDFERR_TOBECONTINUED.
-//
-//			There can be only one rendering procedure for a page at any time. And rendering
-//			can be started over and over again for the same page. If a page rendering is already
-//			active, starting another one will cancel the previous rendering.
-//
-//			Rendering of a page doesn't draw the page background, therefore, you usually need
-//			to draw the background in the DIB yourself.
-//
-FPDFEMB_RESULT FPDFEMB_StartRender(FPDFEMB_BITMAP dib, FPDFEMB_PAGE page,
-						int start_x, int start_y, int size_x, int size_y, int rotate, int flags,
-						FPDFEMB_RECT* clip, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_ContinueRender
-//			Continue the page rendering
-// Parameters:
-//			page		-	Page handle
-//			pause		-	Pointer to a structure that can pause the rendering process.
-//							Can be NULL if no pausing is needed.
-// Return Value:
-//			FPDFERR_SUCCESS: rendering successfully finished.
-//			FPDFERR_TOBECONTINUED: rendering needs to be continued;
-//			Other return value: error code.
-// Comments:
-//			This function may return any time when the pause interface indicates 
-//			a pause is needed. Application can call FPDFEMB_ContinueRender any number
-//			of times, until FPDFERR_TOBECONTINUED is not returned.
-//
-FPDFEMB_RESULT FPDFEMB_ContinueRender(FPDFEMB_PAGE page, FPDFEMB_PAUSE* pause);
-
-// Function: FPDFEMB_GetRenderProgress
-//			Get an estimated rendering progress in percentage
-// Parameters:
-//			page		-	Page handle
-// Return Value:
-//			An integer between 0 and 100 (inclusive) indicating the rendering progress.
-//			The result is just a rough estimation.
-//			If the rendering just finished, this function will return 0.
-//
-int FPDFEMB_GetRenderProgress(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_SetHalftoneLimit
-//			Set pixel count limit for using halftone when display image
-// Parameter:
-//			limit		-	Number of pixels for the limit
-// Return Value:
-//			None.
-// Comments:
-//			By default, FPDFEMB displays all bitmaps using downsamping, which means
-//			if the image is shrinked onto screen, only part of pixels will be picked
-//			and displayed. This saves a lot of calculation, especially for big images
-//			with millions of pixels. However the display quality can be bad. In order to
-//			reach a balance between performance and quality, application can use this
-//			function to set a limit, if number of pixels in an image is more than this
-//			limit, then FPDFEMB will use downsampling for quick drawing, otherwise, if
-//			the image has less pixels, FPDFEMB will use halftoning for better quality.
-//
-void FPDFEMB_SetHalftoneLimit(int limit);
-
-/********************************************************************************************
-****
-****		Coordination Conversion
-****
-********************************************************************************************/
-
-// Structure: FPDFEMB_POINT
-//			A point in device or page coordination system
-//
-struct FPDFEMB_POINT
-{
-	// For device system, coordinations are measured in pixels;
-	// For page system, coordinations are measured hundredth of points.
-	int		x;
-	int		y;
-};
-
-// Function: FPDFEMB_DeviceToPagePoint, FPDFEMB_DeviceToPageRect
-//			Convert the device coordinations of a point or a rectangle to page coordinations.
-// Parameters:
-//			page		-	Handle to the page. Returned by FPDFEMB_LoadPage function.
-//			start_x		-	Left pixel position of the display area in the device coordination
-//			start_y		-	Top pixel position of the display area in the device coordination
-//			size_x		-	Horizontal size (in pixels) for displaying the page
-//			size_y		-	Vertical size (in pixels) for displaying the page
-//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//			point		-	A point structure with device coordinations upon the call,
-//							also receiving the result page coordinations.
-//			rect		-	A rectangle structure with device coordinations upon the call,
-//							also receiving the result page coordinations.
-// Return value:
-//			None.
-// Comments:
-//			The page coordination system has its origin at left-bottom corner of the page, 
-//			with X axis goes along the bottom side to the right, and Y axis goes along the 
-//			left side upward. No matter how you zoom, scroll, or rotate a page, a particular
-//			element (like text or image) on the page should always have the same coordination 
-//			values in the page coordination system. 
-//
-//			The device coordination system is device dependant. For bitmap device, its origin 
-//			is at left-top corner of the window. You must make sure the start_x, start_y, size_x, 
-//			size_y and rotate parameters have exactly same values as you used in 
-//			FPDFEMB_StartRender() function call.
-//
-//			For rectangle conversion, the result rectangle is always "normalized", meaning for
-//			page coordinations, left is always smaller than right, bottom is smaller than top.
-//
-void FPDFEMB_DeviceToPagePoint(FPDFEMB_PAGE page, 
-						int start_x, int start_y, int size_x, int size_y, int rotate, 
-						FPDFEMB_POINT* point);
-
-void FPDFEMB_DeviceToPageRect(FPDFEMB_PAGE page, 
-						int start_x, int start_y, int size_x, int size_y, int rotate, 
-						FPDFEMB_RECT* rect);
-
-// Function: FPDFEMB_PageToDevicePoint, FPDFEMB_PageToDeviceRect
-//			Convert the page coordinations of a point or a rectangle to device coordinations.
-// Parameters:
-//			page		-	Handle to the page. Returned by FPDFEMB_LoadPage function.
-//			start_x		-	Left pixel position of the display area in the device coordination
-//			start_y		-	Top pixel position of the display area in the device coordination
-//			size_x		-	Horizontal size (in pixels) for displaying the page
-//			size_y		-	Vertical size (in pixels) for displaying the page
-//			rotate		-	Page orientation: 0 (normal), 1 (rotated 90 degrees clockwise),
-//								2 (rotated 180 degrees), 3 (rotated 90 degrees counter-clockwise).
-//			point		-	A point structure with page coordinations upon the call,
-//							also receiving the result device coordinations.
-//			rect		-	A rectangle structure with page coordinations upon the call,
-//							also receiving the result device coordinations.
-// Return value:
-//			None
-// Comments:
-//			For rectangle conversion, the result rectangle is always "normalized", meaning for
-//			device coordinations, left is always smaller than right, top is smaller than bottom.
-//
-void FPDFEMB_PageToDevicePoint(FPDFEMB_PAGE page, 
-						int start_x, int start_y, int size_x, int size_y, int rotate, 
-						FPDFEMB_POINT* point);
-
-void FPDFEMB_PageToDeviceRect(FPDFEMB_PAGE page, 
-						int start_x, int start_y, int size_x, int size_y, int rotate, 
-						FPDFEMB_RECT* rect);
-
-/********************************************************************************************
-****
-****		Text Search
-****
-********************************************************************************************/
-
-// Search flags for FPDFEMB_FindFirst function
-#define FPDFEMB_MATCHCASE		1		// whether matching case
-#define FPDFEMB_MATCHWHOLEWORD	2		// whether matching whole word
-#define FPDFEMB_CONSECUTIVE		4		// whether matching consecutively (for example, "CC" will
-										// match twice in "CCC").
-
-// Function: FPDFEMB_FindFirst
-//			Find first occurance of a pattern string in a page
-// Parameters:
-//			page		-	Page handle.
-//			pattern		-	A zero-terminated unicode string to be found. 
-//			from_last	-	Whether we start from the end of page
-//			flags		-	Search flags, see above defined constants
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//			Is not found, FPDFERR_NOTFOUND is returned.
-// Comments:
-//			A page must be parsed first before it can be searched.
-//			There can be only one search in progress for a page. A new search will 
-//			cancel the previous one.
-//
-//			IMPORTANT: this function is now obsolete and kept for back compatibility
-//			only, please use FPDFEMB_FindFrom function below.
-//
-FPDFEMB_RESULT FPDFEMB_FindFirst(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern, 
-								 FPDFEMB_BOOL from_last, unsigned int flags);
-
-// Function: FPDFEMB_FindFrom
-//			Find first occurance of a pattern string in a page, from a particular position
-// Parameters:
-//			page		-	Page handle.
-//			pattern		-	A zero-terminated unicode string to be found. 
-//			pos			-	The position, returned from FPDFEMB_GetSearchPos.
-//							Or 0 from the beginning of page, -1 from the end of page.
-//			flags		-	Search flags, see above defined constants
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//			Is not found, FPDFERR_NOTFOUND is returned.
-// Comments:
-//			A page must be parsed first before it can be searched.
-//			There can be only one search in progress for a page. A new search will 
-//			cancel the previous one.
-//
-FPDFEMB_RESULT FPDFEMB_FindFrom(FPDFEMB_PAGE page, const FPDFEMB_WCHAR* pattern, 
-								 int pos, unsigned int flags);
-
-// Function: FPDFEMB_FindNext
-//			Find next occurance of a search
-// Parameters:
-//			page		-	Page handle. 
-//							FPDFEMB_FindFirst must be called for this page first.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//			Is not found, FPDFERR_NOTFOUND is returned.
-//
-FPDFEMB_RESULT FPDFEMB_FindNext(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_FindPrev
-//			Find previous occurance of a search
-// Parameters:
-//			page		-	Page handle.
-//							FPDFEMB_FindFirst must be called for this page first.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//			Is not found, FPDFERR_NOTFOUND is returned.
-//
-FPDFEMB_RESULT FPDFEMB_FindPrev(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_CountFoundRects
-//			Get number of rectangles for last found result
-// Parameters:
-//			page		-	Page handle.
-// Return Value:
-//			Number of rectangles for last found result. 0 for not found or failure.
-//
-int FPDFEMB_CountFoundRects(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_GetFoundRect
-//			Get a particular found rectangle
-// Parameters:
-//			page		-	Page handle.
-//			index		-	Zero-based index for the rectangle.
-//			rect		-	Receiving the result rectangle, in hundredth of points
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			Application should always call FPDFEMB_CountFoundRects first to get
-//			number of rectangles, then use this function to get each rectangle.
-//
-//			The returned rectangle uses page coordination system.
-//
-FPDFEMB_RESULT FPDFEMB_GetFoundRect(FPDFEMB_PAGE page, int index, FPDFEMB_RECT* rect);
-
-// Function: FPDFEMB_GetSearchPos
-//			Return position of current search result
-// Parameters:
-//			page		-	Page handle.
-// Return Value:
-//			Zero based character index for the current search result. -1 if not found.
-//
-int FPDFEMB_GetSearchPos(FPDFEMB_PAGE page);
-
-// Function: FPDFEMB_QuickSearch
-//			Search a pattern in a page quickly, without the page to be parsed
-// Parameters:
-//			document	-	Document handle returned by FPDFEMB_StartLoadDocument function
-//			page_index	-	Zero-based index of the page
-//			pattern		-	A zero-terminated unicode string to be found. 
-//			case_sensitive	-	Non-zero for case-sensitive searching, zero for case-insensitive
-// Return Value:
-//			FPDFERR_SUCCESS if pattern found, FPDFERR_NOTFOUND if pattern not found.
-//			Otherwise error code is returned.
-// Comments:
-//			This function does a rough and quick search in a page, before the page is loaded. 
-//			The quick search will not generate an exact result saying where the pattern is
-//			found, and, it might be possible if a quick search result is "pattern found", and
-//			a real search for the same pattern, in the same page, will result in "not found".
-//
-//			However, if quick search doesn't find a pattern in a page, then we can be sure the
-//			pattern won't be found in this page when we do a real search. So, this function is 
-//			very useful when we search in a multiple-page document, and we want to quickly skip
-//			those pages in which the pattern can't possibly be found.
-//
-FPDFEMB_RESULT FPDFEMB_QuickSearch(FPDFEMB_DOCUMENT document, int page_index, 
-								   const FPDFEMB_WCHAR* pattern, int case_sensitive);
-
-/********************************************************************************************
-****
-****		Text Information
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_GetCharCount
-//			Get number of characters in the page
-// Parameters:
-//			page		-	Page handle
-//			count		-	Receiving number of characters
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_GetCharCount(FPDFEMB_PAGE page, int* count);
-
-// Structure: FPDFEMB_CHAR_INFO
-//			Character information.
-struct FPDFEMB_CHAR_INFO {
-	int		unicode;		// Unicode for the character. 0 if not available.
-							// Space and new line charcters (U+0020 and U+000A) may be generated
-							// according to the text formatting.
-	FPDFEMB_POINT	origin;	// X/Y position for the character origin, in hundredth of points
-	FPDFEMB_RECT	bbox;	// Bounding box of the character, in hundredth of points
-							// Maybe an empty box (left == right or top == bottom).
-};
-
-// Function: FPDFEMB_GetCharInfo
-//			Get character information
-// Parameters:
-//			page		-	Page handle
-//			index		-	Character index, starting from zero
-//			char_info	-	Receiving the character info
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			Application must call FPDFEMB_GetCharCount first before it can call this function
-//			for any particular characters.
-//			
-FPDFEMB_RESULT FPDFEMB_GetCharInfo(FPDFEMB_PAGE page, int index, FPDFEMB_CHAR_INFO* char_info);
-
-// Function: FPDFEMB_GetCharIndexAtPos()
-//			Get index of character nearest to a certain position on the page
-// Parameters:
-//			page		-	Page handle
-//			x			-	X position in PDF page coordination system
-//			y			-	Y position in PDF page coordination system
-//			index		-	Pointer to an integer receiving zero-based character index.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			This function finds the character that's nearest to the particular page position.
-//			If there is no character, the output index will be -1.
-//			
-FPDFEMB_RESULT FPDFEMB_GetCharIndexAtPos(FPDFEMB_PAGE page, double x, double y, int* index);
-
-/********************************************************************************************
-****
-****		Device Independant Bitmap
-****
-********************************************************************************************/
-
-#define FPDFDIB_BGR		1	// 3 bytes per pixel, byte order: Blue, Green, Red
-#define FPDFDIB_BGRx	2	// 4 bytes per pixel, byte order: Blue, Green, Red, not used
-#define FPDFDIB_BGRA	3	// 4 bytes per pixel, byte order: Blue, Green, Red, Alpha
-#define FPDFDIB_GRAY	4	// 1 byte per pixel (grayscale)
-
-// Function: FPDFEMB_CreateDIB
-//			Create a DIB (Device Independant Bitmap)
-// Parameters:
-//			width		-	Width pixels;
-//			height		-	Height pixels;
-//			format		-	Format type. See FPDFDIB_xxx constants
-//			buffer		-	External buffer provided for the DIB,
-//							or NULL if new buffer is to be allocated.
-//			stride		-	Number of bytes for each scan line, for external buffer only.
-//							If not specified, 4-byte alignment assumed.
-//			dib			-	Receiving the created DIB handle
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			If "buffer" parameter is not NULL, then the provided buffer must conform
-//			to standard DIB format (see comments of FPDFEMB_GetDIBData function below).
-//
-//			This function doesn't initialize the pixels inside the DIB buffer. So if you
-//			want to use the DIB to display a PDF page, you usually need to initialize
-//			the DIB to white background by youself.
-//
-FPDFEMB_RESULT FPDFEMB_CreateDIB(int width, int height, int format, 
-									   void* buffer, int stride, FPDFEMB_BITMAP* dib);
-
-// Function: FPDFEMB_DestroyDIB
-//			Destroy a DIB
-// Parameters:
-//			dib			-	DIB handle
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			If external buffer is used (specified in "buffer" parameter when calling
-//			FPDFEMB_CreateDIB), the buffer will not be destroyed.
-//
-FPDFEMB_RESULT FPDFEMB_DestroyDIB(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBWidth
-//			Get width (in pixels) of a DIB
-// Parameters:
-//			dib			-	DIB handle
-// Return Value:
-//			DIB width in pixels.
-//
-int FPDFEMB_GetDIBWidth(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBHeight
-//			Get height (in pixels) of a DIB
-// Parameters:
-//			dib			-	DIB handle
-// Return Value:
-//			DIB height in pixels.
-//
-int FPDFEMB_GetDIBHeight(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBData
-//			Get data pointer to a DIB
-// Parameters:
-//			dib			-	DIB handle
-// Return Value:
-//			Pointer to the DIB data.
-// Comments:
-//			DIB data are organized in scanlines, from top down.
-//
-void* FPDFEMB_GetDIBData(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetDIBStride
-//			Get scan line stride of a DIB
-// Parameters:
-//			dib			-	DIB handle
-// Return Value:
-//			Number of bytes occupied by a scanline
-//
-int FPDFEMB_GetDIBStride(FPDFEMB_BITMAP dib);
-
-// Function: FPDFEMB_GetRotatedDIB
-//			Swap X/Y dimensions of a DIB to generate a rotated new DIB
-// Parameters:
-//			dib			-	DIB handle
-//			flip_x		-	Whether flip pixels on the destination X dimension (left/right)
-//			flip_y		-	Whether flip pixels on the destination Y dimension (up/down)
-//			result_dib	-	Receiving the result DIB handle
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_GetRotatedDIB(FPDFEMB_BITMAP dib, 
-									 FPDFEMB_BOOL bFlipX, FPDFEMB_BOOL bFlipY,
-									 FPDFEMB_BITMAP* result_dib);
-
-// Function: FPDFEMB_StretchDIB
-//			Stretch a source DIB into another destination DIB
-// Parameters:
-//			dest_dib	-	The destination DIB handle
-//			dest_left	-	Left position in the destination DIB
-//			dest_top	-	Top position in the destination DIB
-//			dest_width	-	Destination width, in pixels. Can be negative for horizontal flipping
-//			dest_height	-	Destination height, in pixels. Can be negative for vertical flipping
-//			clip		-	Destination clipping rectangle, or NULL for no clipping.
-//							The coordinations are measured in destination bitmap.
-//			src_dib		-	Source DIB handle.
-//			interpol	-	Whether we use interpolation to improve the result quality
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_StretchDIB(FPDFEMB_BITMAP dest_dib, int dest_left, int dest_top,
-								  int dest_width, int dest_height, FPDFEMB_RECT* clip_rect, 
-								  FPDFEMB_BITMAP src_dib, FPDFEMB_BOOL interpol);
-
-// Function: FPDFEMB_TransformDIB
-//			Transform a source DIB into another destination DIB
-// Parameters:
-//			dest_dib	-	The destination DIB handle
-//			clip		-	Destination clipping rectangle, or NULL for no clipping.
-//							The coordinations are measured in destination bitmap.
-//			src_dib		-	Source DIB handle.
-//			x			-	X coordination of the dest origin
-//			y			-	Y coordination of the dest origin
-//			xx			-	X distance of the dest X vector
-//			yx			-	Y distance of the dest X vector
-//			xy			-	X distance of the dest Y vector
-//			yy			-	Y distance of the dest Y vector
-//			interpol	-	Whether we use interpolation to improve the result quality
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			All coordinations and distances are measured in destination bitmap system.
-//
-//			This function places the bottom-left pixel of the image at the destination
-//			origin, then the bottom sideline along the destination X vector, and left 
-//			sideline along the destination Y vector.
-//			
-FPDFEMB_RESULT FPDFEMB_TransformDIB(FPDFEMB_BITMAP dest_dib, FPDFEMB_RECT* clip_rect, 
-								  FPDFEMB_BITMAP src_dib, int x, int y, int xx, int yx,
-								  int xy, int yy, FPDFEMB_BOOL interpol);
-
-/********************************************************************************************
-****
-****		Custom Font Handler and CJK Support
-****
-********************************************************************************************/
-
-// FPDFEMB comes with standard fonts for Latin characters. If your device is targeted to
-// Eastern Asian markets, then system fonts must be provided and registered with FPDFEMB.
-// Depending on your device configuration, those system fonts might be in TrueType or Type1
-// format, or some other non-standard compact format. For the first case, you should register
-// a font mapper so FPDFEMB can pick the right font file, and for the second case, you
-// should register a glyph provider so FPDFEMB can get glyph bitmap for each character.
-
-#define FPDFEMB_CHARSET_DEFAULT		0
-#define FPDFEMB_CHARSET_GB			936
-#define FPDFEMB_CHARSET_BIG5		950
-#define FPDFEMB_CHARSET_JIS			932
-#define FPDFEMB_CHARSET_KOREA		949
-#define FPDFEMB_CHARSET_UNICODE		1200
-
-#define FPDFEMB_FONT_FIXEDPITCH		1
-#define FPDFEMB_FONT_SERIF			2
-#define FPDFEMB_FONT_SYMBOLIC		4
-#define FPDFEMB_FONT_SCRIPT			8
-#define FPDFEMB_FONT_NONSYMBOLIC	32
-#define FPDFEMB_FONT_ITALIC			64
-#define FPDFEMB_FONT_ALLCAP			0x10000
-#define FPDFEMB_FONT_SMALLCAP		0x20000
-#define FPDFEMB_FONT_FORCEBOLD		0x40000
-
-// Structure: FPDFEMB_FONT_MAPPER
-//			Defines interface for system font mapper.
-//
-struct FPDFEMB_FONT_MAPPER
-{
-	// Interface: MapFont
-	//		Find font file path for a particular PDF font
-	// Parameters:
-	//		mapper		-	Pointer to the FPDFEMB_FONT_MAPPER structure
-	//		name		-	Font name
-	//		charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-	//		flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
-	//		weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
-	//						700 is bold.
-	//		path		-	Receiving the full file path. The buffer size is 512 bytes.
-	//		face_index	-	Receiving an zero-based index value for the font face, if the 
-	//						mapped font file is a "collection" (meaning a number of faces 
-	//						are stored in the same file). If the font file is not a 
-	//						collection, the index value should be zero.
-	// Return Value:
-	//		Non-zero for success, 0 for failure.
-	//
-	FPDFEMB_BOOL	(*MapFont)(struct FPDFEMB_FONT_MAPPER* mapper, const char* name, int charset,
-									unsigned int flags,	int weight,
-									char* path, int* face_index);
-
-	void*		user;		// A user pointer, used by the application
-};
-
-// Function: FPDFEMB_SetFontMapper
-//			Use a system font mapper (typically for Chinese/Japanese/Korean charsets)
-// Parameters:
-//			mapper		-	Pointer to FPDFEMB_FONT_MAPPER structure.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			This function is used with devices that come with one or more system fonts,
-//			and those fonts are in standard TT or T1 format.
-//
-FPDFEMB_RESULT FPDFEMB_SetFontMapper(FPDFEMB_FONT_MAPPER* mapper);
-
-// Structure: FPDFEMB_GLYPH_PROVIDER
-//			Interface for providing glyph bitmap of non-latin characters.
-//			This is usually used for embedded devices with Chinese/Japanese/Korean 
-//			fonts installed, but those fonts are not in TrueType or Type1 format.
-//
-struct FPDFEMB_GLYPH_PROVIDER
-{
-	// Interface: MapFont
-	//		Return an internal handle for a font
-	// Parameters:
-	//		provider	-	Pointer to this structure
-	//		name		-	Font name
-	//		charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-	//		flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
-	//		weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
-	//						700 is bold.
-	// Return Value:
-	//		An internal handle to the mapped font. If the embedded device supports
-	//		multiple fonts, then this value can serve as an identifier to differentiate
-	//		among them. If the device supports only one font, then implementation of
-	//		this function can simply return NULL.
-	//
-	void*	(*MapFont)(struct FPDFEMB_GLYPH_PROVIDER* provider, const char* name, int charset,
-									unsigned int flags,	int weight);
-	// Interface: GetGlyphBBox
-	//		Get glyph bounding box
-	// Parameters:
-	//		provider	-	Pointer to this structure
-	//		font		-	Internal handle to the font. Returned by MapFont interface.
-	//		unicode		-	Unicode of the character
-	//		CID			-	Adobe CID for this character. Or zero if not available.
-	//		bbox		-	Receiving the result bounding box. See comments below.
-	// Return Value:
-	//		None.
-	// Comments:
-	//		The bounding box is measure in a glyph coordination system, in which the
-	//		origin is set to character origin, and unit is set to one-thousandth of
-	//		"em size" (representing the font size).
-	//
-	//		In most CJK fonts, all CJK characters (except some symbols or western 
-	//		characters) have same glyph bounding box:
-	//		left = 0, right = 1000, bottom = -220, top = 780.
-	//
-	//		It's OK to return a box that's larger than the actual glyph box.
-	//
-	void	(*GetGlyphBBox)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
-									FPDFEMB_WCHAR unicode, unsigned short CID,
-									FPDFEMB_RECT* bbox);
-
-	// Interface: GetGlyphBitmap
-	//		Get bitmap of a glyph
-	// Parameters:
-	//		provider	-	Pointer to this structure
-	//		font		-	Internal handle to the font. Returned by MapFont interface.
-	//		unicode		-	Unicode of the character
-	//		CID			-	Adobe CID for this character. Or zero if not available.
-	//		font_width	-	Width of the font em square, measured in device units.
-	//		font_height	-	Height of the font em square, measured in device units.
-	//		left		-	Receiving the left offset, from the character origin, of the
-	//						result glyph bitmap. Positive value will move the bitmap to
-	//						the right side, negative to the left.
-	//		top			-	Receiving the top offset, from the character origin, of the
-	//						result glyph bitmap. Positive value will move the bitmap upward,
-	//						negative downward.
-	//		bitmap_width -	Receiving number of width pixels in the result bitmap
-	//		bitmap_height -	Receiving number of height pixels in the result bitmap
-	//		buffer		-	Receiving a data buffer pointer, allocated by the implementation.
-	//						See comments below.
-	//		stride		-	Receiving number of bytes per scanline, in the data buffer.
-	//		pdf_width	-	Width of the character specified in PDF. It is measured in one-
-	//						thousandth of the font width. It can be 0 if width not specified
-	//						in PDF. See comments below.
-	// Return Value:
-	//		Non-zero for success. 0 for failure. In this case the glyph can not be displayed.
-	// Comments:
-	//		The buffer should be allocated by implemenation. And it must be allocated
-	//		using FPDFEMB_AllocMemory function. The result buffer will be destroyed by
-	//		FPDFEMB SDK, so implementation should not destroy it.
-	//
-	//		The implementation should write "coverage" data into allocated buffer, one byte 
-	//		for each pixel, from top scanline to bottom scanline, within each scan line, 
-	//		from left pixel to right. Coverage 0 means the pixel is outside the glyph, 
-	//		coverage 255 means the pixel is inside the glyph.
-	//
-	//		The "pdf_width" parameter can be used to scale the character in system font
-	//		horizontally to match the font width specified in PDF. For example, if we have
-	//		a PDF file which requires a character in half-width (pdf_width is 500), but
-	//		in the system font the character has full-width (1000), then the glyph provider
-	//		implementation should scale the font horizontally to half of its original width.
-	//
-	FPDFEMB_BOOL (*GetGlyphBitmap)(struct FPDFEMB_GLYPH_PROVIDER* provider, void* font,
-									FPDFEMB_WCHAR unicode, unsigned short CID,
-									double font_width, double font_height, int* left, int* top,
-									int* bitmap_width, int* bitmap_height, 
-									void** buffer, int* stride, int pdf_width);
-
-	void*		user;		// A user pointer, used by the application
-};
-
-// Function: FPDFEMB_SetGlyphProvider
-//			Make use of a glyph provider: generating glyph bitmap for non-Latin characters
-// Parameters:
-//			provider	-	Pointer to the glyph provider structure.
-//							This structure must stay valid throughout usage of FPDFEMB module.
-// Return Value:
-//			None.
-// Comments:
-//			FPDFEMB embeds some standard fonts for Latin characters and symbols, like
-//			Times, Courier and Helvetica (Arial). For non-Latin characters, however,
-//			FPDFEMB has to ask glyph provide for help.
-//
-//			If an embedded device carries fonts for non-Latin character sets, especially
-//			those for CJK markets, then the application can implement a glyph provider,
-//			allowing PDFs using non-embedded CJK fonts to be properly displayed.
-//
-void FPDFEMB_SetGlyphProvider(FPDFEMB_GLYPH_PROVIDER* provider);
-
-// Function: FPDFEMB_LoadCMap_GB
-// Function: FPDFEMB_LoadCMap_GB_Ext
-// Function: FPDFEMB_LoadCMap_CNS
-// Function: FPDFEMB_LoadCMap_Korean
-// Function: FPDFEMB_LoadCMap_Japan
-// Function: FPDFEMB_LoadCMap_Japan_Ext
-//			Make use of character encoding maps embedded with FPDFEMB
-// Parameters:
-//			None.
-// Return Value:
-//			None.
-// Comments:
-//			These functions add character encoding data to your application. Each call
-//			will increase the code size of your application. Total data size for all
-//			character sets is 151K bytes.
-void FPDFEMB_LoadCMap_GB();
-void FPDFEMB_LoadCMap_GB_Ext();		// Load full code table for GB
-void FPDFEMB_LoadCMap_CNS();
-void FPDFEMB_LoadCMap_Korea();
-void FPDFEMB_LoadCMap_Japan();
-void FPDFEMB_LoadCMap_Japan_Ext();	// Load full code table for Japan
-
-/********************************************************************************************
-****
-****		Document Information
-****
-********************************************************************************************/
-
-// Function: PDFEMB_GetDocInfoString
-//			Get information string about the document, like creator, modifcation date, etc.
-// Parameters:
-//			document	-	Handle to the document
-//			key			-	A byte string for the information key. Currently can be one of the followings:
-//							"Title", "Author", "Subject", "Keywords", "Creator", "Producer", "CreationDate",
-//							"ModDate", or some custom information key, if supported by the PDF file.
-//			buffer		-	A buffer allocated by the application, or NULL.
-//			bufsize		-	[IN/OUT] A pointer to a number indicating the buffer size (number of bytes),
-//							before this function call. After return, this place will store
-//							number of bytes used by the output (including terminator).
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			The string is output in Unicode, using UTF-16LE format. It's terminated by
-//			two consecutive zero bytes.
-//
-//			If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
-//			number of bytes required to store the string (including the two-byte terminator).
-//
-FPDFEMB_RESULT FPDFEMB_GetDocInfoString(FPDFEMB_DOCUMENT document, const char* key, void* buffer, unsigned int* bufsize);
-
-/********************************************************************************************
-****
-****		Action (Destination) Information
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_ACTION;
-
-// Action types supported by FPDFEMB
-#define FPDFEMB_DEST_NONE			0		// No or unsupported destination
-#define FPDFEMB_DEST_PAGE			1		// A page inside the same document
-#define FPDFEMB_DEST_DOC			2		// An external PDF document
-#define FPDFEMB_DEST_URL			3		// An external URL
-#define FPDFEMB_ACTION_LAUNCH		4		// Launch an external file or command
-
-// Zoom mode for destination
-#define FPDFEMB_ZOOM_NONE			0		// Zoom mode not specified
-#define FPDFEMB_ZOOM_FACTOR			1		// Specific zoom factor is used
-#define FPDFEMB_ZOOM_FITPAGE		2		// Fit the whole page on screen
-#define FPDFEMB_ZOOM_FITWIDTH		3		// Fit width of the page on screen
-#define FPDFEMB_ZOOM_FITHEIGHT		4		// Fit height of the page on screen
-#define FPDFEMB_ZOOM_FITRECT		5		// Fit a particular rectangle on screen
-#define FPDFEMB_ZOOM_FITCONTENT		6		// Fit whole content of page on screen
-#define FPDFEMB_ZOOM_FITCONTENTW	7		// Fit content width of page on screen
-#define FPDFEMB_ZOOM_FITCONTENTH	8		// Fit content height of page on screen
-
-// Data structure for page destination
-struct FPDFEMB_PAGEDEST
-{
-	int				page_index;		// Zero based index for the page
-	int				zoom_mode;		// See FPDFEMB_ZOOM_xxx definition above
-	int				zoom_factor;	// For FPDFEMB_ZOOM_FACTOR only: the zoom factor (in percentage)
-	FPDFEMB_RECT	position;		// Specify position inside the page. Depends on the zoom mode,
-									// different members of the rectangle are used:
-									// FPDFEMB_ZOOM_NONE:			left, top
-									// FPDFEMB_ZOOM_FACTOR:			left, top
-									// FPDFEMB_ZOOM_FITPAGE:		none
-									// FPDFEMB_ZOOM_FITWIDTH:		top
-									// FPDFEMB_ZOOM_FITHEIGHT:		left
-									// FPDFEMB_ZOOM_FITRECT:		left, top, bottom, right
-									// FPDFEMB_ZOOM_FITCONTENT:		none
-									// FPDFEMB_ZOOM_FITCONTENTW:	top
-									// FPDFEMB_ZOOM_FITCONTENTH:	left
-};
-
-// Data structure for document destination
-struct FPDFEMB_DOCDEST
-{
-	FPDFEMB_PAGEDEST	page_data;	// page data
-	char*				file_name;	// The file name, encoded in original charset (maybe MBCS)
-};
-
-// Data structure for URL destination
-struct FPDFEMB_URLDEST
-{
-	char*				url;		// URL encoded in 7-bit ASCII
-};
-
-// Data structure for Launch action
-struct FPDFEMB_LAUNCHACTION
-{
-	int					new_window;	// Whether a new window should be opened
-	char*				file_name;	// The file name, encoded in original charset (maybe MBCS)
-};
-
-// Function: FPDFEMB_Action_GetType
-//			Get type of an action
-// Parameters:
-//			document	-	Handle to the document
-//			action		-	Handle to the action
-//			dest_type	-	Pointer to an integer receiving type of the destination. See the above
-//							FPDFEMB_DEST_xxx definitions
-//			data_size	-	Pointer to an integer receiving data block size for the destination.
-//							If this parameter is NULL, then data size won't be retrieved.
-// Comments:
-//			Each different type of destination has different data structure. The "data_size" result
-//			indicates how many bytes is required to hold the destination data structure. The application
-//			can then allocate sufficient buffer and then call FPDFEMB_Bookmark_GetDest function to
-//			get the real data.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetType(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, int* dest_type, int* data_size);
-
-// Function: FPDFEMB_Action_GetData
-//			Get detailed data of a particular action
-// Parameters:
-//			document	-	Handle to the document
-//			action		-	Handle to the action
-//			buffer		-	Application allocated buffer receiving the destination data
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			See data structure definition for different action type above. Please note
-//			the actual action data might use more space than the structure definition
-//			shows, to store things like file name or URL. So you should always call
-//			FPDFEMB_Action_GetType first to get data size then allocate enough buffer
-//			for this call.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetData(FPDFEMB_DOCUMENT document, FPDFEMB_ACTION action, void* buffer);
-
-// Function: FPDFEMB_Action_GetNext
-//			Get next action in an action chain
-// Parameters:
-//			document	-	Handle to the document
-//			action		-	Handle to current action
-//			next		-	Receiving handle to next action.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			If there is no next action, the "next" parameter will be set to NULL after the function returns.
-//
-FPDFEMB_RESULT FPDFEMB_Action_GetNext(FPDFEMB_ACTION action, FPDFEMB_ACTION* next);
-
-/********************************************************************************************
-****
-****		Bookmark Information
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_BOOKMARK;
-
-// Function: FPDFEMB_Bookmark_GetFirstChild
-//			Get first child of a bookmark item, or first top level bookmark item
-// Parameters: 
-//			document	-	Handle to the document
-//			parent		-	Handle to the parent bookmark. 
-//							Can be NULL if you want to get the first top level item.
-//			bookmark	-	Receiving handle to the first child or top level bookmark item. 
-//							If result is NULL, then bookmark not found.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetFirstChild(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK parent,
-											  FPDFEMB_BOOKMARK* bookmark);
-
-// Function: FPDFEMB_Bookmark_GetFirstChild
-//			Get next sibling of a bookmark item
-// Parameters: 
-//			document	-	Handle to the document
-//			bookmark	-	Handle to the bookmark 
-//			sibling		-	Receiving the handle of next sibling.
-//							If result is NULL, then this is the last bookmark in this level.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetNextSibling(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark,
-											  FPDFEMB_BOOKMARK* sibling);
-
-// Function: FPDFEMB_Bookmark_GetTitle
-//			Get title of a bookmark
-// Parameters: 
-//			bookmark	-	Handle to the bookmark 
-//			buffer		-	A buffer allocated by the application, or NULL.
-//			bufsize		-	[IN/OUT] A pointer to a number indicating the buffer size,
-//							before this function call. After return, this place will store
-//							number of bytes used by the output (including terminator).
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			The title is output in Unicode, using UTF-16LE format. It's terminated by
-//			two consecutive zero bytes.
-//
-//			If the "buffer" parameter is NULL, then the "bufsize" parameter will receive
-//			number of bytes required to store the bookmark title (including the two-
-//			byte terminator).
-//
-//			If the buffer provided is smaller than the required size, then this function
-//			will not copy any data, return FPDFEMB_PARAM, and the required buffer size will 
-//			also be put in "bufsize" parameter.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetTitle(FPDFEMB_BOOKMARK bookmark, void* buffer, unsigned int* bufsize);
-
-// Function: FPDFEMB_Bookmark_GetPage
-//			Get page number of a bookmark pointing to
-// Parameters:
-//			document	-	Handle to the document
-//			bookmark	-	Handle to the bookmark 
-//			page		-	Receiving the page number. -1 if this bookmark doesn't actually
-//							point to a page inside the document.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success
-// Comments:
-//			Some bookmark might not point to a page, some bookmark might have more than one destination
-//			(action), for detailed information about a bookmark, you should call FPDFEMB_Bookmark_GetAction.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetPage(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, int* page);
-
-// Function: FPDFEMB_Bookmark_GetAction
-//			Get action(s) associated with a particular bookmark
-// Parameters:
-//			document	-	Handle to the document
-//			bookmark	-	Handle to the bookmark 
-//			action		-	Receiving handle of first action
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Bookmark_GetAction(FPDFEMB_DOCUMENT document, FPDFEMB_BOOKMARK bookmark, FPDFEMB_ACTION* action);
-
-/********************************************************************************************
-****
-****		Hyperlink Information
-****
-********************************************************************************************/
-
-// Function: FPDFEMB_Link_GetCount
-//			Get number of hyperlinks inside a page
-// Parameters:
-//			page		-	Page handle.
-//			link_count	-	Pointer to an integer receiving the number of links
-//			reserved	-	Must be zero now.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			This function must be called before any other link related function can
-//			be called for the page.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetCount(FPDFEMB_PAGE page, int* link_count, int reserved);
-
-// Function: FPDFEMB_Link_GetAction
-//			Get action(s) associated with a particular hyperlink
-// Parameters:
-//			page		-	Page handle
-//			link_index	-	Zero-based index for the link
-//			action		-	Receiving handle of first action
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetAction(FPDFEMB_PAGE page, int link_index, FPDFEMB_ACTION* action);
-
-// Function: FPDFEMB_Link_GetAreaCount
-//			Get number of area (quadrilaterals) for a link
-// Parameters:
-//			page		-	Page handle
-//			link_index	-	Zero-based index for the link
-//			count		-	Pointer to an integer receiving number of quadrilaterals
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetAreaCount(FPDFEMB_PAGE page, int link_index, int* count);
-
-// Function: FPDFEMB_Link_GetArea
-//			Get a particular quadrilateral for a link
-// Parameters:
-//			page		-	Page handle
-//			link_index	-	Zero-based index for the link
-//			area_index	-	Zero-based index for the quadrilateral
-//			points		-	Pointer to an array consists 4 points, receiving coordinations
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			The result in "points" array are the X/Y coordinations for the four vertices
-//			of the quadrilateral. Vertices are in the following order: lower left, lower
-//			right, upper right, upper left.
-//
-FPDFEMB_RESULT FPDFEMB_Link_GetArea(FPDFEMB_PAGE page, int link_index, int area_index, 
-									FPDFEMB_POINT* points);
-
-/********************************************************************************************
-****
-****		Graphic Output (onto DIB)
-****
-********************************************************************************************/
-
-typedef void* FPDFEMB_FONT;
-
-// Function: FPDFEMB_OpenStandardFont
-//			Get ready to use a standard PDF font
-// Parameters:
-//			font_name	-	Name of the font. See a list of supported fonts below.
-//			font_handle	-	Receiving the font handle.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			Currently supported standard fonts:
-//			Courier, Courier-Bold, Courier-BoldOblique, Courier-Oblique,
-//			Helvetica, Helvetica-Bold, Helvetica-BoldOblique, Helvetica-Oblique,
-//			Times-Roman, Times-Bold, Times-Italic, Times-BoldItalic,
-//			Symbol, ZapfDingbats.
-//
-FPDFEMB_RESULT FPDFEMB_OpenStandardFont(const char* font_name, FPDFEMB_FONT* font_handle);
-
-// Function: FPDFEMB_OpenSystemFont
-//			Get ready to use a system font
-// Parameters:
-//			font_name	-	Font name
-//			charset		-	Charset ID (see above FPDFEMB_CHARSET_xxx constants)
-//			flags		-	Font flags (see above FPDFEMB_FONT_xxx constants)
-//			weight		-	Weight of the font. Range from 100 to 900. 400 is normal,
-//							700 is bold.
-//			font_handle	-	Receiving the font handle.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-// Comments:
-//			System font is supported only if either FPDFEMB_SetFontMapper or
-//			FPDFEMB_SetGlyphProvider is called.
-//			Font attributes (name, charset, flags and weight) can be all optional, if the
-//			font mapper or glyph provider doesn't make use of them.
-//
-FPDFEMB_RESULT FPDFEMB_OpenSystemFont(const char* font_name, int charset, unsigned int flags, int weight,
-									  FPDFEMB_FONT* font_handle);
-
-// Function: FPDFEMB_CloseFont
-//			Close a font handle.
-// Parameters:
-//			font_handle	-	Handle to the font.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_CloseFont(FPDFEMB_FONT font_handle);
-
-struct FPDFEMB_TEXTMATRIX
-{
-	double	a, b, c, d;
-};
-
-// Function: FPDFEMB_OutputText
-//			Output text string onto a DIB device.
-// Parameters:
-//			dib			-	DIB handle, as the output device
-//			x, y		-	DIB coordinations for the origin point of the first character.
-//			font_handle	-	Handle to the font
-//			font_size	-	Font size in pixels
-//			matrix		-	Matrix for the text output. Can be NULL.
-//			text		-	Zero-terminated unicode text string
-//			argb		-	Color of the text, in 0xaarrggbb format.
-// Return Value:
-//			Error code, or FPDFERR_SUCCESS for success.
-//
-FPDFEMB_RESULT FPDFEMB_OutputText(FPDFEMB_BITMAP dib, int x, int y, FPDFEMB_FONT font_handle, double font_size,
-								  FPDFEMB_TEXTMATRIX* matrix, const FPDFEMB_WCHAR* text, unsigned long argb);
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif	// #ifdef _FPDFEMB_H_
diff --git a/src/images/fpdfemb_ext.h b/src/images/fpdfemb_ext.h
deleted file mode 100644
index d82c4df..0000000
--- a/src/images/fpdfemb_ext.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Extended interfaces for JPEG, JPEG2000 and JBIG2 decoders **/
-typedef struct
-{
-	/** Initialize the decoding context, with memory allocator provided by FPDFEMB.
-	   Implementation should return a pointer to the decoding context.
-	*/
-	void*	(*Init)(void* (*alloc_func)(unsigned int), void (*free_func)(void*));
-
-	/** Finish with the decoding. */
-	void	(*Finish)(void* pContext);
-
-	/** Input JPEG encoded data from the source.
-		This function may be called multiple times during decoding progress.
-	*/
-	void	(*Input)(void* pContext, const unsigned char* src_buf, unsigned long src_size);
-
-	/** Read the header information. Return non-zero for success, 0 for failure */
-	int		(*ReadHeader)(void* pContext);
-
-	/** Get info from the decoder, including image width, height and number of components */
-	void	(*GetInfo)(void* pContext, int* width, int* height, int* nComps);
-
-	/** Read one scanline from decoded image */
-	int		(*ReadScanline)(void* pContext, unsigned char* dest_buf);
-
-	/** Get number of available source bytes left in the input stream */
-	unsigned long	(*GetAvailInput)(void* pContext);
-} FPDFEMB_JPEG_DECODER;
-
-void FPDFEMB_SetJpegDecoder(FPDFEMB_JPEG_DECODER* pDecoder);
-
-typedef struct 
-{
-	/** Initialize the decoder with the full source data.
-		Implementation should return a pointer to the context.
-	*/
-	void*	(*Init)(const unsigned char* src_buf, unsigned long src_size);
-
-	/** Destroy the context */
-	void	(*Finish)(void* context);
-
-	/** Get image info from the context, including width, height, number of components
-		in original codestream, and number of components in output image. For some
-		particular type of encoded image, like paletted image, these two numbers of 
-		components may vary.
-	*/
-	void	(*GetInfo)(void* context, unsigned long* width, unsigned long* height, 
-				unsigned long* codestream_nComps, unsigned long* output_nComps);
-
-	/** Do the real data decoding, output to a pre-allocated buffer.
-		bTranslateColor indicates whether the decoder should use JPEG2000 embedded
-		color space info to translate image into sRGB color space.
-		"offsets" array describes the byte order of all components. For example,
-		{2,1,0} means the first components is output to last byte.
-	*/
-	void	(*Decode)(void* context, unsigned char* dest_buf, int pitch, 
-				int bTranslateColor, unsigned char* offsets);
-} FPDFEMB_JPEG2000_DECODER;
-
-void FPDFEMB_SetJpeg2000Decoder(FPDFEMB_JPEG2000_DECODER* pDecoder);
-
-typedef struct
-{
-	/** Do the whole decoding process. Supplied parameters include width, height, source image
-		data and size, global data and size (can be shared among different images), destination
-		buffer and scanline pitch in dest buffer.
-	*/
-	void	(*Decode)(unsigned long width, unsigned long height, const unsigned char* src_buf,
-				unsigned long src_size, const unsigned char* global_buf, unsigned long global_size, 
-				unsigned char* dest_buf, int dest_pitch);
-} FPDFEMB_JBIG2_DECODER;
-
-void FPDFEMB_SetJbig2Decoder(FPDFEMB_JBIG2_DECODER* pDecoder);
-
-#ifdef __cplusplus
-};
-#endif
diff --git a/src/opts/SkBlitRow_opts_SSE2.cpp b/src/opts/SkBlitRow_opts_SSE2.cpp
index 244dbb4..4f69fdd 100644
--- a/src/opts/SkBlitRow_opts_SSE2.cpp
+++ b/src/opts/SkBlitRow_opts_SSE2.cpp
@@ -2,16 +2,16 @@
  **
  ** Copyright 2009, The Android Open Source Project
  **
- ** Licensed under the Apache License, Version 2.0 (the "License"); 
- ** you may not use this file except in compliance with the License. 
- ** You may obtain a copy of the License at 
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
  **
- **     http://www.apache.org/licenses/LICENSE-2.0 
+ **     http://www.apache.org/licenses/LICENSE-2.0
  **
- ** Unless required by applicable law or agreed to in writing, software 
- ** distributed under the License is distributed on an "AS IS" BASIS, 
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- ** See the License for the specific language governing permissions and 
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
  ** limitations under the License.
  */
 
@@ -354,7 +354,7 @@ void Color32_SSE2(SkPMColor dst[], const SkPMColor src[], int count,
 
                 // Get red and blue pixels into lower byte of each word.
                 __m128i src_rb = _mm_and_si128(rb_mask, src_pixel);
-    
+
                 // Get alpha and green into lower byte of each word.
                 __m128i src_ag = _mm_srli_epi16(src_pixel, 8);
 
@@ -387,6 +387,105 @@ void Color32_SSE2(SkPMColor dst[], const SkPMColor src[], int count,
             src += 1;
             dst += 1;
             count--;
-        } 
+        }
     }
 }
+
+void SkARGB32_BlitMask_SSE2(void* device, size_t dstRB,
+                            SkBitmap::Config dstConfig, const uint8_t* mask,
+                            size_t maskRB, SkColor origColor,
+                            int width, int height)
+{
+    SkPMColor color = SkPreMultiplyColor(origColor);
+    size_t dstOffset = dstRB - (width << 2);
+    size_t maskOffset = maskRB - width;
+    SkPMColor* dst = (SkPMColor *)device;
+    do {
+        int count = width;
+        if (count >= 4) {
+            while (((size_t)dst & 0x0F) != 0 && (count > 0)) {
+                *dst = SkBlendARGB32(color, *dst, *mask);
+                mask++;
+                dst++;
+                count--;
+            }
+            __m128i *d = reinterpret_cast<__m128i*>(dst);
+            __m128i rb_mask = _mm_set1_epi32(0x00FF00FF);
+            __m128i c_256 = _mm_set1_epi16(256);
+            __m128i c_1 = _mm_set1_epi16(1);
+            __m128i src_pixel = _mm_set1_epi32(color);
+            while (count >= 4) {
+                // Load 4 pixels each of src and dest.
+                __m128i dst_pixel = _mm_load_si128(d);
+
+                //set the aphla value
+                __m128i src_scale_wide =  _mm_set_epi8(0, *(mask+3),\
+                                0, *(mask+3),0, \
+                                *(mask+2),0, *(mask+2),\
+                                0,*(mask+1), 0,*(mask+1),\
+                                0, *mask,0,*mask);
+
+                //call SkAlpha255To256()
+                src_scale_wide = _mm_add_epi16(src_scale_wide, c_1);
+
+                // Get red and blue pixels into lower byte of each word.
+                __m128i dst_rb = _mm_and_si128(rb_mask, dst_pixel);
+                __m128i src_rb = _mm_and_si128(rb_mask, src_pixel);
+
+                // Get alpha and green into lower byte of each word.
+                __m128i dst_ag = _mm_srli_epi16(dst_pixel, 8);
+                __m128i src_ag = _mm_srli_epi16(src_pixel, 8);
+
+                // Put per-pixel alpha in low byte of each word.
+                __m128i dst_alpha = _mm_shufflehi_epi16(src_ag, 0xF5);
+                dst_alpha = _mm_shufflelo_epi16(dst_alpha, 0xF5);
+
+                // dst_alpha = dst_alpha * src_scale
+                dst_alpha = _mm_mullo_epi16(dst_alpha, src_scale_wide);
+
+                // Divide by 256.
+                dst_alpha = _mm_srli_epi16(dst_alpha, 8);
+
+                // Subtract alphas from 256, to get 1..256
+                dst_alpha = _mm_sub_epi16(c_256, dst_alpha);
+                // Multiply red and blue by dst pixel alpha.
+                dst_rb = _mm_mullo_epi16(dst_rb, dst_alpha);
+                // Multiply alpha and green by dst pixel alpha.
+                dst_ag = _mm_mullo_epi16(dst_ag, dst_alpha);
+
+                // Multiply red and blue by global alpha.
+                src_rb = _mm_mullo_epi16(src_rb, src_scale_wide);
+                // Multiply alpha and green by global alpha.
+                src_ag = _mm_mullo_epi16(src_ag, src_scale_wide);
+                // Divide by 256.
+                dst_rb = _mm_srli_epi16(dst_rb, 8);
+                src_rb = _mm_srli_epi16(src_rb, 8);
+
+                // Mask out low bits (goodies already in the right place; no need to divide)
+                dst_ag = _mm_andnot_si128(rb_mask, dst_ag);
+                src_ag = _mm_andnot_si128(rb_mask, src_ag);
+
+                // Combine back into RGBA.
+                dst_pixel = _mm_or_si128(dst_rb, dst_ag);
+                __m128i tmp_src_pixel = _mm_or_si128(src_rb, src_ag);
+
+                // Add two pixels into result.
+                __m128i result = _mm_add_epi8(tmp_src_pixel, dst_pixel);
+                _mm_store_si128(d, result);
+                // load the next 4 pixel
+                mask = mask + 4;
+                d++;
+                count -= 4;
+            }
+            dst = reinterpret_cast<SkPMColor *>(d);
+        }
+        while(count > 0) {
+            *dst= SkBlendARGB32(color, *dst, *mask);
+            dst += 1;
+            mask++;
+            count --;
+        }
+        dst = (SkPMColor *)((char*)dst + dstOffset);
+        mask += maskOffset;
+    } while (--height != 0);
+}
diff --git a/src/opts/SkBlitRow_opts_SSE2.h b/src/opts/SkBlitRow_opts_SSE2.h
index c22edd8..d861bc5 100644
--- a/src/opts/SkBlitRow_opts_SSE2.h
+++ b/src/opts/SkBlitRow_opts_SSE2.h
@@ -28,3 +28,7 @@ void S32A_Opaque_BlitRow32_SSE2(SkPMColor* SK_RESTRICT dst,
 void S32A_Blend_BlitRow32_SSE2(SkPMColor* SK_RESTRICT dst,
                                const SkPMColor* SK_RESTRICT src,
                                int count, U8CPU alpha);
+void SkARGB32_BlitMask_SSE2(void* device, size_t dstRB, 
+                            SkBitmap::Config dstConfig, const uint8_t* mask,
+                            size_t maskRB, SkColor color,
+                            int width, int height);
diff --git a/src/opts/SkBlitRow_opts_arm.cpp b/src/opts/SkBlitRow_opts_arm.cpp
index 2ad7ba7..60b4d64 100644
--- a/src/opts/SkBlitRow_opts_arm.cpp
+++ b/src/opts/SkBlitRow_opts_arm.cpp
@@ -770,7 +770,7 @@ static void S32A_D565_Opaque_Dither_neon (uint16_t * SK_RESTRICT dst,
 
 	    /* calculate 'd', which will be 0..7 */
 	    /* dbase[] is 0..7; alpha is 0..256; 16 bits suffice */
-#if 1
+#if ANDROID
 	    /* SkAlpha255To256() semantic a+1 vs a+a>>7 */
 	    alpha8 = vaddw_u8(vmovl_u8(sa), vdup_n_u8(1));
 #else
@@ -1086,3 +1086,10 @@ SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
 SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
     return NULL;
 }
+
+
+SkBlitMask::Proc SkBlitMask::PlatformProcs(SkBitmap::Config dstConfig,
+                                           SkColor color)
+{
+   return NULL;
+}
diff --git a/src/opts/SkBlitRow_opts_none.cpp b/src/opts/SkBlitRow_opts_none.cpp
index 0eb1185..0fa098e 100644
--- a/src/opts/SkBlitRow_opts_none.cpp
+++ b/src/opts/SkBlitRow_opts_none.cpp
@@ -17,3 +17,10 @@ SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
 SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
     return NULL;
 }
+
+
+SkBlitMask::Proc SkBlitMask::PlatformProcs(SkBitmap::Config dstConfig,
+                                           SkColor color)
+{
+   return NULL;
+}
diff --git a/src/opts/opts_check_SSE2.cpp b/src/opts/opts_check_SSE2.cpp
index fa7b17a..749117a 100644
--- a/src/opts/opts_check_SSE2.cpp
+++ b/src/opts/opts_check_SSE2.cpp
@@ -2,16 +2,16 @@
  **
  ** Copyright 2009, The Android Open Source Project
  **
- ** Licensed under the Apache License, Version 2.0 (the "License"); 
- ** you may not use this file except in compliance with the License. 
- ** You may obtain a copy of the License at 
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
  **
- **     http://www.apache.org/licenses/LICENSE-2.0 
+ **     http://www.apache.org/licenses/LICENSE-2.0
  **
- ** Unless required by applicable law or agreed to in writing, software 
- ** distributed under the License is distributed on an "AS IS" BASIS, 
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- ** See the License for the specific language governing permissions and 
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
  ** limitations under the License.
  */
 
@@ -105,6 +105,27 @@ SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
     }
 }
 
+
+SkBlitMask::Proc SkBlitMask::PlatformProcs(SkBitmap::Config dstConfig,
+                                           SkColor color)
+{
+
+    SkBlitMask::Proc proc = NULL;
+    if (hasSSE2()) {
+        switch (dstConfig) {
+            case SkBitmap::kARGB_8888_Config:
+                // TODO: is our current SSE2 faster than the portable, even in
+                // the case of black or opaque? If so, no need for this check.
+                if ( SK_ColorBLACK != color && 0xFF != SkColorGetA(color))
+                    proc = SkARGB32_BlitMask_SSE2;
+                break;
+            default:
+                 break;
+        }
+    }
+    return proc;
+}
+
 SkMemset16Proc SkMemset16GetPlatformProc() {
     if (hasSSE2()) {
         return sk_memset16_SSE2;
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index 043f0df..5dc38b8 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -121,7 +121,7 @@ public:
     }
 
 protected:
-    virtual unsigned generateGlyphCount() const;
+    virtual unsigned generateGlyphCount();
     virtual uint16_t generateCharToGlyph(SkUnichar uni);
     virtual void generateAdvance(SkGlyph* glyph);
     virtual void generateMetrics(SkGlyph* glyph);
@@ -346,7 +346,7 @@ static bool getWidthAdvance(FT_Face face, int gId, int16_t* data) {
 // static
 SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
         uint32_t fontID, bool perGlyphInfo) {
-#ifdef ANDROID
+#if defined(SK_BUILD_FOR_MAC) || defined(ANDROID)
     return NULL;
 #else
     SkAutoMutexAcquire ac(gFTMutex);
@@ -541,6 +541,7 @@ void SkFontHost::FilterRec(SkScalerContext::Rec* rec) {
     rec->setHinting(h);
 }
 
+#ifdef ANDROID
 uint32_t SkFontHost::GetUnitsPerEm(SkFontID fontID) {
     SkAutoMutexAcquire ac(gFTMutex);
     SkFaceRec *rec = ref_ft_face(fontID);
@@ -553,6 +554,7 @@ uint32_t SkFontHost::GetUnitsPerEm(SkFontID fontID) {
 
     return (uint32_t)unitsPerEm;
 }
+#endif
 
 SkScalerContext_FreeType::SkScalerContext_FreeType(const SkDescriptor* desc)
         : SkScalerContext(desc) {
@@ -748,7 +750,7 @@ void SkScalerContext_FreeType::emboldenOutline(FT_Outline* outline) {
     FT_Outline_Embolden(outline, strength);
 }
 
-unsigned SkScalerContext_FreeType::generateGlyphCount() const {
+unsigned SkScalerContext_FreeType::generateGlyphCount() {
     return fFace->num_glyphs;
 }
 
diff --git a/src/ports/SkFontHost_ascender.cpp b/src/ports/SkFontHost_ascender.cpp
index 88cde38..6f5cf0b 100644
--- a/src/ports/SkFontHost_ascender.cpp
+++ b/src/ports/SkFontHost_ascender.cpp
@@ -22,7 +22,7 @@ public:
     virtual ~SkScalerContext_Ascender();
 
 protected:
-    virtual unsigned generateGlyphCount() const;
+    virtual unsigned generateGlyphCount();
     virtual uint16_t generateCharToGlyph(SkUnichar uni);
     virtual void generateMetrics(SkGlyph* glyph);
     virtual void generateImage(const SkGlyph& glyph);
@@ -102,7 +102,7 @@ SkScalerContext_Ascender::~SkScalerContext_Ascender()
     sk_free(fHandle);
 }
 
-unsigned SkScalerContext_Ascender::generateGlyphCount() const
+unsigned SkScalerContext_Ascender::generateGlyphCount()
 {
     return 1000;
 }
diff --git a/src/ports/SkFontHost_mac_atsui.cpp b/src/ports/SkFontHost_mac_atsui.cpp
index 5183730..1d40a42 100644
--- a/src/ports/SkFontHost_mac_atsui.cpp
+++ b/src/ports/SkFontHost_mac_atsui.cpp
@@ -87,7 +87,7 @@ public:
     virtual ~SkScalerContext_Mac();
 
 protected:
-    virtual unsigned generateGlyphCount() const;
+    virtual unsigned generateGlyphCount();
     virtual uint16_t generateCharToGlyph(SkUnichar uni);
     virtual void generateAdvance(SkGlyph* glyph);
     virtual void generateMetrics(SkGlyph* glyph);
@@ -184,7 +184,7 @@ SkScalerContext_Mac::~SkScalerContext_Mac() {
 
 // man, we need to consider caching this, since it is just dependent on
 // fFontID, and not on any of the other settings like matrix or flags
-unsigned SkScalerContext_Mac::generateGlyphCount() const {
+unsigned SkScalerContext_Mac::generateGlyphCount() {
     // The 'maxp' table stores the number of glyphs a offset 4, in 2 bytes
     uint16_t numGlyphs;
     if (SkFontHost::GetTableData(fRec.fFontID,
diff --git a/src/ports/SkFontHost_mac_coretext.cpp b/src/ports/SkFontHost_mac_coretext.cpp
index 4b5c36d..ae39361 100644
--- a/src/ports/SkFontHost_mac_coretext.cpp
+++ b/src/ports/SkFontHost_mac_coretext.cpp
@@ -1,16 +1,16 @@
 /*
  ** Copyright 2006, The Android Open Source Project
  **
- ** Licensed under the Apache License, Version 2.0 (the "License"); 
- ** you may not use this file except in compliance with the License. 
- ** You may obtain a copy of the License at 
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
  **
- **     http://www.apache.org/licenses/LICENSE-2.0 
+ **     http://www.apache.org/licenses/LICENSE-2.0
  **
- ** Unless required by applicable law or agreed to in writing, software 
- ** distributed under the License is distributed on an "AS IS" BASIS, 
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
- ** See the License for the specific language governing permissions and 
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
  ** limitations under the License.
 */
 #include <vector>
@@ -21,7 +21,7 @@
 #include "SkString.h"
 #include "SkPaint.h"
 #include "SkFloatingPoint.h"
-
+#include "SkUtils.h"
 
 
 
@@ -88,13 +88,13 @@ public:
 
     // Is a font ID valid?
     bool                                IsValid(SkFontID fontID);
-    
-    
+
+
     // Get a font
     CTFontRef                           GetFont(SkFontID fontID);
     SkNativeFontInfo                    GetFontInfo(const SkString &theName, SkTypeface::Style theStyle);
-    
-    
+
+
     // Create a font
     SkNativeFontInfo                    CreateFont(const SkString &theName, SkTypeface::Style theStyle);
 
@@ -132,7 +132,7 @@ SkNativeFontCache::SkNativeFontCache(void)
     fontInfo.style   = SkTypeface::kNormal;
     fontInfo.fontID  = kSkInvalidFontID;
     fontInfo.fontRef = NULL;
-        
+
     mFonts.push_back(fontInfo);
 }
 
@@ -190,7 +190,7 @@ SkNativeFontInfo SkNativeFontCache::GetFontInfo(const SkString &theName, SkTypef
         if (theIter->name == theName && theIter->style == theStyle)
             return(*theIter);
         }
-    
+
     return(fontInfo);
 }
 
@@ -314,7 +314,7 @@ public:
 
 
 protected:
-    unsigned                            generateGlyphCount(void) const;
+    unsigned                            generateGlyphCount(void);
     uint16_t                            generateCharToGlyph(SkUnichar uni);
     void                                generateAdvance(SkGlyph* glyph);
     void                                generateMetrics(SkGlyph* glyph);
@@ -328,7 +328,8 @@ private:
 
 
 private:
-    CGColorSpaceRef                     mColorSpace;
+    CGColorSpaceRef                     mColorSpaceGray;
+    CGColorSpaceRef                     mColorSpaceRGB;
     CGAffineTransform                   mTransform;
 
     CTFontRef                           mFont;
@@ -352,7 +353,11 @@ SkScalerContext_Mac::SkScalerContext_Mac(const SkDescriptor* desc)
 
 
     // Initialise ourselves
-    mColorSpace = CGColorSpaceCreateDeviceGray();
+//    mColorSpaceRGB = CGColorSpaceCreateDeviceRGB();
+//    mColorSpaceRGB = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
+    mColorSpaceRGB = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGBLinear);
+    mColorSpaceGray = CGColorSpaceCreateDeviceGray();
+
     const float inv = 1.0f / FONT_CANONICAL_POINTSIZE;
     mTransform  = CGAffineTransformMake(SkScalarToFloat(skMatrix[SkMatrix::kMScaleX]) * inv,
                                         -SkScalarToFloat(skMatrix[SkMatrix::kMSkewY]) * inv,
@@ -369,11 +374,12 @@ SkScalerContext_Mac::~SkScalerContext_Mac(void)
 {
 
     // Clean up
-    CFSafeRelease(mColorSpace);
+    CFSafeRelease(mColorSpaceGray);
+    CFSafeRelease(mColorSpaceRGB);
     CFSafeRelease(mFont);
 }
 
-unsigned SkScalerContext_Mac::generateGlyphCount(void) const
+unsigned SkScalerContext_Mac::generateGlyphCount(void)
 {
     return(mGlyphCount);
 }
@@ -437,8 +443,27 @@ void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph)
     glyph->fLeft     =  sk_float_round2int(CGRectGetMinX(theBounds));
 }
 
-void SkScalerContext_Mac::generateImage(const SkGlyph& glyph)
-{   CGContextRef        cgContext;
+#include "SkColorPriv.h"
+
+static inline uint16_t rgb_to_lcd16(uint32_t rgb) {
+    int r = (rgb >> 16) & 0xFF;
+    int g = (rgb >>  8) & 0xFF;
+    int b = (rgb >>  0) & 0xFF;
+
+    // invert, since we draw black-on-white, but we want the original
+    // src mask values.
+    r = 255 - r;
+    g = 255 - g;
+    b = 255 - b;
+
+    return SkPackRGB16(SkR32ToR16(r), SkG32ToG16(g), SkB32ToB16(b));
+}
+
+#define BITMAP_INFO_RGB     (kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host)
+#define BITMAP_INFO_GRAY    (kCGImageAlphaNone)
+
+void SkScalerContext_Mac::generateImage(const SkGlyph& glyph) {
+    CGContextRef        cgContext;
     CGGlyph             cgGlyph;
     CGFontRef           cgFont;
 
@@ -447,17 +472,61 @@ void SkScalerContext_Mac::generateImage(const SkGlyph& glyph)
 
     cgGlyph   = (CGGlyph) glyph.getGlyphID(fBaseGlyphCount);
     cgFont    = CTFontCopyGraphicsFont(mFont, NULL);
-    cgContext = CGBitmapContextCreate(  glyph.fImage, glyph.fWidth, glyph.fHeight, 8,
-                                        glyph.rowBytes(), mColorSpace, kCGImageAlphaNone);
+
+    SkAutoSMalloc<1024> storage;
+
+    CGColorSpaceRef colorspace = mColorSpaceGray;
+    uint32_t info = BITMAP_INFO_GRAY;
+    void* image = glyph.fImage;
+    size_t rowBytes = glyph.rowBytes();
+    float grayColor = 1; // white
+
+    /*  For LCD16, we first create a temp offscreen cg-context in 32bit,
+     *  erase to white, and then draw a black glyph into it. Then we can
+     *  extract the r,g,b values, invert-them, and now we have the original
+     *  src mask components, which we pack into our 16bit mask.
+     */
+    if (SkMask::kLCD16_Format == glyph.fMaskFormat) {
+        colorspace = mColorSpaceRGB;
+        info = BITMAP_INFO_RGB;
+        // need tmp storage for 32bit RGB offscreen
+        rowBytes = glyph.fWidth << 2;
+        size_t size = glyph.fHeight * rowBytes;
+        image = storage.realloc(size);
+        // we draw black-on-white (and invert in rgb_to_lcd16)
+        sk_memset32((uint32_t*)image, 0xFFFFFFFF, size >> 2);
+        grayColor = 0;  // black
+    }
+
+    cgContext = CGBitmapContextCreate(image, glyph.fWidth, glyph.fHeight, 8,
+                                      rowBytes, colorspace, info);
 
     // Draw the glyph
     if (cgFont != NULL && cgContext != NULL) {
-        CGContextSetGrayFillColor(  cgContext, 1.0, 1.0);
+        CGContextSetAllowsFontSubpixelQuantization(cgContext, true);
+        CGContextSetShouldSubpixelQuantizeFonts(cgContext, true);
+
+        CGContextSetGrayFillColor(  cgContext, grayColor, 1.0);
         CGContextSetTextDrawingMode(cgContext, kCGTextFill);
         CGContextSetFont(           cgContext, cgFont);
         CGContextSetFontSize(       cgContext, FONT_CANONICAL_POINTSIZE);
         CGContextSetTextMatrix(     cgContext, mTransform);
         CGContextShowGlyphsAtPoint( cgContext, -glyph.fLeft, glyph.fTop + glyph.fHeight, &cgGlyph, 1);
+
+        if (SkMask::kLCD16_Format == glyph.fMaskFormat) {
+            // downsample from rgba to rgb565
+            int width = glyph.fWidth;
+            const uint32_t* src = (const uint32_t*)image;
+            uint16_t* dst = (uint16_t*)glyph.fImage;
+            size_t dstRB = glyph.rowBytes();
+            for (int y = 0; y < glyph.fHeight; y++) {
+                for (int i = 0; i < width; i++) {
+                    dst[i] = rgb_to_lcd16(src[i]);
+                }
+                src = (const uint32_t*)((const char*)src + rowBytes);
+                dst = (uint16_t*)((char*)dst + dstRB);
+            }
+        }
     }
 
     // Clean up
@@ -539,7 +608,7 @@ void SkScalerContext_Mac::CTPathElement(void *info, const CGPathElement *element
         case kCGPathElementCloseSubpath:
             skPath->close();
             break;
-        
+
         default:
             SkASSERT("Unknown path element!");
             break;
@@ -783,7 +852,7 @@ size_t SkFontHost::GetTableSize(SkFontID fontID, SkFontTableTag tag)
         theSize = CFDataGetLength(cfData);
         CFSafeRelease(cfData);
         }
-    
+
     return(theSize);
 }
 
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index c2055aa..a20f001 100644
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -17,11 +17,13 @@
 #include "SkString.h"

 //#include "SkStream.h"

 

+#include "SkEndian.h"

 #include "SkFontHost.h"

 #include "SkDescriptor.h"

 #include "SkAdvancedTypefaceMetrics.h"

 #include "SkStream.h"

 #include "SkThread.h"

+#include "SkTypeface_win.h"

 #include "SkUtils.h"

 

 #ifdef WIN32

@@ -42,6 +44,18 @@ static uint8_t glyphbuf[BUFFERSIZE];
 // Give 1MB font cache budget

 #define FONT_CACHE_MEMORY_BUDGET    (1024 * 1024)

 

+/**

+ *	Since LOGFONT wants its textsize as an int, and we support fractional sizes,

+ *  and since we have a cache of LOGFONTs for our tyepfaces, we always set the

+ *  lfHeight to a canonical size, and then we use the 2x2 matrix to achieve the

+ *  actual requested size.

+ */

+static const int gCanonicalTextSize = 64;

+

+static void make_canonical(LOGFONT* lf) {

+	lf->lfHeight = -gCanonicalTextSize;

+}

+

 static inline FIXED SkFixedToFIXED(SkFixed x) {

     return *(FIXED*)(&x);

 }

@@ -50,6 +64,32 @@ static inline FIXED SkScalarToFIXED(SkScalar x) {
     return SkFixedToFIXED(SkScalarToFixed(x));

 }

 

+static unsigned calculateGlyphCount(HDC hdc) {

+    // The 'maxp' table stores the number of glyphs at offset 4, in 2 bytes.

+    const DWORD maxpTag = *(DWORD*) "maxp";

+    uint16_t glyphs;

+    if (GetFontData(hdc, maxpTag, 4, &glyphs, sizeof(glyphs)) != GDI_ERROR) {

+        return SkEndian_SwapBE16(glyphs);

+    }

+    

+    // Binary search for glyph count.

+    static const MAT2 mat2 = {{0, 1}, {0, 0}, {0, 0}, {0, 1}};

+    int32_t max = SK_MaxU16 + 1;

+    int32_t min = 0;

+    GLYPHMETRICS gm;

+    while (min < max) {

+        int32_t mid = min + ((max - min) / 2);

+        if (GetGlyphOutlineW(hdc, mid, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0,

+                             NULL, &mat2) == GDI_ERROR) {

+            max = mid;

+        } else {

+            min = mid + 1;

+        }

+    }

+    SkASSERT(min == max);

+    return min;

+}

+

 static SkTypeface::Style GetFontStyle(const LOGFONT& lf) {

     int style = SkTypeface::kNormal;

     if (lf.lfWeight == FW_SEMIBOLD || lf.lfWeight == FW_DEMIBOLD || lf.lfWeight == FW_BOLD)

@@ -72,15 +112,17 @@ private:
 

 public:

 

-    LogFontTypeface(Style style, const LOGFONT& logFont) : 

+    LogFontTypeface(Style style, const LOGFONT& logFont) :

       SkTypeface(style, sk_atomic_inc(&gCurrId)+1), // 0 id is reserved so add 1

       fLogFont(logFont)

     {

+		make_canonical(&fLogFont);

+

         SkAutoMutexAcquire am(gMutex);

         fNext = gHead;

         gHead = this;

     }

-    

+

     const LOGFONT& logFont() const { return fLogFont; }

 

     virtual ~LogFontTypeface() {

@@ -108,11 +150,14 @@ public:
         }

         return curr;

     }

-   

+

     static LogFontTypeface* FindByLogFont(const LOGFONT& lf)

     {

+		LOGFONT canonical = lf;

+		make_canonical(&canonical);

+

         LogFontTypeface* curr = gHead;

-        while (curr && memcmp(&curr->fLogFont, &lf, sizeof(LOGFONT))) {

+        while (curr && memcmp(&curr->fLogFont, &canonical, sizeof(LOGFONT))) {

             curr = curr->fNext;

         }

         return curr;

@@ -145,16 +190,15 @@ static const LOGFONT& get_default_font() {
     return gDefaultFont;

 }

 

-static SkTypeface* CreateTypeface_(const LOGFONT& lf) {

-       

+SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT& lf) {

     LogFontTypeface* ptypeface = LogFontTypeface::FindByLogFont(lf);

-    

+

     if (NULL == ptypeface) {

         SkTypeface::Style style = GetFontStyle(lf);

         ptypeface = new LogFontTypeface(style, lf);

     } else {

-        ptypeface->ref();

-    }

+	    ptypeface->ref();

+	}

     return ptypeface;

 }

 

@@ -171,63 +215,64 @@ public:
     virtual ~SkScalerContext_Windows();

 

 protected:

-    virtual unsigned generateGlyphCount() const;

+    virtual unsigned generateGlyphCount();

     virtual uint16_t generateCharToGlyph(SkUnichar uni);

     virtual void generateAdvance(SkGlyph* glyph);

     virtual void generateMetrics(SkGlyph* glyph);

     virtual void generateImage(const SkGlyph& glyph);

     virtual void generatePath(const SkGlyph& glyph, SkPath* path);

-    virtual void generateLineHeight(SkPoint* ascent, SkPoint* descent);

     virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);

     //virtual SkDeviceContext getDC() {return ddc;}

 private:

-    LOGFONT      lf;

-    MAT2         mat22;

-    HDC          ddc;

-    HFONT        savefont;

-    HFONT        font;

-    SCRIPT_CACHE sc;

+	SkScalar	 fScale;	// to get from canonical size to real size

+    MAT2         fMat22;

+    HDC          fDDC;

+    HFONT        fSavefont;

+    HFONT        fFont;

+    SCRIPT_CACHE fSC;

+    int          fGlyphCount;

 };

 

 SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc)

-        : SkScalerContext(desc), ddc(0), font(0), savefont(0), sc(0) {

+        : SkScalerContext(desc), fDDC(0), fFont(0), fSavefont(0), fSC(0)

+        , fGlyphCount(-1) {

     SkAutoMutexAcquire  ac(gFTMutex);

 

-    lf = LogFontTypeface::FindById(fRec.fFontID)->logFont();

+	fScale = fRec.fTextSize / gCanonicalTextSize;

+    fMat22.eM11 = SkScalarToFIXED(SkScalarMul(fScale, fRec.fPost2x2[0][0]));

+    fMat22.eM12 = SkScalarToFIXED(SkScalarMul(fScale, -fRec.fPost2x2[0][1]));

+    fMat22.eM21 = SkScalarToFIXED(SkScalarMul(fScale, fRec.fPost2x2[1][0]));

+    fMat22.eM22 = SkScalarToFIXED(SkScalarMul(fScale, -fRec.fPost2x2[1][1]));

 

-    mat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);

-    mat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);

-    mat22.eM21 = SkScalarToFIXED(fRec.fPost2x2[1][0]);

-    mat22.eM22 = SkScalarToFIXED(-fRec.fPost2x2[1][1]);

-

-    ddc = ::CreateCompatibleDC(NULL);

-    SetBkMode(ddc, TRANSPARENT);

+    fDDC = ::CreateCompatibleDC(NULL);

+    SetBkMode(fDDC, TRANSPARENT);

 

     // Scaling by the DPI is inconsistent with how Skia draws elsewhere

     //SkScalar height = -(fRec.fTextSize * GetDeviceCaps(ddc, LOGPIXELSY) / 72);

-    SkScalar height = -fRec.fTextSize;

-    lf.lfHeight = SkScalarRound(height);

-    font = CreateFontIndirect(&lf);

-    savefont = (HFONT)SelectObject(ddc, font);

+    LOGFONT lf = LogFontTypeface::FindById(fRec.fFontID)->logFont();

+    lf.lfHeight = -gCanonicalTextSize;

+    fFont = CreateFontIndirect(&lf);

+    fSavefont = (HFONT)SelectObject(fDDC, fFont);

 }

 

 SkScalerContext_Windows::~SkScalerContext_Windows() {

-    if (ddc) {

-        ::SelectObject(ddc, savefont);

-        ::DeleteDC(ddc);

-        ddc = NULL;

+    if (fDDC) {

+        ::SelectObject(fDDC, fSavefont);

+        ::DeleteDC(fDDC);

     }

-    if (font) {

-        ::DeleteObject(font);

+    if (fFont) {

+        ::DeleteObject(fFont);

     }

-    if (sc) {

-        ::ScriptFreeCache(&sc);

+    if (fSC) {

+        ::ScriptFreeCache(&fSC);

     }

 }

 

-unsigned SkScalerContext_Windows::generateGlyphCount() const {

-    return 0xFFFF;

-    //    return fFace->num_glyphs;

+unsigned SkScalerContext_Windows::generateGlyphCount() {

+    if (fGlyphCount < 0) {

+        fGlyphCount = calculateGlyphCount(fDDC);

+    }

+    return fGlyphCount;

 }

 

 uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {

@@ -236,7 +281,7 @@ uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {
     // TODO(ctguil): Support characters that generate more than one glyph.

     if (SkUTF16_FromUnichar(uni, (uint16_t*)c) == 1) {

         // Type1 fonts fail with uniscribe API. Use GetGlyphIndices for plane 0.

-        SkAssertResult(GetGlyphIndicesW(ddc, c, 1, &index, 0));

+        SkAssertResult(GetGlyphIndicesW(fDDC, c, 1, &index, 0));

     } else {

         // Use uniscribe to detemine glyph index for non-BMP characters.

         // Need to add extra item to SCRIPT_ITEM to work around a bug in older

@@ -250,7 +295,7 @@ uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {
         SCRIPT_VISATTR vsa;

         int glyphs;

         SkAssertResult(SUCCEEDED(ScriptShape(

-            ddc, &sc, c, 2, 1, &si[0].a, &index, log, &vsa, &glyphs)));

+            fDDC, &fSC, c, 2, 1, &si[0].a, &index, log, &vsa, &glyphs)));

     }

     return index;

 }

@@ -261,7 +306,7 @@ void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {
 

 void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {

 

-    SkASSERT(ddc);

+    SkASSERT(fDDC);

 

     GLYPHMETRICS gm;

     memset(&gm, 0, sizeof(gm));

@@ -271,7 +316,7 @@ void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
 

     // Note: need to use GGO_GRAY8_BITMAP instead of GGO_METRICS because GGO_METRICS returns a smaller

     // BlackBlox; we need the bigger one in case we need the image.  fAdvance is the same.

-    uint32_t ret = GetGlyphOutlineW(ddc, glyph->getGlyphID(0), GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, 0, NULL, &mat22);

+    uint32_t ret = GetGlyphOutlineW(fDDC, glyph->getGlyphID(0), GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);

 

     if (GDI_ERROR != ret) {

         if (ret == 0) {

@@ -301,31 +346,31 @@ void SkScalerContext_Windows::generateFontMetrics(SkPaint::FontMetrics* mx, SkPa
     if (!(mx || my))

       return;

 

-    SkASSERT(ddc);

+    SkASSERT(fDDC);

 

     OUTLINETEXTMETRIC otm;

 

-    uint32_t ret = GetOutlineTextMetrics(ddc, sizeof(otm), &otm);

+    uint32_t ret = GetOutlineTextMetrics(fDDC, sizeof(otm), &otm);

     if (sizeof(otm) != ret) {

       return;

     }

 

     if (mx) {

-      mx->fTop = -SkIntToScalar(otm.otmTextMetrics.tmAscent);  // Actually a long.

-      mx->fAscent = -SkIntToScalar(otm.otmAscent);

-      mx->fDescent = -SkIntToScalar(otm.otmDescent);

-      mx->fBottom = SkIntToScalar(otm.otmTextMetrics.tmDescent);  // Long

-      mx->fLeading = SkIntToScalar(otm.otmTextMetrics.tmInternalLeading

-          + otm.otmTextMetrics.tmExternalLeading);  // Long

+        mx->fTop = -fScale * otm.otmTextMetrics.tmAscent;

+		mx->fAscent = -fScale * otm.otmAscent;

+		mx->fDescent = -fScale * otm.otmDescent;

+		mx->fBottom = fScale * otm.otmTextMetrics.tmDescent;

+		mx->fLeading = fScale * (otm.otmTextMetrics.tmInternalLeading

+								 + otm.otmTextMetrics.tmExternalLeading);

     }

 

     if (my) {

-      my->fTop = -SkIntToScalar(otm.otmTextMetrics.tmAscent);  // Actually a long.

-      my->fAscent = -SkIntToScalar(otm.otmAscent);

-      my->fDescent = -SkIntToScalar(otm.otmDescent);

-      my->fBottom = SkIntToScalar(otm.otmTextMetrics.tmDescent);  // Long

-      my->fLeading = SkIntToScalar(otm.otmTextMetrics.tmInternalLeading

-          + otm.otmTextMetrics.tmExternalLeading);  // Long

+		my->fTop = -fScale * otm.otmTextMetrics.tmAscent;

+		my->fAscent = -fScale * otm.otmAscent;

+		my->fDescent = -fScale * otm.otmDescent;

+		my->fBottom = fScale * otm.otmTextMetrics.tmDescent;

+		my->fLeading = fScale * (otm.otmTextMetrics.tmInternalLeading

+								 + otm.otmTextMetrics.tmExternalLeading);

     }

 }

 

@@ -333,7 +378,7 @@ void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
 

     SkAutoMutexAcquire  ac(gFTMutex);

 

-    SkASSERT(ddc);

+    SkASSERT(fDDC);

 

     GLYPHMETRICS gm;

     memset(&gm, 0, sizeof(gm));

@@ -345,11 +390,11 @@ void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
 #endif

 

     uint32_t bytecount = 0;

-    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, 0, NULL, &mat22);

+    uint32_t total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, 0, NULL, &fMat22);

     if (GDI_ERROR != total_size && total_size > 0) {

         uint8_t *pBuff = new uint8_t[total_size];

         if (NULL != pBuff) {

-            total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, total_size, pBuff, &mat22);

+            total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_GRAY8_BITMAP | GGO_GLYPH_INDEX, &gm, total_size, pBuff, &fMat22);

 

             SkASSERT(total_size != GDI_ERROR);

 

@@ -393,7 +438,7 @@ void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
     SkAutoMutexAcquire  ac(gFTMutex);

 

     SkASSERT(&glyph && path);

-    SkASSERT(ddc);

+    SkASSERT(fDDC);

 

     path->reset();

 

@@ -404,7 +449,7 @@ void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
 #endif

 

     GLYPHMETRICS gm;

-    uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &mat22);

+    uint32_t total_size = GetGlyphOutlineW(fDDC, glyph.fID, GGO_NATIVE | GGO_GLYPH_INDEX, &gm, BUFFERSIZE, glyphbuf, &fMat22);

 

     if (GDI_ERROR != total_size) {

 

@@ -455,26 +500,6 @@ void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
     //OutputDebugString(buf);

 }

 

-

-// Note:  not sure this is the correct implementation

-void SkScalerContext_Windows::generateLineHeight(SkPoint* ascent, SkPoint* descent) {

-

-    SkASSERT(ddc);

-

-    OUTLINETEXTMETRIC otm;

-

-    uint32_t ret = GetOutlineTextMetrics(ddc, sizeof(otm), &otm);

-

-    if (sizeof(otm) == ret) {

-        if (ascent)

-            ascent->iset(0, otm.otmAscent);

-        if (descent)

-            descent->iset(0, otm.otmDescent);

-    }

-

-    return;

-}

-

 void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {

     SkASSERT(!"SkFontHost::Serialize unimplemented");

 }

@@ -524,8 +549,13 @@ SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
     if (!GetOutlineTextMetrics(hdc, sizeof(otm), &otm)) {

         goto Error;

     }

+    const unsigned glyphCount = calculateGlyphCount(hdc);

 

     info = new SkAdvancedTypefaceMetrics;

+    info->fEmSize = otm.otmEMSquare;

+    info->fMultiMaster = false;

+    info->fLastGlyphID = SkToU16(glyphCount - 1);

+    info->fStyle = 0;

 #ifdef UNICODE

     // Get the buffer size needed first.

     size_t str_len = WideCharToMultiByte(CP_UTF8, 0, lf.lfFaceName, -1, NULL,

@@ -545,12 +575,15 @@ SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
         info->fType = SkAdvancedTypefaceMetrics::kTrueType_Font;

     } else {

         info->fType = SkAdvancedTypefaceMetrics::kOther_Font;

+        info->fItalicAngle = 0;

+        info->fAscent = 0;

+        info->fDescent = 0;

+        info->fStemV = 0;

+        info->fCapHeight = 0;

+        info->fBBox = SkIRect::MakeEmpty();

+        return info;

     }

-    info->fEmSize = otm.otmEMSquare;

-    info->fMultiMaster = false;

-    info->fLastGlyphID = 0;

-

-    info->fStyle = 0;

+    

     // If this bit is clear the font is a fixed pitch font.

     if (!(otm.otmTextMetrics.tmPitchAndFamily & TMPF_FIXED_PITCH)) {

         info->fStyle |= SkAdvancedTypefaceMetrics::kFixedPitch_Style;

@@ -602,16 +635,7 @@ SkAdvancedTypefaceMetrics* SkFontHost::GetAdvancedTypefaceMetrics(
         info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;

     } else if (perGlyphInfo) {

         info->fGlyphWidths.reset(

-            getAdvanceData(hdc, SHRT_MAX, &getWidthAdvance));

-

-        // Obtain the last glyph index.

-        SkAdvancedTypefaceMetrics::WidthRange* last = info->fGlyphWidths.get();

-        if (last) {

-            while (last->fNext.get()) {

-                last = last->fNext.get();

-            }

-            info->fLastGlyphID = last->fEndId;

-        }

+            getAdvanceData(hdc, glyphCount, &getWidthAdvance));

     }

 

 Error:

@@ -626,8 +650,8 @@ Error:
 SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {

 

     //Should not be used on Windows, keep linker happy

-    SkASSERT(false);    

-    return CreateTypeface_(get_default_font());

+    SkASSERT(false);

+    return SkCreateTypefaceFromLOGFONT(get_default_font());

 }

 

 SkStream* SkFontHost::OpenStream(SkFontID uniqueID) {

@@ -689,12 +713,12 @@ SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
         // hack until we figure out if SkTypeface should cache this itself

         if (style == SkTypeface::kNormal) {

             if (NULL == gDefaultTypeface) {

-                gDefaultTypeface = CreateTypeface_(lf);

+                gDefaultTypeface = SkCreateTypefaceFromLOGFONT(lf);

             }

             tf = gDefaultTypeface;

             tf->ref();

         } else {

-            tf = CreateTypeface_(lf);

+            tf = SkCreateTypefaceFromLOGFONT(lf);

         }

     } else {

 #ifdef CAN_USE_LOGFONT_NAME

@@ -738,12 +762,12 @@ SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
         // use the style desired

         lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;

         lf.lfItalic = ((style & SkTypeface::kItalic) != 0);

-        tf = CreateTypeface_(lf);

+        tf = SkCreateTypefaceFromLOGFONT(lf);

 #endif

     }

 

-    if (NULL == tf) {        

-        tf = CreateTypeface_(get_default_font());

+    if (NULL == tf) {

+        tf = SkCreateTypefaceFromLOGFONT(get_default_font());

     }

     return tf;

 }

diff --git a/src/utils/SkCamera.cpp b/src/utils/SkCamera.cpp
index c70c4c0..87d2aad 100644
--- a/src/utils/SkCamera.cpp
+++ b/src/utils/SkCamera.cpp
@@ -400,6 +400,7 @@ void Sk3DView::restore()
     fRec = next;
 }
 
+#ifdef ANDROID
 void Sk3DView::setCameraLocation(SkScalar x, SkScalar y, SkScalar z)
 {
     // the camera location is passed in inches, set in pt
@@ -409,6 +410,7 @@ void Sk3DView::setCameraLocation(SkScalar x, SkScalar y, SkScalar z)
     fCamera.update();
     
 }
+#endif
 
 void Sk3DView::translate(SkScalar x, SkScalar y, SkScalar z)
 {
diff --git a/src/utils/SkCullPoints.cpp b/src/utils/SkCullPoints.cpp
index 03bfa99..c8d58c1 100644
--- a/src/utils/SkCullPoints.cpp
+++ b/src/utils/SkCullPoints.cpp
@@ -27,7 +27,7 @@ static bool cross_product_is_neg(const SkIPoint& v, int dx, int dy) {
     tmp0.setMul(v.fX, dy);
     tmp1.setMul(dx, v.fY);
     tmp0.sub(tmp1);
-    return tmp0.isNeg();
+    return tmp0.isNeg() != 0;
 #endif
 }
 
diff --git a/src/utils/SkParsePath.cpp b/src/utils/SkParsePath.cpp
index 6b3afca..e08e84c 100644
--- a/src/utils/SkParsePath.cpp
+++ b/src/utils/SkParsePath.cpp
@@ -184,7 +184,7 @@ static void write_scalar(SkWStream* stream, SkScalar value) {
 #ifdef SK_SCALAR_IS_FLOAT
     char buffer[64];
 #ifdef SK_BUILD_FOR_WIN32
-	int len = sprintf(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/views/SkBGViewArtist.cpp b/src/views/SkBGViewArtist.cpp
deleted file mode 100644
index 07da123..0000000
--- a/src/views/SkBGViewArtist.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "SkBGViewArtist.h"
-#include "SkCanvas.h"
-#include "SkParsePaint.h"
-
-SkBGViewArtist::SkBGViewArtist(SkColor c)
-{
-	fPaint.setColor(c);
-}
-
-SkBGViewArtist::~SkBGViewArtist()
-{
-}
-
-void SkBGViewArtist::onDraw(SkView*, SkCanvas* canvas)
-{
-	// 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);
-}
-
diff --git a/src/views/SkBorderView.cpp b/src/views/SkBorderView.cpp
deleted file mode 100644
index 3a9c449..0000000
--- a/src/views/SkBorderView.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "SkBorderView.h"
-#include "SkAnimator.h"
-#include "SkWidgetViews.h"
-#include "SkSystemEventTypes.h"
-#include "SkTime.h"
-#include "SkStackViewLayout.h"
-
-SkBorderView::SkBorderView() : fTop(SkIntToScalar(0)), fLeft(SkIntToScalar(0)),
-					fRight(SkIntToScalar(0)), fBottom(SkIntToScalar(0))
-{
-	fAnim.setHostEventSink(this);
-	init_skin_anim(kBorder_SkinEnum, &fAnim);
-}
-
-SkBorderView::~SkBorderView()
-{
-	
-}
-
-void SkBorderView::setSkin(const char skin[])
-{
-	init_skin_anim(skin, &fAnim);
-}
-
-/* virtual */ void SkBorderView::onInflate(const SkDOM& dom, const SkDOM::Node* 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);
-}
-
-/*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);
-	}
-}
-
-/*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);
-}
diff --git a/src/views/SkEvent.cpp b/src/views/SkEvent.cpp
deleted file mode 100644
index ec4a7b4..0000000
--- a/src/views/SkEvent.cpp
+++ /dev/null
@@ -1,580 +0,0 @@
-/* libs/graphics/views/SkEvent.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkEvent.h"
-
-void SkEvent::initialize(const char* type, size_t typeLen) {
-    fType = NULL;
-    setType(type, typeLen);
-    f32 = 0;
-#ifdef SK_DEBUG
-    fTargetID = 0;
-    fTime = 0;
-    fNextEvent = NULL;
-#endif
-    SkDEBUGCODE(fDebugTrace = false;)
-}
-
-SkEvent::SkEvent()
-{
-    initialize("", 0);
-}
-
-SkEvent::SkEvent(const SkEvent& src)
-{
-    *this = src;
-    if (((size_t) fType & 1) == 0)
-        setType(src.fType);
-}
-
-SkEvent::SkEvent(const SkString& type)
-{
-    initialize(type.c_str(), type.size());
-}
-
-SkEvent::SkEvent(const char type[])
-{
-    SkASSERT(type);
-    initialize(type, strlen(type));
-}
-
-SkEvent::~SkEvent()
-{
-    if (((size_t) fType & 1) == 0)
-        sk_free((void*) fType);
-}
-
-static size_t makeCharArray(char* buffer, size_t compact)
-{
-    size_t bits = (size_t) compact >> 1;
-    memcpy(buffer, &bits, sizeof(compact));
-    buffer[sizeof(compact)] = 0;
-    return strlen(buffer);
-}
-
-#if 0
-const char* SkEvent::getType() const 
-{ 
-    if ((size_t) fType & 1) {   // not a pointer
-        char chars[sizeof(size_t) + 1];
-        size_t len = makeCharArray(chars, (size_t) fType);
-        fType = (char*) sk_malloc_throw(len);
-        SkASSERT(((size_t) fType & 1) == 0);
-        memcpy(fType, chars, len);
-    }
-    return fType; 
-}
-#endif
-
-void SkEvent::getType(SkString* str) const 
-{ 
-    if (str) 
-    {
-        if ((size_t) fType & 1) // not a pointer
-        {
-            char chars[sizeof(size_t) + 1];
-            size_t len = makeCharArray(chars, (size_t) fType);
-            str->set(chars, len);
-        }
-        else
-            str->set(fType);
-    }
-}
-
-bool SkEvent::isType(const SkString& str) const 
-{
-    return this->isType(str.c_str(), str.size()); 
-}
-
-bool SkEvent::isType(const char type[], size_t typeLen) const 
-{ 
-    if (typeLen == 0)
-        typeLen = strlen(type);
-    if ((size_t) fType & 1) {   // not a pointer
-        char chars[sizeof(size_t) + 1];
-        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; 
-}
-
-void SkEvent::setType(const char type[], size_t typeLen)
-{
-    if (typeLen == 0)
-        typeLen = strlen(type);
-    if (typeLen <= sizeof(fType)) {
-        size_t slot = 0;
-        memcpy(&slot, type, typeLen);
-        if (slot << 1 >> 1 != slot)
-            goto useCharStar;
-        slot <<= 1;
-        slot |= 1;
-        fType = (char*) slot;
-    } else {
-useCharStar:
-        fType = (char*) sk_malloc_throw(typeLen + 1);
-        SkASSERT(((size_t) fType & 1) == 0);
-        memcpy(fType, type, typeLen);
-        fType[typeLen] = 0;
-    }
-}
-
-void SkEvent::setType(const SkString& type)
-{
-    setType(type.c_str());
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-#include "SkParse.h"
-
-void SkEvent::inflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-    const char* name = dom.findAttr(node, "type");
-    if (name)
-        this->setType(name);
-
-    const char* value;
-    if ((value = dom.findAttr(node, "fast32")) != NULL)
-    {
-        int32_t n;
-        if (SkParse::FindS32(value, &n))
-            this->setFast32(n);
-    }
-
-    for (node = dom.getFirstChild(node); node; node = dom.getNextSibling(node))
-    {
-        if (strcmp(dom.getName(node), "data"))
-        {
-            SkDEBUGCODE(SkDebugf("SkEvent::inflate unrecognized subelement <%s>\n", dom.getName(node));)
-            continue;
-        }
-
-        name = dom.findAttr(node, "name");
-        if (name == NULL)
-        {
-            SkDEBUGCODE(SkDebugf("SkEvent::inflate missing required \"name\" attribute in <data> subelement\n");)
-            continue;
-        }
-
-        if ((value = dom.findAttr(node, "s32")) != NULL)
-        {
-            int32_t n;
-            if (SkParse::FindS32(value, &n))
-                this->setS32(name, n);
-        }
-        else if ((value = dom.findAttr(node, "scalar")) != NULL)
-        {
-            SkScalar x;
-            if (SkParse::FindScalar(value, &x))
-                this->setScalar(name, x);
-        }
-        else if ((value = dom.findAttr(node, "string")) != NULL)
-            this->setString(name, value);
-#ifdef SK_DEBUG
-        else
-        {
-            SkDebugf("SkEvent::inflate <data name=\"%s\"> subelement missing required type attribute [S32 | scalar | string]\n", name);
-        }
-#endif
-    }
-}
-
-#ifdef SK_DEBUG
-
-    #ifndef SkScalarToFloat
-        #define SkScalarToFloat(x)  ((x) / 65536.f)
-    #endif
-
-    void SkEvent::dump(const char title[])
-    {
-        if (title)
-            SkDebugf("%s ", title);
-            
-        SkString    etype;
-        this->getType(&etype);
-        SkDebugf("event<%s> fast32=%d", etype.c_str(), this->getFast32());
-
-        const SkMetaData&   md = this->getMetaData();
-        SkMetaData::Iter    iter(md);
-        SkMetaData::Type    mtype;
-        int                 count;
-        const char*         name;
-        
-        while ((name = iter.next(&mtype, &count)) != NULL)
-        {
-            SkASSERT(count > 0);
-
-            SkDebugf(" <%s>=", name);
-            switch (mtype) {
-            case SkMetaData::kS32_Type:     // vector version???
-                {
-                    int32_t value;
-                    md.findS32(name, &value);
-                    SkDebugf("%d ", value);
-                }
-                break;
-            case SkMetaData::kScalar_Type:
-                {
-                    const SkScalar* values = md.findScalars(name, &count, NULL);
-                    SkDebugf("%f", SkScalarToFloat(values[0]));
-                    for (int i = 1; i < count; i++)
-                        SkDebugf(", %f", SkScalarToFloat(values[i]));
-                    SkDebugf(" ");
-                }
-                break;
-            case SkMetaData::kString_Type:
-                {
-                    const char* value = md.findString(name);
-                    SkASSERT(value);
-                    SkDebugf("<%s> ", value);
-                }
-                break;
-            case SkMetaData::kPtr_Type:     // vector version???
-                {
-                    void*   value;
-                    md.findPtr(name, &value);
-                    SkDebugf("%p ", value);
-                }
-                break;
-            case SkMetaData::kBool_Type:    // vector version???
-                {
-                    bool    value;
-                    md.findBool(name, &value);
-                    SkDebugf("%s ", value ? "true" : "false");
-                }
-                break;
-            default:
-                SkASSERT(!"unknown metadata type returned from iterator");
-                break;
-            }
-        }
-        SkDebugf("\n");
-    }
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-// #define SK_TRACE_EVENTSx
-#endif
-
-#ifdef SK_TRACE_EVENTS
-    static void event_log(const char s[])
-    {
-        SkDEBUGF(("%s\n", s));
-    }
-
-    #define EVENT_LOG(s)        event_log(s)
-    #define EVENT_LOGN(s, n)    do { SkString str(s); str.append(" "); str.appendS32(n); event_log(str.c_str()); } while (0)
-#else
-    #define EVENT_LOG(s)
-    #define EVENT_LOGN(s, n)
-#endif
-
-#include "SkGlobals.h"
-#include "SkThread.h"
-#include "SkTime.h"
-
-#define SK_Event_GlobalsTag     SkSetFourByteTag('e', 'v', 'n', 't')
-
-class SkEvent_Globals : public SkGlobals::Rec {
-public:
-    SkMutex     fEventMutex;
-    SkEvent*    fEventQHead, *fEventQTail;
-    SkEvent*    fDelayQHead;
-    SkDEBUGCODE(int fEventCounter;)
-};
-
-static SkGlobals::Rec* create_globals()
-{
-    SkEvent_Globals* rec = new SkEvent_Globals;
-    rec->fEventQHead = NULL;
-    rec->fEventQTail = NULL;
-    rec->fDelayQHead = NULL;
-    SkDEBUGCODE(rec->fEventCounter = 0;)
-    return rec;
-}
-
-bool SkEvent::Post(SkEvent* evt, SkEventSinkID sinkID, SkMSec delay)
-{
-    if (delay)
-        return SkEvent::PostTime(evt, sinkID, SkTime::GetMSecs() + delay);
-
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-
-    evt->fTargetID = sinkID;
-
-#ifdef SK_TRACE_EVENTS
-    {
-        SkString    str("SkEvent::Post(");
-        str.append(evt->getType());
-        str.append(", 0x");
-        str.appendHex(sinkID);
-        str.append(", ");
-        str.appendS32(delay);
-        str.append(")");
-        event_log(str.c_str());
-    }
-#endif
-
-    globals.fEventMutex.acquire();
-    bool wasEmpty = SkEvent::Enqueue(evt);
-    globals.fEventMutex.release();
-
-    // call outside of us holding the mutex
-    if (wasEmpty)
-        SkEvent::SignalNonEmptyQueue();
-    return true;
-}
-
-#if defined(SK_SIMULATE_FAILED_MALLOC) && defined(SK_FIND_MEMORY_LEAKS)
-SkMSec gMaxDrawTime;
-#endif
-
-bool SkEvent::PostTime(SkEvent* evt, SkEventSinkID sinkID, SkMSec time)
-{
-#if defined(SK_SIMULATE_FAILED_MALLOC) && defined(SK_FIND_MEMORY_LEAKS)
-    gMaxDrawTime = time;
-#endif
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-
-    evt->fTargetID = sinkID;
-
-#ifdef SK_TRACE_EVENTS
-    {
-        SkString    str("SkEvent::Post(");
-        str.append(evt->getType());
-        str.append(", 0x");
-        str.appendHex(sinkID);
-        str.append(", ");
-        str.appendS32(time);
-        str.append(")");
-        event_log(str.c_str());
-    }
-#endif
-
-    globals.fEventMutex.acquire();
-    SkMSec queueDelay = SkEvent::EnqueueTime(evt, time);
-    globals.fEventMutex.release();
-
-    // call outside of us holding the mutex
-    if ((int32_t)queueDelay != ~0)
-        SkEvent::SignalQueueTimer(queueDelay);
-    return true;
-}
-
-bool SkEvent::Enqueue(SkEvent* evt)
-{
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-    //  gEventMutex acquired by caller
-
-    SkASSERT(evt);
-
-    bool wasEmpty = globals.fEventQHead == NULL;
-
-    if (globals.fEventQTail)
-        globals.fEventQTail->fNextEvent = evt;
-    globals.fEventQTail = evt;
-    if (globals.fEventQHead == NULL)
-        globals.fEventQHead = evt;
-    evt->fNextEvent = NULL;
-
-    SkDEBUGCODE(++globals.fEventCounter);
-//  SkDebugf("Enqueue: count=%d\n", gEventCounter);
-
-    return wasEmpty;
-}
-
-SkEvent* SkEvent::Dequeue(SkEventSinkID* sinkID)
-{
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-    globals.fEventMutex.acquire();
-
-    SkEvent* evt = globals.fEventQHead;
-    if (evt)
-    {
-        SkDEBUGCODE(--globals.fEventCounter);
-
-        if (sinkID)
-            *sinkID = evt->fTargetID;
-
-        globals.fEventQHead = evt->fNextEvent;
-        if (globals.fEventQHead == NULL)
-            globals.fEventQTail = NULL;
-    }
-    globals.fEventMutex.release();
-
-//  SkDebugf("Dequeue: count=%d\n", gEventCounter);
-
-    return evt;
-}
-
-bool SkEvent::QHasEvents()
-{
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-
-    // this is not thread accurate, need a semaphore for that
-    return globals.fEventQHead != NULL;
-}
-
-#ifdef SK_TRACE_EVENTS
-    static int gDelayDepth;
-#endif
-
-SkMSec SkEvent::EnqueueTime(SkEvent* evt, SkMSec time)
-{
-#ifdef SK_TRACE_EVENTS
-    SkDebugf("enqueue-delay %s %d (%d)", evt->getType(), time, gDelayDepth);
-    const char* idStr = evt->findString("id");
-    if (idStr)
-        SkDebugf(" (%s)", idStr);
-    SkDebugf("\n");
-    ++gDelayDepth;
-#endif
-
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-    //  gEventMutex acquired by caller
-
-    SkEvent* curr = globals.fDelayQHead;
-    SkEvent* prev = NULL;
-
-    while (curr)
-    {
-        if (SkMSec_LT(time, curr->fTime))
-            break;
-        prev = curr;
-        curr = curr->fNextEvent;
-    }
-
-    evt->fTime = time;
-    evt->fNextEvent = curr;
-    if (prev == NULL)
-        globals.fDelayQHead = evt;
-    else
-        prev->fNextEvent = evt;
-
-    SkMSec delay = globals.fDelayQHead->fTime - SkTime::GetMSecs();
-    if ((int32_t)delay <= 0)
-        delay = 1;
-    return delay;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#include "SkEventSink.h"
-
-bool SkEvent::ProcessEvent()
-{
-    SkEventSinkID   sinkID;
-    SkEvent*        evt = SkEvent::Dequeue(&sinkID);
-    SkAutoTDelete<SkEvent>  autoDelete(evt);
-    bool            again = false;
-
-    EVENT_LOGN("ProcessEvent", (int32_t)evt);
-
-    if (evt)
-    {
-        (void)SkEventSink::DoEvent(*evt, sinkID);
-        again = SkEvent::QHasEvents();
-    }
-    return again;
-}
-
-void SkEvent::ServiceQueueTimer()
-{
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-
-    globals.fEventMutex.acquire();
-
-    bool        wasEmpty = false;
-    SkMSec      now = SkTime::GetMSecs();
-    SkEvent*    evt = globals.fDelayQHead;
-
-    while (evt)
-    {
-        if (SkMSec_LT(now, evt->fTime))
-            break;
-
-#ifdef SK_TRACE_EVENTS
-        --gDelayDepth;
-        SkDebugf("dequeue-delay %s (%d)", evt->getType(), gDelayDepth);
-        const char* idStr = evt->findString("id");
-        if (idStr)
-            SkDebugf(" (%s)", idStr);
-        SkDebugf("\n");
-#endif
-
-        SkEvent* next = evt->fNextEvent;
-        if (SkEvent::Enqueue(evt))
-            wasEmpty = true;
-        evt = next;
-    }
-    globals.fDelayQHead = evt;
-
-    SkMSec time = evt ? evt->fTime - now : 0;
-
-    globals.fEventMutex.release();
-
-    if (wasEmpty)
-        SkEvent::SignalNonEmptyQueue();
-
-    SkEvent::SignalQueueTimer(time);
-}
-
-int SkEvent::CountEventsOnQueue() {
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-    globals.fEventMutex.acquire();
-    
-    int count = 0;
-    const SkEvent* evt = globals.fEventQHead;
-    while (evt) {
-        count += 1;
-        evt = evt->fNextEvent;
-    }
-    globals.fEventMutex.release();
-
-    return count;
-}
-
-////////////////////////////////////////////////////////////////
-
-void SkEvent::Init()
-{
-}
-
-void SkEvent::Term()
-{
-    SkEvent_Globals& globals = *(SkEvent_Globals*)SkGlobals::Find(SK_Event_GlobalsTag, create_globals);
-
-    SkEvent* evt = globals.fEventQHead;
-    while (evt)
-    {
-        SkEvent* next = evt->fNextEvent;
-        delete evt;
-        evt = next;
-    }
-
-    evt = globals.fDelayQHead;
-    while (evt)
-    {
-        SkEvent* next = evt->fNextEvent;
-        delete evt;
-        evt = next;
-    }
-}
-
diff --git a/src/views/SkEventSink.cpp b/src/views/SkEventSink.cpp
deleted file mode 100644
index c8fe35c..0000000
--- a/src/views/SkEventSink.cpp
+++ /dev/null
@@ -1,345 +0,0 @@
-/* libs/graphics/views/SkEventSink.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkEventSink.h"
-#include "SkTagList.h"
-#include "SkThread.h"
-
-#include "SkGlobals.h"
-#include "SkThread.h"
-#include "SkTime.h"
-
-#define SK_EventSink_GlobalsTag     SkSetFourByteTag('e', 'v', 's', 'k')
-
-class SkEventSink_Globals : public SkGlobals::Rec {
-public:
-    SkMutex         fSinkMutex;
-    SkEventSinkID   fNextSinkID;
-    SkEventSink*    fSinkHead;
-};
-
-static SkGlobals::Rec* create_globals()
-{
-    SkEventSink_Globals* rec = new SkEventSink_Globals;
-    rec->fNextSinkID = 0;
-    rec->fSinkHead = NULL;
-    return rec;
-}
-
-SkEventSink::SkEventSink() : fTagHead(NULL)
-{
-    SkEventSink_Globals& globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
-
-    globals.fSinkMutex.acquire();
-
-    fID = ++globals.fNextSinkID;
-    fNextSink = globals.fSinkHead;
-    globals.fSinkHead = this;
-
-    globals.fSinkMutex.release();
-}
-
-SkEventSink::~SkEventSink()
-{
-    SkEventSink_Globals& globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
-
-    if (fTagHead)
-        SkTagList::DeleteAll(fTagHead);
-
-    globals.fSinkMutex.acquire();
-
-    SkEventSink* sink = globals.fSinkHead;
-    SkEventSink* prev = NULL;
-
-    for (;;)
-    {
-        SkEventSink* next = sink->fNextSink;
-        if (sink == this)
-        {
-            if (prev)
-                prev->fNextSink = next;
-            else
-                globals.fSinkHead = next;
-            break;
-        }
-        prev = sink;
-        sink = next;
-    }
-    globals.fSinkMutex.release();
-}
-
-bool SkEventSink::doEvent(const SkEvent& evt)
-{
-    return this->onEvent(evt);
-}
-
-bool SkEventSink::doQuery(SkEvent* evt)
-{
-    SkASSERT(evt);
-    return this->onQuery(evt);
-}
-
-bool SkEventSink::onEvent(const SkEvent&)
-{
-    return false;
-}
-
-bool SkEventSink::onQuery(SkEvent*)
-{
-    return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkTagList* SkEventSink::findTagList(U8CPU tag) const
-{
-    return fTagHead ? SkTagList::Find(fTagHead, tag) : NULL;
-}
-
-void SkEventSink::addTagList(SkTagList* rec)
-{
-    SkASSERT(rec);
-    SkASSERT(fTagHead == NULL || SkTagList::Find(fTagHead, rec->fTag) == NULL);
-
-    rec->fNext = fTagHead;
-    fTagHead = rec;
-}
-
-void SkEventSink::removeTagList(U8CPU tag)
-{
-    if (fTagHead)
-        SkTagList::DeleteTag(&fTagHead, tag);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct SkListenersTagList : SkTagList {
-    SkListenersTagList(U16CPU count) : SkTagList(kListeners_SkTagList)
-    {
-        fExtra16 = SkToU16(count);
-        fIDs = (SkEventSinkID*)sk_malloc_throw(count * sizeof(SkEventSinkID));
-    }
-    virtual ~SkListenersTagList()
-    {
-        sk_free(fIDs);
-    }
-
-    int countListners() const { return fExtra16; }
-
-    int find(SkEventSinkID id) const
-    {
-        const SkEventSinkID* idptr = fIDs;
-        for (int i = fExtra16 - 1; i >= 0; --i)
-            if (idptr[i] == id)
-                return i;
-        return -1;
-    }
-
-    SkEventSinkID*  fIDs;
-};
-
-void SkEventSink::addListenerID(SkEventSinkID id)
-{
-    if (id == 0)
-        return;
-
-    SkListenersTagList* prev = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
-    int                 count = 0;
-
-    if (prev)
-    {
-        if (prev->find(id) >= 0)
-            return;
-        count = prev->countListners();
-    }
-
-    SkListenersTagList* next = SkNEW_ARGS(SkListenersTagList, (count + 1));
-
-    if (prev)
-    {
-        memcpy(next->fIDs, prev->fIDs, count * sizeof(SkEventSinkID));
-        this->removeTagList(kListeners_SkTagList);
-    }
-    next->fIDs[count] = id;
-    this->addTagList(next);
-}
-
-void SkEventSink::copyListeners(const SkEventSink& sink) 
-{
-    SkListenersTagList* sinkList = (SkListenersTagList*)sink.findTagList(kListeners_SkTagList);
-    if (sinkList == NULL)
-        return;
-    SkASSERT(sinkList->countListners() > 0);
-    const SkEventSinkID* iter = sinkList->fIDs;
-    const SkEventSinkID* stop = iter + sinkList->countListners();
-    while (iter < stop)
-        addListenerID(*iter++);
-}
-
-void SkEventSink::removeListenerID(SkEventSinkID id)
-{
-    if (id == 0)
-        return;
-
-    SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
-
-    if (list == NULL)
-        return;
-
-    int index = list->find(id);
-    if (index >= 0)
-    {
-        int count = list->countListners();
-        SkASSERT(count > 0);
-        if (count == 1)
-            this->removeTagList(kListeners_SkTagList);
-        else
-        {
-            // overwrite without resize/reallocating our struct (for speed)
-            list->fIDs[index] = list->fIDs[count - 1];
-            list->fExtra16 = SkToU16(count - 1);
-        }
-    }
-}
-
-bool SkEventSink::hasListeners() const
-{
-    return this->findTagList(kListeners_SkTagList) != NULL;
-}
-
-void SkEventSink::postToListeners(const SkEvent& evt, SkMSec delay)
-{
-    SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
-    if (list)
-    {
-        SkASSERT(list->countListners() > 0);
-        const SkEventSinkID* iter = list->fIDs;
-        const SkEventSinkID* stop = iter + list->countListners();
-        while (iter < stop)
-            (SkNEW_ARGS(SkEvent, (evt)))->post(*iter++, delay);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkEventSink::EventResult SkEventSink::DoEvent(const SkEvent& evt, SkEventSinkID sinkID)
-{
-    SkEventSink* sink = SkEventSink::FindSink(sinkID);
-
-    if (sink)
-    {
-#ifdef SK_DEBUG
-        if (evt.isDebugTrace())
-        {
-            SkString    etype;
-            evt.getType(&etype);
-            SkDebugf("SkEventTrace: dispatching event <%s> to 0x%x", etype.c_str(), sinkID);
-            const char* idStr = evt.findString("id");
-            if (idStr)
-                SkDebugf(" (%s)", idStr);
-            SkDebugf("\n");
-        }
-#endif
-        return sink->doEvent(evt) ? kHandled_EventResult : kNotHandled_EventResult;
-    }
-    else
-    {
-#ifdef SK_DEBUG
-        if (sinkID)
-            SkDebugf("DoEvent: Can't find sink for ID(%x)\n", sinkID);
-        else
-            SkDebugf("Event sent to 0 sinkID\n");
-
-        if (evt.isDebugTrace())
-        {
-            SkString    etype;
-            evt.getType(&etype);
-            SkDebugf("SkEventTrace: eventsink not found <%s> for 0x%x\n", etype.c_str(), sinkID);
-        }
-#endif
-        return kSinkNotFound_EventResult;
-    }
-}
-
-SkEventSink* SkEventSink::FindSink(SkEventSinkID sinkID)
-{
-    if (sinkID == 0)
-        return 0;
-
-    SkEventSink_Globals&    globals = *(SkEventSink_Globals*)SkGlobals::Find(SK_EventSink_GlobalsTag, create_globals);
-    SkAutoMutexAcquire      ac(globals.fSinkMutex);
-    SkEventSink*            sink = globals.fSinkHead;
-
-    while (sink)
-    {
-        if (sink->getSinkID() == sinkID)
-            return sink;
-        sink = sink->fNextSink;
-    }
-    return NULL;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-
-#if 0   // experimental, not tested
-
-#include "SkThread.h"
-#include "SkTDict.h"
-
-#define kMinStringBufferSize    128
-static SkMutex                  gNamedSinkMutex;
-static SkTDict<SkEventSinkID>   gNamedSinkIDs(kMinStringBufferSize);
-
-/** Register a name/id pair with the system. If the name already exists,
-    replace its ID with the new id. This pair will persist until UnregisterNamedSink()
-    is called.
-*/
-void SkEventSink::RegisterNamedSinkID(const char name[], SkEventSinkID id)
-{
-    if (id && name && *name)
-    {
-        SkAutoMutexAcquire  ac(gNamedSinkMutex);
-        gNamedSinkIDs.set(name, id);
-    }
-}
-
-/** Return the id that matches the specified name (from a previous call to
-    RegisterNamedSinkID(). If no match is found, return 0
-*/
-SkEventSinkID SkEventSink::FindNamedSinkID(const char name[])
-{
-    SkEventSinkID id = 0;
-
-    if (name && *name)
-    {
-        SkAutoMutexAcquire  ac(gNamedSinkMutex);
-        (void)gNamedSinkIDs.find(name, &id);
-    }
-    return id;
-}
-
-/** Remove all name/id pairs from the system. This is call internally
-    on shutdown, to ensure no memory leaks. It should not be called
-    before shutdown.
-*/
-void SkEventSink::RemoveAllNamedSinkIDs()
-{
-    SkAutoMutexAcquire  ac(gNamedSinkMutex);
-    (void)gNamedSinkIDs.reset();
-}
-#endif
diff --git a/src/views/SkImageView.cpp b/src/views/SkImageView.cpp
deleted file mode 100644
index 9c358c7..0000000
--- a/src/views/SkImageView.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-#include "SkImageView.h"
-#include "SkAnimator.h"
-#include "SkBitmap.h"
-#include "SkCanvas.h"
-#include "SkImageDecoder.h"
-#include "SkMatrix.h"
-#include "SkSystemEventTypes.h"
-#include "SkTime.h"
-
-SkImageView::SkImageView()
-{
-	fMatrix		= NULL;
-	fScaleType	= kMatrix_ScaleType;
-
-	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();
-}
-
-void SkImageView::getUri(SkString* uri) const
-{
-	if (uri)
-		*uri = fUri;
-}
-
-void SkImageView::setUri(const char uri[])
-{
-	if (!fUri.equals(uri))
-	{
-		fUri.set(uri);
-		this->onUriChange();
-	}
-}
-
-void SkImageView::setUri(const SkString& uri)
-{
-	if (fUri != uri)
-	{
-		fUri = uri;
-		this->onUriChange();
-	}
-}
-
-void SkImageView::setScaleType(ScaleType st)
-{
-	SkASSERT((unsigned)st <= kFitEnd_ScaleType);
-
-	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;
-	}
-}
-
-void SkImageView::setImageMatrix(const SkMatrix* matrix)
-{
-	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;
-		}
-	}
-
-	// 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);
-}
-
-static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st)
-{
-	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);
-}
-
-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);
-
-	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);
-}
-
-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);
-
-	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
-}
-
-bool SkImageView::freeData()
-{
-	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;
-}
-
-bool SkImageView::getDataBounds(SkRect* bounds)
-{
-	SkASSERT(bounds);
-
-	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;
-}
-
-bool SkImageView::ensureUriIsLoaded()
-{
-	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);
-
-		fData.fAnim = anim;
-		fDataIsAnim = true;
-	}
-	else	// assume it is an image format
-	{
-    #if 0
-		SkBitmap* bitmap = new SkBitmap;
-
-		if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap))
-		{
-			delete bitmap;
-			fUriIsValid = false;
-			return false;
-		}
-		fData.fBitmap = bitmap;
-		fDataIsAnim = false;
-    #else
-        return false;
-    #endif
-	}
-	return true;
-}
-
diff --git a/src/views/SkListView.cpp b/src/views/SkListView.cpp
deleted file mode 100644
index ba4f02a..0000000
--- a/src/views/SkListView.cpp
+++ /dev/null
@@ -1,895 +0,0 @@
-#include "SkWidget.h"
-#include "SkCanvas.h"
-#include "SkEvent.h"
-#include "SkKey.h"
-#include "SkParsePaint.h"
-#include "SkSystemEventTypes.h"
-
-#if 0
-
-SkEvent* SkListSource::getEvent(int index)
-{
-	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);
-
-		if (fIndex > index)
-		{
-			fIter.reset(fPath.c_str(), fSuffix.c_str());
-			fIndex = 0;
-		}
-
-		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();
-
-		fIndex += 1;
-	}
-	virtual SkEvent* getEvent(int index)
-	{
-		SkASSERT((unsigned)index < (unsigned)fCount);
-
-		SkEvent*	evt = new SkEvent();
-		SkString	label;
-
-		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;
-	}
-
-private:
-	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);
-}
-
-//////////////////////////////////////////////////////////////////
-
-class SkDOMListSource : public SkListSource {
-public:
-	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;
-
-		while (child)
-		{
-			count += 1;
-			child = dom.getNextSibling(child, "item");
-		}
-
-		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;
-
-				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);
-
-		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);
-
-		return NULL;
-	}
-
-private:
-	int			fCount;
-	ItemRec*	fList;
-	SkString	fDirTail;
-};
-
-SkListSource* SkListSource::CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node)
-{
-	return new SkDOMListSource(dom, node);
-}
-
-//////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////
-
-SkListView::SkListView(U32 flags) : SkWidgetView(flags)
-{
-	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);
-}
-
-SkListView::~SkListView()
-{
-	delete[] fStrCache;
-	fSource->safeUnref();
-}
-
-void SkListView::setRowHeight(SkScalar height)
-{
-	SkASSERT(height >= 0);
-
-	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();
-
-		{
-			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);
-	}
-}
-
-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);
-	}
-}
-
-void SkListView::invalSelection()
-{
-	SkRect	r;
-	if (this->getRowRect(fCurrIndex, &r))
-		this->inval(&r);
-}
-
-void SkListView::ensureSelectionIsVisible()
-{
-	if (fSource == NULL)
-		return;
-
-	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());
-
-			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;
-
-		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];
-}
-
-SkListSource* SkListView::setListSource(SkListSource* 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);
-
-	canvas->drawPaint(fPaint[kBG_Attr]);
-
-	int	visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
-	if (visibleCount == 0)
-		return;
-
-	this->ensureStrCache(visibleCount);
-	int currIndex = this->logicalToVisualIndex(fCurrIndex);
-
-	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]);
-	}
-
-	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;
-	}
-
-	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);
-	}
-}
-
-void SkListView::onSizeChange()
-{
-	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;
-
-	if (fVisibleRowCount != n)
-	{
-		fVisibleRowCount = n;
-		this->ensureSelectionIsVisible();
-		this->dirtyStrCache();
-	}
-}
-
-void SkListView::dirtyStrCache()
-{
-	if (fStrCache)
-	{
-		delete[] fStrCache;
-		fStrCache = NULL;
-	}
-}
-
-void SkListView::ensureStrCache(int count)
-{
-	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]);
-	}
-}
-
-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);
-}
-
-void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-
-	SkScalar			x;
-	const SkDOM::Node*	child;
-
-	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);
-
-	// 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 (src)
-		{
-			this->setListSource(src)->unref();
-			this->setSelection(0);
-		}
-	}
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////
-
-#include "SkImageDecoder.h"
-#include "SkShader.h"
-
-class SkScrollBarView : public SkView {
-public:
-	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;
-	}
-protected:
-	virtual void onDraw(SkCanvas* canvas)
-	{
-		if (fBGRef == NULL) return;
-
-		SkPaint	paint;
-
-		SkShader* shader = SkShader::CreateBitmapShader(fBGRef->bitmap(), false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode);
-		paint.setShader(shader)->unref();
-
-		canvas->drawPaint(paint);
-	}
-private:
-	SkBitmapRef*	fBGRef, *fFGRef;
-};
-
-SkGridView::SkGridView(U32 flags) : SkWidgetView(flags)
-{
-	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);
-
-	fScrollBar = new SkScrollBarView("icons/scrollbarGrey.jpg", "icons/scrollbarBlue.jpg");
-	this->attachChildToFront(fScrollBar)->unref();
-	fScrollBar->setVisibleP(true);
-}
-
-SkGridView::~SkGridView()
-{
-	fSource->safeUnref();
-}
-
-void SkGridView::getCellSize(SkPoint* size) const
-{
-	if (size)
-		*size = fCellSize;
-}
-
-void SkGridView::setCellSize(SkScalar x, SkScalar y)
-{
-	SkASSERT(x >= 0 && y >= 0);
-
-	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();
-
-		// 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);
-	}
-}
-
-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);
-	}
-}
-
-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);
-	}
-}
-
-void SkGridView::ensureSelectionIsVisible()
-{
-	if (fSource == NULL)
-		return;
-#if 0
-	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());
-
-			this->dirtyStrCache();
-			this->inval(NULL);
-		}
-	}
-#endif
-}
-
-bool SkGridView::getCellRect(int index, SkRect* r) const
-{
-	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;
-
-		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;
-}
-
-SkPaint& SkGridView::paint(Attr 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;
-}
-
-#include "SkShader.h"
-
-static void copybits(SkCanvas* canvas, const SkBitmap& bm, const SkRect& dst, const SkPaint& paint)
-{
-	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();
-
-		shader->setLocalMatrix(matrix);
-		canvas->drawRect(dst, p);
-	}
-}
-
-#include "SkImageDecoder.h"
-
-void SkGridView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	canvas->drawPaint(fPaint[kBG_Attr]);
-
-	if (fSource == NULL)
-		return;
-
-#if 0
-	int	visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex);
-	if (visibleCount == 0)
-		return;
-
-	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;
-
-		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;
-		}
-	}
-
-	// 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;
-}
-
-void SkGridView::onSizeChange()
-{
-	fScrollBar->setHeight(this->height());
-	fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0);
-
-	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);
-
-	y = check_count(y, rows);
-	x = check_count(x, cols);
-
-	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));
-
-					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);
-
-	SkScalar			x[2];
-	const SkDOM::Node*	child;
-
-	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);
-
-	// 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 (src)
-		{
-			this->setListSource(src)->unref();
-			this->setSelection(0);
-		}
-	}
-	this->onSizeChange();
-}
-
-#endif
diff --git a/src/views/SkListWidget.cpp b/src/views/SkListWidget.cpp
deleted file mode 100644
index f693ebe..0000000
--- a/src/views/SkListWidget.cpp
+++ /dev/null
@@ -1,623 +0,0 @@
-#include "SkWidgetViews.h"
-
-#include "SkAnimator.h"
-#include "SkScrollBarView.h"
-
-extern void init_skin_anim(const char name[], SkAnimator*);
-
-struct SkListView::BindingRec {
-	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;
-
-	fHeights[kNormal_Height] = SkIntToScalar(16);
-	fHeights[kSelected_Height] = SkIntToScalar(16);
-	
-	this->setFlags(this->getFlags() | kFocusable_Mask);
-}
-
-SkListView::~SkListView()
-{
-	fScrollBar->safeUnref();
-	fSource->safeUnref();
-	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);
-	}
-}
-
-void SkListView::setSelection(int index)
-{
-	if (fCurrIndex != index)
-	{
-		fAnimFocusDirty = true;
-		this->inval(NULL);
-
-		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;
-}
-
-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;
-}
-
-void SkListView::invalSelection()
-{
-	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 ((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;
-}
-
-bool SkListView::getRowRect(int index, SkRect* r) const
-{
-	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];
-
-		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;
-}
-
-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;
-	}
-}
-
-bool SkListView::ensureCache()
-{
-	if (fSkinName.size() == 0)
-		return false;
-
-	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");
-
-		fAnimFocusDirty = true;
-	}
-
-	if (fAnimContentDirty && fSource)
-	{
-		fAnimContentDirty = false;
-
-		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;
-	}
-
-	if (fAnimFocusDirty)
-	{
-//SkDEBUGF(("service fAnimFocusDirty\n"));
-		fAnimFocusDirty = false;
-
-		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);
-		}
-	}
-
-	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);
-		}
-	}
-
-	if (fVisibleRowCount != n)
-	{
-		if (fScrollBar)
-			fScrollBar->setShown(n);
-
-		fVisibleRowCount = n;
-		this->ensureSelectionIsVisible();
-		this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag);
-	}
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-#include "SkSystemEventTypes.h"
-#include "SkTime.h"
-
-void SkListView::onSizeChange()
-{
-	this->INHERITED::onSizeChange();
-
-	if (fScrollBar)
-		fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0);
-
-	this->ensureVisibleRowCount();
-}
-
-void SkListView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	this->ensureVisibleRowCount();
-
-	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;
-
-	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);
-
-	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();
-
-		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);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static const char gListViewEventSlot[] = "sk-listview-slot-name";
-
-/*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;
-}
-
-int SkListView::GetWidgetEventListIndex(const SkEvent& evt)
-{
-	int32_t	index;
-
-	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);
-	}
-
-	const SkDOM::Node*	child;
-
-	if ((child = dom.getFirstChild(node, "bindings")) != NULL)
-	{
-		delete[] fBindings;
-		fBindings = NULL;
-		fBindingCount = 0;
-
-		SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields"));
-		SkASSERT(listSrc);
-		fSkinName.set(dom.findAttr(child, "skin-slots"));
-		SkASSERT(fSkinName.size());
-
-		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
-
-			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);
-	}
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-class SkXMLListSource : public SkListSource {
-public:
-	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	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;
-	}
-	
-private:
-	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;
-
-	SkDOM	dom;
-
-	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];
-
-		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, "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>";
-		
-//SkDebugf("doc size %d\n", sizeof(gDoc)-1);
-	return new SkXMLListSource(gDoc, sizeof(gDoc) - 1);
-}
-
-
-
diff --git a/src/views/SkMetaData.cpp b/src/views/SkMetaData.cpp
deleted file mode 100644
index c871efb..0000000
--- a/src/views/SkMetaData.cpp
+++ /dev/null
@@ -1,428 +0,0 @@
-/* libs/graphics/views/SkMetaData.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkMetaData.h"
-
-SkMetaData::SkMetaData() : fRec(NULL)
-{
-}
-
-SkMetaData::SkMetaData(const SkMetaData& src) : fRec(NULL)
-{
-    *this = src;
-}
-
-SkMetaData::~SkMetaData()
-{
-    this->reset();
-}
-
-void SkMetaData::reset()
-{
-    Rec* rec = fRec;
-    while (rec)
-    {
-        Rec* next = rec->fNext;
-        Rec::Free(rec);
-        rec = next;
-    }
-    fRec = NULL;
-}
-
-SkMetaData& SkMetaData::operator=(const SkMetaData& src)
-{
-    this->reset();
-
-    const Rec* rec = src.fRec;
-    while (rec)
-    {
-        this->set(rec->name(), rec->data(), rec->fDataLen, (Type)rec->fType, rec->fDataCount);
-        rec = rec->fNext;
-    }
-    return *this;
-}
-
-void SkMetaData::setS32(const char name[], int32_t value)
-{
-    (void)this->set(name, &value, sizeof(int32_t), kS32_Type, 1);
-}
-
-void SkMetaData::setScalar(const char name[], SkScalar value)
-{
-    (void)this->set(name, &value, sizeof(SkScalar), kScalar_Type, 1);
-}
-
-SkScalar* SkMetaData::setScalars(const char name[], int count, const SkScalar values[])
-{
-    SkASSERT(count > 0);
-    if (count > 0)
-        return (SkScalar*)this->set(name, values, sizeof(SkScalar), kScalar_Type, count);
-    return NULL;
-}
-
-void SkMetaData::setString(const char name[], const char value[])
-{
-    (void)this->set(name, value, sizeof(char), kString_Type, strlen(value) + 1);
-}
-
-void SkMetaData::setPtr(const char name[], void* ptr)
-{
-    (void)this->set(name, &ptr, sizeof(void*), kPtr_Type, 1);
-}
-
-void SkMetaData::setBool(const char name[], bool value)
-{
-    (void)this->set(name, &value, sizeof(bool), kBool_Type, 1);
-}
-
-void SkMetaData::setData(const char name[], const void* data, size_t byteCount) {
-    (void)this->set(name, data, sizeof(char), kData_Type, byteCount);
-}
-
-void* SkMetaData::set(const char name[], const void* data, size_t dataSize, Type type, int count)
-{
-    SkASSERT(name);
-    SkASSERT(dataSize);
-    SkASSERT(count > 0);
-
-    (void)this->remove(name, type);
-
-    size_t  len = strlen(name);
-    Rec*    rec = Rec::Alloc(sizeof(Rec) + dataSize * count + len + 1);
-
-#ifndef SK_DEBUG
-    rec->fType = SkToU8(type);
-#else
-    rec->fType = type;
-#endif
-    rec->fDataLen = SkToU8(dataSize);
-    rec->fDataCount = SkToU16(count);
-    if (data)
-        memcpy(rec->data(), data, dataSize * count);
-    memcpy(rec->name(), name, len + 1);
-
-#ifdef SK_DEBUG
-    rec->fName = rec->name();
-    switch (type) {
-    case kS32_Type:
-        rec->fData.fS32 = *(const int32_t*)rec->data();
-        break;
-    case kScalar_Type:
-        rec->fData.fScalar = *(const SkScalar*)rec->data();
-        break;
-    case kString_Type:
-        rec->fData.fString = (const char*)rec->data();
-        break;
-    case kPtr_Type:
-        rec->fData.fPtr = *(void**)rec->data();
-        break;
-    case kBool_Type:
-        rec->fData.fBool = *(const bool*)rec->data();
-        break;
-    case kData_Type:
-        rec->fData.fPtr = rec->data();
-        break;
-    default:
-        SkASSERT(!"bad type");
-        break;
-    }
-#endif
-
-    rec->fNext = fRec;
-    fRec = rec;
-    return rec->data();
-}
-
-bool SkMetaData::findS32(const char name[], int32_t* value) const
-{
-    const Rec* rec = this->find(name, kS32_Type);
-    if (rec)
-    {
-        SkASSERT(rec->fDataCount == 1);
-        if (value)
-            *value = *(const int32_t*)rec->data();
-        return true;
-    }
-    return false;
-}
-
-bool SkMetaData::findScalar(const char name[], SkScalar* value) const
-{
-    const Rec* rec = this->find(name, kScalar_Type);
-    if (rec)
-    {
-        SkASSERT(rec->fDataCount == 1);
-        if (value)
-            *value = *(const SkScalar*)rec->data();
-        return true;
-    }
-    return false;
-}
-
-const SkScalar* SkMetaData::findScalars(const char name[], int* count, SkScalar values[]) const
-{
-    const Rec* rec = this->find(name, kScalar_Type);
-    if (rec)
-    {
-        if (count)
-            *count = rec->fDataCount;
-        if (values)
-            memcpy(values, rec->data(), rec->fDataCount * rec->fDataLen);
-        return (const SkScalar*)rec->data();
-    }
-    return NULL;
-}
-
-bool SkMetaData::findPtr(const char name[], void** value) const
-{
-    const Rec* rec = this->find(name, kPtr_Type);
-    if (rec)
-    {
-        SkASSERT(rec->fDataCount == 1);
-        if (value)
-            *value = *(void**)rec->data();
-        return true;
-    }
-    return false;
-}
-
-const char* SkMetaData::findString(const char name[]) const
-{
-    const Rec* rec = this->find(name, kString_Type);
-    SkASSERT(rec == NULL || rec->fDataLen == sizeof(char));
-    return rec ? (const char*)rec->data() : NULL;
-}
-
-bool SkMetaData::findBool(const char name[], bool* value) const
-{
-    const Rec* rec = this->find(name, kBool_Type);
-    if (rec)
-    {
-        SkASSERT(rec->fDataCount == 1);
-        if (value)
-            *value = *(const bool*)rec->data();
-        return true;
-    }
-    return false;
-}
-
-const void* SkMetaData::findData(const char name[], size_t* length) const {
-    const Rec* rec = this->find(name, kData_Type);
-    if (rec) {
-        SkASSERT(rec->fDataLen == sizeof(char));
-        if (length) {
-            *length = rec->fDataCount;
-        }
-        return rec->data();
-    }
-    return NULL;
-}
-
-const SkMetaData::Rec* SkMetaData::find(const char name[], Type type) const
-{
-    const Rec* rec = fRec;
-    while (rec)
-    {
-        if (rec->fType == type && !strcmp(rec->name(), name))
-            return rec;
-        rec = rec->fNext;
-    }
-    return NULL;
-}
-
-bool SkMetaData::remove(const char name[], Type type)
-{
-    Rec* rec = fRec;
-    Rec* prev = NULL;
-    while (rec)
-    {
-        Rec* next = rec->fNext;
-        if (rec->fType == type && !strcmp(rec->name(), name))
-        {
-            if (prev)
-                prev->fNext = next;
-            else
-                fRec = next;
-            Rec::Free(rec);
-            return true;
-        }
-        prev = rec;
-        rec = next;
-    }
-    return false;
-}
-
-bool SkMetaData::removeS32(const char name[])
-{
-    return this->remove(name, kS32_Type);
-}
-
-bool SkMetaData::removeScalar(const char name[])
-{
-    return this->remove(name, kScalar_Type);
-}
-
-bool SkMetaData::removeString(const char name[])
-{
-    return this->remove(name, kString_Type);
-}
-
-bool SkMetaData::removePtr(const char name[])
-{
-    return this->remove(name, kPtr_Type);
-}
-
-bool SkMetaData::removeBool(const char name[])
-{
-    return this->remove(name, kBool_Type);
-}
-
-bool SkMetaData::removeData(const char name[]) {
-    return this->remove(name, kData_Type);
-}
-
-///////////////////////////////////////////////////////////////////////////////////
-
-SkMetaData::Iter::Iter(const SkMetaData& metadata)
-{
-    fRec = metadata.fRec;
-}
-
-void SkMetaData::Iter::reset(const SkMetaData& metadata)
-{
-    fRec = metadata.fRec;
-}
-
-const char* SkMetaData::Iter::next(SkMetaData::Type* t, int* count)
-{
-    const char* name = NULL;
-
-    if (fRec)
-    {
-        if (t)
-            *t = (SkMetaData::Type)fRec->fType;
-        if (count)
-            *count = fRec->fDataCount;
-        name = fRec->name();
-
-        fRec = fRec->fNext;
-    }
-    return name;
-}
-
-///////////////////////////////////////////////////////////////////////////////////
-
-SkMetaData::Rec* SkMetaData::Rec::Alloc(size_t size)
-{
-    return (Rec*)sk_malloc_throw(size);
-}
-
-void SkMetaData::Rec::Free(Rec* rec)
-{
-    sk_free(rec);
-}
-
-///////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-
-void SkMetaData::UnitTest()
-{
-#ifdef SK_SUPPORT_UNITTEST
-    SkMetaData  m1;
-
-    SkASSERT(!m1.findS32("int"));
-    SkASSERT(!m1.findScalar("scalar"));
-    SkASSERT(!m1.findString("hello"));
-    SkASSERT(!m1.removeS32("int"));
-    SkASSERT(!m1.removeScalar("scalar"));
-    SkASSERT(!m1.removeString("hello"));
-    SkASSERT(!m1.removeString("true"));
-    SkASSERT(!m1.removeString("false"));
-
-    m1.setS32("int", 12345);
-    m1.setScalar("scalar", SK_Scalar1 * 42);
-    m1.setString("hello", "world");
-    m1.setPtr("ptr", &m1);
-    m1.setBool("true", true);
-    m1.setBool("false", false);
-
-    int32_t     n;
-    SkScalar    s;
-
-    m1.setScalar("scalar", SK_Scalar1/2);
-
-    SkASSERT(m1.findS32("int", &n) && n == 12345);
-    SkASSERT(m1.findScalar("scalar", &s) && s == SK_Scalar1/2);
-    SkASSERT(!strcmp(m1.findString("hello"), "world"));
-    SkASSERT(m1.hasBool("true", true));
-    SkASSERT(m1.hasBool("false", false));
-
-    Iter    iter(m1);
-    const char* name;
-
-    static const struct {
-        const char*         fName;
-        SkMetaData::Type    fType;
-        int                 fCount;
-    } gElems[] = {
-        { "int",    SkMetaData::kS32_Type,      1 },
-        { "scalar", SkMetaData::kScalar_Type,   1 },
-        { "ptr",    SkMetaData::kPtr_Type,      1 },
-        { "hello",  SkMetaData::kString_Type,   sizeof("world") },
-        { "true",   SkMetaData::kBool_Type,     1 },
-        { "false",  SkMetaData::kBool_Type,     1 }
-    };
-
-    int                 loop = 0;
-    int count;
-    SkMetaData::Type    t;
-    while ((name = iter.next(&t, &count)) != NULL)
-    {
-        int match = 0;
-        for (unsigned i = 0; i < SK_ARRAY_COUNT(gElems); i++)
-        {
-            if (!strcmp(name, gElems[i].fName))
-            {
-                match += 1;
-                SkASSERT(gElems[i].fType == t);
-                SkASSERT(gElems[i].fCount == count);
-            }
-        }
-        SkASSERT(match == 1);
-        loop += 1;
-    }
-    SkASSERT(loop == SK_ARRAY_COUNT(gElems));
-
-    SkASSERT(m1.removeS32("int"));
-    SkASSERT(m1.removeScalar("scalar"));
-    SkASSERT(m1.removeString("hello"));
-    SkASSERT(m1.removeBool("true"));
-    SkASSERT(m1.removeBool("false"));
-
-    SkASSERT(!m1.findS32("int"));
-    SkASSERT(!m1.findScalar("scalar"));
-    SkASSERT(!m1.findString("hello"));
-    SkASSERT(!m1.findBool("true"));
-    SkASSERT(!m1.findBool("false"));
-#endif
-}
-
-#endif
-
-
diff --git a/src/views/SkOSMenu.cpp b/src/views/SkOSMenu.cpp
deleted file mode 100644
index 3760ddd..0000000
--- a/src/views/SkOSMenu.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "SkOSMenu.h"
-
-static int gOSMenuCmd = 7000;
-
-SkOSMenu::SkOSMenu(const char title[])
-{
-	fTitle = title;
-}
-
-SkOSMenu::~SkOSMenu()
-{
-}
-
-int SkOSMenu::countItems() const
-{
-	return fItems.count();
-}
-
-void SkOSMenu::appendItem(const char title[], const char eventType[], int32_t eventData)
-{
-	Item* item = fItems.append();
-
-	item->fTitle	 = title;
-	item->fEventType = eventType;
-	item->fEventData = eventData;
-	item->fOSCmd	 = ++gOSMenuCmd;
-}
-
-SkEvent* SkOSMenu::createEvent(uint32_t os_cmd)
-{
-	const Item* iter = fItems.begin();
-	const Item*	stop = fItems.end();
-
-	while (iter < stop)
-	{
-		if (iter->fOSCmd == os_cmd)
-		{
-			SkEvent* evt = new SkEvent(iter->fEventType);
-			evt->setFast32(iter->fEventData);
-			return evt;
-		}
-		iter++;
-	}
-	return NULL;
-}
-
-const char* SkOSMenu::getItem(int index, uint32_t* cmdID) const
-{
-	if (cmdID)
-		*cmdID = fItems[index].fOSCmd;
-	return fItems[index].fTitle;
-}
-
diff --git a/src/views/SkParsePaint.cpp b/src/views/SkParsePaint.cpp
deleted file mode 100644
index a79f30c..0000000
--- a/src/views/SkParsePaint.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "SkParsePaint.h"
-#include "SkTSearch.h"
-#include "SkParse.h"
-#include "SkImageDecoder.h"
-#include "SkGradientShader.h"
-
-static SkShader* inflate_shader(const SkDOM& dom, const SkDOM::Node* node)
-{
-	if ((node = dom.getFirstChild(node, "shader")) == NULL)
-		return NULL;
-
-	const char* str;
-
-	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;
-
-			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;
-
-		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;
-
-			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);
-
-	SkScalar x;
-
-	if (dom.findScalar(node, "stroke-width", &x))
-		paint->setStrokeWidth(x);
-	if (dom.findScalar(node, "text-size", &x))
-		paint->setTextSize(x);
-	
-	bool	b;
-
-	SkASSERT("legacy: use is-stroke" && !dom.findBool(node, "is-frame", &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);
-
-	const char* str = dom.findAttr(node, "color");
-	if (str)
-	{
-		SkColor	c = paint->getColor();
-		if (SkParse::FindColor(str, &c))
-			paint->setColor(c);
-	}
-
-	// 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));
-	}
-
-	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/SkProgressBarView.cpp b/src/views/SkProgressBarView.cpp
deleted file mode 100644
index a9fd516..0000000
--- a/src/views/SkProgressBarView.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "SkProgressBarView.h"
-#include "SkAnimator.h"
-#include "SkWidgetViews.h"
-#include "SkTime.h"
-#include "SkSystemEventTypes.h"
-
-SkProgressBarView::SkProgressBarView()
-{
-	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
-}
-
-/*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);
-	}
-}
-	
-/*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);
-}
-
-/*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);
-}
-
-/*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);
-}
-
-void SkProgressBarView::reset()
-{
-	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);
-}
-
-void SkProgressBarView::setProgress(int progress)
-{
-	fProgress = progress;
-	SkEvent e("user");
-	e.setString("id", "setProgress");
-	e.setS32("newProgress", progress);
-	fAnim.doUserEvent(e);
-}
diff --git a/src/views/SkProgressView.cpp b/src/views/SkProgressView.cpp
deleted file mode 100644
index a34c284..0000000
--- a/src/views/SkProgressView.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include "SkWidget.h"
-#include "SkCanvas.h"
-#include "SkShader.h"
-#include "SkInterpolator.h"
-#include "SkTime.h"
-
-SkProgressView::SkProgressView(uint32_t flags) : SkView(flags), fOnShader(NULL), fOffShader(NULL)
-{
-	fValue = 0;
-	fMax = 0;
-	fInterp = NULL;
-	fDoInterp = false;
-}
-
-SkProgressView::~SkProgressView()
-{
-	delete fInterp;
-	fOnShader->safeUnref();
-	fOffShader->safeUnref();
-}
-
-void SkProgressView::setMax(U16CPU max)
-{
-	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);
-	}
-}
-
-void SkProgressView::onDraw(SkCanvas* canvas)
-{
-	if (fMax == 0)
-		return;
-
-	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);
-	}
-
-
-	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);
-
-	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;
-
-	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);
-
-	const char* s;
-
-	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);
-}
-
diff --git a/src/views/SkScrollBarView.cpp b/src/views/SkScrollBarView.cpp
deleted file mode 100644
index 2e087bd..0000000
--- a/src/views/SkScrollBarView.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "SkScrollBarView.h"
-#include "SkAnimator.h"
-#include "SkWidgetViews.h"
-#include "SkSystemEventTypes.h"
-#include "SkTime.h"
-
-//see SkProgressBarView.cpp
-//#include "SkWidgetViews.cpp"
-
-SkScrollBarView::SkScrollBarView()
-{
-	fAnim.setHostEventSink(this);
-	init_skin_anim(kScroll_SkinEnum, &fAnim);
-
-	fTotalLength = 0;
-	fStartPoint = 0;
-	fShownLength = 0;
-
-	this->adjust();
-}
-
-void SkScrollBarView::setStart(unsigned start)
-{
-	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 (fShownLength != shown)
-	{
-		fShownLength = shown;
-		this->adjust();
-	}
-}
-
-void SkScrollBarView::setTotal(unsigned total)
-{
-	if ((int)total < 0)
-		total = 0;
-
-	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);
-}
-
-/*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);
-}
-
-/*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);
-	}
-}
-
-/*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;
-	}
-
-	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);
-}
-
diff --git a/src/views/SkStackViewLayout.cpp b/src/views/SkStackViewLayout.cpp
deleted file mode 100644
index ae2e9e8..0000000
--- a/src/views/SkStackViewLayout.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-#include "SkStackViewLayout.h"
-
-SkStackViewLayout::SkStackViewLayout()
-{
-	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);
-}
-
-void SkStackViewLayout::getMargin(SkRect* margin) const
-{
-	if (margin)
-		*margin = fMargin;
-}
-
-void SkStackViewLayout::setMargin(const SkRect& margin)
-{
-	fMargin = margin;
-}
-
-void SkStackViewLayout::setSpacer(SkScalar spacer)
-{
-	fSpacer = spacer;
-}
-
-void SkStackViewLayout::setPack(Pack pack)
-{
-	SkASSERT((unsigned)pack < kPackCount);
-	fPack = SkToU8(pack);
-}
-
-void SkStackViewLayout::setAlign(Align align)
-{
-	SkASSERT((unsigned)align < kAlignCount);
-	fAlign = SkToU8(align);
-}
-
-void SkStackViewLayout::setRound(bool r)
-{
-	fRound = SkToU8(r);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-typedef SkScalar (*AlignProc)(SkScalar childLimit, SkScalar parentLimit);
-typedef SkScalar (SkView::*GetSizeProc)() const;
-typedef void (SkView::*SetLocProc)(SkScalar coord);
-typedef void (SkView::*SetSizeProc)(SkScalar coord);
-
-static SkScalar left_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; }
-static SkScalar center_align_proc(SkScalar childLimit, SkScalar parentLimit) { return SkScalarHalf(parentLimit - childLimit); }
-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
-*/
-static SkScalar compute_children_limit(SkView* parent, GetSizeProc sizeProc, int* count,
-									   uint32_t flexMask, int* flexCount)
-{
-	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;
-}
-
-void SkStackViewLayout::onLayoutChildren(SkView* parent)
-{
-	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;
-
-	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;
-
-		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;
-
-		mainGetSizeP	= &SkView::height;
-		crossGetSizeP	= &SkView::width;
-		mainLocP	= &SkView::setLocY;
-		crossLocP	= &SkView::setLocX;
-
-		mainSetSizeP  = &SkView::setHeight;
-		crossSetSizeP = &SkView::setWidth;
-
-		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);
-
-	if (childCount == 0)
-		return;
-
-	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;
-
-	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);
-
-		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);
-	}
-#else
-	#define assert_no_attr(dom, node, attr)
-#endif
-
-void SkStackViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	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 (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 ((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");
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-
-SkFillViewLayout::SkFillViewLayout()
-{
-	fMargin.setEmpty();
-}
-
-void SkFillViewLayout::getMargin(SkRect* r) const
-{
-	if (r)
-		*r = fMargin;
-}
-
-void SkFillViewLayout::setMargin(const SkRect& margin)
-{
-	fMargin = margin;
-}
-
-void SkFillViewLayout::onLayoutChildren(SkView* parent)
-{
-	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);
-	}
-}
-
-void SkFillViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-	(void)dom.findScalars(node, "margin", (SkScalar*)&fMargin, 4);
-}
-
diff --git a/src/views/SkStaticTextView.cpp b/src/views/SkStaticTextView.cpp
deleted file mode 100644
index 8fb8bc1..0000000
--- a/src/views/SkStaticTextView.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#include "SkWidgetViews.h"
-#include "SkTextBox.h"
-
-#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);
-}
-#else
-    #define assert_no_attr(dom, node, attr)
-#endif
-
-SkStaticTextView::SkStaticTextView()
-{
-	fMargin.set(0, 0);
-	fMode = kFixedSize_Mode;
-	fSpacingAlign = SkTextBox::kStart_SpacingAlign;
-	
-//	init_skin_paint(kStaticText_SkinEnum, &fPaint);
-}
-
-SkStaticTextView::~SkStaticTextView()
-{
-}
-
-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;
-
-		this->setHeight(lines * fPaint.getFontSpacing() + fMargin.fY * 2);
-	}
-}
-
-void SkStaticTextView::setMode(Mode mode)
-{
-	SkASSERT((unsigned)mode < kModeCount);
-
-	if (fMode != mode)
-	{
-		fMode = SkToU8(mode);
-		this->computeSize();
-	}
-}
-
-void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
-{
-	fSpacingAlign = SkToU8(align);
-	this->inval(NULL);
-}
-
-void SkStaticTextView::getMargin(SkPoint* margin) const
-{
-	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);
-	}
-}
-
-size_t SkStaticTextView::getText(SkString* text) const
-{
-	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();
-}
-
-void SkStaticTextView::setText(const SkString& text)
-{
-	this->setText(text.c_str(), text.size());
-}
-
-void SkStaticTextView::setText(const char 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);
-	}
-}
-
-void SkStaticTextView::getPaint(SkPaint* paint) const
-{
-	if (paint)
-		*paint = fPaint;
-}
-
-void SkStaticTextView::setPaint(const SkPaint& paint)
-{
-	if (fPaint != paint)
-	{
-		fPaint = paint;
-		this->computeSize();
-		this->inval(NULL);
-	}
-}
-
-void SkStaticTextView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	if (fText.isEmpty())
-		return;
-
-	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);
-}
-
-void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-#if 0
-	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");
-
-	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");
-
-	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)
-	{
-		inflate_paint(dom, node, &fPaint);
-	}
-#endif
-}
-
diff --git a/src/views/SkTagList.cpp b/src/views/SkTagList.cpp
deleted file mode 100644
index 4576ce6..0000000
--- a/src/views/SkTagList.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/* libs/graphics/views/SkTagList.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkTagList.h"
-
-SkTagList::~SkTagList()
-{
-}
-
-SkTagList* SkTagList::Find(SkTagList* rec, U8CPU tag)
-{
-    SkASSERT(tag < kSkTagListCount);
-
-    while (rec != NULL)
-    {
-        if (rec->fTag == tag)
-            break;
-        rec = rec->fNext;
-    }
-    return rec;
-}
-
-void SkTagList::DeleteTag(SkTagList** head, U8CPU tag)
-{
-    SkASSERT(tag < kSkTagListCount);
-
-    SkTagList* rec = *head;
-    SkTagList* prev = NULL;
-
-    while (rec != NULL)
-    {
-        SkTagList* next = rec->fNext;
-
-        if (rec->fTag == tag)
-        {
-            if (prev)
-                prev->fNext = next;
-            else
-                *head = next;
-            delete rec;
-            break;
-        }
-        prev = rec;
-        rec = next;
-    }
-}
-
-void SkTagList::DeleteAll(SkTagList* rec)
-{
-    while (rec)
-    {
-        SkTagList* next = rec->fNext;
-        delete rec;
-        rec = next;
-    }
-}
-
diff --git a/src/views/SkTagList.h b/src/views/SkTagList.h
deleted file mode 100644
index 5f428e4..0000000
--- a/src/views/SkTagList.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* libs/graphics/views/SkTagList.h
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#ifndef SkTagList_DEFINED
-#define SkTagList_DEFINED
-
-#include "SkTypes.h"
-
-enum SkTagListEnum {
-    kListeners_SkTagList,
-    kViewLayout_SkTagList,
-    kViewArtist_SkTagList,
-
-    kSkTagListCount
-};
-
-struct SkTagList {
-    SkTagList*  fNext;
-    uint16_t    fExtra16;
-    uint8_t     fExtra8;
-    uint8_t     fTag;
-
-    SkTagList(U8CPU tag) : fTag(SkToU8(tag))
-    {
-        SkASSERT(tag < kSkTagListCount);
-        fNext       = NULL;
-        fExtra16    = 0;
-        fExtra8     = 0;
-    }
-    virtual ~SkTagList();
-
-    static SkTagList*   Find(SkTagList* head, U8CPU tag);
-    static void         DeleteTag(SkTagList** headptr, U8CPU tag);
-    static void         DeleteAll(SkTagList* head);
-};
-
-#endif
diff --git a/src/views/SkTextBox.cpp b/src/views/SkTextBox.cpp
deleted file mode 100644
index 0e31ac6..0000000
--- a/src/views/SkTextBox.cpp
+++ /dev/null
@@ -1,237 +0,0 @@
-/* libs/graphics/views/SkTextBox.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "SkTextBox.h"
-#include "../core/SkGlyphCache.h"
-#include "SkUtils.h"
-#include "SkAutoKern.h"
-
-static inline int is_ws(int c)
-{
-    return !((c - 1) >> 5);
-}
-
-static size_t linebreak(const char text[], const char stop[], const SkPaint& paint, SkScalar margin)
-{
-    const char* start = text;
-
-    SkAutoGlyphCache    ac(paint, NULL);
-    SkGlyphCache*       cache = ac.getCache();
-    SkFixed             w = 0;
-    SkFixed             limit = SkScalarToFixed(margin);
-    SkAutoKern          autokern;
-
-    const char* word_start = text;
-    int         prevWS = true;
-
-    while (text < stop)
-    {
-        const char* prevText = text;
-        SkUnichar   uni = SkUTF8_NextUnichar(&text);
-        int         currWS = is_ws(uni);
-        const SkGlyph&  glyph = cache->getUnicharMetrics(uni);
-
-        if (!currWS && prevWS)
-            word_start = prevText;
-        prevWS = currWS;
-
-        w += autokern.adjust(glyph) + glyph.fAdvanceX;
-        if (w > limit)
-        {
-            if (currWS) // eat the rest of the whitespace
-            {
-                while (text < stop && is_ws(SkUTF8_ToUnichar(text)))
-                    text += SkUTF8_CountUTF8Bytes(text);
-            }
-            else    // backup until a whitespace (or 1 char)
-            {
-                if (word_start == start)
-                {
-                    if (prevText > start)
-                        text = prevText;
-                }
-                else
-                    text = word_start;
-            }
-            break;
-        }
-    }
-    return text - start;
-}
-
-int SkTextLineBreaker::CountLines(const char text[], size_t len, const SkPaint& paint, SkScalar width)
-{
-    const char* stop = text + len;
-    int         count = 0;
-
-    if (width > 0)
-    {
-        do {
-            count += 1;
-            text += linebreak(text, stop, paint, width);
-        } while (text < stop);
-    }
-    return count;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-SkTextBox::SkTextBox()
-{
-    fBox.setEmpty();
-    fSpacingMul = SK_Scalar1;
-    fSpacingAdd = 0;
-    fMode = kLineBreak_Mode;
-    fSpacingAlign = kStart_SpacingAlign;
-}
-
-void SkTextBox::setMode(Mode mode)
-{
-    SkASSERT((unsigned)mode < kModeCount);
-    fMode = SkToU8(mode);
-}
-
-void SkTextBox::setSpacingAlign(SpacingAlign align)
-{
-    SkASSERT((unsigned)align < kSpacingAlignCount);
-    fSpacingAlign = SkToU8(align);
-}
-
-void SkTextBox::getBox(SkRect* box) const
-{
-    if (box)
-        *box = fBox;
-}
-
-void SkTextBox::setBox(const SkRect& box)
-{
-    fBox = box;
-}
-
-void SkTextBox::setBox(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom)
-{
-    fBox.set(left, top, right, bottom);
-}
-
-void SkTextBox::getSpacing(SkScalar* mul, SkScalar* add) const
-{
-    if (mul)
-        *mul = fSpacingMul;
-    if (add)
-        *add = fSpacingAdd;
-}
-
-void SkTextBox::setSpacing(SkScalar mul, SkScalar add)
-{
-    fSpacingMul = mul;
-    fSpacingAdd = add;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-void SkTextBox::draw(SkCanvas* canvas, const char text[], size_t len, const SkPaint& paint)
-{
-    SkASSERT(canvas && &paint && (text || len == 0));
-
-    SkScalar marginWidth = fBox.width();
-
-    if (marginWidth <= 0 || len == 0)
-        return;
-
-    const char* textStop = text + len;
-
-    SkScalar                x, y, scaledSpacing, height, fontHeight;
-    SkPaint::FontMetrics    metrics;
-
-    switch (paint.getTextAlign()) {
-    case SkPaint::kLeft_Align:
-        x = 0;
-        break;
-    case SkPaint::kCenter_Align:
-        x = SkScalarHalf(marginWidth);
-        break;
-    default:
-        x = marginWidth;
-        break;
-    }
-    x += fBox.fLeft;
-
-    fontHeight = paint.getFontMetrics(&metrics);
-    scaledSpacing = SkScalarMul(fontHeight, fSpacingMul) + fSpacingAdd;
-    height = fBox.height();
-
-    //  compute Y position for first line
-    {
-        SkScalar textHeight = fontHeight;
-
-        if (fMode == kLineBreak_Mode && fSpacingAlign != kStart_SpacingAlign)
-        {
-            int count = SkTextLineBreaker::CountLines(text, textStop - text, paint, marginWidth);
-            SkASSERT(count > 0);
-            textHeight += scaledSpacing * (count - 1);
-        }
-
-        switch (fSpacingAlign) {
-        case kStart_SpacingAlign:
-            y = 0;
-            break;
-        case kCenter_SpacingAlign:
-            y = SkScalarHalf(height - textHeight);
-            break;
-        default:
-            SkASSERT(fSpacingAlign == kEnd_SpacingAlign);
-            y = height - textHeight;
-            break;
-        }
-        y += fBox.fTop - metrics.fAscent;
-    }
-
-    for (;;)
-    {
-        len = linebreak(text, textStop, paint, marginWidth);
-        if (y + metrics.fDescent + metrics.fLeading > 0)
-            canvas->drawText(text, len, x, y, paint);
-        text += len;
-        if (text >= textStop)
-            break;
-        y += scaledSpacing;
-        if (y + metrics.fAscent >= height)
-            break;
-    } 
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkTextBox::setText(const char text[], size_t len, const SkPaint& paint) {
-    fText = text;
-    fLen = len;
-    fPaint = &paint;
-}
-
-void SkTextBox::draw(SkCanvas* canvas) {
-    this->draw(canvas, fText, fLen, *fPaint);
-}
-
-int SkTextBox::countLines() const {
-    return SkTextLineBreaker::CountLines(fText, fLen, *fPaint, fBox.width());
-}
-
-SkScalar SkTextBox::getTextHeight() const {
-    SkScalar spacing = SkScalarMul(fPaint->getTextSize(), fSpacingMul) + fSpacingAdd;
-    return this->countLines() * spacing;
-}
-
diff --git a/src/views/SkView.cpp b/src/views/SkView.cpp
deleted file mode 100644
index 7969d3d..0000000
--- a/src/views/SkView.cpp
+++ /dev/null
@@ -1,793 +0,0 @@
-#include "SkView.h"
-#include "SkCanvas.h"
-
-////////////////////////////////////////////////////////////////////////
-
-SkView::SkView(uint32_t flags) : fFlags(SkToU8(flags))
-{
-	fWidth = fHeight = 0;
-	fLoc.set(0, 0);
-	fParent = fFirstChild = fNextSibling = fPrevSibling = NULL;
-	
-	fContainsFocus = 0;
-}
-
-SkView::~SkView()
-{
-	this->detachAllChildren();
-}
-
-void SkView::setFlags(uint32_t flags)
-{
-	SkASSERT((flags & ~kAllFlagMasks) == 0);
-
-	uint32_t diff = fFlags ^ flags;
-
-	if (diff & kVisible_Mask)
-		this->inval(NULL);
-
-	fFlags = SkToU8(flags);
-
-	if (diff & kVisible_Mask)
-	{
-		this->inval(NULL);
-	}
-}
-
-void SkView::setVisibleP(bool pred)
-{
-	this->setFlags(SkSetClearShift(fFlags, pred, kVisible_Shift));
-}
-
-void SkView::setEnabledP(bool pred)
-{
-	this->setFlags(SkSetClearShift(fFlags, pred, kEnabled_Shift));
-}
-
-void SkView::setFocusableP(bool pred)
-{
-	this->setFlags(SkSetClearShift(fFlags, pred, kFocusable_Shift));
-}
-
-void SkView::setClipToBounds(bool pred) {
-    this->setFlags(SkSetClearShift(fFlags, !pred, kNoClip_Shift));
-}
-
-void SkView::setSize(SkScalar width, SkScalar height)
-{
-	width = SkMaxScalar(0, width);
-	height = SkMaxScalar(0, height);
-
-	if (fWidth != width || fHeight != height)
-	{
-		this->inval(NULL);
-		fWidth = width;
-		fHeight = height;
-		this->inval(NULL);
-		this->onSizeChange();
-		this->invokeLayout();
-	}
-}
-
-void SkView::setLoc(SkScalar x, SkScalar y)
-{
-	if (fLoc.fX != x || fLoc.fY != y)
-	{
-		this->inval(NULL);
-		fLoc.set(x, y);
-		this->inval(NULL);
-	}
-}
-
-void SkView::offset(SkScalar dx, SkScalar dy)
-{
-	if (dx || dy)
-		this->setLoc(fLoc.fX + dx, fLoc.fY + dy);
-}
-
-void SkView::draw(SkCanvas* canvas)
-{
-	if (fWidth && fHeight && this->isVisible())
-	{
-		SkRect	r;
-		r.set(fLoc.fX, fLoc.fY, fLoc.fX + fWidth, fLoc.fY + fHeight);
-		if (this->isClipToBounds() &&
-            canvas->quickReject(r, SkCanvas::kBW_EdgeType)) {
-                return;
-        }
-
-		SkAutoCanvasRestore	as(canvas, true);
-
-        if (this->isClipToBounds()) {
-            canvas->clipRect(r);
-        }
-		canvas->translate(fLoc.fX, fLoc.fY);
-
-        if (fParent) {
-            fParent->beforeChild(this, canvas);
-        }
-
-        int sc = canvas->save();
-		this->onDraw(canvas);
-        canvas->restoreToCount(sc);
-
-        if (fParent) {
-            fParent->afterChild(this, canvas);
-        }
-        
-		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;
-    SkRect storage;
-
-	for (;;) {
-        if (!view->isVisible()) {
-            return;
-        }
-        if (view->isClipToBounds()) {
-            SkRect bounds;
-            view->getLocalBounds(&bounds);
-            if (rect && !bounds.intersect(*rect)) {
-                return;
-            }
-            storage = bounds;
-            rect = &storage;
-        }
-        if (view->handleInval(rect)) {
-            return;
-        }
-
-		SkView* parent = view->fParent;
-        if (parent == NULL) {
-            return;
-        }
-
-        if (rect) {
-            rect->offset(view->fLoc.fX, view->fLoc.fY);
-        }
-        view = parent;
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-bool SkView::setFocusView(SkView* fv)
-{
-	SkView* view = this;
-	
-	do {
-		if (view->onSetFocusView(fv))
-			return true;
-	} while ((view = view->fParent) != NULL);
-	return false;
-}
-
-SkView* SkView::getFocusView() const
-{
-	SkView*			focus = NULL;
-	const SkView*	view = this;
-	do {
-		if (view->onGetFocusView(&focus))
-			break;
-	} while ((view = view->fParent) != NULL);
-	return focus;
-}
-
-bool SkView::hasFocus() const
-{
-	return this == this->getFocusView();
-}
-
-bool SkView::acceptFocus()
-{
-	return this->isFocusable() && this->setFocusView(this);
-}
-
-/*
-	Try to give focus to this view, or its children
-*/
-SkView* SkView::acceptFocus(FocusDirection dir)
-{
-	if (dir == kNext_FocusDirection)
-	{
-		if (this->acceptFocus())
-			return this;
-
-		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;
-		while ((child = iter.next()) != NULL)
-			if ((focus = child->acceptFocus(dir)) != NULL)
-				return focus;
-
-		if (this->acceptFocus())
-			return this;
-	}
-
-	return NULL;
-}
-
-SkView* SkView::moveFocus(FocusDirection dir)
-{
-	SkView* focus = this->getFocusView();
-
-	if (focus == NULL)
-	{	// start with the root
-		focus = this;
-		while (focus->fParent)
-			focus = focus->fParent;
-	}
-
-	SkView*	child, *parent;
-
-	if (dir == kNext_FocusDirection)
-	{
-		parent = focus;
-		child = focus->fFirstChild;
-		if (child)
-			goto FIRST_CHILD;
-		else
-			goto NEXT_SIB;
-
-		do {
-			while (child != parent->fFirstChild)
-			{
-	FIRST_CHILD:
-				if ((focus = child->acceptFocus(dir)) != NULL)
-					return focus;
-				child = child->fNextSibling;
-			}
-	NEXT_SIB:
-			child = parent->fNextSibling;
-			parent = parent->fParent;
-		} while (parent != NULL);
-	}
-	else	// prevfocus
-	{
-		parent = focus->fParent;
-		if (parent == NULL)	// we're the root
-			return focus->acceptFocus(dir);
-		else
-		{
-			child = focus;
-			while (parent)
-			{
-				while (child != parent->fFirstChild)
-				{
-					child = child->fPrevSibling;
-					if ((focus = child->acceptFocus(dir)) != NULL)
-						return focus;
-				}
-				if (parent->acceptFocus())
-					return parent;
-
-				child = parent;
-				parent = parent->fParent;
-			}
-		}
-	}
-	return NULL;
-}
-
-void SkView::onFocusChange(bool gainFocusP)
-{
-	this->inval(NULL);
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-SkView::Click::Click(SkView* target)
-{
-	SkASSERT(target);
-	fTargetID = target->getSinkID();
-	fType = NULL;
-	fWeOwnTheType = false;
-}
-
-SkView::Click::~Click()
-{
-	this->resetType();
-}
-
-void SkView::Click::resetType()
-{
-	if (fWeOwnTheType)
-	{
-		sk_free(fType);
-		fWeOwnTheType = false;
-	}
-	fType = NULL;
-}
-
-bool SkView::Click::isType(const char type[]) const
-{
-	const char* t = fType;
-
-	if (type == t)
-		return true;
-
-	if (type == NULL)
-		type = "";
-	if (t == NULL)
-		t = "";
-	return !strcmp(t, type);
-}
-
-void SkView::Click::setType(const char type[])
-{
-	this->resetType();
-	fType = (char*)type;
-}
-
-void SkView::Click::copyType(const char type[])
-{
-	if (fType != type)
-	{
-		this->resetType();
-		if (type)
-		{
-			size_t	len = strlen(type) + 1;
-			fType = (char*)sk_malloc_throw(len);
-			memcpy(fType, type, len);
-			fWeOwnTheType = true;
-		}
-	}
-}
-
-SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y)
-{
-	if (x < 0 || y < 0 || x >= fWidth || y >= fHeight) {
-		return false;
-    }
-
-    if (this->onSendClickToChildren(x, y)) {
-        F2BIter	iter(this);
-        SkView*	child;
-
-        while ((child = iter.next()) != NULL)
-        {
-            Click* click = child->findClickHandler(x - child->fLoc.fX,
-                                                   y - child->fLoc.fY);
-            if (click) {
-                return click;
-            }
-        }
-    }
-	return this->onFindClickHandler(x, y);
-}
-
-void SkView::DoClickDown(Click* click, int x, int y)
-{
-	SkASSERT(click);
-
-	SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
-	if (target == NULL)
-		return;
-
-	click->fIOrig.set(x, y);
-	click->fICurr = click->fIPrev = click->fIOrig;
-
-	click->fOrig.iset(x, y);
-	target->globalToLocal(&click->fOrig);
-	click->fPrev = click->fCurr = click->fOrig;
-
-	click->fState = Click::kDown_State;
-	target->onClick(click);
-}
-
-void SkView::DoClickMoved(Click* click, int x, int y)
-{
-	SkASSERT(click);
-
-	SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
-	if (target == NULL)
-		return;
-
-	click->fIPrev = click->fICurr;
-	click->fICurr.set(x, y);
-
-	click->fPrev = click->fCurr;
-	click->fCurr.iset(x, y);
-	target->globalToLocal(&click->fCurr);
-
-	click->fState = Click::kMoved_State;
-	target->onClick(click);
-}
-
-void SkView::DoClickUp(Click* click, int x, int y)
-{
-	SkASSERT(click);
-
-	SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
-	if (target == NULL)
-		return;
-
-	click->fIPrev = click->fICurr;
-	click->fICurr.set(x, y);
-
-	click->fPrev = click->fCurr;
-	click->fCurr.iset(x, y);
-	target->globalToLocal(&click->fCurr);
-
-	click->fState = Click::kUp_State;
-	target->onClick(click);
-}
-
-//////////////////////////////////////////////////////////////////////
-
-void SkView::invokeLayout() {
-	SkView::Layout* layout = this->getLayout();
-
-	if (layout) {
-		layout->layoutChildren(this);
-    }
-}
-
-void SkView::onDraw(SkCanvas* canvas) {
-	Artist* artist = this->getArtist();
-
-	if (artist) {
-		artist->draw(this, canvas);
-    }
-}
-
-void SkView::onSizeChange() {}
-
-bool SkView::onSendClickToChildren(SkScalar x, SkScalar y) {
-    return true;
-}
-
-SkView::Click* SkView::onFindClickHandler(SkScalar x, SkScalar y) {
-	return NULL;
-}
-
-bool SkView::onClick(Click*) {
-	return false;
-}
-
-bool SkView::handleInval(const SkRect*) {
-	return false;
-}
-
-//////////////////////////////////////////////////////////////////////
-
-void SkView::getLocalBounds(SkRect* bounds) const
-{
-	if (bounds)
-		bounds->set(0, 0, fWidth, fHeight);
-}
-
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
-
-void SkView::detachFromParent_NoLayout()
-{
-	if (fParent == NULL)
-		return;
-
-	if (fContainsFocus)
-		(void)this->setFocusView(NULL);
-
-	this->inval(NULL);
-
-	SkView*	next = NULL;
-
-	if (fNextSibling != this)	// do we have any siblings
-	{
-		fNextSibling->fPrevSibling = fPrevSibling;
-		fPrevSibling->fNextSibling = fNextSibling;
-		next = fNextSibling;
-	}
-
-	if (fParent->fFirstChild == this)
-		fParent->fFirstChild = next;
-
-	fParent = fNextSibling = fPrevSibling = NULL;
-
-	this->unref();
-}
-
-void SkView::detachFromParent()
-{
-	SkView* parent = fParent;
-
-	if (parent)
-	{
-		this->detachFromParent_NoLayout();
-		parent->invokeLayout();
-	}
-}
-
-SkView* SkView::attachChildToBack(SkView* child)
-{
-	SkASSERT(child != this);
-
-	if (child == NULL || fFirstChild == child)
-		goto DONE;
-
-	child->ref();
-	child->detachFromParent_NoLayout();
-
-	if (fFirstChild == NULL)
-	{
-		child->fNextSibling = child;
-		child->fPrevSibling = child;
-	}
-	else
-	{
-		child->fNextSibling = fFirstChild;
-		child->fPrevSibling = fFirstChild->fPrevSibling;
-		fFirstChild->fPrevSibling->fNextSibling = child;
-		fFirstChild->fPrevSibling = child;
-	}
-
-	fFirstChild = child;
-	child->fParent = this;
-	child->inval(NULL);
-
-	this->invokeLayout();
-DONE:
-	return child;
-}
-
-SkView* SkView::attachChildToFront(SkView* child)
-{
-	SkASSERT(child != this);
-
-	if (child == NULL || fFirstChild && fFirstChild->fPrevSibling == child)
-		goto DONE;
-
-	child->ref();
-	child->detachFromParent_NoLayout();
-
-	if (fFirstChild == NULL)
-	{
-		fFirstChild = child;
-		child->fNextSibling = child;
-		child->fPrevSibling = child;
-	}
-	else
-	{
-		child->fNextSibling = fFirstChild;
-		child->fPrevSibling = fFirstChild->fPrevSibling;
-		fFirstChild->fPrevSibling->fNextSibling = child;
-		fFirstChild->fPrevSibling = child;
-	}
-
-	child->fParent = this;
-	child->inval(NULL);
-
-	this->invokeLayout();
-DONE:
-	return child;
-}
-
-void SkView::detachAllChildren()
-{
-	while (fFirstChild)
-		fFirstChild->detachFromParent_NoLayout();
-}
-
-void SkView::globalToLocal(SkScalar x, SkScalar y, SkPoint* local) const
-{
-	SkASSERT(this);
-
-	if (local)
-	{
-		const SkView* view = this;
-		while (view)
-		{
-			x -= view->fLoc.fX;
-			y -= view->fLoc.fY;
-			view = view->fParent;
-		}
-		local->set(x, y);
-	}
-}
-
-//////////////////////////////////////////////////////////////////
-
-/*	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)
-{
-	SkScalar x, y;
-
-	x = this->locX();
-	y = this->locY();
-	(void)dom.findScalar(node, "x", &x);
-	(void)dom.findScalar(node, "y", &y);
-	this->setLoc(x, y);
-
-	x = this->width();
-	y = this->height();
-	(void)dom.findScalar(node, "width", &x);
-	(void)dom.findScalar(node, "height", &y);
-	this->setSize(x, y);
-
-	// inflate the flags
-
-	static const char* gFlagNames[] = {
-		"visible", "enabled", "focusable", "flexH", "flexV"
-	};
-	SkASSERT(SK_ARRAY_COUNT(gFlagNames) == kFlagShiftCount);
-
-	bool     b;
-	uint32_t flags = this->getFlags();
-	for (unsigned i = 0; i < SK_ARRAY_COUNT(gFlagNames); i++)
-		if (dom.findBool(node, gFlagNames[i], &b))
-			flags = SkSetClearShift(flags, b, i);
-	this->setFlags(flags);
-}
-
-void SkView::inflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->onInflate(dom, node);
-}
-
-void SkView::onPostInflate(const SkTDict<SkView*>&)
-{
-	// override in subclass as needed
-}
-
-void SkView::postInflate(const SkTDict<SkView*>& dict)
-{
-	this->onPostInflate(dict);
-
-	B2FIter	iter(this);
-	SkView*	child;
-	while ((child = iter.next()) != NULL)
-		child->postInflate(dict);
-}
-
-//////////////////////////////////////////////////////////////////
-
-SkView* SkView::sendEventToParents(const SkEvent& evt)
-{
-	SkView* parent = fParent;
-    
-	while (parent)
-	{
-		if (parent->doEvent(evt))
-			return parent;
-		parent = parent->fParent;
-	}
-	return NULL;
-}
-
-SkView* SkView::sendQueryToParents(SkEvent* evt) {
-	SkView* parent = fParent;
-    
-	while (parent) {
-		if (parent->doQuery(evt)) {
-			return parent;
-        }
-		parent = parent->fParent;
-	}
-	return NULL;
-}
-
-//////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////
-
-SkView::F2BIter::F2BIter(const SkView* parent)
-{
-	fFirstChild = parent ? parent->fFirstChild : NULL;
-	fChild = fFirstChild ? fFirstChild->fPrevSibling : NULL;
-}
-
-SkView*	SkView::F2BIter::next()
-{
-	SkView* curr = fChild;
-
-	if (fChild)
-	{
-		if (fChild == fFirstChild)
-			fChild = NULL;
-		else
-			fChild = fChild->fPrevSibling;
-	}
-	return curr;
-}
-
-SkView::B2FIter::B2FIter(const SkView* parent)
-{
-	fFirstChild = parent ? parent->fFirstChild : NULL;
-	fChild = fFirstChild;
-}
-
-SkView*	SkView::B2FIter::next()
-{
-	SkView* curr = fChild;
-
-	if (fChild)
-	{
-		SkView* next = fChild->fNextSibling;
-		if (next == fFirstChild)
-			next = NULL;
-		fChild = next;
-	}
-	return curr;
-}
-
-//////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-
-static inline void show_if_nonzero(const char name[], SkScalar value)
-{
-	if (value)
-		SkDebugf("%s=\"%g\"", name, value/65536.);
-}
-
-static void tab(int level)
-{
-	for (int i = 0; i < level; i++)
-		SkDebugf("    ");
-}
-
-static void dumpview(const SkView* view, int level, bool recurse)
-{
-	tab(level);
-
-	SkDebugf("<view");
-	show_if_nonzero(" x", view->locX());
-	show_if_nonzero(" y", view->locY());
-	show_if_nonzero(" width", view->width());
-	show_if_nonzero(" height", view->height());
-
-	if (recurse)
-	{
-		SkView::B2FIter	iter(view);
-		SkView*			child;
-		bool			noChildren = true;
-
-		while ((child = iter.next()) != NULL)
-		{
-			if (noChildren)
-				SkDebugf(">\n");
-			noChildren = false;
-			dumpview(child, level + 1, true);
-		}
-
-		if (!noChildren)
-		{
-			tab(level);
-			SkDebugf("</view>\n");
-		}
-		else
-			goto ONELINER;
-	}
-	else
-	{
-	ONELINER:
-		SkDebugf(" />\n");
-	}
-}
-
-void SkView::dump(bool recurse) const
-{
-	dumpview(this, 0, recurse);
-}
-
-#endif
diff --git a/src/views/SkViewInflate.cpp b/src/views/SkViewInflate.cpp
deleted file mode 100644
index 8f5489d..0000000
--- a/src/views/SkViewInflate.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "SkViewInflate.h"
-#include "SkView.h"
-#include <stdio.h>
-
-SkViewInflate::SkViewInflate() : fIDs(kMinIDStrAlloc), fStrings(kMinIDStrAlloc)
-{
-}
-
-SkViewInflate::~SkViewInflate()
-{
-}
-
-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 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, "broadcastTo") && (target = dom.findAttr(child, "target")) != NULL)
-				this->addIDStr(&fBroadcastTo, parent, target);
-		}
-		child = dom.getNextSibling(child);
-	}
-
-	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);
-}
-
-SkView* SkViewInflate::inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root)
-{
-	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);
-
-	// 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());
-		}
-	}
-
-	// 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);
-
-	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;
-}
-
-SkView* SkViewInflate::createView(const SkDOM& dom, const SkDOM::Node* node)
-{
-	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);
-}
-
-#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);
-
-	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
deleted file mode 100644
index b03ca8c..0000000
--- a/src/views/SkViewPriv.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "SkViewPriv.h"
-
-//////////////////////////////////////////////////////////////////////
-
-void SkView::Artist::draw(SkView* view, SkCanvas* 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);
-}
-
-void SkView::Artist::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	// 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);
-
-	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 (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);
-}
-
-void SkView::Layout::inflate(const SkDOM& dom, const SkDOM::Node* 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
-}
-
-SkView::Layout* SkView::getLayout() const
-{
-	Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
-	SkASSERT(rec == NULL || 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 (rec)
-			SkRefCnt_SafeAssign(rec->fLayout, obj);
-		else
-			this->addTagList(new Layout_SkTagList(obj));
-	}
-	
-	if (invokeLayoutNow)
-		this->invokeLayout();
-
-	return obj;
-}
-
diff --git a/src/views/SkViewPriv.h b/src/views/SkViewPriv.h
deleted file mode 100644
index 06ce59b..0000000
--- a/src/views/SkViewPriv.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef SkViewPriv_DEFINED
-#define SkViewPriv_DEFINED
-
-#include "SkView.h"
-#include "SkTagList.h"
-
-struct Layout_SkTagList : SkTagList {
-	SkView::Layout*	fLayout;
-
-	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;
-
-	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
deleted file mode 100644
index 4d055c4..0000000
--- a/src/views/SkWidget.cpp
+++ /dev/null
@@ -1,323 +0,0 @@
-#include "SkWidget.h"
-#include "SkCanvas.h"
-#include "SkInterpolator.h"
-#include "SkTime.h"
-#include "SkParsePaint.h"
-
-#if 0
-SkWidgetView::SkWidgetView(U32 flags) : SkView(flags)
-{
-}
-
-SkWidgetView::~SkWidgetView()
-{
-}
-
-const char* SkWidgetView::GetEventType()
-{
-	return "SkWidgetView";
-}
-
-/////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////
-
-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;
-
-		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;
-		}
-	}
-
-private:
-	SkString		fOldText;
-	SkInterpolator	fInterp;
-};
-
-SkTextView::SkTextView(U32 flags) : SkView(flags), fInterp(NULL), fDoInterp(false)
-{
-	fMargin.set(0, 0);
-}
-
-SkTextView::~SkTextView()
-{
-	delete fInterp;
-}
-
-void SkTextView::getText(SkString* str) const
-{
-	if (str)
-		str->set(fText);
-}
-
-void SkTextView::setText(const char text[], AnimaDir 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);
-	}
-}
-
-void SkTextView::setText(const SkString& src, AnimaDir dir)
-{
-	if (fText != src)
-		this->privSetText(src, dir);
-}
-
-void SkTextView::privSetText(const SkString& src, AnimaDir dir)
-{
-	SkASSERT(fText != src);
-
-	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;
-}
-
-void SkTextView::setMargin(const SkPoint& margin)
-{
-	if (fMargin != margin)
-	{
-		fMargin = margin;
-		this->inval(NULL);
-	}
-}
-
-void SkTextView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	if (fText.size() == 0)
-		return;
-
-	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;
-	}
-
-	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);
-}
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-void SkTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-
-	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);
-
-	SkPaint_Inflate(&fPaint, dom, node);
-}
-
-//////////////////////////////////////////////////////////////////////////////////////
-
-SkSliderView::SkSliderView(U32 flags) : SkWidgetView(flags)
-{
-	fValue = 0;
-	fMax = 0;
-}
-
-static U16 actual_value(U16CPU value, U16CPU 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);
-	}
-}
-
-void SkSliderView::setValue(U16CPU value)
-{
-	if (fValue != value)
-	{
-		U16 prev = actual_value(fValue, fMax);
-		U16 next = actual_value(value, fMax);
-
-		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);
-			}
-		}
-	}
-}
-
-#include "SkGradientShader.h"
-
-static void setgrad(SkPaint* paint, const SkRect& r)
-{
-	SkPoint	pts[2];
-	SkColor	colors[2];
-
-#if 0
-	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);
-#endif
-	colors[0] = SK_ColorBLUE;
-	colors[1] = SK_ColorWHITE;
-
-	paint->setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kMirror_TileMode))->unref();
-}
-
-void SkSliderView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	U16CPU value = SkMax32(0, SkMin32(fValue, fMax));
-
-	SkRect	r;
-	SkPaint	p;
-
-	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);
-
-	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);
-#endif
-}
-
-SkView::Click* SkSliderView::onFindClickHandler(SkScalar x, SkScalar y)
-{
-	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;
-}
-
-#endif
-
diff --git a/src/views/SkWidgetViews.cpp b/src/views/SkWidgetViews.cpp
deleted file mode 100644
index 109e620..0000000
--- a/src/views/SkWidgetViews.cpp
+++ /dev/null
@@ -1,405 +0,0 @@
-#include "SkWidgetViews.h"
-#include "SkAnimator.h"
-#include "SkCanvas.h"
-#include "SkPaint.h"
-#include "SkStream.h"
-#include "SkSystemEventTypes.h"
-
-#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);
-	}
-#else
-	#define assert_no_attr(dom, node, attr)
-#endif
-/*
-I have moved this to SkWidgetViews.h
-enum SkinEnum {
-	kButton_SkinEnum,
-	kProgress_SkinEnum,
-	kScroll_SkinEnum,
-	kStaticText_SkinEnum,
-	
-	kSkinEnumCount
-};
-*/
-
-const char* get_skin_enum_path(SkinEnum se)
-{
-	SkASSERT((unsigned)se < kSkinEnumCount);
-
-	static const char* gSkinPaths[] = {
-            "common/default/default/skins/border3.xml",
-            "common/default/default/skins/button.xml",
-            "common/default/default/skins/progressBar.xml",
-            "common/default/default/skins/scrollBar.xml",
-            "common/default/default/skins/statictextpaint.xml"
-	};
-
-	return gSkinPaths[se];
-}
-
-void init_skin_anim(const char path[], SkAnimator* anim)
-{
-	SkASSERT(path && anim);
-
-	SkFILEStream	stream(path);
-
-	if (!stream.isValid())
-	{
-		SkDEBUGF(("init_skin_anim: loading skin failed <%s>\n", path));
-		sk_throw();
-	}
-
-	if (!anim->decodeStream(&stream))
-	{
-		SkDEBUGF(("init_skin_anim: decoding skin failed <%s>\n", path));
-		sk_throw();
-	}
-}
-
-void init_skin_anim(SkinEnum se, SkAnimator* anim)
-{
-	init_skin_anim(get_skin_enum_path(se), anim);
-}
-
-void init_skin_paint(SkinEnum se, SkPaint* paint)
-{
-	SkASSERT(paint);
-
-	SkAnimator	anim;
-	SkCanvas	canvas;
-	
-	init_skin_anim(se, &anim);
-	anim.draw(&canvas, paint, 0);
-}
-
-void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint)
-{
-	SkASSERT(paint);
-
-	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);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-
-SkWidgetView::SkWidgetView() : SkView(SkView::kFocusable_Mask | SkView::kEnabled_Mask)
-{
-}
-
-const char* SkWidgetView::getLabel() const
-{
-	return fLabel.c_str();
-}
-	
-void SkWidgetView::getLabel(SkString* label) const
-{
-	if (label)
-		*label = fLabel;
-}
-
-void SkWidgetView::setLabel(const char label[])
-{
-	this->setLabel(label, label ? strlen(label) : 0);
-}
-
-void SkWidgetView::setLabel(const char label[], size_t len)
-{
-	if (label == NULL && fLabel.size() != 0 || !fLabel.equals(label, len))
-	{
-		SkString	tmp(label, len);
-
-		this->onLabelChange(fLabel.c_str(), tmp.c_str());
-		fLabel.swap(tmp);
-	}
-}
-
-void SkWidgetView::setLabel(const SkString& label)
-{
-	if (fLabel != label)
-	{
-		this->onLabelChange(fLabel.c_str(), label.c_str());
-		fLabel = label;
-	}
-}
-
-bool SkWidgetView::postWidgetEvent()
-{
-	if (!fEvent.isType(""))
-	{
-		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...
-			return true;
-		}
-	}
-	return false;
-}
-
-/*virtual*/ void SkWidgetView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-
-	const char* label = dom.findAttr(node, "label");
-	if (label)
-		this->setLabel(label);
-		
-	if ((node = dom.getFirstChild(node, "event")) != NULL)
-		fEvent.inflate(dom, node);
-}
-
-/*virtual*/ void SkWidgetView::onLabelChange(const char oldLabel[], const char newLabel[])
-{
-	this->inval(NULL);
-}
-
-static const char gWidgetEventSinkIDSlotName[] = "sk-widget-sinkid-slot";
-
-/*virtual*/ bool SkWidgetView::onPrepareWidgetEvent(SkEvent* evt)
-{
-	evt->setS32(gWidgetEventSinkIDSlotName, this->getSinkID());
-	return true;
-}
-
-SkEventSinkID SkWidgetView::GetWidgetEventSinkID(const SkEvent& evt)
-{
-	int32_t	sinkID;
-	
-	return evt.findS32(gWidgetEventSinkIDSlotName, &sinkID) ? (SkEventSinkID)sinkID : 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-/*virtual*/ bool SkButtonView::onEvent(const SkEvent& evt)
-{
-	if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey)
-	{
-		this->postWidgetEvent();
-		return true;
-	}
-	return this->INHERITED::onEvent(evt);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-SkCheckButtonView::SkCheckButtonView() : fCheckState(kOff_CheckState)
-{
-}
-
-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);
-}
-
-/*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);
-}
-
-static const char gCheckStateSlotName[] = "sk-checkbutton-check-slot";
-
-/*virtual*/ bool SkCheckButtonView::onPrepareWidgetEvent(SkEvent* evt)
-{
-	// could check if we're "disabled", and return false...
-
-	evt->setS32(gCheckStateSlotName, this->getCheckState());
-	return true;
-}
-
-bool SkCheckButtonView::GetWidgetEventCheckState(const SkEvent& evt, CheckState* state)
-{
-	int32_t	state32;
-	
-	if (evt.findS32(gCheckStateSlotName, &state32))
-	{
-		if (state)
-			*state = (CheckState)state32;
-		return true;
-	}
-	return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include "SkTime.h"
-#include <stdio.h>
-
-class SkAnimButtonView : public SkButtonView {
-public:
-	SkAnimButtonView()
-	{
-		fAnim.setHostEventSink(this);
-		init_skin_anim(kButton_SkinEnum, &fAnim);
-	}
-
-protected:
-	virtual void onLabelChange(const char oldLabel[], const char newLabel[])
-	{
-		this->INHERITED::onLabelChange(oldLabel, newLabel);
-
-		SkEvent evt("user");
-		evt.setString("id", "setLabel");
-		evt.setString("LABEL", newLabel);
-		fAnim.doUserEvent(evt);
-	}
-	
-	virtual void onFocusChange(bool gainFocus)
-	{
-		this->INHERITED::onFocusChange(gainFocus);
-
-		SkEvent evt("user");
-		evt.setString("id", "setFocus");
-		evt.setS32("FOCUS", gainFocus);
-		fAnim.doUserEvent(evt);
-	}
-
-	virtual void onSizeChange()
-	{
-		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 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);
-		}
-	}
-	
-	virtual bool 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);
-	}
-	
-	virtual bool onPrepareWidgetEvent(SkEvent* evt)
-	{
-		if (this->INHERITED::onPrepareWidgetEvent(evt))
-		{
-			SkEvent	e("user");
-			e.setString("id", "handlePress");
-			(void)fAnim.doUserEvent(e);
-			return true;
-		}
-		return false;
-	}
-
-private:
-	SkAnimator	fAnim;
-	
-	typedef SkButtonView INHERITED;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////
-
-SkView* SkWidgetFactory(const char name[])
-{
-	if (name == NULL)
-		return NULL;
-	
-	// must be in the same order as the SkSkinWidgetEnum is declared
-	static const char* gNames[] = {
-		"sk-border",
-		"sk-button",
-		"sk-image",
-		"sk-list",
-		"sk-progress",
-		"sk-scroll",
-		"sk-text"
-		
-	};
-
-	for (int i = 0; i < SK_ARRAY_COUNT(gNames); i++)
-		if (!strcmp(gNames[i], name))
-			return SkWidgetFactory((SkWidgetEnum)i);
-
-	return NULL;
-}
-
-#include "SkImageView.h"
-#include "SkProgressBarView.h"
-#include "SkScrollBarView.h"
-#include "SkBorderView.h"
-
-SkView* SkWidgetFactory(SkWidgetEnum sw)
-{
-	switch (sw) {
-	case kBorder_WidgetEnum:
-		return new SkBorderView;
-	case kButton_WidgetEnum:
-		return new SkAnimButtonView;
-	case kImage_WidgetEnum:
-		return new SkImageView;
-	case kList_WidgetEnum:
-		return new SkListView;
-	case kProgress_WidgetEnum:
-		return new SkProgressBarView;
-	case kScroll_WidgetEnum:
-		return new SkScrollBarView;
-	case kText_WidgetEnum:
-		return new SkStaticTextView;
-	default:
-		SkASSERT(!"unknown enum passed to SkWidgetFactory");
-		break;
-	}
-	return NULL;
-}
diff --git a/src/views/SkWidgets.cpp b/src/views/SkWidgets.cpp
deleted file mode 100644
index dba9ab3..0000000
--- a/src/views/SkWidgets.cpp
+++ /dev/null
@@ -1,554 +0,0 @@
-#include "SkWidget.h"
-#include "SkCanvas.h"
-#include "SkKey.h"
-#include "SkParsePaint.h"
-#include "SkSystemEventTypes.h"
-#include "SkTextBox.h"
-
-#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);
-	}
-#else
-	#define assert_no_attr(dom, node, attr)
-#endif
-
-#include "SkAnimator.h"
-#include "SkTime.h"
-
-///////////////////////////////////////////////////////////////////////////////
-
-enum SkinType {
-	kPushButton_SkinType,
-	kStaticText_SkinType,
-
-	kSkinTypeCount
-};
-
-struct SkinSuite {
-	SkinSuite();
-	~SkinSuite()
-	{
-		for (int i = 0; i < kSkinTypeCount; i++)
-			delete fAnimators[i];
-	}
-
-	SkAnimator*	get(SkinType);
-
-private:
-	SkAnimator*	fAnimators[kSkinTypeCount];
-};
-
-SkinSuite::SkinSuite()
-{
-	static const char kSkinPath[] = "skins/";
-
-	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);
-
-		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;
-		}
-	}
-}
-
-SkAnimator* SkinSuite::get(SkinType st)
-{
-	SkASSERT((unsigned)st < kSkinTypeCount);
-	return fAnimators[st];
-}
-
-static SkinSuite* gSkinSuite;
-
-static SkAnimator* get_skin_animator(SkinType st)
-{
-#if 0
-	if (gSkinSuite == NULL)
-		gSkinSuite = new SkinSuite;
-	return gSkinSuite->get(st);
-#else
-	return NULL;
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkWidget::Init()
-{
-}
-
-void SkWidget::Term()
-{
-	delete gSkinSuite;
-}
-
-void SkWidget::onEnabledChange()
-{
-	this->inval(NULL);
-}
-
-void SkWidget::postWidgetEvent()
-{
-	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
-}
-
-void SkWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(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();
-}
-
-size_t SkHasLabelWidget::getLabel(char buffer[]) const
-{
-	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());
-}
-
-void SkHasLabelWidget::setLabel(const char 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();
-	}
-}
-
-void SkHasLabelWidget::onLabelChange()
-{
-	// override in subclass
-}
-
-void SkHasLabelWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-
-	const char* text = dom.findAttr(node, "label");
-	if (text)
-		this->setLabel(text);
-}
-
-/////////////////////////////////////////////////////////////////////////////////////
-
-void SkButtonWidget::setButtonState(State state)
-{
-	if (fState != state)
-	{
-		fState = state;
-		this->onButtonStateChange();
-	}
-}
-
-void SkButtonWidget::onButtonStateChange()
-{
-	this->inval(NULL);
-}
-
-void SkButtonWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node)
-{
-	this->INHERITED::onInflate(dom, node);
-
-	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);
-}
-
-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";
-}
-
-#include "SkBlurMaskFilter.h"
-#include "SkEmbossMaskFilter.h"
-
-static void create_emboss(SkPaint* paint, SkScalar radius, bool focus, bool pressed)
-{
-	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;
-
-	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();
-}
-
-void SkPushButtonWidget::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	SkString label;
-	this->getLabel(&label);
-
-	SkAnimator* anim = get_skin_animator(kPushButton_SkinType);
-
-	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()));
-
-		(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);
-
-		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());
-
-//		if (this->getButtonState() == kOn_State)
-//			p.setColor(SK_ColorRED);
-//		else
-			p.setColor(SK_ColorWHITE);
-
-		box.draw(canvas, label.c_str(), label.size(), p);
-	}
-}
-
-SkView::Click* SkPushButtonWidget::onFindClickHandler(SkScalar x, SkScalar y)
-{
-	this->acceptFocus();
-	return new Click(this);
-}
-
-bool SkPushButtonWidget::onClick(Click* click)
-{
-	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;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////
-
-SkStaticTextView::SkStaticTextView(U32 flags) : SkView(flags)
-{
-	fMargin.set(0, 0);
-	fMode = kFixedSize_Mode;
-	fSpacingAlign = SkTextBox::kStart_SpacingAlign;
-}
-
-SkStaticTextView::~SkStaticTextView()
-{
-}
-
-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;
-
-		SkScalar	before, after;
-		(void)fPaint.measureText(0, NULL, &before, &after);
-
-		this->setHeight(lines * (after - before) + fMargin.fY * 2);
-	}
-}
-
-void SkStaticTextView::setMode(Mode mode)
-{
-	SkASSERT((unsigned)mode < kModeCount);
-
-	if (fMode != mode)
-	{
-		fMode = SkToU8(mode);
-		this->computeSize();
-	}
-}
-
-void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align)
-{
-	fSpacingAlign = SkToU8(align);
-	this->inval(NULL);
-}
-
-void SkStaticTextView::getMargin(SkPoint* margin) const
-{
-	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);
-	}
-}
-
-size_t SkStaticTextView::getText(SkString* text) const
-{
-	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();
-}
-
-void SkStaticTextView::setText(const SkString& text)
-{
-	this->setText(text.c_str(), text.size());
-}
-
-void SkStaticTextView::setText(const char 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);
-	}
-}
-
-void SkStaticTextView::getPaint(SkPaint* paint) const
-{
-	if (paint)
-		*paint = fPaint;
-}
-
-void SkStaticTextView::setPaint(const SkPaint& paint)
-{
-	if (fPaint != paint)
-	{
-		fPaint = paint;
-		this->computeSize();
-		this->inval(NULL);
-	}
-}
-
-void SkStaticTextView::onDraw(SkCanvas* canvas)
-{
-	this->INHERITED::onDraw(canvas);
-
-	if (fText.isEmpty())
-		return;
-
-	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);
-}
-
-void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* 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");
-
-	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");
-
-	const char* text = dom.findAttr(node, "text");
-	if (text)
-		this->setText(text);
-
-	if ((node = dom.getFirstChild(node, "paint")) != NULL)
-		SkPaint_Inflate(&fPaint, dom, node);
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include "SkImageDecoder.h"
-
-SkBitmapView::SkBitmapView(U32 flags) : SkView(flags)
-{
-}
-
-SkBitmapView::~SkBitmapView()
-{
-}
-
-bool SkBitmapView::getBitmap(SkBitmap* bitmap) const
-{
-	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);
-	}
-}
-
-bool SkBitmapView::loadBitmapFromFile(const char path[])
-{
-	SkBitmap	bitmap;
-
-	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;
-
-		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);
-
-	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
deleted file mode 100644
index dbc1eea..0000000
--- a/src/views/SkWindow.cpp
+++ /dev/null
@@ -1,405 +0,0 @@
-#include "SkWindow.h"
-#include "SkCanvas.h"
-#include "SkDevice.h"
-#include "SkOSMenu.h"
-#include "SkSystemEventTypes.h"
-#include "SkTime.h"
-
-#define SK_EventDelayInval "\xd" "n" "\xa" "l"
-
-#define TEST_BOUNDERx
-
-#include "SkBounder.h"
-class test_bounder : public SkBounder {
-public:
-	test_bounder(const SkBitmap& bm) : fCanvas(bm) {}
-protected:
-	virtual bool onIRect(const SkIRect& r)
-	{
-		SkRect	rr;
-
-		rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop),
-				SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom));
-
-		SkPaint	p;
-
-		p.setStyle(SkPaint::kStroke_Style);
-		p.setColor(SK_ColorYELLOW);
-
-#if 0
-		rr.inset(SK_ScalarHalf, SK_ScalarHalf);
-#else
-		rr.inset(-SK_ScalarHalf, -SK_ScalarHalf);
-#endif
-
-		fCanvas.drawRect(rr, p);
-		return true;
-	}
-private:
-	SkCanvas	fCanvas;
-};
-
-SkWindow::SkWindow() : fFocusView(NULL)
-{
-	fClick = NULL;
-	fWaitingOnInval = false;
-
-#ifdef SK_BUILD_FOR_WINCE
-	fConfig = SkBitmap::kRGB_565_Config;
-#else
-	fConfig = SkBitmap::kARGB_8888_Config;
-#endif
-
-    fMatrix.reset();
-}
-
-SkWindow::~SkWindow()
-{
-	delete fClick;
-
-	fMenus.deleteAll();
-}
-
-void SkWindow::setMatrix(const SkMatrix& matrix) {
-    if (fMatrix != matrix) {
-        fMatrix = matrix;
-        this->inval(NULL);
-    }
-}
-
-void SkWindow::preConcat(const SkMatrix& matrix) {
-    SkMatrix m;
-    m.setConcat(fMatrix, matrix);
-    this->setMatrix(m);
-}
-
-void SkWindow::postConcat(const SkMatrix& matrix) {
-    SkMatrix m;
-    m.setConcat(matrix, fMatrix);
-    this->setMatrix(m);
-}
-
-void SkWindow::setConfig(SkBitmap::Config 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 (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);
-	}
-}
-
-void SkWindow::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
-{
-	fBitmap.eraseARGB(a, r, g, b);
-}
-
-void SkWindow::eraseRGB(U8CPU r, U8CPU g, U8CPU b)
-{
-	fBitmap.eraseRGB(r, g, b);
-}
-
-bool SkWindow::handleInval(const SkRect* localR)
-{
-	SkIRect	ir;
-
-    if (localR) {
-        SkRect devR;
-        SkMatrix inverse;
-        if (!fMatrix.invert(&inverse)) {
-            return false;
-        }
-        fMatrix.mapRect(&devR, *localR);
-        devR.round(&ir);
-    } else {
-        ir.set(0, 0, this->width(), this->height());
-    }
-	fDirtyRgn.op(ir, SkRegion::kUnion_Op);
-
-	this->onHandleInval(ir);
-	return true;
-}
-
-void SkWindow::forceInvalAll() {
-    fDirtyRgn.setRect(0, 0, this->width(), this->height());
-}
-
-#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-	#include <windows.h>
-	#include <gx.h>
-	extern GXDisplayProperties gDisplayProps;
-#endif
-
-#ifdef SK_SIMULATE_FAILED_MALLOC
-extern bool gEnableControlledThrow;
-#endif
-
-bool SkWindow::update(SkIRect* updateArea, SkCanvas* canvas)
-{
-	if (!fDirtyRgn.isEmpty())
-	{
-		SkBitmap bm = this->getBitmap();
-
-#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-		char* buffer = (char*)GXBeginDraw();
-		SkASSERT(buffer);
-
-		RECT	rect;
-		GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect);
-		buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch;
-
-		bm.setPixels(buffer);
-#endif
-
-		SkCanvas	rasterCanvas;
-        SkDevice*   device;
-
-        if (NULL == canvas) {
-            canvas = &rasterCanvas;
-            device = new SkDevice(canvas, bm, false);
-            canvas->setDevice(device)->unref();
-        } else {
-            canvas->setBitmapDevice(bm);
-        }
-
-		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();
-
-#ifdef TEST_BOUNDER
-		test_bounder	b(bm);
-		canvas->setBounder(&b);
-#endif
-#ifdef SK_SIMULATE_FAILED_MALLOC
-		gEnableControlledThrow = true;
-#endif
-#ifdef SK_BUILD_FOR_WIN32
-		//try {
-			this->draw(canvas);
-		//}
-		//catch (...) {
-		//}
-#else
-		this->draw(canvas);
-#endif
-#ifdef SK_SIMULATE_FAILED_MALLOC
-		gEnableControlledThrow = false;
-#endif
-#ifdef TEST_BOUNDER
-		canvas->setBounder(NULL);
-#endif
-
-#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN)
-		GXEndDraw();
-#endif
-
-		return true;
-	}
-	return false;
-}
-
-bool SkWindow::handleChar(SkUnichar uni)
-{
-	if (this->onHandleChar(uni))
-		return true;
-
-	SkView* focus = this->getFocusView();
-	if (focus == NULL)
-		focus = this;
-
-	SkEvent evt(SK_EventType_Unichar);
-	evt.setFast32(uni);
-	return focus->doEvent(evt);
-}
-
-bool SkWindow::handleKey(SkKey key)
-{
-	if (key == kNONE_SkKey)
-		return false;
-
-	if (this->onHandleKey(key))
-		return true;
-
-	// 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;
-	}
-
-	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);
-        if (focus->doEvent(evt))
-            return true;
-    }
-    return false;
-}
-
-void SkWindow::addMenu(SkOSMenu* menu)
-{
-	*fMenus.append() = menu;
-	this->onAddMenu(menu);
-}
-
-void SkWindow::setTitle(const char title[]) {
-    if (NULL == title) {
-        title = "";
-    }
-    fTitle.set(title);
-    this->onSetTitle(title);
-}
-
-bool SkWindow::handleMenu(uint32_t cmd)
-{
-	for (int i = 0; i < fMenus.count(); i++)
-	{
-		SkEvent* evt = fMenus[i]->createEvent(cmd);
-		if (evt)
-		{
-			evt->post(this->getSinkID());
-			return true;
-		}
-	}
-	return false;
-}
-
-//////////////////////////////////////////////////////////////////////
-
-bool SkWindow::onEvent(const SkEvent& evt)
-{
-	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);
-}
-
-bool SkWindow::onGetFocusView(SkView** focus) const
-{
-	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;
-}
-
-//////////////////////////////////////////////////////////////////////
-
-void SkWindow::onHandleInval(const SkIRect&)
-{
-}
-
-bool SkWindow::onHandleChar(SkUnichar)
-{
-	return false;
-}
-
-bool SkWindow::onHandleKey(SkKey key)
-{
-	return false;
-}
-
-bool SkWindow::onHandleKeyUp(SkKey key)
-{
-    return false;
-}
-
-bool SkWindow::handleClick(int x, int y, Click::State state)
-{
-	bool handled = false;
-
-	switch (state) {
-	case Click::kDown_State:
-		if (fClick)
-			delete fClick;
-		fClick = this->findClickHandler(SkIntToScalar(x), SkIntToScalar(y));
-		if (fClick)
-		{
-			SkView::DoClickDown(fClick, x, y);
-			handled = true;
-		}
-		break;
-	case Click::kMoved_State:
-		if (fClick)
-		{
-			SkView::DoClickMoved(fClick, x, y);
-			handled = true;
-		}
-		break;
-	case Click::kUp_State:
-		if (fClick)
-		{
-			SkView::DoClickUp(fClick, x, y);
-			delete fClick;
-			fClick = NULL;
-			handled = true;
-		}
-		break;
-	}
-	return handled;
-}
-
diff --git a/tests/Android.mk b/tests/Android.mk
index e1c03ec..a5611ee 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -3,24 +3,40 @@ include $(CLEAR_VARS)
 
 
 LOCAL_SRC_FILES:= \
-        BlitRowTest.cpp \
-        GeometryTest.cpp \
-        MathTest.cpp \
-        MatrixTest.cpp \
-        PackBitsTest.cpp \
-        Sk64Test.cpp \
-        StringTest.cpp \
-        Test.cpp UtilsTest.cpp \
-        PathTest.cpp \
-        SrcOverTest.cpp \
-        StreamTest.cpp \
-        SortTest.cpp \
-        PathMeasureTest.cpp
+  BitmapCopyTest.cpp \
+  BitmapGetColorTest.cpp \
+  BlitRowTest.cpp \
+  ClipCubicTest.cpp \
+  ClipStackTest.cpp \
+  ClipperTest.cpp \
+  DequeTest.cpp \
+  FillPathTest.cpp \
+  FlateTest.cpp \
+  GeometryTest.cpp \
+  InfRectTest.cpp \
+  MathTest.cpp \
+  MatrixTest.cpp \
+  PackBitsTest.cpp \
+  PaintTest.cpp \
+  ParsePathTest.cpp \
+  PathMeasureTest.cpp \
+  PathTest.cpp \
+  RefDictTest.cpp \
+  RegionTest.cpp \
+  Sk64Test.cpp \
+  SortTest.cpp \
+  SrcOverTest.cpp \
+  StreamTest.cpp \
+  StringTest.cpp \
+  Test.cpp \
+  TestSize.cpp \
+  UtilsTest.cpp \
+  XfermodeTest.cpp
 
 # The name of the file with a main function must
 # match native test's naming rule: xxx_test.cpp.
 LOCAL_SRC_FILES += \
-        skia_test.cpp
+  skia_test.cpp
 
 LOCAL_MODULE:= skia_test
 
diff --git a/tests/BitmapCopyTest.cpp b/tests/BitmapCopyTest.cpp
index be3850e..1878dfa 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -62,10 +62,14 @@ static void test_isOpaque(skiatest::Reporter* reporter, const SkBitmap& src,
     }
 }
 
-static void init_src(const SkBitmap& bitmap) {
+static void init_src(const SkBitmap& bitmap, const SkColorTable* ct) {
     SkAutoLockPixels lock(bitmap);
     if (bitmap.getPixels()) {
-        memset(bitmap.getPixels(), 4, bitmap.getSize());
+        if (ct) {
+            sk_bzero(bitmap.getPixels(), bitmap.getSize());
+        } else {
+            bitmap.eraseColor(SK_ColorWHITE);
+        }
     }
 }
 
@@ -81,6 +85,151 @@ struct Pair {
     const char*         fValid;
 };
 
+// Utility functions for copyPixelsTo()/copyPixelsFrom() tests.
+// getPixel()
+// setPixel()
+// getSkConfigName()
+// struct Coordinates
+// reportCopyVerification()
+// writeCoordPixels()
+
+// Utility function to read the value of a given pixel in bm. All
+// values converted to uint32_t for simplification of comparisons.
+uint32_t getPixel(int x, int y, const SkBitmap& bm) {
+    uint32_t val = 0;
+    uint16_t val16;
+    uint8_t val8, shift;
+    SkAutoLockPixels lock(bm);
+    const void* rawAddr = bm.getAddr(x,y);
+
+    switch (bm.getConfig()) {
+        case SkBitmap::kARGB_8888_Config:
+            memcpy(&val, rawAddr, sizeof(uint32_t));
+            break;
+        case SkBitmap::kARGB_4444_Config:
+        case SkBitmap::kRGB_565_Config:
+            memcpy(&val16, rawAddr, sizeof(uint16_t));
+            val = val16;
+            break;
+        case SkBitmap::kA8_Config:
+        case SkBitmap::kIndex8_Config:
+            memcpy(&val8, rawAddr, sizeof(uint8_t));
+            val = val8;
+            break;
+        case SkBitmap::kA1_Config:
+            memcpy(&val8, rawAddr, sizeof(uint8_t));
+            shift = x % 8;
+            val = (val8 >> shift) & 0x1 ;
+            break;
+        default:
+            break;
+    }
+    return val;
+}
+
+// Utility function to set value of any pixel in bm.
+// bm.getConfig() specifies what format 'val' must be
+// converted to, but at present uint32_t can handle all formats.
+void setPixel(int x, int y, uint32_t val, SkBitmap& bm) {
+    uint16_t val16;
+    uint8_t val8, shift;
+    SkAutoLockPixels lock(bm);
+    void* rawAddr = bm.getAddr(x,y);
+
+    switch (bm.getConfig()) {
+        case SkBitmap::kARGB_8888_Config:
+            memcpy(rawAddr, &val, sizeof(uint32_t));
+            break;
+        case SkBitmap::kARGB_4444_Config:
+        case SkBitmap::kRGB_565_Config:
+            val16 = val & 0xFFFF;
+            memcpy(rawAddr, &val16, sizeof(uint16_t));
+            break;
+        case SkBitmap::kA8_Config:
+        case SkBitmap::kIndex8_Config:
+            val8 = val & 0xFF;
+            memcpy(rawAddr, &val8, sizeof(uint8_t));
+            break;
+        case SkBitmap::kA1_Config:
+            shift = x % 8; // We assume we're in the right byte.
+            memcpy(&val8, rawAddr, sizeof(uint8_t));
+            if (val & 0x1) // Turn bit on.
+                val8 |= (0x1 << shift);
+            else // Turn bit off.
+                val8 &= ~(0x1 << shift);
+            memcpy(rawAddr, &val8, sizeof(uint8_t));
+            break;
+        default:
+            // Ignore.
+            break;
+    }
+}
+
+// Utility to return string containing name of each format, to
+// simplify diagnostic output.
+const char* getSkConfigName(const SkBitmap& bm) {
+    switch (bm.getConfig()) {
+        case SkBitmap::kNo_Config: return "SkBitmap::kNo_Config";
+        case SkBitmap::kA1_Config: return "SkBitmap::kA1_Config";
+        case SkBitmap::kA8_Config: return "SkBitmap::kA8_Config";
+        case SkBitmap::kIndex8_Config: return "SkBitmap::kIndex8_Config";
+        case SkBitmap::kRGB_565_Config: return "SkBitmap::kRGB_565_Config";
+        case SkBitmap::kARGB_4444_Config: return "SkBitmap::kARGB_4444_Config";
+        case SkBitmap::kARGB_8888_Config: return "SkBitmap::kARGB_8888_Config";
+        case SkBitmap::kRLE_Index8_Config:
+            return "SkBitmap::kRLE_Index8_Config,";
+        default: return "Unknown SkBitmap configuration.";
+    }
+}
+
+// Helper struct to contain pixel locations, while avoiding need for STL.
+struct Coordinates {
+
+    const int length;
+    SkIPoint* const data;
+
+    explicit Coordinates(int _length): length(_length)
+                                     , data(new SkIPoint[length]) { }
+
+    ~Coordinates(){
+        delete [] data;
+    }
+
+    SkIPoint* operator[](int i) const {
+        // Use with care, no bounds checking.
+        return data + i;
+    }
+};
+
+// A function to verify that two bitmaps contain the same pixel values
+// at all coordinates indicated by coords. Simplifies verification of
+// copied bitmaps.
+void reportCopyVerification(const SkBitmap& bm1, const SkBitmap& bm2,
+                            Coordinates& coords,
+                            const char* msg,
+                            skiatest::Reporter* reporter){
+    bool success = true;
+
+    // Confirm all pixels in the list match.
+    for (int i = 0; i < coords.length; ++i)
+        success = success &&
+                  (getPixel(coords[i]->fX, coords[i]->fY, bm1) ==
+                   getPixel(coords[i]->fX, coords[i]->fY, bm2));
+
+    if (!success) {
+        SkString str;
+        str.printf("%s [config = %s]",
+                   msg, getSkConfigName(bm1));
+        reporter->reportFailed(str);
+    }
+}
+
+// Writes unique pixel values at locations specified by coords.
+void writeCoordPixels(SkBitmap& bm, const Coordinates& coords) {
+    for (int i = 0; i < coords.length; ++i)
+        setPixel(coords[i]->fX, coords[i]->fY, i, bm);
+}
+
 static void TestBitmapCopy(skiatest::Reporter* reporter) {
     static const Pair gPairs[] = {
         { SkBitmap::kNo_Config,         "00000000"  },
@@ -94,6 +243,10 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
  //       { SkBitmap::kRLE_Index8_Config, "00101111"  }
     };
 
+    static const bool isExtracted[] = {
+        false, true
+    };
+
     const int W = 20;
     const int H = 33;
 
@@ -110,7 +263,7 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
             src.allocPixels(ct);
             SkSafeUnref(ct);
 
-            init_src(src);
+            init_src(src, ct);
             bool success = src.copyTo(&dst, gPairs[j].fConfig);
             bool expected = gPairs[i].fValid[j] != '0';
             if (success != expected) {
@@ -120,7 +273,7 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                            boolStr(success));
                 reporter->reportFailed(str);
             }
-            
+
             bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
             if (success != canSucceed) {
                 SkString str;
@@ -161,7 +314,7 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                         REPORTER_ASSERT(reporter, copy.width() == 1);
                         REPORTER_ASSERT(reporter, copy.height() == 1);
                         REPORTER_ASSERT(reporter, copy.rowBytes() <= 4);
-                        
+
                         SkAutoLockPixels alp0(subset);
                         SkAutoLockPixels alp1(copy);
                         // they should both have, or both not-have, a colortable
@@ -176,7 +329,257 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                 REPORTER_ASSERT(reporter, dst.width() == 0);
                 REPORTER_ASSERT(reporter, dst.height() == 0);
             }
-        }
+        } // for (size_t j = ...
+
+        // Tests for getSafeSize(), getSafeSize64(), copyPixelsTo(),
+        // copyPixelsFrom().
+        //
+        for (size_t copyCase = 0; copyCase < SK_ARRAY_COUNT(isExtracted);
+             ++copyCase) {
+            // Test copying to/from external buffer.
+            // Note: the tests below have hard-coded values ---
+            //       Please take care if modifying.
+            if (gPairs[i].fConfig != SkBitmap::kRLE_Index8_Config) {
+
+                // Tests for getSafeSize64().
+                // Test with a very large configuration without pixel buffer
+                // attached.
+                SkBitmap tstSafeSize;
+                tstSafeSize.setConfig(gPairs[i].fConfig, 100000000U,
+                                      100000000U);
+                Sk64 safeSize = tstSafeSize.getSafeSize64();
+                if (safeSize.isNeg()) {
+                    SkString str;
+                    str.printf("getSafeSize64() negative: %s",
+                        getSkConfigName(tstSafeSize));
+                    reporter->reportFailed(str);
+                }
+                bool sizeFail = false;
+                // Compare against hand-computed values.
+                switch (gPairs[i].fConfig) {
+                    case SkBitmap::kNo_Config:
+                        break;
+
+                    case SkBitmap::kA1_Config:
+                        if (safeSize.fHi != 0x470DE ||
+                            safeSize.fLo != 0x4DF82000)
+                            sizeFail = true;
+                        break;
+
+                    case SkBitmap::kA8_Config:
+                    case SkBitmap::kIndex8_Config:
+                        if (safeSize.fHi != 0x2386F2 ||
+                            safeSize.fLo != 0x6FC10000)
+                            sizeFail = true;
+                        break;
+
+                    case SkBitmap::kRGB_565_Config:
+                    case SkBitmap::kARGB_4444_Config:
+                        if (safeSize.fHi != 0x470DE4 ||
+                            safeSize.fLo != 0xDF820000)
+                            sizeFail = true;
+                        break;
+
+                    case SkBitmap::kARGB_8888_Config:
+                        if (safeSize.fHi != 0x8E1BC9 ||
+                            safeSize.fLo != 0xBF040000)
+                            sizeFail = true;
+                        break;
+
+                    case SkBitmap::kRLE_Index8_Config:
+                        break;
+
+                    default:
+                        break;
+                }
+                if (sizeFail) {
+                    SkString str;
+                    str.printf("getSafeSize64() wrong size: %s",
+                        getSkConfigName(tstSafeSize));
+                    reporter->reportFailed(str);
+                }
+
+                size_t subW, subH;
+                // Set sizes to be height = 2 to force the last row of the
+                // source to be used, thus verifying correct operation if
+                // the bitmap is an extracted subset.
+                if (gPairs[i].fConfig == SkBitmap::kA1_Config) {
+                    // If one-bit per pixel, use 9 pixels to force more than
+                    // one byte per row.
+                    subW = 9;
+                    subH = 2;
+                } else {
+                    // All other configurations are at least one byte per pixel,
+                    // and different configs will test copying different numbers
+                    // of bytes.
+                    subW = subH = 2;
+                }
+
+                // Create bitmap to act as source for copies and subsets.
+                SkBitmap src, subset;
+                SkColorTable* ct = NULL;
+                if (isExtracted[copyCase]) { // A larger image to extract from.
+                    src.setConfig(gPairs[i].fConfig, 2 * subW + 1, subH);
+                } else // Tests expect a 2x2 bitmap, so make smaller.
+                    src.setConfig(gPairs[i].fConfig, subW, subH);
+                if (SkBitmap::kIndex8_Config == src.config() ||
+                        SkBitmap::kRLE_Index8_Config == src.config()) {
+                    ct = init_ctable();
+                }
+
+                src.allocPixels(ct);
+                SkSafeUnref(ct);
+
+                // Either copy src or extract into 'subset', which is used
+                // for subsequent calls to copyPixelsTo/From.
+                bool srcReady = false;
+                if (isExtracted[copyCase]) {
+                    // The extractedSubset() test case allows us to test copy-
+                    // ing when src and dst mave possibly different strides.
+                    SkIRect r;
+                    if (gPairs[i].fConfig == SkBitmap::kA1_Config)
+                        // This config seems to need byte-alignment of
+                        // extracted subset bits.
+                        r.set(0, 0, subW, subH);
+                    else
+                        r.set(1, 0, 1 + subW, subH); // 2x2 extracted bitmap
+
+                    srcReady = src.extractSubset(&subset, r);
+                } else {
+                    srcReady = src.copyTo(&subset, src.getConfig());
+                }
+
+                // Not all configurations will generate a valid 'subset'.
+                if (srcReady) {
+
+                    // Allocate our target buffer 'buf' for all copies.
+                    // To simplify verifying correctness of copies attach
+                    // buf to a SkBitmap, but copies are done using the
+                    // raw buffer pointer.
+                    const uint32_t bufSize = subH *
+                        SkBitmap::ComputeRowBytes(src.getConfig(), subW) * 2;
+                    uint8_t* buf = new uint8_t[bufSize];
+
+                    SkBitmap bufBm; // Attach buf to this bitmap.
+                    bool successExpected;
+
+                    // Set up values for each pixel being copied.
+                    Coordinates coords(subW * subH);
+                    for (size_t x = 0; x < subW; ++x)
+                        for (size_t y = 0; y < subH; ++y)
+                        {
+                            int index = y * subW + x;
+                            SkASSERT(index < coords.length);
+                            coords[index]->fX = x;
+                            coords[index]->fY = y;
+                        }
+
+                    writeCoordPixels(subset, coords);
+
+                    // Test #1 ////////////////////////////////////////////
+
+                    // Before/after comparisons easier if we attach buf
+                    // to an appropriately configured SkBitmap.
+                    memset(buf, 0xFF, bufSize);
+                    // Config with stride greater than src but that fits in buf.
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH,
+                        SkBitmap::ComputeRowBytes(subset.getConfig(), subW)
+                                                  * 2);
+                    bufBm.setPixels(buf);
+                    successExpected = false;
+                    // Then attempt to copy with a stride that is too large
+                    // to fit in the buffer.
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsTo(buf, bufSize, bufBm.rowBytes() * 3)
+                        == successExpected);
+
+                    if (successExpected)
+                        reportCopyVerification(subset, bufBm, coords,
+                            "copyPixelsTo(buf, bufSize, 1.5*maxRowBytes)",
+                            reporter);
+
+                    // Test #2 ////////////////////////////////////////////
+                    // This test should always succeed, but in the case
+                    // of extracted bitmaps only because we handle the
+                    // issue of getSafeSize(). Without getSafeSize()
+                    // buffer overrun/read would occur.
+                    memset(buf, 0xFF, bufSize);
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH,
+                                    subset.rowBytes());
+                    bufBm.setPixels(buf);
+                    successExpected = subset.getSafeSize() <= bufSize;
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsTo(buf, bufSize) ==
+                            successExpected);
+                    if (successExpected)
+                        reportCopyVerification(subset, bufBm, coords,
+                        "copyPixelsTo(buf, bufSize)", reporter);
+
+                    // Test #3 ////////////////////////////////////////////
+                    // Copy with different stride between src and dst.
+                    memset(buf, 0xFF, bufSize);
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH,
+                                    subset.rowBytes()+1);
+                    bufBm.setPixels(buf);
+                    successExpected = true; // Should always work.
+                    REPORTER_ASSERT(reporter,
+                            subset.copyPixelsTo(buf, bufSize,
+                                subset.rowBytes()+1) == successExpected);
+                    if (successExpected)
+                        reportCopyVerification(subset, bufBm, coords,
+                        "copyPixelsTo(buf, bufSize, rowBytes+1)", reporter);
+
+                    // Test #4 ////////////////////////////////////////////
+                    // Test copy with stride too small.
+                    memset(buf, 0xFF, bufSize);
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH);
+                    bufBm.setPixels(buf);
+                    successExpected = false;
+                    // Request copy with stride too small.
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsTo(buf, bufSize, bufBm.rowBytes()-1)
+                            == successExpected);
+                    if (successExpected)
+                        reportCopyVerification(subset, bufBm, coords,
+                        "copyPixelsTo(buf, bufSize, rowBytes()-1)", reporter);
+
+                    // Test #5 ////////////////////////////////////////////
+                    // Tests the case where the source stride is too small
+                    // for the source configuration.
+                    memset(buf, 0xFF, bufSize);
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH);
+                    bufBm.setPixels(buf);
+                    writeCoordPixels(bufBm, coords);
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsFrom(buf, bufSize, 1) == false);
+
+                    // Test #6 ////////////////////////////////////////////
+                    // Tests basic copy from an external buffer to the bitmap.
+                    // If the bitmap is "extracted", this also tests the case
+                    // where the source stride is different from the dest.
+                    // stride.
+                    // We've made the buffer large enough to always succeed.
+                    bufBm.setConfig(gPairs[i].fConfig, subW, subH);
+                    bufBm.setPixels(buf);
+                    writeCoordPixels(bufBm, coords);
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsFrom(buf, bufSize, bufBm.rowBytes()) ==
+                            true);
+                    reportCopyVerification(bufBm, subset, coords,
+                        "copyPixelsFrom(buf, bufSize)",
+                        reporter);
+
+                    // Test #7 ////////////////////////////////////////////
+                    // Tests the case where the source buffer is too small
+                    // for the transfer.
+                    REPORTER_ASSERT(reporter,
+                        subset.copyPixelsFrom(buf, 1, subset.rowBytes()) ==
+                            false);
+
+                    delete [] buf;
+                }
+            }
+        } // for (size_t copyCase ...
     }
 }
 
diff --git a/tests/BitmapGetColorTest.cpp b/tests/BitmapGetColorTest.cpp
new file mode 100644
index 0000000..81cf412
--- /dev/null
+++ b/tests/BitmapGetColorTest.cpp
@@ -0,0 +1,36 @@
+#include "Test.h"
+#include "SkBitmap.h"
+
+static void TestGetColor(skiatest::Reporter* reporter) {
+    static const struct Rec {
+        SkBitmap::Config    fConfig;
+        SkColor             fInColor;
+        SkColor             fOutColor;
+    } gRec[] = {
+        // todo: add some tests that involve alpha, so we exercise the
+        // unpremultiply aspect of getColor()
+        {   SkBitmap::kA8_Config,           0xFF000000,     0xFF000000  },
+        {   SkBitmap::kA8_Config,           0,              0           },
+        {   SkBitmap::kARGB_4444_Config,    0xFF224466,     0xFF224466  },
+        {   SkBitmap::kARGB_4444_Config,    0,              0           },
+        {   SkBitmap::kRGB_565_Config,      0xFF00FF00,     0xFF00FF00  },
+        {   SkBitmap::kRGB_565_Config,      0xFFFF00FF,     0xFFFF00FF  },
+        {   SkBitmap::kARGB_8888_Config,    0xFFFFFFFF,     0xFFFFFFFF  },
+        {   SkBitmap::kARGB_8888_Config,    0,              0           },
+        {   SkBitmap::kARGB_8888_Config,    0xFF224466,     0xFF224466  },
+    };
+
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
+        SkBitmap bm;
+        uint32_t storage[1];
+        bm.setConfig(gRec[i].fConfig, 1, 1);
+        bm.setPixels(storage);
+        bm.eraseColor(gRec[i].fInColor);
+
+        SkColor c = bm.getColor(0, 0);
+        REPORTER_ASSERT(reporter, c == gRec[i].fOutColor);
+    }
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("GetColor", TestGetColorClass, TestGetColor)
diff --git a/tests/BlitRowTest.cpp b/tests/BlitRowTest.cpp
index 91d6b94..d18cb8a 100644
--- a/tests/BlitRowTest.cpp
+++ b/tests/BlitRowTest.cpp
@@ -207,7 +207,8 @@ static void test_diagonal(skiatest::Reporter* reporter) {
     SkBitmap srcBM;
     srcBM.setConfig(SkBitmap::kARGB_8888_Config, W, H);
     srcBM.allocPixels();
-    SkRect srcR = { 0, 0, srcBM.width(), srcBM.height() };
+    SkRect srcR = {
+        0, 0, SkIntToScalar(srcBM.width()), SkIntToScalar(srcBM.height()) };
 
     // cons up a mesh to draw the bitmap with
     Mesh mesh(srcBM, &paint);
diff --git a/tests/ClipCubicTest.cpp b/tests/ClipCubicTest.cpp
index 905b733..e38a22f 100644
--- a/tests/ClipCubicTest.cpp
+++ b/tests/ClipCubicTest.cpp
@@ -7,10 +7,10 @@
 static void PrintCurve(const char *name, const SkPoint crv[4]) {
     printf("%s: %.10g, %.10g, %.10g, %.10g, %.10g, %.10g, %.10g, %.10g\n",
             name,
-            crv[0].fX, crv[0].fY,
-            crv[1].fX, crv[1].fY,
-            crv[2].fX, crv[2].fY,
-            crv[3].fX, crv[3].fY);
+            (float)crv[0].fX, (float)crv[0].fY,
+            (float)crv[1].fX, (float)crv[1].fY,
+            (float)crv[2].fX, (float)crv[2].fY,
+            (float)crv[3].fX, (float)crv[3].fY);
 
 }
 
@@ -46,17 +46,17 @@ static SkPoint* SetCurve(float x0, float y0,
 
 static void TestCubicClipping(skiatest::Reporter* reporter) {
     static SkPoint crv[4] = {
-        { SkFloatToScalar(0), SkFloatToScalar(0)  },
-        { SkFloatToScalar(2), SkFloatToScalar(3)  },
-        { SkFloatToScalar(1), SkFloatToScalar(10) },
-        { SkFloatToScalar(4), SkFloatToScalar(12) }
+        { SkIntToScalar(0), SkIntToScalar(0)  },
+        { SkIntToScalar(2), SkIntToScalar(3)  },
+        { SkIntToScalar(1), SkIntToScalar(10) },
+        { SkIntToScalar(4), SkIntToScalar(12) }
     };
 
     SkCubicClipper clipper;
     SkPoint clipped[4], shouldbe[4];
     SkIRect clipRect;
     bool success;
-    const float tol = 1e-4;
+    const float tol = SkFloatToScalar(1e-4);
 
     // Test no clip, with plenty of room.
     clipRect.set(-2, -2, 6, 14);
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
new file mode 100644
index 0000000..e3c95b4
--- /dev/null
+++ b/tests/ClipStackTest.cpp
@@ -0,0 +1,49 @@
+#include "Test.h"
+#include "SkClipStack.h"
+
+static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
+                         int count) {
+    REPORTER_ASSERT(reporter, count == stack.getSaveCount());
+
+    SkClipStack::B2FIter iter(stack);
+    int counter = 0;
+    while (iter.next()) {
+        counter += 1;
+    }
+    REPORTER_ASSERT(reporter, count == counter);
+}
+
+static void TestClipStack(skiatest::Reporter* reporter) {
+    SkClipStack stack;
+
+    assert_count(reporter, stack, 0);
+
+    static const SkIRect gRects[] = {
+        { 0, 0, 100, 100 },
+        { 25, 25, 125, 125 },
+        { 0, 0, 1000, 1000 },
+        { 0, 0, 75, 75 }
+    };
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gRects); i++) {
+        stack.clipDevRect(gRects[i]);
+    }
+
+    // all of the above rects should have been intersected, leaving only 1 rect
+    SkClipStack::B2FIter iter(stack);
+    const SkClipStack::B2FIter::Clip* clip = iter.next();
+    const SkRect answer = { 25, 25, 75, 75 };
+
+    REPORTER_ASSERT(reporter, clip);
+    REPORTER_ASSERT(reporter, clip->fRect);
+    REPORTER_ASSERT(reporter, !clip->fPath);
+    REPORTER_ASSERT(reporter, SkRegion::kIntersect_Op == clip->fOp);
+    REPORTER_ASSERT(reporter, *clip->fRect == answer);
+    // now check that we only had one in our iterator
+    REPORTER_ASSERT(reporter, !iter.next());
+
+    stack.reset();
+    assert_count(reporter, stack, 0);
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("ClipStack", TestClipStackClass, TestClipStack)
diff --git a/tests/DequeTest.cpp b/tests/DequeTest.cpp
new file mode 100644
index 0000000..e74fd28
--- /dev/null
+++ b/tests/DequeTest.cpp
@@ -0,0 +1,96 @@
+#include "Test.h"
+#include "SkDeque.h"
+
+static void assert_count(skiatest::Reporter* reporter, const SkDeque& deq, int count) {
+    if (0 == count) {
+        REPORTER_ASSERT(reporter, deq.empty());
+        REPORTER_ASSERT(reporter, 0 == deq.count());
+        REPORTER_ASSERT(reporter, sizeof(int) == deq.elemSize());
+        REPORTER_ASSERT(reporter, NULL == deq.front());
+        REPORTER_ASSERT(reporter, NULL == deq.back());
+    } else {
+        REPORTER_ASSERT(reporter, !deq.empty());
+        REPORTER_ASSERT(reporter, count == deq.count());
+        REPORTER_ASSERT(reporter, sizeof(int) == deq.elemSize());
+        REPORTER_ASSERT(reporter, NULL != deq.front());
+        REPORTER_ASSERT(reporter, NULL != deq.back());
+        if (1 == count) {
+            REPORTER_ASSERT(reporter, deq.back() == deq.front());
+        } else {
+            REPORTER_ASSERT(reporter, deq.back() != deq.front());
+        }
+    }
+}
+
+static void assert_f2biter(skiatest::Reporter* reporter, const SkDeque& deq,
+                           int max, int min) {
+    SkDeque::F2BIter iter(deq);
+    void* ptr;
+
+    int value = max;
+    while ((ptr = iter.next()) != NULL) {
+        REPORTER_ASSERT(reporter, value == *(int*)ptr);
+        value -= 1;
+    }
+    REPORTER_ASSERT(reporter, value+1 == min);
+}
+
+static void TestDeque(skiatest::Reporter* reporter) {
+    SkDeque deq(sizeof(int));
+    int i;
+
+    // test pushing on the front
+
+    assert_count(reporter, deq, 0);
+    for (i = 1; i <= 10; i++) {
+        *(int*)deq.push_front() = i;
+    }
+    assert_count(reporter, deq, 10);
+    assert_f2biter(reporter, deq, 10, 1);
+
+    for (i = 0; i < 5; i++) {
+        deq.pop_front();
+    }
+    assert_count(reporter, deq, 5);
+    assert_f2biter(reporter, deq, 5, 1);
+
+    for (i = 0; i < 5; i++) {
+        deq.pop_front();
+    }
+    assert_count(reporter, deq, 0);
+
+    // now test pushing on the back
+
+    for (i = 10; i >= 1; --i) {
+        *(int*)deq.push_back() = i;
+    }
+    assert_count(reporter, deq, 10);
+    assert_f2biter(reporter, deq, 10, 1);
+
+    for (i = 0; i < 5; i++) {
+        deq.pop_back();
+    }
+    assert_count(reporter, deq, 5);
+    assert_f2biter(reporter, deq, 10, 6);
+
+    for (i = 0; i < 5; i++) {
+        deq.pop_back();
+    }
+    assert_count(reporter, deq, 0);
+
+    // now tests pushing/poping on both ends
+
+    *(int*)deq.push_front() = 5;
+    *(int*)deq.push_back() = 4;
+    *(int*)deq.push_front() = 6;
+    *(int*)deq.push_back() = 3;
+    *(int*)deq.push_front() = 7;
+    *(int*)deq.push_back() = 2;
+    *(int*)deq.push_front() = 8;
+    *(int*)deq.push_back() = 1;
+    assert_count(reporter, deq, 8);
+    assert_f2biter(reporter, deq, 8, 1);
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Deque", TestDequeClass, TestDeque)
diff --git a/tests/FillPathTest.cpp b/tests/FillPathTest.cpp
new file mode 100644
index 0000000..ffc9f8e
--- /dev/null
+++ b/tests/FillPathTest.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2010 The Chromium Authors. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Test.h"
+#include "SkRegion.h"
+#include "SkPath.h"
+#include "SkScan.h"
+#include "SkBlitter.h"
+
+namespace {
+
+struct FakeBlitter : public SkBlitter {
+  FakeBlitter()
+      : m_blitCount(0)
+  {}
+
+  virtual void blitH(int x, int y, int width) {
+    m_blitCount++;
+  }
+
+  int m_blitCount;
+};
+
+}
+
+// http://code.google.com/p/skia/issues/detail?id=87
+// Lines which is not clipped by boundary based clipping, 
+// but skipped after tessellation, should be cleared by the blitter.
+static void TestFillPathInverse(skiatest::Reporter* reporter) {
+  FakeBlitter blitter;
+  SkRegion clip;
+  SkPath path;
+  int height = 100;
+  int width  = 200;
+  int expected_lines = 5;
+  clip.setRect(0, height - expected_lines, width, height);
+  path.moveTo(0.0, 0.0);
+  path.quadTo(width/2, height, width, 0.0);
+  path.close();
+  path.setFillType(SkPath::kInverseWinding_FillType);
+  SkScan::FillPath(path, clip, &blitter);
+
+  REPORTER_ASSERT(reporter, blitter.m_blitCount == expected_lines);
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("FillPath", FillPathTestClass, TestFillPathInverse)
diff --git a/tests/FlateTest.cpp b/tests/FlateTest.cpp
new file mode 100644
index 0000000..f8e0921
--- /dev/null
+++ b/tests/FlateTest.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "Test.h"
+#include "SkFlate.h"
+#include "SkStream.h"
+
+// A memory stream that reports zero size with the standard call, like
+// an unseekable file stream would.
+class SkZeroSizeMemStream : public SkMemoryStream {
+public:
+    virtual size_t read(void* buffer, size_t size) {
+        if (buffer == NULL && size == 0)
+            return 0;
+        if (buffer == NULL && size == kGetSizeKey)
+            size = 0;
+        return SkMemoryStream::read(buffer, size);
+    }
+
+    static const size_t kGetSizeKey = 0xDEADBEEF;
+};
+
+static void TestFlate(skiatest::Reporter* reporter, SkMemoryStream* testStream,
+                      size_t dataSize) {
+    if (testStream == NULL)
+      return;
+
+    SkMemoryStream testData(dataSize);
+    uint8_t* data = (uint8_t*)testData.getMemoryBase();
+    srand(0);  // Make data deterministic.
+    for (size_t i = 0; i < dataSize; i++)
+        data[i] = rand() & 0xFF;
+
+    testStream->setMemory(testData.getMemoryBase(), dataSize, true);
+    SkDynamicMemoryWStream compressed;
+    bool status = SkFlate::Deflate(testStream, &compressed);
+    REPORTER_ASSERT(reporter, status);
+
+    // Check that the input data wasn't changed.
+    size_t inputSize = testStream->getLength();
+    if (inputSize == 0)
+        inputSize = testStream->read(NULL, SkZeroSizeMemStream::kGetSizeKey);
+    REPORTER_ASSERT(reporter, testData.getLength() == inputSize);
+    REPORTER_ASSERT(reporter, memcmp(testData.getMemoryBase(),
+                                     testStream->getMemoryBase(),
+                                     testData.getLength()) == 0);
+
+    // Assume there are two test sizes, big and small.
+    if (dataSize < 1024)
+      REPORTER_ASSERT(reporter, compressed.getOffset() < 1024);
+    else
+      REPORTER_ASSERT(reporter, compressed.getOffset() > 1024);
+
+    testStream->setMemory(compressed.getStream(), compressed.getOffset(), true);
+    SkDynamicMemoryWStream uncompressed;
+    status = SkFlate::Inflate(testStream, &uncompressed);
+    REPORTER_ASSERT(reporter, status);
+
+    // Check that the input data wasn't changed.
+    inputSize = testStream->getLength();
+    if (inputSize == 0)
+        inputSize = testStream->read(NULL, SkZeroSizeMemStream::kGetSizeKey);
+    REPORTER_ASSERT(reporter, compressed.getOffset() == inputSize);
+    REPORTER_ASSERT(reporter, memcmp(testStream->getMemoryBase(),
+                                     compressed.getStream(),
+                                     compressed.getOffset()) == 0);
+
+    // Check that the uncompressed data matches the source data.
+    REPORTER_ASSERT(reporter, testData.getLength() == uncompressed.getOffset());
+    REPORTER_ASSERT(reporter, memcmp(testData.getMemoryBase(),
+                                     uncompressed.getStream(),
+                                     testData.getLength()) == 0);
+}
+
+static void TestFlateCompression(skiatest::Reporter* reporter) {
+    TestFlate(reporter, NULL, 0);
+#ifdef SK_ZLIB_INCLUDE
+    REPORTER_ASSERT(reporter, SkFlate::HaveFlate());
+
+    SkMemoryStream memStream;
+    TestFlate(reporter, &memStream, 512);
+    TestFlate(reporter, &memStream, 10240);
+
+    SkZeroSizeMemStream fileStream;
+    TestFlate(reporter, &fileStream, 512);
+    TestFlate(reporter, &fileStream, 10240);
+#endif
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Flate", FlateTestClass, TestFlateCompression)
diff --git a/tests/InfRectTest.cpp b/tests/InfRectTest.cpp
new file mode 100644
index 0000000..1e15023
--- /dev/null
+++ b/tests/InfRectTest.cpp
@@ -0,0 +1,44 @@
+#include "Test.h"
+#include "SkRect.h"
+
+#ifdef SK_SCALAR_IS_FLOAT
+static float make_zero() {
+    return sk_float_sin(0);
+}
+#endif
+
+static void check_invalid(skiatest::Reporter* reporter,
+                          SkScalar l, SkScalar t, SkScalar r, SkScalar b) {
+    SkRect rect;
+    rect.set(l, t, r, b);
+    REPORTER_ASSERT(reporter, !rect.hasValidCoordinates());
+}
+
+// Tests that hasValidCoordinates() will reject any rect with +/-inf values
+// as one of its coordinates.
+static void TestInfRect(skiatest::Reporter* reporter) {
+#ifdef SK_SCALAR_IS_FLOAT
+    float invalid = 1 / make_zero();    // infinity
+#else
+    SkFixed invalid = SK_FixedNaN;
+#endif
+    SkScalar small = SkIntToScalar(10);
+    SkScalar big = SkIntToScalar(100);
+
+    SkRect rect = SkRect::MakeXYWH(small, small, big, big);
+    REPORTER_ASSERT(reporter, rect.hasValidCoordinates());
+
+    check_invalid(reporter, small, small, big, invalid);
+    check_invalid(reporter, small, small, invalid, big);
+    check_invalid(reporter, small, invalid, big, big);
+    check_invalid(reporter, invalid, small, big, big);
+    check_invalid(reporter, small, small, big, -invalid);
+    check_invalid(reporter, small, small, -invalid, big);
+    check_invalid(reporter, small, -invalid, big, big);
+    check_invalid(reporter, -invalid, small, big, big);
+}
+
+// need tests for SkStrSearch
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("InfRect", InfRectTestClass, TestInfRect)
diff --git a/tests/MathTest.cpp b/tests/MathTest.cpp
index 4bfbd94..493691e 100644
--- a/tests/MathTest.cpp
+++ b/tests/MathTest.cpp
@@ -146,6 +146,38 @@ static void unittest_fastfloat(skiatest::Reporter* reporter) {
     }
 }
 
+#ifdef SK_SCALAR_IS_FLOAT
+static float make_zero() {
+    return sk_float_sin(0);
+}
+#endif
+
+static void unittest_isfinite(skiatest::Reporter* reporter) {
+#ifdef SK_SCALAR_IS_FLOAT
+    float nan = ::asin(2);
+    float inf = 1.0 / make_zero();
+    float big = 3.40282e+038;
+
+    REPORTER_ASSERT(reporter, !SkScalarIsNaN(inf));
+    REPORTER_ASSERT(reporter, !SkScalarIsNaN(-inf));
+    REPORTER_ASSERT(reporter, !SkScalarIsFinite(inf));
+    REPORTER_ASSERT(reporter, !SkScalarIsFinite(-inf));
+#else
+    SkFixed nan = SK_FixedNaN;
+    SkFixed big = SK_FixedMax;
+#endif
+
+    REPORTER_ASSERT(reporter,  SkScalarIsNaN(nan));
+    REPORTER_ASSERT(reporter, !SkScalarIsNaN(big));
+    REPORTER_ASSERT(reporter, !SkScalarIsNaN(-big));
+    REPORTER_ASSERT(reporter, !SkScalarIsNaN(0));
+    
+    REPORTER_ASSERT(reporter, !SkScalarIsFinite(nan));
+    REPORTER_ASSERT(reporter,  SkScalarIsFinite(big));
+    REPORTER_ASSERT(reporter,  SkScalarIsFinite(-big));
+    REPORTER_ASSERT(reporter,  SkScalarIsFinite(0));
+}
+
 #endif
 
 static void test_muldiv255(skiatest::Reporter* reporter) {
@@ -171,6 +203,19 @@ static void test_muldiv255(skiatest::Reporter* reporter) {
 #endif
 }
 
+static void test_muldiv255ceiling(skiatest::Reporter* reporter) {
+    for (int c = 0; c <= 255; c++) {
+        for (int a = 0; a <= 255; a++) {
+            int product = (c * a + 255);
+            int expected_ceiling = (product + (product >> 8)) >> 8;
+            int webkit_ceiling = (c * a + 254) / 255;
+            REPORTER_ASSERT(reporter, expected_ceiling == webkit_ceiling);
+            int skia_ceiling = SkMulDiv255Ceiling(c, a);
+            REPORTER_ASSERT(reporter, skia_ceiling == webkit_ceiling);
+        }
+    }
+}
+
 static void test_copysign(skiatest::Reporter* reporter) {
     static const int32_t gTriples[] = {
         // x, y, expected result
@@ -237,6 +282,7 @@ static void TestMath(skiatest::Reporter* reporter) {
 #endif
 
     test_muldiv255(reporter);
+    test_muldiv255ceiling(reporter);
     test_copysign(reporter);
 
     {
@@ -295,6 +341,7 @@ static void TestMath(skiatest::Reporter* reporter) {
 
 #ifdef SK_CAN_USE_FLOAT
     unittest_fastfloat(reporter);
+    unittest_isfinite(reporter);
 #endif
 
 #ifdef SkLONGLONG
diff --git a/tests/MatrixTest.cpp b/tests/MatrixTest.cpp
index 052687d..49a98c2 100644
--- a/tests/MatrixTest.cpp
+++ b/tests/MatrixTest.cpp
@@ -5,7 +5,7 @@ static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
 #ifdef SK_SCALAR_IS_FLOAT
     const float tolerance = 0.000005f;
 #else
-    const int32_t tolerance = 3;
+    const int32_t tolerance = 8;
 #endif
 
     return SkScalarAbs(a - b) <= tolerance;
@@ -14,7 +14,7 @@ static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
 static bool nearly_equal(const SkMatrix& a, const SkMatrix& b) {
     for (int i = 0; i < 9; i++) {
         if (!nearly_equal_scalar(a[i], b[i])) {
-            printf("not equal %g %g\n", a[i], b[i]);
+            printf("not equal %g %g\n", (float)a[i], (float)b[i]);
             return false;
         }
     }
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
new file mode 100644
index 0000000..6feab51
--- /dev/null
+++ b/tests/PDFPrimitivesTest.cpp
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+
+#include "Test.h"
+#include "SkPDFCatalog.h"
+#include "SkPDFStream.h"
+#include "SkPDFTypes.h"
+#include "SkScalar.h"
+#include "SkStream.h"
+
+static void CheckObjectOutput(skiatest::Reporter* reporter, SkPDFObject* obj,
+                              const std::string& representation,
+                              bool indirect) {
+    size_t directSize = obj->getOutputSize(NULL, false);
+    REPORTER_ASSERT(reporter, directSize == representation.size());
+
+    SkDynamicMemoryWStream buffer;
+    obj->emitObject(&buffer, NULL, false);
+    REPORTER_ASSERT(reporter, directSize == buffer.getOffset());
+    REPORTER_ASSERT(reporter, memcmp(buffer.getStream(), representation.c_str(),
+                                     directSize) == 0);
+
+    if (indirect) {
+        // Indirect output.
+        static char header[] = "1 0 obj\n";
+        static size_t headerLen = strlen(header);
+        static char footer[] = "\nendobj\n";
+        static size_t footerLen = strlen(footer);
+
+        SkPDFCatalog catalog;
+        catalog.addObject(obj, false);
+
+        size_t indirectSize = obj->getOutputSize(&catalog, true);
+        REPORTER_ASSERT(reporter,
+                        indirectSize == directSize + headerLen + footerLen);
+
+        buffer.reset();
+        obj->emitObject(&buffer, &catalog, true);
+        REPORTER_ASSERT(reporter, indirectSize == buffer.getOffset());
+        REPORTER_ASSERT(reporter, memcmp(buffer.getStream(), header,
+                                         headerLen) == 0);
+        REPORTER_ASSERT(reporter,
+                        memcmp(buffer.getStream() + headerLen,
+                               representation.c_str(), directSize) == 0);
+        REPORTER_ASSERT(reporter,
+                        memcmp(buffer.getStream() + headerLen + directSize,
+                               footer, footerLen) == 0);
+    }
+}
+
+static void TestCatalog(skiatest::Reporter* reporter) {
+    SkPDFCatalog catalog;
+    SkRefPtr<SkPDFInt> int1 = new SkPDFInt(1);
+    int1->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFInt> int2 = new SkPDFInt(2);
+    int2->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFInt> int3 = new SkPDFInt(3);
+    int3->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFInt> int1Again(int1.get());
+
+    catalog.addObject(int1.get(), false);
+    catalog.addObject(int2.get(), false);
+    catalog.addObject(int3.get(), false);
+
+    REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int1.get()) == 3);
+    REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int2.get()) == 3);
+    REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int3.get()) == 3);
+
+    SkDynamicMemoryWStream buffer;
+    catalog.emitObjectNumber(&buffer, int1.get());
+    catalog.emitObjectNumber(&buffer, int2.get());
+    catalog.emitObjectNumber(&buffer, int3.get());
+    catalog.emitObjectNumber(&buffer, int1Again.get());
+    char expectedResult[] = "1 02 03 01 0";
+    REPORTER_ASSERT(reporter, memcmp(buffer.getStream(), expectedResult,
+                                     strlen(expectedResult)) == 0);
+}
+
+static void TestObjectRef(skiatest::Reporter* reporter) {
+    SkRefPtr<SkPDFInt> int1 = new SkPDFInt(1);
+    int1->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFInt> int2 = new SkPDFInt(2);
+    int2->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFObjRef> int2ref = new SkPDFObjRef(int2.get());
+    int2ref->unref();  // SkRefPtr and new both took a reference.
+
+    SkPDFCatalog catalog;
+    catalog.addObject(int1.get(), false);
+    catalog.addObject(int2.get(), false);
+    REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int1.get()) == 3);
+    REPORTER_ASSERT(reporter, catalog.getObjectNumberSize(int2.get()) == 3);
+
+    char expectedResult[] = "2 0 R";
+    SkDynamicMemoryWStream buffer;
+    int2ref->emitObject(&buffer, &catalog, false);
+    REPORTER_ASSERT(reporter, buffer.getOffset() == strlen(expectedResult));
+    REPORTER_ASSERT(reporter, memcmp(buffer.getStream(), expectedResult,
+                                     buffer.getOffset()) == 0);
+}
+
+static void TestPDFPrimitives(skiatest::Reporter* reporter) {
+    SkRefPtr<SkPDFInt> int42 = new SkPDFInt(42);
+    int42->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, int42.get(), "42", true);
+
+    SkRefPtr<SkPDFScalar> realHalf = new SkPDFScalar(SK_ScalarHalf);
+    realHalf->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, realHalf.get(), "0.5", true);
+
+    SkRefPtr<SkPDFScalar> bigScalar = new SkPDFScalar(110999.75);
+    bigScalar->unref();  // SkRefPtr and new both took a reference.
+#if defined(SK_SCALAR_IS_FIXED) || !defined(SK_ALLOW_LARGE_PDF_SCALARS)
+    CheckObjectOutput(reporter, bigScalar.get(), "111000", true);
+#else
+    CheckObjectOutput(reporter, bigScalar.get(), "110999.75", true);
+#endif
+
+#if defined(SK_SCALAR_IS_FLOAT) && defined(SK_ALLOW_LARGE_PDF_SCALARS)
+    SkRefPtr<SkPDFScalar> biggerScalar = new SkPDFScalar(50000000.1);
+    biggerScalar->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, biggerScalar.get(), "50000000", true);
+
+    SkRefPtr<SkPDFScalar> smallestScalar = new SkPDFScalar(1.0/65536);
+    smallestScalar->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, smallestScalar.get(), "0.00001526", true);
+#endif
+
+    SkRefPtr<SkPDFString> stringSimple = new SkPDFString("test ) string ( foo");
+    stringSimple->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, stringSimple.get(), "(test \\) string \\( foo)",
+                      true);
+    SkRefPtr<SkPDFString> stringComplex =
+        new SkPDFString("\ttest ) string ( foo");
+    stringComplex->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, stringComplex.get(),
+                      "<0974657374202920737472696E67202820666F6F>", true);
+
+    SkRefPtr<SkPDFName> name = new SkPDFName("Test name\twith#tab");
+    name->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, name.get(), "/Test#20name#09with#23tab", false);
+
+    SkRefPtr<SkPDFArray> array = new SkPDFArray;
+    array->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, array.get(), "[]", true);
+    array->append(int42.get());
+    CheckObjectOutput(reporter, array.get(), "[42]", true);
+    array->append(realHalf.get());
+    CheckObjectOutput(reporter, array.get(), "[42 0.5]", true);
+    SkRefPtr<SkPDFInt> int0 = new SkPDFInt(0);
+    int0->unref();  // SkRefPtr and new both took a reference.
+    array->append(int0.get());
+    CheckObjectOutput(reporter, array.get(), "[42 0.5 0]", true);
+    SkRefPtr<SkPDFInt> int1 = new SkPDFInt(1);
+    int1->unref();  // SkRefPtr and new both took a reference.
+    array->setAt(0, int1.get());
+    CheckObjectOutput(reporter, array.get(), "[1 0.5 0]", true);
+
+    SkRefPtr<SkPDFDict> dict = new SkPDFDict;
+    dict->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, dict.get(), "<<>>", true);
+    SkRefPtr<SkPDFName> n1 = new SkPDFName("n1");
+    n1->unref();  // SkRefPtr and new both took a reference.
+    dict->insert(n1.get(), int42.get());
+    CheckObjectOutput(reporter, dict.get(), "<</n1 42\n>>", true);
+    SkRefPtr<SkPDFName> n2 = new SkPDFName("n2");
+    n2->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFName> n3 = new SkPDFName("n3");
+    n3->unref();  // SkRefPtr and new both took a reference.
+    dict->insert(n2.get(), realHalf.get());
+    dict->insert(n3.get(), array.get());
+    CheckObjectOutput(reporter, dict.get(),
+                      "<</n1 42\n/n2 0.5\n/n3 [1 0.5 0]\n>>", true);
+
+    char streamBytes[] = "Test\nFoo\tBar";
+    SkRefPtr<SkMemoryStream> streamData = new SkMemoryStream(
+        streamBytes, strlen(streamBytes), true);
+    streamData->unref();  // SkRefPtr and new both took a reference.
+    SkRefPtr<SkPDFStream> stream = new SkPDFStream(streamData.get());
+    stream->unref();  // SkRefPtr and new both took a reference.
+    CheckObjectOutput(reporter, stream.get(),
+                      "<</Length 12\n>> stream\nTest\nFoo\tBar\nendstream",
+                      true);
+    stream->insert(n1.get(), int42.get());
+    CheckObjectOutput(reporter, stream.get(),
+                      "<</Length 12\n/n1 42\n>> stream\nTest\nFoo\tBar"
+                      "\nendstream",
+                      true);
+
+    TestCatalog(reporter);
+
+    TestObjectRef(reporter);
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("PDFPrimitives", PDFPrimitivesTestClass, TestPDFPrimitives)
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index 4e6c8b9..5b19090 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -8,10 +8,14 @@ static void regression_cubic(skiatest::Reporter* reporter) {
     SkPath path, stroke;
     SkPaint paint;
 
-    path.moveTo(460.2881309415525, 303.250847066498);
-    path.cubicTo(463.36378422175284, 302.1169735073363,
-                 456.32239330810046, 304.720354932878,
-                 453.15255460013304, 305.788586869862);
+    path.moveTo(SkFloatToFixed(460.2881309415525f),
+                SkFloatToFixed(303.250847066498));
+    path.cubicTo(SkFloatToFixed(463.36378422175284),
+                 SkFloatToFixed(302.1169735073363),
+                 SkFloatToFixed(456.32239330810046),
+                 SkFloatToFixed(304.720354932878),
+                 SkFloatToFixed(453.15255460013304),
+                 SkFloatToFixed(305.788586869862));
     
     SkRect fillR, strokeR;
     fillR = path.getBounds();
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 9f26d01..b4b6317 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -6,7 +6,7 @@ static void check_convex_bounds(skiatest::Reporter* reporter, const SkPath& p,
                                 const SkRect& bounds) {
     REPORTER_ASSERT(reporter, p.isConvex());
     REPORTER_ASSERT(reporter, p.getBounds() == bounds);
-    
+
     SkPath p2(p);
     REPORTER_ASSERT(reporter, p2.isConvex());
     REPORTER_ASSERT(reporter, p2.getBounds() == bounds);
@@ -45,12 +45,12 @@ static void TestPath(skiatest::Reporter* reporter) {
     p.setIsConvex(false);
     p.addRoundRect(bounds, SK_Scalar1, SK_Scalar1);
     check_convex_bounds(reporter, p, bounds);
-    
+
     p.reset();
     p.setIsConvex(false);
     p.addOval(bounds);
     check_convex_bounds(reporter, p, bounds);
-    
+
     p.reset();
     p.setIsConvex(false);
     p.addRect(bounds);
@@ -88,6 +88,18 @@ static void TestPath(skiatest::Reporter* reporter) {
     p.moveTo(SK_Scalar1, 0);
     p.getLastPt(&pt);
     REPORTER_ASSERT(reporter, pt.fX == SK_Scalar1);
+
+    // check that reset and rewind clear the convex hint back to false
+    p.setIsConvex(false);
+    REPORTER_ASSERT(reporter, !p.isConvex());
+    p.setIsConvex(true);
+    REPORTER_ASSERT(reporter, p.isConvex());
+    p.reset();
+    REPORTER_ASSERT(reporter, !p.isConvex());
+    p.setIsConvex(true);
+    REPORTER_ASSERT(reporter, p.isConvex());
+    p.rewind();
+    REPORTER_ASSERT(reporter, !p.isConvex());
 }
 
 #include "TestClassDef.h"
diff --git a/tests/RefDictTest.cpp b/tests/RefDictTest.cpp
new file mode 100644
index 0000000..f52541b
--- /dev/null
+++ b/tests/RefDictTest.cpp
@@ -0,0 +1,66 @@
+#include "Test.h"
+#include "SkRefDict.h"
+
+class TestRC : public SkRefCnt {
+};
+
+static void TestRefDict(skiatest::Reporter* reporter) {
+    TestRC    data0, data1;
+    SkRefDict dict;
+
+    REPORTER_ASSERT(reporter, NULL == dict.find(NULL));
+    REPORTER_ASSERT(reporter, NULL == dict.find("foo"));
+    REPORTER_ASSERT(reporter, NULL == dict.find("bar"));
+
+    dict.set("foo", &data0);
+    REPORTER_ASSERT(reporter, &data0 == dict.find("foo"));
+    REPORTER_ASSERT(reporter, 2 == data0.getRefCnt());
+
+    dict.set("foo", &data0);
+    REPORTER_ASSERT(reporter, &data0 == dict.find("foo"));
+    REPORTER_ASSERT(reporter, 2 == data0.getRefCnt());
+
+    dict.set("foo", &data1);
+    REPORTER_ASSERT(reporter, &data1 == dict.find("foo"));
+    REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+    REPORTER_ASSERT(reporter, 2 == data1.getRefCnt());
+
+    dict.set("foo", NULL);
+    REPORTER_ASSERT(reporter, NULL == dict.find("foo"));
+    REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+    REPORTER_ASSERT(reporter, 1 == data1.getRefCnt());
+
+    dict.set("foo", &data0);
+    dict.set("bar", &data1);
+    REPORTER_ASSERT(reporter, &data0 == dict.find("foo"));
+    REPORTER_ASSERT(reporter, &data1 == dict.find("bar"));
+    REPORTER_ASSERT(reporter, 2 == data0.getRefCnt());
+    REPORTER_ASSERT(reporter, 2 == data1.getRefCnt());
+
+    dict.set("foo", &data1);
+    REPORTER_ASSERT(reporter, &data1 == dict.find("foo"));
+    REPORTER_ASSERT(reporter, &data1 == dict.find("bar"));
+    REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+    REPORTER_ASSERT(reporter, 3 == data1.getRefCnt());
+
+    dict.removeAll();
+    REPORTER_ASSERT(reporter, NULL == dict.find("foo"));
+    REPORTER_ASSERT(reporter, NULL == dict.find("bar"));
+    REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+    REPORTER_ASSERT(reporter, 1 == data1.getRefCnt());
+
+    {
+        SkRefDict d;
+        REPORTER_ASSERT(reporter, NULL == d.find("foo"));
+        REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+        d.set("foo", &data0);
+        REPORTER_ASSERT(reporter, &data0 == d.find("foo"));
+        REPORTER_ASSERT(reporter, 2 == data0.getRefCnt());
+        // let d go out of scope still with a ref on data0
+    }
+    // be sure d's destructor lowered data0's owner count back to 1
+    REPORTER_ASSERT(reporter, 1 == data0.getRefCnt());
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("RefDict", RefDictTestClass, TestRefDict)
diff --git a/tests/RegionTest.cpp b/tests/RegionTest.cpp
new file mode 100644
index 0000000..ee34d8b
--- /dev/null
+++ b/tests/RegionTest.cpp
@@ -0,0 +1,63 @@
+#include "Test.h"
+#include "SkRegion.h"
+#include "SkRandom.h"
+
+static void rand_rect(SkIRect* rect, SkRandom& rand) {
+    int bits = 6;
+    int shift = 32 - bits;
+    rect->set(rand.nextU() >> shift, rand.nextU() >> shift,
+              rand.nextU() >> shift, rand.nextU() >> shift);
+    rect->sort();
+}
+
+static bool test_rects(const SkIRect rect[], int count) {
+    SkRegion rgn0, rgn1;
+
+    for (int i = 0; i < count; i++) {
+        rgn0.op(rect[i], SkRegion::kUnion_Op);
+    }
+    rgn1.setRects(rect, count);
+
+    if (rgn0 != rgn1) {
+        SkDebugf("\n");
+        for (int i = 0; i < count; i++) {
+            SkDebugf(" { %d, %d, %d, %d },\n",
+                     rect[i].fLeft, rect[i].fTop,
+                     rect[i].fRight, rect[i].fBottom);
+        }
+        SkDebugf("\n");
+        return false;
+    }
+    return true;
+}
+
+static void TestRegion(skiatest::Reporter* reporter) {
+    const SkIRect r2[] = {
+        { 0, 0, 1, 1 },
+        { 2, 2, 3, 3 },
+    };
+    REPORTER_ASSERT(reporter, test_rects(r2, SK_ARRAY_COUNT(r2)));
+    
+    const SkIRect rects[] = {
+        { 0, 0, 1, 2 },
+        { 2, 1, 3, 3 },
+        { 4, 0, 5, 1 },
+        { 6, 0, 7, 4 },
+    };
+    REPORTER_ASSERT(reporter, test_rects(rects, SK_ARRAY_COUNT(rects)));
+
+    SkRandom rand;
+    for (int i = 0; i < 1000; i++) {
+        SkRegion rgn0, rgn1;
+
+        const int N = 8;
+        SkIRect rect[N];
+        for (int j = 0; j < N; j++) {
+            rand_rect(&rect[j], rand);
+        }
+        REPORTER_ASSERT(reporter, test_rects(rect, N));
+    }
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Region", RegionTestClass, TestRegion)
diff --git a/tests/StringTest.cpp b/tests/StringTest.cpp
index 344c752..270ccfd 100644
--- a/tests/StringTest.cpp
+++ b/tests/StringTest.cpp
@@ -48,6 +48,43 @@ static void TestString(skiatest::Reporter* reporter) {
     a.set("ab");
     a.set("abc");
     a.set("abcd");
+
+    a.set("");
+    a.appendS64(72036854775808LL, 0);
+    REPORTER_ASSERT(reporter, a.equals("72036854775808"));
+
+    a.set("");
+    a.appendS64(-1844674407370LL, 0);
+    REPORTER_ASSERT(reporter, a.equals("-1844674407370"));
+
+    a.set("");
+    a.appendS64(73709551616LL, 15);
+    REPORTER_ASSERT(reporter, a.equals("000073709551616"));
+
+    a.set("");
+    a.appendS64(-429496729612LL, 15);
+    REPORTER_ASSERT(reporter, a.equals("-000429496729612"));
+
+    static const struct {
+        SkScalar    fValue;
+        const char* fString;
+    } gRec[] = {
+        { 0,            "0" },
+        { SK_Scalar1,   "1" },
+        { -SK_Scalar1,  "-1" },
+        { SK_Scalar1/2, "0.5" },
+#ifdef SK_SCALAR_IS_FLOAT
+        { 3.4028234e38f,   "3.4028235e+38" },
+        { -3.4028234e38f, "-3.4028235e+38" },
+#endif
+    };
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
+        a.reset();
+        a.appendScalar(gRec[i].fValue);
+        REPORTER_ASSERT(reporter, a.size() <= SkStrAppendScalar_MaxSize);
+//        SkDebugf(" received <%s> expected <%s>\n", a.c_str(), gRec[i].fString);
+        REPORTER_ASSERT(reporter, a.equals(gRec[i].fString));
+    }
 }
 
 #include "TestClassDef.h"
diff --git a/tests/TestSize.cpp b/tests/TestSize.cpp
index 6551509..9e0aaaa 100644
--- a/tests/TestSize.cpp
+++ b/tests/TestSize.cpp
@@ -53,7 +53,7 @@ static void TestSize(skiatest::Reporter* reporter) {
     SkISize ia;
     ia.set(ix, iy);
     a.set(x, y);
-    REPORTER_ASSERT(reporter, a.round() == ia);
+    REPORTER_ASSERT(reporter, a.toRound() == ia);
 };
 
 #include "TestClassDef.h"
diff --git a/tests/UtilsTest.cpp b/tests/UtilsTest.cpp
index 8a8319c..2019a77 100644
--- a/tests/UtilsTest.cpp
+++ b/tests/UtilsTest.cpp
@@ -1,9 +1,71 @@
 #include "Test.h"
 #include "SkRandom.h"
+#include "SkRefCnt.h"
 #include "SkTSearch.h"
 #include "SkTSort.h"
 #include "SkUtils.h"
 
+class RefClass : public SkRefCnt {
+public:
+    RefClass(int n) : fN(n) {}
+    int get() const { return fN; }
+
+private:
+    int fN;
+};
+
+static void test_refptr(skiatest::Reporter* reporter) {
+    RefClass* r0 = new RefClass(0);
+
+    SkRefPtr<RefClass> rc0;
+    REPORTER_ASSERT(reporter, rc0.get() == NULL);
+    REPORTER_ASSERT(reporter, !rc0);
+
+    SkRefPtr<RefClass> rc1;
+    REPORTER_ASSERT(reporter, rc0 == rc1);
+    REPORTER_ASSERT(reporter, rc0.get() != r0);
+
+    rc0 = r0;
+    REPORTER_ASSERT(reporter, rc0);
+    REPORTER_ASSERT(reporter, rc0 != rc1);
+    REPORTER_ASSERT(reporter, rc0.get() == r0);
+
+    rc1 = rc0;
+    REPORTER_ASSERT(reporter, rc1);
+    REPORTER_ASSERT(reporter, rc0 == rc1);
+    REPORTER_ASSERT(reporter, rc0.get() == r0);
+
+    rc0 = NULL;
+    REPORTER_ASSERT(reporter, rc0.get() == NULL);
+    REPORTER_ASSERT(reporter, !rc0);
+    REPORTER_ASSERT(reporter, rc0 != rc1);
+
+    r0->unref();
+}
+
+static void test_autounref(skiatest::Reporter* reporter) {
+    RefClass obj(0);
+    REPORTER_ASSERT(reporter, 1 == obj.getRefCnt());
+
+    SkAutoTUnref<RefClass> tmp(&obj);
+    REPORTER_ASSERT(reporter, &obj == tmp.get());
+    REPORTER_ASSERT(reporter, 1 == obj.getRefCnt());
+
+    REPORTER_ASSERT(reporter, &obj == tmp.detach());
+    REPORTER_ASSERT(reporter, 1 == obj.getRefCnt());
+    REPORTER_ASSERT(reporter, NULL == tmp.detach());
+    REPORTER_ASSERT(reporter, NULL == tmp.get());
+
+    obj.ref();
+    REPORTER_ASSERT(reporter, 2 == obj.getRefCnt());
+    {
+        SkAutoTUnref<RefClass> tmp2(&obj);
+    }
+    REPORTER_ASSERT(reporter, 1 == obj.getRefCnt());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 #define kSEARCH_COUNT   91
 
 static void test_search(skiatest::Reporter* reporter) {
@@ -103,7 +165,9 @@ static void TestUTF(skiatest::Reporter* reporter) {
 
     test_utf16(reporter);
     test_search(reporter);
+    test_refptr(reporter);
+    test_autounref(reporter);
 }
 
 #include "TestClassDef.h"
-DEFINE_TESTCLASS("UTF", UtfTestClass, TestUTF)
+DEFINE_TESTCLASS("Utils", UtfTestClass, TestUTF)
diff --git a/tests/XfermodeTest.cpp b/tests/XfermodeTest.cpp
new file mode 100644
index 0000000..6ab6cd7
--- /dev/null
+++ b/tests/XfermodeTest.cpp
@@ -0,0 +1,30 @@
+#include "Test.h"
+#include "SkColor.h"
+#include "SkXfermode.h"
+
+SkPMColor bogusXfermodeProc(SkPMColor src, SkPMColor dst) {
+    return 42;
+}
+
+static void test_asMode(skiatest::Reporter* reporter) {
+    for (int mode = 0; mode <= SkXfermode::kLastMode; mode++) {
+        SkXfermode* xfer = SkXfermode::Create((SkXfermode::Mode) mode);
+        SkXfermode::Mode reportedMode = (SkXfermode::Mode) -1;
+        REPORTER_ASSERT(reporter,
+                        xfer != NULL || mode == SkXfermode::kSrcOver_Mode);
+        if (xfer) {
+          REPORTER_ASSERT(reporter, xfer->asMode(&reportedMode));
+          REPORTER_ASSERT(reporter, reportedMode == mode);
+          xfer->unref();
+        }
+    }
+
+    SkXfermode* bogusXfer = new SkProcXfermode(bogusXfermodeProc);
+    SkXfermode::Mode reportedMode = (SkXfermode::Mode) -1;
+    REPORTER_ASSERT(reporter, !bogusXfer->asMode(&reportedMode));
+    REPORTER_ASSERT(reporter, reportedMode == -1);
+    bogusXfer->unref();
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Xfermode", XfermodeTestClass, test_asMode)
diff --git a/xcode/GL.xcodeproj/project.pbxproj b/xcode/GL.xcodeproj/project.pbxproj
deleted file mode 100644
index 2d60cf8..0000000
--- a/xcode/GL.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,267 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DCF60EDCA0BD00F77EA2 /* SkGL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */; };
-		00B7DCF70EDCA0BD00F77EA2 /* SkGL.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */; };
-		00B7DCF80EDCA0BD00F77EA2 /* SkGLCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */; };
-		00B7DCF90EDCA0BD00F77EA2 /* SkGLDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */; };
-		00B7DCFA0EDCA0BD00F77EA2 /* SkGLDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */; };
-		00B7DCFB0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */; };
-		00B7DCFC0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */; };
-		00B7DCFD0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */; };
-		00B7DCFE0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */; };
-		00B7DCFF0EDCA0BD00F77EA2 /* SkGLTextCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */; };
-		00B7DD000EDCA0BD00F77EA2 /* SkGLTextCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */; };
-		00B7DD010EDCA0BD00F77EA2 /* SkTextureCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */; };
-		00B7DD020EDCA0BD00F77EA2 /* SkTextureCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGL.cpp; path = ../libsgl/gl/SkGL.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGL.h; path = ../libsgl/gl/SkGL.h; sourceTree = SOURCE_ROOT; };
-		00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLCanvas.cpp; path = ../libsgl/gl/SkGLCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice.cpp; path = ../libsgl/gl/SkGLDevice.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice.h; path = ../libsgl/gl/SkGLDevice.h; sourceTree = SOURCE_ROOT; };
-		00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_FBO.cpp; path = ../libsgl/gl/SkGLDevice_FBO.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_FBO.h; path = ../libsgl/gl/SkGLDevice_FBO.h; sourceTree = SOURCE_ROOT; };
-		00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_SWLayer.cpp; path = ../libsgl/gl/SkGLDevice_SWLayer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_SWLayer.h; path = ../libsgl/gl/SkGLDevice_SWLayer.h; sourceTree = SOURCE_ROOT; };
-		00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLTextCache.cpp; path = ../libsgl/gl/SkGLTextCache.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLTextCache.h; path = ../libsgl/gl/SkGLTextCache.h; sourceTree = SOURCE_ROOT; };
-		00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextureCache.cpp; path = ../libsgl/gl/SkTextureCache.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextureCache.h; path = ../libsgl/gl/SkTextureCache.h; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libGL.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libGL.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* GL */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = GL;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */,
-				00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */,
-				00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */,
-				00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */,
-				00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */,
-				00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */,
-				00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */,
-				00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */,
-				00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */,
-				00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */,
-				00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */,
-				00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */,
-				00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libGL.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DCF70EDCA0BD00F77EA2 /* SkGL.h in Headers */,
-				00B7DCFA0EDCA0BD00F77EA2 /* SkGLDevice.h in Headers */,
-				00B7DCFC0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h in Headers */,
-				00B7DCFE0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h in Headers */,
-				00B7DD000EDCA0BD00F77EA2 /* SkGLTextCache.h in Headers */,
-				00B7DD020EDCA0BD00F77EA2 /* SkTextureCache.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* GL */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "GL" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = GL;
-			productName = GL;
-			productReference = D2AAC046055464E500DB518D /* libGL.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "GL" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* GL */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				D2AAC045055464E500DB518D /* GL */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DCF60EDCA0BD00F77EA2 /* SkGL.cpp in Sources */,
-				00B7DCF80EDCA0BD00F77EA2 /* SkGLCanvas.cpp in Sources */,
-				00B7DCF90EDCA0BD00F77EA2 /* SkGLDevice.cpp in Sources */,
-				00B7DCFB0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp in Sources */,
-				00B7DCFD0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp in Sources */,
-				00B7DCFF0EDCA0BD00F77EA2 /* SkGLTextCache.cpp in Sources */,
-				00B7DD010EDCA0BD00F77EA2 /* SkTextureCache.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = GL;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = GL;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_DEBUG,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_SIGN_COMPARE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/corecg ../include/graphics";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_SIGN_COMPARE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/corecg ../include/graphics";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "GL" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "GL" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/SampleCode/English.lproj/InfoPlist.strings b/xcode/SampleCode/English.lproj/InfoPlist.strings
deleted file mode 100644
index e842e19..0000000
--- a/xcode/SampleCode/English.lproj/InfoPlist.strings
+++ /dev/null
@@ -1,3 +0,0 @@
-/* Localized versions of Info.plist keys */
-
-NSHumanReadableCopyright = "© __MyCompanyName__, 2008";
diff --git a/xcode/SampleCode/English.lproj/main.nib/classes.nib b/xcode/SampleCode/English.lproj/main.nib/classes.nib
deleted file mode 100644
index c4b887e..0000000
--- a/xcode/SampleCode/English.lproj/main.nib/classes.nib
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IBVersion</key>
-	<string>1</string>
-</dict>
-</plist>
diff --git a/xcode/SampleCode/English.lproj/main.nib/info.nib b/xcode/SampleCode/English.lproj/main.nib/info.nib
deleted file mode 100644
index 2af896b..0000000
--- a/xcode/SampleCode/English.lproj/main.nib/info.nib
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IBFramework Version</key>
-	<string>629</string>
-	<key>IBLastKnownRelativeProjectPath</key>
-	<string>../../SampleCode.xcodeproj</string>
-	<key>IBOldestOS</key>
-	<integer>5</integer>
-	<key>IBOpenObjects</key>
-	<array/>
-	<key>IBSystem Version</key>
-	<string>9B18</string>
-	<key>targetFramework</key>
-	<string>IBCarbonFramework</string>
-</dict>
-</plist>
diff --git a/xcode/SampleCode/English.lproj/main.nib/objects.xib b/xcode/SampleCode/English.lproj/main.nib/objects.xib
deleted file mode 100644
index a9e438e..0000000
--- a/xcode/SampleCode/English.lproj/main.nib/objects.xib
+++ /dev/null
@@ -1,269 +0,0 @@
-<?xml version="1.0" standalone="yes"?>
-<object class="NSIBObjectData">
-  <object name="rootObject" class="NSCustomObject" id="1">
-  </object>
-  <array count="38" name="allObjects">
-    <object class="IBCarbonMenuItem" id="193">
-      <string name="title">Arrange in Front</string>
-      <boolean name="dynamic">TRUE</boolean>
-      <int name="keyEquivalentModifier">1572864</int>
-      <ostype name="command">frnt</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="148">
-      <string name="title">Select All</string>
-      <string name="keyEquivalent">a</string>
-      <ostype name="command">sall</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="152">
-      <string name="title">Edit</string>
-      <object name="submenu" class="IBCarbonMenu" id="147">
-        <string name="title">Edit</string>
-        <array count="10" name="items">
-          <object class="IBCarbonMenuItem" id="141">
-            <string name="title">Undo</string>
-            <string name="keyEquivalent">z</string>
-            <ostype name="command">undo</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="146">
-            <string name="title">Redo</string>
-            <string name="keyEquivalent">Z</string>
-            <ostype name="command">redo</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="142">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="143">
-            <string name="title">Cut</string>
-            <string name="keyEquivalent">x</string>
-            <ostype name="command">cut </ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="149">
-            <string name="title">Copy</string>
-            <string name="keyEquivalent">c</string>
-            <ostype name="command">copy</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="144">
-            <string name="title">Paste</string>
-            <string name="keyEquivalent">v</string>
-            <ostype name="command">past</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="151">
-            <string name="title">Delete</string>
-            <ostype name="command">clea</ostype>
-          </object>
-          <reference idRef="148"/>
-          <object class="IBCarbonMenuItem" id="199">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="198">
-            <string name="title">Special Characters…</string>
-            <ostype name="command">chrp</ostype>
-          </object>
-        </array>
-      </object>
-    </object>
-    <object class="IBCarbonRootControl" id="167">
-      <string name="bounds">0 0 360 480 </string>
-    </object>
-    <object class="IBCarbonMenuItem" id="139">
-      <string name="title">New</string>
-      <string name="keyEquivalent">n</string>
-      <ostype name="command">new </ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="192">
-      <string name="title">Window</string>
-      <object name="submenu" class="IBCarbonMenu" id="195">
-        <string name="title">Window</string>
-        <string name="name">_NSWindowsMenu</string>
-        <array count="6" name="items">
-          <object class="IBCarbonMenuItem" id="190">
-            <string name="title">Minimize</string>
-            <string name="keyEquivalent">m</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <ostype name="command">mini</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="191">
-            <string name="title">Minimize All</string>
-            <string name="keyEquivalent">m</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <int name="keyEquivalentModifier">1572864</int>
-            <ostype name="command">mina</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="197">
-            <string name="title">Zoom</string>
-            <ostype name="command">zoom</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="194">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="196">
-            <string name="title">Bring All to Front</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <ostype name="command">bfrt</ostype>
-          </object>
-          <reference idRef="193"/>
-        </array>
-      </object>
-    </object>
-    <object class="IBCarbonMenuItem" id="132">
-      <string name="title">Revert</string>
-      <string name="keyEquivalent">r</string>
-      <ostype name="command">rvrt</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="187">
-      <string name="title">About Foo</string>
-      <int name="keyEquivalentModifier">0</int>
-      <ostype name="command">abou</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="138">
-      <string name="title">Save</string>
-      <string name="keyEquivalent">s</string>
-      <ostype name="command">save</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="137">
-      <string name="title">Save As…</string>
-      <string name="keyEquivalent">S</string>
-      <ostype name="command">svas</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="136">
-      <string name="title">Print…</string>
-      <string name="keyEquivalent">p</string>
-      <ostype name="command">prnt</ostype>
-    </object>
-    <reference idRef="146"/>
-    <reference idRef="142"/>
-    <reference idRef="143"/>
-    <object class="IBCarbonWindow" id="166">
-      <boolean name="liveResize">TRUE</boolean>
-      <int name="scalingMode">1048576</int>
-      <string name="title">Window</string>
-      <reference name="rootControl" idRef="167"/>
-      <string name="windowRect">1001 727 1361 1207 </string>
-      <string name="ScreenRectAtEncodeTime">0 0 768 1024 </string>
-    </object>
-    <reference idRef="199"/>
-    <object class="IBCarbonMenuItem" id="135">
-      <string name="title">Page Setup…</string>
-      <string name="keyEquivalent">P</string>
-      <ostype name="command">page</ostype>
-    </object>
-    <reference idRef="144"/>
-    <object class="IBCarbonMenuItem" id="134">
-      <string name="title">Open…</string>
-      <string name="keyEquivalent">o</string>
-      <ostype name="command">open</ostype>
-    </object>
-    <object class="IBCarbonMenu" id="131">
-      <string name="title">File</string>
-      <array count="10" name="items">
-        <reference idRef="139"/>
-        <reference idRef="134"/>
-        <object class="IBCarbonMenuItem" id="133">
-          <boolean name="separator">TRUE</boolean>
-        </object>
-        <object class="IBCarbonMenuItem" id="130">
-          <string name="title">Close</string>
-          <string name="keyEquivalent">w</string>
-          <ostype name="command">clos</ostype>
-        </object>
-        <reference idRef="138"/>
-        <reference idRef="137"/>
-        <reference idRef="132"/>
-        <object class="IBCarbonMenuItem" id="128">
-          <boolean name="separator">TRUE</boolean>
-        </object>
-        <reference idRef="135"/>
-        <reference idRef="136"/>
-      </array>
-    </object>
-    <reference idRef="128"/>
-    <reference idRef="141"/>
-    <reference idRef="198"/>
-    <object class="IBCarbonMenu" id="29">
-      <string name="title">main</string>
-      <string name="name">_NSMainMenu</string>
-      <array count="4" name="items">
-        <object class="IBCarbonMenuItem" id="185">
-          <string name="title">Foo</string>
-          <object name="submenu" class="IBCarbonMenu" id="184">
-            <string name="title">Foo</string>
-            <string name="name">_NSAppleMenu</string>
-            <array count="1" name="items">
-              <reference idRef="187"/>
-            </array>
-          </object>
-        </object>
-        <object class="IBCarbonMenuItem" id="127">
-          <string name="title">File</string>
-          <reference name="submenu" idRef="131"/>
-        </object>
-        <reference idRef="152"/>
-        <reference idRef="192"/>
-      </array>
-    </object>
-    <reference idRef="184"/>
-    <reference idRef="194"/>
-    <reference idRef="195"/>
-    <reference idRef="127"/>
-    <reference idRef="147"/>
-    <reference idRef="133"/>
-    <reference idRef="149"/>
-    <reference idRef="151"/>
-    <reference idRef="190"/>
-    <reference idRef="185"/>
-    <reference idRef="197"/>
-    <reference idRef="130"/>
-    <reference idRef="191"/>
-    <reference idRef="196"/>
-  </array>
-  <array count="38" name="allParents">
-    <reference idRef="195"/>
-    <reference idRef="147"/>
-    <reference idRef="29"/>
-    <reference idRef="166"/>
-    <reference idRef="131"/>
-    <reference idRef="29"/>
-    <reference idRef="131"/>
-    <reference idRef="184"/>
-    <reference idRef="131"/>
-    <reference idRef="131"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="1"/>
-    <reference idRef="147"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="131"/>
-    <reference idRef="127"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="1"/>
-    <reference idRef="185"/>
-    <reference idRef="195"/>
-    <reference idRef="192"/>
-    <reference idRef="29"/>
-    <reference idRef="152"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="195"/>
-    <reference idRef="29"/>
-    <reference idRef="195"/>
-    <reference idRef="131"/>
-    <reference idRef="195"/>
-    <reference idRef="195"/>
-  </array>
-  <dictionary count="3" name="nameTable">
-    <string>File&apos;s Owner</string>
-    <reference idRef="1"/>
-    <string>MainWindow</string>
-    <reference idRef="166"/>
-    <string>MenuBar</string>
-    <reference idRef="29"/>
-  </dictionary>
-  <string name="targetFramework">IBCarbonFramework</string>
-  <unsigned_int name="nextObjectID">200</unsigned_int>
-</object>
diff --git a/xcode/SampleCode/Info.plist b/xcode/SampleCode/Info.plist
deleted file mode 100644
index e12ff9b..0000000
--- a/xcode/SampleCode/Info.plist
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.SampleCode</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>
diff --git a/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj b/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj
deleted file mode 100644
index 685aea4..0000000
--- a/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,1067 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		0008AEE10DABF08F00477EFB /* libgiflib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0008AEDE0DABF01400477EFB /* libgiflib.a */; };
-		00152A800EE71EB60068F9B2 /* SkDumpCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */; };
-		0017F2CF0D6F3933008D9B31 /* libgraphics.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C440D3E999300651393 /* libgraphics.a */; };
-		0017F2D00D6F393F008D9B31 /* libcorecg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C2C0D3E999300651393 /* libcorecg.a */; };
-		0017F2D60D6F3949008D9B31 /* libviews.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C5E0D3E999300651393 /* libviews.a */; };
-		006860100D8A1C8B00CD71AA /* OpenGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0068600F0D8A1C8A00CD71AA /* OpenGL.framework */; };
-		006860290D8A1DFB00CD71AA /* AGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 006860280D8A1DFB00CD71AA /* AGL.framework */; };
-		0081D7800EE45EF100AB0A0A /* SampleRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */; };
-		0082BE7C0EE414DE00DEE451 /* SkSetPoly3To3.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */; };
-		009A74250DA11C5D00876C03 /* libGL.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 009A740E0DA11B1F00876C03 /* libGL.a */; };
-		00B7E3030EDCAF2000F77EA2 /* SampleAll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */; };
-		00B7E3040EDCAF2000F77EA2 /* SampleApp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */; };
-		00B7E3050EDCAF2000F77EA2 /* SampleArc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */; };
-		00B7E3060EDCAF2000F77EA2 /* SampleBitmapRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */; };
-		00B7E3070EDCAF2000F77EA2 /* SampleCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */; };
-		00B7E3080EDCAF2000F77EA2 /* SampleCircle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */; };
-		00B7E3090EDCAF2000F77EA2 /* SampleCull.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */; };
-		00B7E30A0EDCAF2000F77EA2 /* SampleDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */; };
-		00B7E30B0EDCAF2000F77EA2 /* SampleDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */; };
-		00B7E30C0EDCAF2000F77EA2 /* SampleEmboss.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */; };
-		00B7E30D0EDCAF2000F77EA2 /* SampleEncode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */; };
-		00B7E30F0EDCAF2000F77EA2 /* SampleFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */; };
-		00B7E3100EDCAF2000F77EA2 /* SampleFilter2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */; };
-		00B7E3110EDCAF2000F77EA2 /* SampleFontCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */; };
-		00B7E3130EDCAF2000F77EA2 /* SampleImage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */; };
-		00B7E3140EDCAF2000F77EA2 /* SampleImageDir.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */; };
-		00B7E3150EDCAF2000F77EA2 /* SampleLayers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */; };
-		00B7E3160EDCAF2000F77EA2 /* SampleLines.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */; };
-		00B7E3170EDCAF2000F77EA2 /* SampleMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */; };
-		00B7E3180EDCAF2000F77EA2 /* SampleNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */; };
-		00B7E3190EDCAF2000F77EA2 /* SampleOverflow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */; };
-		00B7E31A0EDCAF2000F77EA2 /* SamplePageFlip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */; };
-		00B7E31B0EDCAF2000F77EA2 /* SamplePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */; };
-		00B7E31C0EDCAF2000F77EA2 /* SamplePath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */; };
-		00B7E31D0EDCAF2000F77EA2 /* SamplePathEffects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */; };
-		00B7E31E0EDCAF2000F77EA2 /* SamplePicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */; };
-		00B7E31F0EDCAF2000F77EA2 /* SamplePoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */; };
-		00B7E3200EDCAF2000F77EA2 /* SamplePolyToPoly.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */; };
-		00B7E3220EDCAF2000F77EA2 /* SampleShaders.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */; };
-		00B7E3230EDCAF2000F77EA2 /* SampleStrokeText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */; };
-		00B7E3240EDCAF2000F77EA2 /* SampleTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */; };
-		00B7E3250EDCAF2000F77EA2 /* SampleText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */; };
-		00B7E3260EDCAF2000F77EA2 /* SampleTextAlpha.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */; };
-		00B7E3270EDCAF2000F77EA2 /* SampleTextEffects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */; };
-		00B7E3280EDCAF2000F77EA2 /* SampleTextOnPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */; };
-		00B7E3290EDCAF2000F77EA2 /* SampleTiling.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */; };
-		00B7E32A0EDCAF2000F77EA2 /* SampleTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */; };
-		00B7E32B0EDCAF2000F77EA2 /* SampleVertices.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */; };
-		00B7E32C0EDCAF2000F77EA2 /* SampleXfermodes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */; };
-		00B7E32D0EDCAF2000F77EA2 /* vertexdump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */; };
-		00B7E3560EDCB03600F77EA2 /* test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3520EDCB03600F77EA2 /* test.cpp */; };
-		00B7E3570EDCB03600F77EA2 /* test_drawcolor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */; };
-		00B7E3580EDCB03600F77EA2 /* test_drawrect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */; };
-		00D12E4D0DAD3D0A003918C5 /* libanimator.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0013C7920D94043200B41703 /* libanimator.a */; };
-		00ED8CD70D3E9FD900651393 /* libexpat.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C320D3E999300651393 /* libexpat.a */; };
-		00ED8CD80D3E9FDB00651393 /* libfreetype.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C380D3E999300651393 /* libfreetype.a */; };
-		00ED8CDB0D3E9FE300651393 /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C480D3E999300651393 /* libjpeg.a */; };
-		00ED8CDC0D3E9FE500651393 /* liblibpng.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C4C0D3E999300651393 /* liblibpng.a */; };
-		00ED8CDD0D3E9FE700651393 /* libports-mac.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C520D3E999300651393 /* libports-mac.a */; };
-		00ED8CDE0D3E9FEA00651393 /* libports.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C580D3E999300651393 /* libports.a */; };
-		00ED8CE00D3E9FEF00651393 /* libzlib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C620D3E999300651393 /* libzlib.a */; };
-		8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; };
-		8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; };
-		8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		0008AEDD0DABF01400477EFB /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0008AED90DABF01300477EFB /* giflib.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = giflib;
-		};
-		0008AF0F0DABF9BD00477EFB /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0008AED90DABF01300477EFB /* giflib.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = giflib;
-		};
-		0013C7910D94043200B41703 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0013C78A0D94043200B41703 /* animator.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = animator;
-		};
-		0013C7940D94044800B41703 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 0013C78A0D94043200B41703 /* animator.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = animator;
-		};
-		009A740D0DA11B1F00876C03 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 009A74060DA11B1F00876C03 /* GL.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = GL;
-		};
-		009A741C0DA11BAE00876C03 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 009A74060DA11B1F00876C03 /* GL.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = GL;
-		};
-		00ED8C2B0D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C060D3E999300651393 /* corecg.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = corecg;
-		};
-		00ED8C310D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C090D3E999300651393 /* expat.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = expat;
-		};
-		00ED8C370D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = freetype;
-		};
-		00ED8C430D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C120D3E999300651393 /* graphics.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC06F0554671400DB518D;
-			remoteInfo = graphics;
-		};
-		00ED8C470D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = jpeg;
-		};
-		00ED8C4B0D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C180D3E999300651393 /* libpng.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = libpng;
-		};
-		00ED8C510D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = "ports-mac";
-		};
-		00ED8C570D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = ports;
-		};
-		00ED8C5D0D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C210D3E999300651393 /* views.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = views;
-		};
-		00ED8C610D3E999300651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C240D3E999300651393 /* zlib.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = zlib;
-		};
-		00ED8C9D0D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = "ports-mac";
-		};
-		00ED8C9F0D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = ports;
-		};
-		00ED8CA10D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = jpeg;
-		};
-		00ED8CA30D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C120D3E999300651393 /* graphics.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC06E0554671400DB518D;
-			remoteInfo = graphics;
-		};
-		00ED8CA70D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C090D3E999300651393 /* expat.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = expat;
-		};
-		00ED8CA90D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C210D3E999300651393 /* views.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = views;
-		};
-		00ED8CAB0D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C060D3E999300651393 /* corecg.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = corecg;
-		};
-		00ED8CAD0D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C240D3E999300651393 /* zlib.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = zlib;
-		};
-		00ED8CAF0D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = freetype;
-		};
-		00ED8CB10D3E9AFA00651393 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00ED8C180D3E999300651393 /* libpng.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = libpng;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		0008AED90DABF01300477EFB /* giflib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = giflib.xcodeproj; path = ../giflib.xcodeproj; sourceTree = SOURCE_ROOT; };
-		0013C78A0D94043200B41703 /* animator.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = animator.xcodeproj; path = ../animator.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDumpCanvas.cpp; path = ../../libsgl/effects/SkDumpCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00152A810EE71EEC0068F9B2 /* SkDumpCanvas.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDumpCanvas.h; path = ../../include/graphics/SkDumpCanvas.h; sourceTree = SOURCE_ROOT; };
-		0068600F0D8A1C8A00CD71AA /* OpenGL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenGL.framework; path = SDKs/MacOSX10.5.sdk/System/Library/Frameworks/OpenGL.framework; sourceTree = SYSTEM_DEVELOPER_DIR; };
-		006860280D8A1DFB00CD71AA /* AGL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AGL.framework; path = SDKs/MacOSX10.5.sdk/System/Library/Frameworks/AGL.framework; sourceTree = SYSTEM_DEVELOPER_DIR; };
-		0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3.cpp; path = ../../test/SkSetPoly3To3.cpp; sourceTree = SOURCE_ROOT; };
-		0082BE7A0EE414DE00DEE451 /* SkSetPoly3To3_A.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3_A.cpp; path = ../../test/SkSetPoly3To3_A.cpp; sourceTree = SOURCE_ROOT; };
-		0082BE7B0EE414DE00DEE451 /* SkSetPoly3To3_D.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3_D.cpp; path = ../../test/SkSetPoly3To3_D.cpp; sourceTree = SOURCE_ROOT; };
-		009A74060DA11B1F00876C03 /* GL.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = GL.xcodeproj; path = ../GL.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleAll.cpp; path = ../../Samples/SampleAll.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleApp.cpp; path = ../../Samples/SampleApp.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleArc.cpp; path = ../../Samples/SampleArc.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleBitmapRect.cpp; path = ../../Samples/SampleBitmapRect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCamera.cpp; path = ../../Samples/SampleCamera.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCircle.cpp; path = ../../Samples/SampleCircle.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2DD0EDCAF2000F77EA2 /* SampleCode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SampleCode.h; path = ../../Samples/SampleCode.h; sourceTree = SOURCE_ROOT; };
-		00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCull.cpp; path = ../../Samples/SampleCull.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleDither.cpp; path = ../../Samples/SampleDither.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleDrawLooper.cpp; path = ../../Samples/SampleDrawLooper.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleEmboss.cpp; path = ../../Samples/SampleEmboss.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleEncode.cpp; path = ../../Samples/SampleEncode.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E30EDCAF2000F77EA2 /* SampleFillType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFillType.cpp; path = ../../Samples/SampleFillType.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFilter.cpp; path = ../../Samples/SampleFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFilter2.cpp; path = ../../Samples/SampleFilter2.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFontCache.cpp; path = ../../Samples/SampleFontCache.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E70EDCAF2000F77EA2 /* SampleGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleGL.cpp; path = ../../Samples/SampleGL.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleImage.cpp; path = ../../Samples/SampleImage.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleImageDir.cpp; path = ../../Samples/SampleImageDir.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleLayers.cpp; path = ../../Samples/SampleLayers.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleLines.cpp; path = ../../Samples/SampleLines.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleMeasure.cpp; path = ../../Samples/SampleMeasure.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleNinePatch.cpp; path = ../../Samples/SampleNinePatch.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleOverflow.cpp; path = ../../Samples/SampleOverflow.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePageFlip.cpp; path = ../../Samples/SamplePageFlip.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePatch.cpp; path = ../../Samples/SamplePatch.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePath.cpp; path = ../../Samples/SamplePath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePathEffects.cpp; path = ../../Samples/SamplePathEffects.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePicture.cpp; path = ../../Samples/SamplePicture.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePoints.cpp; path = ../../Samples/SamplePoints.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePolyToPoly.cpp; path = ../../Samples/SamplePolyToPoly.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleRegion.cpp; path = ../../Samples/SampleRegion.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleShaders.cpp; path = ../../Samples/SampleShaders.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleStrokeText.cpp; path = ../../Samples/SampleStrokeText.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTests.cpp; path = ../../Samples/SampleTests.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleText.cpp; path = ../../Samples/SampleText.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextAlpha.cpp; path = ../../Samples/SampleTextAlpha.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextEffects.cpp; path = ../../Samples/SampleTextEffects.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextOnPath.cpp; path = ../../Samples/SampleTextOnPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTiling.cpp; path = ../../Samples/SampleTiling.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTypeface.cpp; path = ../../Samples/SampleTypeface.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleVertices.cpp; path = ../../Samples/SampleVertices.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleXfermodes.cpp; path = ../../Samples/SampleXfermodes.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vertexdump.cpp; path = ../../Samples/vertexdump.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3430EDCAFA600F77EA2 /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; };
-		00B7E3520EDCB03600F77EA2 /* test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test.cpp; path = ../../test/test.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3530EDCB03600F77EA2 /* test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = test.h; path = ../../test/test.h; sourceTree = SOURCE_ROOT; };
-		00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test_drawcolor.cpp; path = ../../test/test_drawcolor.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test_drawrect.cpp; path = ../../test/test_drawrect.cpp; sourceTree = SOURCE_ROOT; };
-		00ED8C060D3E999300651393 /* corecg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = corecg.xcodeproj; path = ../corecg.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C090D3E999300651393 /* expat.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = expat.xcodeproj; path = ../expat.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = freetype2.xcodeproj; path = ../freetype2.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C120D3E999300651393 /* graphics.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = graphics.xcodeproj; path = ../graphics.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C150D3E999300651393 /* jpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = jpeg.xcodeproj; path = ../jpeg.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C180D3E999300651393 /* libpng.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = libpng.xcodeproj; path = ../libpng.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = "ports-mac.xcodeproj"; path = "../ports-mac.xcodeproj"; sourceTree = SOURCE_ROOT; };
-		00ED8C1E0D3E999300651393 /* ports.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = ports.xcodeproj; path = ../ports.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C210D3E999300651393 /* views.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = views.xcodeproj; path = ../views.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00ED8C240D3E999300651393 /* zlib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = zlib.xcodeproj; path = ../zlib.xcodeproj; sourceTree = SOURCE_ROOT; };
-		0867D6ABFE840B52C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		1870340FFE93FCAF11CA0CD7 /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/main.nib; sourceTree = "<group>"; };
-		20286C33FDCF999611CA2CEA /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; };
-		8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		8D0C4E970486CD37000505A6 /* SampleCode.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = SampleCode.app; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8D0C4E910486CD37000505A6 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00ED8CD70D3E9FD900651393 /* libexpat.a in Frameworks */,
-				00ED8CD80D3E9FDB00651393 /* libfreetype.a in Frameworks */,
-				00ED8CDB0D3E9FE300651393 /* libjpeg.a in Frameworks */,
-				00ED8CDC0D3E9FE500651393 /* liblibpng.a in Frameworks */,
-				00ED8CDD0D3E9FE700651393 /* libports-mac.a in Frameworks */,
-				00ED8CDE0D3E9FEA00651393 /* libports.a in Frameworks */,
-				00ED8CE00D3E9FEF00651393 /* libzlib.a in Frameworks */,
-				8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */,
-				0017F2CF0D6F3933008D9B31 /* libgraphics.a in Frameworks */,
-				0017F2D00D6F393F008D9B31 /* libcorecg.a in Frameworks */,
-				0017F2D60D6F3949008D9B31 /* libviews.a in Frameworks */,
-				006860100D8A1C8B00CD71AA /* OpenGL.framework in Frameworks */,
-				006860290D8A1DFB00CD71AA /* AGL.framework in Frameworks */,
-				009A74250DA11C5D00876C03 /* libGL.a in Frameworks */,
-				0008AEE10DABF08F00477EFB /* libgiflib.a in Frameworks */,
-				00D12E4D0DAD3D0A003918C5 /* libanimator.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		0008AEDA0DABF01300477EFB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				0008AEDE0DABF01400477EFB /* libgiflib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		0013C78B0D94043200B41703 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				0013C7920D94043200B41703 /* libanimator.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		009A74070DA11B1F00876C03 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				009A740E0DA11B1F00876C03 /* libGL.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00B7E2D60EDCAF0E00F77EA2 /* Samples */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E3430EDCAFA600F77EA2 /* SkGeometry.h */,
-				00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */,
-				00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */,
-				00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */,
-				00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */,
-				00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */,
-				00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */,
-				00B7E2DD0EDCAF2000F77EA2 /* SampleCode.h */,
-				00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */,
-				00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */,
-				00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */,
-				00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */,
-				00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */,
-				00B7E2E30EDCAF2000F77EA2 /* SampleFillType.cpp */,
-				00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */,
-				00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */,
-				00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */,
-				00B7E2E70EDCAF2000F77EA2 /* SampleGL.cpp */,
-				00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */,
-				00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */,
-				00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */,
-				00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */,
-				00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */,
-				00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */,
-				00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */,
-				00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */,
-				00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */,
-				00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */,
-				00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */,
-				00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */,
-				00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */,
-				00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */,
-				00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */,
-				00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */,
-				00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */,
-				00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */,
-				00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */,
-				00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */,
-				00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */,
-				00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */,
-				00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */,
-				00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */,
-				00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */,
-				00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */,
-				00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */,
-			);
-			name = Samples;
-			sourceTree = "<group>";
-		};
-		00B7E3510EDCB02800F77EA2 /* tests */ = {
-			isa = PBXGroup;
-			children = (
-				00152A810EE71EEC0068F9B2 /* SkDumpCanvas.h */,
-				00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */,
-				0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */,
-				0082BE7A0EE414DE00DEE451 /* SkSetPoly3To3_A.cpp */,
-				0082BE7B0EE414DE00DEE451 /* SkSetPoly3To3_D.cpp */,
-				00B7E3520EDCB03600F77EA2 /* test.cpp */,
-				00B7E3530EDCB03600F77EA2 /* test.h */,
-				00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */,
-				00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */,
-			);
-			name = tests;
-			sourceTree = "<group>";
-		};
-		00ED8C070D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C2C0D3E999300651393 /* libcorecg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C0A0D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C320D3E999300651393 /* libexpat.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C0D0D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C380D3E999300651393 /* libfreetype.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C130D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C440D3E999300651393 /* libgraphics.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C160D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C480D3E999300651393 /* libjpeg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C190D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C4C0D3E999300651393 /* liblibpng.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C1C0D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C520D3E999300651393 /* libports-mac.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C1F0D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C580D3E999300651393 /* libports.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C220D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C5E0D3E999300651393 /* libviews.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00ED8C250D3E999300651393 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00ED8C620D3E999300651393 /* libzlib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		195DF8CFFE9D517E11CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				8D0C4E970486CD37000505A6 /* SampleCode.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		20286C29FDCF999611CA2CEA /* SampleCode */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E3510EDCB02800F77EA2 /* tests */,
-				00B7E2D60EDCAF0E00F77EA2 /* Samples */,
-				0008AED90DABF01300477EFB /* giflib.xcodeproj */,
-				009A74060DA11B1F00876C03 /* GL.xcodeproj */,
-				0013C78A0D94043200B41703 /* animator.xcodeproj */,
-				00ED8C060D3E999300651393 /* corecg.xcodeproj */,
-				00ED8C090D3E999300651393 /* expat.xcodeproj */,
-				00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */,
-				00ED8C120D3E999300651393 /* graphics.xcodeproj */,
-				00ED8C150D3E999300651393 /* jpeg.xcodeproj */,
-				00ED8C180D3E999300651393 /* libpng.xcodeproj */,
-				00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */,
-				00ED8C1E0D3E999300651393 /* ports.xcodeproj */,
-				00ED8C210D3E999300651393 /* views.xcodeproj */,
-				00ED8C240D3E999300651393 /* zlib.xcodeproj */,
-				20286C2CFDCF999611CA2CEA /* Resources */,
-				20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */,
-				195DF8CFFE9D517E11CA2CBB /* Products */,
-			);
-			name = SampleCode;
-			sourceTree = "<group>";
-		};
-		20286C2CFDCF999611CA2CEA /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				8D0C4E960486CD37000505A6 /* Info.plist */,
-				0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */,
-				02345980000FD03B11CA0E72 /* main.nib */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */ = {
-			isa = PBXGroup;
-			children = (
-				006860280D8A1DFB00CD71AA /* AGL.framework */,
-				0068600F0D8A1C8A00CD71AA /* OpenGL.framework */,
-				20286C33FDCF999611CA2CEA /* Carbon.framework */,
-			);
-			name = "External Frameworks and Libraries";
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		8D0C4E890486CD37000505A6 /* SampleCode */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "SampleCode" */;
-			buildPhases = (
-				8D0C4E8C0486CD37000505A6 /* Resources */,
-				8D0C4E8F0486CD37000505A6 /* Sources */,
-				8D0C4E910486CD37000505A6 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				00ED8C9E0D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CA00D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CA20D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CA40D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CA80D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CAA0D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CAC0D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CAE0D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CB00D3E9AFA00651393 /* PBXTargetDependency */,
-				00ED8CB20D3E9AFA00651393 /* PBXTargetDependency */,
-				0013C7950D94044800B41703 /* PBXTargetDependency */,
-				009A741D0DA11BAE00876C03 /* PBXTargetDependency */,
-				0008AF100DABF9BD00477EFB /* PBXTargetDependency */,
-			);
-			name = SampleCode;
-			productInstallPath = "$(HOME)/Applications";
-			productName = SampleCode;
-			productReference = 8D0C4E970486CD37000505A6 /* SampleCode.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		20286C28FDCF999611CA2CEA /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "SampleCode" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 20286C29FDCF999611CA2CEA /* SampleCode */;
-			projectDirPath = "";
-			projectReferences = (
-				{
-					ProductGroup = 0013C78B0D94043200B41703 /* Products */;
-					ProjectRef = 0013C78A0D94043200B41703 /* animator.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C070D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C060D3E999300651393 /* corecg.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C0A0D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C090D3E999300651393 /* expat.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C0D0D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */;
-				},
-				{
-					ProductGroup = 0008AEDA0DABF01300477EFB /* Products */;
-					ProjectRef = 0008AED90DABF01300477EFB /* giflib.xcodeproj */;
-				},
-				{
-					ProductGroup = 009A74070DA11B1F00876C03 /* Products */;
-					ProjectRef = 009A74060DA11B1F00876C03 /* GL.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C130D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C120D3E999300651393 /* graphics.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C160D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C190D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C180D3E999300651393 /* libpng.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C1C0D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C1F0D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C220D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C210D3E999300651393 /* views.xcodeproj */;
-				},
-				{
-					ProductGroup = 00ED8C250D3E999300651393 /* Products */;
-					ProjectRef = 00ED8C240D3E999300651393 /* zlib.xcodeproj */;
-				},
-			);
-			projectRoot = "";
-			targets = (
-				8D0C4E890486CD37000505A6 /* SampleCode */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXReferenceProxy section */
-		0008AEDE0DABF01400477EFB /* libgiflib.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libgiflib.a;
-			remoteRef = 0008AEDD0DABF01400477EFB /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		0013C7920D94043200B41703 /* libanimator.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libanimator.a;
-			remoteRef = 0013C7910D94043200B41703 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		009A740E0DA11B1F00876C03 /* libGL.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libGL.a;
-			remoteRef = 009A740D0DA11B1F00876C03 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C2C0D3E999300651393 /* libcorecg.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libcorecg.a;
-			remoteRef = 00ED8C2B0D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C320D3E999300651393 /* libexpat.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libexpat.a;
-			remoteRef = 00ED8C310D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C380D3E999300651393 /* libfreetype.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libfreetype.a;
-			remoteRef = 00ED8C370D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C440D3E999300651393 /* libgraphics.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libgraphics.a;
-			remoteRef = 00ED8C430D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C480D3E999300651393 /* libjpeg.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libjpeg.a;
-			remoteRef = 00ED8C470D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C4C0D3E999300651393 /* liblibpng.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = liblibpng.a;
-			remoteRef = 00ED8C4B0D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C520D3E999300651393 /* libports-mac.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = "libports-mac.a";
-			remoteRef = 00ED8C510D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C580D3E999300651393 /* libports.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libports.a;
-			remoteRef = 00ED8C570D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C5E0D3E999300651393 /* libviews.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libviews.a;
-			remoteRef = 00ED8C5D0D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00ED8C620D3E999300651393 /* libzlib.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libzlib.a;
-			remoteRef = 00ED8C610D3E999300651393 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-/* End PBXReferenceProxy section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D0C4E8C0486CD37000505A6 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */,
-				8D0C4E8E0486CD37000505A6 /* main.nib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8D0C4E8F0486CD37000505A6 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E3030EDCAF2000F77EA2 /* SampleAll.cpp in Sources */,
-				00B7E3040EDCAF2000F77EA2 /* SampleApp.cpp in Sources */,
-				00B7E3060EDCAF2000F77EA2 /* SampleBitmapRect.cpp in Sources */,
-				00B7E3070EDCAF2000F77EA2 /* SampleCamera.cpp in Sources */,
-				00B7E3090EDCAF2000F77EA2 /* SampleCull.cpp in Sources */,
-				00B7E30B0EDCAF2000F77EA2 /* SampleDrawLooper.cpp in Sources */,
-				00B7E30C0EDCAF2000F77EA2 /* SampleEmboss.cpp in Sources */,
-				00B7E30D0EDCAF2000F77EA2 /* SampleEncode.cpp in Sources */,
-				00B7E30F0EDCAF2000F77EA2 /* SampleFilter.cpp in Sources */,
-				00B7E3100EDCAF2000F77EA2 /* SampleFilter2.cpp in Sources */,
-				00B7E3110EDCAF2000F77EA2 /* SampleFontCache.cpp in Sources */,
-				00B7E3130EDCAF2000F77EA2 /* SampleImage.cpp in Sources */,
-				00B7E3140EDCAF2000F77EA2 /* SampleImageDir.cpp in Sources */,
-				00B7E3150EDCAF2000F77EA2 /* SampleLayers.cpp in Sources */,
-				00B7E3160EDCAF2000F77EA2 /* SampleLines.cpp in Sources */,
-				00B7E3170EDCAF2000F77EA2 /* SampleMeasure.cpp in Sources */,
-				00B7E3180EDCAF2000F77EA2 /* SampleNinePatch.cpp in Sources */,
-				00B7E3190EDCAF2000F77EA2 /* SampleOverflow.cpp in Sources */,
-				00B7E31A0EDCAF2000F77EA2 /* SamplePageFlip.cpp in Sources */,
-				00B7E31B0EDCAF2000F77EA2 /* SamplePatch.cpp in Sources */,
-				00B7E31C0EDCAF2000F77EA2 /* SamplePath.cpp in Sources */,
-				00B7E31D0EDCAF2000F77EA2 /* SamplePathEffects.cpp in Sources */,
-				00B7E31E0EDCAF2000F77EA2 /* SamplePicture.cpp in Sources */,
-				00B7E31F0EDCAF2000F77EA2 /* SamplePoints.cpp in Sources */,
-				00B7E3200EDCAF2000F77EA2 /* SamplePolyToPoly.cpp in Sources */,
-				00B7E3220EDCAF2000F77EA2 /* SampleShaders.cpp in Sources */,
-				00B7E3230EDCAF2000F77EA2 /* SampleStrokeText.cpp in Sources */,
-				00B7E3240EDCAF2000F77EA2 /* SampleTests.cpp in Sources */,
-				00B7E3250EDCAF2000F77EA2 /* SampleText.cpp in Sources */,
-				00B7E3260EDCAF2000F77EA2 /* SampleTextAlpha.cpp in Sources */,
-				00B7E3270EDCAF2000F77EA2 /* SampleTextEffects.cpp in Sources */,
-				00B7E3280EDCAF2000F77EA2 /* SampleTextOnPath.cpp in Sources */,
-				00B7E3290EDCAF2000F77EA2 /* SampleTiling.cpp in Sources */,
-				00B7E32A0EDCAF2000F77EA2 /* SampleTypeface.cpp in Sources */,
-				00B7E32B0EDCAF2000F77EA2 /* SampleVertices.cpp in Sources */,
-				00B7E32C0EDCAF2000F77EA2 /* SampleXfermodes.cpp in Sources */,
-				00B7E32D0EDCAF2000F77EA2 /* vertexdump.cpp in Sources */,
-				00B7E3560EDCB03600F77EA2 /* test.cpp in Sources */,
-				00B7E3570EDCB03600F77EA2 /* test_drawcolor.cpp in Sources */,
-				00B7E3580EDCB03600F77EA2 /* test_drawrect.cpp in Sources */,
-				0082BE7C0EE414DE00DEE451 /* SkSetPoly3To3.cpp in Sources */,
-				0081D7800EE45EF100AB0A0A /* SampleRegion.cpp in Sources */,
-				00152A800EE71EB60068F9B2 /* SkDumpCanvas.cpp in Sources */,
-				00B7E3080EDCAF2000F77EA2 /* SampleCircle.cpp in Sources */,
-				00B7E3050EDCAF2000F77EA2 /* SampleArc.cpp in Sources */,
-				00B7E30A0EDCAF2000F77EA2 /* SampleDither.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		0008AF100DABF9BD00477EFB /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = giflib;
-			targetProxy = 0008AF0F0DABF9BD00477EFB /* PBXContainerItemProxy */;
-		};
-		0013C7950D94044800B41703 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = animator;
-			targetProxy = 0013C7940D94044800B41703 /* PBXContainerItemProxy */;
-		};
-		009A741D0DA11BAE00876C03 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = GL;
-			targetProxy = 009A741C0DA11BAE00876C03 /* PBXContainerItemProxy */;
-		};
-		00ED8C9E0D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = "ports-mac";
-			targetProxy = 00ED8C9D0D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CA00D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = ports;
-			targetProxy = 00ED8C9F0D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CA20D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = jpeg;
-			targetProxy = 00ED8CA10D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CA40D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = graphics;
-			targetProxy = 00ED8CA30D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CA80D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = expat;
-			targetProxy = 00ED8CA70D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CAA0D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = views;
-			targetProxy = 00ED8CA90D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CAC0D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = corecg;
-			targetProxy = 00ED8CAB0D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CAE0D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = zlib;
-			targetProxy = 00ED8CAD0D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CB00D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = freetype;
-			targetProxy = 00ED8CAF0D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-		00ED8CB20D3E9AFA00651393 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = libpng;
-			targetProxy = 00ED8CB10D3E9AFA00651393 /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin PBXVariantGroup section */
-		02345980000FD03B11CA0E72 /* main.nib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				1870340FFE93FCAF11CA0CD7 /* English */,
-			);
-			name = main.nib;
-			sourceTree = "<group>";
-		};
-		0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */ = {
-			isa = PBXVariantGroup;
-			children = (
-				0867D6ABFE840B52C02AAC07 /* English */,
-			);
-			name = InfoPlist.strings;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		006B85250EED8C4400938119 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_DEBUGGING_SYMBOLS = full;
-				GCC_ENABLE_ASM_KEYWORD = NO;
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_OPTIMIZATION_LEVEL = 2;
-				GCC_PREFIX_HEADER = " ";
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_RELEASE,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				USER_HEADER_SEARCH_PATHS = "../../include/**";
-			};
-			name = Release;
-		};
-		006B85260EED8C4400938119 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-				);
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(DEVELOPER_DIR)/SDKs/MacOSX10.5.sdk/System/Library/Frameworks\"";
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = NO;
-				GCC_PREFIX_HEADER = SampleCode_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = SampleCode;
-				WRAPPER_EXTENSION = app;
-				ZERO_LINK = YES;
-			};
-			name = Release;
-		};
-		C0E91AC608A95435008D54AB /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-				);
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(DEVELOPER_DIR)/SDKs/MacOSX10.5.sdk/System/Library/Frameworks\"";
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = NO;
-				GCC_PREFIX_HEADER = SampleCode_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = SampleCode;
-				WRAPPER_EXTENSION = app;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		C0E91ACA08A95435008D54AB /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_DEBUGGING_SYMBOLS = full;
-				GCC_ENABLE_ASM_KEYWORD = NO;
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREFIX_HEADER = " ";
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_DEBUG,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				USER_HEADER_SEARCH_PATHS = "../../include/**";
-			};
-			name = Debug;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "SampleCode" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C0E91AC608A95435008D54AB /* Debug */,
-				006B85260EED8C4400938119 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "SampleCode" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C0E91ACA08A95435008D54AB /* Debug */,
-				006B85250EED8C4400938119 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 20286C28FDCF999611CA2CEA /* Project object */;
-}
diff --git a/xcode/SampleCode/SampleCode_Prefix.pch b/xcode/SampleCode/SampleCode_Prefix.pch
deleted file mode 100644
index e69de29..0000000
--- a/xcode/SampleCode/SampleCode_Prefix.pch
+++ /dev/null
diff --git a/xcode/Simple/English.lproj/InfoPlist.strings b/xcode/Simple/English.lproj/InfoPlist.strings
deleted file mode 100644
index 26bf880..0000000
--- a/xcode/Simple/English.lproj/InfoPlist.strings
+++ /dev/null
diff --git a/xcode/Simple/English.lproj/main.nib/classes.nib b/xcode/Simple/English.lproj/main.nib/classes.nib
deleted file mode 100644
index c4b887e..0000000
--- a/xcode/Simple/English.lproj/main.nib/classes.nib
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IBVersion</key>
-	<string>1</string>
-</dict>
-</plist>
diff --git a/xcode/Simple/English.lproj/main.nib/info.nib b/xcode/Simple/English.lproj/main.nib/info.nib
deleted file mode 100644
index 2af896b..0000000
--- a/xcode/Simple/English.lproj/main.nib/info.nib
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IBFramework Version</key>
-	<string>629</string>
-	<key>IBLastKnownRelativeProjectPath</key>
-	<string>../../SampleCode.xcodeproj</string>
-	<key>IBOldestOS</key>
-	<integer>5</integer>
-	<key>IBOpenObjects</key>
-	<array/>
-	<key>IBSystem Version</key>
-	<string>9B18</string>
-	<key>targetFramework</key>
-	<string>IBCarbonFramework</string>
-</dict>
-</plist>
diff --git a/xcode/Simple/English.lproj/main.nib/objects.xib b/xcode/Simple/English.lproj/main.nib/objects.xib
deleted file mode 100644
index a9e438e..0000000
--- a/xcode/Simple/English.lproj/main.nib/objects.xib
+++ /dev/null
@@ -1,269 +0,0 @@
-<?xml version="1.0" standalone="yes"?>
-<object class="NSIBObjectData">
-  <object name="rootObject" class="NSCustomObject" id="1">
-  </object>
-  <array count="38" name="allObjects">
-    <object class="IBCarbonMenuItem" id="193">
-      <string name="title">Arrange in Front</string>
-      <boolean name="dynamic">TRUE</boolean>
-      <int name="keyEquivalentModifier">1572864</int>
-      <ostype name="command">frnt</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="148">
-      <string name="title">Select All</string>
-      <string name="keyEquivalent">a</string>
-      <ostype name="command">sall</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="152">
-      <string name="title">Edit</string>
-      <object name="submenu" class="IBCarbonMenu" id="147">
-        <string name="title">Edit</string>
-        <array count="10" name="items">
-          <object class="IBCarbonMenuItem" id="141">
-            <string name="title">Undo</string>
-            <string name="keyEquivalent">z</string>
-            <ostype name="command">undo</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="146">
-            <string name="title">Redo</string>
-            <string name="keyEquivalent">Z</string>
-            <ostype name="command">redo</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="142">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="143">
-            <string name="title">Cut</string>
-            <string name="keyEquivalent">x</string>
-            <ostype name="command">cut </ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="149">
-            <string name="title">Copy</string>
-            <string name="keyEquivalent">c</string>
-            <ostype name="command">copy</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="144">
-            <string name="title">Paste</string>
-            <string name="keyEquivalent">v</string>
-            <ostype name="command">past</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="151">
-            <string name="title">Delete</string>
-            <ostype name="command">clea</ostype>
-          </object>
-          <reference idRef="148"/>
-          <object class="IBCarbonMenuItem" id="199">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="198">
-            <string name="title">Special Characters…</string>
-            <ostype name="command">chrp</ostype>
-          </object>
-        </array>
-      </object>
-    </object>
-    <object class="IBCarbonRootControl" id="167">
-      <string name="bounds">0 0 360 480 </string>
-    </object>
-    <object class="IBCarbonMenuItem" id="139">
-      <string name="title">New</string>
-      <string name="keyEquivalent">n</string>
-      <ostype name="command">new </ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="192">
-      <string name="title">Window</string>
-      <object name="submenu" class="IBCarbonMenu" id="195">
-        <string name="title">Window</string>
-        <string name="name">_NSWindowsMenu</string>
-        <array count="6" name="items">
-          <object class="IBCarbonMenuItem" id="190">
-            <string name="title">Minimize</string>
-            <string name="keyEquivalent">m</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <ostype name="command">mini</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="191">
-            <string name="title">Minimize All</string>
-            <string name="keyEquivalent">m</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <int name="keyEquivalentModifier">1572864</int>
-            <ostype name="command">mina</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="197">
-            <string name="title">Zoom</string>
-            <ostype name="command">zoom</ostype>
-          </object>
-          <object class="IBCarbonMenuItem" id="194">
-            <boolean name="separator">TRUE</boolean>
-          </object>
-          <object class="IBCarbonMenuItem" id="196">
-            <string name="title">Bring All to Front</string>
-            <boolean name="dynamic">TRUE</boolean>
-            <ostype name="command">bfrt</ostype>
-          </object>
-          <reference idRef="193"/>
-        </array>
-      </object>
-    </object>
-    <object class="IBCarbonMenuItem" id="132">
-      <string name="title">Revert</string>
-      <string name="keyEquivalent">r</string>
-      <ostype name="command">rvrt</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="187">
-      <string name="title">About Foo</string>
-      <int name="keyEquivalentModifier">0</int>
-      <ostype name="command">abou</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="138">
-      <string name="title">Save</string>
-      <string name="keyEquivalent">s</string>
-      <ostype name="command">save</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="137">
-      <string name="title">Save As…</string>
-      <string name="keyEquivalent">S</string>
-      <ostype name="command">svas</ostype>
-    </object>
-    <object class="IBCarbonMenuItem" id="136">
-      <string name="title">Print…</string>
-      <string name="keyEquivalent">p</string>
-      <ostype name="command">prnt</ostype>
-    </object>
-    <reference idRef="146"/>
-    <reference idRef="142"/>
-    <reference idRef="143"/>
-    <object class="IBCarbonWindow" id="166">
-      <boolean name="liveResize">TRUE</boolean>
-      <int name="scalingMode">1048576</int>
-      <string name="title">Window</string>
-      <reference name="rootControl" idRef="167"/>
-      <string name="windowRect">1001 727 1361 1207 </string>
-      <string name="ScreenRectAtEncodeTime">0 0 768 1024 </string>
-    </object>
-    <reference idRef="199"/>
-    <object class="IBCarbonMenuItem" id="135">
-      <string name="title">Page Setup…</string>
-      <string name="keyEquivalent">P</string>
-      <ostype name="command">page</ostype>
-    </object>
-    <reference idRef="144"/>
-    <object class="IBCarbonMenuItem" id="134">
-      <string name="title">Open…</string>
-      <string name="keyEquivalent">o</string>
-      <ostype name="command">open</ostype>
-    </object>
-    <object class="IBCarbonMenu" id="131">
-      <string name="title">File</string>
-      <array count="10" name="items">
-        <reference idRef="139"/>
-        <reference idRef="134"/>
-        <object class="IBCarbonMenuItem" id="133">
-          <boolean name="separator">TRUE</boolean>
-        </object>
-        <object class="IBCarbonMenuItem" id="130">
-          <string name="title">Close</string>
-          <string name="keyEquivalent">w</string>
-          <ostype name="command">clos</ostype>
-        </object>
-        <reference idRef="138"/>
-        <reference idRef="137"/>
-        <reference idRef="132"/>
-        <object class="IBCarbonMenuItem" id="128">
-          <boolean name="separator">TRUE</boolean>
-        </object>
-        <reference idRef="135"/>
-        <reference idRef="136"/>
-      </array>
-    </object>
-    <reference idRef="128"/>
-    <reference idRef="141"/>
-    <reference idRef="198"/>
-    <object class="IBCarbonMenu" id="29">
-      <string name="title">main</string>
-      <string name="name">_NSMainMenu</string>
-      <array count="4" name="items">
-        <object class="IBCarbonMenuItem" id="185">
-          <string name="title">Foo</string>
-          <object name="submenu" class="IBCarbonMenu" id="184">
-            <string name="title">Foo</string>
-            <string name="name">_NSAppleMenu</string>
-            <array count="1" name="items">
-              <reference idRef="187"/>
-            </array>
-          </object>
-        </object>
-        <object class="IBCarbonMenuItem" id="127">
-          <string name="title">File</string>
-          <reference name="submenu" idRef="131"/>
-        </object>
-        <reference idRef="152"/>
-        <reference idRef="192"/>
-      </array>
-    </object>
-    <reference idRef="184"/>
-    <reference idRef="194"/>
-    <reference idRef="195"/>
-    <reference idRef="127"/>
-    <reference idRef="147"/>
-    <reference idRef="133"/>
-    <reference idRef="149"/>
-    <reference idRef="151"/>
-    <reference idRef="190"/>
-    <reference idRef="185"/>
-    <reference idRef="197"/>
-    <reference idRef="130"/>
-    <reference idRef="191"/>
-    <reference idRef="196"/>
-  </array>
-  <array count="38" name="allParents">
-    <reference idRef="195"/>
-    <reference idRef="147"/>
-    <reference idRef="29"/>
-    <reference idRef="166"/>
-    <reference idRef="131"/>
-    <reference idRef="29"/>
-    <reference idRef="131"/>
-    <reference idRef="184"/>
-    <reference idRef="131"/>
-    <reference idRef="131"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="1"/>
-    <reference idRef="147"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="131"/>
-    <reference idRef="127"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="1"/>
-    <reference idRef="185"/>
-    <reference idRef="195"/>
-    <reference idRef="192"/>
-    <reference idRef="29"/>
-    <reference idRef="152"/>
-    <reference idRef="131"/>
-    <reference idRef="147"/>
-    <reference idRef="147"/>
-    <reference idRef="195"/>
-    <reference idRef="29"/>
-    <reference idRef="195"/>
-    <reference idRef="131"/>
-    <reference idRef="195"/>
-    <reference idRef="195"/>
-  </array>
-  <dictionary count="3" name="nameTable">
-    <string>File&apos;s Owner</string>
-    <reference idRef="1"/>
-    <string>MainWindow</string>
-    <reference idRef="166"/>
-    <string>MenuBar</string>
-    <reference idRef="29"/>
-  </dictionary>
-  <string name="targetFramework">IBCarbonFramework</string>
-  <unsigned_int name="nextObjectID">200</unsigned_int>
-</object>
diff --git a/xcode/Simple/Info.plist b/xcode/Simple/Info.plist
deleted file mode 100644
index d70d738..0000000
--- a/xcode/Simple/Info.plist
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.Simple</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>
diff --git a/xcode/Simple/Simple.xcodeproj/project.pbxproj b/xcode/Simple/Simple.xcodeproj/project.pbxproj
deleted file mode 100644
index d24c9e9..0000000
--- a/xcode/Simple/Simple.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,335 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		0099A4CA0EF176A5004F1DA4 /* SimpleApp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */; };
-		00AFCD5B0EF1667600BD2FF1 /* libskia2.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */; };
-		00AFCD750EF1679700BD2FF1 /* skia_mac.cp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD730EF1679700BD2FF1 /* skia_mac.cp */; };
-		8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; };
-		8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; };
-		8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		00AFCD4C0EF165CE00BD2FF1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = skia2;
-		};
-		00AFCD510EF165E500BD2FF1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = skia2;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleApp.cpp; sourceTree = "<group>"; };
-		00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = skia2.xcodeproj; path = ../skia2.xcodeproj; sourceTree = SOURCE_ROOT; };
-		00AFCD730EF1679700BD2FF1 /* skia_mac.cp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = skia_mac.cp; path = ../ports/skia_mac.cp; sourceTree = SOURCE_ROOT; };
-		0867D6ABFE840B52C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		1870340FFE93FCAF11CA0CD7 /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/main.nib; sourceTree = "<group>"; };
-		20286C33FDCF999611CA2CEA /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; };
-		5048396D09E3307300765E4B /* SimpleProj.xcconfig */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.xcconfig; path = SimpleProj.xcconfig; sourceTree = "<group>"; };
-		5048396E09E3307300765E4B /* SimpleTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.xcconfig; path = SimpleTarget.xcconfig; sourceTree = "<group>"; };
-		508344B209E5C41E0093A071 /* Simple.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Simple.app; sourceTree = BUILT_PRODUCTS_DIR; };
-		8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8D0C4E910486CD37000505A6 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */,
-				00AFCD5B0EF1667600BD2FF1 /* libskia2.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		00AFCD310EF165CE00BD2FF1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		195DF8CFFE9D517E11CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				508344B209E5C41E0093A071 /* Simple.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		20286C29FDCF999611CA2CEA /* Simple */ = {
-			isa = PBXGroup;
-			children = (
-				5048396909E3304600765E4B /* Configuration Files */,
-				20286C2AFDCF999611CA2CEA /* Sources */,
-				20286C2CFDCF999611CA2CEA /* Resources */,
-				20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */,
-				195DF8CFFE9D517E11CA2CBB /* Products */,
-				00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */,
-			);
-			name = Simple;
-			sourceTree = "<group>";
-		};
-		20286C2AFDCF999611CA2CEA /* Sources */ = {
-			isa = PBXGroup;
-			children = (
-				0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */,
-				00AFCD730EF1679700BD2FF1 /* skia_mac.cp */,
-			);
-			name = Sources;
-			sourceTree = "<group>";
-		};
-		20286C2CFDCF999611CA2CEA /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				8D0C4E960486CD37000505A6 /* Info.plist */,
-				0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */,
-				02345980000FD03B11CA0E72 /* main.nib */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */ = {
-			isa = PBXGroup;
-			children = (
-				20286C33FDCF999611CA2CEA /* Carbon.framework */,
-			);
-			name = "External Frameworks and Libraries";
-			sourceTree = "<group>";
-		};
-		5048396909E3304600765E4B /* Configuration Files */ = {
-			isa = PBXGroup;
-			children = (
-				5048396D09E3307300765E4B /* SimpleProj.xcconfig */,
-				5048396E09E3307300765E4B /* SimpleTarget.xcconfig */,
-			);
-			name = "Configuration Files";
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		8D0C4E890486CD37000505A6 /* Simple */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "Simple" */;
-			buildPhases = (
-				8D0C4E8C0486CD37000505A6 /* Resources */,
-				8D0C4E8F0486CD37000505A6 /* Sources */,
-				8D0C4E910486CD37000505A6 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				00AFCD520EF165E500BD2FF1 /* PBXTargetDependency */,
-			);
-			name = Simple;
-			productInstallPath = "$(HOME)/Applications";
-			productName = Simple;
-			productReference = 508344B209E5C41E0093A071 /* Simple.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		20286C28FDCF999611CA2CEA /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "Simple" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 20286C29FDCF999611CA2CEA /* Simple */;
-			projectDirPath = "";
-			projectReferences = (
-				{
-					ProductGroup = 00AFCD310EF165CE00BD2FF1 /* Products */;
-					ProjectRef = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */;
-				},
-			);
-			projectRoot = "";
-			targets = (
-				8D0C4E890486CD37000505A6 /* Simple */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXReferenceProxy section */
-		00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libskia2.a;
-			remoteRef = 00AFCD4C0EF165CE00BD2FF1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-/* End PBXReferenceProxy section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D0C4E8C0486CD37000505A6 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */,
-				8D0C4E8E0486CD37000505A6 /* main.nib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8D0C4E8F0486CD37000505A6 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00AFCD750EF1679700BD2FF1 /* skia_mac.cp in Sources */,
-				0099A4CA0EF176A5004F1DA4 /* SimpleApp.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		00AFCD520EF165E500BD2FF1 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = skia2;
-			targetProxy = 00AFCD510EF165E500BD2FF1 /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin PBXVariantGroup section */
-		02345980000FD03B11CA0E72 /* main.nib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				1870340FFE93FCAF11CA0CD7 /* English */,
-			);
-			name = main.nib;
-			sourceTree = "<group>";
-		};
-		0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */ = {
-			isa = PBXVariantGroup;
-			children = (
-				0867D6ABFE840B52C02AAC07 /* English */,
-			);
-			name = InfoPlist.strings;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		C0E91AC608A95435008D54AB /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_PREFIX_HEADER = Simple_Prefix.pch;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"_GLIBCXX_DEBUG=1",
-					"_GLIBCXX_DEBUG_PEDANTIC=1",
-				);
-			};
-			name = Debug;
-		};
-		C0E91AC708A95435008D54AB /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */;
-			buildSettings = {
-				DEAD_CODE_STRIPPING = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_PREFIX_HEADER = Simple_Prefix.pch;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRESERVE_DEAD_CODE_INITS_AND_TERMS = YES;
-			};
-			name = Release;
-		};
-		C0E91ACA08A95435008D54AB /* Debug */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5048396D09E3307300765E4B /* SimpleProj.xcconfig */;
-			buildSettings = {
-				ARCHS = (
-					i386,
-					ppc,
-				);
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_INCREASE_PRECOMPILED_HEADER_SHARING = NO;
-				GCC_MODEL_TUNING = "";
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_DEBUG,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				USER_HEADER_SEARCH_PATHS = "../../include/**";
-				VALID_ARCHS = "i386 x86_64";
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		C0E91ACB08A95435008D54AB /* Release */ = {
-			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5048396D09E3307300765E4B /* SimpleProj.xcconfig */;
-			buildSettings = {
-				ARCHS = (
-					i386,
-					ppc,
-				);
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_INCREASE_PRECOMPILED_HEADER_SHARING = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_RELEASE,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				SEPARATE_STRIP = YES;
-				USER_HEADER_SEARCH_PATHS = "../../include/**";
-				VALID_ARCHS = "i386 x86_64";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "Simple" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C0E91AC608A95435008D54AB /* Debug */,
-				C0E91AC708A95435008D54AB /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "Simple" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C0E91ACA08A95435008D54AB /* Debug */,
-				C0E91ACB08A95435008D54AB /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 20286C28FDCF999611CA2CEA /* Project object */;
-}
diff --git a/xcode/Simple/SimpleApp.cpp b/xcode/Simple/SimpleApp.cpp
deleted file mode 100644
index 7e7e282..0000000
--- a/xcode/Simple/SimpleApp.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "SkCanvas.h"
-#include "SkDevice.h"
-#include "SkGraphics.h"
-#include "SkPaint.h"
-#include "SkPicture.h"
-#include "SkStream.h"
-#include "SkWindow.h"
-
-//////////////////////////////////////////////////////////////////////////////
-
-class SimpleWindow : public SkOSWindow {
-public:
-	SimpleWindow(void* hwnd);
-
-protected:
-    virtual void onDraw(SkCanvas* canvas);
-	virtual bool onHandleKey(SkKey key);
-    virtual bool onHandleChar(SkUnichar);
-    virtual void onSizeChange();
-    
-    virtual SkCanvas* beforeChildren(SkCanvas*);
-    virtual void afterChildren(SkCanvas*);
-
-	virtual bool onEvent(const SkEvent& evt);
-
-private:
-    typedef SkOSWindow INHERITED;
-};
-
-SimpleWindow::SimpleWindow(void* hwnd) : INHERITED(hwnd) {
-//	this->setConfig(SkBitmap::kRGB_565_Config);
-	this->setConfig(SkBitmap::kARGB_8888_Config);
-	this->setVisibleP(true);
-    this->setTitle("Simple");
-}
-
-void SimpleWindow::onDraw(SkCanvas* canvas) {
-    canvas->drawColor(SK_ColorWHITE);
-    
-    const SkScalar w = this->width();
-    const SkScalar h = this->height();
-
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    paint.setTextSize(SkIntToScalar(40));
-    paint.setTextAlign(SkPaint::kCenter_Align);
-
-    canvas->drawText("Hello world", 11, w/2, h/2, paint);
-}
-
-SkCanvas* SimpleWindow::beforeChildren(SkCanvas* canvas) {
-    // can wack the canvas here, which will affect child views
-    // and can be "undone" in afterChildren()
-    //
-    // e.g. return a picture-canvas, or wack the clip or matrix, etc.
-
-    return canvas;
-}
-
-void SimpleWindow::afterChildren(SkCanvas* orig) {
-}
-
-bool SimpleWindow::onEvent(const SkEvent& evt) {
-    return this->INHERITED::onEvent(evt);
-}
-
-bool SimpleWindow::onHandleChar(SkUnichar uni) {
-    return this->INHERITED::onHandleChar(uni);
-}
-
-bool SimpleWindow::onHandleKey(SkKey key) {
-    return this->INHERITED::onHandleKey(key);
-}
-
-void SimpleWindow::onSizeChange() {
-    this->INHERITED::onSizeChange();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkOSWindow* create_sk_window(void* hwnd) {
-	return new SimpleWindow(hwnd);
-}
-
-void get_preferred_size(int* x, int* y, int* width, int* height) {
-    *x = 10;
-    *y = 50;
-    *width = 640;
-    *height = 480;
-}
-
-void application_init() {
-//    setenv("ANDROID_ROOT", "../../../data", 0);
-    setenv("ANDROID_ROOT", "/android/device/data", 0);
-	SkGraphics::Init(true);
-	SkEvent::Init();
-}
-
-void application_term() {
-	SkEvent::Term();
-	SkGraphics::Term();
-}
diff --git a/xcode/Simple/SimpleProj.xcconfig b/xcode/Simple/SimpleProj.xcconfig
deleted file mode 100644
index 73543b8..0000000
--- a/xcode/Simple/SimpleProj.xcconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-	GCC_ENABLE_CPP_EXCEPTIONS = YES;
-	GCC_ENABLE_CPP_RTTI = YES;
-	GCC_WARN_ABOUT_RETURN_TYPE = YES;
-	GCC_WARN_UNUSED_VARIABLE = YES;
-	GCC_INCREASE_PRECOMPILED_HEADER_SHARING = YES;
-	GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-	PREBINDING = NO;
-	INFOPLIST_EXPAND_BUILD_SETTINGS = YES;
\ No newline at end of file
diff --git a/xcode/Simple/SimpleTarget.xcconfig b/xcode/Simple/SimpleTarget.xcconfig
deleted file mode 100644
index 1d47d33..0000000
--- a/xcode/Simple/SimpleTarget.xcconfig
+++ /dev/null
@@ -1,7 +0,0 @@
-	GCC_PRECOMPILE_PREFIX_HEADER = YES;
-	GCC_PREFIX_HEADER = Simple_Prefix.pch;
-	INFOPLIST_FILE = Info.plist;
-	INSTALL_PATH = $(HOME)/Applications;
-	PRODUCT_NAME = 	Simple;
-	STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = Dynamic;
-	GCC_SYMBOLS_PRIVATE_EXTERN = YES;
diff --git a/xcode/Simple/Simple_Prefix.pch b/xcode/Simple/Simple_Prefix.pch
deleted file mode 100644
index ffcb61e..0000000
--- a/xcode/Simple/Simple_Prefix.pch
+++ /dev/null
@@ -1,4 +0,0 @@
-//
-// Prefix header for all source files of the 'Simple' target in the 'Simple' project.
-//
-
diff --git a/xcode/animator.xcodeproj/project.pbxproj b/xcode/animator.xcodeproj/project.pbxproj
deleted file mode 100644
index ea401fd..0000000
--- a/xcode/animator.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,833 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DDB80EDCA15800F77EA2 /* SkAnimate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD170EDCA15800F77EA2 /* SkAnimate.h */; };
-		00B7DDB90EDCA15800F77EA2 /* SkAnimateActive.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */; };
-		00B7DDBA0EDCA15800F77EA2 /* SkAnimateActive.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */; };
-		00B7DDBB0EDCA15800F77EA2 /* SkAnimateBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */; };
-		00B7DDBC0EDCA15800F77EA2 /* SkAnimateBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */; };
-		00B7DDBD0EDCA15800F77EA2 /* SkAnimateField.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */; };
-		00B7DDBE0EDCA15800F77EA2 /* SkAnimateMaker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */; };
-		00B7DDBF0EDCA15800F77EA2 /* SkAnimateMaker.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */; };
-		00B7DDC00EDCA15800F77EA2 /* SkAnimateProperties.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */; };
-		00B7DDC10EDCA15800F77EA2 /* SkAnimateSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */; };
-		00B7DDC20EDCA15800F77EA2 /* SkAnimateSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */; };
-		00B7DDC30EDCA15800F77EA2 /* SkAnimator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */; };
-		00B7DDC40EDCA15800F77EA2 /* SkAnimatorScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */; };
-		00B7DDC50EDCA15800F77EA2 /* SkAnimatorScript.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */; };
-		00B7DDC60EDCA15800F77EA2 /* SkAnimatorScript2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */; };
-		00B7DDC70EDCA15800F77EA2 /* SkAnimatorScript2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */; };
-		00B7DDC80EDCA15800F77EA2 /* SkBase64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */; };
-		00B7DDC90EDCA15800F77EA2 /* SkBase64.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */; };
-		00B7DDCA0EDCA15800F77EA2 /* SkBoundable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */; };
-		00B7DDCB0EDCA15800F77EA2 /* SkBoundable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */; };
-		00B7DDCF0EDCA15800F77EA2 /* SkDisplayable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */; };
-		00B7DDD00EDCA15800F77EA2 /* SkDisplayable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */; };
-		00B7DDD10EDCA15800F77EA2 /* SkDisplayAdd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */; };
-		00B7DDD20EDCA15800F77EA2 /* SkDisplayAdd.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */; };
-		00B7DDD30EDCA15800F77EA2 /* SkDisplayApply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */; };
-		00B7DDD40EDCA15800F77EA2 /* SkDisplayApply.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */; };
-		00B7DDD50EDCA15800F77EA2 /* SkDisplayBounds.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */; };
-		00B7DDD60EDCA15800F77EA2 /* SkDisplayBounds.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */; };
-		00B7DDD70EDCA15800F77EA2 /* SkDisplayEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */; };
-		00B7DDD80EDCA15800F77EA2 /* SkDisplayEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */; };
-		00B7DDD90EDCA15800F77EA2 /* SkDisplayEvents.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */; };
-		00B7DDDA0EDCA15800F77EA2 /* SkDisplayEvents.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */; };
-		00B7DDDB0EDCA15800F77EA2 /* SkDisplayInclude.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */; };
-		00B7DDDC0EDCA15800F77EA2 /* SkDisplayInclude.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */; };
-		00B7DDDD0EDCA15800F77EA2 /* SkDisplayInput.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */; };
-		00B7DDDE0EDCA15800F77EA2 /* SkDisplayInput.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */; };
-		00B7DDDF0EDCA15800F77EA2 /* SkDisplayList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */; };
-		00B7DDE00EDCA15800F77EA2 /* SkDisplayList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */; };
-		00B7DDE10EDCA15800F77EA2 /* SkDisplayMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */; };
-		00B7DDE20EDCA15800F77EA2 /* SkDisplayMath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */; };
-		00B7DDE30EDCA15800F77EA2 /* SkDisplayMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */; };
-		00B7DDE40EDCA15800F77EA2 /* SkDisplayMovie.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */; };
-		00B7DDE50EDCA15800F77EA2 /* SkDisplayNumber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */; };
-		00B7DDE60EDCA15800F77EA2 /* SkDisplayNumber.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */; };
-		00B7DDE70EDCA15800F77EA2 /* SkDisplayPost.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */; };
-		00B7DDE80EDCA15800F77EA2 /* SkDisplayPost.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */; };
-		00B7DDE90EDCA15800F77EA2 /* SkDisplayRandom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */; };
-		00B7DDEA0EDCA15800F77EA2 /* SkDisplayRandom.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */; };
-		00B7DDEB0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */; };
-		00B7DDEC0EDCA15800F77EA2 /* SkDisplayScreenplay.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */; };
-		00B7DDED0EDCA15800F77EA2 /* SkDisplayType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */; };
-		00B7DDEE0EDCA15800F77EA2 /* SkDisplayType.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */; };
-		00B7DDEF0EDCA15800F77EA2 /* SkDisplayTypes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */; };
-		00B7DDF00EDCA15800F77EA2 /* SkDisplayTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */; };
-		00B7DDF10EDCA15800F77EA2 /* SkDisplayXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */; };
-		00B7DDF20EDCA15800F77EA2 /* SkDisplayXMLParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */; };
-		00B7DDF30EDCA15800F77EA2 /* SkDraw3D.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */; };
-		00B7DDF40EDCA15800F77EA2 /* SkDraw3D.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */; };
-		00B7DDF50EDCA15800F77EA2 /* SkDrawable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */; };
-		00B7DDF60EDCA15800F77EA2 /* SkDrawable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD590EDCA15800F77EA2 /* SkDrawable.h */; };
-		00B7DDF70EDCA15800F77EA2 /* SkDrawBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */; };
-		00B7DDF80EDCA15800F77EA2 /* SkDrawBitmap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */; };
-		00B7DDF90EDCA15800F77EA2 /* SkDrawBlur.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */; };
-		00B7DDFA0EDCA15800F77EA2 /* SkDrawBlur.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */; };
-		00B7DDFB0EDCA15800F77EA2 /* SkDrawClip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */; };
-		00B7DDFC0EDCA15800F77EA2 /* SkDrawClip.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */; };
-		00B7DDFD0EDCA15800F77EA2 /* SkDrawColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */; };
-		00B7DDFE0EDCA15800F77EA2 /* SkDrawColor.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */; };
-		00B7DDFF0EDCA15800F77EA2 /* SkDrawDash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */; };
-		00B7DE000EDCA15800F77EA2 /* SkDrawDash.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */; };
-		00B7DE010EDCA15800F77EA2 /* SkDrawDiscrete.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */; };
-		00B7DE020EDCA15800F77EA2 /* SkDrawDiscrete.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */; };
-		00B7DE030EDCA15800F77EA2 /* SkDrawEmboss.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */; };
-		00B7DE040EDCA15800F77EA2 /* SkDrawEmboss.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */; };
-		00B7DE050EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */; };
-		00B7DE060EDCA15800F77EA2 /* SkDrawFull.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */; };
-		00B7DE070EDCA15800F77EA2 /* SkDrawFull.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */; };
-		00B7DE080EDCA15800F77EA2 /* SkDrawGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */; };
-		00B7DE090EDCA15800F77EA2 /* SkDrawGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */; };
-		00B7DE0A0EDCA15800F77EA2 /* SkDrawGroup.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */; };
-		00B7DE0B0EDCA15800F77EA2 /* SkDrawGroup.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */; };
-		00B7DE0C0EDCA15800F77EA2 /* SkDrawLine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */; };
-		00B7DE0D0EDCA15800F77EA2 /* SkDrawLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */; };
-		00B7DE0E0EDCA15800F77EA2 /* SkDrawMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */; };
-		00B7DE0F0EDCA15800F77EA2 /* SkDrawMatrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */; };
-		00B7DE100EDCA15800F77EA2 /* SkDrawOval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */; };
-		00B7DE110EDCA15800F77EA2 /* SkDrawOval.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */; };
-		00B7DE120EDCA15800F77EA2 /* SkDrawPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */; };
-		00B7DE130EDCA15800F77EA2 /* SkDrawPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */; };
-		00B7DE140EDCA15800F77EA2 /* SkDrawPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */; };
-		00B7DE150EDCA15800F77EA2 /* SkDrawPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */; };
-		00B7DE160EDCA15800F77EA2 /* SkDrawPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */; };
-		00B7DE170EDCA15800F77EA2 /* SkDrawPoint.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */; };
-		00B7DE180EDCA15800F77EA2 /* SkDrawRectangle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */; };
-		00B7DE190EDCA15800F77EA2 /* SkDrawRectangle.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */; };
-		00B7DE1A0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */; };
-		00B7DE1B0EDCA15800F77EA2 /* SkDrawSaveLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */; };
-		00B7DE1C0EDCA15800F77EA2 /* SkDrawShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */; };
-		00B7DE1D0EDCA15800F77EA2 /* SkDrawShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */; };
-		00B7DE1E0EDCA15800F77EA2 /* SkDrawText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */; };
-		00B7DE1F0EDCA15800F77EA2 /* SkDrawText.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD820EDCA15800F77EA2 /* SkDrawText.h */; };
-		00B7DE200EDCA15800F77EA2 /* SkDrawTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */; };
-		00B7DE210EDCA15800F77EA2 /* SkDrawTextBox.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */; };
-		00B7DE220EDCA15800F77EA2 /* SkDrawTo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */; };
-		00B7DE230EDCA15800F77EA2 /* SkDrawTo.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */; };
-		00B7DE240EDCA15800F77EA2 /* SkDrawTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */; };
-		00B7DE250EDCA15800F77EA2 /* SkDrawTransparentShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */; };
-		00B7DE260EDCA15800F77EA2 /* SkDump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD890EDCA15800F77EA2 /* SkDump.cpp */; };
-		00B7DE270EDCA15800F77EA2 /* SkDump.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8A0EDCA15800F77EA2 /* SkDump.h */; };
-		00B7DE280EDCA15800F77EA2 /* SkExtras.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */; };
-		00B7DE290EDCA15800F77EA2 /* SkGetCondensedInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */; };
-		00B7DE2A0EDCA15800F77EA2 /* SkHitClear.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */; };
-		00B7DE2B0EDCA15800F77EA2 /* SkHitClear.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */; };
-		00B7DE2C0EDCA15800F77EA2 /* SkHitTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */; };
-		00B7DE2D0EDCA15800F77EA2 /* SkHitTest.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD910EDCA15800F77EA2 /* SkHitTest.h */; };
-		00B7DE2E0EDCA15800F77EA2 /* SkIntArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD920EDCA15800F77EA2 /* SkIntArray.h */; };
-		00B7DE2F0EDCA15800F77EA2 /* SkMatrixParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */; };
-		00B7DE300EDCA15800F77EA2 /* SkMatrixParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */; };
-		00B7DE310EDCA15800F77EA2 /* SkMemberInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */; };
-		00B7DE320EDCA15800F77EA2 /* SkMemberInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */; };
-		00B7DE330EDCA15800F77EA2 /* SkOpArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */; };
-		00B7DE340EDCA15800F77EA2 /* SkOpArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD980EDCA15800F77EA2 /* SkOpArray.h */; };
-		00B7DE350EDCA15800F77EA2 /* SkOperand.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD990EDCA15800F77EA2 /* SkOperand.h */; };
-		00B7DE360EDCA15800F77EA2 /* SkOperand2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */; };
-		00B7DE370EDCA15800F77EA2 /* SkOperandInterpolator.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */; };
-		00B7DE380EDCA15800F77EA2 /* SkOperandIterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */; };
-		00B7DE390EDCA15800F77EA2 /* SkPaintParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */; };
-		00B7DE3A0EDCA15800F77EA2 /* SkPaintParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */; };
-		00B7DE3B0EDCA15800F77EA2 /* SkPathParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */; };
-		00B7DE3C0EDCA15800F77EA2 /* SkPathParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */; };
-		00B7DE3D0EDCA15800F77EA2 /* SkPostParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */; };
-		00B7DE3E0EDCA15800F77EA2 /* SkPostParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */; };
-		00B7DE3F0EDCA15800F77EA2 /* SkScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */; };
-		00B7DE400EDCA15800F77EA2 /* SkScript.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA40EDCA15800F77EA2 /* SkScript.h */; };
-		00B7DE410EDCA15800F77EA2 /* SkScript2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA50EDCA15800F77EA2 /* SkScript2.h */; };
-		00B7DE420EDCA15800F77EA2 /* SkScriptCallBack.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */; };
-		00B7DE430EDCA15800F77EA2 /* SkScriptDecompile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */; };
-		00B7DE440EDCA15800F77EA2 /* SkScriptRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */; };
-		00B7DE450EDCA15800F77EA2 /* SkScriptRuntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */; };
-		00B7DE460EDCA15800F77EA2 /* SkScriptTokenizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */; };
-		00B7DE470EDCA15800F77EA2 /* SkSnapshot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */; };
-		00B7DE480EDCA15800F77EA2 /* SkSnapshot.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */; };
-		00B7DE490EDCA15800F77EA2 /* SkSVGPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */; };
-		00B7DE4A0EDCA15800F77EA2 /* SkTDArray_Experimental.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */; };
-		00B7DE4B0EDCA15800F77EA2 /* SkTextOnPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */; };
-		00B7DE4C0EDCA15800F77EA2 /* SkTextOnPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */; };
-		00B7DE4D0EDCA15800F77EA2 /* SkTextToPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */; };
-		00B7DE4E0EDCA15800F77EA2 /* SkTextToPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */; };
-		00B7DE4F0EDCA15800F77EA2 /* SkTime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */; };
-		00B7DE500EDCA15800F77EA2 /* SkTypedArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */; };
-		00B7DE510EDCA15800F77EA2 /* SkTypedArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */; };
-		00B7DE520EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */; };
-		00B7DE530EDCA15800F77EA2 /* SkXMLAnimatorWriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DD170EDCA15800F77EA2 /* SkAnimate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimate.h; path = ../libsgl/animator/SkAnimate.h; sourceTree = SOURCE_ROOT; };
-		00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateActive.cpp; path = ../libsgl/animator/SkAnimateActive.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateActive.h; path = ../libsgl/animator/SkAnimateActive.h; sourceTree = SOURCE_ROOT; };
-		00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateBase.cpp; path = ../libsgl/animator/SkAnimateBase.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateBase.h; path = ../libsgl/animator/SkAnimateBase.h; sourceTree = SOURCE_ROOT; };
-		00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateField.cpp; path = ../libsgl/animator/SkAnimateField.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateMaker.cpp; path = ../libsgl/animator/SkAnimateMaker.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateMaker.h; path = ../libsgl/animator/SkAnimateMaker.h; sourceTree = SOURCE_ROOT; };
-		00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateProperties.h; path = ../libsgl/animator/SkAnimateProperties.h; sourceTree = SOURCE_ROOT; };
-		00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateSet.cpp; path = ../libsgl/animator/SkAnimateSet.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateSet.h; path = ../libsgl/animator/SkAnimateSet.h; sourceTree = SOURCE_ROOT; };
-		00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimator.cpp; path = ../libsgl/animator/SkAnimator.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimatorScript.cpp; path = ../libsgl/animator/SkAnimatorScript.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimatorScript.h; path = ../libsgl/animator/SkAnimatorScript.h; sourceTree = SOURCE_ROOT; };
-		00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimatorScript2.cpp; path = ../libsgl/animator/SkAnimatorScript2.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimatorScript2.h; path = ../libsgl/animator/SkAnimatorScript2.h; sourceTree = SOURCE_ROOT; };
-		00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBase64.cpp; path = ../libsgl/animator/SkBase64.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBase64.h; path = ../libsgl/animator/SkBase64.h; sourceTree = SOURCE_ROOT; };
-		00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBoundable.cpp; path = ../libsgl/animator/SkBoundable.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBoundable.h; path = ../libsgl/animator/SkBoundable.h; sourceTree = SOURCE_ROOT; };
-		00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayable.cpp; path = ../libsgl/animator/SkDisplayable.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayable.h; path = ../libsgl/animator/SkDisplayable.h; sourceTree = SOURCE_ROOT; };
-		00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayAdd.cpp; path = ../libsgl/animator/SkDisplayAdd.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayAdd.h; path = ../libsgl/animator/SkDisplayAdd.h; sourceTree = SOURCE_ROOT; };
-		00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayApply.cpp; path = ../libsgl/animator/SkDisplayApply.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayApply.h; path = ../libsgl/animator/SkDisplayApply.h; sourceTree = SOURCE_ROOT; };
-		00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayBounds.cpp; path = ../libsgl/animator/SkDisplayBounds.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayBounds.h; path = ../libsgl/animator/SkDisplayBounds.h; sourceTree = SOURCE_ROOT; };
-		00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayEvent.cpp; path = ../libsgl/animator/SkDisplayEvent.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayEvent.h; path = ../libsgl/animator/SkDisplayEvent.h; sourceTree = SOURCE_ROOT; };
-		00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayEvents.cpp; path = ../libsgl/animator/SkDisplayEvents.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayEvents.h; path = ../libsgl/animator/SkDisplayEvents.h; sourceTree = SOURCE_ROOT; };
-		00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayInclude.cpp; path = ../libsgl/animator/SkDisplayInclude.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayInclude.h; path = ../libsgl/animator/SkDisplayInclude.h; sourceTree = SOURCE_ROOT; };
-		00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayInput.cpp; path = ../libsgl/animator/SkDisplayInput.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayInput.h; path = ../libsgl/animator/SkDisplayInput.h; sourceTree = SOURCE_ROOT; };
-		00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayList.cpp; path = ../libsgl/animator/SkDisplayList.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayList.h; path = ../libsgl/animator/SkDisplayList.h; sourceTree = SOURCE_ROOT; };
-		00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayMath.cpp; path = ../libsgl/animator/SkDisplayMath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayMath.h; path = ../libsgl/animator/SkDisplayMath.h; sourceTree = SOURCE_ROOT; };
-		00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayMovie.cpp; path = ../libsgl/animator/SkDisplayMovie.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayMovie.h; path = ../libsgl/animator/SkDisplayMovie.h; sourceTree = SOURCE_ROOT; };
-		00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayNumber.cpp; path = ../libsgl/animator/SkDisplayNumber.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayNumber.h; path = ../libsgl/animator/SkDisplayNumber.h; sourceTree = SOURCE_ROOT; };
-		00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayPost.cpp; path = ../libsgl/animator/SkDisplayPost.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayPost.h; path = ../libsgl/animator/SkDisplayPost.h; sourceTree = SOURCE_ROOT; };
-		00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayRandom.cpp; path = ../libsgl/animator/SkDisplayRandom.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayRandom.h; path = ../libsgl/animator/SkDisplayRandom.h; sourceTree = SOURCE_ROOT; };
-		00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayScreenplay.cpp; path = ../libsgl/animator/SkDisplayScreenplay.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayScreenplay.h; path = ../libsgl/animator/SkDisplayScreenplay.h; sourceTree = SOURCE_ROOT; };
-		00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayType.cpp; path = ../libsgl/animator/SkDisplayType.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayType.h; path = ../libsgl/animator/SkDisplayType.h; sourceTree = SOURCE_ROOT; };
-		00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayTypes.cpp; path = ../libsgl/animator/SkDisplayTypes.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayTypes.h; path = ../libsgl/animator/SkDisplayTypes.h; sourceTree = SOURCE_ROOT; };
-		00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayXMLParser.cpp; path = ../libsgl/animator/SkDisplayXMLParser.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayXMLParser.h; path = ../libsgl/animator/SkDisplayXMLParser.h; sourceTree = SOURCE_ROOT; };
-		00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw3D.cpp; path = ../libsgl/animator/SkDraw3D.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDraw3D.h; path = ../libsgl/animator/SkDraw3D.h; sourceTree = SOURCE_ROOT; };
-		00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawable.cpp; path = ../libsgl/animator/SkDrawable.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD590EDCA15800F77EA2 /* SkDrawable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawable.h; path = ../libsgl/animator/SkDrawable.h; sourceTree = SOURCE_ROOT; };
-		00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawBitmap.cpp; path = ../libsgl/animator/SkDrawBitmap.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawBitmap.h; path = ../libsgl/animator/SkDrawBitmap.h; sourceTree = SOURCE_ROOT; };
-		00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawBlur.cpp; path = ../libsgl/animator/SkDrawBlur.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawBlur.h; path = ../libsgl/animator/SkDrawBlur.h; sourceTree = SOURCE_ROOT; };
-		00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawClip.cpp; path = ../libsgl/animator/SkDrawClip.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawClip.h; path = ../libsgl/animator/SkDrawClip.h; sourceTree = SOURCE_ROOT; };
-		00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawColor.cpp; path = ../libsgl/animator/SkDrawColor.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawColor.h; path = ../libsgl/animator/SkDrawColor.h; sourceTree = SOURCE_ROOT; };
-		00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawDash.cpp; path = ../libsgl/animator/SkDrawDash.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawDash.h; path = ../libsgl/animator/SkDrawDash.h; sourceTree = SOURCE_ROOT; };
-		00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawDiscrete.cpp; path = ../libsgl/animator/SkDrawDiscrete.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawDiscrete.h; path = ../libsgl/animator/SkDrawDiscrete.h; sourceTree = SOURCE_ROOT; };
-		00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawEmboss.cpp; path = ../libsgl/animator/SkDrawEmboss.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawEmboss.h; path = ../libsgl/animator/SkDrawEmboss.h; sourceTree = SOURCE_ROOT; };
-		00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawExtraPathEffect.cpp; path = ../libsgl/animator/SkDrawExtraPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawFull.cpp; path = ../libsgl/animator/SkDrawFull.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawFull.h; path = ../libsgl/animator/SkDrawFull.h; sourceTree = SOURCE_ROOT; };
-		00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawGradient.cpp; path = ../libsgl/animator/SkDrawGradient.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawGradient.h; path = ../libsgl/animator/SkDrawGradient.h; sourceTree = SOURCE_ROOT; };
-		00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawGroup.cpp; path = ../libsgl/animator/SkDrawGroup.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawGroup.h; path = ../libsgl/animator/SkDrawGroup.h; sourceTree = SOURCE_ROOT; };
-		00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawLine.cpp; path = ../libsgl/animator/SkDrawLine.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawLine.h; path = ../libsgl/animator/SkDrawLine.h; sourceTree = SOURCE_ROOT; };
-		00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawMatrix.cpp; path = ../libsgl/animator/SkDrawMatrix.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawMatrix.h; path = ../libsgl/animator/SkDrawMatrix.h; sourceTree = SOURCE_ROOT; };
-		00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawOval.cpp; path = ../libsgl/animator/SkDrawOval.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawOval.h; path = ../libsgl/animator/SkDrawOval.h; sourceTree = SOURCE_ROOT; };
-		00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPaint.cpp; path = ../libsgl/animator/SkDrawPaint.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPaint.h; path = ../libsgl/animator/SkDrawPaint.h; sourceTree = SOURCE_ROOT; };
-		00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPath.cpp; path = ../libsgl/animator/SkDrawPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPath.h; path = ../libsgl/animator/SkDrawPath.h; sourceTree = SOURCE_ROOT; };
-		00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPoint.cpp; path = ../libsgl/animator/SkDrawPoint.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPoint.h; path = ../libsgl/animator/SkDrawPoint.h; sourceTree = SOURCE_ROOT; };
-		00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawRectangle.cpp; path = ../libsgl/animator/SkDrawRectangle.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawRectangle.h; path = ../libsgl/animator/SkDrawRectangle.h; sourceTree = SOURCE_ROOT; };
-		00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawSaveLayer.cpp; path = ../libsgl/animator/SkDrawSaveLayer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawSaveLayer.h; path = ../libsgl/animator/SkDrawSaveLayer.h; sourceTree = SOURCE_ROOT; };
-		00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawShader.cpp; path = ../libsgl/animator/SkDrawShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawShader.h; path = ../libsgl/animator/SkDrawShader.h; sourceTree = SOURCE_ROOT; };
-		00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawText.cpp; path = ../libsgl/animator/SkDrawText.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD820EDCA15800F77EA2 /* SkDrawText.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawText.h; path = ../libsgl/animator/SkDrawText.h; sourceTree = SOURCE_ROOT; };
-		00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTextBox.cpp; path = ../libsgl/animator/SkDrawTextBox.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTextBox.h; path = ../libsgl/animator/SkDrawTextBox.h; sourceTree = SOURCE_ROOT; };
-		00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTo.cpp; path = ../libsgl/animator/SkDrawTo.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTo.h; path = ../libsgl/animator/SkDrawTo.h; sourceTree = SOURCE_ROOT; };
-		00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTransparentShader.cpp; path = ../libsgl/animator/SkDrawTransparentShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTransparentShader.h; path = ../libsgl/animator/SkDrawTransparentShader.h; sourceTree = SOURCE_ROOT; };
-		00B7DD890EDCA15800F77EA2 /* SkDump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDump.cpp; path = ../libsgl/animator/SkDump.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD8A0EDCA15800F77EA2 /* SkDump.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDump.h; path = ../libsgl/animator/SkDump.h; sourceTree = SOURCE_ROOT; };
-		00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkExtras.h; path = ../libsgl/animator/SkExtras.h; sourceTree = SOURCE_ROOT; };
-		00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGetCondensedInfo.cpp; path = ../libsgl/animator/SkGetCondensedInfo.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkHitClear.cpp; path = ../libsgl/animator/SkHitClear.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkHitClear.h; path = ../libsgl/animator/SkHitClear.h; sourceTree = SOURCE_ROOT; };
-		00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkHitTest.cpp; path = ../libsgl/animator/SkHitTest.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD910EDCA15800F77EA2 /* SkHitTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkHitTest.h; path = ../libsgl/animator/SkHitTest.h; sourceTree = SOURCE_ROOT; };
-		00B7DD920EDCA15800F77EA2 /* SkIntArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkIntArray.h; path = ../libsgl/animator/SkIntArray.h; sourceTree = SOURCE_ROOT; };
-		00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrixParts.cpp; path = ../libsgl/animator/SkMatrixParts.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkMatrixParts.h; path = ../libsgl/animator/SkMatrixParts.h; sourceTree = SOURCE_ROOT; };
-		00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemberInfo.cpp; path = ../libsgl/animator/SkMemberInfo.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkMemberInfo.h; path = ../libsgl/animator/SkMemberInfo.h; sourceTree = SOURCE_ROOT; };
-		00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOpArray.cpp; path = ../libsgl/animator/SkOpArray.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD980EDCA15800F77EA2 /* SkOpArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOpArray.h; path = ../libsgl/animator/SkOpArray.h; sourceTree = SOURCE_ROOT; };
-		00B7DD990EDCA15800F77EA2 /* SkOperand.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperand.h; path = ../libsgl/animator/SkOperand.h; sourceTree = SOURCE_ROOT; };
-		00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperand2.h; path = ../libsgl/animator/SkOperand2.h; sourceTree = SOURCE_ROOT; };
-		00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperandInterpolator.h; path = ../libsgl/animator/SkOperandInterpolator.h; sourceTree = SOURCE_ROOT; };
-		00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOperandIterpolator.cpp; path = ../libsgl/animator/SkOperandIterpolator.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintParts.cpp; path = ../libsgl/animator/SkPaintParts.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPaintParts.h; path = ../libsgl/animator/SkPaintParts.h; sourceTree = SOURCE_ROOT; };
-		00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathParts.cpp; path = ../libsgl/animator/SkPathParts.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathParts.h; path = ../libsgl/animator/SkPathParts.h; sourceTree = SOURCE_ROOT; };
-		00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPostParts.cpp; path = ../libsgl/animator/SkPostParts.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPostParts.h; path = ../libsgl/animator/SkPostParts.h; sourceTree = SOURCE_ROOT; };
-		00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScript.cpp; path = ../libsgl/animator/SkScript.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDA40EDCA15800F77EA2 /* SkScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScript.h; path = ../libsgl/animator/SkScript.h; sourceTree = SOURCE_ROOT; };
-		00B7DDA50EDCA15800F77EA2 /* SkScript2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScript2.h; path = ../libsgl/animator/SkScript2.h; sourceTree = SOURCE_ROOT; };
-		00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScriptCallBack.h; path = ../libsgl/animator/SkScriptCallBack.h; sourceTree = SOURCE_ROOT; };
-		00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptDecompile.cpp; path = ../libsgl/animator/SkScriptDecompile.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptRuntime.cpp; path = ../libsgl/animator/SkScriptRuntime.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScriptRuntime.h; path = ../libsgl/animator/SkScriptRuntime.h; sourceTree = SOURCE_ROOT; };
-		00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptTokenizer.cpp; path = ../libsgl/animator/SkScriptTokenizer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSnapshot.cpp; path = ../libsgl/animator/SkSnapshot.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSnapshot.h; path = ../libsgl/animator/SkSnapshot.h; sourceTree = SOURCE_ROOT; };
-		00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSVGPath.cpp; path = ../libsgl/animator/SkSVGPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTDArray_Experimental.h; path = ../libsgl/animator/SkTDArray_Experimental.h; sourceTree = SOURCE_ROOT; };
-		00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextOnPath.cpp; path = ../libsgl/animator/SkTextOnPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextOnPath.h; path = ../libsgl/animator/SkTextOnPath.h; sourceTree = SOURCE_ROOT; };
-		00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextToPath.cpp; path = ../libsgl/animator/SkTextToPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextToPath.h; path = ../libsgl/animator/SkTextToPath.h; sourceTree = SOURCE_ROOT; };
-		00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime.cpp; path = ../libsgl/animator/SkTime.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypedArray.cpp; path = ../libsgl/animator/SkTypedArray.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTypedArray.h; path = ../libsgl/animator/SkTypedArray.h; sourceTree = SOURCE_ROOT; };
-		00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLAnimatorWriter.cpp; path = ../libsgl/animator/SkXMLAnimatorWriter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkXMLAnimatorWriter.h; path = ../libsgl/animator/SkXMLAnimatorWriter.h; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libanimator.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libanimator.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* animator */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = animator;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DD170EDCA15800F77EA2 /* SkAnimate.h */,
-				00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */,
-				00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */,
-				00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */,
-				00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */,
-				00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */,
-				00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */,
-				00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */,
-				00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */,
-				00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */,
-				00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */,
-				00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */,
-				00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */,
-				00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */,
-				00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */,
-				00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */,
-				00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */,
-				00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */,
-				00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */,
-				00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */,
-				00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */,
-				00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */,
-				00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */,
-				00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */,
-				00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */,
-				00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */,
-				00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */,
-				00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */,
-				00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */,
-				00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */,
-				00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */,
-				00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */,
-				00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */,
-				00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */,
-				00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */,
-				00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */,
-				00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */,
-				00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */,
-				00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */,
-				00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */,
-				00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */,
-				00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */,
-				00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */,
-				00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */,
-				00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */,
-				00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */,
-				00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */,
-				00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */,
-				00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */,
-				00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */,
-				00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */,
-				00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */,
-				00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */,
-				00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */,
-				00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */,
-				00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */,
-				00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */,
-				00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */,
-				00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */,
-				00B7DD590EDCA15800F77EA2 /* SkDrawable.h */,
-				00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */,
-				00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */,
-				00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */,
-				00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */,
-				00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */,
-				00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */,
-				00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */,
-				00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */,
-				00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */,
-				00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */,
-				00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */,
-				00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */,
-				00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */,
-				00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */,
-				00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */,
-				00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */,
-				00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */,
-				00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */,
-				00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */,
-				00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */,
-				00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */,
-				00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */,
-				00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */,
-				00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */,
-				00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */,
-				00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */,
-				00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */,
-				00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */,
-				00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */,
-				00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */,
-				00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */,
-				00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */,
-				00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */,
-				00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */,
-				00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */,
-				00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */,
-				00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */,
-				00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */,
-				00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */,
-				00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */,
-				00B7DD820EDCA15800F77EA2 /* SkDrawText.h */,
-				00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */,
-				00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */,
-				00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */,
-				00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */,
-				00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */,
-				00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */,
-				00B7DD890EDCA15800F77EA2 /* SkDump.cpp */,
-				00B7DD8A0EDCA15800F77EA2 /* SkDump.h */,
-				00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */,
-				00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */,
-				00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */,
-				00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */,
-				00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */,
-				00B7DD910EDCA15800F77EA2 /* SkHitTest.h */,
-				00B7DD920EDCA15800F77EA2 /* SkIntArray.h */,
-				00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */,
-				00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */,
-				00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */,
-				00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */,
-				00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */,
-				00B7DD980EDCA15800F77EA2 /* SkOpArray.h */,
-				00B7DD990EDCA15800F77EA2 /* SkOperand.h */,
-				00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */,
-				00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */,
-				00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */,
-				00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */,
-				00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */,
-				00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */,
-				00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */,
-				00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */,
-				00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */,
-				00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */,
-				00B7DDA40EDCA15800F77EA2 /* SkScript.h */,
-				00B7DDA50EDCA15800F77EA2 /* SkScript2.h */,
-				00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */,
-				00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */,
-				00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */,
-				00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */,
-				00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */,
-				00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */,
-				00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */,
-				00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */,
-				00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */,
-				00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */,
-				00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */,
-				00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */,
-				00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */,
-				00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */,
-				00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */,
-				00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */,
-				00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */,
-				00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libanimator.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DDB80EDCA15800F77EA2 /* SkAnimate.h in Headers */,
-				00B7DDBA0EDCA15800F77EA2 /* SkAnimateActive.h in Headers */,
-				00B7DDBC0EDCA15800F77EA2 /* SkAnimateBase.h in Headers */,
-				00B7DDBF0EDCA15800F77EA2 /* SkAnimateMaker.h in Headers */,
-				00B7DDC00EDCA15800F77EA2 /* SkAnimateProperties.h in Headers */,
-				00B7DDC20EDCA15800F77EA2 /* SkAnimateSet.h in Headers */,
-				00B7DDC50EDCA15800F77EA2 /* SkAnimatorScript.h in Headers */,
-				00B7DDC70EDCA15800F77EA2 /* SkAnimatorScript2.h in Headers */,
-				00B7DDC90EDCA15800F77EA2 /* SkBase64.h in Headers */,
-				00B7DDCB0EDCA15800F77EA2 /* SkBoundable.h in Headers */,
-				00B7DDD00EDCA15800F77EA2 /* SkDisplayable.h in Headers */,
-				00B7DDD20EDCA15800F77EA2 /* SkDisplayAdd.h in Headers */,
-				00B7DDD40EDCA15800F77EA2 /* SkDisplayApply.h in Headers */,
-				00B7DDD60EDCA15800F77EA2 /* SkDisplayBounds.h in Headers */,
-				00B7DDD80EDCA15800F77EA2 /* SkDisplayEvent.h in Headers */,
-				00B7DDDA0EDCA15800F77EA2 /* SkDisplayEvents.h in Headers */,
-				00B7DDDC0EDCA15800F77EA2 /* SkDisplayInclude.h in Headers */,
-				00B7DDDE0EDCA15800F77EA2 /* SkDisplayInput.h in Headers */,
-				00B7DDE00EDCA15800F77EA2 /* SkDisplayList.h in Headers */,
-				00B7DDE20EDCA15800F77EA2 /* SkDisplayMath.h in Headers */,
-				00B7DDE40EDCA15800F77EA2 /* SkDisplayMovie.h in Headers */,
-				00B7DDE60EDCA15800F77EA2 /* SkDisplayNumber.h in Headers */,
-				00B7DDE80EDCA15800F77EA2 /* SkDisplayPost.h in Headers */,
-				00B7DDEA0EDCA15800F77EA2 /* SkDisplayRandom.h in Headers */,
-				00B7DDEC0EDCA15800F77EA2 /* SkDisplayScreenplay.h in Headers */,
-				00B7DDEE0EDCA15800F77EA2 /* SkDisplayType.h in Headers */,
-				00B7DDF00EDCA15800F77EA2 /* SkDisplayTypes.h in Headers */,
-				00B7DDF20EDCA15800F77EA2 /* SkDisplayXMLParser.h in Headers */,
-				00B7DDF40EDCA15800F77EA2 /* SkDraw3D.h in Headers */,
-				00B7DDF60EDCA15800F77EA2 /* SkDrawable.h in Headers */,
-				00B7DDF80EDCA15800F77EA2 /* SkDrawBitmap.h in Headers */,
-				00B7DDFA0EDCA15800F77EA2 /* SkDrawBlur.h in Headers */,
-				00B7DDFC0EDCA15800F77EA2 /* SkDrawClip.h in Headers */,
-				00B7DDFE0EDCA15800F77EA2 /* SkDrawColor.h in Headers */,
-				00B7DE000EDCA15800F77EA2 /* SkDrawDash.h in Headers */,
-				00B7DE020EDCA15800F77EA2 /* SkDrawDiscrete.h in Headers */,
-				00B7DE040EDCA15800F77EA2 /* SkDrawEmboss.h in Headers */,
-				00B7DE070EDCA15800F77EA2 /* SkDrawFull.h in Headers */,
-				00B7DE090EDCA15800F77EA2 /* SkDrawGradient.h in Headers */,
-				00B7DE0B0EDCA15800F77EA2 /* SkDrawGroup.h in Headers */,
-				00B7DE0D0EDCA15800F77EA2 /* SkDrawLine.h in Headers */,
-				00B7DE0F0EDCA15800F77EA2 /* SkDrawMatrix.h in Headers */,
-				00B7DE110EDCA15800F77EA2 /* SkDrawOval.h in Headers */,
-				00B7DE130EDCA15800F77EA2 /* SkDrawPaint.h in Headers */,
-				00B7DE150EDCA15800F77EA2 /* SkDrawPath.h in Headers */,
-				00B7DE170EDCA15800F77EA2 /* SkDrawPoint.h in Headers */,
-				00B7DE190EDCA15800F77EA2 /* SkDrawRectangle.h in Headers */,
-				00B7DE1B0EDCA15800F77EA2 /* SkDrawSaveLayer.h in Headers */,
-				00B7DE1D0EDCA15800F77EA2 /* SkDrawShader.h in Headers */,
-				00B7DE1F0EDCA15800F77EA2 /* SkDrawText.h in Headers */,
-				00B7DE210EDCA15800F77EA2 /* SkDrawTextBox.h in Headers */,
-				00B7DE230EDCA15800F77EA2 /* SkDrawTo.h in Headers */,
-				00B7DE250EDCA15800F77EA2 /* SkDrawTransparentShader.h in Headers */,
-				00B7DE270EDCA15800F77EA2 /* SkDump.h in Headers */,
-				00B7DE280EDCA15800F77EA2 /* SkExtras.h in Headers */,
-				00B7DE2B0EDCA15800F77EA2 /* SkHitClear.h in Headers */,
-				00B7DE2D0EDCA15800F77EA2 /* SkHitTest.h in Headers */,
-				00B7DE2E0EDCA15800F77EA2 /* SkIntArray.h in Headers */,
-				00B7DE300EDCA15800F77EA2 /* SkMatrixParts.h in Headers */,
-				00B7DE320EDCA15800F77EA2 /* SkMemberInfo.h in Headers */,
-				00B7DE340EDCA15800F77EA2 /* SkOpArray.h in Headers */,
-				00B7DE350EDCA15800F77EA2 /* SkOperand.h in Headers */,
-				00B7DE360EDCA15800F77EA2 /* SkOperand2.h in Headers */,
-				00B7DE370EDCA15800F77EA2 /* SkOperandInterpolator.h in Headers */,
-				00B7DE3A0EDCA15800F77EA2 /* SkPaintParts.h in Headers */,
-				00B7DE3C0EDCA15800F77EA2 /* SkPathParts.h in Headers */,
-				00B7DE3E0EDCA15800F77EA2 /* SkPostParts.h in Headers */,
-				00B7DE400EDCA15800F77EA2 /* SkScript.h in Headers */,
-				00B7DE410EDCA15800F77EA2 /* SkScript2.h in Headers */,
-				00B7DE420EDCA15800F77EA2 /* SkScriptCallBack.h in Headers */,
-				00B7DE450EDCA15800F77EA2 /* SkScriptRuntime.h in Headers */,
-				00B7DE480EDCA15800F77EA2 /* SkSnapshot.h in Headers */,
-				00B7DE4A0EDCA15800F77EA2 /* SkTDArray_Experimental.h in Headers */,
-				00B7DE4C0EDCA15800F77EA2 /* SkTextOnPath.h in Headers */,
-				00B7DE4E0EDCA15800F77EA2 /* SkTextToPath.h in Headers */,
-				00B7DE510EDCA15800F77EA2 /* SkTypedArray.h in Headers */,
-				00B7DE530EDCA15800F77EA2 /* SkXMLAnimatorWriter.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* animator */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "animator" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = animator;
-			productName = animator;
-			productReference = D2AAC046055464E500DB518D /* libanimator.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "animator" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* animator */;
-			projectDirPath = "";
-			projectRoot = ..;
-			targets = (
-				D2AAC045055464E500DB518D /* animator */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DDB90EDCA15800F77EA2 /* SkAnimateActive.cpp in Sources */,
-				00B7DDBB0EDCA15800F77EA2 /* SkAnimateBase.cpp in Sources */,
-				00B7DDBD0EDCA15800F77EA2 /* SkAnimateField.cpp in Sources */,
-				00B7DDBE0EDCA15800F77EA2 /* SkAnimateMaker.cpp in Sources */,
-				00B7DDC10EDCA15800F77EA2 /* SkAnimateSet.cpp in Sources */,
-				00B7DDC30EDCA15800F77EA2 /* SkAnimator.cpp in Sources */,
-				00B7DDC40EDCA15800F77EA2 /* SkAnimatorScript.cpp in Sources */,
-				00B7DDC60EDCA15800F77EA2 /* SkAnimatorScript2.cpp in Sources */,
-				00B7DDC80EDCA15800F77EA2 /* SkBase64.cpp in Sources */,
-				00B7DDCA0EDCA15800F77EA2 /* SkBoundable.cpp in Sources */,
-				00B7DDCF0EDCA15800F77EA2 /* SkDisplayable.cpp in Sources */,
-				00B7DDD10EDCA15800F77EA2 /* SkDisplayAdd.cpp in Sources */,
-				00B7DDD30EDCA15800F77EA2 /* SkDisplayApply.cpp in Sources */,
-				00B7DDD50EDCA15800F77EA2 /* SkDisplayBounds.cpp in Sources */,
-				00B7DDD70EDCA15800F77EA2 /* SkDisplayEvent.cpp in Sources */,
-				00B7DDD90EDCA15800F77EA2 /* SkDisplayEvents.cpp in Sources */,
-				00B7DDDB0EDCA15800F77EA2 /* SkDisplayInclude.cpp in Sources */,
-				00B7DDDD0EDCA15800F77EA2 /* SkDisplayInput.cpp in Sources */,
-				00B7DDDF0EDCA15800F77EA2 /* SkDisplayList.cpp in Sources */,
-				00B7DDE10EDCA15800F77EA2 /* SkDisplayMath.cpp in Sources */,
-				00B7DDE30EDCA15800F77EA2 /* SkDisplayMovie.cpp in Sources */,
-				00B7DDE50EDCA15800F77EA2 /* SkDisplayNumber.cpp in Sources */,
-				00B7DDE70EDCA15800F77EA2 /* SkDisplayPost.cpp in Sources */,
-				00B7DDE90EDCA15800F77EA2 /* SkDisplayRandom.cpp in Sources */,
-				00B7DDEB0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp in Sources */,
-				00B7DDED0EDCA15800F77EA2 /* SkDisplayType.cpp in Sources */,
-				00B7DDEF0EDCA15800F77EA2 /* SkDisplayTypes.cpp in Sources */,
-				00B7DDF10EDCA15800F77EA2 /* SkDisplayXMLParser.cpp in Sources */,
-				00B7DDF30EDCA15800F77EA2 /* SkDraw3D.cpp in Sources */,
-				00B7DDF50EDCA15800F77EA2 /* SkDrawable.cpp in Sources */,
-				00B7DDF70EDCA15800F77EA2 /* SkDrawBitmap.cpp in Sources */,
-				00B7DDF90EDCA15800F77EA2 /* SkDrawBlur.cpp in Sources */,
-				00B7DDFB0EDCA15800F77EA2 /* SkDrawClip.cpp in Sources */,
-				00B7DDFD0EDCA15800F77EA2 /* SkDrawColor.cpp in Sources */,
-				00B7DDFF0EDCA15800F77EA2 /* SkDrawDash.cpp in Sources */,
-				00B7DE010EDCA15800F77EA2 /* SkDrawDiscrete.cpp in Sources */,
-				00B7DE030EDCA15800F77EA2 /* SkDrawEmboss.cpp in Sources */,
-				00B7DE050EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp in Sources */,
-				00B7DE060EDCA15800F77EA2 /* SkDrawFull.cpp in Sources */,
-				00B7DE080EDCA15800F77EA2 /* SkDrawGradient.cpp in Sources */,
-				00B7DE0A0EDCA15800F77EA2 /* SkDrawGroup.cpp in Sources */,
-				00B7DE0C0EDCA15800F77EA2 /* SkDrawLine.cpp in Sources */,
-				00B7DE0E0EDCA15800F77EA2 /* SkDrawMatrix.cpp in Sources */,
-				00B7DE100EDCA15800F77EA2 /* SkDrawOval.cpp in Sources */,
-				00B7DE120EDCA15800F77EA2 /* SkDrawPaint.cpp in Sources */,
-				00B7DE140EDCA15800F77EA2 /* SkDrawPath.cpp in Sources */,
-				00B7DE160EDCA15800F77EA2 /* SkDrawPoint.cpp in Sources */,
-				00B7DE180EDCA15800F77EA2 /* SkDrawRectangle.cpp in Sources */,
-				00B7DE1A0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp in Sources */,
-				00B7DE1C0EDCA15800F77EA2 /* SkDrawShader.cpp in Sources */,
-				00B7DE1E0EDCA15800F77EA2 /* SkDrawText.cpp in Sources */,
-				00B7DE200EDCA15800F77EA2 /* SkDrawTextBox.cpp in Sources */,
-				00B7DE220EDCA15800F77EA2 /* SkDrawTo.cpp in Sources */,
-				00B7DE240EDCA15800F77EA2 /* SkDrawTransparentShader.cpp in Sources */,
-				00B7DE260EDCA15800F77EA2 /* SkDump.cpp in Sources */,
-				00B7DE290EDCA15800F77EA2 /* SkGetCondensedInfo.cpp in Sources */,
-				00B7DE2A0EDCA15800F77EA2 /* SkHitClear.cpp in Sources */,
-				00B7DE2C0EDCA15800F77EA2 /* SkHitTest.cpp in Sources */,
-				00B7DE2F0EDCA15800F77EA2 /* SkMatrixParts.cpp in Sources */,
-				00B7DE310EDCA15800F77EA2 /* SkMemberInfo.cpp in Sources */,
-				00B7DE330EDCA15800F77EA2 /* SkOpArray.cpp in Sources */,
-				00B7DE380EDCA15800F77EA2 /* SkOperandIterpolator.cpp in Sources */,
-				00B7DE390EDCA15800F77EA2 /* SkPaintParts.cpp in Sources */,
-				00B7DE3B0EDCA15800F77EA2 /* SkPathParts.cpp in Sources */,
-				00B7DE3D0EDCA15800F77EA2 /* SkPostParts.cpp in Sources */,
-				00B7DE3F0EDCA15800F77EA2 /* SkScript.cpp in Sources */,
-				00B7DE430EDCA15800F77EA2 /* SkScriptDecompile.cpp in Sources */,
-				00B7DE440EDCA15800F77EA2 /* SkScriptRuntime.cpp in Sources */,
-				00B7DE460EDCA15800F77EA2 /* SkScriptTokenizer.cpp in Sources */,
-				00B7DE470EDCA15800F77EA2 /* SkSnapshot.cpp in Sources */,
-				00B7DE490EDCA15800F77EA2 /* SkSVGPath.cpp in Sources */,
-				00B7DE4B0EDCA15800F77EA2 /* SkTextOnPath.cpp in Sources */,
-				00B7DE4D0EDCA15800F77EA2 /* SkTextToPath.cpp in Sources */,
-				00B7DE4F0EDCA15800F77EA2 /* SkTime.cpp in Sources */,
-				00B7DE500EDCA15800F77EA2 /* SkTypedArray.cpp in Sources */,
-				00B7DE520EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = animator;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = animator;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "animator" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "animator" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/chipmunk.xcodeproj/project.pbxproj b/xcode/chipmunk.xcodeproj/project.pbxproj
deleted file mode 100644
index d30ddcd..0000000
--- a/xcode/chipmunk.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,258 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		FE16E1510CE26D84006BB7E0 /* chipmunk.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1270CE26C3D006BB7E0 /* chipmunk.c */; };
-		FE16E1520CE26D86006BB7E0 /* cpArbiter.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */; };
-		FE16E1530CE26D87006BB7E0 /* cpArray.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12C0CE26C3D006BB7E0 /* cpArray.c */; };
-		FE16E1540CE26D88006BB7E0 /* cpBB.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12E0CE26C3D006BB7E0 /* cpBB.c */; };
-		FE16E1550CE26D8A006BB7E0 /* cpBody.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1300CE26C3D006BB7E0 /* cpBody.c */; };
-		FE16E1560CE26D8B006BB7E0 /* cpCollision.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1320CE26C3D006BB7E0 /* cpCollision.c */; };
-		FE16E1570CE26D8C006BB7E0 /* cpHashSet.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */; };
-		FE16E1580CE26D8F006BB7E0 /* cpJoint.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1360CE26C3D006BB7E0 /* cpJoint.c */; };
-		FE16E1590CE26D91006BB7E0 /* cpPolyShape.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */; };
-		FE16E15E0CE26D9E006BB7E0 /* cpShape.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13A0CE26C3D006BB7E0 /* cpShape.c */; };
-		FE16E15F0CE26D9F006BB7E0 /* cpSpace.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */; };
-		FE16E1600CE26DA0006BB7E0 /* cpSpaceHash.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */; };
-		FE16E1610CE26DA1006BB7E0 /* cpVect.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1400CE26C3D006BB7E0 /* cpVect.c */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		FE16E1270CE26C3D006BB7E0 /* chipmunk.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = chipmunk.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/chipmunk.c"; sourceTree = "<absolute>"; };
-		FE16E1280CE26C3D006BB7E0 /* chipmunk.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = chipmunk.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/chipmunk.h"; sourceTree = "<absolute>"; };
-		FE16E1290CE26C3D006BB7E0 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; name = CMakeLists.txt; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/CMakeLists.txt"; sourceTree = "<absolute>"; };
-		FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpArbiter.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArbiter.c"; sourceTree = "<absolute>"; };
-		FE16E12B0CE26C3D006BB7E0 /* cpArbiter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpArbiter.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArbiter.h"; sourceTree = "<absolute>"; };
-		FE16E12C0CE26C3D006BB7E0 /* cpArray.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpArray.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArray.c"; sourceTree = "<absolute>"; };
-		FE16E12D0CE26C3D006BB7E0 /* cpArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpArray.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArray.h"; sourceTree = "<absolute>"; };
-		FE16E12E0CE26C3D006BB7E0 /* cpBB.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpBB.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBB.c"; sourceTree = "<absolute>"; };
-		FE16E12F0CE26C3D006BB7E0 /* cpBB.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpBB.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBB.h"; sourceTree = "<absolute>"; };
-		FE16E1300CE26C3D006BB7E0 /* cpBody.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpBody.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBody.c"; sourceTree = "<absolute>"; };
-		FE16E1310CE26C3D006BB7E0 /* cpBody.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpBody.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBody.h"; sourceTree = "<absolute>"; };
-		FE16E1320CE26C3D006BB7E0 /* cpCollision.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpCollision.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpCollision.c"; sourceTree = "<absolute>"; };
-		FE16E1330CE26C3D006BB7E0 /* cpCollision.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpCollision.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpCollision.h"; sourceTree = "<absolute>"; };
-		FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpHashSet.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpHashSet.c"; sourceTree = "<absolute>"; };
-		FE16E1350CE26C3D006BB7E0 /* cpHashSet.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpHashSet.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpHashSet.h"; sourceTree = "<absolute>"; };
-		FE16E1360CE26C3D006BB7E0 /* cpJoint.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpJoint.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpJoint.c"; sourceTree = "<absolute>"; };
-		FE16E1370CE26C3D006BB7E0 /* cpJoint.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpJoint.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpJoint.h"; sourceTree = "<absolute>"; };
-		FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpPolyShape.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpPolyShape.c"; sourceTree = "<absolute>"; };
-		FE16E1390CE26C3D006BB7E0 /* cpPolyShape.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpPolyShape.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpPolyShape.h"; sourceTree = "<absolute>"; };
-		FE16E13A0CE26C3D006BB7E0 /* cpShape.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpShape.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpShape.c"; sourceTree = "<absolute>"; };
-		FE16E13B0CE26C3D006BB7E0 /* cpShape.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpShape.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpShape.h"; sourceTree = "<absolute>"; };
-		FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpSpace.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpace.c"; sourceTree = "<absolute>"; };
-		FE16E13D0CE26C3D006BB7E0 /* cpSpace.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpSpace.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpace.h"; sourceTree = "<absolute>"; };
-		FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpSpaceHash.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpaceHash.c"; sourceTree = "<absolute>"; };
-		FE16E13F0CE26C3D006BB7E0 /* cpSpaceHash.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpSpaceHash.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpaceHash.h"; sourceTree = "<absolute>"; };
-		FE16E1400CE26C3D006BB7E0 /* cpVect.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpVect.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpVect.c"; sourceTree = "<absolute>"; };
-		FE16E1410CE26C3D006BB7E0 /* cpVect.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpVect.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpVect.h"; sourceTree = "<absolute>"; };
-		FE16E1420CE26C3D006BB7E0 /* prime.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = prime.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/prime.h"; sourceTree = "<absolute>"; };
-		FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libchipmunk.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		FE16E14A0CE26D61006BB7E0 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		FE16E11A0CE26B5D006BB7E0 = {
-			isa = PBXGroup;
-			children = (
-				FE16E1250CE26B6A006BB7E0 /* Sources */,
-				FE16E14D0CE26D61006BB7E0 /* Products */,
-			);
-			sourceTree = "<group>";
-		};
-		FE16E1250CE26B6A006BB7E0 /* Sources */ = {
-			isa = PBXGroup;
-			children = (
-				FE16E1270CE26C3D006BB7E0 /* chipmunk.c */,
-				FE16E1280CE26C3D006BB7E0 /* chipmunk.h */,
-				FE16E1290CE26C3D006BB7E0 /* CMakeLists.txt */,
-				FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */,
-				FE16E12B0CE26C3D006BB7E0 /* cpArbiter.h */,
-				FE16E12C0CE26C3D006BB7E0 /* cpArray.c */,
-				FE16E12D0CE26C3D006BB7E0 /* cpArray.h */,
-				FE16E12E0CE26C3D006BB7E0 /* cpBB.c */,
-				FE16E12F0CE26C3D006BB7E0 /* cpBB.h */,
-				FE16E1300CE26C3D006BB7E0 /* cpBody.c */,
-				FE16E1310CE26C3D006BB7E0 /* cpBody.h */,
-				FE16E1320CE26C3D006BB7E0 /* cpCollision.c */,
-				FE16E1330CE26C3D006BB7E0 /* cpCollision.h */,
-				FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */,
-				FE16E1350CE26C3D006BB7E0 /* cpHashSet.h */,
-				FE16E1360CE26C3D006BB7E0 /* cpJoint.c */,
-				FE16E1370CE26C3D006BB7E0 /* cpJoint.h */,
-				FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */,
-				FE16E1390CE26C3D006BB7E0 /* cpPolyShape.h */,
-				FE16E13A0CE26C3D006BB7E0 /* cpShape.c */,
-				FE16E13B0CE26C3D006BB7E0 /* cpShape.h */,
-				FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */,
-				FE16E13D0CE26C3D006BB7E0 /* cpSpace.h */,
-				FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */,
-				FE16E13F0CE26C3D006BB7E0 /* cpSpaceHash.h */,
-				FE16E1400CE26C3D006BB7E0 /* cpVect.c */,
-				FE16E1410CE26C3D006BB7E0 /* cpVect.h */,
-				FE16E1420CE26C3D006BB7E0 /* prime.h */,
-			);
-			name = Sources;
-			sourceTree = "<group>";
-		};
-		FE16E14D0CE26D61006BB7E0 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		FE16E1480CE26D61006BB7E0 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		FE16E14B0CE26D61006BB7E0 /* chipmunk */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = FE16E14E0CE26D61006BB7E0 /* Build configuration list for PBXNativeTarget "chipmunk" */;
-			buildPhases = (
-				FE16E1480CE26D61006BB7E0 /* Headers */,
-				FE16E1490CE26D61006BB7E0 /* Sources */,
-				FE16E14A0CE26D61006BB7E0 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = chipmunk;
-			productName = chipmunk;
-			productReference = FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		FE16E11C0CE26B5D006BB7E0 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = FE16E11D0CE26B5D006BB7E0 /* Build configuration list for PBXProject "chipmunk" */;
-			hasScannedForEncodings = 0;
-			mainGroup = FE16E11A0CE26B5D006BB7E0;
-			productRefGroup = FE16E14D0CE26D61006BB7E0 /* Products */;
-			projectDirPath = "";
-			targets = (
-				FE16E14B0CE26D61006BB7E0 /* chipmunk */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		FE16E1490CE26D61006BB7E0 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FE16E1510CE26D84006BB7E0 /* chipmunk.c in Sources */,
-				FE16E1520CE26D86006BB7E0 /* cpArbiter.c in Sources */,
-				FE16E1530CE26D87006BB7E0 /* cpArray.c in Sources */,
-				FE16E1540CE26D88006BB7E0 /* cpBB.c in Sources */,
-				FE16E1550CE26D8A006BB7E0 /* cpBody.c in Sources */,
-				FE16E1560CE26D8B006BB7E0 /* cpCollision.c in Sources */,
-				FE16E1570CE26D8C006BB7E0 /* cpHashSet.c in Sources */,
-				FE16E1580CE26D8F006BB7E0 /* cpJoint.c in Sources */,
-				FE16E1590CE26D91006BB7E0 /* cpPolyShape.c in Sources */,
-				FE16E15E0CE26D9E006BB7E0 /* cpShape.c in Sources */,
-				FE16E15F0CE26D9F006BB7E0 /* cpSpace.c in Sources */,
-				FE16E1600CE26DA0006BB7E0 /* cpSpaceHash.c in Sources */,
-				FE16E1610CE26DA1006BB7E0 /* cpVect.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		FE16E11E0CE26B5D006BB7E0 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-			};
-			name = Debug;
-		};
-		FE16E11F0CE26B5D006BB7E0 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-			};
-			name = Release;
-		};
-		FE16E14F0CE26D61006BB7E0 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PREBINDING = NO;
-				PRODUCT_NAME = chipmunk;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		FE16E1500CE26D61006BB7E0 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PREBINDING = NO;
-				PRODUCT_NAME = chipmunk;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		FE16E11D0CE26B5D006BB7E0 /* Build configuration list for PBXProject "chipmunk" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE16E11E0CE26B5D006BB7E0 /* Debug */,
-				FE16E11F0CE26B5D006BB7E0 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		FE16E14E0CE26D61006BB7E0 /* Build configuration list for PBXNativeTarget "chipmunk" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE16E14F0CE26D61006BB7E0 /* Debug */,
-				FE16E1500CE26D61006BB7E0 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = FE16E11C0CE26B5D006BB7E0 /* Project object */;
-}
diff --git a/xcode/corecg.xcodeproj/project.pbxproj b/xcode/corecg.xcodeproj/project.pbxproj
deleted file mode 100644
index 1b01d4f..0000000
--- a/xcode/corecg.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,292 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DE790EDCA1CE00F77EA2 /* Sk64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */; };
-		00B7DE7A0EDCA1CE00F77EA2 /* SkBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */; };
-		00B7DE7B0EDCA1CE00F77EA2 /* SkChunkAlloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */; };
-		00B7DE7C0EDCA1CE00F77EA2 /* SkCordic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */; };
-		00B7DE7D0EDCA1CE00F77EA2 /* SkCordic.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */; };
-		00B7DE7E0EDCA1CE00F77EA2 /* SkDebug.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */; };
-		00B7DE7F0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */; };
-		00B7DE800EDCA1CE00F77EA2 /* SkFloat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */; };
-		00B7DE810EDCA1CE00F77EA2 /* SkFloat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */; };
-		00B7DE820EDCA1CE00F77EA2 /* SkFloatBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */; };
-		00B7DE830EDCA1CE00F77EA2 /* SkInterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */; };
-		00B7DE840EDCA1CE00F77EA2 /* SkMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */; };
-		00B7DE850EDCA1CE00F77EA2 /* SkMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */; };
-		00B7DE860EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */; };
-		00B7DE870EDCA1CE00F77EA2 /* SkPageFlipper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */; };
-		00B7DE880EDCA1CE00F77EA2 /* SkPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */; };
-		00B7DE890EDCA1CE00F77EA2 /* SkRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */; };
-		00B7DE8A0EDCA1CE00F77EA2 /* SkRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */; };
-		00B7DE8B0EDCA1CE00F77EA2 /* SkRegionPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */; };
-		00B7DE8C0EDCA1CE00F77EA2 /* SkSinTable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */; };
-		00B7DE8D0EDCA1CE00F77EA2 /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk64.cpp; path = ../libcorecg/Sk64.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBuffer.cpp; path = ../libcorecg/SkBuffer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkChunkAlloc.cpp; path = ../libcorecg/SkChunkAlloc.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCordic.cpp; path = ../libcorecg/SkCordic.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCordic.h; path = ../libcorecg/SkCordic.h; sourceTree = SOURCE_ROOT; };
-		00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug.cpp; path = ../libcorecg/SkDebug.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug_stdio.cpp; path = ../libcorecg/SkDebug_stdio.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloat.cpp; path = ../libcorecg/SkFloat.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFloat.h; path = ../libcorecg/SkFloat.h; sourceTree = SOURCE_ROOT; };
-		00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloatBits.cpp; path = ../libcorecg/SkFloatBits.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkInterpolator.cpp; path = ../libcorecg/SkInterpolator.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMath.cpp; path = ../libcorecg/SkMath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrix.cpp; path = ../libcorecg/SkMatrix.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemory_stdlib.cpp; path = ../libcorecg/SkMemory_stdlib.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPageFlipper.cpp; path = ../libcorecg/SkPageFlipper.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPoint.cpp; path = ../libcorecg/SkPoint.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRect.cpp; path = ../libcorecg/SkRect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion.cpp; path = ../libcorecg/SkRegion.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRegionPriv.h; path = ../libcorecg/SkRegionPriv.h; sourceTree = SOURCE_ROOT; };
-		00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSinTable.h; path = ../libcorecg/SkSinTable.h; sourceTree = SOURCE_ROOT; };
-		00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libcorecg/SkTSort.h; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libcorecg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libcorecg.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* corecg */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = corecg;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */,
-				00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */,
-				00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */,
-				00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */,
-				00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */,
-				00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */,
-				00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */,
-				00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */,
-				00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */,
-				00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */,
-				00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */,
-				00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */,
-				00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */,
-				00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */,
-				00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */,
-				00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */,
-				00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */,
-				00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */,
-				00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */,
-				00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */,
-				00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libcorecg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DE7D0EDCA1CE00F77EA2 /* SkCordic.h in Headers */,
-				00B7DE810EDCA1CE00F77EA2 /* SkFloat.h in Headers */,
-				00B7DE8B0EDCA1CE00F77EA2 /* SkRegionPriv.h in Headers */,
-				00B7DE8C0EDCA1CE00F77EA2 /* SkSinTable.h in Headers */,
-				00B7DE8D0EDCA1CE00F77EA2 /* SkTSort.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* corecg */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "corecg" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = corecg;
-			productName = corecg;
-			productReference = D2AAC046055464E500DB518D /* libcorecg.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "corecg" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* corecg */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC045055464E500DB518D /* corecg */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DE790EDCA1CE00F77EA2 /* Sk64.cpp in Sources */,
-				00B7DE7A0EDCA1CE00F77EA2 /* SkBuffer.cpp in Sources */,
-				00B7DE7B0EDCA1CE00F77EA2 /* SkChunkAlloc.cpp in Sources */,
-				00B7DE7C0EDCA1CE00F77EA2 /* SkCordic.cpp in Sources */,
-				00B7DE7E0EDCA1CE00F77EA2 /* SkDebug.cpp in Sources */,
-				00B7DE7F0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp in Sources */,
-				00B7DE800EDCA1CE00F77EA2 /* SkFloat.cpp in Sources */,
-				00B7DE820EDCA1CE00F77EA2 /* SkFloatBits.cpp in Sources */,
-				00B7DE830EDCA1CE00F77EA2 /* SkInterpolator.cpp in Sources */,
-				00B7DE840EDCA1CE00F77EA2 /* SkMath.cpp in Sources */,
-				00B7DE850EDCA1CE00F77EA2 /* SkMatrix.cpp in Sources */,
-				00B7DE860EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp in Sources */,
-				00B7DE870EDCA1CE00F77EA2 /* SkPageFlipper.cpp in Sources */,
-				00B7DE880EDCA1CE00F77EA2 /* SkPoint.cpp in Sources */,
-				00B7DE890EDCA1CE00F77EA2 /* SkRect.cpp in Sources */,
-				00B7DE8A0EDCA1CE00F77EA2 /* SkRegion.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = corecg;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = corecg;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = ../include/corecg;
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = ../include/corecg;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "corecg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "corecg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/expat.xcodeproj/project.pbxproj b/xcode/expat.xcodeproj/project.pbxproj
deleted file mode 100644
index 37a9b0f..0000000
--- a/xcode/expat.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,246 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DE9E0EDCA22F00F77EA2 /* SkXMLPullParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */; };
-		00B7DEA20EDCA25700F77EA2 /* SkXMLParser_expat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */; };
-		00B7DEA60EDCA27F00F77EA2 /* xmlparse.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */; };
-		00B7DEA70EDCA27F00F77EA2 /* xmlrole.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */; };
-		00B7DEA80EDCA27F00F77EA2 /* xmltok.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA50EDCA27F00F77EA2 /* xmltok.c */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLPullParser.cpp; path = ../libsgl/xml/SkXMLPullParser.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser_expat.cpp; path = ../libsgl/ports/SkXMLParser_expat.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmlparse.c; path = ../../expat/lib/xmlparse.c; sourceTree = SOURCE_ROOT; };
-		00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmlrole.c; path = ../../expat/lib/xmlrole.c; sourceTree = SOURCE_ROOT; };
-		00B7DEA50EDCA27F00F77EA2 /* xmltok.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmltok.c; path = ../../expat/lib/xmltok.c; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libexpat.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libexpat.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* expat */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = expat;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */,
-				00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */,
-				00B7DEA50EDCA27F00F77EA2 /* xmltok.c */,
-				00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */,
-				00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libexpat.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* expat */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "expat" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = expat;
-			productName = expat;
-			productReference = D2AAC046055464E500DB518D /* libexpat.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "expat" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* expat */;
-			projectDirPath = "";
-			projectRoot = ..;
-			targets = (
-				D2AAC045055464E500DB518D /* expat */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DE9E0EDCA22F00F77EA2 /* SkXMLPullParser.cpp in Sources */,
-				00B7DEA20EDCA25700F77EA2 /* SkXMLParser_expat.cpp in Sources */,
-				00B7DEA60EDCA27F00F77EA2 /* xmlparse.c in Sources */,
-				00B7DEA70EDCA27F00F77EA2 /* xmlrole.c in Sources */,
-				00B7DEA80EDCA27F00F77EA2 /* xmltok.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = expat;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					MACOS_CLASSIC,
-					XML_STATIC,
-					SK_RELEASE,
-				);
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = expat;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					MACOS_CLASSIC,
-					XML_STATIC,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/** ../../expat/lib";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					MACOS_CLASSIC,
-					XML_STATIC,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/** ../../expat/lib";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "expat" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "expat" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/freetype2.xcodeproj/project.pbxproj b/xcode/freetype2.xcodeproj/project.pbxproj
deleted file mode 100644
index 08c13a3..0000000
--- a/xcode/freetype2.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,456 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DEE20EDCA46500F77EA2 /* ftadvanc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */; };
-		00B7DEE30EDCA46500F77EA2 /* ftapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC80EDCA46500F77EA2 /* ftapi.c */; };
-		00B7DEE40EDCA46500F77EA2 /* ftbase.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC90EDCA46500F77EA2 /* ftbase.c */; };
-		00B7DEE50EDCA46500F77EA2 /* ftbbox.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECA0EDCA46500F77EA2 /* ftbbox.c */; };
-		00B7DEE60EDCA46500F77EA2 /* ftbitmap.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */; };
-		00B7DEE70EDCA46500F77EA2 /* ftcalc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECC0EDCA46500F77EA2 /* ftcalc.c */; };
-		00B7DEE80EDCA46500F77EA2 /* ftdbgmem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */; };
-		00B7DEE90EDCA46500F77EA2 /* ftdebug.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECE0EDCA46500F77EA2 /* ftdebug.c */; };
-		00B7DEEA0EDCA46500F77EA2 /* ftgasp.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECF0EDCA46500F77EA2 /* ftgasp.c */; };
-		00B7DEEB0EDCA46500F77EA2 /* ftgloadr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED00EDCA46500F77EA2 /* ftgloadr.c */; };
-		00B7DEEC0EDCA46500F77EA2 /* ftglyph.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED10EDCA46500F77EA2 /* ftglyph.c */; };
-		00B7DEED0EDCA46500F77EA2 /* ftinit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED20EDCA46500F77EA2 /* ftinit.c */; };
-		00B7DEEE0EDCA46500F77EA2 /* ftlcdfil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */; };
-		00B7DEEF0EDCA46500F77EA2 /* ftmm.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED40EDCA46500F77EA2 /* ftmm.c */; };
-		00B7DEF00EDCA46500F77EA2 /* ftnames.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED50EDCA46500F77EA2 /* ftnames.c */; };
-		00B7DEF10EDCA46500F77EA2 /* ftobjs.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED60EDCA46500F77EA2 /* ftobjs.c */; };
-		00B7DEF20EDCA46500F77EA2 /* ftoutln.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED70EDCA46500F77EA2 /* ftoutln.c */; };
-		00B7DEF30EDCA46500F77EA2 /* ftpatent.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED80EDCA46500F77EA2 /* ftpatent.c */; };
-		00B7DEF40EDCA46500F77EA2 /* ftrfork.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED90EDCA46500F77EA2 /* ftrfork.c */; };
-		00B7DEF50EDCA46500F77EA2 /* ftstream.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDA0EDCA46500F77EA2 /* ftstream.c */; };
-		00B7DEF60EDCA46500F77EA2 /* ftstroke.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */; };
-		00B7DEF70EDCA46500F77EA2 /* ftsynth.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */; };
-		00B7DEF80EDCA46500F77EA2 /* ftsystem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */; };
-		00B7DEF90EDCA46500F77EA2 /* fttrigon.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */; };
-		00B7DEFA0EDCA46500F77EA2 /* ftutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDF0EDCA46500F77EA2 /* ftutil.c */; };
-		00B7DEFB0EDCA46500F77EA2 /* ftwinfnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */; };
-		00B7DEFC0EDCA46500F77EA2 /* ftxf86.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEE10EDCA46500F77EA2 /* ftxf86.c */; };
-		00B7DEFE0EDCA47900F77EA2 /* raster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEFD0EDCA47900F77EA2 /* raster.c */; };
-		00B7DF000EDCA48B00F77EA2 /* sfnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */; };
-		00B7DF020EDCA49C00F77EA2 /* smooth.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF010EDCA49C00F77EA2 /* smooth.c */; };
-		00B7DF040EDCA4AF00F77EA2 /* autofit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF030EDCA4AF00F77EA2 /* autofit.c */; };
-		00B7DF060EDCA4BE00F77EA2 /* truetype.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF050EDCA4BE00F77EA2 /* truetype.c */; };
-		00B7DF080EDCA4CE00F77EA2 /* cff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF070EDCA4CE00F77EA2 /* cff.c */; };
-		00B7DF0A0EDCA4DD00F77EA2 /* psaux.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF090EDCA4DD00F77EA2 /* psaux.c */; };
-		00B7DF0C0EDCA4ED00F77EA2 /* psnames.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */; };
-		00B7DF100EDCA50100F77EA2 /* pshinter.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF0F0EDCA50100F77EA2 /* pshinter.c */; };
-		00B7DF120EDCA51600F77EA2 /* SkFontHost_FreeType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftadvanc.c; path = ../../freetype/src/base/ftadvanc.c; sourceTree = SOURCE_ROOT; };
-		00B7DEC80EDCA46500F77EA2 /* ftapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftapi.c; path = ../../freetype/src/base/ftapi.c; sourceTree = SOURCE_ROOT; };
-		00B7DEC90EDCA46500F77EA2 /* ftbase.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbase.c; path = ../../freetype/src/base/ftbase.c; sourceTree = SOURCE_ROOT; };
-		00B7DECA0EDCA46500F77EA2 /* ftbbox.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbbox.c; path = ../../freetype/src/base/ftbbox.c; sourceTree = SOURCE_ROOT; };
-		00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbitmap.c; path = ../../freetype/src/base/ftbitmap.c; sourceTree = SOURCE_ROOT; };
-		00B7DECC0EDCA46500F77EA2 /* ftcalc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftcalc.c; path = ../../freetype/src/base/ftcalc.c; sourceTree = SOURCE_ROOT; };
-		00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftdbgmem.c; path = ../../freetype/src/base/ftdbgmem.c; sourceTree = SOURCE_ROOT; };
-		00B7DECE0EDCA46500F77EA2 /* ftdebug.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftdebug.c; path = ../../freetype/src/base/ftdebug.c; sourceTree = SOURCE_ROOT; };
-		00B7DECF0EDCA46500F77EA2 /* ftgasp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftgasp.c; path = ../../freetype/src/base/ftgasp.c; sourceTree = SOURCE_ROOT; };
-		00B7DED00EDCA46500F77EA2 /* ftgloadr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftgloadr.c; path = ../../freetype/src/base/ftgloadr.c; sourceTree = SOURCE_ROOT; };
-		00B7DED10EDCA46500F77EA2 /* ftglyph.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftglyph.c; path = ../../freetype/src/base/ftglyph.c; sourceTree = SOURCE_ROOT; };
-		00B7DED20EDCA46500F77EA2 /* ftinit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftinit.c; path = ../../freetype/src/base/ftinit.c; sourceTree = SOURCE_ROOT; };
-		00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftlcdfil.c; path = ../../freetype/src/base/ftlcdfil.c; sourceTree = SOURCE_ROOT; };
-		00B7DED40EDCA46500F77EA2 /* ftmm.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftmm.c; path = ../../freetype/src/base/ftmm.c; sourceTree = SOURCE_ROOT; };
-		00B7DED50EDCA46500F77EA2 /* ftnames.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftnames.c; path = ../../freetype/src/base/ftnames.c; sourceTree = SOURCE_ROOT; };
-		00B7DED60EDCA46500F77EA2 /* ftobjs.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftobjs.c; path = ../../freetype/src/base/ftobjs.c; sourceTree = SOURCE_ROOT; };
-		00B7DED70EDCA46500F77EA2 /* ftoutln.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftoutln.c; path = ../../freetype/src/base/ftoutln.c; sourceTree = SOURCE_ROOT; };
-		00B7DED80EDCA46500F77EA2 /* ftpatent.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftpatent.c; path = ../../freetype/src/base/ftpatent.c; sourceTree = SOURCE_ROOT; };
-		00B7DED90EDCA46500F77EA2 /* ftrfork.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftrfork.c; path = ../../freetype/src/base/ftrfork.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDA0EDCA46500F77EA2 /* ftstream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftstream.c; path = ../../freetype/src/base/ftstream.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftstroke.c; path = ../../freetype/src/base/ftstroke.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftsynth.c; path = ../../freetype/src/base/ftsynth.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftsystem.c; path = ../../freetype/src/base/ftsystem.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = fttrigon.c; path = ../../freetype/src/base/fttrigon.c; sourceTree = SOURCE_ROOT; };
-		00B7DEDF0EDCA46500F77EA2 /* ftutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftutil.c; path = ../../freetype/src/base/ftutil.c; sourceTree = SOURCE_ROOT; };
-		00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftwinfnt.c; path = ../../freetype/src/base/ftwinfnt.c; sourceTree = SOURCE_ROOT; };
-		00B7DEE10EDCA46500F77EA2 /* ftxf86.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftxf86.c; path = ../../freetype/src/base/ftxf86.c; sourceTree = SOURCE_ROOT; };
-		00B7DEFD0EDCA47900F77EA2 /* raster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = raster.c; path = ../../freetype/src/raster/raster.c; sourceTree = SOURCE_ROOT; };
-		00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = sfnt.c; path = ../../freetype/src/sfnt/sfnt.c; sourceTree = SOURCE_ROOT; };
-		00B7DF010EDCA49C00F77EA2 /* smooth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = smooth.c; path = ../../freetype/src/smooth/smooth.c; sourceTree = SOURCE_ROOT; };
-		00B7DF030EDCA4AF00F77EA2 /* autofit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = autofit.c; path = ../../freetype/src/autofit/autofit.c; sourceTree = SOURCE_ROOT; };
-		00B7DF050EDCA4BE00F77EA2 /* truetype.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = truetype.c; path = ../../freetype/src/truetype/truetype.c; sourceTree = SOURCE_ROOT; };
-		00B7DF070EDCA4CE00F77EA2 /* cff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = cff.c; path = ../../freetype/src/cff/cff.c; sourceTree = SOURCE_ROOT; };
-		00B7DF090EDCA4DD00F77EA2 /* psaux.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = psaux.c; path = ../../freetype/src/psaux/psaux.c; sourceTree = SOURCE_ROOT; };
-		00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = psnames.c; path = ../../freetype/src/psnames/psnames.c; sourceTree = SOURCE_ROOT; };
-		00B7DF0F0EDCA50100F77EA2 /* pshinter.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pshinter.c; path = ../../freetype/src/pshinter/pshinter.c; sourceTree = SOURCE_ROOT; };
-		00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_FreeType.cpp; path = ../libsgl/ports/SkFontHost_FreeType.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libfreetype.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libfreetype.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* freetype */ = {
-			isa = PBXGroup;
-			children = (
-				FE33C98F094E104700C4A640 /* base */,
-				FE33C990094E105100C4A640 /* raster */,
-				FE33C997094E109300C4A640 /* snft */,
-				FE33C998094E109D00C4A640 /* smooth */,
-				FE33C999094E10B000C4A640 /* autohint */,
-				FE33C99A094E10BD00C4A640 /* truetype */,
-				FE33C99B094E10C600C4A640 /* cff */,
-				FE33C99E094E10E100C4A640 /* psaux */,
-				FE33C99F094E10EB00C4A640 /* psnames */,
-				FE33C9A0094E10F400C4A640 /* pshinter */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = freetype;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libfreetype.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-		FE33C98F094E104700C4A640 /* base */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */,
-				00B7DEC80EDCA46500F77EA2 /* ftapi.c */,
-				00B7DEC90EDCA46500F77EA2 /* ftbase.c */,
-				00B7DECA0EDCA46500F77EA2 /* ftbbox.c */,
-				00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */,
-				00B7DECC0EDCA46500F77EA2 /* ftcalc.c */,
-				00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */,
-				00B7DECE0EDCA46500F77EA2 /* ftdebug.c */,
-				00B7DECF0EDCA46500F77EA2 /* ftgasp.c */,
-				00B7DED00EDCA46500F77EA2 /* ftgloadr.c */,
-				00B7DED10EDCA46500F77EA2 /* ftglyph.c */,
-				00B7DED20EDCA46500F77EA2 /* ftinit.c */,
-				00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */,
-				00B7DED40EDCA46500F77EA2 /* ftmm.c */,
-				00B7DED50EDCA46500F77EA2 /* ftnames.c */,
-				00B7DED60EDCA46500F77EA2 /* ftobjs.c */,
-				00B7DED70EDCA46500F77EA2 /* ftoutln.c */,
-				00B7DED80EDCA46500F77EA2 /* ftpatent.c */,
-				00B7DED90EDCA46500F77EA2 /* ftrfork.c */,
-				00B7DEDA0EDCA46500F77EA2 /* ftstream.c */,
-				00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */,
-				00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */,
-				00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */,
-				00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */,
-				00B7DEDF0EDCA46500F77EA2 /* ftutil.c */,
-				00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */,
-				00B7DEE10EDCA46500F77EA2 /* ftxf86.c */,
-			);
-			name = base;
-			sourceTree = "<group>";
-		};
-		FE33C990094E105100C4A640 /* raster */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DEFD0EDCA47900F77EA2 /* raster.c */,
-			);
-			name = raster;
-			sourceTree = "<group>";
-		};
-		FE33C997094E109300C4A640 /* snft */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */,
-			);
-			name = snft;
-			sourceTree = "<group>";
-		};
-		FE33C998094E109D00C4A640 /* smooth */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF010EDCA49C00F77EA2 /* smooth.c */,
-			);
-			name = smooth;
-			sourceTree = "<group>";
-		};
-		FE33C999094E10B000C4A640 /* autohint */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF030EDCA4AF00F77EA2 /* autofit.c */,
-			);
-			name = autohint;
-			sourceTree = "<group>";
-		};
-		FE33C99A094E10BD00C4A640 /* truetype */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF050EDCA4BE00F77EA2 /* truetype.c */,
-			);
-			name = truetype;
-			sourceTree = "<group>";
-		};
-		FE33C99B094E10C600C4A640 /* cff */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF070EDCA4CE00F77EA2 /* cff.c */,
-			);
-			name = cff;
-			sourceTree = "<group>";
-		};
-		FE33C99E094E10E100C4A640 /* psaux */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF090EDCA4DD00F77EA2 /* psaux.c */,
-			);
-			name = psaux;
-			sourceTree = "<group>";
-		};
-		FE33C99F094E10EB00C4A640 /* psnames */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */,
-			);
-			name = psnames;
-			sourceTree = "<group>";
-		};
-		FE33C9A0094E10F400C4A640 /* pshinter */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF0F0EDCA50100F77EA2 /* pshinter.c */,
-			);
-			name = pshinter;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* freetype */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "freetype" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = freetype;
-			productName = freetype;
-			productReference = D2AAC046055464E500DB518D /* libfreetype.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "freetype2" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* freetype */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC045055464E500DB518D /* freetype */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DEE20EDCA46500F77EA2 /* ftadvanc.c in Sources */,
-				00B7DEE30EDCA46500F77EA2 /* ftapi.c in Sources */,
-				00B7DEE40EDCA46500F77EA2 /* ftbase.c in Sources */,
-				00B7DEE50EDCA46500F77EA2 /* ftbbox.c in Sources */,
-				00B7DEE60EDCA46500F77EA2 /* ftbitmap.c in Sources */,
-				00B7DEE70EDCA46500F77EA2 /* ftcalc.c in Sources */,
-				00B7DEE80EDCA46500F77EA2 /* ftdbgmem.c in Sources */,
-				00B7DEE90EDCA46500F77EA2 /* ftdebug.c in Sources */,
-				00B7DEEA0EDCA46500F77EA2 /* ftgasp.c in Sources */,
-				00B7DEEB0EDCA46500F77EA2 /* ftgloadr.c in Sources */,
-				00B7DEEC0EDCA46500F77EA2 /* ftglyph.c in Sources */,
-				00B7DEED0EDCA46500F77EA2 /* ftinit.c in Sources */,
-				00B7DEEE0EDCA46500F77EA2 /* ftlcdfil.c in Sources */,
-				00B7DEEF0EDCA46500F77EA2 /* ftmm.c in Sources */,
-				00B7DEF00EDCA46500F77EA2 /* ftnames.c in Sources */,
-				00B7DEF10EDCA46500F77EA2 /* ftobjs.c in Sources */,
-				00B7DEF20EDCA46500F77EA2 /* ftoutln.c in Sources */,
-				00B7DEF30EDCA46500F77EA2 /* ftpatent.c in Sources */,
-				00B7DEF40EDCA46500F77EA2 /* ftrfork.c in Sources */,
-				00B7DEF50EDCA46500F77EA2 /* ftstream.c in Sources */,
-				00B7DEF60EDCA46500F77EA2 /* ftstroke.c in Sources */,
-				00B7DEF70EDCA46500F77EA2 /* ftsynth.c in Sources */,
-				00B7DEF80EDCA46500F77EA2 /* ftsystem.c in Sources */,
-				00B7DEF90EDCA46500F77EA2 /* fttrigon.c in Sources */,
-				00B7DEFA0EDCA46500F77EA2 /* ftutil.c in Sources */,
-				00B7DEFB0EDCA46500F77EA2 /* ftwinfnt.c in Sources */,
-				00B7DEFC0EDCA46500F77EA2 /* ftxf86.c in Sources */,
-				00B7DEFE0EDCA47900F77EA2 /* raster.c in Sources */,
-				00B7DF000EDCA48B00F77EA2 /* sfnt.c in Sources */,
-				00B7DF020EDCA49C00F77EA2 /* smooth.c in Sources */,
-				00B7DF040EDCA4AF00F77EA2 /* autofit.c in Sources */,
-				00B7DF060EDCA4BE00F77EA2 /* truetype.c in Sources */,
-				00B7DF080EDCA4CE00F77EA2 /* cff.c in Sources */,
-				00B7DF0A0EDCA4DD00F77EA2 /* psaux.c in Sources */,
-				00B7DF0C0EDCA4ED00F77EA2 /* psnames.c in Sources */,
-				00B7DF100EDCA50100F77EA2 /* pshinter.c in Sources */,
-				00B7DF120EDCA51600F77EA2 /* SkFontHost_FreeType.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = freetype;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = freetype;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					TT_CONFIG_OPTION_BYTECODE_INTERPRETER,
-					FT2_BUILD_LIBRARY,
-					DARWIN_NO_CARBON,
-					SK_DEBUG,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../../freetype/include ../include/**";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					TT_CONFIG_OPTION_BYTECODE_INTERPRETER,
-					FT2_BUILD_LIBRARY,
-					DARWIN_NO_CARBON,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../../freetype/include ../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "freetype" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "freetype2" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/gif.xcodeproj/project.pbxproj b/xcode/gif.xcodeproj/project.pbxproj
deleted file mode 100644
index 0645a35..0000000
--- a/xcode/gif.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,264 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		008CFC4D0C04B77E00FB4126 /* SkMovie_gif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */; };
-		00B13BE30C0C6EFA0033F013 /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */; };
-		FE08AB3F0945EFBE0057213F /* gif_lib_private.h in Headers */ = {isa = PBXBuildFile; fileRef = FE08AB3D0945EFBE0057213F /* gif_lib_private.h */; };
-		FE08AB400945EFBE0057213F /* gif_lib.h in Headers */ = {isa = PBXBuildFile; fileRef = FE08AB3E0945EFBE0057213F /* gif_lib.h */; };
-		FE08AB440945EFEF0057213F /* dgif_lib.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB410945EFEF0057213F /* dgif_lib.c */; };
-		FE08AB450945EFEF0057213F /* gif_err.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB420945EFEF0057213F /* gif_err.c */; };
-		FE08AB460945EFEF0057213F /* gifalloc.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB430945EFEF0057213F /* gifalloc.c */; };
-		FE7B86240948E6A1001B952C /* SkImageDecoder_libgif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie_gif.cpp; path = ../../libs/graphics/images/SkMovie_gif.cpp; sourceTree = SOURCE_ROOT; };
-		00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../../libs/graphics/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libgif.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgif.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		FE08AB3D0945EFBE0057213F /* gif_lib_private.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = gif_lib_private.h; path = "../../extlibs/libgif-4.0/gif_lib_private.h"; sourceTree = SOURCE_ROOT; };
-		FE08AB3E0945EFBE0057213F /* gif_lib.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = gif_lib.h; path = "../../extlibs/libgif-4.0/gif_lib.h"; sourceTree = SOURCE_ROOT; };
-		FE08AB410945EFEF0057213F /* dgif_lib.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = dgif_lib.c; path = "../../extlibs/libgif-4.0/dgif_lib.c"; sourceTree = SOURCE_ROOT; };
-		FE08AB420945EFEF0057213F /* gif_err.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = gif_err.c; path = "../../extlibs/libgif-4.0/gif_err.c"; sourceTree = SOURCE_ROOT; };
-		FE08AB430945EFEF0057213F /* gifalloc.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = gifalloc.c; path = "../../extlibs/libgif-4.0/gifalloc.c"; sourceTree = SOURCE_ROOT; };
-		FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libgif.cpp; path = ../../libs/graphics/images/SkImageDecoder_libgif.cpp; sourceTree = SOURCE_ROOT; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* gif */ = {
-			isa = PBXGroup;
-			children = (
-				00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */,
-				FE08AB3C0945EF830057213F /* Include */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = gif;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */,
-				FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */,
-				FE08AB410945EFEF0057213F /* dgif_lib.c */,
-				FE08AB420945EFEF0057213F /* gif_err.c */,
-				FE08AB430945EFEF0057213F /* gifalloc.c */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libgif.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-		FE08AB3C0945EF830057213F /* Include */ = {
-			isa = PBXGroup;
-			children = (
-				FE08AB3D0945EFBE0057213F /* gif_lib_private.h */,
-				FE08AB3E0945EFBE0057213F /* gif_lib.h */,
-			);
-			name = Include;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FE08AB3F0945EFBE0057213F /* gif_lib_private.h in Headers */,
-				FE08AB400945EFBE0057213F /* gif_lib.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* gif */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = FE5F47EB094782A50095980F /* Build configuration list for PBXNativeTarget "gif" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = gif;
-			productName = gif;
-			productReference = D2AAC046055464E500DB518D /* libgif.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = FE5F47EF094782A50095980F /* Build configuration list for PBXProject "gif" */;
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* gif */;
-			projectDirPath = "";
-			targets = (
-				D2AAC045055464E500DB518D /* gif */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FE08AB440945EFEF0057213F /* dgif_lib.c in Sources */,
-				FE08AB450945EFEF0057213F /* gif_err.c in Sources */,
-				FE08AB460945EFEF0057213F /* gifalloc.c in Sources */,
-				FE7B86240948E6A1001B952C /* SkImageDecoder_libgif.cpp in Sources */,
-				008CFC4D0C04B77E00FB4126 /* SkMovie_gif.cpp in Sources */,
-				00B13BE30C0C6EFA0033F013 /* SkMovie.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		FE5F47EC094782A50095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					_LIB,
-					SK_FORCE_SCALARFIXED,
-				);
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = ../../include/graphics;
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = gif;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		FE5F47ED094782A50095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = gif;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		FE5F47F0094782A50095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg";
-			};
-			name = Debug;
-		};
-		FE5F47F1094782A50095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		FE5F47EB094782A50095980F /* Build configuration list for PBXNativeTarget "gif" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F47EC094782A50095980F /* Debug */,
-				FE5F47ED094782A50095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		FE5F47EF094782A50095980F /* Build configuration list for PBXProject "gif" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F47F0094782A50095980F /* Debug */,
-				FE5F47F1094782A50095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/giflib.xcodeproj/project.pbxproj b/xcode/giflib.xcodeproj/project.pbxproj
deleted file mode 100644
index 6c289a3..0000000
--- a/xcode/giflib.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,235 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7DCD40EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */; };
-		00B7DCD50EDCA06600F77EA2 /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */; };
-		00B7DCD60EDCA06600F77EA2 /* SkMovie_gif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */; };
-		00B7DCDA0EDCA07F00F77EA2 /* dgif_lib.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */; };
-		00B7DCDB0EDCA07F00F77EA2 /* gif_err.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD80EDCA07F00F77EA2 /* gif_err.c */; };
-		00B7DCDC0EDCA07F00F77EA2 /* gifalloc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libgif.cpp; path = ../libsgl/images/SkImageDecoder_libgif.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../libsgl/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie_gif.cpp; path = ../libsgl/images/SkMovie_gif.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dgif_lib.c; path = ../../giflib/dgif_lib.c; sourceTree = SOURCE_ROOT; };
-		00B7DCD80EDCA07F00F77EA2 /* gif_err.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gif_err.c; path = ../../giflib/gif_err.c; sourceTree = SOURCE_ROOT; };
-		00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gifalloc.c; path = ../../giflib/gifalloc.c; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libgiflib.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgiflib.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* giflib */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */,
-				00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */,
-				00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = giflib;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */,
-				00B7DCD80EDCA07F00F77EA2 /* gif_err.c */,
-				00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libgiflib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* giflib */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "giflib" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = giflib;
-			productName = giflib;
-			productReference = D2AAC046055464E500DB518D /* libgiflib.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "giflib" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* giflib */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				D2AAC045055464E500DB518D /* giflib */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DCD40EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp in Sources */,
-				00B7DCD50EDCA06600F77EA2 /* SkMovie.cpp in Sources */,
-				00B7DCD60EDCA06600F77EA2 /* SkMovie_gif.cpp in Sources */,
-				00B7DCDA0EDCA07F00F77EA2 /* dgif_lib.c in Sources */,
-				00B7DCDB0EDCA07F00F77EA2 /* gif_err.c in Sources */,
-				00B7DCDC0EDCA07F00F77EA2 /* gifalloc.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = giflib;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = giflib;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					HAVE_CONFIG_H,
-					SK_DEBUG,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					HAVE_CONFIG_H,
-					SK_RELEASE,
-				);
-				GCC_THREADSAFE_STATICS = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "giflib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "giflib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/graphics.xcodeproj/project.pbxproj b/xcode/graphics.xcodeproj/project.pbxproj
deleted file mode 100644
index e64247c..0000000
--- a/xcode/graphics.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,843 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		006B43940EF73CFC00F15BC4 /* SkString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43930EF73CFC00F15BC4 /* SkString.cpp */; };
-		006B43AE0EF7444A00F15BC4 /* SkUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */; };
-		00B7DF260EDCA56700F77EA2 /* SkPathHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */; };
-		00B7DF270EDCA56700F77EA2 /* SkPathHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */; };
-		00B7DF280EDCA56700F77EA2 /* SkPicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */; };
-		00B7DF290EDCA56700F77EA2 /* SkPictureFlat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */; };
-		00B7DF2A0EDCA56700F77EA2 /* SkPictureFlat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */; };
-		00B7DF2B0EDCA56700F77EA2 /* SkPicturePlayback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */; };
-		00B7DF2C0EDCA56700F77EA2 /* SkPicturePlayback.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */; };
-		00B7DF2D0EDCA56700F77EA2 /* SkPictureRecord.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */; };
-		00B7DF2E0EDCA56700F77EA2 /* SkPictureRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */; };
-		00B7DF4E0EDCA57800F77EA2 /* Sk1DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */; };
-		00B7DF4F0EDCA57800F77EA2 /* Sk2DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */; };
-		00B7DF500EDCA57800F77EA2 /* SkAvoidXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */; };
-		00B7DF510EDCA57800F77EA2 /* SkBlurDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */; };
-		00B7DF520EDCA57800F77EA2 /* SkBlurMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */; };
-		00B7DF530EDCA57800F77EA2 /* SkBlurMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */; };
-		00B7DF540EDCA57800F77EA2 /* SkBlurMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */; };
-		00B7DF550EDCA57800F77EA2 /* SkCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */; };
-		00B7DF560EDCA57800F77EA2 /* SkColorFilters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */; };
-		00B7DF570EDCA57800F77EA2 /* SkColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */; };
-		00B7DF580EDCA57800F77EA2 /* SkColorMatrixFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */; };
-		00B7DF590EDCA57800F77EA2 /* SkCornerPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */; };
-		00B7DF5A0EDCA57800F77EA2 /* SkCullPoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */; };
-		00B7DF5B0EDCA57800F77EA2 /* SkDashPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */; };
-		00B7DF5C0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */; };
-		00B7DF5D0EDCA57800F77EA2 /* SkEmbossMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */; };
-		00B7DF5E0EDCA57800F77EA2 /* SkEmbossMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */; };
-		00B7DF5F0EDCA57800F77EA2 /* SkEmbossMask_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */; };
-		00B7DF600EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */; };
-		00B7DF610EDCA57800F77EA2 /* SkGradientShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */; };
-		00B7DF620EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */; };
-		00B7DF630EDCA57800F77EA2 /* SkLayerDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */; };
-		00B7DF640EDCA57800F77EA2 /* SkLayerRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */; };
-		00B7DF650EDCA57800F77EA2 /* SkNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */; };
-		00B7DF660EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */; };
-		00B7DF670EDCA57800F77EA2 /* SkPixelXorXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */; };
-		00B7DF680EDCA57800F77EA2 /* SkProxyCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */; };
-		00B7DF690EDCA57800F77EA2 /* SkRadialGradient_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */; };
-		00B7DF6A0EDCA57800F77EA2 /* SkShaderExtras.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */; };
-		00B7DF6B0EDCA57800F77EA2 /* SkTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */; };
-		00B7DF6C0EDCA57800F77EA2 /* SkUnitMappers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */; };
-		00B7DF8E0EDCA59200F77EA2 /* SkFDStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */; };
-		00B7DF8F0EDCA59200F77EA2 /* SkFlipPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */; };
-		00B7DF900EDCA59200F77EA2 /* SkImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */; };
-		00B7DF990EDCA59200F77EA2 /* SkImageRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */; };
-		00B7DF9A0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */; };
-		00B7DF9B0EDCA59200F77EA2 /* SkImageRefPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */; };
-		00B7DF9D0EDCA59200F77EA2 /* SkMMapStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */; };
-		00B7DFA00EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */; };
-		00B7DFA10EDCA59200F77EA2 /* SkScaledBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */; };
-		00B7DFA20EDCA59200F77EA2 /* SkStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF870EDCA59200F77EA2 /* SkStream.cpp */; };
-		00B7DFAD0EDCA60D00F77EA2 /* SkBML_Verbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */; };
-		00B7DFAE0EDCA60D00F77EA2 /* SkBML_XMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */; };
-		00B7DFAF0EDCA60D00F77EA2 /* SkDOM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */; };
-		00B7DFB20EDCA60D00F77EA2 /* SkParse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */; };
-		00B7DFB30EDCA60D00F77EA2 /* SkParseColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */; };
-		00B7DFB40EDCA60D00F77EA2 /* SkXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */; };
-		00B7DFB60EDCA60D00F77EA2 /* SkXMLWriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */; };
-		00B7E0120EDCA64500F77EA2 /* SkAlphaRuns.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */; };
-		00B7E0130EDCA64500F77EA2 /* SkAntiRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */; };
-		00B7E0140EDCA64500F77EA2 /* SkAutoKern.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */; };
-		00B7E0150EDCA64500F77EA2 /* SkBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */; };
-		00B7E0160EDCA64500F77EA2 /* SkBitmap_scroll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */; };
-		00B7E0170EDCA64500F77EA2 /* SkBitmapProcShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */; };
-		00B7E0180EDCA64500F77EA2 /* SkBitmapProcShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */; };
-		00B7E0190EDCA64500F77EA2 /* SkBitmapProcState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */; };
-		00B7E01A0EDCA64500F77EA2 /* SkBitmapProcState.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */; };
-		00B7E01B0EDCA64500F77EA2 /* SkBitmapProcState_matrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */; };
-		00B7E01C0EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */; };
-		00B7E01D0EDCA64500F77EA2 /* SkBitmapProcState_sample.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */; };
-		00B7E01E0EDCA64500F77EA2 /* SkBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */; };
-		00B7E01F0EDCA64500F77EA2 /* SkBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */; };
-		00B7E0200EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */; };
-		00B7E0210EDCA64500F77EA2 /* SkBitmapShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */; };
-		00B7E0220EDCA64500F77EA2 /* SkBitmapShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */; };
-		00B7E0230EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */; };
-		00B7E0240EDCA64500F77EA2 /* SkBitmapShaderTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */; };
-		00B7E0250EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */; };
-		00B7E0260EDCA64500F77EA2 /* SkBlitRow.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */; };
-		00B7E0270EDCA64500F77EA2 /* SkBlitRow_D16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */; };
-		00B7E0280EDCA64500F77EA2 /* SkBlitRow_D4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */; };
-		00B7E0290EDCA64500F77EA2 /* SkBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */; };
-		00B7E02A0EDCA64500F77EA2 /* SkBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */; };
-		00B7E02B0EDCA64500F77EA2 /* SkBlitter_4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */; };
-		00B7E02C0EDCA64500F77EA2 /* SkBlitter_A1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */; };
-		00B7E02D0EDCA64500F77EA2 /* SkBlitter_A8.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */; };
-		00B7E02E0EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */; };
-		00B7E02F0EDCA64500F77EA2 /* SkBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */; };
-		00B7E0300EDCA64500F77EA2 /* SkBlitter_Sprite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */; };
-		00B7E0310EDCA64500F77EA2 /* SkCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */; };
-		00B7E0320EDCA64500F77EA2 /* SkColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */; };
-		00B7E0330EDCA64500F77EA2 /* SkColorFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */; };
-		00B7E0340EDCA64500F77EA2 /* SkColorTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */; };
-		00B7E0350EDCA64500F77EA2 /* SkCoreBlitters.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */; };
-		00B7E0360EDCA64500F77EA2 /* SkDeque.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */; };
-		00B7E0370EDCA64500F77EA2 /* SkDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */; };
-		00B7E0380EDCA64500F77EA2 /* SkDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */; };
-		00B7E0390EDCA64500F77EA2 /* SkDraw.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */; };
-		00B7E03A0EDCA64500F77EA2 /* SkDrawProcs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */; };
-		00B7E03B0EDCA64500F77EA2 /* SkEdge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */; };
-		00B7E03C0EDCA64500F77EA2 /* SkEdge.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE10EDCA64500F77EA2 /* SkEdge.h */; };
-		00B7E03D0EDCA64500F77EA2 /* SkFilterProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */; };
-		00B7E03E0EDCA64500F77EA2 /* SkFilterProc.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */; };
-		00B7E03F0EDCA64500F77EA2 /* SkFlattenable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */; };
-		00B7E0400EDCA64500F77EA2 /* SkFP.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE50EDCA64500F77EA2 /* SkFP.h */; };
-		00B7E0410EDCA64500F77EA2 /* SkGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */; };
-		00B7E0420EDCA64500F77EA2 /* SkGeometry.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */; };
-		00B7E0430EDCA64500F77EA2 /* SkGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */; };
-		00B7E0440EDCA64500F77EA2 /* SkGlyphCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */; };
-		00B7E0450EDCA64500F77EA2 /* SkGlyphCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */; };
-		00B7E0460EDCA64500F77EA2 /* SkGraphics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */; };
-		00B7E0470EDCA64500F77EA2 /* SkMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */; };
-		00B7E0480EDCA64500F77EA2 /* SkMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */; };
-		00B7E0490EDCA64500F77EA2 /* SkPackBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */; };
-		00B7E04A0EDCA64500F77EA2 /* SkPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */; };
-		00B7E04B0EDCA64500F77EA2 /* SkPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */; };
-		00B7E04C0EDCA64500F77EA2 /* SkPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */; };
-		00B7E04D0EDCA64500F77EA2 /* SkPathMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */; };
-		00B7E04E0EDCA64500F77EA2 /* SkPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */; };
-		00B7E04F0EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */; };
-		00B7E0500EDCA64500F77EA2 /* SkPtrRecorder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */; };
-		00B7E0510EDCA64500F77EA2 /* SkRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */; };
-		00B7E0520EDCA64500F77EA2 /* SkRefCnt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */; };
-		00B7E0530EDCA64500F77EA2 /* SkRegion_path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */; };
-		00B7E0540EDCA64500F77EA2 /* SkScalerContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */; };
-		00B7E0550EDCA64500F77EA2 /* SkScan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */; };
-		00B7E0560EDCA64500F77EA2 /* SkScan.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFFB0EDCA64500F77EA2 /* SkScan.h */; };
-		00B7E0570EDCA64500F77EA2 /* SkScan_Antihair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */; };
-		00B7E0580EDCA64500F77EA2 /* SkScan_AntiPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */; };
-		00B7E0590EDCA64500F77EA2 /* SkScan_Hairline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */; };
-		00B7E05A0EDCA64500F77EA2 /* SkScan_Path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */; };
-		00B7E05B0EDCA64500F77EA2 /* SkScanPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */; };
-		00B7E05C0EDCA64500F77EA2 /* SkShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0010EDCA64500F77EA2 /* SkShader.cpp */; };
-		00B7E05D0EDCA64500F77EA2 /* SkSpriteBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */; };
-		00B7E05E0EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */; };
-		00B7E05F0EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */; };
-		00B7E0600EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */; };
-		00B7E0620EDCA64500F77EA2 /* SkStroke.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */; };
-		00B7E0630EDCA64500F77EA2 /* SkStrokerPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */; };
-		00B7E0640EDCA64500F77EA2 /* SkStrokerPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */; };
-		00B7E0650EDCA64500F77EA2 /* SkTemplatesPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */; };
-		00B7E0660EDCA64500F77EA2 /* SkTSearch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */; };
-		00B7E0670EDCA64500F77EA2 /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E00C0EDCA64500F77EA2 /* SkTSort.h */; };
-		00B7E0680EDCA64500F77EA2 /* SkTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */; };
-		00B7E0690EDCA64500F77EA2 /* SkUnPreMultiply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */; };
-		00B7E06B0EDCA64500F77EA2 /* SkWriter32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */; };
-		00B7E06C0EDCA64500F77EA2 /* SkXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		006B43930EF73CFC00F15BC4 /* SkString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkString.cpp; path = ../libcorecg/SkString.cpp; sourceTree = SOURCE_ROOT; };
-		006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUtils.cpp; path = ../libcorecg/SkUtils.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathHeap.cpp; path = ../libsgl/picture/SkPathHeap.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathHeap.h; path = ../libsgl/picture/SkPathHeap.h; sourceTree = SOURCE_ROOT; };
-		00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicture.cpp; path = ../libsgl/picture/SkPicture.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureFlat.cpp; path = ../libsgl/picture/SkPictureFlat.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureFlat.h; path = ../libsgl/picture/SkPictureFlat.h; sourceTree = SOURCE_ROOT; };
-		00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicturePlayback.cpp; path = ../libsgl/picture/SkPicturePlayback.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPicturePlayback.h; path = ../libsgl/picture/SkPicturePlayback.h; sourceTree = SOURCE_ROOT; };
-		00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureRecord.cpp; path = ../libsgl/picture/SkPictureRecord.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureRecord.h; path = ../libsgl/picture/SkPictureRecord.h; sourceTree = SOURCE_ROOT; };
-		00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk1DPathEffect.cpp; path = ../libsgl/effects/Sk1DPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk2DPathEffect.cpp; path = ../libsgl/effects/Sk2DPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAvoidXfermode.cpp; path = ../libsgl/effects/SkAvoidXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurDrawLooper.cpp; path = ../libsgl/effects/SkBlurDrawLooper.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMask.cpp; path = ../libsgl/effects/SkBlurMask.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlurMask.h; path = ../libsgl/effects/SkBlurMask.h; sourceTree = SOURCE_ROOT; };
-		00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMaskFilter.cpp; path = ../libsgl/effects/SkBlurMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCamera.cpp; path = ../libsgl/effects/SkCamera.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilters.cpp; path = ../libsgl/effects/SkColorFilters.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrix.cpp; path = ../libsgl/effects/SkColorMatrix.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrixFilter.cpp; path = ../libsgl/effects/SkColorMatrixFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCornerPathEffect.cpp; path = ../libsgl/effects/SkCornerPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCullPoints.cpp; path = ../libsgl/effects/SkCullPoints.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDashPathEffect.cpp; path = ../libsgl/effects/SkDashPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDiscretePathEffect.cpp; path = ../libsgl/effects/SkDiscretePathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMask.cpp; path = ../libsgl/effects/SkEmbossMask.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask.h; path = ../libsgl/effects/SkEmbossMask.h; sourceTree = SOURCE_ROOT; };
-		00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask_Table.h; path = ../libsgl/effects/SkEmbossMask_Table.h; sourceTree = SOURCE_ROOT; };
-		00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMaskFilter.cpp; path = ../libsgl/effects/SkEmbossMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGradientShader.cpp; path = ../libsgl/effects/SkGradientShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkKernel33MaskFilter.cpp; path = ../libsgl/effects/SkKernel33MaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerDrawLooper.cpp; path = ../libsgl/effects/SkLayerDrawLooper.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerRasterizer.cpp; path = ../libsgl/effects/SkLayerRasterizer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkNinePatch.cpp; path = ../libsgl/effects/SkNinePatch.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintFlagsDrawFilter.cpp; path = ../libsgl/effects/SkPaintFlagsDrawFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelXorXfermode.cpp; path = ../libsgl/effects/SkPixelXorXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProxyCanvas.cpp; path = ../libsgl/effects/SkProxyCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRadialGradient_Table.h; path = ../libsgl/effects/SkRadialGradient_Table.h; sourceTree = SOURCE_ROOT; };
-		00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShaderExtras.cpp; path = ../libsgl/effects/SkShaderExtras.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTransparentShader.cpp; path = ../libsgl/effects/SkTransparentShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnitMappers.cpp; path = ../libsgl/effects/SkUnitMappers.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFDStream.cpp; path = ../libsgl/images/SkFDStream.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlipPixelRef.cpp; path = ../libsgl/images/SkFlipPixelRef.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder.cpp; path = ../libsgl/images/SkImageDecoder.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef.cpp; path = ../libsgl/images/SkImageRef.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef_GlobalPool.cpp; path = ../libsgl/images/SkImageRef_GlobalPool.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRefPool.cpp; path = ../libsgl/images/SkImageRefPool.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMMapStream.cpp; path = ../libsgl/images/SkMMapStream.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScaledBitmapSampler.cpp; path = ../libsgl/images/SkScaledBitmapSampler.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScaledBitmapSampler.h; path = ../libsgl/images/SkScaledBitmapSampler.h; sourceTree = SOURCE_ROOT; };
-		00B7DF870EDCA59200F77EA2 /* SkStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStream.cpp; path = ../libsgl/images/SkStream.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBML_Verbs.h; path = ../libsgl/xml/SkBML_Verbs.h; sourceTree = SOURCE_ROOT; };
-		00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBML_XMLParser.cpp; path = ../libsgl/xml/SkBML_XMLParser.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDOM.cpp; path = ../libsgl/xml/SkDOM.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParse.cpp; path = ../libsgl/xml/SkParse.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParseColor.cpp; path = ../libsgl/xml/SkParseColor.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser.cpp; path = ../libsgl/xml/SkXMLParser.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLWriter.cpp; path = ../libsgl/xml/SkXMLWriter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAlphaRuns.cpp; path = ../libsgl/sgl/SkAlphaRuns.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAntiRun.h; path = ../libsgl/sgl/SkAntiRun.h; sourceTree = SOURCE_ROOT; };
-		00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAutoKern.h; path = ../libsgl/sgl/SkAutoKern.h; sourceTree = SOURCE_ROOT; };
-		00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap.cpp; path = ../libsgl/sgl/SkBitmap.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_scroll.cpp; path = ../libsgl/sgl/SkBitmap_scroll.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcShader.cpp; path = ../libsgl/sgl/SkBitmapProcShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcShader.h; path = ../libsgl/sgl/SkBitmapProcShader.h; sourceTree = SOURCE_ROOT; };
-		00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState.cpp; path = ../libsgl/sgl/SkBitmapProcState.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState.h; path = ../libsgl/sgl/SkBitmapProcState.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_matrix.h; path = ../libsgl/sgl/SkBitmapProcState_matrix.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState_matrixProcs.cpp; path = ../libsgl/sgl/SkBitmapProcState_matrixProcs.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_sample.h; path = ../libsgl/sgl/SkBitmapProcState_sample.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapSampler.cpp; path = ../libsgl/sgl/SkBitmapSampler.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSampler.h; path = ../libsgl/sgl/SkBitmapSampler.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSamplerTemplate.h; path = ../libsgl/sgl/SkBitmapSamplerTemplate.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapShader.cpp; path = ../libsgl/sgl/SkBitmapShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader.h; path = ../libsgl/sgl/SkBitmapShader.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader16BilerpTemplate.h; path = ../libsgl/sgl/SkBitmapShader16BilerpTemplate.h; sourceTree = SOURCE_ROOT; };
-		00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShaderTemplate.h; path = ../libsgl/sgl/SkBitmapShaderTemplate.h; sourceTree = SOURCE_ROOT; };
-		00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitBWMaskTemplate.h; path = ../libsgl/sgl/SkBlitBWMaskTemplate.h; sourceTree = SOURCE_ROOT; };
-		00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitRow.h; path = ../libsgl/sgl/SkBlitRow.h; sourceTree = SOURCE_ROOT; };
-		00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D16.cpp; path = ../libsgl/sgl/SkBlitRow_D16.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D4444.cpp; path = ../libsgl/sgl/SkBlitRow_D4444.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter.cpp; path = ../libsgl/sgl/SkBlitter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitter.h; path = ../libsgl/sgl/SkBlitter.h; sourceTree = SOURCE_ROOT; };
-		00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_4444.cpp; path = ../libsgl/sgl/SkBlitter_4444.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A1.cpp; path = ../libsgl/sgl/SkBlitter_A1.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A8.cpp; path = ../libsgl/sgl/SkBlitter_A8.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_RGB16.cpp; path = ../libsgl/sgl/SkBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_Sprite.cpp; path = ../libsgl/sgl/SkBlitter_Sprite.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCanvas.cpp; path = ../libsgl/sgl/SkCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColor.cpp; path = ../libsgl/sgl/SkColor.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilter.cpp; path = ../libsgl/sgl/SkColorFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorTable.cpp; path = ../libsgl/sgl/SkColorTable.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCoreBlitters.h; path = ../libsgl/sgl/SkCoreBlitters.h; sourceTree = SOURCE_ROOT; };
-		00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDeque.cpp; path = ../libsgl/sgl/SkDeque.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDevice.cpp; path = ../libsgl/sgl/SkDevice.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDither.cpp; path = ../libsgl/sgl/SkDither.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw.cpp; path = ../libsgl/sgl/SkDraw.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawProcs.h; path = ../libsgl/sgl/SkDrawProcs.h; sourceTree = SOURCE_ROOT; };
-		00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEdge.cpp; path = ../libsgl/sgl/SkEdge.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFE10EDCA64500F77EA2 /* SkEdge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEdge.h; path = ../libsgl/sgl/SkEdge.h; sourceTree = SOURCE_ROOT; };
-		00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFilterProc.cpp; path = ../libsgl/sgl/SkFilterProc.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFilterProc.h; path = ../libsgl/sgl/SkFilterProc.h; sourceTree = SOURCE_ROOT; };
-		00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlattenable.cpp; path = ../libsgl/sgl/SkFlattenable.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFE50EDCA64500F77EA2 /* SkFP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFP.h; path = ../libsgl/sgl/SkFP.h; sourceTree = SOURCE_ROOT; };
-		00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGeometry.cpp; path = ../libsgl/sgl/SkGeometry.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; };
-		00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals.cpp; path = ../libsgl/sgl/SkGlobals.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlyphCache.cpp; path = ../libsgl/sgl/SkGlyphCache.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGlyphCache.h; path = ../libsgl/sgl/SkGlyphCache.h; sourceTree = SOURCE_ROOT; };
-		00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGraphics.cpp; path = ../libsgl/sgl/SkGraphics.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMask.cpp; path = ../libsgl/sgl/SkMask.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMaskFilter.cpp; path = ../libsgl/sgl/SkMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPackBits.cpp; path = ../libsgl/sgl/SkPackBits.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaint.cpp; path = ../libsgl/sgl/SkPaint.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPath.cpp; path = ../libsgl/sgl/SkPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathEffect.cpp; path = ../libsgl/sgl/SkPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathMeasure.cpp; path = ../libsgl/sgl/SkPathMeasure.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelRef.cpp; path = ../libsgl/sgl/SkPixelRef.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProcSpriteBlitter.cpp; path = ../libsgl/sgl/SkProcSpriteBlitter.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPtrRecorder.cpp; path = ../libsgl/sgl/SkPtrRecorder.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRasterizer.cpp; path = ../libsgl/sgl/SkRasterizer.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRefCnt.cpp; path = ../libsgl/sgl/SkRefCnt.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion_path.cpp; path = ../libsgl/sgl/SkRegion_path.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScalerContext.cpp; path = ../libsgl/sgl/SkScalerContext.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan.cpp; path = ../libsgl/sgl/SkScan.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFFB0EDCA64500F77EA2 /* SkScan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScan.h; path = ../libsgl/sgl/SkScan.h; sourceTree = SOURCE_ROOT; };
-		00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Antihair.cpp; path = ../libsgl/sgl/SkScan_Antihair.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_AntiPath.cpp; path = ../libsgl/sgl/SkScan_AntiPath.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Hairline.cpp; path = ../libsgl/sgl/SkScan_Hairline.cpp; sourceTree = SOURCE_ROOT; };
-		00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Path.cpp; path = ../libsgl/sgl/SkScan_Path.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScanPriv.h; path = ../libsgl/sgl/SkScanPriv.h; sourceTree = SOURCE_ROOT; };
-		00B7E0010EDCA64500F77EA2 /* SkShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShader.cpp; path = ../libsgl/sgl/SkShader.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitter.h; path = ../libsgl/sgl/SkSpriteBlitter.h; sourceTree = SOURCE_ROOT; };
-		00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkSpriteBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_RGB16.cpp; path = ../libsgl/sgl/SkSpriteBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitterTemplate.h; path = ../libsgl/sgl/SkSpriteBlitterTemplate.h; sourceTree = SOURCE_ROOT; };
-		00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStroke.cpp; path = ../libsgl/sgl/SkStroke.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStrokerPriv.cpp; path = ../libsgl/sgl/SkStrokerPriv.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkStrokerPriv.h; path = ../libsgl/sgl/SkStrokerPriv.h; sourceTree = SOURCE_ROOT; };
-		00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTemplatesPriv.h; path = ../libsgl/sgl/SkTemplatesPriv.h; sourceTree = SOURCE_ROOT; };
-		00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTSearch.cpp; path = ../libsgl/sgl/SkTSearch.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E00C0EDCA64500F77EA2 /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libsgl/sgl/SkTSort.h; sourceTree = SOURCE_ROOT; };
-		00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypeface.cpp; path = ../libsgl/sgl/SkTypeface.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnPreMultiply.cpp; path = ../libsgl/sgl/SkUnPreMultiply.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWriter32.cpp; path = ../libsgl/sgl/SkWriter32.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXfermode.cpp; path = ../libsgl/sgl/SkXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC06F0554671400DB518D /* libgraphics.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgraphics.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D2AAC06D0554671400DB518D /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		001142D10DCA3ED10070D0A3 /* picture */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */,
-				00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */,
-				00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */,
-				00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */,
-				00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */,
-				00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */,
-				00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */,
-				00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */,
-				00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */,
-			);
-			name = picture;
-			sourceTree = "<group>";
-		};
-		034768DDFF38A45A11DB9C8B /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC06F0554671400DB518D /* libgraphics.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		0867D691FE84028FC02AAC07 /* graphics */ = {
-			isa = PBXGroup;
-			children = (
-				001142D10DCA3ED10070D0A3 /* picture */,
-				FE5F48C8094798660095980F /* effects */,
-				FE5F48C5094797E90095980F /* images */,
-				FE5F48B2094797A80095980F /* xml */,
-				08FB77ACFE841707C02AAC07 /* sgl */,
-				034768DDFF38A45A11DB9C8B /* Products */,
-			);
-			name = graphics;
-			sourceTree = "<group>";
-		};
-		08FB77ACFE841707C02AAC07 /* sgl */ = {
-			isa = PBXGroup;
-			children = (
-				006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */,
-				006B43930EF73CFC00F15BC4 /* SkString.cpp */,
-				00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */,
-				00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */,
-				00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */,
-				00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */,
-				00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */,
-				00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */,
-				00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */,
-				00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */,
-				00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */,
-				00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */,
-				00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */,
-				00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */,
-				00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */,
-				00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */,
-				00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */,
-				00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */,
-				00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */,
-				00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */,
-				00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */,
-				00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */,
-				00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */,
-				00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */,
-				00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */,
-				00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */,
-				00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */,
-				00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */,
-				00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */,
-				00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */,
-				00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */,
-				00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */,
-				00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */,
-				00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */,
-				00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */,
-				00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */,
-				00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */,
-				00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */,
-				00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */,
-				00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */,
-				00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */,
-				00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */,
-				00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */,
-				00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */,
-				00B7DFE10EDCA64500F77EA2 /* SkEdge.h */,
-				00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */,
-				00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */,
-				00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */,
-				00B7DFE50EDCA64500F77EA2 /* SkFP.h */,
-				00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */,
-				00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */,
-				00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */,
-				00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */,
-				00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */,
-				00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */,
-				00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */,
-				00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */,
-				00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */,
-				00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */,
-				00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */,
-				00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */,
-				00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */,
-				00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */,
-				00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */,
-				00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */,
-				00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */,
-				00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */,
-				00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */,
-				00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */,
-				00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */,
-				00B7DFFB0EDCA64500F77EA2 /* SkScan.h */,
-				00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */,
-				00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */,
-				00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */,
-				00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */,
-				00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */,
-				00B7E0010EDCA64500F77EA2 /* SkShader.cpp */,
-				00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */,
-				00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */,
-				00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */,
-				00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */,
-				00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */,
-				00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */,
-				00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */,
-				00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */,
-				00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */,
-				00B7E00C0EDCA64500F77EA2 /* SkTSort.h */,
-				00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */,
-				00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */,
-				00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */,
-				00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */,
-			);
-			name = sgl;
-			sourceTree = "<group>";
-		};
-		FE5F48B2094797A80095980F /* xml */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */,
-				00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */,
-				00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */,
-				00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */,
-				00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */,
-				00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */,
-				00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */,
-			);
-			name = xml;
-			sourceTree = "<group>";
-		};
-		FE5F48C5094797E90095980F /* images */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */,
-				00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */,
-				00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */,
-				00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */,
-				00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */,
-				00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */,
-				00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */,
-				00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */,
-				00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */,
-				00B7DF870EDCA59200F77EA2 /* SkStream.cpp */,
-			);
-			name = images;
-			sourceTree = "<group>";
-		};
-		FE5F48C8094798660095980F /* effects */ = {
-			isa = PBXGroup;
-			children = (
-				00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */,
-				00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */,
-				00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */,
-				00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */,
-				00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */,
-				00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */,
-				00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */,
-				00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */,
-				00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */,
-				00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */,
-				00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */,
-				00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */,
-				00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */,
-				00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */,
-				00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */,
-				00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */,
-				00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */,
-				00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */,
-				00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */,
-				00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */,
-				00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */,
-				00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */,
-				00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */,
-				00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */,
-				00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */,
-				00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */,
-				00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */,
-				00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */,
-				00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */,
-				00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */,
-				00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */,
-			);
-			name = effects;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC06B0554671400DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DF270EDCA56700F77EA2 /* SkPathHeap.h in Headers */,
-				00B7DF2A0EDCA56700F77EA2 /* SkPictureFlat.h in Headers */,
-				00B7DF2C0EDCA56700F77EA2 /* SkPicturePlayback.h in Headers */,
-				00B7DF2E0EDCA56700F77EA2 /* SkPictureRecord.h in Headers */,
-				00B7DF530EDCA57800F77EA2 /* SkBlurMask.h in Headers */,
-				00B7DF5E0EDCA57800F77EA2 /* SkEmbossMask.h in Headers */,
-				00B7DF5F0EDCA57800F77EA2 /* SkEmbossMask_Table.h in Headers */,
-				00B7DF690EDCA57800F77EA2 /* SkRadialGradient_Table.h in Headers */,
-				00B7DFA10EDCA59200F77EA2 /* SkScaledBitmapSampler.h in Headers */,
-				00B7DFAD0EDCA60D00F77EA2 /* SkBML_Verbs.h in Headers */,
-				00B7E0130EDCA64500F77EA2 /* SkAntiRun.h in Headers */,
-				00B7E0140EDCA64500F77EA2 /* SkAutoKern.h in Headers */,
-				00B7E0180EDCA64500F77EA2 /* SkBitmapProcShader.h in Headers */,
-				00B7E01A0EDCA64500F77EA2 /* SkBitmapProcState.h in Headers */,
-				00B7E01B0EDCA64500F77EA2 /* SkBitmapProcState_matrix.h in Headers */,
-				00B7E01D0EDCA64500F77EA2 /* SkBitmapProcState_sample.h in Headers */,
-				00B7E01F0EDCA64500F77EA2 /* SkBitmapSampler.h in Headers */,
-				00B7E0200EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h in Headers */,
-				00B7E0220EDCA64500F77EA2 /* SkBitmapShader.h in Headers */,
-				00B7E0230EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h in Headers */,
-				00B7E0240EDCA64500F77EA2 /* SkBitmapShaderTemplate.h in Headers */,
-				00B7E0250EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h in Headers */,
-				00B7E0260EDCA64500F77EA2 /* SkBlitRow.h in Headers */,
-				00B7E02A0EDCA64500F77EA2 /* SkBlitter.h in Headers */,
-				00B7E0350EDCA64500F77EA2 /* SkCoreBlitters.h in Headers */,
-				00B7E03A0EDCA64500F77EA2 /* SkDrawProcs.h in Headers */,
-				00B7E03C0EDCA64500F77EA2 /* SkEdge.h in Headers */,
-				00B7E03E0EDCA64500F77EA2 /* SkFilterProc.h in Headers */,
-				00B7E0400EDCA64500F77EA2 /* SkFP.h in Headers */,
-				00B7E0420EDCA64500F77EA2 /* SkGeometry.h in Headers */,
-				00B7E0450EDCA64500F77EA2 /* SkGlyphCache.h in Headers */,
-				00B7E0560EDCA64500F77EA2 /* SkScan.h in Headers */,
-				00B7E05B0EDCA64500F77EA2 /* SkScanPriv.h in Headers */,
-				00B7E05D0EDCA64500F77EA2 /* SkSpriteBlitter.h in Headers */,
-				00B7E0600EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h in Headers */,
-				00B7E0640EDCA64500F77EA2 /* SkStrokerPriv.h in Headers */,
-				00B7E0650EDCA64500F77EA2 /* SkTemplatesPriv.h in Headers */,
-				00B7E0670EDCA64500F77EA2 /* SkTSort.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC06E0554671400DB518D /* graphics */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB920108733DBB0010E9CD /* Build configuration list for PBXNativeTarget "graphics" */;
-			buildPhases = (
-				D2AAC06B0554671400DB518D /* Headers */,
-				D2AAC06C0554671400DB518D /* Sources */,
-				D2AAC06D0554671400DB518D /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = graphics;
-			productName = graphics;
-			productReference = D2AAC06F0554671400DB518D /* libgraphics.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		0867D690FE84028FC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB920508733DBB0010E9CD /* Build configuration list for PBXProject "graphics" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 0867D691FE84028FC02AAC07 /* graphics */;
-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC06E0554671400DB518D /* graphics */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC06C0554671400DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7DF260EDCA56700F77EA2 /* SkPathHeap.cpp in Sources */,
-				00B7DF280EDCA56700F77EA2 /* SkPicture.cpp in Sources */,
-				00B7DF290EDCA56700F77EA2 /* SkPictureFlat.cpp in Sources */,
-				00B7DF2B0EDCA56700F77EA2 /* SkPicturePlayback.cpp in Sources */,
-				00B7DF2D0EDCA56700F77EA2 /* SkPictureRecord.cpp in Sources */,
-				00B7DF4E0EDCA57800F77EA2 /* Sk1DPathEffect.cpp in Sources */,
-				00B7DF4F0EDCA57800F77EA2 /* Sk2DPathEffect.cpp in Sources */,
-				00B7DF500EDCA57800F77EA2 /* SkAvoidXfermode.cpp in Sources */,
-				00B7DF510EDCA57800F77EA2 /* SkBlurDrawLooper.cpp in Sources */,
-				00B7DF520EDCA57800F77EA2 /* SkBlurMask.cpp in Sources */,
-				00B7DF540EDCA57800F77EA2 /* SkBlurMaskFilter.cpp in Sources */,
-				00B7DF550EDCA57800F77EA2 /* SkCamera.cpp in Sources */,
-				00B7DF560EDCA57800F77EA2 /* SkColorFilters.cpp in Sources */,
-				00B7DF570EDCA57800F77EA2 /* SkColorMatrix.cpp in Sources */,
-				00B7DF580EDCA57800F77EA2 /* SkColorMatrixFilter.cpp in Sources */,
-				00B7DF590EDCA57800F77EA2 /* SkCornerPathEffect.cpp in Sources */,
-				00B7DF5A0EDCA57800F77EA2 /* SkCullPoints.cpp in Sources */,
-				00B7DF5B0EDCA57800F77EA2 /* SkDashPathEffect.cpp in Sources */,
-				00B7DF5C0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp in Sources */,
-				00B7DF5D0EDCA57800F77EA2 /* SkEmbossMask.cpp in Sources */,
-				00B7DF600EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp in Sources */,
-				00B7DF610EDCA57800F77EA2 /* SkGradientShader.cpp in Sources */,
-				00B7DF620EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp in Sources */,
-				00B7DF630EDCA57800F77EA2 /* SkLayerDrawLooper.cpp in Sources */,
-				00B7DF640EDCA57800F77EA2 /* SkLayerRasterizer.cpp in Sources */,
-				00B7DF650EDCA57800F77EA2 /* SkNinePatch.cpp in Sources */,
-				00B7DF660EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp in Sources */,
-				00B7DF670EDCA57800F77EA2 /* SkPixelXorXfermode.cpp in Sources */,
-				00B7DF680EDCA57800F77EA2 /* SkProxyCanvas.cpp in Sources */,
-				00B7DF6A0EDCA57800F77EA2 /* SkShaderExtras.cpp in Sources */,
-				00B7DF6B0EDCA57800F77EA2 /* SkTransparentShader.cpp in Sources */,
-				00B7DF6C0EDCA57800F77EA2 /* SkUnitMappers.cpp in Sources */,
-				00B7DF8E0EDCA59200F77EA2 /* SkFDStream.cpp in Sources */,
-				00B7DF8F0EDCA59200F77EA2 /* SkFlipPixelRef.cpp in Sources */,
-				00B7DF900EDCA59200F77EA2 /* SkImageDecoder.cpp in Sources */,
-				00B7DF990EDCA59200F77EA2 /* SkImageRef.cpp in Sources */,
-				00B7DF9A0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp in Sources */,
-				00B7DF9B0EDCA59200F77EA2 /* SkImageRefPool.cpp in Sources */,
-				00B7DF9D0EDCA59200F77EA2 /* SkMMapStream.cpp in Sources */,
-				00B7DFA00EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp in Sources */,
-				00B7DFA20EDCA59200F77EA2 /* SkStream.cpp in Sources */,
-				00B7DFAE0EDCA60D00F77EA2 /* SkBML_XMLParser.cpp in Sources */,
-				00B7DFAF0EDCA60D00F77EA2 /* SkDOM.cpp in Sources */,
-				00B7DFB20EDCA60D00F77EA2 /* SkParse.cpp in Sources */,
-				00B7DFB30EDCA60D00F77EA2 /* SkParseColor.cpp in Sources */,
-				00B7DFB40EDCA60D00F77EA2 /* SkXMLParser.cpp in Sources */,
-				00B7DFB60EDCA60D00F77EA2 /* SkXMLWriter.cpp in Sources */,
-				00B7E0120EDCA64500F77EA2 /* SkAlphaRuns.cpp in Sources */,
-				00B7E0150EDCA64500F77EA2 /* SkBitmap.cpp in Sources */,
-				00B7E0160EDCA64500F77EA2 /* SkBitmap_scroll.cpp in Sources */,
-				00B7E0170EDCA64500F77EA2 /* SkBitmapProcShader.cpp in Sources */,
-				00B7E0190EDCA64500F77EA2 /* SkBitmapProcState.cpp in Sources */,
-				00B7E01C0EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp in Sources */,
-				00B7E01E0EDCA64500F77EA2 /* SkBitmapSampler.cpp in Sources */,
-				00B7E0210EDCA64500F77EA2 /* SkBitmapShader.cpp in Sources */,
-				00B7E0270EDCA64500F77EA2 /* SkBlitRow_D16.cpp in Sources */,
-				00B7E0280EDCA64500F77EA2 /* SkBlitRow_D4444.cpp in Sources */,
-				00B7E0290EDCA64500F77EA2 /* SkBlitter.cpp in Sources */,
-				00B7E02B0EDCA64500F77EA2 /* SkBlitter_4444.cpp in Sources */,
-				00B7E02C0EDCA64500F77EA2 /* SkBlitter_A1.cpp in Sources */,
-				00B7E02D0EDCA64500F77EA2 /* SkBlitter_A8.cpp in Sources */,
-				00B7E02E0EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp in Sources */,
-				00B7E02F0EDCA64500F77EA2 /* SkBlitter_RGB16.cpp in Sources */,
-				00B7E0300EDCA64500F77EA2 /* SkBlitter_Sprite.cpp in Sources */,
-				00B7E0310EDCA64500F77EA2 /* SkCanvas.cpp in Sources */,
-				00B7E0320EDCA64500F77EA2 /* SkColor.cpp in Sources */,
-				00B7E0330EDCA64500F77EA2 /* SkColorFilter.cpp in Sources */,
-				00B7E0340EDCA64500F77EA2 /* SkColorTable.cpp in Sources */,
-				00B7E0360EDCA64500F77EA2 /* SkDeque.cpp in Sources */,
-				00B7E0370EDCA64500F77EA2 /* SkDevice.cpp in Sources */,
-				00B7E0380EDCA64500F77EA2 /* SkDither.cpp in Sources */,
-				00B7E0390EDCA64500F77EA2 /* SkDraw.cpp in Sources */,
-				00B7E03B0EDCA64500F77EA2 /* SkEdge.cpp in Sources */,
-				00B7E03D0EDCA64500F77EA2 /* SkFilterProc.cpp in Sources */,
-				00B7E03F0EDCA64500F77EA2 /* SkFlattenable.cpp in Sources */,
-				00B7E0410EDCA64500F77EA2 /* SkGeometry.cpp in Sources */,
-				00B7E0430EDCA64500F77EA2 /* SkGlobals.cpp in Sources */,
-				00B7E0440EDCA64500F77EA2 /* SkGlyphCache.cpp in Sources */,
-				00B7E0460EDCA64500F77EA2 /* SkGraphics.cpp in Sources */,
-				00B7E0470EDCA64500F77EA2 /* SkMask.cpp in Sources */,
-				00B7E0480EDCA64500F77EA2 /* SkMaskFilter.cpp in Sources */,
-				00B7E0490EDCA64500F77EA2 /* SkPackBits.cpp in Sources */,
-				00B7E04A0EDCA64500F77EA2 /* SkPaint.cpp in Sources */,
-				00B7E04B0EDCA64500F77EA2 /* SkPath.cpp in Sources */,
-				00B7E04C0EDCA64500F77EA2 /* SkPathEffect.cpp in Sources */,
-				00B7E04D0EDCA64500F77EA2 /* SkPathMeasure.cpp in Sources */,
-				00B7E04E0EDCA64500F77EA2 /* SkPixelRef.cpp in Sources */,
-				00B7E04F0EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp in Sources */,
-				00B7E0500EDCA64500F77EA2 /* SkPtrRecorder.cpp in Sources */,
-				00B7E0510EDCA64500F77EA2 /* SkRasterizer.cpp in Sources */,
-				00B7E0520EDCA64500F77EA2 /* SkRefCnt.cpp in Sources */,
-				00B7E0530EDCA64500F77EA2 /* SkRegion_path.cpp in Sources */,
-				00B7E0540EDCA64500F77EA2 /* SkScalerContext.cpp in Sources */,
-				00B7E0550EDCA64500F77EA2 /* SkScan.cpp in Sources */,
-				00B7E0570EDCA64500F77EA2 /* SkScan_Antihair.cpp in Sources */,
-				00B7E0580EDCA64500F77EA2 /* SkScan_AntiPath.cpp in Sources */,
-				00B7E0590EDCA64500F77EA2 /* SkScan_Hairline.cpp in Sources */,
-				00B7E05A0EDCA64500F77EA2 /* SkScan_Path.cpp in Sources */,
-				00B7E05C0EDCA64500F77EA2 /* SkShader.cpp in Sources */,
-				00B7E05E0EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp in Sources */,
-				00B7E05F0EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp in Sources */,
-				00B7E0620EDCA64500F77EA2 /* SkStroke.cpp in Sources */,
-				00B7E0630EDCA64500F77EA2 /* SkStrokerPriv.cpp in Sources */,
-				00B7E0660EDCA64500F77EA2 /* SkTSearch.cpp in Sources */,
-				00B7E0680EDCA64500F77EA2 /* SkTypeface.cpp in Sources */,
-				00B7E0690EDCA64500F77EA2 /* SkUnPreMultiply.cpp in Sources */,
-				00B7E06B0EDCA64500F77EA2 /* SkWriter32.cpp in Sources */,
-				00B7E06C0EDCA64500F77EA2 /* SkXfermode.cpp in Sources */,
-				006B43940EF73CFC00F15BC4 /* SkString.cpp in Sources */,
-				006B43AE0EF7444A00F15BC4 /* SkUtils.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB920208733DBB0010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = graphics_Prefix.pch;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = graphics;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB920308733DBB0010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = graphics_Prefix.pch;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = graphics;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB920608733DBB0010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_DEBUGGING_SYMBOLS = full;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PFE_FILE_C_DIALECTS = "";
-				GCC_PREPROCESSOR_DEFINITIONS = SK_DEBUG;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/** ../libcorecg";
-			};
-			name = Debug;
-		};
-		1DEB920708733DBB0010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_DEBUGGING_SYMBOLS = full;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PFE_FILE_C_DIALECTS = "";
-				GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE;
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/** ../libcorecg";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB920108733DBB0010E9CD /* Build configuration list for PBXNativeTarget "graphics" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB920208733DBB0010E9CD /* Debug */,
-				1DEB920308733DBB0010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB920508733DBB0010E9CD /* Build configuration list for PBXProject "graphics" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB920608733DBB0010E9CD /* Debug */,
-				1DEB920708733DBB0010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
-}
diff --git a/xcode/hostapp/test.cpp b/xcode/hostapp/test.cpp
deleted file mode 100644
index 4f66a82..0000000
--- a/xcode/hostapp/test.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include <Carbon/Carbon.h>
-#include "SkCGUtils.h"
-#include "SkCanvas.h"
-#include "SkPaint.h"
-
-extern "C" void SkiaDraw(CGContextRef cg, CGRect bounds);
-
-static void sampleDraw(SkCanvas* canvas) {
-    canvas->drawColor(0xFF0000FF);
-    
-    SkPaint paint;
-    paint.setAntiAlias(true);
-
-    canvas->drawCircle(SkIntToScalar(100), SkIntToScalar(100),
-                       SkIntToScalar(90), paint);
-    
-    const char text[] = "fry42";
-    const size_t len = strlen(text);
-
-    paint.setColor(SK_ColorWHITE);
-    paint.setTextSize(SkIntToScalar(50));
-    canvas->drawText(text, len, SkIntToScalar(100), SkIntToScalar(50), paint);
-    paint.setTextAlign(SkPaint::kCenter_Align);
-    canvas->drawText(text, len, SkIntToScalar(100), SkIntToScalar(100), paint);
-    paint.setTextAlign(SkPaint::kRight_Align);
-    canvas->drawText(text, len, SkIntToScalar(100), SkIntToScalar(150), paint);
-}
-
-static CGImageRef gImage;
-
-void SkiaDraw(CGContextRef cg, CGRect bounds) {
-    if (NULL == gImage) {
-        SkBitmap bitmap;
-        bitmap.setConfig(SkBitmap::kARGB_8888_Config, 640, 480);
-        bitmap.allocPixels();
-        
-        SkCanvas canvas(bitmap);
-        sampleDraw(&canvas);
-        
-        gImage = SkCreateCGImageRef(bitmap);
-    }
-
-	float components[] = { 1, 1, 1, 1 };
-
-	CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
-	CGColorRef color = CGColorCreate(colorspace, components);
-
-    CGContextSetFillColorWithColor(cg, color);
-    CGColorRelease(color);
-	CGColorSpaceRelease(colorspace);
-
-    CGContextFillRect(cg, bounds);
-
-    CGRect r = CGRectMake(0, 0, 640, 480);
-    
-    CGContextSaveGState(cg);
-    CGContextTranslateCTM(cg, 0, r.size.height);
-    CGContextScaleCTM(cg, 1, -1);
-    
-    CGContextDrawImage(cg, r, gImage);
-    
-    CGContextRestoreGState(cg);
-}
-
-
diff --git a/xcode/jpeg.xcodeproj/project.pbxproj b/xcode/jpeg.xcodeproj/project.pbxproj
deleted file mode 100644
index ee1c4b3..0000000
--- a/xcode/jpeg.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,451 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E07F0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */; };
-		00B7E0D60EDCA78B00F77EA2 /* jcapimin.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0890EDCA78B00F77EA2 /* jcapimin.c */; };
-		00B7E0D70EDCA78B00F77EA2 /* jcapistd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */; };
-		00B7E0D80EDCA78B00F77EA2 /* jccoefct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */; };
-		00B7E0D90EDCA78B00F77EA2 /* jccolor.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08C0EDCA78B00F77EA2 /* jccolor.c */; };
-		00B7E0DA0EDCA78B00F77EA2 /* jcdctmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */; };
-		00B7E0DB0EDCA78B00F77EA2 /* jchuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08E0EDCA78B00F77EA2 /* jchuff.c */; };
-		00B7E0DD0EDCA78B00F77EA2 /* jcinit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0900EDCA78B00F77EA2 /* jcinit.c */; };
-		00B7E0DE0EDCA78B00F77EA2 /* jcmainct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0910EDCA78B00F77EA2 /* jcmainct.c */; };
-		00B7E0DF0EDCA78B00F77EA2 /* jcmarker.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0920EDCA78B00F77EA2 /* jcmarker.c */; };
-		00B7E0E00EDCA78B00F77EA2 /* jcmaster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0930EDCA78B00F77EA2 /* jcmaster.c */; };
-		00B7E0E10EDCA78B00F77EA2 /* jcomapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0940EDCA78B00F77EA2 /* jcomapi.c */; };
-		00B7E0E30EDCA78B00F77EA2 /* jcparam.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A20EDCA78B00F77EA2 /* jcparam.c */; };
-		00B7E0E40EDCA78B00F77EA2 /* jcphuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */; };
-		00B7E0E50EDCA78B00F77EA2 /* jcprepct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */; };
-		00B7E0E60EDCA78B00F77EA2 /* jcsample.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A50EDCA78B00F77EA2 /* jcsample.c */; };
-		00B7E0E70EDCA78B00F77EA2 /* jctrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A60EDCA78B00F77EA2 /* jctrans.c */; };
-		00B7E0E80EDCA78B00F77EA2 /* jdapimin.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */; };
-		00B7E0E90EDCA78B00F77EA2 /* jdapistd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */; };
-		00B7E0EA0EDCA78B00F77EA2 /* jdatadst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */; };
-		00B7E0EB0EDCA78B00F77EA2 /* jdatasrc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */; };
-		00B7E0EC0EDCA78B00F77EA2 /* jdcoefct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */; };
-		00B7E0ED0EDCA78B00F77EA2 /* jdcolor.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */; };
-		00B7E0EF0EDCA78B00F77EA2 /* jddctmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */; };
-		00B7E0F00EDCA78B00F77EA2 /* jdhuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */; };
-		00B7E0F20EDCA78B00F77EA2 /* jdinput.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B10EDCA78B00F77EA2 /* jdinput.c */; };
-		00B7E0F30EDCA78B00F77EA2 /* jdmainct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */; };
-		00B7E0F40EDCA78B00F77EA2 /* jdmarker.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */; };
-		00B7E0F50EDCA78B00F77EA2 /* jdmaster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */; };
-		00B7E0F60EDCA78B00F77EA2 /* jdmerge.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */; };
-		00B7E0F70EDCA78B00F77EA2 /* jdphuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */; };
-		00B7E0F80EDCA78B00F77EA2 /* jdpostct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */; };
-		00B7E0F90EDCA78B00F77EA2 /* jdsample.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B80EDCA78B00F77EA2 /* jdsample.c */; };
-		00B7E0FA0EDCA78B00F77EA2 /* jdtrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */; };
-		00B7E0FB0EDCA78B00F77EA2 /* jerror.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BA0EDCA78B00F77EA2 /* jerror.c */; };
-		00B7E0FD0EDCA78B00F77EA2 /* jfdctflt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */; };
-		00B7E0FE0EDCA78B00F77EA2 /* jfdctfst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */; };
-		00B7E0FF0EDCA78B00F77EA2 /* jfdctint.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */; };
-		00B7E1000EDCA78B00F77EA2 /* jidctflt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */; };
-		00B7E1010EDCA78B00F77EA2 /* jidctfst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */; };
-		00B7E1030EDCA78B00F77EA2 /* jidctint.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C20EDCA78B00F77EA2 /* jidctint.c */; };
-		00B7E1040EDCA78B00F77EA2 /* jidctred.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C30EDCA78B00F77EA2 /* jidctred.c */; };
-		00B7E1070EDCA78B00F77EA2 /* jmemansi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */; };
-		00B7E10B0EDCA78B00F77EA2 /* jmemmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */; };
-		00B7E1130EDCA78B00F77EA2 /* jquant1.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D30EDCA78B00F77EA2 /* jquant1.c */; };
-		00B7E1140EDCA78B00F77EA2 /* jquant2.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D40EDCA78B00F77EA2 /* jquant2.c */; };
-		00B7E1150EDCA78B00F77EA2 /* jutils.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D50EDCA78B00F77EA2 /* jutils.c */; };
-		00B7E11C0EDCA84F00F77EA2 /* jchuff.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1180EDCA84F00F77EA2 /* jchuff.h */; };
-		00B7E11D0EDCA84F00F77EA2 /* jconfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1190EDCA84F00F77EA2 /* jconfig.h */; };
-		00B7E11E0EDCA84F00F77EA2 /* jerror.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E11A0EDCA84F00F77EA2 /* jerror.h */; };
-		00B7E11F0EDCA84F00F77EA2 /* jpeglib.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libjpeg.cpp; path = ../libsgl/images/SkImageDecoder_libjpeg.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E0890EDCA78B00F77EA2 /* jcapimin.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcapimin.c; path = ../../jpeg/jcapimin.c; sourceTree = SOURCE_ROOT; };
-		00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcapistd.c; path = ../../jpeg/jcapistd.c; sourceTree = SOURCE_ROOT; };
-		00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jccoefct.c; path = ../../jpeg/jccoefct.c; sourceTree = SOURCE_ROOT; };
-		00B7E08C0EDCA78B00F77EA2 /* jccolor.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jccolor.c; path = ../../jpeg/jccolor.c; sourceTree = SOURCE_ROOT; };
-		00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcdctmgr.c; path = ../../jpeg/jcdctmgr.c; sourceTree = SOURCE_ROOT; };
-		00B7E08E0EDCA78B00F77EA2 /* jchuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jchuff.c; path = ../../jpeg/jchuff.c; sourceTree = SOURCE_ROOT; };
-		00B7E0900EDCA78B00F77EA2 /* jcinit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcinit.c; path = ../../jpeg/jcinit.c; sourceTree = SOURCE_ROOT; };
-		00B7E0910EDCA78B00F77EA2 /* jcmainct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmainct.c; path = ../../jpeg/jcmainct.c; sourceTree = SOURCE_ROOT; };
-		00B7E0920EDCA78B00F77EA2 /* jcmarker.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmarker.c; path = ../../jpeg/jcmarker.c; sourceTree = SOURCE_ROOT; };
-		00B7E0930EDCA78B00F77EA2 /* jcmaster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmaster.c; path = ../../jpeg/jcmaster.c; sourceTree = SOURCE_ROOT; };
-		00B7E0940EDCA78B00F77EA2 /* jcomapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcomapi.c; path = ../../jpeg/jcomapi.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A20EDCA78B00F77EA2 /* jcparam.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcparam.c; path = ../../jpeg/jcparam.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcphuff.c; path = ../../jpeg/jcphuff.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcprepct.c; path = ../../jpeg/jcprepct.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A50EDCA78B00F77EA2 /* jcsample.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcsample.c; path = ../../jpeg/jcsample.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A60EDCA78B00F77EA2 /* jctrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jctrans.c; path = ../../jpeg/jctrans.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdapimin.c; path = ../../jpeg/jdapimin.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdapistd.c; path = ../../jpeg/jdapistd.c; sourceTree = SOURCE_ROOT; };
-		00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdatadst.c; path = ../../jpeg/jdatadst.c; sourceTree = SOURCE_ROOT; };
-		00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdatasrc.c; path = ../../jpeg/jdatasrc.c; sourceTree = SOURCE_ROOT; };
-		00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdcoefct.c; path = ../../jpeg/jdcoefct.c; sourceTree = SOURCE_ROOT; };
-		00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdcolor.c; path = ../../jpeg/jdcolor.c; sourceTree = SOURCE_ROOT; };
-		00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jddctmgr.c; path = ../../jpeg/jddctmgr.c; sourceTree = SOURCE_ROOT; };
-		00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdhuff.c; path = ../../jpeg/jdhuff.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B10EDCA78B00F77EA2 /* jdinput.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdinput.c; path = ../../jpeg/jdinput.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmainct.c; path = ../../jpeg/jdmainct.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmarker.c; path = ../../jpeg/jdmarker.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmaster.c; path = ../../jpeg/jdmaster.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmerge.c; path = ../../jpeg/jdmerge.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdphuff.c; path = ../../jpeg/jdphuff.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdpostct.c; path = ../../jpeg/jdpostct.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B80EDCA78B00F77EA2 /* jdsample.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdsample.c; path = ../../jpeg/jdsample.c; sourceTree = SOURCE_ROOT; };
-		00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdtrans.c; path = ../../jpeg/jdtrans.c; sourceTree = SOURCE_ROOT; };
-		00B7E0BA0EDCA78B00F77EA2 /* jerror.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jerror.c; path = ../../jpeg/jerror.c; sourceTree = SOURCE_ROOT; };
-		00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctflt.c; path = ../../jpeg/jfdctflt.c; sourceTree = SOURCE_ROOT; };
-		00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctfst.c; path = ../../jpeg/jfdctfst.c; sourceTree = SOURCE_ROOT; };
-		00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctint.c; path = ../../jpeg/jfdctint.c; sourceTree = SOURCE_ROOT; };
-		00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctflt.c; path = ../../jpeg/jidctflt.c; sourceTree = SOURCE_ROOT; };
-		00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctfst.c; path = ../../jpeg/jidctfst.c; sourceTree = SOURCE_ROOT; };
-		00B7E0C20EDCA78B00F77EA2 /* jidctint.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctint.c; path = ../../jpeg/jidctint.c; sourceTree = SOURCE_ROOT; };
-		00B7E0C30EDCA78B00F77EA2 /* jidctred.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctred.c; path = ../../jpeg/jidctred.c; sourceTree = SOURCE_ROOT; };
-		00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jmemansi.c; path = ../../jpeg/jmemansi.c; sourceTree = SOURCE_ROOT; };
-		00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jmemmgr.c; path = ../../jpeg/jmemmgr.c; sourceTree = SOURCE_ROOT; };
-		00B7E0D30EDCA78B00F77EA2 /* jquant1.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jquant1.c; path = ../../jpeg/jquant1.c; sourceTree = SOURCE_ROOT; };
-		00B7E0D40EDCA78B00F77EA2 /* jquant2.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jquant2.c; path = ../../jpeg/jquant2.c; sourceTree = SOURCE_ROOT; };
-		00B7E0D50EDCA78B00F77EA2 /* jutils.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jutils.c; path = ../../jpeg/jutils.c; sourceTree = SOURCE_ROOT; };
-		00B7E1180EDCA84F00F77EA2 /* jchuff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jchuff.h; path = ../../jpeg/jchuff.h; sourceTree = SOURCE_ROOT; };
-		00B7E1190EDCA84F00F77EA2 /* jconfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jconfig.h; path = ../../jpeg/jconfig.h; sourceTree = SOURCE_ROOT; };
-		00B7E11A0EDCA84F00F77EA2 /* jerror.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jerror.h; path = ../../jpeg/jerror.h; sourceTree = SOURCE_ROOT; };
-		00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jpeglib.h; path = ../../jpeg/jpeglib.h; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libjpeg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libjpeg.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* jpeg */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */,
-				FE08AA3E0945D5620057213F /* Include */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = jpeg;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E0890EDCA78B00F77EA2 /* jcapimin.c */,
-				00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */,
-				00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */,
-				00B7E08C0EDCA78B00F77EA2 /* jccolor.c */,
-				00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */,
-				00B7E08E0EDCA78B00F77EA2 /* jchuff.c */,
-				00B7E0900EDCA78B00F77EA2 /* jcinit.c */,
-				00B7E0910EDCA78B00F77EA2 /* jcmainct.c */,
-				00B7E0920EDCA78B00F77EA2 /* jcmarker.c */,
-				00B7E0930EDCA78B00F77EA2 /* jcmaster.c */,
-				00B7E0940EDCA78B00F77EA2 /* jcomapi.c */,
-				00B7E0A20EDCA78B00F77EA2 /* jcparam.c */,
-				00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */,
-				00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */,
-				00B7E0A50EDCA78B00F77EA2 /* jcsample.c */,
-				00B7E0A60EDCA78B00F77EA2 /* jctrans.c */,
-				00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */,
-				00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */,
-				00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */,
-				00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */,
-				00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */,
-				00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */,
-				00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */,
-				00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */,
-				00B7E0B10EDCA78B00F77EA2 /* jdinput.c */,
-				00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */,
-				00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */,
-				00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */,
-				00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */,
-				00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */,
-				00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */,
-				00B7E0B80EDCA78B00F77EA2 /* jdsample.c */,
-				00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */,
-				00B7E0BA0EDCA78B00F77EA2 /* jerror.c */,
-				00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */,
-				00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */,
-				00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */,
-				00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */,
-				00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */,
-				00B7E0C20EDCA78B00F77EA2 /* jidctint.c */,
-				00B7E0C30EDCA78B00F77EA2 /* jidctred.c */,
-				00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */,
-				00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */,
-				00B7E0D30EDCA78B00F77EA2 /* jquant1.c */,
-				00B7E0D40EDCA78B00F77EA2 /* jquant2.c */,
-				00B7E0D50EDCA78B00F77EA2 /* jutils.c */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libjpeg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-		FE08AA3E0945D5620057213F /* Include */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E1180EDCA84F00F77EA2 /* jchuff.h */,
-				00B7E1190EDCA84F00F77EA2 /* jconfig.h */,
-				00B7E11A0EDCA84F00F77EA2 /* jerror.h */,
-				00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */,
-			);
-			name = Include;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E11C0EDCA84F00F77EA2 /* jchuff.h in Headers */,
-				00B7E11D0EDCA84F00F77EA2 /* jconfig.h in Headers */,
-				00B7E11E0EDCA84F00F77EA2 /* jerror.h in Headers */,
-				00B7E11F0EDCA84F00F77EA2 /* jpeglib.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* jpeg */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = FE5F48080947840B0095980F /* Build configuration list for PBXNativeTarget "jpeg" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = jpeg;
-			productName = jpeg;
-			productReference = D2AAC046055464E500DB518D /* libjpeg.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = FE5F480C0947840B0095980F /* Build configuration list for PBXProject "jpeg" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* jpeg */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC045055464E500DB518D /* jpeg */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E07F0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp in Sources */,
-				00B7E0D60EDCA78B00F77EA2 /* jcapimin.c in Sources */,
-				00B7E0D70EDCA78B00F77EA2 /* jcapistd.c in Sources */,
-				00B7E0D80EDCA78B00F77EA2 /* jccoefct.c in Sources */,
-				00B7E0D90EDCA78B00F77EA2 /* jccolor.c in Sources */,
-				00B7E0DA0EDCA78B00F77EA2 /* jcdctmgr.c in Sources */,
-				00B7E0DB0EDCA78B00F77EA2 /* jchuff.c in Sources */,
-				00B7E0DD0EDCA78B00F77EA2 /* jcinit.c in Sources */,
-				00B7E0DE0EDCA78B00F77EA2 /* jcmainct.c in Sources */,
-				00B7E0DF0EDCA78B00F77EA2 /* jcmarker.c in Sources */,
-				00B7E0E00EDCA78B00F77EA2 /* jcmaster.c in Sources */,
-				00B7E0E10EDCA78B00F77EA2 /* jcomapi.c in Sources */,
-				00B7E0E30EDCA78B00F77EA2 /* jcparam.c in Sources */,
-				00B7E0E40EDCA78B00F77EA2 /* jcphuff.c in Sources */,
-				00B7E0E50EDCA78B00F77EA2 /* jcprepct.c in Sources */,
-				00B7E0E60EDCA78B00F77EA2 /* jcsample.c in Sources */,
-				00B7E0E70EDCA78B00F77EA2 /* jctrans.c in Sources */,
-				00B7E0E80EDCA78B00F77EA2 /* jdapimin.c in Sources */,
-				00B7E0E90EDCA78B00F77EA2 /* jdapistd.c in Sources */,
-				00B7E0EA0EDCA78B00F77EA2 /* jdatadst.c in Sources */,
-				00B7E0EB0EDCA78B00F77EA2 /* jdatasrc.c in Sources */,
-				00B7E0EC0EDCA78B00F77EA2 /* jdcoefct.c in Sources */,
-				00B7E0ED0EDCA78B00F77EA2 /* jdcolor.c in Sources */,
-				00B7E0EF0EDCA78B00F77EA2 /* jddctmgr.c in Sources */,
-				00B7E0F00EDCA78B00F77EA2 /* jdhuff.c in Sources */,
-				00B7E0F20EDCA78B00F77EA2 /* jdinput.c in Sources */,
-				00B7E0F30EDCA78B00F77EA2 /* jdmainct.c in Sources */,
-				00B7E0F40EDCA78B00F77EA2 /* jdmarker.c in Sources */,
-				00B7E0F50EDCA78B00F77EA2 /* jdmaster.c in Sources */,
-				00B7E0F60EDCA78B00F77EA2 /* jdmerge.c in Sources */,
-				00B7E0F70EDCA78B00F77EA2 /* jdphuff.c in Sources */,
-				00B7E0F80EDCA78B00F77EA2 /* jdpostct.c in Sources */,
-				00B7E0F90EDCA78B00F77EA2 /* jdsample.c in Sources */,
-				00B7E0FA0EDCA78B00F77EA2 /* jdtrans.c in Sources */,
-				00B7E0FB0EDCA78B00F77EA2 /* jerror.c in Sources */,
-				00B7E0FD0EDCA78B00F77EA2 /* jfdctflt.c in Sources */,
-				00B7E0FE0EDCA78B00F77EA2 /* jfdctfst.c in Sources */,
-				00B7E0FF0EDCA78B00F77EA2 /* jfdctint.c in Sources */,
-				00B7E1000EDCA78B00F77EA2 /* jidctflt.c in Sources */,
-				00B7E1010EDCA78B00F77EA2 /* jidctfst.c in Sources */,
-				00B7E1030EDCA78B00F77EA2 /* jidctint.c in Sources */,
-				00B7E1040EDCA78B00F77EA2 /* jidctred.c in Sources */,
-				00B7E1070EDCA78B00F77EA2 /* jmemansi.c in Sources */,
-				00B7E10B0EDCA78B00F77EA2 /* jmemmgr.c in Sources */,
-				00B7E1130EDCA78B00F77EA2 /* jquant1.c in Sources */,
-				00B7E1140EDCA78B00F77EA2 /* jquant2.c in Sources */,
-				00B7E1150EDCA78B00F77EA2 /* jutils.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		FE5F48090947840B0095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = jpeg;
-				PUBLIC_HEADERS_FOLDER_PATH = "";
-				REZ_PREPROCESSOR_DEFINITIONS = "_LIB SK_FORCE_SCALARFIXED";
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		FE5F480A0947840B0095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = jpeg;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		FE5F480D0947840B0095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_DEBUG,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Debug;
-		};
-		FE5F480E0947840B0095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_RELEASE,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		FE5F48080947840B0095980F /* Build configuration list for PBXNativeTarget "jpeg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F48090947840B0095980F /* Debug */,
-				FE5F480A0947840B0095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		FE5F480C0947840B0095980F /* Build configuration list for PBXProject "jpeg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F480D0947840B0095980F /* Debug */,
-				FE5F480E0947840B0095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/libpng.xcodeproj/project.pbxproj b/xcode/libpng.xcodeproj/project.pbxproj
deleted file mode 100644
index 7e12316..0000000
--- a/xcode/libpng.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,306 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E1390EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */; };
-		00B7E14B0EDCA98D00F77EA2 /* png.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13A0EDCA98D00F77EA2 /* png.c */; };
-		00B7E14C0EDCA98D00F77EA2 /* pngerror.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13B0EDCA98D00F77EA2 /* pngerror.c */; };
-		00B7E14D0EDCA98D00F77EA2 /* pnggccrd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */; };
-		00B7E14E0EDCA98D00F77EA2 /* pngget.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13D0EDCA98D00F77EA2 /* pngget.c */; };
-		00B7E14F0EDCA98D00F77EA2 /* pngmem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13E0EDCA98D00F77EA2 /* pngmem.c */; };
-		00B7E1500EDCA98D00F77EA2 /* pngpread.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13F0EDCA98D00F77EA2 /* pngpread.c */; };
-		00B7E1510EDCA98D00F77EA2 /* pngread.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1400EDCA98D00F77EA2 /* pngread.c */; };
-		00B7E1520EDCA98D00F77EA2 /* pngrio.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1410EDCA98D00F77EA2 /* pngrio.c */; };
-		00B7E1530EDCA98D00F77EA2 /* pngrtran.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1420EDCA98D00F77EA2 /* pngrtran.c */; };
-		00B7E1540EDCA98D00F77EA2 /* pngrutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1430EDCA98D00F77EA2 /* pngrutil.c */; };
-		00B7E1550EDCA98D00F77EA2 /* pngset.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1440EDCA98D00F77EA2 /* pngset.c */; };
-		00B7E1560EDCA98D00F77EA2 /* pngtrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1450EDCA98D00F77EA2 /* pngtrans.c */; };
-		00B7E1570EDCA98D00F77EA2 /* pngvcrd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */; };
-		00B7E1580EDCA98D00F77EA2 /* pngwio.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1470EDCA98D00F77EA2 /* pngwio.c */; };
-		00B7E1590EDCA98D00F77EA2 /* pngwrite.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1480EDCA98D00F77EA2 /* pngwrite.c */; };
-		00B7E15A0EDCA98D00F77EA2 /* pngwtran.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1490EDCA98D00F77EA2 /* pngwtran.c */; };
-		00B7E15B0EDCA98D00F77EA2 /* pngwutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libpng.cpp; path = ../libsgl/images/SkImageDecoder_libpng.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E13A0EDCA98D00F77EA2 /* png.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = png.c; path = ../../libpng/png.c; sourceTree = SOURCE_ROOT; };
-		00B7E13B0EDCA98D00F77EA2 /* pngerror.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngerror.c; path = ../../libpng/pngerror.c; sourceTree = SOURCE_ROOT; };
-		00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pnggccrd.c; path = ../../libpng/pnggccrd.c; sourceTree = SOURCE_ROOT; };
-		00B7E13D0EDCA98D00F77EA2 /* pngget.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngget.c; path = ../../libpng/pngget.c; sourceTree = SOURCE_ROOT; };
-		00B7E13E0EDCA98D00F77EA2 /* pngmem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngmem.c; path = ../../libpng/pngmem.c; sourceTree = SOURCE_ROOT; };
-		00B7E13F0EDCA98D00F77EA2 /* pngpread.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngpread.c; path = ../../libpng/pngpread.c; sourceTree = SOURCE_ROOT; };
-		00B7E1400EDCA98D00F77EA2 /* pngread.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngread.c; path = ../../libpng/pngread.c; sourceTree = SOURCE_ROOT; };
-		00B7E1410EDCA98D00F77EA2 /* pngrio.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrio.c; path = ../../libpng/pngrio.c; sourceTree = SOURCE_ROOT; };
-		00B7E1420EDCA98D00F77EA2 /* pngrtran.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrtran.c; path = ../../libpng/pngrtran.c; sourceTree = SOURCE_ROOT; };
-		00B7E1430EDCA98D00F77EA2 /* pngrutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrutil.c; path = ../../libpng/pngrutil.c; sourceTree = SOURCE_ROOT; };
-		00B7E1440EDCA98D00F77EA2 /* pngset.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngset.c; path = ../../libpng/pngset.c; sourceTree = SOURCE_ROOT; };
-		00B7E1450EDCA98D00F77EA2 /* pngtrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngtrans.c; path = ../../libpng/pngtrans.c; sourceTree = SOURCE_ROOT; };
-		00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngvcrd.c; path = ../../libpng/pngvcrd.c; sourceTree = SOURCE_ROOT; };
-		00B7E1470EDCA98D00F77EA2 /* pngwio.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwio.c; path = ../../libpng/pngwio.c; sourceTree = SOURCE_ROOT; };
-		00B7E1480EDCA98D00F77EA2 /* pngwrite.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwrite.c; path = ../../libpng/pngwrite.c; sourceTree = SOURCE_ROOT; };
-		00B7E1490EDCA98D00F77EA2 /* pngwtran.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwtran.c; path = ../../libpng/pngwtran.c; sourceTree = SOURCE_ROOT; };
-		00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwutil.c; path = ../../libpng/pngwutil.c; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* liblibpng.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = liblibpng.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* libpng */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = libpng;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E13A0EDCA98D00F77EA2 /* png.c */,
-				00B7E13B0EDCA98D00F77EA2 /* pngerror.c */,
-				00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */,
-				00B7E13D0EDCA98D00F77EA2 /* pngget.c */,
-				00B7E13E0EDCA98D00F77EA2 /* pngmem.c */,
-				00B7E13F0EDCA98D00F77EA2 /* pngpread.c */,
-				00B7E1400EDCA98D00F77EA2 /* pngread.c */,
-				00B7E1410EDCA98D00F77EA2 /* pngrio.c */,
-				00B7E1420EDCA98D00F77EA2 /* pngrtran.c */,
-				00B7E1430EDCA98D00F77EA2 /* pngrutil.c */,
-				00B7E1440EDCA98D00F77EA2 /* pngset.c */,
-				00B7E1450EDCA98D00F77EA2 /* pngtrans.c */,
-				00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */,
-				00B7E1470EDCA98D00F77EA2 /* pngwio.c */,
-				00B7E1480EDCA98D00F77EA2 /* pngwrite.c */,
-				00B7E1490EDCA98D00F77EA2 /* pngwtran.c */,
-				00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* liblibpng.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* libpng */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = FE5F4815094784400095980F /* Build configuration list for PBXNativeTarget "libpng" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = libpng;
-			productName = libpng;
-			productReference = D2AAC046055464E500DB518D /* liblibpng.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = FE5F4819094784400095980F /* Build configuration list for PBXProject "libpng" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* libpng */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC045055464E500DB518D /* libpng */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E1390EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp in Sources */,
-				00B7E14B0EDCA98D00F77EA2 /* png.c in Sources */,
-				00B7E14C0EDCA98D00F77EA2 /* pngerror.c in Sources */,
-				00B7E14D0EDCA98D00F77EA2 /* pnggccrd.c in Sources */,
-				00B7E14E0EDCA98D00F77EA2 /* pngget.c in Sources */,
-				00B7E14F0EDCA98D00F77EA2 /* pngmem.c in Sources */,
-				00B7E1500EDCA98D00F77EA2 /* pngpread.c in Sources */,
-				00B7E1510EDCA98D00F77EA2 /* pngread.c in Sources */,
-				00B7E1520EDCA98D00F77EA2 /* pngrio.c in Sources */,
-				00B7E1530EDCA98D00F77EA2 /* pngrtran.c in Sources */,
-				00B7E1540EDCA98D00F77EA2 /* pngrutil.c in Sources */,
-				00B7E1550EDCA98D00F77EA2 /* pngset.c in Sources */,
-				00B7E1560EDCA98D00F77EA2 /* pngtrans.c in Sources */,
-				00B7E1570EDCA98D00F77EA2 /* pngvcrd.c in Sources */,
-				00B7E1580EDCA98D00F77EA2 /* pngwio.c in Sources */,
-				00B7E1590EDCA98D00F77EA2 /* pngwrite.c in Sources */,
-				00B7E15A0EDCA98D00F77EA2 /* pngwtran.c in Sources */,
-				00B7E15B0EDCA98D00F77EA2 /* pngwutil.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		FE5F4816094784400095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = (
-					../../include/graphics,
-					../../extlibs/png,
-					../../extlibs/zlib,
-				);
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = libpng;
-				REZ_PREPROCESSOR_DEFINITIONS = "_LIB PNG_USER_CONFIG SK_FORCE_SCALARFIXED";
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		FE5F4817094784400095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = libpng;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		FE5F481A094784400095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_DEBUG,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Debug;
-		};
-		FE5F481B094784400095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		FE5F4815094784400095980F /* Build configuration list for PBXNativeTarget "libpng" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F4816094784400095980F /* Debug */,
-				FE5F4817094784400095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		FE5F4819094784400095980F /* Build configuration list for PBXProject "libpng" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F481A094784400095980F /* Debug */,
-				FE5F481B094784400095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/ports-mac.xcodeproj/project.pbxproj b/xcode/ports-mac.xcodeproj/project.pbxproj
deleted file mode 100644
index e4aba44..0000000
--- a/xcode/ports-mac.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,248 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E16C0EDCA9EA00F77EA2 /* SkThread_pthread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */; };
-		00B7E16D0EDCA9EA00F77EA2 /* SkTime_Unix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */; };
-		00B7E16F0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */; };
-		FE33C956094E031400C4A640 /* SkBitmap_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */; };
-		FE33C957094E031400C4A640 /* SkOSWindow_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */; };
-		FE33C959094E041D00C4A640 /* skia_mac.cp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C958094E041D00C4A640 /* skia_mac.cp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkThread_pthread.cpp; path = ../libsgl/ports/SkThread_pthread.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime_Unix.cpp; path = ../libsgl/ports/SkTime_Unix.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_wbmp.cpp; path = ../libsgl/images/SkImageDecoder_wbmp.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libports-mac.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libports-mac.a"; sourceTree = BUILT_PRODUCTS_DIR; };
-		FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_Mac.cpp; path = ports/SkBitmap_Mac.cpp; sourceTree = "<group>"; };
-		FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSWindow_Mac.cpp; path = ports/SkOSWindow_Mac.cpp; sourceTree = "<group>"; };
-		FE33C958094E041D00C4A640 /* skia_mac.cp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = skia_mac.cp; path = ports/skia_mac.cp; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* ports-mac */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = "ports-mac";
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */,
-				00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */,
-				00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */,
-				FE33C958094E041D00C4A640 /* skia_mac.cp */,
-				FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */,
-				FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libports-mac.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* ports-mac */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports-mac" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = "ports-mac";
-			productName = "ports-mac";
-			productReference = D2AAC046055464E500DB518D /* libports-mac.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports-mac" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* ports-mac */;
-			projectDirPath = "";
-			projectRoot = ..;
-			targets = (
-				D2AAC045055464E500DB518D /* ports-mac */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				FE33C956094E031400C4A640 /* SkBitmap_Mac.cpp in Sources */,
-				FE33C957094E031400C4A640 /* SkOSWindow_Mac.cpp in Sources */,
-				FE33C959094E041D00C4A640 /* skia_mac.cp in Sources */,
-				00B7E16C0EDCA9EA00F77EA2 /* SkThread_pthread.cpp in Sources */,
-				00B7E16D0EDCA9EA00F77EA2 /* SkTime_Unix.cpp in Sources */,
-				00B7E16F0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = "ports-mac";
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = "ports-mac";
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports-mac" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports-mac" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/ports.xcodeproj/project.pbxproj b/xcode/ports.xcodeproj/project.pbxproj
deleted file mode 100644
index 7d22634..0000000
--- a/xcode/ports.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,251 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E18F0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */; };
-		00B7E1900EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */; };
-		00B7E1950EDCAA9300F77EA2 /* SkFontHost_android.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */; };
-		00B7E1960EDCAA9300F77EA2 /* SkGlobals_global.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */; };
-		00B7E1970EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */; };
-		00B7E1980EDCAA9300F77EA2 /* SkOSFile_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */; };
-		00B7E19A0EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */; };
-		00B7E3610EDCB05400F77EA2 /* SkFontHost_gamma.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bmpdecoderhelper.cpp; path = ../libsgl/images/bmpdecoderhelper.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libbmp.cpp; path = ../libsgl/images/SkImageDecoder_libbmp.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_android.cpp; path = ../libsgl/ports/SkFontHost_android.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals_global.cpp; path = ../libsgl/ports/SkGlobals_global.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_Factory.cpp; path = ../libsgl/ports/SkImageDecoder_Factory.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile_stdio.cpp; path = ../libsgl/ports/SkOSFile_stdio.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libico.cpp; path = ../libsgl/images/SkImageDecoder_libico.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_gamma.cpp; path = ../libsgl/ports/SkFontHost_gamma.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libports.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libports.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* ports */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = ports;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */,
-				00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */,
-				00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */,
-				00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */,
-				00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */,
-				00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */,
-				00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */,
-				00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libports.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* ports */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = ports;
-			productName = ports;
-			productReference = D2AAC046055464E500DB518D /* libports.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* ports */;
-			projectDirPath = "";
-			projectRoot = ../..;
-			targets = (
-				D2AAC045055464E500DB518D /* ports */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E18F0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp in Sources */,
-				00B7E1900EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp in Sources */,
-				00B7E1950EDCAA9300F77EA2 /* SkFontHost_android.cpp in Sources */,
-				00B7E1960EDCAA9300F77EA2 /* SkGlobals_global.cpp in Sources */,
-				00B7E1970EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp in Sources */,
-				00B7E1980EDCAA9300F77EA2 /* SkOSFile_stdio.cpp in Sources */,
-				00B7E19A0EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp in Sources */,
-				00B7E3610EDCB05400F77EA2 /* SkFontHost_gamma.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = ports;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = ports;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_RELEASE,
-				);
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/ports/skia_mac.cp b/xcode/ports/skia_mac.cp
deleted file mode 100644
index 81b26e1..0000000
--- a/xcode/ports/skia_mac.cp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "SkTypes.h"
-
-#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS)
-#include <Carbon/Carbon.h>
-#include <unistd.h>
-#include <cerrno>
-#include "SkApplication.h"
-
-extern void get_preferred_size(int*, int*, int*, int* );
-
-int main(int argc, char* argv[])
-{
-    
-#if 0
-{
-	FILE* f = ::fopen("/whereami.txt", "w");
-	for (int i = 0; i < argc; i++)
-		fprintf(f, "[%d] %s\n", i, argv[i]);
-	::fclose(f);
-}
-#else
-// argv[0] is set to the execution path of the application, e.g. 
-// /Users/caryclark/android/device/build/ide/xcode/animatorTest/build/Debug/animatorTest.app/Contents/MacOS/animatorTest
-// the desired directory path is :
-// /Users/caryclark/android/device/jsapps
-// the variable (client-specific) part is :
-// /Users/caryclark/android/
-// since different applications share this library, they only have in common:
-// {client}/device/build/ide/xcode/{application}
-{
-	const char* applicationPath = argv[0];
-	const char* common = strstr(applicationPath, "build/ide/xcode/");
-	const char systemParent[] = "apps/"; 
-	if (common != 0) {
-		size_t prefixLength = common - applicationPath;
-		char* workingDirectory = new char[prefixLength + sizeof(systemParent)];
-		strncpy(workingDirectory, applicationPath, prefixLength);
-		strcpy(&workingDirectory[prefixLength], systemParent);
-		int error = chdir(workingDirectory);
-		if (error != 0) {
-			error = errno;
-			SkASSERT(error != ENOENT);
-			SkASSERT(error != ENOTDIR);
-			SkASSERT(error != EACCES);
-			SkASSERT(error != EIO);
-			SkASSERT(0);
-		}
-		delete workingDirectory;
-	}
-}
-#endif
-	IBNibRef 		nibRef;
-    WindowRef 		window;
-    
-    OSStatus		err;
-
-    // Create a Nib reference passing the name of the nib file (without the .nib extension)
-    // CreateNibReference only searches into the application bundle.
-    err = CreateNibReference(CFSTR("main"), &nibRef);
-    require_noerr( err, CantGetNibRef );
-    
-    // Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar
-    // object. This name is set in InterfaceBuilder when the nib is created.
-    err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar"));
-    require_noerr( err, CantSetMenuBar );
-    
-    // Then create a window. "MainWindow" is the name of the window object. This name is set in 
-    // InterfaceBuilder when the nib is created.
-    err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window);
-    require_noerr( err, CantCreateWindow );
-
-    // We don't need the nib reference anymore.
-    DisposeNibReference(nibRef);
-    {
-	// if we get here, we can start our normal Skia sequence
-	application_init();
-	(void)create_sk_window(window);
-        int x =0, y =0, width =640, height=480;
-        get_preferred_size(&x, &y, &width, &height);
-        MoveWindow(window, x, y, false);
-        SizeWindow(window, width, height, false);
-    }
-    // The window was created hidden so show it.
-    ShowWindow( window );
-
-    // Call the event loop
-    RunApplicationEventLoop();
-	
-	application_term();
-
-CantCreateWindow:
-CantSetMenuBar:
-CantGetNibRef:
-	return err;
-}
-
-#endif
\ No newline at end of file
diff --git a/xcode/pvjpeg.xcodeproj/project.pbxproj b/xcode/pvjpeg.xcodeproj/project.pbxproj
deleted file mode 100644
index 5d09e2d..0000000
--- a/xcode/pvjpeg.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,261 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		007ECA0E0DA67F7B0086775A /* jpgdec_bitstream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */; };
-		007ECA0F0DA67F7B0086775A /* jpgdec_cint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */; };
-		007ECA100DA67F7B0086775A /* jpgdec_colorconv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */; };
-		007ECA110DA67F7B0086775A /* jpgdec_ct.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */; };
-		007ECA120DA67F7B0086775A /* jpgdec_decoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */; };
-		007ECA130DA67F7B0086775A /* jpgdec_header.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA060DA67F7B0086775A /* jpgdec_header.cpp */; };
-		007ECA140DA67F7B0086775A /* jpgdec_huffman.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */; };
-		007ECA150DA67F7B0086775A /* jpgdec_idctp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */; };
-		007ECA160DA67F7B0086775A /* jpgdec_idcts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */; };
-		007ECA170DA67F7B0086775A /* jpgdec_scan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */; };
-		007ECA180DA67F7B0086775A /* jpgdec_table.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */; };
-		007ECA190DA67F7B0086775A /* jpgdec_utils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */; };
-		007ECA1A0DA67F7B0086775A /* pvjpgdecoder_factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */; };
-		007ECA500DA683160086775A /* SkImageDecoder_libpvjpeg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_bitstream.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_bitstream.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_cint.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_cint.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_colorconv.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_colorconv.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_ct.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_ct.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_decoder.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_decoder.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA060DA67F7B0086775A /* jpgdec_header.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_header.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_header.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_huffman.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_huffman.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idctp.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idctp.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idcts.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idcts.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_scan.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_scan.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_table.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_table.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_utils.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_utils.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pvjpgdecoder_factory.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/pvjpgdecoder_factory.cpp; sourceTree = SOURCE_ROOT; };
-		007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libpvjpeg.cpp; path = ../../libs/graphics/images/SkImageDecoder_libpvjpeg.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libpvjpeg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libpvjpeg.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* pvjpeg */ = {
-			isa = PBXGroup;
-			children = (
-				007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = pvjpeg;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */,
-				007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */,
-				007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */,
-				007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */,
-				007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */,
-				007ECA060DA67F7B0086775A /* jpgdec_header.cpp */,
-				007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */,
-				007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */,
-				007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */,
-				007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */,
-				007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */,
-				007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */,
-				007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libpvjpeg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* pvjpeg */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "pvjpeg" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = pvjpeg;
-			productName = pvjpeg;
-			productReference = D2AAC046055464E500DB518D /* libpvjpeg.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "pvjpeg" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* pvjpeg */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				D2AAC045055464E500DB518D /* pvjpeg */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				007ECA0E0DA67F7B0086775A /* jpgdec_bitstream.cpp in Sources */,
-				007ECA0F0DA67F7B0086775A /* jpgdec_cint.cpp in Sources */,
-				007ECA100DA67F7B0086775A /* jpgdec_colorconv.cpp in Sources */,
-				007ECA110DA67F7B0086775A /* jpgdec_ct.cpp in Sources */,
-				007ECA120DA67F7B0086775A /* jpgdec_decoder.cpp in Sources */,
-				007ECA130DA67F7B0086775A /* jpgdec_header.cpp in Sources */,
-				007ECA140DA67F7B0086775A /* jpgdec_huffman.cpp in Sources */,
-				007ECA150DA67F7B0086775A /* jpgdec_idctp.cpp in Sources */,
-				007ECA160DA67F7B0086775A /* jpgdec_idcts.cpp in Sources */,
-				007ECA170DA67F7B0086775A /* jpgdec_scan.cpp in Sources */,
-				007ECA180DA67F7B0086775A /* jpgdec_table.cpp in Sources */,
-				007ECA190DA67F7B0086775A /* jpgdec_utils.cpp in Sources */,
-				007ECA1A0DA67F7B0086775A /* pvjpgdecoder_factory.cpp in Sources */,
-				007ECA500DA683160086775A /* SkImageDecoder_libpvjpeg.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = pvjpeg;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = pvjpeg;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = "USE_PV_OSCL_LIB=0";
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../../extlibs/pv/** ../../include/corecg ../../include/graphics";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = "USE_PV_OSCL_LIB=0";
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-				USER_HEADER_SEARCH_PATHS = "../../extlibs/pv/** ../../include/corecg ../../include/graphics";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "pvjpeg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "pvjpeg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/skia2.xcodeproj/project.pbxproj b/xcode/skia2.xcodeproj/project.pbxproj
deleted file mode 100644
index 1a27e69..0000000
--- a/xcode/skia2.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,1389 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		003E926F0EED78220091D85B /* libfreetype.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00A5676D0EED77850096A2A1 /* libfreetype.a */; };
-		006B43FE0EF7526E00F15BC4 /* SkString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43FC0EF7526E00F15BC4 /* SkString.cpp */; };
-		006B43FF0EF7526E00F15BC4 /* SkUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */; };
-		00A567300EED6F6E0096A2A1 /* libgiflib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE44670EE9D1780008420F /* libgiflib.a */; };
-		00AFCD710EF1672C00BD2FF1 /* SkDOM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */; };
-		00AFCD7C0EF167BC00BD2FF1 /* SkParse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */; };
-		00AFCD7D0EF167BC00BD2FF1 /* SkParseColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */; };
-		00AFCD7E0EF167BC00BD2FF1 /* SkXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */; };
-		00AFCD890EF1684200BD2FF1 /* SkBitmap_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */; };
-		00AFCD8B0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */; };
-		00AFCE240EF16C0500BD2FF1 /* libexpat.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00AFCE150EF16BA400BD2FF1 /* libexpat.a */; };
-		00BE435D0EE9CDFA0008420F /* Sk1DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */; };
-		00BE435E0EE9CDFA0008420F /* Sk2DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */; };
-		00BE435F0EE9CDFA0008420F /* SkAvoidXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */; };
-		00BE43600EE9CDFA0008420F /* SkBlurDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */; };
-		00BE43610EE9CDFA0008420F /* SkBlurMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */; };
-		00BE43620EE9CDFA0008420F /* SkBlurMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42850EE9CDFA0008420F /* SkBlurMask.h */; };
-		00BE43630EE9CDFA0008420F /* SkBlurMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */; };
-		00BE43640EE9CDFA0008420F /* SkCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42870EE9CDFA0008420F /* SkCamera.cpp */; };
-		00BE43650EE9CDFA0008420F /* SkColorFilters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */; };
-		00BE43660EE9CDFA0008420F /* SkColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */; };
-		00BE43670EE9CDFA0008420F /* SkColorMatrixFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */; };
-		00BE43680EE9CDFA0008420F /* SkCornerPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */; };
-		00BE43690EE9CDFA0008420F /* SkCullPoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */; };
-		00BE436A0EE9CDFA0008420F /* SkDashPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */; };
-		00BE436B0EE9CDFA0008420F /* SkDiscretePathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */; };
-		00BE436C0EE9CDFA0008420F /* SkDumpCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */; };
-		00BE436D0EE9CDFA0008420F /* SkEmbossMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */; };
-		00BE436E0EE9CDFA0008420F /* SkEmbossMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42910EE9CDFA0008420F /* SkEmbossMask.h */; };
-		00BE436F0EE9CDFA0008420F /* SkEmbossMask_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */; };
-		00BE43700EE9CDFA0008420F /* SkEmbossMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */; };
-		00BE43710EE9CDFA0008420F /* SkGradientShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */; };
-		00BE43720EE9CDFA0008420F /* SkKernel33MaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */; };
-		00BE43730EE9CDFA0008420F /* SkLayerDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */; };
-		00BE43740EE9CDFA0008420F /* SkLayerRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */; };
-		00BE43750EE9CDFA0008420F /* SkNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */; };
-		00BE43760EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */; };
-		00BE43770EE9CDFA0008420F /* SkPixelXorXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */; };
-		00BE43780EE9CDFA0008420F /* SkProxyCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */; };
-		00BE43790EE9CDFA0008420F /* SkRadialGradient_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */; };
-		00BE437A0EE9CDFA0008420F /* SkShaderExtras.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */; };
-		00BE437B0EE9CDFA0008420F /* SkTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */; };
-		00BE437C0EE9CDFA0008420F /* SkUnitMappers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */; };
-		00BE437D0EE9CDFA0008420F /* SkBGViewArtist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */; };
-		00BE437E0EE9CDFA0008420F /* SkBorderView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */; };
-		00BE437F0EE9CDFA0008420F /* SkEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A30EE9CDFA0008420F /* SkEvent.cpp */; };
-		00BE43800EE9CDFA0008420F /* SkEventSink.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */; };
-		00BE43810EE9CDFA0008420F /* SkImageView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A50EE9CDFA0008420F /* SkImageView.cpp */; };
-		00BE43820EE9CDFA0008420F /* SkListView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A60EE9CDFA0008420F /* SkListView.cpp */; };
-		00BE43830EE9CDFA0008420F /* SkListWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */; };
-		00BE43840EE9CDFA0008420F /* SkMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */; };
-		00BE43850EE9CDFA0008420F /* SkOSFile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */; };
-		00BE43860EE9CDFA0008420F /* SkOSMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */; };
-		00BE43870EE9CDFA0008420F /* SkOSSound.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */; };
-		00BE43880EE9CDFA0008420F /* SkParsePaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */; };
-		00BE43890EE9CDFA0008420F /* SkProgressBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */; };
-		00BE438A0EE9CDFA0008420F /* SkProgressView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */; };
-		00BE438B0EE9CDFA0008420F /* SkScrollBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */; };
-		00BE438C0EE9CDFA0008420F /* SkStackViewLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */; };
-		00BE438D0EE9CDFA0008420F /* SkTagList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B10EE9CDFA0008420F /* SkTagList.cpp */; };
-		00BE438E0EE9CDFA0008420F /* SkTagList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42B20EE9CDFA0008420F /* SkTagList.h */; };
-		00BE438F0EE9CDFA0008420F /* SkTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */; };
-		00BE43900EE9CDFA0008420F /* SkView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B40EE9CDFA0008420F /* SkView.cpp */; };
-		00BE43910EE9CDFA0008420F /* SkViewInflate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */; };
-		00BE43920EE9CDFA0008420F /* SkViewPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */; };
-		00BE43930EE9CDFA0008420F /* SkViewPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42B70EE9CDFA0008420F /* SkViewPriv.h */; };
-		00BE43940EE9CDFA0008420F /* SkWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B80EE9CDFA0008420F /* SkWidget.cpp */; };
-		00BE43950EE9CDFA0008420F /* SkWidgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */; };
-		00BE43960EE9CDFA0008420F /* SkWidgetViews.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */; };
-		00BE43970EE9CDFA0008420F /* SkWindow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */; };
-		00BE43980EE9CDFA0008420F /* SkFDStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */; };
-		00BE43990EE9CDFA0008420F /* SkFlipPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */; };
-		00BE439A0EE9CDFA0008420F /* SkImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */; };
-		00BE439C0EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */; };
-		00BE439E0EE9CDFA0008420F /* SkImageDecoder_libico.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */; };
-		00BE43A20EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */; };
-		00BE43A30EE9CDFA0008420F /* SkImageRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */; };
-		00BE43A40EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */; };
-		00BE43A50EE9CDFA0008420F /* SkImageRefPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */; };
-		00BE43A60EE9CDFA0008420F /* SkImageRefPool.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */; };
-		00BE43A70EE9CDFA0008420F /* SkMMapStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */; };
-		00BE43A80EE9CDFA0008420F /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */; };
-		00BE43AA0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */; };
-		00BE43AB0EE9CDFA0008420F /* SkScaledBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */; };
-		00BE43AC0EE9CDFA0008420F /* SkStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D10EE9CDFA0008420F /* SkStream.cpp */; };
-		00BE43AD0EE9CDFA0008420F /* SkFontHost_android.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */; };
-		00BE43AE0EE9CDFA0008420F /* SkFontHost_gamma.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */; };
-		00BE43AF0EE9CDFA0008420F /* SkGlobals_global.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */; };
-		00BE43B00EE9CDFA0008420F /* SkImageDecoder_Factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */; };
-		00BE43B10EE9CDFA0008420F /* SkThread_pthread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */; };
-		00BE43B20EE9CDFA0008420F /* SkTime_Unix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */; };
-		00BE43B30EE9CDFA0008420F /* SkPathHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */; };
-		00BE43B40EE9CDFA0008420F /* SkPathHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */; };
-		00BE43B50EE9CDFA0008420F /* SkPicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */; };
-		00BE43B60EE9CDFA0008420F /* SkPictureFlat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */; };
-		00BE43B70EE9CDFA0008420F /* SkPictureFlat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */; };
-		00BE43B80EE9CDFA0008420F /* SkPicturePlayback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */; };
-		00BE43B90EE9CDFA0008420F /* SkPicturePlayback.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */; };
-		00BE43BA0EE9CDFA0008420F /* SkPictureRecord.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */; };
-		00BE43BB0EE9CDFA0008420F /* SkPictureRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */; };
-		00BE43BC0EE9CDFA0008420F /* SkGL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E30EE9CDFA0008420F /* SkGL.cpp */; };
-		00BE43BD0EE9CDFA0008420F /* SkGL.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E40EE9CDFA0008420F /* SkGL.h */; };
-		00BE43BE0EE9CDFA0008420F /* SkGLCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */; };
-		00BE43BF0EE9CDFA0008420F /* SkGLDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */; };
-		00BE43C00EE9CDFA0008420F /* SkGLDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E70EE9CDFA0008420F /* SkGLDevice.h */; };
-		00BE43C10EE9CDFA0008420F /* SkGLDevice_FBO.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */; };
-		00BE43C20EE9CDFA0008420F /* SkGLDevice_FBO.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */; };
-		00BE43C30EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */; };
-		00BE43C40EE9CDFA0008420F /* SkGLDevice_SWLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */; };
-		00BE43C50EE9CDFA0008420F /* SkGLTextCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */; };
-		00BE43C60EE9CDFA0008420F /* SkGLTextCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */; };
-		00BE43C70EE9CDFA0008420F /* SkTextureCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */; };
-		00BE43C80EE9CDFA0008420F /* SkTextureCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */; };
-		00BE43C90EE9CDFA0008420F /* SkAlphaRuns.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */; };
-		00BE43CA0EE9CDFA0008420F /* SkAntiRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F10EE9CDFA0008420F /* SkAntiRun.h */; };
-		00BE43CB0EE9CDFA0008420F /* SkAutoKern.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F20EE9CDFA0008420F /* SkAutoKern.h */; };
-		00BE43CC0EE9CDFA0008420F /* SkBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */; };
-		00BE43CD0EE9CDFA0008420F /* SkBitmap_scroll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */; };
-		00BE43CE0EE9CDFA0008420F /* SkBitmapProcShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */; };
-		00BE43CF0EE9CDFA0008420F /* SkBitmapProcShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */; };
-		00BE43D00EE9CDFA0008420F /* SkBitmapProcState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */; };
-		00BE43D10EE9CDFA0008420F /* SkBitmapProcState.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */; };
-		00BE43D20EE9CDFA0008420F /* SkBitmapProcState_matrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */; };
-		00BE43D30EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */; };
-		00BE43D40EE9CDFA0008420F /* SkBitmapProcState_sample.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */; };
-		00BE43D50EE9CDFA0008420F /* SkBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */; };
-		00BE43D60EE9CDFA0008420F /* SkBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */; };
-		00BE43D70EE9CDFA0008420F /* SkBitmapSamplerTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */; };
-		00BE43D80EE9CDFA0008420F /* SkBitmapShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */; };
-		00BE43D90EE9CDFA0008420F /* SkBitmapShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43000EE9CDFA0008420F /* SkBitmapShader.h */; };
-		00BE43DA0EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */; };
-		00BE43DB0EE9CDFA0008420F /* SkBitmapShaderTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */; };
-		00BE43DC0EE9CDFA0008420F /* SkBlitBWMaskTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */; };
-		00BE43DD0EE9CDFA0008420F /* SkBlitRow.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43040EE9CDFA0008420F /* SkBlitRow.h */; };
-		00BE43DE0EE9CDFA0008420F /* SkBlitRow_D16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */; };
-		00BE43DF0EE9CDFA0008420F /* SkBlitRow_D4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */; };
-		00BE43E00EE9CDFA0008420F /* SkBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43070EE9CDFA0008420F /* SkBlitter.cpp */; };
-		00BE43E10EE9CDFA0008420F /* SkBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43080EE9CDFA0008420F /* SkBlitter.h */; };
-		00BE43E20EE9CDFA0008420F /* SkBlitter_4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */; };
-		00BE43E30EE9CDFA0008420F /* SkBlitter_A1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */; };
-		00BE43E40EE9CDFA0008420F /* SkBlitter_A8.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */; };
-		00BE43E50EE9CDFA0008420F /* SkBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */; };
-		00BE43E60EE9CDFA0008420F /* SkBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */; };
-		00BE43E70EE9CDFA0008420F /* SkBlitter_Sprite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */; };
-		00BE43E80EE9CDFA0008420F /* SkCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */; };
-		00BE43E90EE9CDFA0008420F /* SkColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43100EE9CDFA0008420F /* SkColor.cpp */; };
-		00BE43EA0EE9CDFA0008420F /* SkColorFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */; };
-		00BE43EB0EE9CDFA0008420F /* SkColorTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43120EE9CDFA0008420F /* SkColorTable.cpp */; };
-		00BE43EC0EE9CDFA0008420F /* SkCoreBlitters.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */; };
-		00BE43ED0EE9CDFA0008420F /* SkDeque.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43140EE9CDFA0008420F /* SkDeque.cpp */; };
-		00BE43EE0EE9CDFA0008420F /* SkDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43150EE9CDFA0008420F /* SkDevice.cpp */; };
-		00BE43EF0EE9CDFA0008420F /* SkDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43160EE9CDFA0008420F /* SkDither.cpp */; };
-		00BE43F00EE9CDFA0008420F /* SkDraw.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43170EE9CDFA0008420F /* SkDraw.cpp */; };
-		00BE43F10EE9CDFA0008420F /* SkDrawProcs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43180EE9CDFA0008420F /* SkDrawProcs.h */; };
-		00BE43F20EE9CDFA0008420F /* SkEdge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43190EE9CDFA0008420F /* SkEdge.cpp */; };
-		00BE43F30EE9CDFA0008420F /* SkEdge.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431A0EE9CDFA0008420F /* SkEdge.h */; };
-		00BE43F40EE9CDFA0008420F /* SkFilterProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */; };
-		00BE43F50EE9CDFA0008420F /* SkFilterProc.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431C0EE9CDFA0008420F /* SkFilterProc.h */; };
-		00BE43F60EE9CDFA0008420F /* SkFlattenable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */; };
-		00BE43F70EE9CDFA0008420F /* SkFP.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431E0EE9CDFA0008420F /* SkFP.h */; };
-		00BE43F80EE9CDFA0008420F /* SkGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */; };
-		00BE43F90EE9CDFA0008420F /* SkGeometry.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43200EE9CDFA0008420F /* SkGeometry.h */; };
-		00BE43FA0EE9CDFA0008420F /* SkGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43210EE9CDFA0008420F /* SkGlobals.cpp */; };
-		00BE43FB0EE9CDFA0008420F /* SkGlyphCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */; };
-		00BE43FC0EE9CDFA0008420F /* SkGlyphCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43230EE9CDFA0008420F /* SkGlyphCache.h */; };
-		00BE43FD0EE9CDFA0008420F /* SkGraphics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43240EE9CDFA0008420F /* SkGraphics.cpp */; };
-		00BE43FE0EE9CDFA0008420F /* SkMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43250EE9CDFA0008420F /* SkMask.cpp */; };
-		00BE43FF0EE9CDFA0008420F /* SkMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */; };
-		00BE44000EE9CDFA0008420F /* SkPackBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43270EE9CDFA0008420F /* SkPackBits.cpp */; };
-		00BE44010EE9CDFA0008420F /* SkPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43280EE9CDFA0008420F /* SkPaint.cpp */; };
-		00BE44020EE9CDFA0008420F /* SkPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43290EE9CDFA0008420F /* SkPath.cpp */; };
-		00BE44030EE9CDFA0008420F /* SkPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */; };
-		00BE44040EE9CDFA0008420F /* SkPathMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */; };
-		00BE44050EE9CDFA0008420F /* SkPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */; };
-		00BE44060EE9CDFA0008420F /* SkProcSpriteBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */; };
-		00BE44070EE9CDFA0008420F /* SkPtrRecorder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */; };
-		00BE44080EE9CDFA0008420F /* SkRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */; };
-		00BE44090EE9CDFA0008420F /* SkRefCnt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */; };
-		00BE440A0EE9CDFA0008420F /* SkRegion_path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */; };
-		00BE440B0EE9CDFA0008420F /* SkScalerContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */; };
-		00BE440C0EE9CDFA0008420F /* SkScan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43330EE9CDFA0008420F /* SkScan.cpp */; };
-		00BE440D0EE9CDFA0008420F /* SkScan.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43340EE9CDFA0008420F /* SkScan.h */; };
-		00BE440E0EE9CDFA0008420F /* SkScan_Antihair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */; };
-		00BE440F0EE9CDFA0008420F /* SkScan_AntiPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */; };
-		00BE44100EE9CDFA0008420F /* SkScan_Hairline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */; };
-		00BE44110EE9CDFA0008420F /* SkScan_Path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */; };
-		00BE44120EE9CDFA0008420F /* SkScanPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43390EE9CDFA0008420F /* SkScanPriv.h */; };
-		00BE44130EE9CDFA0008420F /* SkShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433A0EE9CDFA0008420F /* SkShader.cpp */; };
-		00BE44140EE9CDFA0008420F /* SkSpriteBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */; };
-		00BE44150EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */; };
-		00BE44160EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */; };
-		00BE44170EE9CDFA0008420F /* SkSpriteBlitterTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */; };
-		00BE44190EE9CDFA0008420F /* SkStroke.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43400EE9CDFA0008420F /* SkStroke.cpp */; };
-		00BE441A0EE9CDFA0008420F /* SkStrokerPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */; };
-		00BE441B0EE9CDFA0008420F /* SkStrokerPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */; };
-		00BE441C0EE9CDFA0008420F /* SkTemplatesPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */; };
-		00BE441D0EE9CDFA0008420F /* SkTSearch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43440EE9CDFA0008420F /* SkTSearch.cpp */; };
-		00BE441E0EE9CDFA0008420F /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43450EE9CDFA0008420F /* SkTSort.h */; };
-		00BE441F0EE9CDFA0008420F /* SkTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43460EE9CDFA0008420F /* SkTypeface.cpp */; };
-		00BE44200EE9CDFA0008420F /* SkUnPreMultiply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */; };
-		00BE44220EE9CDFA0008420F /* SkWriter32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43490EE9CDFA0008420F /* SkWriter32.cpp */; };
-		00BE44230EE9CDFA0008420F /* SkXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */; };
-		00BE44240EE9CDFA0008420F /* Sk64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434B0EE9CDFA0008420F /* Sk64.cpp */; };
-		00BE44250EE9CDFA0008420F /* SkBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */; };
-		00BE44260EE9CDFA0008420F /* SkChunkAlloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */; };
-		00BE44270EE9CDFA0008420F /* SkCordic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434E0EE9CDFA0008420F /* SkCordic.cpp */; };
-		00BE44280EE9CDFA0008420F /* SkCordic.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE434F0EE9CDFA0008420F /* SkCordic.h */; };
-		00BE44290EE9CDFA0008420F /* SkDebug.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43500EE9CDFA0008420F /* SkDebug.cpp */; };
-		00BE442A0EE9CDFA0008420F /* SkDebug_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */; };
-		00BE442B0EE9CDFA0008420F /* SkFloat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43520EE9CDFA0008420F /* SkFloat.cpp */; };
-		00BE442C0EE9CDFA0008420F /* SkFloat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43530EE9CDFA0008420F /* SkFloat.h */; };
-		00BE442D0EE9CDFA0008420F /* SkFloatBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */; };
-		00BE442E0EE9CDFA0008420F /* SkInterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */; };
-		00BE442F0EE9CDFA0008420F /* SkMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43560EE9CDFA0008420F /* SkMath.cpp */; };
-		00BE44300EE9CDFA0008420F /* SkMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43570EE9CDFA0008420F /* SkMatrix.cpp */; };
-		00BE44310EE9CDFA0008420F /* SkMemory_stdlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */; };
-		00BE44320EE9CDFA0008420F /* SkPageFlipper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */; };
-		00BE44330EE9CDFA0008420F /* SkPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435A0EE9CDFA0008420F /* SkPoint.cpp */; };
-		00BE44340EE9CDFA0008420F /* SkRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435B0EE9CDFA0008420F /* SkRect.cpp */; };
-		00BE44350EE9CDFA0008420F /* SkRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435C0EE9CDFA0008420F /* SkRegion.cpp */; };
-		00BE44C90EE9D4FC0008420F /* SkOSFile_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */; };
-		00BE44D40EE9D5660008420F /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE446A0EE9D1780008420F /* libjpeg.a */; };
-		00BE44D50EE9D5670008420F /* liblibpng.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE446D0EE9D1780008420F /* liblibpng.a */; };
-		00BE44D60EE9D5690008420F /* libzlib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE44700EE9D1780008420F /* libzlib.a */; };
-		00BE45070EE9D8120008420F /* bmpdecoderhelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		003E929A0EED79240091D85B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = freetype;
-		};
-		003E92D90EED7C3B0091D85B /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = zlib;
-		};
-		00A5676C0EED77850096A2A1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = freetype;
-		};
-		00AFCE140EF16BA400BD2FF1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = expat;
-		};
-		00AFCE170EF16BBB00BD2FF1 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = expat;
-		};
-		00BE44660EE9D1780008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = giflib;
-		};
-		00BE44690EE9D1780008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = jpeg;
-		};
-		00BE446C0EE9D1780008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE44590EE9D1780008420F /* libpng.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = libpng;
-		};
-		00BE446F0EE9D1780008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */;
-			proxyType = 2;
-			remoteGlobalIDString = D2AAC046055464E500DB518D;
-			remoteInfo = zlib;
-		};
-		00BE44F00EE9D70D0008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = jpeg;
-		};
-		00BE44F40EE9D70D0008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = giflib;
-		};
-		00BE44F60EE9D70D0008420F /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 00BE44590EE9D1780008420F /* libpng.xcodeproj */;
-			proxyType = 1;
-			remoteGlobalIDString = D2AAC045055464E500DB518D;
-			remoteInfo = libpng;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		006B43FC0EF7526E00F15BC4 /* SkString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkString.cpp; path = ../libcorecg/SkString.cpp; sourceTree = SOURCE_ROOT; };
-		006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUtils.cpp; path = ../libcorecg/SkUtils.cpp; sourceTree = SOURCE_ROOT; };
-		00A567680EED77850096A2A1 /* freetype2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = freetype2.xcodeproj; sourceTree = "<group>"; };
-		00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDOM.cpp; path = ../libsgl/xml/SkDOM.cpp; sourceTree = SOURCE_ROOT; };
-		00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParse.cpp; path = ../libsgl/xml/SkParse.cpp; sourceTree = SOURCE_ROOT; };
-		00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParseColor.cpp; path = ../libsgl/xml/SkParseColor.cpp; sourceTree = SOURCE_ROOT; };
-		00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser.cpp; path = ../libsgl/xml/SkXMLParser.cpp; sourceTree = SOURCE_ROOT; };
-		00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_Mac.cpp; path = ports/SkBitmap_Mac.cpp; sourceTree = "<group>"; };
-		00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSWindow_Mac.cpp; path = ports/SkOSWindow_Mac.cpp; sourceTree = "<group>"; };
-		00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = expat.xcodeproj; sourceTree = "<group>"; };
-		00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk1DPathEffect.cpp; path = ../libsgl/effects/Sk1DPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk2DPathEffect.cpp; path = ../libsgl/effects/Sk2DPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAvoidXfermode.cpp; path = ../libsgl/effects/SkAvoidXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurDrawLooper.cpp; path = ../libsgl/effects/SkBlurDrawLooper.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMask.cpp; path = ../libsgl/effects/SkBlurMask.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42850EE9CDFA0008420F /* SkBlurMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlurMask.h; path = ../libsgl/effects/SkBlurMask.h; sourceTree = SOURCE_ROOT; };
-		00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMaskFilter.cpp; path = ../libsgl/effects/SkBlurMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42870EE9CDFA0008420F /* SkCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCamera.cpp; path = ../libsgl/effects/SkCamera.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilters.cpp; path = ../libsgl/effects/SkColorFilters.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrix.cpp; path = ../libsgl/effects/SkColorMatrix.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrixFilter.cpp; path = ../libsgl/effects/SkColorMatrixFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCornerPathEffect.cpp; path = ../libsgl/effects/SkCornerPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCullPoints.cpp; path = ../libsgl/effects/SkCullPoints.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDashPathEffect.cpp; path = ../libsgl/effects/SkDashPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDiscretePathEffect.cpp; path = ../libsgl/effects/SkDiscretePathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDumpCanvas.cpp; path = ../libsgl/effects/SkDumpCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMask.cpp; path = ../libsgl/effects/SkEmbossMask.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42910EE9CDFA0008420F /* SkEmbossMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask.h; path = ../libsgl/effects/SkEmbossMask.h; sourceTree = SOURCE_ROOT; };
-		00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask_Table.h; path = ../libsgl/effects/SkEmbossMask_Table.h; sourceTree = SOURCE_ROOT; };
-		00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMaskFilter.cpp; path = ../libsgl/effects/SkEmbossMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGradientShader.cpp; path = ../libsgl/effects/SkGradientShader.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkKernel33MaskFilter.cpp; path = ../libsgl/effects/SkKernel33MaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerDrawLooper.cpp; path = ../libsgl/effects/SkLayerDrawLooper.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerRasterizer.cpp; path = ../libsgl/effects/SkLayerRasterizer.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkNinePatch.cpp; path = ../libsgl/effects/SkNinePatch.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintFlagsDrawFilter.cpp; path = ../libsgl/effects/SkPaintFlagsDrawFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelXorXfermode.cpp; path = ../libsgl/effects/SkPixelXorXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProxyCanvas.cpp; path = ../libsgl/effects/SkProxyCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRadialGradient_Table.h; path = ../libsgl/effects/SkRadialGradient_Table.h; sourceTree = SOURCE_ROOT; };
-		00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShaderExtras.cpp; path = ../libsgl/effects/SkShaderExtras.cpp; sourceTree = SOURCE_ROOT; };
-		00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTransparentShader.cpp; path = ../libsgl/effects/SkTransparentShader.cpp; sourceTree = SOURCE_ROOT; };
-		00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnitMappers.cpp; path = ../libsgl/effects/SkUnitMappers.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBGViewArtist.cpp; path = ../libsgl/views/SkBGViewArtist.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBorderView.cpp; path = ../libsgl/views/SkBorderView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A30EE9CDFA0008420F /* SkEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEvent.cpp; path = ../libsgl/views/SkEvent.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEventSink.cpp; path = ../libsgl/views/SkEventSink.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A50EE9CDFA0008420F /* SkImageView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageView.cpp; path = ../libsgl/views/SkImageView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A60EE9CDFA0008420F /* SkListView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListView.cpp; path = ../libsgl/views/SkListView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListWidget.cpp; path = ../libsgl/views/SkListWidget.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMetaData.cpp; path = ../libsgl/views/SkMetaData.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile.cpp; path = ../libsgl/views/SkOSFile.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSMenu.cpp; path = ../libsgl/views/SkOSMenu.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSSound.cpp; path = ../libsgl/views/SkOSSound.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParsePaint.cpp; path = ../libsgl/views/SkParsePaint.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressBarView.cpp; path = ../libsgl/views/SkProgressBarView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressView.cpp; path = ../libsgl/views/SkProgressView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScrollBarView.cpp; path = ../libsgl/views/SkScrollBarView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStackViewLayout.cpp; path = ../libsgl/views/SkStackViewLayout.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B10EE9CDFA0008420F /* SkTagList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTagList.cpp; path = ../libsgl/views/SkTagList.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B20EE9CDFA0008420F /* SkTagList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTagList.h; path = ../libsgl/views/SkTagList.h; sourceTree = SOURCE_ROOT; };
-		00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextBox.cpp; path = ../libsgl/views/SkTextBox.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B40EE9CDFA0008420F /* SkView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkView.cpp; path = ../libsgl/views/SkView.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewInflate.cpp; path = ../libsgl/views/SkViewInflate.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewPriv.cpp; path = ../libsgl/views/SkViewPriv.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B70EE9CDFA0008420F /* SkViewPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkViewPriv.h; path = ../libsgl/views/SkViewPriv.h; sourceTree = SOURCE_ROOT; };
-		00BE42B80EE9CDFA0008420F /* SkWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidget.cpp; path = ../libsgl/views/SkWidget.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgets.cpp; path = ../libsgl/views/SkWidgets.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgetViews.cpp; path = ../libsgl/views/SkWidgetViews.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWindow.cpp; path = ../libsgl/views/SkWindow.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFDStream.cpp; path = ../libsgl/images/SkFDStream.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlipPixelRef.cpp; path = ../libsgl/images/SkFlipPixelRef.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder.cpp; path = ../libsgl/images/SkImageDecoder.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libbmp.cpp; path = ../libsgl/images/SkImageDecoder_libbmp.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libico.cpp; path = ../libsgl/images/SkImageDecoder_libico.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_wbmp.cpp; path = ../libsgl/images/SkImageDecoder_wbmp.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef.cpp; path = ../libsgl/images/SkImageRef.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef_GlobalPool.cpp; path = ../libsgl/images/SkImageRef_GlobalPool.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRefPool.cpp; path = ../libsgl/images/SkImageRefPool.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkImageRefPool.h; path = ../libsgl/images/SkImageRefPool.h; sourceTree = SOURCE_ROOT; };
-		00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMMapStream.cpp; path = ../libsgl/images/SkMMapStream.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../libsgl/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScaledBitmapSampler.cpp; path = ../libsgl/images/SkScaledBitmapSampler.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScaledBitmapSampler.h; path = ../libsgl/images/SkScaledBitmapSampler.h; sourceTree = SOURCE_ROOT; };
-		00BE42D10EE9CDFA0008420F /* SkStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStream.cpp; path = ../libsgl/images/SkStream.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_android.cpp; path = ../libsgl/ports/SkFontHost_android.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_gamma.cpp; path = ../libsgl/ports/SkFontHost_gamma.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals_global.cpp; path = ../libsgl/ports/SkGlobals_global.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_Factory.cpp; path = ../libsgl/ports/SkImageDecoder_Factory.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkThread_pthread.cpp; path = ../libsgl/ports/SkThread_pthread.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime_Unix.cpp; path = ../libsgl/ports/SkTime_Unix.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathHeap.cpp; path = ../libsgl/picture/SkPathHeap.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathHeap.h; path = ../libsgl/picture/SkPathHeap.h; sourceTree = SOURCE_ROOT; };
-		00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicture.cpp; path = ../libsgl/picture/SkPicture.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureFlat.cpp; path = ../libsgl/picture/SkPictureFlat.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureFlat.h; path = ../libsgl/picture/SkPictureFlat.h; sourceTree = SOURCE_ROOT; };
-		00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicturePlayback.cpp; path = ../libsgl/picture/SkPicturePlayback.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPicturePlayback.h; path = ../libsgl/picture/SkPicturePlayback.h; sourceTree = SOURCE_ROOT; };
-		00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureRecord.cpp; path = ../libsgl/picture/SkPictureRecord.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureRecord.h; path = ../libsgl/picture/SkPictureRecord.h; sourceTree = SOURCE_ROOT; };
-		00BE42E30EE9CDFA0008420F /* SkGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGL.cpp; path = ../libsgl/gl/SkGL.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E40EE9CDFA0008420F /* SkGL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGL.h; path = ../libsgl/gl/SkGL.h; sourceTree = SOURCE_ROOT; };
-		00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLCanvas.cpp; path = ../libsgl/gl/SkGLCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice.cpp; path = ../libsgl/gl/SkGLDevice.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E70EE9CDFA0008420F /* SkGLDevice.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice.h; path = ../libsgl/gl/SkGLDevice.h; sourceTree = SOURCE_ROOT; };
-		00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_FBO.cpp; path = ../libsgl/gl/SkGLDevice_FBO.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_FBO.h; path = ../libsgl/gl/SkGLDevice_FBO.h; sourceTree = SOURCE_ROOT; };
-		00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_SWLayer.cpp; path = ../libsgl/gl/SkGLDevice_SWLayer.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_SWLayer.h; path = ../libsgl/gl/SkGLDevice_SWLayer.h; sourceTree = SOURCE_ROOT; };
-		00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLTextCache.cpp; path = ../libsgl/gl/SkGLTextCache.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLTextCache.h; path = ../libsgl/gl/SkGLTextCache.h; sourceTree = SOURCE_ROOT; };
-		00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextureCache.cpp; path = ../libsgl/gl/SkTextureCache.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextureCache.h; path = ../libsgl/gl/SkTextureCache.h; sourceTree = SOURCE_ROOT; };
-		00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAlphaRuns.cpp; path = ../libsgl/sgl/SkAlphaRuns.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42F10EE9CDFA0008420F /* SkAntiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAntiRun.h; path = ../libsgl/sgl/SkAntiRun.h; sourceTree = SOURCE_ROOT; };
-		00BE42F20EE9CDFA0008420F /* SkAutoKern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAutoKern.h; path = ../libsgl/sgl/SkAutoKern.h; sourceTree = SOURCE_ROOT; };
-		00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap.cpp; path = ../libsgl/sgl/SkBitmap.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_scroll.cpp; path = ../libsgl/sgl/SkBitmap_scroll.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcShader.cpp; path = ../libsgl/sgl/SkBitmapProcShader.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcShader.h; path = ../libsgl/sgl/SkBitmapProcShader.h; sourceTree = SOURCE_ROOT; };
-		00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState.cpp; path = ../libsgl/sgl/SkBitmapProcState.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState.h; path = ../libsgl/sgl/SkBitmapProcState.h; sourceTree = SOURCE_ROOT; };
-		00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_matrix.h; path = ../libsgl/sgl/SkBitmapProcState_matrix.h; sourceTree = SOURCE_ROOT; };
-		00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState_matrixProcs.cpp; path = ../libsgl/sgl/SkBitmapProcState_matrixProcs.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_sample.h; path = ../libsgl/sgl/SkBitmapProcState_sample.h; sourceTree = SOURCE_ROOT; };
-		00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapSampler.cpp; path = ../libsgl/sgl/SkBitmapSampler.cpp; sourceTree = SOURCE_ROOT; };
-		00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSampler.h; path = ../libsgl/sgl/SkBitmapSampler.h; sourceTree = SOURCE_ROOT; };
-		00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSamplerTemplate.h; path = ../libsgl/sgl/SkBitmapSamplerTemplate.h; sourceTree = SOURCE_ROOT; };
-		00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapShader.cpp; path = ../libsgl/sgl/SkBitmapShader.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43000EE9CDFA0008420F /* SkBitmapShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader.h; path = ../libsgl/sgl/SkBitmapShader.h; sourceTree = SOURCE_ROOT; };
-		00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader16BilerpTemplate.h; path = ../libsgl/sgl/SkBitmapShader16BilerpTemplate.h; sourceTree = SOURCE_ROOT; };
-		00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShaderTemplate.h; path = ../libsgl/sgl/SkBitmapShaderTemplate.h; sourceTree = SOURCE_ROOT; };
-		00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitBWMaskTemplate.h; path = ../libsgl/sgl/SkBlitBWMaskTemplate.h; sourceTree = SOURCE_ROOT; };
-		00BE43040EE9CDFA0008420F /* SkBlitRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitRow.h; path = ../libsgl/sgl/SkBlitRow.h; sourceTree = SOURCE_ROOT; };
-		00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D16.cpp; path = ../libsgl/sgl/SkBlitRow_D16.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D4444.cpp; path = ../libsgl/sgl/SkBlitRow_D4444.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43070EE9CDFA0008420F /* SkBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter.cpp; path = ../libsgl/sgl/SkBlitter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43080EE9CDFA0008420F /* SkBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitter.h; path = ../libsgl/sgl/SkBlitter.h; sourceTree = SOURCE_ROOT; };
-		00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_4444.cpp; path = ../libsgl/sgl/SkBlitter_4444.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A1.cpp; path = ../libsgl/sgl/SkBlitter_A1.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A8.cpp; path = ../libsgl/sgl/SkBlitter_A8.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_RGB16.cpp; path = ../libsgl/sgl/SkBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_Sprite.cpp; path = ../libsgl/sgl/SkBlitter_Sprite.cpp; sourceTree = SOURCE_ROOT; };
-		00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCanvas.cpp; path = ../libsgl/sgl/SkCanvas.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43100EE9CDFA0008420F /* SkColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColor.cpp; path = ../libsgl/sgl/SkColor.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilter.cpp; path = ../libsgl/sgl/SkColorFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43120EE9CDFA0008420F /* SkColorTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorTable.cpp; path = ../libsgl/sgl/SkColorTable.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCoreBlitters.h; path = ../libsgl/sgl/SkCoreBlitters.h; sourceTree = SOURCE_ROOT; };
-		00BE43140EE9CDFA0008420F /* SkDeque.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDeque.cpp; path = ../libsgl/sgl/SkDeque.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43150EE9CDFA0008420F /* SkDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDevice.cpp; path = ../libsgl/sgl/SkDevice.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43160EE9CDFA0008420F /* SkDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDither.cpp; path = ../libsgl/sgl/SkDither.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43170EE9CDFA0008420F /* SkDraw.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw.cpp; path = ../libsgl/sgl/SkDraw.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43180EE9CDFA0008420F /* SkDrawProcs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawProcs.h; path = ../libsgl/sgl/SkDrawProcs.h; sourceTree = SOURCE_ROOT; };
-		00BE43190EE9CDFA0008420F /* SkEdge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEdge.cpp; path = ../libsgl/sgl/SkEdge.cpp; sourceTree = SOURCE_ROOT; };
-		00BE431A0EE9CDFA0008420F /* SkEdge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEdge.h; path = ../libsgl/sgl/SkEdge.h; sourceTree = SOURCE_ROOT; };
-		00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFilterProc.cpp; path = ../libsgl/sgl/SkFilterProc.cpp; sourceTree = SOURCE_ROOT; };
-		00BE431C0EE9CDFA0008420F /* SkFilterProc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFilterProc.h; path = ../libsgl/sgl/SkFilterProc.h; sourceTree = SOURCE_ROOT; };
-		00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlattenable.cpp; path = ../libsgl/sgl/SkFlattenable.cpp; sourceTree = SOURCE_ROOT; };
-		00BE431E0EE9CDFA0008420F /* SkFP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFP.h; path = ../libsgl/sgl/SkFP.h; sourceTree = SOURCE_ROOT; };
-		00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGeometry.cpp; path = ../libsgl/sgl/SkGeometry.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43200EE9CDFA0008420F /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; };
-		00BE43210EE9CDFA0008420F /* SkGlobals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals.cpp; path = ../libsgl/sgl/SkGlobals.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlyphCache.cpp; path = ../libsgl/sgl/SkGlyphCache.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43230EE9CDFA0008420F /* SkGlyphCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGlyphCache.h; path = ../libsgl/sgl/SkGlyphCache.h; sourceTree = SOURCE_ROOT; };
-		00BE43240EE9CDFA0008420F /* SkGraphics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGraphics.cpp; path = ../libsgl/sgl/SkGraphics.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43250EE9CDFA0008420F /* SkMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMask.cpp; path = ../libsgl/sgl/SkMask.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMaskFilter.cpp; path = ../libsgl/sgl/SkMaskFilter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43270EE9CDFA0008420F /* SkPackBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPackBits.cpp; path = ../libsgl/sgl/SkPackBits.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43280EE9CDFA0008420F /* SkPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaint.cpp; path = ../libsgl/sgl/SkPaint.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43290EE9CDFA0008420F /* SkPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPath.cpp; path = ../libsgl/sgl/SkPath.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathEffect.cpp; path = ../libsgl/sgl/SkPathEffect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathMeasure.cpp; path = ../libsgl/sgl/SkPathMeasure.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelRef.cpp; path = ../libsgl/sgl/SkPixelRef.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProcSpriteBlitter.cpp; path = ../libsgl/sgl/SkProcSpriteBlitter.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPtrRecorder.cpp; path = ../libsgl/sgl/SkPtrRecorder.cpp; sourceTree = SOURCE_ROOT; };
-		00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRasterizer.cpp; path = ../libsgl/sgl/SkRasterizer.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRefCnt.cpp; path = ../libsgl/sgl/SkRefCnt.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion_path.cpp; path = ../libsgl/sgl/SkRegion_path.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScalerContext.cpp; path = ../libsgl/sgl/SkScalerContext.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43330EE9CDFA0008420F /* SkScan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan.cpp; path = ../libsgl/sgl/SkScan.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43340EE9CDFA0008420F /* SkScan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScan.h; path = ../libsgl/sgl/SkScan.h; sourceTree = SOURCE_ROOT; };
-		00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Antihair.cpp; path = ../libsgl/sgl/SkScan_Antihair.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_AntiPath.cpp; path = ../libsgl/sgl/SkScan_AntiPath.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Hairline.cpp; path = ../libsgl/sgl/SkScan_Hairline.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Path.cpp; path = ../libsgl/sgl/SkScan_Path.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43390EE9CDFA0008420F /* SkScanPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScanPriv.h; path = ../libsgl/sgl/SkScanPriv.h; sourceTree = SOURCE_ROOT; };
-		00BE433A0EE9CDFA0008420F /* SkShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShader.cpp; path = ../libsgl/sgl/SkShader.cpp; sourceTree = SOURCE_ROOT; };
-		00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitter.h; path = ../libsgl/sgl/SkSpriteBlitter.h; sourceTree = SOURCE_ROOT; };
-		00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkSpriteBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; };
-		00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_RGB16.cpp; path = ../libsgl/sgl/SkSpriteBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; };
-		00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitterTemplate.h; path = ../libsgl/sgl/SkSpriteBlitterTemplate.h; sourceTree = SOURCE_ROOT; };
-		00BE43400EE9CDFA0008420F /* SkStroke.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStroke.cpp; path = ../libsgl/sgl/SkStroke.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStrokerPriv.cpp; path = ../libsgl/sgl/SkStrokerPriv.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkStrokerPriv.h; path = ../libsgl/sgl/SkStrokerPriv.h; sourceTree = SOURCE_ROOT; };
-		00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTemplatesPriv.h; path = ../libsgl/sgl/SkTemplatesPriv.h; sourceTree = SOURCE_ROOT; };
-		00BE43440EE9CDFA0008420F /* SkTSearch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTSearch.cpp; path = ../libsgl/sgl/SkTSearch.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43450EE9CDFA0008420F /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libsgl/sgl/SkTSort.h; sourceTree = SOURCE_ROOT; };
-		00BE43460EE9CDFA0008420F /* SkTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypeface.cpp; path = ../libsgl/sgl/SkTypeface.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnPreMultiply.cpp; path = ../libsgl/sgl/SkUnPreMultiply.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43490EE9CDFA0008420F /* SkWriter32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWriter32.cpp; path = ../libsgl/sgl/SkWriter32.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXfermode.cpp; path = ../libsgl/sgl/SkXfermode.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434B0EE9CDFA0008420F /* Sk64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk64.cpp; path = ../libcorecg/Sk64.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBuffer.cpp; path = ../libcorecg/SkBuffer.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkChunkAlloc.cpp; path = ../libcorecg/SkChunkAlloc.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434E0EE9CDFA0008420F /* SkCordic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCordic.cpp; path = ../libcorecg/SkCordic.cpp; sourceTree = SOURCE_ROOT; };
-		00BE434F0EE9CDFA0008420F /* SkCordic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCordic.h; path = ../libcorecg/SkCordic.h; sourceTree = SOURCE_ROOT; };
-		00BE43500EE9CDFA0008420F /* SkDebug.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug.cpp; path = ../libcorecg/SkDebug.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug_stdio.cpp; path = ../libcorecg/SkDebug_stdio.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43520EE9CDFA0008420F /* SkFloat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloat.cpp; path = ../libcorecg/SkFloat.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43530EE9CDFA0008420F /* SkFloat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFloat.h; path = ../libcorecg/SkFloat.h; sourceTree = SOURCE_ROOT; };
-		00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloatBits.cpp; path = ../libcorecg/SkFloatBits.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkInterpolator.cpp; path = ../libcorecg/SkInterpolator.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43560EE9CDFA0008420F /* SkMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMath.cpp; path = ../libcorecg/SkMath.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43570EE9CDFA0008420F /* SkMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrix.cpp; path = ../libcorecg/SkMatrix.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemory_stdlib.cpp; path = ../libcorecg/SkMemory_stdlib.cpp; sourceTree = SOURCE_ROOT; };
-		00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPageFlipper.cpp; path = ../libcorecg/SkPageFlipper.cpp; sourceTree = SOURCE_ROOT; };
-		00BE435A0EE9CDFA0008420F /* SkPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPoint.cpp; path = ../libcorecg/SkPoint.cpp; sourceTree = SOURCE_ROOT; };
-		00BE435B0EE9CDFA0008420F /* SkRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRect.cpp; path = ../libcorecg/SkRect.cpp; sourceTree = SOURCE_ROOT; };
-		00BE435C0EE9CDFA0008420F /* SkRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion.cpp; path = ../libcorecg/SkRegion.cpp; sourceTree = SOURCE_ROOT; };
-		00BE444D0EE9D1780008420F /* giflib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = giflib.xcodeproj; sourceTree = "<group>"; };
-		00BE44560EE9D1780008420F /* jpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = jpeg.xcodeproj; sourceTree = "<group>"; };
-		00BE44590EE9D1780008420F /* libpng.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = libpng.xcodeproj; sourceTree = "<group>"; };
-		00BE445C0EE9D1780008420F /* zlib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = zlib.xcodeproj; sourceTree = "<group>"; };
-		00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile_stdio.cpp; path = ../libsgl/ports/SkOSFile_stdio.cpp; sourceTree = SOURCE_ROOT; };
-		00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bmpdecoderhelper.cpp; path = ../libsgl/images/bmpdecoderhelper.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libskia2.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libskia2.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00BE44D40EE9D5660008420F /* libjpeg.a in Frameworks */,
-				00BE44D50EE9D5670008420F /* liblibpng.a in Frameworks */,
-				00BE44D60EE9D5690008420F /* libzlib.a in Frameworks */,
-				00A567300EED6F6E0096A2A1 /* libgiflib.a in Frameworks */,
-				003E926F0EED78220091D85B /* libfreetype.a in Frameworks */,
-				00AFCE240EF16C0500BD2FF1 /* libexpat.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		00A567690EED77850096A2A1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00A5676D0EED77850096A2A1 /* libfreetype.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00AFCD780EF167A300BD2FF1 /* xml */ = {
-			isa = PBXGroup;
-			children = (
-				00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */,
-				00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */,
-				00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */,
-				00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */,
-			);
-			name = xml;
-			sourceTree = "<group>";
-		};
-		00AFCE0E0EF16BA400BD2FF1 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00AFCE150EF16BA400BD2FF1 /* libexpat.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00BE427F0EE9CDFA0008420F /* effects */ = {
-			isa = PBXGroup;
-			children = (
-				00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */,
-				00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */,
-				00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */,
-				00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */,
-				00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */,
-				00BE42850EE9CDFA0008420F /* SkBlurMask.h */,
-				00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */,
-				00BE42870EE9CDFA0008420F /* SkCamera.cpp */,
-				00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */,
-				00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */,
-				00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */,
-				00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */,
-				00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */,
-				00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */,
-				00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */,
-				00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */,
-				00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */,
-				00BE42910EE9CDFA0008420F /* SkEmbossMask.h */,
-				00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */,
-				00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */,
-				00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */,
-				00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */,
-				00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */,
-				00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */,
-				00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */,
-				00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */,
-				00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */,
-				00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */,
-				00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */,
-				00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */,
-				00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */,
-				00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */,
-			);
-			name = effects;
-			sourceTree = "<group>";
-		};
-		00BE42A00EE9CDFA0008420F /* view */ = {
-			isa = PBXGroup;
-			children = (
-				00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */,
-				00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */,
-				00BE42A30EE9CDFA0008420F /* SkEvent.cpp */,
-				00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */,
-				00BE42A50EE9CDFA0008420F /* SkImageView.cpp */,
-				00BE42A60EE9CDFA0008420F /* SkListView.cpp */,
-				00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */,
-				00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */,
-				00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */,
-				00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */,
-				00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */,
-				00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */,
-				00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */,
-				00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */,
-				00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */,
-				00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */,
-				00BE42B10EE9CDFA0008420F /* SkTagList.cpp */,
-				00BE42B20EE9CDFA0008420F /* SkTagList.h */,
-				00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */,
-				00BE42B40EE9CDFA0008420F /* SkView.cpp */,
-				00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */,
-				00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */,
-				00BE42B70EE9CDFA0008420F /* SkViewPriv.h */,
-				00BE42B80EE9CDFA0008420F /* SkWidget.cpp */,
-				00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */,
-				00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */,
-				00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */,
-			);
-			name = view;
-			sourceTree = "<group>";
-		};
-		00BE42BC0EE9CDFA0008420F /* image */ = {
-			isa = PBXGroup;
-			children = (
-				00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */,
-				00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */,
-				00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */,
-				00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */,
-				00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */,
-				00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */,
-				00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */,
-				00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */,
-				00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */,
-				00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */,
-				00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */,
-				00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */,
-				00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */,
-				00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */,
-				00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */,
-				00BE42D10EE9CDFA0008420F /* SkStream.cpp */,
-			);
-			name = image;
-			sourceTree = "<group>";
-		};
-		00BE42D20EE9CDFA0008420F /* port */ = {
-			isa = PBXGroup;
-			children = (
-				00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */,
-				00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */,
-				00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */,
-				00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */,
-				00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */,
-				00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */,
-				00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */,
-				00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */,
-				00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */,
-			);
-			name = port;
-			sourceTree = "<group>";
-		};
-		00BE42D90EE9CDFA0008420F /* core */ = {
-			isa = PBXGroup;
-			children = (
-				006B43FC0EF7526E00F15BC4 /* SkString.cpp */,
-				006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */,
-				00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */,
-				00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */,
-				00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */,
-				00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */,
-				00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */,
-				00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */,
-				00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */,
-				00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */,
-				00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */,
-				00BE42E30EE9CDFA0008420F /* SkGL.cpp */,
-				00BE42E40EE9CDFA0008420F /* SkGL.h */,
-				00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */,
-				00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */,
-				00BE42E70EE9CDFA0008420F /* SkGLDevice.h */,
-				00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */,
-				00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */,
-				00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */,
-				00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */,
-				00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */,
-				00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */,
-				00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */,
-				00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */,
-				00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */,
-				00BE42F10EE9CDFA0008420F /* SkAntiRun.h */,
-				00BE42F20EE9CDFA0008420F /* SkAutoKern.h */,
-				00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */,
-				00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */,
-				00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */,
-				00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */,
-				00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */,
-				00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */,
-				00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */,
-				00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */,
-				00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */,
-				00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */,
-				00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */,
-				00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */,
-				00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */,
-				00BE43000EE9CDFA0008420F /* SkBitmapShader.h */,
-				00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */,
-				00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */,
-				00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */,
-				00BE43040EE9CDFA0008420F /* SkBlitRow.h */,
-				00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */,
-				00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */,
-				00BE43070EE9CDFA0008420F /* SkBlitter.cpp */,
-				00BE43080EE9CDFA0008420F /* SkBlitter.h */,
-				00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */,
-				00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */,
-				00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */,
-				00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */,
-				00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */,
-				00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */,
-				00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */,
-				00BE43100EE9CDFA0008420F /* SkColor.cpp */,
-				00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */,
-				00BE43120EE9CDFA0008420F /* SkColorTable.cpp */,
-				00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */,
-				00BE43140EE9CDFA0008420F /* SkDeque.cpp */,
-				00BE43150EE9CDFA0008420F /* SkDevice.cpp */,
-				00BE43160EE9CDFA0008420F /* SkDither.cpp */,
-				00BE43170EE9CDFA0008420F /* SkDraw.cpp */,
-				00BE43180EE9CDFA0008420F /* SkDrawProcs.h */,
-				00BE43190EE9CDFA0008420F /* SkEdge.cpp */,
-				00BE431A0EE9CDFA0008420F /* SkEdge.h */,
-				00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */,
-				00BE431C0EE9CDFA0008420F /* SkFilterProc.h */,
-				00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */,
-				00BE431E0EE9CDFA0008420F /* SkFP.h */,
-				00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */,
-				00BE43200EE9CDFA0008420F /* SkGeometry.h */,
-				00BE43210EE9CDFA0008420F /* SkGlobals.cpp */,
-				00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */,
-				00BE43230EE9CDFA0008420F /* SkGlyphCache.h */,
-				00BE43240EE9CDFA0008420F /* SkGraphics.cpp */,
-				00BE43250EE9CDFA0008420F /* SkMask.cpp */,
-				00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */,
-				00BE43270EE9CDFA0008420F /* SkPackBits.cpp */,
-				00BE43280EE9CDFA0008420F /* SkPaint.cpp */,
-				00BE43290EE9CDFA0008420F /* SkPath.cpp */,
-				00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */,
-				00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */,
-				00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */,
-				00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */,
-				00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */,
-				00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */,
-				00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */,
-				00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */,
-				00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */,
-				00BE43330EE9CDFA0008420F /* SkScan.cpp */,
-				00BE43340EE9CDFA0008420F /* SkScan.h */,
-				00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */,
-				00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */,
-				00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */,
-				00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */,
-				00BE43390EE9CDFA0008420F /* SkScanPriv.h */,
-				00BE433A0EE9CDFA0008420F /* SkShader.cpp */,
-				00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */,
-				00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */,
-				00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */,
-				00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */,
-				00BE43400EE9CDFA0008420F /* SkStroke.cpp */,
-				00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */,
-				00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */,
-				00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */,
-				00BE43440EE9CDFA0008420F /* SkTSearch.cpp */,
-				00BE43450EE9CDFA0008420F /* SkTSort.h */,
-				00BE43460EE9CDFA0008420F /* SkTypeface.cpp */,
-				00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */,
-				00BE43490EE9CDFA0008420F /* SkWriter32.cpp */,
-				00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */,
-				00BE434B0EE9CDFA0008420F /* Sk64.cpp */,
-				00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */,
-				00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */,
-				00BE434E0EE9CDFA0008420F /* SkCordic.cpp */,
-				00BE434F0EE9CDFA0008420F /* SkCordic.h */,
-				00BE43500EE9CDFA0008420F /* SkDebug.cpp */,
-				00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */,
-				00BE43520EE9CDFA0008420F /* SkFloat.cpp */,
-				00BE43530EE9CDFA0008420F /* SkFloat.h */,
-				00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */,
-				00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */,
-				00BE43560EE9CDFA0008420F /* SkMath.cpp */,
-				00BE43570EE9CDFA0008420F /* SkMatrix.cpp */,
-				00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */,
-				00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */,
-				00BE435A0EE9CDFA0008420F /* SkPoint.cpp */,
-				00BE435B0EE9CDFA0008420F /* SkRect.cpp */,
-				00BE435C0EE9CDFA0008420F /* SkRegion.cpp */,
-			);
-			name = core;
-			sourceTree = "<group>";
-		};
-		00BE444E0EE9D1780008420F /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00BE44670EE9D1780008420F /* libgiflib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00BE44570EE9D1780008420F /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00BE446A0EE9D1780008420F /* libjpeg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00BE445A0EE9D1780008420F /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00BE446D0EE9D1780008420F /* liblibpng.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		00BE445D0EE9D1780008420F /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				00BE44700EE9D1780008420F /* libzlib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		08FB7794FE84155DC02AAC07 /* skia2 */ = {
-			isa = PBXGroup;
-			children = (
-				00AFCD780EF167A300BD2FF1 /* xml */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-				00BE42D90EE9CDFA0008420F /* core */,
-				00BE42D20EE9CDFA0008420F /* port */,
-				00BE42BC0EE9CDFA0008420F /* image */,
-				00BE42A00EE9CDFA0008420F /* view */,
-				00BE427F0EE9CDFA0008420F /* effects */,
-				00BE444D0EE9D1780008420F /* giflib.xcodeproj */,
-				00BE44560EE9D1780008420F /* jpeg.xcodeproj */,
-				00BE44590EE9D1780008420F /* libpng.xcodeproj */,
-				00BE445C0EE9D1780008420F /* zlib.xcodeproj */,
-				00A567680EED77850096A2A1 /* freetype2.xcodeproj */,
-				00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */,
-			);
-			name = skia2;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libskia2.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00BE43620EE9CDFA0008420F /* SkBlurMask.h in Headers */,
-				00BE436E0EE9CDFA0008420F /* SkEmbossMask.h in Headers */,
-				00BE436F0EE9CDFA0008420F /* SkEmbossMask_Table.h in Headers */,
-				00BE43790EE9CDFA0008420F /* SkRadialGradient_Table.h in Headers */,
-				00BE438E0EE9CDFA0008420F /* SkTagList.h in Headers */,
-				00BE43930EE9CDFA0008420F /* SkViewPriv.h in Headers */,
-				00BE43A60EE9CDFA0008420F /* SkImageRefPool.h in Headers */,
-				00BE43AB0EE9CDFA0008420F /* SkScaledBitmapSampler.h in Headers */,
-				00BE43B40EE9CDFA0008420F /* SkPathHeap.h in Headers */,
-				00BE43B70EE9CDFA0008420F /* SkPictureFlat.h in Headers */,
-				00BE43B90EE9CDFA0008420F /* SkPicturePlayback.h in Headers */,
-				00BE43BB0EE9CDFA0008420F /* SkPictureRecord.h in Headers */,
-				00BE43BD0EE9CDFA0008420F /* SkGL.h in Headers */,
-				00BE43C00EE9CDFA0008420F /* SkGLDevice.h in Headers */,
-				00BE43C20EE9CDFA0008420F /* SkGLDevice_FBO.h in Headers */,
-				00BE43C40EE9CDFA0008420F /* SkGLDevice_SWLayer.h in Headers */,
-				00BE43C60EE9CDFA0008420F /* SkGLTextCache.h in Headers */,
-				00BE43C80EE9CDFA0008420F /* SkTextureCache.h in Headers */,
-				00BE43CA0EE9CDFA0008420F /* SkAntiRun.h in Headers */,
-				00BE43CB0EE9CDFA0008420F /* SkAutoKern.h in Headers */,
-				00BE43CF0EE9CDFA0008420F /* SkBitmapProcShader.h in Headers */,
-				00BE43D10EE9CDFA0008420F /* SkBitmapProcState.h in Headers */,
-				00BE43D20EE9CDFA0008420F /* SkBitmapProcState_matrix.h in Headers */,
-				00BE43D40EE9CDFA0008420F /* SkBitmapProcState_sample.h in Headers */,
-				00BE43D60EE9CDFA0008420F /* SkBitmapSampler.h in Headers */,
-				00BE43D70EE9CDFA0008420F /* SkBitmapSamplerTemplate.h in Headers */,
-				00BE43D90EE9CDFA0008420F /* SkBitmapShader.h in Headers */,
-				00BE43DA0EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h in Headers */,
-				00BE43DB0EE9CDFA0008420F /* SkBitmapShaderTemplate.h in Headers */,
-				00BE43DC0EE9CDFA0008420F /* SkBlitBWMaskTemplate.h in Headers */,
-				00BE43DD0EE9CDFA0008420F /* SkBlitRow.h in Headers */,
-				00BE43E10EE9CDFA0008420F /* SkBlitter.h in Headers */,
-				00BE43EC0EE9CDFA0008420F /* SkCoreBlitters.h in Headers */,
-				00BE43F10EE9CDFA0008420F /* SkDrawProcs.h in Headers */,
-				00BE43F30EE9CDFA0008420F /* SkEdge.h in Headers */,
-				00BE43F50EE9CDFA0008420F /* SkFilterProc.h in Headers */,
-				00BE43F70EE9CDFA0008420F /* SkFP.h in Headers */,
-				00BE43F90EE9CDFA0008420F /* SkGeometry.h in Headers */,
-				00BE43FC0EE9CDFA0008420F /* SkGlyphCache.h in Headers */,
-				00BE440D0EE9CDFA0008420F /* SkScan.h in Headers */,
-				00BE44120EE9CDFA0008420F /* SkScanPriv.h in Headers */,
-				00BE44140EE9CDFA0008420F /* SkSpriteBlitter.h in Headers */,
-				00BE44170EE9CDFA0008420F /* SkSpriteBlitterTemplate.h in Headers */,
-				00BE441B0EE9CDFA0008420F /* SkStrokerPriv.h in Headers */,
-				00BE441C0EE9CDFA0008420F /* SkTemplatesPriv.h in Headers */,
-				00BE441E0EE9CDFA0008420F /* SkTSort.h in Headers */,
-				00BE44280EE9CDFA0008420F /* SkCordic.h in Headers */,
-				00BE442C0EE9CDFA0008420F /* SkFloat.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* skia2 */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "skia2" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				00BE44F10EE9D70D0008420F /* PBXTargetDependency */,
-				00BE44F50EE9D70D0008420F /* PBXTargetDependency */,
-				00BE44F70EE9D70D0008420F /* PBXTargetDependency */,
-				003E929B0EED79240091D85B /* PBXTargetDependency */,
-				003E92DA0EED7C3B0091D85B /* PBXTargetDependency */,
-				00AFCE180EF16BBB00BD2FF1 /* PBXTargetDependency */,
-			);
-			name = skia2;
-			productName = skia2;
-			productReference = D2AAC046055464E500DB518D /* libskia2.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "skia2" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* skia2 */;
-			projectDirPath = "";
-			projectReferences = (
-				{
-					ProductGroup = 00AFCE0E0EF16BA400BD2FF1 /* Products */;
-					ProjectRef = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */;
-				},
-				{
-					ProductGroup = 00A567690EED77850096A2A1 /* Products */;
-					ProjectRef = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */;
-				},
-				{
-					ProductGroup = 00BE444E0EE9D1780008420F /* Products */;
-					ProjectRef = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */;
-				},
-				{
-					ProductGroup = 00BE44570EE9D1780008420F /* Products */;
-					ProjectRef = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */;
-				},
-				{
-					ProductGroup = 00BE445A0EE9D1780008420F /* Products */;
-					ProjectRef = 00BE44590EE9D1780008420F /* libpng.xcodeproj */;
-				},
-				{
-					ProductGroup = 00BE445D0EE9D1780008420F /* Products */;
-					ProjectRef = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */;
-				},
-			);
-			projectRoot = "";
-			targets = (
-				D2AAC045055464E500DB518D /* skia2 */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXReferenceProxy section */
-		00A5676D0EED77850096A2A1 /* libfreetype.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libfreetype.a;
-			remoteRef = 00A5676C0EED77850096A2A1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00AFCE150EF16BA400BD2FF1 /* libexpat.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libexpat.a;
-			remoteRef = 00AFCE140EF16BA400BD2FF1 /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00BE44670EE9D1780008420F /* libgiflib.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libgiflib.a;
-			remoteRef = 00BE44660EE9D1780008420F /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00BE446A0EE9D1780008420F /* libjpeg.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libjpeg.a;
-			remoteRef = 00BE44690EE9D1780008420F /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00BE446D0EE9D1780008420F /* liblibpng.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = liblibpng.a;
-			remoteRef = 00BE446C0EE9D1780008420F /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-		00BE44700EE9D1780008420F /* libzlib.a */ = {
-			isa = PBXReferenceProxy;
-			fileType = archive.ar;
-			path = libzlib.a;
-			remoteRef = 00BE446F0EE9D1780008420F /* PBXContainerItemProxy */;
-			sourceTree = BUILT_PRODUCTS_DIR;
-		};
-/* End PBXReferenceProxy section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00BE435D0EE9CDFA0008420F /* Sk1DPathEffect.cpp in Sources */,
-				00BE435E0EE9CDFA0008420F /* Sk2DPathEffect.cpp in Sources */,
-				00BE435F0EE9CDFA0008420F /* SkAvoidXfermode.cpp in Sources */,
-				00BE43600EE9CDFA0008420F /* SkBlurDrawLooper.cpp in Sources */,
-				00BE43610EE9CDFA0008420F /* SkBlurMask.cpp in Sources */,
-				00BE43630EE9CDFA0008420F /* SkBlurMaskFilter.cpp in Sources */,
-				00BE43640EE9CDFA0008420F /* SkCamera.cpp in Sources */,
-				00BE43650EE9CDFA0008420F /* SkColorFilters.cpp in Sources */,
-				00BE43660EE9CDFA0008420F /* SkColorMatrix.cpp in Sources */,
-				00BE43670EE9CDFA0008420F /* SkColorMatrixFilter.cpp in Sources */,
-				00BE43680EE9CDFA0008420F /* SkCornerPathEffect.cpp in Sources */,
-				00BE43690EE9CDFA0008420F /* SkCullPoints.cpp in Sources */,
-				00BE436A0EE9CDFA0008420F /* SkDashPathEffect.cpp in Sources */,
-				00BE436B0EE9CDFA0008420F /* SkDiscretePathEffect.cpp in Sources */,
-				00BE436C0EE9CDFA0008420F /* SkDumpCanvas.cpp in Sources */,
-				00BE436D0EE9CDFA0008420F /* SkEmbossMask.cpp in Sources */,
-				00BE43700EE9CDFA0008420F /* SkEmbossMaskFilter.cpp in Sources */,
-				00BE43710EE9CDFA0008420F /* SkGradientShader.cpp in Sources */,
-				00BE43720EE9CDFA0008420F /* SkKernel33MaskFilter.cpp in Sources */,
-				00BE43730EE9CDFA0008420F /* SkLayerDrawLooper.cpp in Sources */,
-				00BE43740EE9CDFA0008420F /* SkLayerRasterizer.cpp in Sources */,
-				00BE43750EE9CDFA0008420F /* SkNinePatch.cpp in Sources */,
-				00BE43760EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp in Sources */,
-				00BE43770EE9CDFA0008420F /* SkPixelXorXfermode.cpp in Sources */,
-				00BE43780EE9CDFA0008420F /* SkProxyCanvas.cpp in Sources */,
-				00BE437A0EE9CDFA0008420F /* SkShaderExtras.cpp in Sources */,
-				00BE437B0EE9CDFA0008420F /* SkTransparentShader.cpp in Sources */,
-				00BE437C0EE9CDFA0008420F /* SkUnitMappers.cpp in Sources */,
-				00BE437D0EE9CDFA0008420F /* SkBGViewArtist.cpp in Sources */,
-				00BE437E0EE9CDFA0008420F /* SkBorderView.cpp in Sources */,
-				00BE437F0EE9CDFA0008420F /* SkEvent.cpp in Sources */,
-				00BE43800EE9CDFA0008420F /* SkEventSink.cpp in Sources */,
-				00BE43810EE9CDFA0008420F /* SkImageView.cpp in Sources */,
-				00BE43820EE9CDFA0008420F /* SkListView.cpp in Sources */,
-				00BE43830EE9CDFA0008420F /* SkListWidget.cpp in Sources */,
-				00BE43840EE9CDFA0008420F /* SkMetaData.cpp in Sources */,
-				00BE43850EE9CDFA0008420F /* SkOSFile.cpp in Sources */,
-				00BE43860EE9CDFA0008420F /* SkOSMenu.cpp in Sources */,
-				00BE43870EE9CDFA0008420F /* SkOSSound.cpp in Sources */,
-				00BE43880EE9CDFA0008420F /* SkParsePaint.cpp in Sources */,
-				00BE43890EE9CDFA0008420F /* SkProgressBarView.cpp in Sources */,
-				00BE438A0EE9CDFA0008420F /* SkProgressView.cpp in Sources */,
-				00BE438B0EE9CDFA0008420F /* SkScrollBarView.cpp in Sources */,
-				00BE438C0EE9CDFA0008420F /* SkStackViewLayout.cpp in Sources */,
-				00BE438D0EE9CDFA0008420F /* SkTagList.cpp in Sources */,
-				00BE438F0EE9CDFA0008420F /* SkTextBox.cpp in Sources */,
-				00BE43900EE9CDFA0008420F /* SkView.cpp in Sources */,
-				00BE43910EE9CDFA0008420F /* SkViewInflate.cpp in Sources */,
-				00BE43920EE9CDFA0008420F /* SkViewPriv.cpp in Sources */,
-				00BE43940EE9CDFA0008420F /* SkWidget.cpp in Sources */,
-				00BE43950EE9CDFA0008420F /* SkWidgets.cpp in Sources */,
-				00BE43960EE9CDFA0008420F /* SkWidgetViews.cpp in Sources */,
-				00BE43970EE9CDFA0008420F /* SkWindow.cpp in Sources */,
-				00BE43980EE9CDFA0008420F /* SkFDStream.cpp in Sources */,
-				00BE43990EE9CDFA0008420F /* SkFlipPixelRef.cpp in Sources */,
-				00BE439A0EE9CDFA0008420F /* SkImageDecoder.cpp in Sources */,
-				00BE439C0EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp in Sources */,
-				00BE439E0EE9CDFA0008420F /* SkImageDecoder_libico.cpp in Sources */,
-				00BE43A20EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp in Sources */,
-				00BE43A30EE9CDFA0008420F /* SkImageRef.cpp in Sources */,
-				00BE43A40EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp in Sources */,
-				00BE43A50EE9CDFA0008420F /* SkImageRefPool.cpp in Sources */,
-				00BE43A70EE9CDFA0008420F /* SkMMapStream.cpp in Sources */,
-				00BE43A80EE9CDFA0008420F /* SkMovie.cpp in Sources */,
-				00BE43AA0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp in Sources */,
-				00BE43AC0EE9CDFA0008420F /* SkStream.cpp in Sources */,
-				00BE43AD0EE9CDFA0008420F /* SkFontHost_android.cpp in Sources */,
-				00BE43AE0EE9CDFA0008420F /* SkFontHost_gamma.cpp in Sources */,
-				00BE43AF0EE9CDFA0008420F /* SkGlobals_global.cpp in Sources */,
-				00BE43B00EE9CDFA0008420F /* SkImageDecoder_Factory.cpp in Sources */,
-				00BE43B10EE9CDFA0008420F /* SkThread_pthread.cpp in Sources */,
-				00BE43B20EE9CDFA0008420F /* SkTime_Unix.cpp in Sources */,
-				00BE43B30EE9CDFA0008420F /* SkPathHeap.cpp in Sources */,
-				00BE43B50EE9CDFA0008420F /* SkPicture.cpp in Sources */,
-				00BE43B60EE9CDFA0008420F /* SkPictureFlat.cpp in Sources */,
-				00BE43B80EE9CDFA0008420F /* SkPicturePlayback.cpp in Sources */,
-				00BE43BA0EE9CDFA0008420F /* SkPictureRecord.cpp in Sources */,
-				00BE43BC0EE9CDFA0008420F /* SkGL.cpp in Sources */,
-				00BE43BE0EE9CDFA0008420F /* SkGLCanvas.cpp in Sources */,
-				00BE43BF0EE9CDFA0008420F /* SkGLDevice.cpp in Sources */,
-				00BE43C10EE9CDFA0008420F /* SkGLDevice_FBO.cpp in Sources */,
-				00BE43C30EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp in Sources */,
-				00BE43C50EE9CDFA0008420F /* SkGLTextCache.cpp in Sources */,
-				00BE43C70EE9CDFA0008420F /* SkTextureCache.cpp in Sources */,
-				00BE43C90EE9CDFA0008420F /* SkAlphaRuns.cpp in Sources */,
-				00BE43CC0EE9CDFA0008420F /* SkBitmap.cpp in Sources */,
-				00BE43CD0EE9CDFA0008420F /* SkBitmap_scroll.cpp in Sources */,
-				00BE43CE0EE9CDFA0008420F /* SkBitmapProcShader.cpp in Sources */,
-				00BE43D00EE9CDFA0008420F /* SkBitmapProcState.cpp in Sources */,
-				00BE43D30EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp in Sources */,
-				00BE43D50EE9CDFA0008420F /* SkBitmapSampler.cpp in Sources */,
-				00BE43D80EE9CDFA0008420F /* SkBitmapShader.cpp in Sources */,
-				00BE43DE0EE9CDFA0008420F /* SkBlitRow_D16.cpp in Sources */,
-				00BE43DF0EE9CDFA0008420F /* SkBlitRow_D4444.cpp in Sources */,
-				00BE43E00EE9CDFA0008420F /* SkBlitter.cpp in Sources */,
-				00BE43E20EE9CDFA0008420F /* SkBlitter_4444.cpp in Sources */,
-				00BE43E30EE9CDFA0008420F /* SkBlitter_A1.cpp in Sources */,
-				00BE43E40EE9CDFA0008420F /* SkBlitter_A8.cpp in Sources */,
-				00BE43E50EE9CDFA0008420F /* SkBlitter_ARGB32.cpp in Sources */,
-				00BE43E60EE9CDFA0008420F /* SkBlitter_RGB16.cpp in Sources */,
-				00BE43E70EE9CDFA0008420F /* SkBlitter_Sprite.cpp in Sources */,
-				00BE43E80EE9CDFA0008420F /* SkCanvas.cpp in Sources */,
-				00BE43E90EE9CDFA0008420F /* SkColor.cpp in Sources */,
-				00BE43EA0EE9CDFA0008420F /* SkColorFilter.cpp in Sources */,
-				00BE43EB0EE9CDFA0008420F /* SkColorTable.cpp in Sources */,
-				00BE43ED0EE9CDFA0008420F /* SkDeque.cpp in Sources */,
-				00BE43EE0EE9CDFA0008420F /* SkDevice.cpp in Sources */,
-				00BE43EF0EE9CDFA0008420F /* SkDither.cpp in Sources */,
-				00BE43F00EE9CDFA0008420F /* SkDraw.cpp in Sources */,
-				00BE43F20EE9CDFA0008420F /* SkEdge.cpp in Sources */,
-				00BE43F40EE9CDFA0008420F /* SkFilterProc.cpp in Sources */,
-				00BE43F60EE9CDFA0008420F /* SkFlattenable.cpp in Sources */,
-				00BE43F80EE9CDFA0008420F /* SkGeometry.cpp in Sources */,
-				00BE43FA0EE9CDFA0008420F /* SkGlobals.cpp in Sources */,
-				00BE43FB0EE9CDFA0008420F /* SkGlyphCache.cpp in Sources */,
-				00BE43FD0EE9CDFA0008420F /* SkGraphics.cpp in Sources */,
-				00BE43FE0EE9CDFA0008420F /* SkMask.cpp in Sources */,
-				00BE43FF0EE9CDFA0008420F /* SkMaskFilter.cpp in Sources */,
-				00BE44000EE9CDFA0008420F /* SkPackBits.cpp in Sources */,
-				00BE44010EE9CDFA0008420F /* SkPaint.cpp in Sources */,
-				00BE44020EE9CDFA0008420F /* SkPath.cpp in Sources */,
-				00BE44030EE9CDFA0008420F /* SkPathEffect.cpp in Sources */,
-				00BE44040EE9CDFA0008420F /* SkPathMeasure.cpp in Sources */,
-				00BE44050EE9CDFA0008420F /* SkPixelRef.cpp in Sources */,
-				00BE44060EE9CDFA0008420F /* SkProcSpriteBlitter.cpp in Sources */,
-				00BE44070EE9CDFA0008420F /* SkPtrRecorder.cpp in Sources */,
-				00BE44080EE9CDFA0008420F /* SkRasterizer.cpp in Sources */,
-				00BE44090EE9CDFA0008420F /* SkRefCnt.cpp in Sources */,
-				00BE440A0EE9CDFA0008420F /* SkRegion_path.cpp in Sources */,
-				00BE440B0EE9CDFA0008420F /* SkScalerContext.cpp in Sources */,
-				00BE440C0EE9CDFA0008420F /* SkScan.cpp in Sources */,
-				00BE440E0EE9CDFA0008420F /* SkScan_Antihair.cpp in Sources */,
-				00BE440F0EE9CDFA0008420F /* SkScan_AntiPath.cpp in Sources */,
-				00BE44100EE9CDFA0008420F /* SkScan_Hairline.cpp in Sources */,
-				00BE44110EE9CDFA0008420F /* SkScan_Path.cpp in Sources */,
-				00BE44130EE9CDFA0008420F /* SkShader.cpp in Sources */,
-				00BE44150EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp in Sources */,
-				00BE44160EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp in Sources */,
-				00BE44190EE9CDFA0008420F /* SkStroke.cpp in Sources */,
-				00BE441A0EE9CDFA0008420F /* SkStrokerPriv.cpp in Sources */,
-				00BE441D0EE9CDFA0008420F /* SkTSearch.cpp in Sources */,
-				00BE441F0EE9CDFA0008420F /* SkTypeface.cpp in Sources */,
-				00BE44200EE9CDFA0008420F /* SkUnPreMultiply.cpp in Sources */,
-				00BE44220EE9CDFA0008420F /* SkWriter32.cpp in Sources */,
-				00BE44230EE9CDFA0008420F /* SkXfermode.cpp in Sources */,
-				00BE44240EE9CDFA0008420F /* Sk64.cpp in Sources */,
-				00BE44250EE9CDFA0008420F /* SkBuffer.cpp in Sources */,
-				00BE44260EE9CDFA0008420F /* SkChunkAlloc.cpp in Sources */,
-				00BE44270EE9CDFA0008420F /* SkCordic.cpp in Sources */,
-				00BE44290EE9CDFA0008420F /* SkDebug.cpp in Sources */,
-				00BE442A0EE9CDFA0008420F /* SkDebug_stdio.cpp in Sources */,
-				00BE442B0EE9CDFA0008420F /* SkFloat.cpp in Sources */,
-				00BE442D0EE9CDFA0008420F /* SkFloatBits.cpp in Sources */,
-				00BE442E0EE9CDFA0008420F /* SkInterpolator.cpp in Sources */,
-				00BE442F0EE9CDFA0008420F /* SkMath.cpp in Sources */,
-				00BE44300EE9CDFA0008420F /* SkMatrix.cpp in Sources */,
-				00BE44310EE9CDFA0008420F /* SkMemory_stdlib.cpp in Sources */,
-				00BE44320EE9CDFA0008420F /* SkPageFlipper.cpp in Sources */,
-				00BE44330EE9CDFA0008420F /* SkPoint.cpp in Sources */,
-				00BE44340EE9CDFA0008420F /* SkRect.cpp in Sources */,
-				00BE44350EE9CDFA0008420F /* SkRegion.cpp in Sources */,
-				00BE44C90EE9D4FC0008420F /* SkOSFile_stdio.cpp in Sources */,
-				00BE45070EE9D8120008420F /* bmpdecoderhelper.cpp in Sources */,
-				00AFCD710EF1672C00BD2FF1 /* SkDOM.cpp in Sources */,
-				00AFCD7C0EF167BC00BD2FF1 /* SkParse.cpp in Sources */,
-				00AFCD7D0EF167BC00BD2FF1 /* SkParseColor.cpp in Sources */,
-				00AFCD7E0EF167BC00BD2FF1 /* SkXMLParser.cpp in Sources */,
-				00AFCD890EF1684200BD2FF1 /* SkBitmap_Mac.cpp in Sources */,
-				00AFCD8B0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp in Sources */,
-				006B43FE0EF7526E00F15BC4 /* SkString.cpp in Sources */,
-				006B43FF0EF7526E00F15BC4 /* SkUtils.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		003E929B0EED79240091D85B /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = freetype;
-			targetProxy = 003E929A0EED79240091D85B /* PBXContainerItemProxy */;
-		};
-		003E92DA0EED7C3B0091D85B /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = zlib;
-			targetProxy = 003E92D90EED7C3B0091D85B /* PBXContainerItemProxy */;
-		};
-		00AFCE180EF16BBB00BD2FF1 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = expat;
-			targetProxy = 00AFCE170EF16BBB00BD2FF1 /* PBXContainerItemProxy */;
-		};
-		00BE44F10EE9D70D0008420F /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = jpeg;
-			targetProxy = 00BE44F00EE9D70D0008420F /* PBXContainerItemProxy */;
-		};
-		00BE44F50EE9D70D0008420F /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = giflib;
-			targetProxy = 00BE44F40EE9D70D0008420F /* PBXContainerItemProxy */;
-		};
-		00BE44F70EE9D70D0008420F /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			name = libpng;
-			targetProxy = 00BE44F60EE9D70D0008420F /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		00A9BB930EF6BFC400D8DC2B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_MODEL_TUNING = "";
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_RELEASE,
-					SK_BUILD_FOR_MAC,
-				);
-				GCC_STRICT_ALIASING = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_SIGN_COMPARE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-				VALID_ARCHS = "i386 x86_64";
-			};
-			name = Release;
-		};
-		00A9BB940EF6BFC400D8DC2B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = skia2;
-				ZERO_LINK = YES;
-			};
-			name = Release;
-		};
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = skia2;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_ENABLE_CPP_EXCEPTIONS = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					SK_BUILD_FOR_MAC,
-					SK_DEBUG,
-				);
-				GCC_STRICT_ALIASING = YES;
-				GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_SIGN_COMPARE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				USER_HEADER_SEARCH_PATHS = "../include/**";
-				VALID_ARCHS = "i386 x86_64";
-			};
-			name = Debug;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "skia2" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				00A9BB940EF6BFC400D8DC2B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "skia2" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				00A9BB930EF6BFC400D8DC2B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/svg.xcodeproj/project.pbxproj b/xcode/svg.xcodeproj/project.pbxproj
deleted file mode 100644
index c4374eb..0000000
--- a/xcode/svg.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,435 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		002843AB09DDC030002E9CB0 /* SkSVGCircle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */; };
-		002843AC09DDC030002E9CB0 /* SkSVGCircle.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437709DDC02F002E9CB0 /* SkSVGCircle.h */; };
-		002843AD09DDC030002E9CB0 /* SkSVGClipPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */; };
-		002843AE09DDC030002E9CB0 /* SkSVGClipPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */; };
-		002843AF09DDC030002E9CB0 /* SkSVGDefs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */; };
-		002843B009DDC030002E9CB0 /* SkSVGDefs.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */; };
-		002843B109DDC030002E9CB0 /* SkSVGElements.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */; };
-		002843B209DDC030002E9CB0 /* SkSVGElements.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437D09DDC02F002E9CB0 /* SkSVGElements.h */; };
-		002843B309DDC030002E9CB0 /* SkSVGEllipse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */; };
-		002843B409DDC030002E9CB0 /* SkSVGEllipse.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */; };
-		002843B509DDC030002E9CB0 /* SkSVGFeColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */; };
-		002843B609DDC030002E9CB0 /* SkSVGFeColorMatrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */; };
-		002843B709DDC030002E9CB0 /* SkSVGFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */; };
-		002843B809DDC030002E9CB0 /* SkSVGFilter.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438309DDC02F002E9CB0 /* SkSVGFilter.h */; };
-		002843B909DDC030002E9CB0 /* SkSVGG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438409DDC02F002E9CB0 /* SkSVGG.cpp */; };
-		002843BA09DDC030002E9CB0 /* SkSVGG.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438509DDC02F002E9CB0 /* SkSVGG.h */; };
-		002843BB09DDC030002E9CB0 /* SkSVGGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */; };
-		002843BC09DDC030002E9CB0 /* SkSVGGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438709DDC02F002E9CB0 /* SkSVGGradient.h */; };
-		002843BD09DDC030002E9CB0 /* SkSVGGroup.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */; };
-		002843BE09DDC030002E9CB0 /* SkSVGGroup.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438909DDC02F002E9CB0 /* SkSVGGroup.h */; };
-		002843BF09DDC030002E9CB0 /* SkSVGImage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */; };
-		002843C009DDC030002E9CB0 /* SkSVGImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438B09DDC02F002E9CB0 /* SkSVGImage.h */; };
-		002843C109DDC030002E9CB0 /* SkSVGLine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */; };
-		002843C209DDC030002E9CB0 /* SkSVGLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438D09DDC02F002E9CB0 /* SkSVGLine.h */; };
-		002843C309DDC030002E9CB0 /* SkSVGLinearGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */; };
-		002843C409DDC030002E9CB0 /* SkSVGLinearGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */; };
-		002843C509DDC030002E9CB0 /* SkSVGMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */; };
-		002843C609DDC030002E9CB0 /* SkSVGMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439109DDC02F002E9CB0 /* SkSVGMask.h */; };
-		002843C709DDC030002E9CB0 /* SkSVGMetadata.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */; };
-		002843C809DDC030002E9CB0 /* SkSVGMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */; };
-		002843C909DDC030002E9CB0 /* SkSVGPaintState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */; };
-		002843CA09DDC030002E9CB0 /* SkSVGParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */; };
-		002843CB09DDC030002E9CB0 /* SkSVGPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */; };
-		002843CC09DDC030002E9CB0 /* SkSVGPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439709DDC02F002E9CB0 /* SkSVGPath.h */; };
-		002843CD09DDC030002E9CB0 /* SkSVGPolygon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */; };
-		002843CE09DDC030002E9CB0 /* SkSVGPolygon.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */; };
-		002843CF09DDC030002E9CB0 /* SkSVGPolyline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */; };
-		002843D009DDC030002E9CB0 /* SkSVGPolyline.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */; };
-		002843D109DDC030002E9CB0 /* SkSVGRadialGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */; };
-		002843D209DDC030002E9CB0 /* SkSVGRadialGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */; };
-		002843D309DDC030002E9CB0 /* SkSVGRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */; };
-		002843D409DDC030002E9CB0 /* SkSVGRect.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439F09DDC02F002E9CB0 /* SkSVGRect.h */; };
-		002843D509DDC030002E9CB0 /* SkSVGStop.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */; };
-		002843D609DDC030002E9CB0 /* SkSVGStop.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A109DDC02F002E9CB0 /* SkSVGStop.h */; };
-		002843D709DDC030002E9CB0 /* SkSVGSVG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */; };
-		002843D809DDC030002E9CB0 /* SkSVGSVG.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A309DDC02F002E9CB0 /* SkSVGSVG.h */; };
-		002843D909DDC030002E9CB0 /* SkSVGSymbol.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */; };
-		002843DA09DDC030002E9CB0 /* SkSVGSymbol.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */; };
-		002843DB09DDC030002E9CB0 /* SkSVGText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A609DDC02F002E9CB0 /* SkSVGText.cpp */; };
-		002843DC09DDC030002E9CB0 /* SkSVGText.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A709DDC02F002E9CB0 /* SkSVGText.h */; };
-		002843DD09DDC030002E9CB0 /* SkSVGUse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */; };
-		002843DE09DDC030002E9CB0 /* SkSVGUse.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A909DDC02F002E9CB0 /* SkSVGUse.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXBuildStyle section */
-		014CEA520018CE5811CA2923 /* Debug */ = {
-			isa = PBXBuildStyle;
-			buildSettings = {
-			};
-			name = Debug;
-		};
-		014CEA530018CE5811CA2923 /* Release */ = {
-			isa = PBXBuildStyle;
-			buildSettings = {
-			};
-			name = Release;
-		};
-/* End PBXBuildStyle section */
-
-/* Begin PBXFileReference section */
-		0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGCircle.cpp; sourceTree = "<group>"; };
-		0028437709DDC02F002E9CB0 /* SkSVGCircle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGCircle.h; sourceTree = "<group>"; };
-		0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGClipPath.cpp; sourceTree = "<group>"; };
-		0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGClipPath.h; sourceTree = "<group>"; };
-		0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGDefs.cpp; sourceTree = "<group>"; };
-		0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGDefs.h; sourceTree = "<group>"; };
-		0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGElements.cpp; sourceTree = "<group>"; };
-		0028437D09DDC02F002E9CB0 /* SkSVGElements.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGElements.h; sourceTree = "<group>"; };
-		0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGEllipse.cpp; sourceTree = "<group>"; };
-		0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGEllipse.h; sourceTree = "<group>"; };
-		0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGFeColorMatrix.cpp; sourceTree = "<group>"; };
-		0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGFeColorMatrix.h; sourceTree = "<group>"; };
-		0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGFilter.cpp; sourceTree = "<group>"; };
-		0028438309DDC02F002E9CB0 /* SkSVGFilter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGFilter.h; sourceTree = "<group>"; };
-		0028438409DDC02F002E9CB0 /* SkSVGG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGG.cpp; sourceTree = "<group>"; };
-		0028438509DDC02F002E9CB0 /* SkSVGG.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGG.h; sourceTree = "<group>"; };
-		0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGGradient.cpp; sourceTree = "<group>"; };
-		0028438709DDC02F002E9CB0 /* SkSVGGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGGradient.h; sourceTree = "<group>"; };
-		0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGGroup.cpp; sourceTree = "<group>"; };
-		0028438909DDC02F002E9CB0 /* SkSVGGroup.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGGroup.h; sourceTree = "<group>"; };
-		0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGImage.cpp; sourceTree = "<group>"; };
-		0028438B09DDC02F002E9CB0 /* SkSVGImage.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGImage.h; sourceTree = "<group>"; };
-		0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGLine.cpp; sourceTree = "<group>"; };
-		0028438D09DDC02F002E9CB0 /* SkSVGLine.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGLine.h; sourceTree = "<group>"; };
-		0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGLinearGradient.cpp; sourceTree = "<group>"; };
-		0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGLinearGradient.h; sourceTree = "<group>"; };
-		0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGMask.cpp; sourceTree = "<group>"; };
-		0028439109DDC02F002E9CB0 /* SkSVGMask.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGMask.h; sourceTree = "<group>"; };
-		0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGMetadata.cpp; sourceTree = "<group>"; };
-		0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGMetadata.h; sourceTree = "<group>"; };
-		0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPaintState.cpp; sourceTree = "<group>"; };
-		0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGParser.cpp; sourceTree = "<group>"; };
-		0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPath.cpp; sourceTree = "<group>"; };
-		0028439709DDC02F002E9CB0 /* SkSVGPath.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPath.h; sourceTree = "<group>"; };
-		0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPolygon.cpp; sourceTree = "<group>"; };
-		0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPolygon.h; sourceTree = "<group>"; };
-		0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPolyline.cpp; sourceTree = "<group>"; };
-		0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPolyline.h; sourceTree = "<group>"; };
-		0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGRadialGradient.cpp; sourceTree = "<group>"; };
-		0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGRadialGradient.h; sourceTree = "<group>"; };
-		0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGRect.cpp; sourceTree = "<group>"; };
-		0028439F09DDC02F002E9CB0 /* SkSVGRect.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGRect.h; sourceTree = "<group>"; };
-		002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGStop.cpp; sourceTree = "<group>"; };
-		002843A109DDC02F002E9CB0 /* SkSVGStop.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGStop.h; sourceTree = "<group>"; };
-		002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGSVG.cpp; sourceTree = "<group>"; };
-		002843A309DDC02F002E9CB0 /* SkSVGSVG.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGSVG.h; sourceTree = "<group>"; };
-		002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGSymbol.cpp; sourceTree = "<group>"; };
-		002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGSymbol.h; sourceTree = "<group>"; };
-		002843A609DDC02F002E9CB0 /* SkSVGText.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGText.cpp; sourceTree = "<group>"; };
-		002843A709DDC02F002E9CB0 /* SkSVGText.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGText.h; sourceTree = "<group>"; };
-		002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGUse.cpp; sourceTree = "<group>"; };
-		002843A909DDC02F002E9CB0 /* SkSVGUse.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGUse.h; sourceTree = "<group>"; };
-		D2AAC046055464E500DB518D /* libsvg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libsvg.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		0028437409DDC02F002E9CB0 /* svg */ = {
-			isa = PBXGroup;
-			children = (
-				0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */,
-				0028437709DDC02F002E9CB0 /* SkSVGCircle.h */,
-				0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */,
-				0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */,
-				0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */,
-				0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */,
-				0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */,
-				0028437D09DDC02F002E9CB0 /* SkSVGElements.h */,
-				0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */,
-				0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */,
-				0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */,
-				0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */,
-				0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */,
-				0028438309DDC02F002E9CB0 /* SkSVGFilter.h */,
-				0028438409DDC02F002E9CB0 /* SkSVGG.cpp */,
-				0028438509DDC02F002E9CB0 /* SkSVGG.h */,
-				0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */,
-				0028438709DDC02F002E9CB0 /* SkSVGGradient.h */,
-				0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */,
-				0028438909DDC02F002E9CB0 /* SkSVGGroup.h */,
-				0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */,
-				0028438B09DDC02F002E9CB0 /* SkSVGImage.h */,
-				0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */,
-				0028438D09DDC02F002E9CB0 /* SkSVGLine.h */,
-				0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */,
-				0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */,
-				0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */,
-				0028439109DDC02F002E9CB0 /* SkSVGMask.h */,
-				0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */,
-				0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */,
-				0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */,
-				0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */,
-				0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */,
-				0028439709DDC02F002E9CB0 /* SkSVGPath.h */,
-				0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */,
-				0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */,
-				0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */,
-				0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */,
-				0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */,
-				0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */,
-				0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */,
-				0028439F09DDC02F002E9CB0 /* SkSVGRect.h */,
-				002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */,
-				002843A109DDC02F002E9CB0 /* SkSVGStop.h */,
-				002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */,
-				002843A309DDC02F002E9CB0 /* SkSVGSVG.h */,
-				002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */,
-				002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */,
-				002843A609DDC02F002E9CB0 /* SkSVGText.cpp */,
-				002843A709DDC02F002E9CB0 /* SkSVGText.h */,
-				002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */,
-				002843A909DDC02F002E9CB0 /* SkSVGUse.h */,
-			);
-			name = svg;
-			path = ../../libs/graphics/svg;
-			sourceTree = SOURCE_ROOT;
-		};
-		08FB7794FE84155DC02AAC07 /* svg */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = svg;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				0028437409DDC02F002E9CB0 /* svg */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libsvg.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				002843AC09DDC030002E9CB0 /* SkSVGCircle.h in Headers */,
-				002843AE09DDC030002E9CB0 /* SkSVGClipPath.h in Headers */,
-				002843B009DDC030002E9CB0 /* SkSVGDefs.h in Headers */,
-				002843B209DDC030002E9CB0 /* SkSVGElements.h in Headers */,
-				002843B409DDC030002E9CB0 /* SkSVGEllipse.h in Headers */,
-				002843B609DDC030002E9CB0 /* SkSVGFeColorMatrix.h in Headers */,
-				002843B809DDC030002E9CB0 /* SkSVGFilter.h in Headers */,
-				002843BA09DDC030002E9CB0 /* SkSVGG.h in Headers */,
-				002843BC09DDC030002E9CB0 /* SkSVGGradient.h in Headers */,
-				002843BE09DDC030002E9CB0 /* SkSVGGroup.h in Headers */,
-				002843C009DDC030002E9CB0 /* SkSVGImage.h in Headers */,
-				002843C209DDC030002E9CB0 /* SkSVGLine.h in Headers */,
-				002843C409DDC030002E9CB0 /* SkSVGLinearGradient.h in Headers */,
-				002843C609DDC030002E9CB0 /* SkSVGMask.h in Headers */,
-				002843C809DDC030002E9CB0 /* SkSVGMetadata.h in Headers */,
-				002843CC09DDC030002E9CB0 /* SkSVGPath.h in Headers */,
-				002843CE09DDC030002E9CB0 /* SkSVGPolygon.h in Headers */,
-				002843D009DDC030002E9CB0 /* SkSVGPolyline.h in Headers */,
-				002843D209DDC030002E9CB0 /* SkSVGRadialGradient.h in Headers */,
-				002843D409DDC030002E9CB0 /* SkSVGRect.h in Headers */,
-				002843D609DDC030002E9CB0 /* SkSVGStop.h in Headers */,
-				002843D809DDC030002E9CB0 /* SkSVGSVG.h in Headers */,
-				002843DA09DDC030002E9CB0 /* SkSVGSymbol.h in Headers */,
-				002843DC09DDC030002E9CB0 /* SkSVGText.h in Headers */,
-				002843DE09DDC030002E9CB0 /* SkSVGUse.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* svg */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "svg" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			buildSettings = {
-			};
-			dependencies = (
-			);
-			name = svg;
-			productName = svg;
-			productReference = D2AAC046055464E500DB518D /* libsvg.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "svg" */;
-			buildSettings = {
-			};
-			buildStyles = (
-				014CEA520018CE5811CA2923 /* Debug */,
-				014CEA530018CE5811CA2923 /* Release */,
-			);
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* svg */;
-			projectDirPath = "";
-			targets = (
-				D2AAC045055464E500DB518D /* svg */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				002843AB09DDC030002E9CB0 /* SkSVGCircle.cpp in Sources */,
-				002843AD09DDC030002E9CB0 /* SkSVGClipPath.cpp in Sources */,
-				002843AF09DDC030002E9CB0 /* SkSVGDefs.cpp in Sources */,
-				002843B109DDC030002E9CB0 /* SkSVGElements.cpp in Sources */,
-				002843B309DDC030002E9CB0 /* SkSVGEllipse.cpp in Sources */,
-				002843B509DDC030002E9CB0 /* SkSVGFeColorMatrix.cpp in Sources */,
-				002843B709DDC030002E9CB0 /* SkSVGFilter.cpp in Sources */,
-				002843B909DDC030002E9CB0 /* SkSVGG.cpp in Sources */,
-				002843BB09DDC030002E9CB0 /* SkSVGGradient.cpp in Sources */,
-				002843BD09DDC030002E9CB0 /* SkSVGGroup.cpp in Sources */,
-				002843BF09DDC030002E9CB0 /* SkSVGImage.cpp in Sources */,
-				002843C109DDC030002E9CB0 /* SkSVGLine.cpp in Sources */,
-				002843C309DDC030002E9CB0 /* SkSVGLinearGradient.cpp in Sources */,
-				002843C509DDC030002E9CB0 /* SkSVGMask.cpp in Sources */,
-				002843C709DDC030002E9CB0 /* SkSVGMetadata.cpp in Sources */,
-				002843C909DDC030002E9CB0 /* SkSVGPaintState.cpp in Sources */,
-				002843CA09DDC030002E9CB0 /* SkSVGParser.cpp in Sources */,
-				002843CB09DDC030002E9CB0 /* SkSVGPath.cpp in Sources */,
-				002843CD09DDC030002E9CB0 /* SkSVGPolygon.cpp in Sources */,
-				002843CF09DDC030002E9CB0 /* SkSVGPolyline.cpp in Sources */,
-				002843D109DDC030002E9CB0 /* SkSVGRadialGradient.cpp in Sources */,
-				002843D309DDC030002E9CB0 /* SkSVGRect.cpp in Sources */,
-				002843D509DDC030002E9CB0 /* SkSVGStop.cpp in Sources */,
-				002843D709DDC030002E9CB0 /* SkSVGSVG.cpp in Sources */,
-				002843D909DDC030002E9CB0 /* SkSVGSymbol.cpp in Sources */,
-				002843DB09DDC030002E9CB0 /* SkSVGText.cpp in Sources */,
-				002843DD09DDC030002E9CB0 /* SkSVGUse.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = svg;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = svg;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "svg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "svg" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/views.xcodeproj/project.pbxproj b/xcode/views.xcodeproj/project.pbxproj
deleted file mode 100644
index 05d65d3..0000000
--- a/xcode/views.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,324 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E1C20EDCAB1500F77EA2 /* SkEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */; };
-		00B7E1C30EDCAB1500F77EA2 /* SkEventSink.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */; };
-		00B7E1C40EDCAB1500F77EA2 /* SkMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */; };
-		00B7E1C50EDCAB1500F77EA2 /* SkTagList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */; };
-		00B7E1C60EDCAB1500F77EA2 /* SkTagList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */; };
-		00B7E1C70EDCAB1500F77EA2 /* SkTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */; };
-		00B7E1DF0EDCABAC00F77EA2 /* SkBGViewArtist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */; };
-		00B7E1E00EDCABAC00F77EA2 /* SkBorderView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */; };
-		00B7E1E10EDCABAC00F77EA2 /* SkImageView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */; };
-		00B7E1E20EDCABAC00F77EA2 /* SkListView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */; };
-		00B7E1E30EDCABAC00F77EA2 /* SkListWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */; };
-		00B7E1E40EDCABAC00F77EA2 /* SkOSFile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */; };
-		00B7E1E50EDCABAC00F77EA2 /* SkOSMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */; };
-		00B7E1E60EDCABAC00F77EA2 /* SkOSSound.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */; };
-		00B7E1E70EDCABAC00F77EA2 /* SkParsePaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */; };
-		00B7E1E80EDCABAC00F77EA2 /* SkProgressBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */; };
-		00B7E1E90EDCABAC00F77EA2 /* SkProgressView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */; };
-		00B7E1EA0EDCABAC00F77EA2 /* SkScrollBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */; };
-		00B7E1EB0EDCABAC00F77EA2 /* SkStackViewLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */; };
-		00B7E1EC0EDCABAC00F77EA2 /* SkView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */; };
-		00B7E1ED0EDCABAC00F77EA2 /* SkViewInflate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */; };
-		00B7E1EE0EDCABAC00F77EA2 /* SkViewPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */; };
-		00B7E1EF0EDCABAC00F77EA2 /* SkViewPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */; };
-		00B7E1F00EDCABAC00F77EA2 /* SkWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */; };
-		00B7E1F10EDCABAC00F77EA2 /* SkWidgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */; };
-		00B7E1F20EDCABAC00F77EA2 /* SkWidgetViews.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */; };
-		00B7E1F30EDCABAC00F77EA2 /* SkWindow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEvent.cpp; path = ../libsgl/views/SkEvent.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEventSink.cpp; path = ../libsgl/views/SkEventSink.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMetaData.cpp; path = ../libsgl/views/SkMetaData.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTagList.cpp; path = ../libsgl/views/SkTagList.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTagList.h; path = ../libsgl/views/SkTagList.h; sourceTree = SOURCE_ROOT; };
-		00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextBox.cpp; path = ../libsgl/views/SkTextBox.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBGViewArtist.cpp; path = ../libsgl/views/SkBGViewArtist.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBorderView.cpp; path = ../libsgl/views/SkBorderView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageView.cpp; path = ../libsgl/views/SkImageView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListView.cpp; path = ../libsgl/views/SkListView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListWidget.cpp; path = ../libsgl/views/SkListWidget.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile.cpp; path = ../libsgl/views/SkOSFile.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSMenu.cpp; path = ../libsgl/views/SkOSMenu.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSSound.cpp; path = ../libsgl/views/SkOSSound.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParsePaint.cpp; path = ../libsgl/views/SkParsePaint.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressBarView.cpp; path = ../libsgl/views/SkProgressBarView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressView.cpp; path = ../libsgl/views/SkProgressView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScrollBarView.cpp; path = ../libsgl/views/SkScrollBarView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStackViewLayout.cpp; path = ../libsgl/views/SkStackViewLayout.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkView.cpp; path = ../libsgl/views/SkView.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewInflate.cpp; path = ../libsgl/views/SkViewInflate.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewPriv.cpp; path = ../libsgl/views/SkViewPriv.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkViewPriv.h; path = ../libsgl/views/SkViewPriv.h; sourceTree = SOURCE_ROOT; };
-		00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidget.cpp; path = ../libsgl/views/SkWidget.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgets.cpp; path = ../libsgl/views/SkWidgets.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgetViews.cpp; path = ../libsgl/views/SkWidgetViews.cpp; sourceTree = SOURCE_ROOT; };
-		00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWindow.cpp; path = ../libsgl/views/SkWindow.cpp; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libviews.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libviews.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* views */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = views;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */,
-				00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */,
-				00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */,
-				00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */,
-				00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */,
-				00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */,
-				00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */,
-				00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */,
-				00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */,
-				00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */,
-				00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */,
-				00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */,
-				00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */,
-				00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */,
-				00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */,
-				00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */,
-				00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */,
-				00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */,
-				00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */,
-				00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */,
-				00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */,
-				00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */,
-				00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */,
-				00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */,
-				00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */,
-				00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */,
-				00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libviews.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E1C60EDCAB1500F77EA2 /* SkTagList.h in Headers */,
-				00B7E1EF0EDCABAC00F77EA2 /* SkViewPriv.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* views */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "views" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = views;
-			productName = views;
-			productReference = D2AAC046055464E500DB518D /* libviews.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "views" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* views */;
-			projectDirPath = "";
-			projectRoot = ..;
-			targets = (
-				D2AAC045055464E500DB518D /* views */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E1C20EDCAB1500F77EA2 /* SkEvent.cpp in Sources */,
-				00B7E1C30EDCAB1500F77EA2 /* SkEventSink.cpp in Sources */,
-				00B7E1C40EDCAB1500F77EA2 /* SkMetaData.cpp in Sources */,
-				00B7E1C50EDCAB1500F77EA2 /* SkTagList.cpp in Sources */,
-				00B7E1C70EDCAB1500F77EA2 /* SkTextBox.cpp in Sources */,
-				00B7E1DF0EDCABAC00F77EA2 /* SkBGViewArtist.cpp in Sources */,
-				00B7E1E00EDCABAC00F77EA2 /* SkBorderView.cpp in Sources */,
-				00B7E1E10EDCABAC00F77EA2 /* SkImageView.cpp in Sources */,
-				00B7E1E20EDCABAC00F77EA2 /* SkListView.cpp in Sources */,
-				00B7E1E30EDCABAC00F77EA2 /* SkListWidget.cpp in Sources */,
-				00B7E1E40EDCABAC00F77EA2 /* SkOSFile.cpp in Sources */,
-				00B7E1E50EDCABAC00F77EA2 /* SkOSMenu.cpp in Sources */,
-				00B7E1E60EDCABAC00F77EA2 /* SkOSSound.cpp in Sources */,
-				00B7E1E70EDCABAC00F77EA2 /* SkParsePaint.cpp in Sources */,
-				00B7E1E80EDCABAC00F77EA2 /* SkProgressBarView.cpp in Sources */,
-				00B7E1E90EDCABAC00F77EA2 /* SkProgressView.cpp in Sources */,
-				00B7E1EA0EDCABAC00F77EA2 /* SkScrollBarView.cpp in Sources */,
-				00B7E1EB0EDCABAC00F77EA2 /* SkStackViewLayout.cpp in Sources */,
-				00B7E1EC0EDCABAC00F77EA2 /* SkView.cpp in Sources */,
-				00B7E1ED0EDCABAC00F77EA2 /* SkViewInflate.cpp in Sources */,
-				00B7E1EE0EDCABAC00F77EA2 /* SkViewPriv.cpp in Sources */,
-				00B7E1F00EDCABAC00F77EA2 /* SkWidget.cpp in Sources */,
-				00B7E1F10EDCABAC00F77EA2 /* SkWidgets.cpp in Sources */,
-				00B7E1F20EDCABAC00F77EA2 /* SkWidgetViews.cpp in Sources */,
-				00B7E1F30EDCABAC00F77EA2 /* SkWindow.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB91EC08733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = views;
-				ZERO_LINK = NO;
-			};
-			name = Debug;
-		};
-		1DEB91ED08733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = "$(NATIVE_ARCH)";
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				INSTALL_PATH = /usr/local/lib;
-				PRODUCT_NAME = views;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		1DEB91F008733DB70010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = "";
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/**";
-			};
-			name = Debug;
-		};
-		1DEB91F108733DB70010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)";
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				SDKROOT = "";
-				SHARED_PRECOMPS_DIR = "";
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/**";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "views" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91EC08733DB70010E9CD /* Debug */,
-				1DEB91ED08733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "views" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB91F008733DB70010E9CD /* Debug */,
-				1DEB91F108733DB70010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/xcode/zlib.xcodeproj/project.pbxproj b/xcode/zlib.xcodeproj/project.pbxproj
deleted file mode 100644
index b7f96b2..0000000
--- a/xcode/zlib.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,269 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		00B7E21D0EDCAC9E00F77EA2 /* adler32.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2120EDCAC9E00F77EA2 /* adler32.c */; };
-		00B7E21E0EDCAC9E00F77EA2 /* compress.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2130EDCAC9E00F77EA2 /* compress.c */; };
-		00B7E21F0EDCAC9E00F77EA2 /* crc32.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2140EDCAC9E00F77EA2 /* crc32.c */; };
-		00B7E2200EDCAC9E00F77EA2 /* deflate.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2150EDCAC9E00F77EA2 /* deflate.c */; };
-		00B7E2210EDCAC9E00F77EA2 /* infback.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2160EDCAC9E00F77EA2 /* infback.c */; };
-		00B7E2220EDCAC9E00F77EA2 /* inffast.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2170EDCAC9E00F77EA2 /* inffast.c */; };
-		00B7E2230EDCAC9E00F77EA2 /* inflate.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2180EDCAC9E00F77EA2 /* inflate.c */; };
-		00B7E2240EDCAC9E00F77EA2 /* inftrees.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2190EDCAC9E00F77EA2 /* inftrees.c */; };
-		00B7E2250EDCAC9E00F77EA2 /* trees.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21A0EDCAC9E00F77EA2 /* trees.c */; };
-		00B7E2260EDCAC9E00F77EA2 /* uncompr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */; };
-		00B7E2270EDCAC9E00F77EA2 /* zutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21C0EDCAC9E00F77EA2 /* zutil.c */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		00B7E2120EDCAC9E00F77EA2 /* adler32.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = adler32.c; path = ../../zlib/adler32.c; sourceTree = SOURCE_ROOT; };
-		00B7E2130EDCAC9E00F77EA2 /* compress.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = compress.c; path = ../../zlib/compress.c; sourceTree = SOURCE_ROOT; };
-		00B7E2140EDCAC9E00F77EA2 /* crc32.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = crc32.c; path = ../../zlib/crc32.c; sourceTree = SOURCE_ROOT; };
-		00B7E2150EDCAC9E00F77EA2 /* deflate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = deflate.c; path = ../../zlib/deflate.c; sourceTree = SOURCE_ROOT; };
-		00B7E2160EDCAC9E00F77EA2 /* infback.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = infback.c; path = ../../zlib/infback.c; sourceTree = SOURCE_ROOT; };
-		00B7E2170EDCAC9E00F77EA2 /* inffast.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inffast.c; path = ../../zlib/inffast.c; sourceTree = SOURCE_ROOT; };
-		00B7E2180EDCAC9E00F77EA2 /* inflate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inflate.c; path = ../../zlib/inflate.c; sourceTree = SOURCE_ROOT; };
-		00B7E2190EDCAC9E00F77EA2 /* inftrees.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inftrees.c; path = ../../zlib/inftrees.c; sourceTree = SOURCE_ROOT; };
-		00B7E21A0EDCAC9E00F77EA2 /* trees.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = trees.c; path = ../../zlib/trees.c; sourceTree = SOURCE_ROOT; };
-		00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = uncompr.c; path = ../../zlib/uncompr.c; sourceTree = SOURCE_ROOT; };
-		00B7E21C0EDCAC9E00F77EA2 /* zutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = zutil.c; path = ../../zlib/zutil.c; sourceTree = SOURCE_ROOT; };
-		D2AAC046055464E500DB518D /* libzlib.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libzlib.a; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		D289987405E68DCB004EDB86 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* zlib */ = {
-			isa = PBXGroup;
-			children = (
-				FE08AA1A0944F1FE0057213F /* Include */,
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6A0FF2B0290797F04C91782 /* Documentation */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = zlib;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				00B7E2120EDCAC9E00F77EA2 /* adler32.c */,
-				00B7E2130EDCAC9E00F77EA2 /* compress.c */,
-				00B7E2140EDCAC9E00F77EA2 /* crc32.c */,
-				00B7E2150EDCAC9E00F77EA2 /* deflate.c */,
-				00B7E2160EDCAC9E00F77EA2 /* infback.c */,
-				00B7E2170EDCAC9E00F77EA2 /* inffast.c */,
-				00B7E2180EDCAC9E00F77EA2 /* inflate.c */,
-				00B7E2190EDCAC9E00F77EA2 /* inftrees.c */,
-				00B7E21A0EDCAC9E00F77EA2 /* trees.c */,
-				00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */,
-				00B7E21C0EDCAC9E00F77EA2 /* zutil.c */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				D2AAC046055464E500DB518D /* libzlib.a */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		C6A0FF2B0290797F04C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-		FE08AA1A0944F1FE0057213F /* Include */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Include;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		D2AAC043055464E500DB518D /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		D2AAC045055464E500DB518D /* zlib */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = FE5F4830094784880095980F /* Build configuration list for PBXNativeTarget "zlib" */;
-			buildPhases = (
-				D2AAC043055464E500DB518D /* Headers */,
-				D2AAC044055464E500DB518D /* Sources */,
-				D289987405E68DCB004EDB86 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = zlib;
-			productName = zlib;
-			productReference = D2AAC046055464E500DB518D /* libzlib.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = FE5F4834094784880095980F /* Build configuration list for PBXProject "zlib" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 1;
-			mainGroup = 08FB7794FE84155DC02AAC07 /* zlib */;
-			projectDirPath = "";
-			projectRoot = ..;
-			targets = (
-				D2AAC045055464E500DB518D /* zlib */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		D2AAC044055464E500DB518D /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				00B7E21D0EDCAC9E00F77EA2 /* adler32.c in Sources */,
-				00B7E21E0EDCAC9E00F77EA2 /* compress.c in Sources */,
-				00B7E21F0EDCAC9E00F77EA2 /* crc32.c in Sources */,
-				00B7E2200EDCAC9E00F77EA2 /* deflate.c in Sources */,
-				00B7E2210EDCAC9E00F77EA2 /* infback.c in Sources */,
-				00B7E2220EDCAC9E00F77EA2 /* inffast.c in Sources */,
-				00B7E2230EDCAC9E00F77EA2 /* inflate.c in Sources */,
-				00B7E2240EDCAC9E00F77EA2 /* inftrees.c in Sources */,
-				00B7E2250EDCAC9E00F77EA2 /* trees.c in Sources */,
-				00B7E2260EDCAC9E00F77EA2 /* uncompr.c in Sources */,
-				00B7E2270EDCAC9E00F77EA2 /* zutil.c in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		FE5F4831094784880095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = zlib;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		FE5F4832094784880095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				INSTALL_PATH = /usr/local/lib;
-				LIBRARY_STYLE = STATIC;
-				PREBINDING = NO;
-				PRODUCT_NAME = zlib;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		FE5F4835094784880095980F /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = ../../zlib;
-			};
-			name = Debug;
-		};
-		FE5F4836094784880095980F /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_CW_ASM_SYNTAX = NO;
-				GCC_ENABLE_CPP_RTTI = NO;
-				GCC_ENABLE_PASCAL_STRINGS = NO;
-				GCC_ENABLE_SYMBOL_SEPARATION = NO;
-				GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE;
-				GCC_USE_GCC3_PFE_SUPPORT = NO;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				LINK_WITH_STANDARD_LIBRARIES = NO;
-				PREBINDING = NO;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				STRIP_INSTALLED_PRODUCT = NO;
-				USER_HEADER_SEARCH_PATHS = ../../zlib;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		FE5F4830094784880095980F /* Build configuration list for PBXNativeTarget "zlib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F4831094784880095980F /* Debug */,
-				FE5F4832094784880095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-		FE5F4834094784880095980F /* Build configuration list for PBXProject "zlib" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				FE5F4835094784880095980F /* Debug */,
-				FE5F4836094784880095980F /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Debug;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}