More 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 39 matching lines @@
 
 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, SkBitmap& bitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 private:
-    SkPath fPath;
+    SkPath       fPath;
     SkRegion::Op fOp;
-    bool fDoAA;
-    SkBitmap fBitmap;
+    bool         fDoAA;
+    SkBitmap     fBitmap;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class ClipRegion : public SkDrawCommand {
 public:
     ClipRegion(const SkRegion& region, SkRegion::Op op);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
-    const SkRegion* fRegion;
+    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; }
@@ skipping 21 matching lines @@
     bool         fDoAA;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class Concat : public SkDrawCommand {
 public:
     Concat(const SkMatrix& matrix);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
-    const SkMatrix* fMatrix;
+    SkMatrix fMatrix;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawBitmap : public SkDrawCommand {
 public:
     DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-            const SkPaint* paint, SkBitmap& resizedBitmap);
+               const SkPaint* paint, SkBitmap& resizedBitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 private:
-    const SkPaint* fPaint;
-    const SkBitmap* fBitmap;
+    SkBitmap fBitmap;
     SkScalar fLeft;
     SkScalar fTop;
+    SkPaint  fPaint;
+    SkPaint* fPaintPtr;
     SkBitmap fResizedBitmap;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawBitmapMatrix : public SkDrawCommand {
 public:
     DrawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix,
-            const SkPaint* paint, SkBitmap& resizedBitmap);
+                     const SkPaint* paint, SkBitmap& resizedBitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 private:
-    const SkPaint* fPaint;
-    const SkBitmap* fBitmap;
-    const SkMatrix* fMatrix;
+    SkBitmap fBitmap;
+    SkMatrix fMatrix;
+    SkPaint  fPaint;
+    SkPaint* fPaintPtr;
     SkBitmap fResizedBitmap;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawBitmapNine : public SkDrawCommand {
 public:
     DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-            const SkRect& dst, const SkPaint* paint, SkBitmap& resizedBitmap);
+                   const SkRect& dst, const SkPaint* paint, 
+                   SkBitmap& resizedBitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 private:
-    const SkBitmap* fBitmap;
-    const SkIRect* fCenter;
-    const SkRect* fDst;
-    const SkPaint* fPaint;
+    SkBitmap fBitmap;
+    SkIRect  fCenter;
+    SkRect   fDst;
+    SkPaint  fPaint;
+    SkPaint* fPaintPtr;
     SkBitmap fResizedBitmap;
+
+    typedef SkDrawCommand INHERITED;
 };
 
 class DrawBitmapRect : public SkDrawCommand {
 public:
     DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                    const SkRect& dst, const SkPaint* paint,
                    SkBitmap& resizedBitmap);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual const SkBitmap* getBitmap() const SK_OVERRIDE;
 
     // 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; }
 
 private:
-    SkRect  fSrc;
-    SkPaint fPaint;
+    SkBitmap fBitmap;
+    SkRect   fSrc;
+    SkRect   fDst;
+    SkPaint  fPaint;
     SkPaint* fPaintPtr;
-    SkBitmap fBitmap;
-    SkRect  fDst;
     SkBitmap fResizedBitmap;
 
     typedef SkDrawCommand INHERITED;
 };
 
 class DrawData : public SkDrawCommand {
 public:
     DrawData(const void* data, size_t length);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
 private:
@@ skipping 182 matching lines @@
     SkScalar fDegrees;
 };
 
 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);
+              SkCanvas::SaveFlags flags);
     virtual void execute(SkCanvas* canvas) SK_OVERRIDE;
     virtual void trackSaveState(int* state) SK_OVERRIDE;
 
-    const SkPaint* paint() const { return fPaint; }
+    const SkPaint* paint() const { return fPaintPtr; }
 
 private:
-    const SkRect* fBounds;
-    const SkPaint* fPaint;
+    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; }
 
@@ skipping 26 matching lines @@
 
     SkScalar x() const { return fDx; }
     SkScalar y() const { return fDy; }
 
 private:
     SkScalar fDx;
     SkScalar fDy;
 };
 
 #endif