SkDrawCommand cleanup

debugger/SkDrawCommand.h

 
 /*
  * 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_
@@ skipping 208 matching lines @@
     SkPaint  fPaint;
     SkPaint* fPaintPtr;
     SkBitmap fResizedBitmap;
 
     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:
-    const void* fData;
+    void*  fData;
     size_t fLength;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawOval : public SkDrawCommand {
 public:
     DrawOval(const SkRect& oval, const SkPaint& paint);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
     SkRect  fOval;
     SkPaint fPaint;
 
@@ skipping 10 matching lines @@
     typedef SkDrawCommand INHERITED;
 };
 
 class DrawPath : public SkDrawCommand {
 public:
     DrawPath(const SkPath& path, const SkPaint& paint, SkBitmap& bitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 
 private:
-    SkPath  fPath;
-    SkPaint fPaint;
+    SkPath   fPath;
+    SkPaint  fPaint;
     SkBitmap fBitmap;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class DrawPicture : public SkDrawCommand {
 public:
     DrawPicture(SkPicture& picture);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
-    SkPicture* fPicture;
+    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;
 
 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);
+              const SkPaint& paint);
+    virtual ~DrawTextC() { delete [] fText; }
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
-    const void* fText;
-    size_t fByteLength;
+    void*    fText;
+    size_t   fByteLength;
     SkScalar fX;
     SkScalar fY;
-    const SkPaint* fPaint;
+    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;
-    char* fText;
-    size_t fByteLength;
-    SkPaint fPaint;
+    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:
-    const SkMatrix* fMatrix;
-    const void* fText;
-    size_t fByteLength;
-    const SkPath* fPath;
-    const SkPaint* fPaint;
+    void*    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;
+    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;
 private:
     SkRRect fRRect;
     SkPaint fPaint;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawSprite : public SkDrawCommand {
 public:
     DrawSprite(const SkBitmap& bitmap, int left, int top, const SkPaint* paint,
                SkBitmap& resizedBitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 private:
-    const SkPaint* fPaint;
-    int fLeft;
-    int fTop;
-    const SkBitmap* fBitmap;
+    SkBitmap fBitmap;
+    int      fLeft;
+    int      fTop;
+    SkPaint  fPaint;
+    SkPaint* fPaintPtr;
     SkBitmap fResizedBitmap;
+
+    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);
+                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;
-    int fIndexCount;
-    const SkPoint* fVertices;
-    const SkPoint* fTexs;
-    const SkColor* fColors;
-    const uint16_t* fIndices;
+    int         fVertexCount;
+    SkPoint*    fVertices;
+    SkPoint*    fTexs;
+    SkColor*    fColors;
     SkXfermode* fXfermode;
-    const SkPaint* fPaint;
+    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;
 
@@ skipping 22 matching lines @@
 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