diff --git a/include/effects/SkPixelXorXfermode.h b/include/effects/SkPixelXorXfermode.h
index 53f1210..b01f3c5 100644
--- a/include/effects/SkPixelXorXfermode.h
+++ b/include/effects/SkPixelXorXfermode.h
@@ -26,7 +26,7 @@
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
     // override from SkXfermode
-    virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst);
+    virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;
 
 private:
     SkColor fOpColor;
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index acdb148..662d561 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -51,7 +51,8 @@
 
 class SkGrayScaleColorFilter : public SkColorFilter {
 public:
-    virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
+    virtual void filterSpan(const SkPMColor src[], int count,
+                            SkPMColor result[]) const SK_OVERRIDE {
         for (int i = 0; i < count; i++)
             result[i] = rgb2gray(src[i]);
     }
@@ -63,7 +64,8 @@
         fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask);
     }
 
-    virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
+    virtual void filterSpan(const SkPMColor src[], int count,
+                            SkPMColor result[]) const SK_OVERRIDE {
         SkPMColor mask = fMask;
         for (int i = 0; i < count; i++) {
             result[i] = src[i] & mask;
@@ -163,7 +165,7 @@
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Dot2DPathEffect)
 
 protected:
-    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) {
+    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) const SK_OVERRIDE {
         dst->addCircle(loc.fX, loc.fY, fRadius);
     }
 
diff --git a/samplecode/SampleRotateCircles.cpp b/samplecode/SampleRotateCircles.cpp
index 8a04bcd..8e8bc01 100644
--- a/samplecode/SampleRotateCircles.cpp
+++ b/samplecode/SampleRotateCircles.cpp
@@ -9,6 +9,8 @@
 #include "SkView.h"
 #include "SkCanvas.h"
 #include "SkRandom.h"
+#include "SkRRect.h"
+#include "SkColorPriv.h"
 
 static void rotateAbout(SkCanvas* canvas, SkScalar degrees,
                         SkScalar cx, SkScalar cy) {
@@ -65,12 +67,17 @@
 
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeWidth(rad*2);
-
+            
             canvas->save();
             rotateAbout(canvas, fAngle * scale * sign, cx + DX, cy);
             canvas->drawCircle(cx + DX, cy, 10, paint);
             canvas->restore();
 
+            canvas->save();
+            rotateAbout(canvas, fAngle * scale * sign, cx + DX, cy + DX);
+            canvas->drawCircle(cx + DX, cy + DX, 10, paint);
+            canvas->restore();
+            
         }
 
         fAngle = (fAngle + 1) % 360;
@@ -82,6 +89,272 @@
     typedef SkView INHERITED;
 };
 
+class TestCirclesView : public SampleView {
+public:
+    TestCirclesView() {
+    }
+    
+protected:
+    virtual bool onQuery(SkEvent* evt) SK_OVERRIDE {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "RotateCircles2");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void draw_real_circle(SkCanvas* canvas, SkScalar radius) {
+        int w = SkScalarCeilToInt(radius * 2);
+        int h = w;
+        
+        SkBitmap bm;
+        bm.setConfig(SkBitmap::kARGB_8888_Config, w, h);
+        bm.allocPixels();
+        bm.eraseColor(0);
+        
+        SkAutoLockPixels alp(bm);
+
+        SkScalar cx = radius;
+        SkScalar cy = radius;
+        for (int y = 0; y < h; y += 1) {
+            for (int x = 0; x < w; x += 1) {
+                float d = sqrtf((x - cx)*(x - cx) + (y - cy)*(y - cy));
+                if (d <= radius) {
+                    *bm.getAddr32(x, y) = SkPackARGB32(0xFF, 0, 0, 0);
+                }
+            }
+        }
+        
+        canvas->drawBitmap(bm, 0, 0, NULL);
+    }
+
+    virtual void onDrawContent(SkCanvas* canvas) {
+        SkScalar radius = 256;
+        canvas->translate(10, 10);
+
+        draw_real_circle(canvas, radius);
+        
+        SkPaint paint;
+        paint.setAntiAlias(true);
+
+        paint.setColor(0x80FF0000);
+        canvas->drawCircle(radius, radius, radius, paint);
+
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(radius);
+        paint.setColor(0x8000FF00);
+        canvas->drawCircle(radius, radius, radius/2, paint);
+    }
+    
+private:
+    typedef SkView INHERITED;
+};
+
+static bool hittest(const SkPoint& target, SkScalar x, SkScalar y) {
+    const SkScalar TOL = 7;
+    return SkPoint::Distance(target, SkPoint::Make(x, y)) <= TOL;
+}
+
+static int getOnCurvePoints(const SkPath& path, SkPoint storage[]) {
+    SkPath::RawIter iter(path);
+    SkPoint pts[4];
+    SkPath::Verb verb;
+
+    int count = 0;
+    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+        switch (verb) {
+            case SkPath::kMove_Verb:
+            case SkPath::kLine_Verb:
+            case SkPath::kQuad_Verb:
+            case SkPath::kCubic_Verb:
+                storage[count++] = pts[0];
+                break;
+            default:
+                break;
+        }
+    }
+    return count;
+}
+
+#include "SkPathMeasure.h"
+
+class TestStrokeView : public SampleView {
+    enum {
+        SKELETON_COLOR = 0xFF0000FF,
+        WIREFRAME_COLOR = 0x80FF0000
+    };
+
+    enum {
+        kCount = 9
+    };
+    SkPoint fPts[kCount];
+    SkScalar fWidth, fDWidth;
+public:
+    TestStrokeView() {
+        this->setBGColor(SK_ColorLTGRAY);
+
+        fPts[0].set(50, 200);
+        fPts[1].set(50, 100);
+        fPts[2].set(150, 50);
+        fPts[3].set(300, 50);
+        
+        fPts[4].set(350, 200);
+        fPts[5].set(350, 100);
+        fPts[6].set(450, 50);
+        
+        fPts[7].set(200, 200);
+        fPts[8].set(400, 400);
+        
+        fWidth = 50;
+        fDWidth = 0.25f;
+    }
+    
+protected:
+    virtual bool onQuery(SkEvent* evt) SK_OVERRIDE {
+        if (SampleCode::TitleQ(*evt)) {
+            SampleCode::TitleR(evt, "RotateCircles3");
+            return true;
+        }
+        return this->INHERITED::onQuery(evt);
+    }
+
+    void draw_points(SkCanvas* canvas, const SkPath& path, SkColor color,
+                     bool show_lines) {
+        SkPaint paint;
+        paint.setColor(color);
+        paint.setAlpha(0x80);
+        
+        int n = path.countPoints();
+        SkAutoSTArray<32, SkPoint> pts(n);
+        if (show_lines) {
+            path.getPoints(pts.get(), n);
+            canvas->drawPoints(SkCanvas::kPolygon_PointMode, n, pts.get(), paint);
+        } else {
+            n = getOnCurvePoints(path, pts.get());
+        }
+        paint.setStrokeWidth(5);
+        canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts.get(), paint);
+    }
+
+    void draw_ribs(SkCanvas* canvas, const SkPath& path, SkScalar width,
+                   SkColor color) {
+        const SkScalar radius = width / 2;
+
+        SkPathMeasure meas(path, false);
+        SkScalar total = meas.getLength();
+        
+        SkScalar delta = 8;
+        SkPaint paint;
+        paint.setColor(color);
+
+        SkPoint pos, tan;
+        for (SkScalar dist = 0; dist <= total; dist += delta) {
+            (void)meas.getPosTan(dist, &pos, &tan);
+            tan.scale(radius);
+            tan.rotateCCW();
+            canvas->drawLine(pos.x() + tan.x(), pos.y() + tan.y(),
+                             pos.x() - tan.x(), pos.y() - tan.y(), paint);
+        }
+    }
+
+    void draw_stroke(SkCanvas* canvas, const SkPath& path, SkScalar width) {
+        SkPaint paint;
+        paint.setAntiAlias(true);
+        paint.setStyle(SkPaint::kStroke_Style);
+
+        paint.setColor(SKELETON_COLOR);
+        canvas->drawPath(path, paint);
+        draw_points(canvas, path, SKELETON_COLOR, true);
+
+        draw_ribs(canvas, path, width, 0xFF00FF00);
+
+        SkPath fill;
+
+        SkPaint p;
+        p.setStyle(SkPaint::kStroke_Style);
+        p.setStrokeWidth(width);
+        p.getFillPath(path, &fill);
+
+        paint.setColor(WIREFRAME_COLOR);
+        canvas->drawPath(fill, paint);
+        draw_points(canvas, fill, WIREFRAME_COLOR, false);
+    }
+
+    virtual void onDrawContent(SkCanvas* canvas) {
+        SkPath path;
+        SkScalar width = fWidth;
+        
+        path.moveTo(fPts[0]);
+        path.cubicTo(fPts[1], fPts[2], fPts[3]);
+        draw_stroke(canvas, path, width);
+
+        path.reset();
+        path.moveTo(fPts[4]);
+        path.quadTo(fPts[5], fPts[6]);
+        draw_stroke(canvas, path, width);
+
+        SkScalar rad = 32;
+        SkRect r;
+        r.set(&fPts[7], 2);
+        path.reset();
+        SkRRect rr;
+        rr.setRectXY(r, rad, rad);
+        path.addRRect(rr);
+        draw_stroke(canvas, path, width);
+        
+        path.reset();
+        SkRRect rr2;
+        rr.inset(width/2, width/2, &rr2);
+        path.addRRect(rr2, SkPath::kCCW_Direction);
+        rr.inset(-width/2, -width/2, &rr2);
+        path.addRRect(rr2, SkPath::kCW_Direction);
+        SkPaint paint;
+        paint.setAntiAlias(true);
+        paint.setColor(0x40FF8844);
+        canvas->drawPath(path, paint);
+        
+        fWidth += fDWidth;
+        if (fDWidth > 0 && fWidth > 100) {
+            fDWidth = -fDWidth;
+        } else if (fDWidth < 0 && fWidth < 10) {
+            fDWidth = -fDWidth;
+        }
+        this->inval(NULL);
+    }
+
+    class MyClick : public Click {
+    public:
+        int fIndex;
+        MyClick(SkView* target, int index) : Click(target), fIndex(index) {}
+    };
+
+    virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
+        for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
+            if (hittest(fPts[i], x, y)) {
+                return new MyClick(this, i);
+            }
+        }
+        return this->INHERITED::onFindClickHandler(x, y);
+    }
+    
+    virtual bool onClick(Click* click) {
+        int index = ((MyClick*)click)->fIndex;
+        fPts[index].offset(click->fICurr.fX - click->fIPrev.fX,
+                           click->fICurr.fY - click->fIPrev.fY);
+        this->inval(NULL);
+        return true;
+    }
+
+private:
+    typedef SkView INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 static SkView* F0() { return new RotateCirclesView; }
 static SkViewRegister gR0(F0);
+static SkView* F1() { return new TestCirclesView; }
+static SkViewRegister gR1(F1);
+static SkView* F2() { return new TestStrokeView; }
+static SkViewRegister gR2(F2);
 
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index cf454da..dab4ebd 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -13,7 +13,7 @@
 
 // we always return an opaque color, 'cause I don't know what to do with
 // the alpha-component and still return a valid premultiplied color.
-SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst) {
+SkPMColor SkPixelXorXfermode::xferColor(SkPMColor src, SkPMColor dst) const {
     SkPMColor res = src ^ dst ^ fOpColor;
     res |= (SK_A32_MASK << SK_A32_SHIFT);   // force it to be opaque
     return res;