More SkDrawCommand cleanup

debugger/SkDrawCommand.cpp

 
 /*
  * 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"
@@ skipping 52 matching lines @@
     }
     SkDEBUGFAIL("DrawType UNUSED\n");
     return NULL;
 }
 
 SkString SkDrawCommand::toString() {
     return SkString(GetCommandString(fDrawType));
 }
 
 Clear::Clear(SkColor color) {
-    this->fColor = color;
-    this->fDrawType = DRAW_CLEAR;
-    this->fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
+    fColor = color;
+    fDrawType = DRAW_CLEAR;
+    fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 
 void Clear::execute(SkCanvas* canvas) {
-    canvas->clear(this->fColor);
+    canvas->clear(fColor);
 }
 
 ClipPath::ClipPath(const SkPath& path, SkRegion::Op op, bool doAA, SkBitmap& bitmap) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
     fDrawType = CLIP_PATH;
     fBitmap = bitmap;
 
     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);
 }
 
 const SkBitmap* ClipPath::getBitmap() const {
     return &fBitmap;
 }
 
 ClipRegion::ClipRegion(const SkRegion& region, SkRegion::Op op) {
-    this->fRegion = &region;
-    this->fOp = op;
-    this->fDrawType = CLIP_REGION;
+    fRegion = region;
+    fOp = op;
+    fDrawType = CLIP_REGION;
 
-    this->fInfo.push(SkObjectParser::RegionToString(region));
-    this->fInfo.push(SkObjectParser::RegionOpToString(op));
+    fInfo.push(SkObjectParser::RegionToString(region));
+    fInfo.push(SkObjectParser::RegionOpToString(op));
 }
 
 void ClipRegion::execute(SkCanvas* canvas) {
-    canvas->clipRegion(*this->fRegion, this->fOp);
+    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));
@@ skipping 13 matching lines @@
     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);
 }
 
 Concat::Concat(const SkMatrix& matrix) {
-    this->fMatrix = &matrix;
-    this->fDrawType = CONCAT;
+    fMatrix = matrix;
+    fDrawType = CONCAT;
 
-    this->fInfo.push(SkObjectParser::MatrixToString(matrix));
+    fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
 void Concat::execute(SkCanvas* canvas) {
-    canvas->concat(*this->fMatrix);
+    canvas->concat(fMatrix);
 }
 
 DrawBitmap::DrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-        const SkPaint* paint, SkBitmap& resizedBitmap) {
-    this->fBitmap = &bitmap;
-    this->fLeft = left;
-    this->fTop = top;
-    this->fPaint = paint;
-    this->fDrawType = DRAW_BITMAP;
-    this->fResizedBitmap = resizedBitmap;
+                       const SkPaint* paint, SkBitmap& resizedBitmap) {
+    fBitmap = bitmap;
+    fLeft = left;
+    fTop = top;
+    if (NULL != paint) {
+        fPaint = *paint;
+        fPaintPtr = &fPaint;
+    } else {
+        fPaintPtr = NULL;
+    }
+    fDrawType = DRAW_BITMAP;
+    fResizedBitmap = resizedBitmap;
 
-    this->fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    this->fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
-    this->fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
+    fInfo.push(SkObjectParser::BitmapToString(bitmap));
+    fInfo.push(SkObjectParser::ScalarToString(left, "SkScalar left: "));
+    fInfo.push(SkObjectParser::ScalarToString(top, "SkScalar top: "));
     if (NULL != paint) {
-        this->fInfo.push(SkObjectParser::PaintToString(*paint));
+        fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmap::execute(SkCanvas* canvas) {
-    canvas->drawBitmap(*this->fBitmap, this->fLeft, this->fTop, this->fPaint);
+    canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
 const SkBitmap* DrawBitmap::getBitmap() const {
     return &fResizedBitmap;
 }
 
 DrawBitmapMatrix::DrawBitmapMatrix(const SkBitmap& bitmap,
-        const SkMatrix& matrix, const SkPaint* paint, SkBitmap& resizedBitmap) {
-    this->fBitmap = &bitmap;
-    this->fMatrix = &matrix;
-    this->fPaint = paint;
-    this->fDrawType = DRAW_BITMAP_MATRIX;
-    this->fResizedBitmap = resizedBitmap;
+                                   const SkMatrix& matrix, 
+                                   const SkPaint* paint, 
+                                   SkBitmap& resizedBitmap) {
+    fBitmap = bitmap;
+    fMatrix = matrix;
+    if (NULL != paint) {
+        fPaint = *paint;
+        fPaintPtr = &fPaint;
+    } else {
+        fPaintPtr = NULL;
+    }
+    fDrawType = DRAW_BITMAP_MATRIX;
+    fResizedBitmap = resizedBitmap;
 
-    this->fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    this->fInfo.push(SkObjectParser::MatrixToString(matrix));
+    fInfo.push(SkObjectParser::BitmapToString(bitmap));
+    fInfo.push(SkObjectParser::MatrixToString(matrix));
     if (NULL != paint) {
-        this->fInfo.push(SkObjectParser::PaintToString(*paint));
+        fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmapMatrix::execute(SkCanvas* canvas) {
-    canvas->drawBitmapMatrix(*this->fBitmap, *this->fMatrix, this->fPaint);
+    canvas->drawBitmapMatrix(fBitmap, fMatrix, fPaintPtr);
 }
 
 const SkBitmap* DrawBitmapMatrix::getBitmap() const {
     return &fResizedBitmap;
 }
 
 DrawBitmapNine::DrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-        const SkRect& dst, const SkPaint* paint, SkBitmap& resizedBitmap) {
-    this->fBitmap = &bitmap;
-    this->fCenter = &center;
-    this->fDst = &dst;
-    this->fPaint = paint;
-    this->fDrawType = DRAW_BITMAP_NINE;
-    this->fResizedBitmap = resizedBitmap;
+                               const SkRect& dst, const SkPaint* paint, 
+                               SkBitmap& resizedBitmap) {
+    fBitmap = bitmap;
+    fCenter = center;
+    fDst = dst;
+    if (NULL != paint) {
+        fPaint = *paint;
+        fPaintPtr = &fPaint;
+    } else {
+        fPaintPtr = NULL;
+    }
+    fDrawType = DRAW_BITMAP_NINE;
+    fResizedBitmap = resizedBitmap;
 
-    this->fInfo.push(SkObjectParser::BitmapToString(bitmap));
-    this->fInfo.push(SkObjectParser::IRectToString(center));
-    this->fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
+    fInfo.push(SkObjectParser::BitmapToString(bitmap));
+    fInfo.push(SkObjectParser::IRectToString(center));
+    fInfo.push(SkObjectParser::RectToString(dst, "Dst: "));
     if (NULL != paint) {
-        this->fInfo.push(SkObjectParser::PaintToString(*paint));
+        fInfo.push(SkObjectParser::PaintToString(*paint));
     }
 }
 
 void DrawBitmapNine::execute(SkCanvas* canvas) {
-    canvas->drawBitmapNine(*this->fBitmap, *this->fCenter, *this->fDst, this->fPaint);
+    canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
 }
 
 const SkBitmap* DrawBitmapNine::getBitmap() const {
     return &fResizedBitmap;
 }
 
 DrawBitmapRect::DrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                                const SkRect& dst, const SkPaint* paint,
                                SkBitmap& resizedBitmap) {
     fBitmap = bitmap;
@@ skipping 269 matching lines @@
     this->fInfo.push(SkObjectParser::CustomTextToString("To be implemented."));
 }
 
 void DrawVertices::execute(SkCanvas* canvas) {
     canvas->drawVertices(this->fVmode, this->fVertexCount, this->fVertices,
             this->fTexs, this->fColors, this->fXfermode, this->fIndices,
             this->fIndexCount, *this->fPaint);
 }
 
 Restore::Restore() {
-    this->fDrawType = RESTORE;
-    this->fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
+    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) {
     this->fDegrees = degrees;
     this->fDrawType = ROTATE;
 
     this->fInfo.push(SkObjectParser::ScalarToString(degrees, "SkScalar degrees: "));
 }
 
 void Rotate::execute(SkCanvas* canvas) {
     canvas->rotate(this->fDegrees);
 }
 
 Save::Save(SkCanvas::SaveFlags flags) {
-    this->fFlags = flags;
-    this->fDrawType = SAVE;
-    this->fInfo.push(SkObjectParser::SaveFlagsToString(flags));
+    fFlags = flags;
+    fDrawType = SAVE;
+    fInfo.push(SkObjectParser::SaveFlagsToString(flags));
 }
 
 void Save::execute(SkCanvas* canvas) {
-    canvas->save(this->fFlags);
+    canvas->save(fFlags);
 }
 
 void Save::trackSaveState(int* state) {
     (*state)++;
 }
 
 SaveLayer::SaveLayer(const SkRect* bounds, const SkPaint* paint,
-        SkCanvas::SaveFlags flags) {
-    this->fBounds = bounds;
-    this->fPaint = paint;
-    this->fFlags = flags;
-    this->fDrawType = SAVE_LAYER;
+                     SkCanvas::SaveFlags flags) {
+    if (NULL != bounds) {
+        fBounds = *bounds;
+    } else {
+        fBounds.setEmpty();
+    }
 
-    if (bounds) this->fInfo.push(SkObjectParser::RectToString(*bounds, "Bounds: "));
-    if (paint) this->fInfo.push(SkObjectParser::PaintToString(*paint));
-    this->fInfo.push(SkObjectParser::SaveFlagsToString(flags));
+    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(this->fBounds, this->fPaint, this->fFlags);
+    canvas->saveLayer(fBounds.isEmpty() ? NULL : &fBounds, 
+                      fPaintPtr,
+                      fFlags);
 }
 
 void SaveLayer::trackSaveState(int* state) {
     (*state)++;
 }
 
 Scale::Scale(SkScalar sx, SkScalar sy) {
     this->fSx = sx;
     this->fSy = sy;
     this->fDrawType = SCALE;
@@ skipping 35 matching lines @@
     this->fDy = dy;
     this->fDrawType = TRANSLATE;
 
     this->fInfo.push(SkObjectParser::ScalarToString(dx, "SkScalar dx: "));
     this->fInfo.push(SkObjectParser::ScalarToString(dy, "SkScalar dy: "));
 }
 
 void Translate::execute(SkCanvas* canvas) {
     canvas->translate(this->fDx, this->fDy);
 }