Expose debugger backend classes externally.

SkDebugCanvas & friends are useful beyond the Qt debugger app - Chromium's picture inspector (in development) is at the point where it could take advantage of it.

This patch moves SkDrawCommand, SkDebugCanvas & SkObjectParser from trunk/debugger to trunk/src/utils (since several tools already use these, this seems appropriate), and makes SkDrawCommand & SkDebugCanvas' symbols visible externally (SK_API).

R=reed@google.com

Review URL: https://codereview.chromium.org/16638014

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

6 files changed, 0 insertions, 2640 deletions

diff --git a/debugger/SkDebugCanvas.cpp b/debugger/SkDebugCanvas.cpp
deleted file mode 100644
index 199c4c9b0a..0000000000
--- a/debugger/SkDebugCanvas.cpp
+++ /dev/null
@@ -1,430 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#include "SkColorPriv.h"
-#include "SkDebugCanvas.h"
-#include "SkDrawCommand.h"
-#include "SkDrawFilter.h"
-#include "SkDevice.h"
-#include "SkXfermode.h"
-
-#ifdef SK_BUILD_FOR_WIN
-    // iostream includes xlocale which generates warning 4530 because we're compiling without
-    // exceptions
-    #pragma warning(push)
-    #pragma warning(disable : 4530)
-#endif
-#include <iostream>
-#ifdef SK_BUILD_FOR_WIN
-    #pragma warning(pop)
-#endif
-
-static SkBitmap make_noconfig_bm(int width, int height) {
-    SkBitmap bm;
-    bm.setConfig(SkBitmap::kNo_Config, width, height);
-    return bm;
-}
-
-SkDebugCanvas::SkDebugCanvas(int width, int height)
-        : INHERITED(make_noconfig_bm(width, height))
-        , fOverdrawViz(false)
-        , fOverdrawFilter(NULL)
-        , fOutstandingSaveCount(0) {
-    // TODO(chudy): Free up memory from all draw commands in destructor.
-    fWidth = width;
-    fHeight = height;
-    // do we need fBm anywhere?
-    fBm.setConfig(SkBitmap::kNo_Config, fWidth, fHeight);
-    fFilter = false;
-    fIndex = 0;
-    fUserMatrix.reset();
-}
-
-SkDebugCanvas::~SkDebugCanvas() {
-    fCommandVector.deleteAll();
-    SkSafeUnref(fOverdrawFilter);
-}
-
-void SkDebugCanvas::addDrawCommand(SkDrawCommand* command) {
-    fCommandVector.push(command);
-}
-
-void SkDebugCanvas::draw(SkCanvas* canvas) {
-    if(!fCommandVector.isEmpty()) {
-        for (int i = 0; i < fCommandVector.count(); i++) {
-            if (fCommandVector[i]->isVisible()) {
-                fCommandVector[i]->execute(canvas);
-            }
-        }
-    }
-    fIndex = fCommandVector.count() - 1;
-}
-
-void SkDebugCanvas::applyUserTransform(SkCanvas* canvas) {
-    canvas->concat(fUserMatrix);
-}
-
-int SkDebugCanvas::getCommandAtPoint(int x, int y, int index) {
-    SkBitmap bitmap;
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
-    bitmap.allocPixels();
-
-    SkCanvas canvas(bitmap);
-    canvas.translate(SkIntToScalar(-x), SkIntToScalar(-y));
-    applyUserTransform(&canvas);
-
-    int layer = 0;
-    SkColor prev = bitmap.getColor(0,0);
-    for (int i = 0; i < index; i++) {
-        if (fCommandVector[i]->isVisible()) {
-            fCommandVector[i]->execute(&canvas);
-        }
-        if (prev != bitmap.getColor(0,0)) {
-            layer = i;
-        }
-        prev = bitmap.getColor(0,0);
-    }
-    return layer;
-}
-
-static SkPMColor OverdrawXferModeProc(SkPMColor src, SkPMColor dst) {
-    // This table encodes the color progression of the overdraw visualization
-    static const SkPMColor gTable[] = {
-        SkPackARGB32(0x00, 0x00, 0x00, 0x00),
-        SkPackARGB32(0xFF, 128, 158, 255),
-        SkPackARGB32(0xFF, 170, 185, 212),
-        SkPackARGB32(0xFF, 213, 195, 170),
-        SkPackARGB32(0xFF, 255, 192, 127),
-        SkPackARGB32(0xFF, 255, 185, 85),
-        SkPackARGB32(0xFF, 255, 165, 42),
-        SkPackARGB32(0xFF, 255, 135, 0),
-        SkPackARGB32(0xFF, 255,  95, 0),
-        SkPackARGB32(0xFF, 255,  50, 0),
-        SkPackARGB32(0xFF, 255,  0, 0)
-    };
-
-    for (size_t i = 0; i < SK_ARRAY_COUNT(gTable)-1; ++i) {
-        if (gTable[i] == dst) {
-            return gTable[i+1];
-        }
-    }
-
-    return gTable[SK_ARRAY_COUNT(gTable)-1];
-}
-
-// The OverdrawFilter modifies every paint to use an SkProcXfermode which
-// in turn invokes OverdrawXferModeProc
-class OverdrawFilter : public SkDrawFilter {
-public:
-    OverdrawFilter() {
-        fXferMode = new SkProcXfermode(OverdrawXferModeProc);
-    }
-
-    virtual ~OverdrawFilter() {
-        delete fXferMode;
-    }
-
-    virtual bool filter(SkPaint* p, Type) SK_OVERRIDE {
-        p->setXfermode(fXferMode);
-        return true;
-    }
-
-protected:
-    SkXfermode* fXferMode;
-
-private:
-    typedef SkDrawFilter INHERITED;
-};
-
-void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) {
-    SkASSERT(!fCommandVector.isEmpty());
-    SkASSERT(index < fCommandVector.count());
-    int i;
-
-    // This only works assuming the canvas and device are the same ones that
-    // were previously drawn into because they need to preserve all saves
-    // and restores.
-    if (fIndex < index) {
-        i = fIndex + 1;
-    } else {
-        for (int j = 0; j < fOutstandingSaveCount; j++) {
-            canvas->restore();
-        }
-        i = 0;
-        canvas->clear(SK_ColorTRANSPARENT);
-        canvas->resetMatrix();
-        SkRect rect = SkRect::MakeWH(SkIntToScalar(fWidth),
-                                     SkIntToScalar(fHeight));
-        canvas->clipRect(rect, SkRegion::kReplace_Op );
-        applyUserTransform(canvas);
-        fOutstandingSaveCount = 0;
-
-        // The setting of the draw filter has to go here (rather than in
-        // SkRasterWidget) due to the canvas restores this class performs.
-        // Since the draw filter is stored in the layer stack if we
-        // call setDrawFilter on anything but the root layer odd things happen
-        if (fOverdrawViz) {
-            if (NULL == fOverdrawFilter) {
-                fOverdrawFilter = new OverdrawFilter;
-            }
-
-            if (fOverdrawFilter != canvas->getDrawFilter()) {
-                canvas->setDrawFilter(fOverdrawFilter);
-            }
-        } else {
-            canvas->setDrawFilter(NULL);
-        }
-    }
-
-    for (; i <= index; i++) {
-        if (i == index && fFilter) {
-            SkPaint p;
-            p.setColor(0xAAFFFFFF);
-            canvas->save();
-            canvas->resetMatrix();
-            SkRect mask;
-            mask.set(SkIntToScalar(0), SkIntToScalar(0),
-                    SkIntToScalar(fWidth), SkIntToScalar(fHeight));
-            canvas->clipRect(mask, SkRegion::kReplace_Op, false);
-            canvas->drawRectCoords(SkIntToScalar(0), SkIntToScalar(0),
-                    SkIntToScalar(fWidth), SkIntToScalar(fHeight), p);
-            canvas->restore();
-        }
-
-        if (fCommandVector[i]->isVisible()) {
-            fCommandVector[i]->execute(canvas);
-            fCommandVector[i]->trackSaveState(&fOutstandingSaveCount);
-        }
-    }
-    fMatrix = canvas->getTotalMatrix();
-    fClip = canvas->getTotalClip().getBounds();
-    fIndex = index;
-}
-
-void SkDebugCanvas::deleteDrawCommandAt(int index) {
-    SkASSERT(index < fCommandVector.count());
-    delete fCommandVector[index];
-    fCommandVector.remove(index);
-}
-
-SkDrawCommand* SkDebugCanvas::getDrawCommandAt(int index) {
-    SkASSERT(index < fCommandVector.count());
-    return fCommandVector[index];
-}
-
-void SkDebugCanvas::setDrawCommandAt(int index, SkDrawCommand* command) {
-    SkASSERT(index < fCommandVector.count());
-    delete fCommandVector[index];
-    fCommandVector[index] = command;
-}
-
-SkTDArray<SkString*>* SkDebugCanvas::getCommandInfo(int index) {
-    SkASSERT(index < fCommandVector.count());
-    return fCommandVector[index]->Info();
-}
-
-bool SkDebugCanvas::getDrawCommandVisibilityAt(int index) {
-    SkASSERT(index < fCommandVector.count());
-    return fCommandVector[index]->isVisible();
-}
-
-const SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() const {
-    return fCommandVector;
-}
-
-SkTDArray <SkDrawCommand*>& SkDebugCanvas::getDrawCommands() {
-    return fCommandVector;
-}
-
-// TODO(chudy): Free command string memory.
-SkTArray<SkString>* SkDebugCanvas::getDrawCommandsAsStrings() const {
-    SkTArray<SkString>* commandString = new SkTArray<SkString>(fCommandVector.count());
-    if (!fCommandVector.isEmpty()) {
-        for (int i = 0; i < fCommandVector.count(); i ++) {
-            commandString->push_back() = fCommandVector[i]->toString();
-        }
-    }
-    return commandString;
-}
-
-void SkDebugCanvas::toggleFilter(bool toggle) {
-    fFilter = toggle;
-}
-
-void SkDebugCanvas::clear(SkColor color) {
-    addDrawCommand(new Clear(color));
-}
-
-bool SkDebugCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
-    addDrawCommand(new ClipPath(path, op, doAA));
-    return true;
-}
-
-bool SkDebugCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
-    addDrawCommand(new ClipRect(rect, op, doAA));
-    return true;
-}
-
-bool SkDebugCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
-    addDrawCommand(new ClipRRect(rrect, op, doAA));
-    return true;
-}
-
-bool SkDebugCanvas::clipRegion(const SkRegion& region, SkRegion::Op op) {
-    addDrawCommand(new ClipRegion(region, op));
-    return true;
-}
-
-bool SkDebugCanvas::concat(const SkMatrix& matrix) {
-    addDrawCommand(new Concat(matrix));
-    return true;
-}
-
-void SkDebugCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
-        SkScalar top, const SkPaint* paint = NULL) {
-    addDrawCommand(new DrawBitmap(bitmap, left, top, paint));
-}
-
-void SkDebugCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
-        const SkRect* src, const SkRect& dst, const SkPaint* paint) {
-    addDrawCommand(new DrawBitmapRect(bitmap, src, dst, paint));
-}
-
-void SkDebugCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
-        const SkMatrix& matrix, const SkPaint* paint) {
-    addDrawCommand(new DrawBitmapMatrix(bitmap, matrix, paint));
-}
-
-void SkDebugCanvas::drawBitmapNine(const SkBitmap& bitmap,
-        const SkIRect& center, const SkRect& dst, const SkPaint* paint) {
-    addDrawCommand(new DrawBitmapNine(bitmap, center, dst, paint));
-}
-
-void SkDebugCanvas::drawData(const void* data, size_t length) {
-    addDrawCommand(new DrawData(data, length));
-}
-
-void SkDebugCanvas::beginCommentGroup(const char* description) {
-    addDrawCommand(new BeginCommentGroup(description));
-}
-
-void SkDebugCanvas::addComment(const char* kywd, const char* value) {
-    addDrawCommand(new Comment(kywd, value));
-}
-
-void SkDebugCanvas::endCommentGroup() {
-    addDrawCommand(new EndCommentGroup());
-}
-
-void SkDebugCanvas::drawOval(const SkRect& oval, const SkPaint& paint) {
-    addDrawCommand(new DrawOval(oval, paint));
-}
-
-void SkDebugCanvas::drawPaint(const SkPaint& paint) {
-    addDrawCommand(new DrawPaint(paint));
-}
-
-void SkDebugCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
-    addDrawCommand(new DrawPath(path, paint));
-}
-
-void SkDebugCanvas::drawPicture(SkPicture& picture) {
-    addDrawCommand(new DrawPicture(picture));
-}
-
-void SkDebugCanvas::drawPoints(PointMode mode, size_t count,
-                               const SkPoint pts[], const SkPaint& paint) {
-    addDrawCommand(new DrawPoints(mode, count, pts, paint));
-}
-
-void SkDebugCanvas::drawPosText(const void* text, size_t byteLength,
-        const SkPoint pos[], const SkPaint& paint) {
-    addDrawCommand(new DrawPosText(text, byteLength, pos, paint));
-}
-
-void SkDebugCanvas::drawPosTextH(const void* text, size_t byteLength,
-        const SkScalar xpos[], SkScalar constY, const SkPaint& paint) {
-    addDrawCommand(new DrawPosTextH(text, byteLength, xpos, constY, paint));
-}
-
-void SkDebugCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
-    // NOTE(chudy): Messing up when renamed to DrawRect... Why?
-    addDrawCommand(new DrawRectC(rect, paint));
-}
-
-void SkDebugCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
-    addDrawCommand(new DrawRRect(rrect, paint));
-}
-
-void SkDebugCanvas::drawSprite(const SkBitmap& bitmap, int left, int top,
-                               const SkPaint* paint = NULL) {
-    addDrawCommand(new DrawSprite(bitmap, left, top, paint));
-}
-
-void SkDebugCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
-        SkScalar y, const SkPaint& paint) {
-    addDrawCommand(new DrawTextC(text, byteLength, x, y, paint));
-}
-
-void SkDebugCanvas::drawTextOnPath(const void* text, size_t byteLength,
-        const SkPath& path, const SkMatrix* matrix, const SkPaint& paint) {
-    addDrawCommand(new DrawTextOnPath(text, byteLength, path, matrix, paint));
-}
-
-void SkDebugCanvas::drawVertices(VertexMode vmode, int vertexCount,
-        const SkPoint vertices[], const SkPoint texs[], const SkColor colors[],
-        SkXfermode*, const uint16_t indices[], int indexCount,
-        const SkPaint& paint) {
-    addDrawCommand(new DrawVertices(vmode, vertexCount, vertices, texs, colors,
-            NULL, indices, indexCount, paint));
-}
-
-void SkDebugCanvas::restore() {
-    addDrawCommand(new Restore());
-}
-
-bool SkDebugCanvas::rotate(SkScalar degrees) {
-    addDrawCommand(new Rotate(degrees));
-    return true;
-}
-
-int SkDebugCanvas::save(SaveFlags flags) {
-    addDrawCommand(new Save(flags));
-    return true;
-}
-
-int SkDebugCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
-        SaveFlags flags) {
-    addDrawCommand(new SaveLayer(bounds, paint, flags));
-    return true;
-}
-
-bool SkDebugCanvas::scale(SkScalar sx, SkScalar sy) {
-    addDrawCommand(new Scale(sx, sy));
-    return true;
-}
-
-void SkDebugCanvas::setMatrix(const SkMatrix& matrix) {
-    addDrawCommand(new SetMatrix(matrix));
-}
-
-bool SkDebugCanvas::skew(SkScalar sx, SkScalar sy) {
-    addDrawCommand(new Skew(sx, sy));
-    return true;
-}
-
-bool SkDebugCanvas::translate(SkScalar dx, SkScalar dy) {
-    addDrawCommand(new Translate(dx, dy));
-    return true;
-}
-
-void SkDebugCanvas::toggleCommand(int index, bool toggle) {
-    SkASSERT(index < fCommandVector.count());
-    fCommandVector[index]->setVisible(toggle);
-}
diff --git a/debugger/SkDebugCanvas.h b/debugger/SkDebugCanvas.h
deleted file mode 100644
index bcb2bbf028..0000000000
--- a/debugger/SkDebugCanvas.h
+++ /dev/null
@@ -1,273 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#ifndef SKDEBUGCANVAS_H_
-#define SKDEBUGCANVAS_H_
-
-#include "SkCanvas.h"
-#include "SkDrawCommand.h"
-#include "SkPicture.h"
-#include "SkTArray.h"
-#include "SkString.h"
-
-class SkDebugCanvas : public SkCanvas {
-public:
-    SkDebugCanvas(int width, int height);
-    virtual ~SkDebugCanvas();
-
-    void toggleFilter(bool toggle);
-
-    /**
-     * Enable or disable overdraw visualization
-     */
-    void setOverdrawViz(bool overdrawViz) { fOverdrawViz = overdrawViz; }
-
-    /**
-        Executes all draw calls to the canvas.
-        @param canvas  The canvas being drawn to
-     */
-    void draw(SkCanvas* canvas);
-
-    /**
-        Executes the draw calls in the specified range.
-        @param canvas  The canvas being drawn to
-        @param i  The beginning of the range
-        @param j  The end of the range
-        TODO(chudy): Implement
-     */
-    void drawRange(SkCanvas* canvas, int i, int j);
-
-    /**
-        Executes the draw calls up to the specified index.
-        @param canvas  The canvas being drawn to
-        @param index  The index of the final command being executed
-     */
-    void drawTo(SkCanvas* canvas, int index);
-
-    /**
-        Returns the most recently calculated transformation matrix
-     */
-    const SkMatrix& getCurrentMatrix() {
-        return fMatrix;
-    }
-
-    /**
-        Returns the most recently calculated clip
-     */
-    const SkIRect& getCurrentClip() {
-        return fClip;
-    }
-
-    /**
-        Returns the index of the last draw command to write to the pixel at (x,y)
-     */
-    int getCommandAtPoint(int x, int y, int index);
-
-    /**
-        Removes the command at the specified index
-        @param index  The index of the command to delete
-     */
-    void deleteDrawCommandAt(int index);
-
-    /**
-        Returns the draw command at the given index.
-        @param index  The index of the command
-     */
-    SkDrawCommand* getDrawCommandAt(int index);
-
-    /**
-        Sets the draw command for a given index.
-        @param index  The index to overwrite
-        @param command The new command
-     */
-    void setDrawCommandAt(int index, SkDrawCommand* command);
-
-    /**
-        Returns information about the command at the given index.
-        @param index  The index of the command
-     */
-    SkTDArray<SkString*>* getCommandInfo(int index);
-
-    /**
-        Returns the visibility of the command at the given index.
-        @param index  The index of the command
-     */
-    bool getDrawCommandVisibilityAt(int index);
-
-    /**
-        Returns the vector of draw commands
-        DEPRECATED: please use getDrawCommandAt and getSize instead
-     */
-    const SkTDArray<SkDrawCommand*>& getDrawCommands() const;
-
-    /**
-        Returns the vector of draw commands. Do not use this entry
-        point - it is going away!
-     */
-    SkTDArray<SkDrawCommand*>& getDrawCommands();
-
-    /**
-     * Returns the string vector of draw commands
-     */
-    SkTArray<SkString>* getDrawCommandsAsStrings() const;
-
-    /**
-        Returns length of draw command vector.
-     */
-    int getSize() {
-        return fCommandVector.count();
-    }
-
-    /**
-        Toggles the visibility / execution of the draw command at index i with
-        the value of toggle.
-     */
-    void toggleCommand(int index, bool toggle);
-
-    void setBounds(int width, int height) {
-        fWidth = width;
-        fHeight = height;
-    }
-
-    void setUserMatrix(SkMatrix matrix) {
-        fUserMatrix = matrix;
-    }
-
-////////////////////////////////////////////////////////////////////////////////
-// Inherited from SkCanvas
-////////////////////////////////////////////////////////////////////////////////
-
-    virtual void clear(SkColor) SK_OVERRIDE;
-
-    virtual bool clipPath(const SkPath&, SkRegion::Op, bool) SK_OVERRIDE;
-
-    virtual bool clipRect(const SkRect&, SkRegion::Op, bool) SK_OVERRIDE;
-
-    virtual bool clipRRect(const SkRRect& rrect,
-                           SkRegion::Op op = SkRegion::kIntersect_Op,
-                           bool doAntiAlias = false) SK_OVERRIDE;
-
-    virtual bool clipRegion(const SkRegion& region, SkRegion::Op op) SK_OVERRIDE;
-
-    virtual bool concat(const SkMatrix& matrix) SK_OVERRIDE;
-
-    virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
-                            const SkPaint*) SK_OVERRIDE;
-
-    virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
-                                  const SkRect& dst, const SkPaint*) SK_OVERRIDE;
-
-    virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
-                                  const SkPaint*) SK_OVERRIDE;
-
-    virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-                                const SkRect& dst, const SkPaint*) SK_OVERRIDE;
-
-    virtual void drawData(const void*, size_t) SK_OVERRIDE;
-
-    virtual void beginCommentGroup(const char* description) SK_OVERRIDE;
-
-    virtual void addComment(const char* kywd, const char* value) SK_OVERRIDE;
-
-    virtual void endCommentGroup() SK_OVERRIDE;
-
-    virtual void drawOval(const SkRect& oval, const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
-
-    virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawPicture(SkPicture& picture) SK_OVERRIDE;
-
-    virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
-                            const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawPosText(const void* text, size_t byteLength,
-                             const SkPoint pos[], const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawPosTextH(const void* text, size_t byteLength,
-                              const SkScalar xpos[], SkScalar constY,
-                              const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawRect(const SkRect& rect, const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint) SK_OVERRIDE;
-
-    virtual void drawSprite(const SkBitmap&, int left, int top,
-                            const SkPaint*) SK_OVERRIDE;
-
-    virtual void drawText(const void* text, size_t byteLength, SkScalar x,
-                          SkScalar y, const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawTextOnPath(const void* text, size_t byteLength,
-                                const SkPath& path, const SkMatrix* matrix,
-                                const SkPaint&) SK_OVERRIDE;
-
-    virtual void drawVertices(VertexMode, int vertexCount,
-                              const SkPoint vertices[], const SkPoint texs[],
-                              const SkColor colors[], SkXfermode*,
-                              const uint16_t indices[], int indexCount,
-                              const SkPaint&) SK_OVERRIDE;
-
-    virtual void restore() SK_OVERRIDE;
-
-    virtual bool rotate(SkScalar degrees) SK_OVERRIDE;
-
-    virtual int save(SaveFlags) SK_OVERRIDE;
-
-    virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE;
-
-    virtual bool scale(SkScalar sx, SkScalar sy) SK_OVERRIDE;
-
-    virtual void setMatrix(const SkMatrix& matrix) SK_OVERRIDE;
-
-    virtual bool skew(SkScalar sx, SkScalar sy) SK_OVERRIDE;
-
-    virtual bool translate(SkScalar dx, SkScalar dy) SK_OVERRIDE;
-
-    static const int kVizImageHeight = 256;
-    static const int kVizImageWidth = 256;
-
-private:
-    SkTDArray<SkDrawCommand*> fCommandVector;
-    int fHeight;
-    int fWidth;
-    SkBitmap fBm;
-    bool fFilter;
-    int fIndex;
-    SkMatrix fUserMatrix;
-    SkMatrix fMatrix;
-    SkIRect fClip;
-    bool fOverdrawViz;
-    SkDrawFilter* fOverdrawFilter;
-
-    /**
-        Number of unmatched save() calls at any point during a draw.
-        If there are any saveLayer() calls outstanding, we need to resolve
-        all of them, which in practice means resolving all save() calls,
-        to avoid corruption of our canvas.
-    */
-    int fOutstandingSaveCount;
-
-    /**
-        Adds the command to the classes vector of commands.
-        @param command  The draw command for execution
-     */
-    void addDrawCommand(SkDrawCommand* command);
-
-    /**
-        Applies any panning and zooming the user has specified before
-        drawing anything else into the canvas.
-     */
-    void applyUserTransform(SkCanvas* canvas);
-
-    typedef SkCanvas INHERITED;
-};
-
-#endif
diff --git a/debugger/SkDrawCommand.cpp b/debugger/SkDrawCommand.cpp
deleted file mode 100644
index c9d9a47da3..0000000000
--- a/debugger/SkDrawCommand.cpp
+++ /dev/null
@@ -1,878 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-
-#include "SkDrawCommand.h"
-#include "SkObjectParser.h"
-
-// TODO(chudy): Refactor into non subclass model.
-
-SkDrawCommand::SkDrawCommand(DrawType type)
-    : fDrawType(type)
-    , fVisible(true) {
-}
-
-SkDrawCommand::SkDrawCommand() {
-    fVisible = true;
-}
-
-SkDrawCommand::~SkDrawCommand() {
-    fInfo.deleteAll();
-}
-
-const char* SkDrawCommand::GetCommandString(DrawType type) {
-    switch (type) {
-        case UNUSED: SkDEBUGFAIL("DrawType UNUSED\n"); break;
-        case DRAW_CLEAR: return "Clear";
-        case CLIP_PATH: return "Clip Path";
-        case CLIP_REGION: return "Clip Region";
-        case CLIP_RECT: return "Clip Rect";
-        case CLIP_RRECT: return "Clip RRect";
-        case CONCAT: return "Concat";
-        case DRAW_BITMAP: return "Draw Bitmap";
-        case DRAW_BITMAP_MATRIX: return "Draw Bitmap Matrix";
-        case DRAW_BITMAP_NINE: return "Draw Bitmap Nine";
-        case DRAW_BITMAP_RECT_TO_RECT: return "Draw Bitmap Rect";
-        case DRAW_DATA: return "Draw Data";
-        case DRAW_OVAL: return "Draw Oval";
-        case DRAW_PAINT: return "Draw Paint";
-        case DRAW_PATH: return "Draw Path";
-        case DRAW_PICTURE: return "Draw Picture";
-        case DRAW_POINTS: return "Draw Points";
-        case DRAW_POS_TEXT: return "Draw Pos Text";
-        case DRAW_POS_TEXT_H: return "Draw Pos Text H";
-        case DRAW_RECT: return "Draw Rect";
-        case DRAW_RRECT: return "Draw RRect";
-        case DRAW_SPRITE: return "Draw Sprite";
-        case DRAW_TEXT: return "Draw Text";
-        case DRAW_TEXT_ON_PATH: return "Draw Text On Path";
-        case DRAW_VERTICES: return "Draw Vertices";
-        case RESTORE: return "Restore";
-        case ROTATE: return "Rotate";
-        case SAVE: return "Save";
-        case SAVE_LAYER: return "Save Layer";
-        case SCALE: return "Scale";
-        case SET_MATRIX: return "Set Matrix";
-        case SKEW: return "Skew";
-        case TRANSLATE: return "Translate";
-        case NOOP: return "NoOp";
-        case BEGIN_COMMENT_GROUP: return "BeginCommentGroup";
-        case COMMENT: return "Comment";
-        case END_COMMENT_GROUP: return "EndCommentGroup";
-        default:
-            SkDebugf("DrawType error 0x%08x\n", type);
-            SkASSERT(0);
-            break;
-    }
-    SkDEBUGFAIL("DrawType UNUSED\n");
-    return NULL;
-}
-
-SkString SkDrawCommand::toString() {
-    return SkString(GetCommandString(fDrawType));
-}
-
-Clear::Clear(SkColor color) {
-    fColor = color;
-    fDrawType = DRAW_CLEAR;
-    fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
-}
-
-void Clear::execute(SkCanvas* canvas) {
-    canvas->clear(fColor);
-}
-
-namespace {
-
-void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
-    const SkISize& size = canvas->getDeviceSize();
-
-    static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
-
-    canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
-    if (bounds.width() > bounds.height()) {
-        canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.width()),
-                      SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.width()));
-    } else {
-        canvas->scale(SkDoubleToScalar((kInsetFrac*size.fWidth)/bounds.height()),
-                      SkDoubleToScalar((kInsetFrac*size.fHeight)/bounds.height()));
-    }
-    canvas->translate(-bounds.centerX(), -bounds.centerY());
-}
-
-
-void render_path(SkCanvas* canvas, const SkPath& path) {
-    canvas->clear(0xFFFFFFFF);
-    canvas->save();
-
-    const SkRect& bounds = path.getBounds();
-
-    xlate_and_scale_to_bounds(canvas, bounds);
-
-    SkPaint p;
-    p.setColor(SK_ColorBLACK);
-    p.setStyle(SkPaint::kStroke_Style);
-
-    canvas->drawPath(path, p);
-    canvas->restore();
-}
-
-void render_bitmap(SkCanvas* canvas, const SkBitmap& input, const SkRect* srcRect = NULL) {
-    const SkISize& size = canvas->getDeviceSize();
-
-    SkScalar xScale = SkIntToScalar(size.fWidth-2) / input.width();
-    SkScalar yScale = SkIntToScalar(size.fHeight-2) / input.height();
-
-    if (input.width() > input.height()) {
-        yScale *= input.height() / (float) input.width();
-    } else {
-        xScale *= input.width() / (float) input.height();
-    }
-
-    SkRect dst = SkRect::MakeXYWH(SK_Scalar1, SK_Scalar1,
-                                  xScale * input.width(),
-                                  yScale * input.height());
-
-    canvas->clear(0xFFFFFFFF);
-    canvas->drawBitmapRect(input, NULL, dst);
-
-    if (NULL != srcRect) {
-        SkRect r = SkRect::MakeLTRB(srcRect->fLeft * xScale + SK_Scalar1,
-                                    srcRect->fTop * yScale + SK_Scalar1,
-                                    srcRect->fRight * xScale + SK_Scalar1,
-                                    srcRect->fBottom * yScale + SK_Scalar1);
-        SkPaint p;
-        p.setColor(SK_ColorRED);
-        p.setStyle(SkPaint::kStroke_Style);
-
-        canvas->drawRect(r, p);
-    }
-}
-
-void render_rrect(SkCanvas* canvas, const SkRRect& rrect) {
-    canvas->clear(0xFFFFFFFF);
-    canvas->save();
-
-    const SkRect& bounds = rrect.getBounds();
-
-    xlate_and_scale_to_bounds(canvas, bounds);
-
-    SkPaint p;
-    p.setColor(SK_ColorBLACK);
-    p.setStyle(SkPaint::kStroke_Style);
-
-    canvas->drawRRect(rrect, p);
-    canvas->restore();
-}
-
-};
-
-
-ClipPath::ClipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
-    fPath = path;
-    fOp = op;
-    fDoAA = doAA;
-    fDrawType = CLIP_PATH;
-
-    fInfo.push(SkObjectParser::PathToString(path));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
-    fInfo.push(SkObjectParser::BoolToString(doAA));
-}
-
-void ClipPath::execute(SkCanvas* canvas) {
-    canvas->clipPath(fPath, fOp, fDoAA);
-}
-
-bool ClipPath::render(SkCanvas* canvas) const {
-    render_path(canvas, fPath);
-    return true;
-}
-
-ClipRegion::ClipRegion(const SkRegion& region, SkRegion::Op op) {
-    fRegion = region;
-    fOp = op;
-    fDrawType = CLIP_REGION;
-
-    fInfo.push(SkObjectParser::RegionToString(region));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
-}
-
-void ClipRegion::execute(SkCanvas* canvas) {
-    canvas->clipRegion(fRegion, fOp);
-}
-
-ClipRect::ClipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
-    fRect = rect;
-    fOp = op;
-    fDoAA = doAA;
-    fDrawType = CLIP_RECT;
-
-    fInfo.push(SkObjectParser::RectToString(rect));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
-    fInfo.push(SkObjectParser::BoolToString(doAA));
-}
-
-void ClipRect::execute(SkCanvas* canvas) {
-    canvas->clipRect(fRect, fOp, fDoAA);
-}
-
-ClipRRect::ClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
-    fRRect = rrect;
-    fOp = op;
-    fDoAA = doAA;
-    fDrawType = CLIP_RRECT;
-
-    fInfo.push(SkObjectParser::RRectToString(rrect));
-    fInfo.push(SkObjectParser::RegionOpToString(op));
-    fInfo.push(SkObjectParser::BoolToString(doAA));
-}
-
-void ClipRRect::execute(SkCanvas* canvas) {
-    canvas->clipRRect(fRRect, fOp, fDoAA);
-}
-
-bool ClipRRect::render(SkCanvas* canvas) const {
-    render_rrect(canvas, fRRect);
-    return true;
-}
-
-Concat::Concat(const SkMatrix& matrix) {
-    fMatrix = matrix;
-    fDrawType = CONCAT;
-
-    fInfo.push(SkObjectParser::MatrixToString(matrix));
-}
-
-void Concat::execute(SkCanvas* canvas) {
-    canvas->concat(fMatrix);
-}
-
-DrawBitmap::DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-                       const SkPaint* paint) {
-    fBitmap = bitmap;
-    fLeft = left;
-    fTop = top;
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fDrawType = DRAW_BITMAP;
-
-    fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
-    fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-}
-
-void DrawBitmap::execute(SkCanvas* canvas) {
-    canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
-}
-
-bool DrawBitmap::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap);
-    return true;
-}
-
-DrawBitmapMatrix::DrawBitmapMatrix(const SkBitmap& bitmap,
-                                   const SkMatrix& matrix,
-                                   const SkPaint* paint) {
-    fBitmap = bitmap;
-    fMatrix = matrix;
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fDrawType = DRAW_BITMAP_MATRIX;
-
-    fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    fInfo.push(SkObjectParser::MatrixToString(matrix));
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-}
-
-void DrawBitmapMatrix::execute(SkCanvas* canvas) {
-    canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr);
-}
-
-bool DrawBitmapMatrix::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap);
-    return true;
-}
-
-DrawBitmapNine::DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-                               const SkRect& dst, const SkPaint* paint) {
-    fBitmap = bitmap;
-    fCenter = center;
-    fDst = dst;
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fDrawType = DRAW_BITMAP_NINE;
-
-    fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    fInfo.push(SkObjectParser::IRectToString(center));
-    fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-}
-
-void DrawBitmapNine::execute(SkCanvas* canvas) {
-    canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
-}
-
-bool DrawBitmapNine::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap);
-    return true;
-}
-
-DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
-                               const SkRect& dst, const SkPaint* paint) {
-    fBitmap = bitmap;
-    if (NULL != src) {
-        fSrc = *src;
-    } else {
-        fSrc.setEmpty();
-    }
-    fDst = dst;
-
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fDrawType = DRAW_BITMAP_RECT_TO_RECT;
-
-    fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    if (NULL != src) {
-        fInfo.push(SkObjectParser::RectToString(*src, "Src: "));
-    }
-    fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-}
-
-void DrawBitmapRect::execute(SkCanvas* canvas) {
-    canvas->drawBitmapRectToRect(fBitmap, this->srcRect(), fDst, fPaintPtr);
-}
-
-bool DrawBitmapRect::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap, this->srcRect());
-    return true;
-}
-
-DrawData::DrawData(const void* data, size_t length) {
-    fData = new char[length];
-    memcpy(fData, data, length);
-    fLength = length;
-    fDrawType = DRAW_DATA;
-
-    // TODO: add display of actual data?
-    SkString* str = new SkString;
-    str->appendf("length: %d", (int) length);
-    fInfo.push(str);
-}
-
-void DrawData::execute(SkCanvas* canvas) {
-    canvas->drawData(fData, fLength);
-}
-
-BeginCommentGroup::BeginCommentGroup(const char* description)
-    : INHERITED(BEGIN_COMMENT_GROUP)
-    , fDescription(description) {
-    SkString* temp = new SkString;
-    temp->appendf("Description: %s", description);
-    fInfo.push(temp);
-}
-
-Comment::Comment(const char* kywd, const char* value)
-    : INHERITED(COMMENT)
-    , fKywd(kywd)
-    , fValue(value) {
-    SkString* temp = new SkString;
-    temp->appendf("%s: %s", kywd, value);
-    fInfo.push(temp);
-}
-
-EndCommentGroup::EndCommentGroup() : INHERITED(END_COMMENT_GROUP) {
-}
-
-DrawOval::DrawOval(const SkRect& oval, const SkPaint& paint) {
-    fOval = oval;
-    fPaint = paint;
-    fDrawType = DRAW_OVAL;
-
-    fInfo.push(SkObjectParser::RectToString(oval));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawOval::execute(SkCanvas* canvas) {
-    canvas->drawOval(fOval, fPaint);
-}
-
-bool DrawOval::render(SkCanvas* canvas) const {
-    canvas->clear(0xFFFFFFFF);
-    canvas->save();
-
-    xlate_and_scale_to_bounds(canvas, fOval);
-
-    SkPaint p;
-    p.setColor(SK_ColorBLACK);
-    p.setStyle(SkPaint::kStroke_Style);
-
-    canvas->drawOval(fOval, p);
-    canvas->restore();
-
-    return true;
-}
-
-DrawPaint::DrawPaint(const SkPaint& paint) {
-    fPaint = paint;
-    fDrawType = DRAW_PAINT;
-
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawPaint::execute(SkCanvas* canvas) {
-    canvas->drawPaint(fPaint);
-}
-
-bool DrawPaint::render(SkCanvas* canvas) const {
-    canvas->clear(0xFFFFFFFF);
-    canvas->drawPaint(fPaint);
-    return true;
-}
-
-DrawPath::DrawPath(const SkPath& path, const SkPaint& paint) {
-    fPath = path;
-    fPaint = paint;
-    fDrawType = DRAW_PATH;
-
-    fInfo.push(SkObjectParser::PathToString(path));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawPath::execute(SkCanvas* canvas) {
-    canvas->drawPath(fPath, fPaint);
-}
-
-bool DrawPath::render(SkCanvas* canvas) const {
-    render_path(canvas, fPath);
-    return true;
-}
-
-DrawPicture::DrawPicture(SkPicture& picture) :
-    fPicture(picture) {
-    fDrawType = DRAW_PICTURE;
-    fInfo.push(SkObjectParser::CustomTextToString("To be implemented."));
-}
-
-void DrawPicture::execute(SkCanvas* canvas) {
-    canvas->drawPicture(fPicture);
-}
-
-DrawPoints::DrawPoints(SkCanvas::PointMode mode, size_t count,
-                       const SkPoint pts[], const SkPaint& paint) {
-    fMode = mode;
-    fCount = count;
-    fPts = new SkPoint[count];
-    memcpy(fPts, pts, count * sizeof(SkPoint));
-    fPaint = paint;
-    fDrawType = DRAW_POINTS;
-
-    fInfo.push(SkObjectParser::PointsToString(pts, count));
-    fInfo.push(SkObjectParser::ScalarToString(SkIntToScalar((unsigned int)count),
-                                              "Points: "));
-    fInfo.push(SkObjectParser::PointModeToString(mode));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawPoints::execute(SkCanvas* canvas) {
-    canvas->drawPoints(fMode, fCount, fPts, fPaint);
-}
-
-bool DrawPoints::render(SkCanvas* canvas) const {
-    canvas->clear(0xFFFFFFFF);
-    canvas->save();
-
-    SkRect bounds;
-
-    bounds.setEmpty();
-    for (unsigned int i = 0; i < fCount; ++i) {
-        bounds.growToInclude(fPts[i].fX, fPts[i].fY);
-    }
-
-    xlate_and_scale_to_bounds(canvas, bounds);
-
-    SkPaint p;
-    p.setColor(SK_ColorBLACK);
-    p.setStyle(SkPaint::kStroke_Style);
-
-    canvas->drawPoints(fMode, fCount, fPts, p);
-    canvas->restore();
-
-    return true;
-}
-
-DrawPosText::DrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
-                         const SkPaint& paint) {
-    size_t numPts = paint.countText(text, byteLength);
-
-    fText = new char[byteLength];
-    memcpy(fText, text, byteLength);
-    fByteLength = byteLength;
-
-    fPos = new SkPoint[numPts];
-    memcpy(fPos, pos, numPts * sizeof(SkPoint));
-
-    fPaint = paint;
-    fDrawType = DRAW_POS_TEXT;
-
-    fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
-    // TODO(chudy): Test that this works.
-    fInfo.push(SkObjectParser::PointsToString(pos, 1));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawPosText::execute(SkCanvas* canvas) {
-    canvas->drawPosText(fText, fByteLength, fPos, fPaint);
-}
-
-
-DrawPosTextH::DrawPosTextH(const void* text, size_t byteLength,
-                           const SkScalar xpos[], SkScalar constY,
-                           const SkPaint& paint) {
-    size_t numPts = paint.countText(text, byteLength);
-
-    fText = new char[byteLength];
-    memcpy(fText, text, byteLength);
-    fByteLength = byteLength;
-
-    fXpos = new SkScalar[numPts];
-    memcpy(fXpos, xpos, numPts * sizeof(SkScalar));
-
-    fConstY = constY;
-    fPaint = paint;
-    fDrawType = DRAW_POS_TEXT_H;
-
-    fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
-    fInfo.push(SkObjectParser::ScalarToString(xpos[0], "XPOS: "));
-    fInfo.push(SkObjectParser::ScalarToString(constY, "SkScalar constY: "));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawPosTextH::execute(SkCanvas* canvas) {
-    canvas->drawPosTextH(fText, fByteLength, fXpos, fConstY, fPaint);
-}
-
-DrawRectC::DrawRectC(const SkRect& rect, const SkPaint& paint) {
-    fRect = rect;
-    fPaint = paint;
-    fDrawType = DRAW_RECT;
-
-    fInfo.push(SkObjectParser::RectToString(rect));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawRectC::execute(SkCanvas* canvas) {
-    canvas->drawRect(fRect, fPaint);
-}
-
-DrawRRect::DrawRRect(const SkRRect& rrect, const SkPaint& paint) {
-    fRRect = rrect;
-    fPaint = paint;
-    fDrawType = DRAW_RRECT;
-
-    fInfo.push(SkObjectParser::RRectToString(rrect));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawRRect::execute(SkCanvas* canvas) {
-    canvas->drawRRect(fRRect, fPaint);
-}
-
-bool DrawRRect::render(SkCanvas* canvas) const {
-    render_rrect(canvas, fRRect);
-    return true;
-}
-
-DrawSprite::DrawSprite(const SkBitmap& bitmap, int left, int top,
-                       const SkPaint* paint) {
-    fBitmap = bitmap;
-    fLeft = left;
-    fTop = top;
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fDrawType = DRAW_SPRITE;
-
-    fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    fInfo.push(SkObjectParser::IntToString(left, "Left: "));
-    fInfo.push(SkObjectParser::IntToString(top, "Top: "));
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-}
-
-void DrawSprite::execute(SkCanvas* canvas) {
-    canvas->drawSprite(fBitmap, fLeft, fTop, fPaintPtr);
-}
-
-bool DrawSprite::render(SkCanvas* canvas) const {
-    render_bitmap(canvas, fBitmap);
-    return true;
-}
-
-DrawTextC::DrawTextC(const void* text, size_t byteLength, SkScalar x, SkScalar y,
-                     const SkPaint& paint) {
-    fText = new char[byteLength];
-    memcpy(fText, text, byteLength);
-    fByteLength = byteLength;
-    fX = x;
-    fY = y;
-    fPaint = paint;
-    fDrawType = DRAW_TEXT;
-
-    fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
-    fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: "));
-    fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: "));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawTextC::execute(SkCanvas* canvas) {
-    canvas->drawText(fText, fByteLength, fX, fY, fPaint);
-}
-
-DrawTextOnPath::DrawTextOnPath(const void* text, size_t byteLength,
-                               const SkPath& path, const SkMatrix* matrix,
-                               const SkPaint& paint) {
-    fText = new char[byteLength];
-    memcpy(fText, text, byteLength);
-    fByteLength = byteLength;
-    fPath = path;
-    if (NULL != matrix) {
-        fMatrix = *matrix;
-    } else {
-        fMatrix.setIdentity();
-    }
-    fPaint = paint;
-    fDrawType = DRAW_TEXT_ON_PATH;
-
-    fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
-    fInfo.push(SkObjectParser::PathToString(path));
-    if (NULL != matrix) {
-        fInfo.push(SkObjectParser::MatrixToString(*matrix));
-    }
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-void DrawTextOnPath::execute(SkCanvas* canvas) {
-    canvas->drawTextOnPath(fText, fByteLength, fPath,
-                           fMatrix.isIdentity() ? NULL : &fMatrix,
-                           fPaint);
-}
-
-DrawVertices::DrawVertices(SkCanvas::VertexMode vmode, int vertexCount,
-                           const SkPoint vertices[], const SkPoint texs[],
-                           const SkColor colors[], SkXfermode* xfermode,
-                           const uint16_t indices[], int indexCount,
-                           const SkPaint& paint) {
-    fVmode = vmode;
-
-    fVertexCount = vertexCount;
-
-    fVertices = new SkPoint[vertexCount];
-    memcpy(fVertices, vertices, vertexCount * sizeof(SkPoint));
-
-    if (NULL != texs) {
-        fTexs = new SkPoint[vertexCount];
-        memcpy(fTexs, texs, vertexCount * sizeof(SkPoint));
-    } else {
-        fTexs = NULL;
-    }
-
-    if (NULL != colors) {
-        fColors = new SkColor[vertexCount];
-        memcpy(fColors, colors, vertexCount * sizeof(SkColor));
-    } else {
-        fColors = NULL;
-    }
-
-    fXfermode = xfermode;
-    if (NULL != fXfermode) {
-        fXfermode->ref();
-    }
-
-    if (indexCount > 0) {
-        fIndices = new uint16_t[indexCount];
-        memcpy(fIndices, indices, indexCount * sizeof(uint16_t));
-    } else {
-        fIndices = NULL;
-    }
-
-    fIndexCount = indexCount;
-    fPaint = paint;
-    fDrawType = DRAW_VERTICES;
-
-    // TODO(chudy)
-    fInfo.push(SkObjectParser::CustomTextToString("To be implemented."));
-    fInfo.push(SkObjectParser::PaintToString(paint));
-}
-
-DrawVertices::~DrawVertices() {
-    delete [] fVertices;
-    delete [] fTexs;
-    delete [] fColors;
-    SkSafeUnref(fXfermode);
-    delete [] fIndices;
-}
-
-void DrawVertices::execute(SkCanvas* canvas) {
-    canvas->drawVertices(fVmode, fVertexCount, fVertices,
-                         fTexs, fColors, fXfermode, fIndices,
-                         fIndexCount, fPaint);
-}
-
-Restore::Restore() {
-    fDrawType = RESTORE;
-    fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
-}
-
-void Restore::execute(SkCanvas* canvas) {
-    canvas->restore();
-}
-
-void Restore::trackSaveState(int* state) {
-    (*state)--;
-}
-
-Rotate::Rotate(SkScalar degrees) {
-    fDegrees = degrees;
-    fDrawType = ROTATE;
-
-    fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: "));
-}
-
-void Rotate::execute(SkCanvas* canvas) {
-    canvas->rotate(fDegrees);
-}
-
-Save::Save(SkCanvas::SaveFlags flags) {
-    fFlags = flags;
-    fDrawType = SAVE;
-    fInfo.push(SkObjectParser::SaveFlagsToString(flags));
-}
-
-void Save::execute(SkCanvas* canvas) {
-    canvas->save(fFlags);
-}
-
-void Save::trackSaveState(int* state) {
-    (*state)++;
-}
-
-SaveLayer::SaveLayer(const SkRect* bounds, const SkPaint* paint,
-                     SkCanvas::SaveFlags flags) {
-    if (NULL != bounds) {
-        fBounds = *bounds;
-    } else {
-        fBounds.setEmpty();
-    }
-
-    if (NULL != paint) {
-        fPaint = *paint;
-        fPaintPtr = &fPaint;
-    } else {
-        fPaintPtr = NULL;
-    }
-    fFlags = flags;
-    fDrawType = SAVE_LAYER;
-
-    if (NULL != bounds) {
-        fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: "));
-    }
-    if (NULL != paint) {
-        fInfo.push(SkObjectParser::PaintToString(*paint));
-    }
-    fInfo.push(SkObjectParser::SaveFlagsToString(flags));
-}
-
-void SaveLayer::execute(SkCanvas* canvas) {
-    canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds,
-                      fPaintPtr,
-                      fFlags);
-}
-
-void SaveLayer::trackSaveState(int* state) {
-    (*state)++;
-}
-
-Scale::Scale(SkScalar sx, SkScalar sy) {
-    fSx = sx;
-    fSy = sy;
-    fDrawType = SCALE;
-
-    fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: "));
-    fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: "));
-}
-
-void Scale::execute(SkCanvas* canvas) {
-    canvas->scale(fSx, fSy);
-}
-
-SetMatrix::SetMatrix(const SkMatrix& matrix) {
-    fMatrix = matrix;
-    fDrawType = SET_MATRIX;
-
-    fInfo.push(SkObjectParser::MatrixToString(matrix));
-}
-
-void SetMatrix::execute(SkCanvas* canvas) {
-    canvas->setMatrix(fMatrix);
-}
-
-Skew::Skew(SkScalar sx, SkScalar sy) {
-    fSx = sx;
-    fSy = sy;
-    fDrawType = SKEW;
-
-    fInfo.push(SkObjectParser::ScalarToString(sx, "SkScalar sx: "));
-    fInfo.push(SkObjectParser::ScalarToString(sy, "SkScalar sy: "));
-}
-
-void Skew::execute(SkCanvas* canvas) {
-    canvas->skew(fSx, fSy);
-}
-
-Translate::Translate(SkScalar dx, SkScalar dy) {
-    fDx = dx;
-    fDy = dy;
-    fDrawType = TRANSLATE;
-
-    fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: "));
-    fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: "));
-}
-
-void Translate::execute(SkCanvas* canvas) {
-    canvas->translate(fDx, fDy);
-}
diff --git a/debugger/SkDrawCommand.h b/debugger/SkDrawCommand.h
deleted file mode 100644
index 4b5ab0ac00..0000000000
--- a/debugger/SkDrawCommand.h
+++ /dev/null
@@ -1,556 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKDRAWCOMMAND_H_
-#define SKDRAWCOMMAND_H_
-
-#include "SkPictureFlat.h"
-#include "SkCanvas.h"
-#include "SkString.h"
-
-class SkDrawCommand {
-public:
-    /* TODO(chudy): Remove subclasses. */
-    SkDrawCommand(DrawType drawType);
-    SkDrawCommand();
-
-    virtual ~SkDrawCommand();
-
-    virtual SkString toString();
-
-    virtual const char* toCString() {
-        return GetCommandString(fDrawType);
-    }
-
-    bool isVisible() const {
-        return fVisible;
-    }
-
-    void setVisible(bool toggle) {
-        fVisible = toggle;
-    }
-
-    SkTDArray<SkString*>* Info() {return &fInfo; };
-    virtual void execute(SkCanvas* canvas)=0;
-    /** Does nothing by default, but used by save() and restore()-type
-        subclassse to track unresolved save() calls. */
-    virtual void trackSaveState(int* state) { };
-    DrawType getType() { return fDrawType; };
-
-    virtual bool render(SkCanvas* canvas) const { return false; }
-
-    static const char* GetCommandString(DrawType type);
-
-protected:
-    DrawType fDrawType;
-    SkTDArray<SkString*> fInfo;
-
-private:
-    bool fVisible;
-};
-
-class Restore : public SkDrawCommand {
-public:
-    Restore();
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual void trackSaveState(int* state) SK_OVERRIDE;
-
-private:
-    typedef SkDrawCommand INHERITED;
-};
-
-class Clear : public SkDrawCommand {
-public:
-    Clear(SkColor color);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkColor fColor;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class ClipPath : public SkDrawCommand {
-public:
-    ClipPath(const SkPath& path, SkRegion::Op op, bool doAA);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkPath       fPath;
-    SkRegion::Op fOp;
-    bool         fDoAA;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class ClipRegion : public SkDrawCommand {
-public:
-    ClipRegion(const SkRegion& region, SkRegion::Op op);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkRegion     fRegion;
-    SkRegion::Op fOp;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class ClipRect : public SkDrawCommand {
-public:
-    ClipRect(const SkRect& rect, SkRegion::Op op, bool doAA);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-
-    const SkRect& rect() const { return fRect; }
-    SkRegion::Op op() const { return fOp; }
-    bool doAA() const { return fDoAA; }
-
-private:
-    SkRect       fRect;
-    SkRegion::Op fOp;
-    bool         fDoAA;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class ClipRRect : public SkDrawCommand {
-public:
-    ClipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-
-    const SkRRect& rrect() const { return fRRect; }
-    SkRegion::Op op() const { return fOp; }
-    bool doAA() const { return fDoAA; }
-
-private:
-    SkRRect      fRRect;
-    SkRegion::Op fOp;
-    bool         fDoAA;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Concat : public SkDrawCommand {
-public:
-    Concat(const SkMatrix& matrix);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkMatrix fMatrix;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawBitmap : public SkDrawCommand {
-public:
-    DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-               const SkPaint* paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkBitmap fBitmap;
-    SkScalar fLeft;
-    SkScalar fTop;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawBitmapMatrix : public SkDrawCommand {
-public:
-    DrawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix,
-                     const SkPaint* paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkBitmap fBitmap;
-    SkMatrix fMatrix;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawBitmapNine : public SkDrawCommand {
-public:
-    DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-                   const SkRect& dst, const SkPaint* paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkBitmap fBitmap;
-    SkIRect  fCenter;
-    SkRect   fDst;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawBitmapRect : public SkDrawCommand {
-public:
-    DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
-                   const SkRect& dst, const SkPaint* paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-
-    const SkBitmap& bitmap() const { return fBitmap; }
-
-    // The non-const 'paint' method allows modification of this object's
-    // SkPaint. For this reason the ctor and setPaint method make a local copy.
-    // The 'fPaintPtr' member acts a signal that the local SkPaint is valid
-    // (since only an SkPaint* is passed into the ctor).
-    const SkPaint* paint() const { return fPaintPtr; }
-    SkPaint* paint() { return fPaintPtr; }
-
-    void setPaint(const SkPaint& paint) { fPaint = paint; fPaintPtr = &fPaint; }
-
-    const SkRect* srcRect() const { return fSrc.isEmpty() ? NULL : &fSrc; }
-    const SkRect& dstRect() const { return fDst; }
-
-    void setSrcRect(const SkRect& src) { fSrc = src; }
-    void setDstRect(const SkRect& dst) { fDst = dst; }
-
-private:
-    SkBitmap fBitmap;
-    SkRect   fSrc;
-    SkRect   fDst;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawData : public SkDrawCommand {
-public:
-    DrawData(const void* data, size_t length);
-    virtual ~DrawData() { delete [] fData; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    char*  fData;
-    size_t fLength;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class BeginCommentGroup : public SkDrawCommand {
-public:
-    BeginCommentGroup(const char* description);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
-        canvas->beginCommentGroup(fDescription.c_str());
-    };
-private:
-    SkString fDescription;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Comment : public SkDrawCommand {
-public:
-    Comment(const char* kywd, const char* value);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
-        canvas->addComment(fKywd.c_str(), fValue.c_str());
-    };
-private:
-    SkString fKywd;
-    SkString fValue;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class EndCommentGroup : public SkDrawCommand {
-public:
-    EndCommentGroup();
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE {
-        canvas->endCommentGroup();
-    };
-private:
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawOval : public SkDrawCommand {
-public:
-    DrawOval(const SkRect& oval, const SkPaint& paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkRect  fOval;
-    SkPaint fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPaint : public SkDrawCommand {
-public:
-    DrawPaint(const SkPaint& paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkPaint fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPath : public SkDrawCommand {
-public:
-    DrawPath(const SkPath& path, const SkPaint& paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-
-private:
-    SkPath   fPath;
-    SkPaint  fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPicture : public SkDrawCommand {
-public:
-    DrawPicture(SkPicture& picture);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkPicture fPicture;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPoints : public SkDrawCommand {
-public:
-    DrawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint pts[],
-               const SkPaint& paint);
-    virtual ~DrawPoints() { delete [] fPts; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkCanvas::PointMode fMode;
-    size_t              fCount;
-    SkPoint*            fPts;
-    SkPaint             fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-/* TODO(chudy): DrawText is a predefined macro and was breaking something
- * in the windows build of the debugger.
- */
-class DrawTextC : public SkDrawCommand {
-public:
-    DrawTextC(const void* text, size_t byteLength, SkScalar x, SkScalar y,
-              const SkPaint& paint);
-    virtual ~DrawTextC() { delete [] fText; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    char*    fText;
-    size_t   fByteLength;
-    SkScalar fX;
-    SkScalar fY;
-    SkPaint  fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPosText : public SkDrawCommand {
-public:
-    DrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
-                const SkPaint& paint);
-    virtual ~DrawPosText() { delete [] fPos; delete [] fText; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    char*    fText;
-    size_t   fByteLength;
-    SkPoint* fPos;
-    SkPaint  fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawTextOnPath : public SkDrawCommand {
-public:
-    DrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
-                   const SkMatrix* matrix, const SkPaint& paint);
-    virtual ~DrawTextOnPath() { delete [] fText; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    char*    fText;
-    size_t   fByteLength;
-    SkPath   fPath;
-    SkMatrix fMatrix;
-    SkPaint  fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawPosTextH : public SkDrawCommand {
-public:
-    DrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
-                 SkScalar constY, const SkPaint& paint);
-    virtual ~DrawPosTextH() { delete [] fXpos; delete [] fText; }
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkScalar* fXpos;
-    char*     fText;
-    size_t    fByteLength;
-    SkScalar  fConstY;
-    SkPaint   fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawRectC : public SkDrawCommand {
-public:
-    DrawRectC(const SkRect& rect, const SkPaint& paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-
-    const SkRect& rect() const   { return fRect; }
-    const SkPaint& paint() const { return fPaint; }
-private:
-    SkRect  fRect;
-    SkPaint fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawRRect : public SkDrawCommand {
-public:
-    DrawRRect(const SkRRect& rrect, const SkPaint& paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkRRect fRRect;
-    SkPaint fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawSprite : public SkDrawCommand {
-public:
-    DrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual bool render(SkCanvas* canvas) const SK_OVERRIDE;
-private:
-    SkBitmap fBitmap;
-    int      fLeft;
-    int      fTop;
-    SkPaint  fPaint;
-    SkPaint* fPaintPtr;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class DrawVertices : public SkDrawCommand {
-public:
-    DrawVertices(SkCanvas::VertexMode vmode, int vertexCount,
-                const SkPoint vertices[], const SkPoint texs[],
-                const SkColor colors[], SkXfermode* xfermode,
-                const uint16_t indices[], int indexCount,
-                const SkPaint& paint);
-    virtual ~DrawVertices();
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkCanvas::VertexMode fVmode;
-    int         fVertexCount;
-    SkPoint*    fVertices;
-    SkPoint*    fTexs;
-    SkColor*    fColors;
-    SkXfermode* fXfermode;
-    uint16_t*   fIndices;
-    int         fIndexCount;
-    SkPaint     fPaint;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Rotate : public SkDrawCommand {
-public:
-    Rotate(SkScalar degrees);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkScalar fDegrees;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Save : public SkDrawCommand {
-public:
-    Save(SkCanvas::SaveFlags flags);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual void trackSaveState(int* state) SK_OVERRIDE;
-private:
-    SkCanvas::SaveFlags fFlags;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class SaveLayer : public SkDrawCommand {
-public:
-    SaveLayer(const SkRect* bounds, const SkPaint* paint,
-              SkCanvas::SaveFlags flags);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-    virtual void trackSaveState(int* state) SK_OVERRIDE;
-
-    const SkPaint* paint() const { return fPaintPtr; }
-
-private:
-    SkRect              fBounds;
-    SkPaint             fPaint;
-    SkPaint*            fPaintPtr;
-    SkCanvas::SaveFlags fFlags;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Scale : public SkDrawCommand {
-public:
-    Scale(SkScalar sx, SkScalar sy);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-
-    SkScalar x() const { return fSx; }
-    SkScalar y() const { return fSy; }
-
-private:
-    SkScalar fSx;
-    SkScalar fSy;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class SetMatrix : public SkDrawCommand {
-public:
-    SetMatrix(const SkMatrix& matrix);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkMatrix fMatrix;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Skew : public SkDrawCommand {
-public:
-    Skew(SkScalar sx, SkScalar sy);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-private:
-    SkScalar fSx;
-    SkScalar fSy;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-class Translate : public SkDrawCommand {
-public:
-    Translate(SkScalar dx, SkScalar dy);
-    virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
-
-    SkScalar x() const { return fDx; }
-    SkScalar y() const { return fDy; }
-
-private:
-    SkScalar fDx;
-    SkScalar fDy;
-
-    typedef SkDrawCommand INHERITED;
-};
-
-#endif
diff --git a/debugger/SkObjectParser.cpp b/debugger/SkObjectParser.cpp
deleted file mode 100644
index 7004bf0622..0000000000
--- a/debugger/SkObjectParser.cpp
+++ /dev/null
@@ -1,375 +0,0 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkObjectParser.h"
-#include "SkData.h"
-#include "SkFontDescriptor.h"
-#include "SkRRect.h"
-#include "SkShader.h"
-#include "SkStream.h"
-#include "SkStringUtils.h"
-#include "SkTypeface.h"
-#include "SkUtils.h"
-
-/* TODO(chudy): Replace all std::strings with char */
-
-SkString* SkObjectParser::BitmapToString(const SkBitmap& bitmap) {
-    SkString* mBitmap = new SkString("SkBitmap: ");
-    mBitmap->append("W: ");
-    mBitmap->appendS32(bitmap.width());
-    mBitmap->append(" H: ");
-    mBitmap->appendS32(bitmap.height());
-
-    const char* gConfigStrings[] = {
-        "None", "A1", "A8", "Index8", "RGB565", "ARGB4444", "ARGB8888", "RLE8"
-    };
-    SkASSERT(SkBitmap::kConfigCount == 8);
-
-    mBitmap->append(" Config: ");
-    mBitmap->append(gConfigStrings[bitmap.getConfig()]);
-
-    if (bitmap.isOpaque()) {
-        mBitmap->append(" opaque");
-    } else {
-        mBitmap->append(" not-opaque");
-    }
-
-    if (bitmap.isImmutable()) {
-        mBitmap->append(" immutable");
-    } else {
-        mBitmap->append(" not-immutable");
-    }
-
-    if (bitmap.isVolatile()) {
-        mBitmap->append(" volatile");
-    } else {
-        mBitmap->append(" not-volatile");
-    }
-
-    mBitmap->append(" genID: ");
-    mBitmap->appendS32(bitmap.getGenerationID());
-
-    return mBitmap;
-}
-
-SkString* SkObjectParser::BoolToString(bool doAA) {
-    SkString* mBool = new SkString("Bool doAA: ");
-    if (doAA) {
-        mBool->append("True");
-    } else {
-        mBool->append("False");
-    }
-    return mBool;
-}
-
-SkString* SkObjectParser::CustomTextToString(const char* text) {
-    SkString* mText = new SkString(text);
-    return mText;
-}
-
-SkString* SkObjectParser::IntToString(int x, const char* text) {
-    SkString* mInt = new SkString(text);
-    mInt->append(" ");
-    mInt->appendScalar(SkIntToScalar(x));
-    return mInt;
-}
-
-SkString* SkObjectParser::IRectToString(const SkIRect& rect) {
-    SkString* mRect = new SkString("SkIRect: ");
-    mRect->append("L: ");
-    mRect->appendS32(rect.left());
-    mRect->append(", T: ");
-    mRect->appendS32(rect.top());
-    mRect->append(", R: ");
-    mRect->appendS32(rect.right());
-    mRect->append(", B: ");
-    mRect->appendS32(rect.bottom());
-    return mRect;
-}
-
-SkString* SkObjectParser::MatrixToString(const SkMatrix& matrix) {
-    SkString* str = new SkString("SkMatrix: ");
-#ifdef SK_DEVELOPER
-    matrix.toString(str);
-#endif
-    return str;
-}
-
-SkString* SkObjectParser::PaintToString(const SkPaint& paint) {
-    SkString* str = new SkString;
-#ifdef SK_DEVELOPER
-    paint.toString(str);
-#endif
-    return str;
-}
-
-SkString* SkObjectParser::PathToString(const SkPath& path) {
-    SkString* mPath = new SkString("Path (");
-
-    static const char* gFillStrings[] = {
-        "Winding", "EvenOdd", "InverseWinding", "InverseEvenOdd"
-    };
-
-    mPath->append(gFillStrings[path.getFillType()]);
-    mPath->append(", ");
-
-    static const char* gConvexityStrings[] = {
-        "Unknown", "Convex", "Concave"
-    };
-    SkASSERT(SkPath::kConcave_Convexity == 2);
-
-    mPath->append(gConvexityStrings[path.getConvexity()]);
-    mPath->append(", ");
-
-    if (path.isRect(NULL)) {
-        mPath->append("isRect, ");
-    } else {
-        mPath->append("isNotRect, ");
-    }
-
-    mPath->appendS32(path.countVerbs());
-    mPath->append("V, ");
-    mPath->appendS32(path.countPoints());
-    mPath->append("P): ");
-
-    static const char* gVerbStrings[] = {
-        "Move", "Line", "Quad", "Conic", "Cubic", "Close", "Done"
-    };
-    static const int gPtsPerVerb[] = { 1, 1, 2, 2, 3, 0, 0 };
-    static const int gPtOffsetPerVerb[] = { 0, 1, 1, 1, 1, 0, 0 };
-    SkASSERT(SkPath::kDone_Verb == 6);
-
-    SkPath::Iter iter(const_cast<SkPath&>(path), false);
-    SkPath::Verb verb;
-    SkPoint points[4];
-
-    for(verb = iter.next(points, false);
-        verb != SkPath::kDone_Verb;
-        verb = iter.next(points, false)) {
-
-        mPath->append(gVerbStrings[verb]);
-        mPath->append(" ");
-
-        for (int i = 0; i < gPtsPerVerb[verb]; ++i) {
-            mPath->append("(");
-            mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fX);
-            mPath->append(", ");
-            mPath->appendScalar(points[gPtOffsetPerVerb[verb]+i].fY);
-            mPath->append(")");
-        }
-
-        if (SkPath::kConic_Verb == verb) {
-            mPath->append("(");
-            mPath->appendScalar(iter.conicWeight());
-            mPath->append(")");
-        }
-
-        mPath->append(" ");
-    }
-
-    SkString* boundStr = SkObjectParser::RectToString(path.getBounds(), "    Bound: ");
-
-    if (NULL != boundStr) {
-        mPath->append(*boundStr);
-        SkDELETE(boundStr);
-    }
-
-    return mPath;
-}
-
-SkString* SkObjectParser::PointsToString(const SkPoint pts[], size_t count) {
-    SkString* mPoints = new SkString("SkPoints pts[]: ");
-    for (unsigned int i = 0; i < count; i++) {
-        mPoints->append("(");
-        mPoints->appendScalar(pts[i].fX);
-        mPoints->append(",");
-        mPoints->appendScalar(pts[i].fY);
-        mPoints->append(")");
-    }
-    return mPoints;
-}
-
-SkString* SkObjectParser::PointModeToString(SkCanvas::PointMode mode) {
-    SkString* mMode = new SkString("SkCanvas::PointMode: ");
-    if (mode == SkCanvas::kPoints_PointMode) {
-        mMode->append("kPoints_PointMode");
-    } else if (mode == SkCanvas::kLines_PointMode) {
-        mMode->append("kLines_Mode");
-    } else if (mode == SkCanvas::kPolygon_PointMode) {
-        mMode->append("kPolygon_PointMode");
-    }
-    return mMode;
-}
-
-SkString* SkObjectParser::RectToString(const SkRect& rect, const char* title) {
-
-    SkString* mRect = new SkString;
-
-    if (NULL == title) {
-        mRect->append("SkRect: ");
-    } else {
-        mRect->append(title);
-    }
-    mRect->append("(");
-    mRect->appendScalar(rect.left());
-    mRect->append(", ");
-    mRect->appendScalar(rect.top());
-    mRect->append(", ");
-    mRect->appendScalar(rect.right());
-    mRect->append(", ");
-    mRect->appendScalar(rect.bottom());
-    mRect->append(")");
-    return mRect;
-}
-
-SkString* SkObjectParser::RRectToString(const SkRRect& rrect, const char* title) {
-
-    SkString* mRRect = new SkString;
-
-    if (NULL == title) {
-        mRRect->append("SkRRect (");
-        if (rrect.isEmpty()) {
-            mRRect->append("empty");
-        } else if (rrect.isRect()) {
-            mRRect->append("rect");
-        } else if (rrect.isOval()) {
-            mRRect->append("oval");
-        } else if (rrect.isSimple()) {
-            mRRect->append("simple");
-        } else {
-            SkASSERT(rrect.isComplex());
-            mRRect->append("complex");
-        }
-        mRRect->append("): ");
-    } else {
-        mRRect->append(title);
-    }
-    mRRect->append("(");
-    mRRect->appendScalar(rrect.rect().left());
-    mRRect->append(", ");
-    mRRect->appendScalar(rrect.rect().top());
-    mRRect->append(", ");
-    mRRect->appendScalar(rrect.rect().right());
-    mRRect->append(", ");
-    mRRect->appendScalar(rrect.rect().bottom());
-    mRRect->append(") radii: (");
-    for (int i = 0; i < 4; ++i) {
-        const SkVector& radii = rrect.radii((SkRRect::Corner) i);
-        mRRect->appendScalar(radii.fX);
-        mRRect->append(", ");
-        mRRect->appendScalar(radii.fY);
-        if (i < 3) {
-            mRRect->append(", ");
-        }
-    }
-    mRRect->append(")");
-    return mRRect;
-}
-
-SkString* SkObjectParser::RegionOpToString(SkRegion::Op op) {
-    SkString* mOp = new SkString("SkRegion::Op: ");
-    if (op == SkRegion::kDifference_Op) {
-        mOp->append("kDifference_Op");
-    } else if (op == SkRegion::kIntersect_Op) {
-        mOp->append("kIntersect_Op");
-    } else if (op == SkRegion::kUnion_Op) {
-        mOp->append("kUnion_Op");
-    } else if (op == SkRegion::kXOR_Op) {
-        mOp->append("kXOR_Op");
-    } else if (op == SkRegion::kReverseDifference_Op) {
-        mOp->append("kReverseDifference_Op");
-    } else if (op == SkRegion::kReplace_Op) {
-        mOp->append("kReplace_Op");
-    } else {
-        mOp->append("Unknown Type");
-    }
-    return mOp;
-}
-
-SkString* SkObjectParser::RegionToString(const SkRegion& region) {
-    SkString* mRegion = new SkString("SkRegion: Data unavailable.");
-    return mRegion;
-}
-
-SkString* SkObjectParser::SaveFlagsToString(SkCanvas::SaveFlags flags) {
-    SkString* mFlags = new SkString("SkCanvas::SaveFlags: ");
-    if(flags == SkCanvas::kMatrixClip_SaveFlag) {
-        mFlags->append("kMatrixClip_SaveFlag");
-    } else if (flags == SkCanvas::kClip_SaveFlag) {
-        mFlags->append("kClip_SaveFlag");
-    } else if (flags == SkCanvas::kHasAlphaLayer_SaveFlag) {
-        mFlags->append("kHasAlphaLayer_SaveFlag");
-    } else if (flags == SkCanvas::kFullColorLayer_SaveFlag) {
-        mFlags->append("kFullColorLayer_SaveFlag");
-    } else if (flags == SkCanvas::kClipToLayer_SaveFlag) {
-        mFlags->append("kClipToLayer_SaveFlag");
-    } else if (flags == SkCanvas::kMatrixClip_SaveFlag) {
-        mFlags->append("kMatrixClip_SaveFlag");
-    } else if (flags == SkCanvas::kARGB_NoClipLayer_SaveFlag) {
-        mFlags->append("kARGB_NoClipLayer_SaveFlag");
-    } else if (flags == SkCanvas::kARGB_ClipLayer_SaveFlag) {
-        mFlags->append("kARGB_ClipLayer_SaveFlag");
-    } else {
-        mFlags->append("Data Unavailable");
-    }
-    return mFlags;
-}
-
-SkString* SkObjectParser::ScalarToString(SkScalar x, const char* text) {
-    SkString* mScalar = new SkString(text);
-    mScalar->append(" ");
-    mScalar->appendScalar(x);
-    return mScalar;
-}
-
-SkString* SkObjectParser::TextToString(const void* text, size_t byteLength,
-                                       SkPaint::TextEncoding encoding) {
-
-    SkString* decodedText = new SkString();
-    switch (encoding) {
-        case SkPaint::kUTF8_TextEncoding: {
-            decodedText->append("UTF-8: ");
-            decodedText->append((const char*)text, byteLength);
-            break;
-        }
-        case SkPaint::kUTF16_TextEncoding: {
-            decodedText->append("UTF-16: ");
-            size_t sizeNeeded = SkUTF16_ToUTF8((uint16_t*)text, byteLength / 2, NULL);
-            char* utf8 = new char[sizeNeeded];
-            SkUTF16_ToUTF8((uint16_t*)text, byteLength / 2, utf8);
-            decodedText->append(utf8, sizeNeeded);
-            delete utf8;
-            break;
-        }
-        case SkPaint::kUTF32_TextEncoding: {
-            decodedText->append("UTF-32: ");
-            const SkUnichar* begin = (const SkUnichar*)text;
-            const SkUnichar* end = (const SkUnichar*)((const char*)text + byteLength);
-            for (const SkUnichar* unichar = begin; unichar < end; ++unichar) {
-                decodedText->appendUnichar(*unichar);
-            }
-            break;
-        }
-        case SkPaint::kGlyphID_TextEncoding: {
-            decodedText->append("GlyphID: ");
-            const uint16_t* begin = (const uint16_t*)text;
-            const uint16_t* end = (const uint16_t*)((const char*)text + byteLength);
-            for (const uint16_t* glyph = begin; glyph < end; ++glyph) {
-                decodedText->append("0x");
-                decodedText->appendHex(*glyph);
-                decodedText->append(" ");
-            }
-            break;
-        }
-        default:
-            decodedText->append("Unknown text encoding.");
-            break;
-    }
-
-    return decodedText;
-}
diff --git a/debugger/SkObjectParser.h b/debugger/SkObjectParser.h
deleted file mode 100644
index 911b778921..0000000000
--- a/debugger/SkObjectParser.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKOBJECTPARSER_H_
-#define SKOBJECTPARSER_H_
-
-#include "SkCanvas.h"
-#include "SkString.h"
-
-/** \class SkObjectParser
-
-    The ObjectParser is used to return string information about parameters
-    in each draw command.
- */
-class SkObjectParser {
-public:
-
-    /**
-        Returns a string about a bitmaps bounds and config.
-        @param bitmap  SkBitmap
-    */
-    static SkString* BitmapToString(const SkBitmap& bitmap);
-
-    /**
-        Returns a string representation of a boolean.
-        @param doAA  boolean
-     */
-    static SkString* BoolToString(bool doAA);
-
-    /**
-        Returns a string representation of the text pointer passed in.
-     */
-    static SkString* CustomTextToString(const char* text);
-
-    /**
-        Returns a string representation of an integer with the text parameter
-        at the front of the string.
-        @param x  integer
-        @param text
-     */
-    static SkString* IntToString(int x, const char* text);
-    /**
-        Returns a string representation of the SkIRects coordinates.
-        @param rect  SkIRect
-     */
-    static SkString* IRectToString(const SkIRect& rect);
-
-    /**
-        Returns a string representation of an SkMatrix's contents
-        @param matrix  SkMatrix
-     */
-    static SkString* MatrixToString(const SkMatrix& matrix);
-
-    /**
-        Returns a string representation of an SkPaint's color
-        @param paint  SkPaint
-     */
-    static SkString* PaintToString(const SkPaint& paint);
-
-    /**
-        Returns a string representation of a SkPath's points.
-        @param path  SkPath
-     */
-    static SkString* PathToString(const SkPath& path);
-
-    /**
-        Returns a string representation of the points in the point array.
-        @param pts[]  Array of SkPoints
-        @param count
-     */
-    static SkString* PointsToString(const SkPoint pts[], size_t count);
-
-    /**
-        Returns a string representation of the SkCanvas PointMode enum.
-     */
-    static SkString* PointModeToString(SkCanvas::PointMode mode);
-
-    /**
-        Returns a string representation of the SkRects coordinates.
-        @param rect  SkRect
-     */
-    static SkString* RectToString(const SkRect& rect, const char* title = NULL);
-
-    /**
-        Returns a string representation of an SkRRect.
-        @param rrect  SkRRect
-     */
-    static SkString* RRectToString(const SkRRect& rrect, const char* title = NULL);
-
-    /**
-        Returns a string representation of the SkRegion enum.
-        @param op  SkRegion::op enum
-     */
-    static SkString* RegionOpToString(SkRegion::Op op);
-
-    /**
-        Returns a string representation of the SkRegion.
-        @param region  SkRegion
-     */
-    static SkString* RegionToString(const SkRegion& region);
-
-    /**
-        Returns a string representation of the SkCanvas::SaveFlags enum.
-        @param flags  SkCanvas::SaveFlags enum
-     */
-    static SkString* SaveFlagsToString(SkCanvas::SaveFlags flags);
-
-    /**
-        Returns a string representation of an SkScalar with the text parameter
-        at the front of the string.
-        @param x  SkScalar
-        @param text
-     */
-    static SkString* ScalarToString(SkScalar x, const char* text);
-
-    /**
-        Returns a string representation of the char pointer passed in.
-        @param text  const void* that will be cast to a char*
-     */
-    static SkString* TextToString(const void* text, size_t byteLength,
-                                  SkPaint::TextEncoding encoding);
-};
-
-#endif