Rename SkDrawCommand subclasses

tools/filtermain.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 "SkDebugCanvas.h"
 #include "SkDevice.h"
 #include "SkForceLinking.h"
@@ skipping 39 matching lines @@
 //    RESTORE
 // where the saveLayer's color can be moved into the drawBitmapRect
 static bool check_0(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE_LAYER != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+2 ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+2)->getType()) {
         return false;
     }
 
-    SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+1);
+    SkSaveLayerCommand* saveLayer =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+1);
 
     const SkPaint* saveLayerPaint = saveLayer->paint();
     SkPaint* dbmrPaint = dbmr->paint();
 
     // For this optimization we only fold the saveLayer and drawBitmapRect
     // together if the saveLayer's draw is simple (i.e., no fancy effects)
     // and the only difference in the colors is their alpha value
     SkColor layerColor = saveLayerPaint->getColor() | 0xFF000000; // force opaque
     SkColor dbmrColor = dbmrPaint->getColor() | 0xFF000000;       // force opaque
 
     // If either operation lacks a paint then the collapse is trivial
     return NULL == saveLayerPaint ||
            NULL == dbmrPaint ||
            (is_simple(*saveLayerPaint) && dbmrColor == layerColor);
 }
 
 // Fold the saveLayer's alpha into the drawBitmapRect and remove the saveLayer
 // and restore
 static void apply_0(SkDebugCanvas* canvas, int curCommand) {
-    SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
+    SkSaveLayerCommand* saveLayer =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand);
     const SkPaint* saveLayerPaint = saveLayer->paint();
 
     // if (NULL == saveLayerPaint) the dbmr's paint doesn't need to be changed
     if (NULL != saveLayerPaint) {
-        DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+1);
+        SkDrawBitmapRectCommand* dbmr =
+            (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+1);
         SkPaint* dbmrPaint = dbmr->paint();
 
         if (NULL == dbmrPaint) {
             // if the DBMR doesn't have a paint just use the saveLayer's
             dbmr->setPaint(*saveLayerPaint);
         } else if (NULL != saveLayerPaint) {
             // Both paints are present so their alphas need to be combined
             SkColor color = saveLayerPaint->getColor();
             int a0 = SkColorGetA(color);
 
@@ skipping 24 matching lines @@
     if (SAVE_LAYER != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+5 ||
         SAVE != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+3)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+4)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+5)->getType()) {
         return false;
     }
 
-    SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+3);
+    SkSaveLayerCommand* saveLayer =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+3);
 
     const SkPaint* saveLayerPaint = saveLayer->paint();
     SkPaint* dbmrPaint = dbmr->paint();
 
     // For this optimization we only fold the saveLayer and drawBitmapRect
     // together if the saveLayer's draw is simple (i.e., no fancy effects) and
     // and the only difference in the colors is that the saveLayer's can have
     // an alpha while the drawBitmapRect's is opaque.
     // TODO: it should be possible to fold them together even if they both
     // have different non-255 alphas but this is low priority since we have
     // never seen that case
     // If either operation lacks a paint then the collapse is trivial
     SkColor layerColor = saveLayerPaint->getColor() | 0xFF000000; // force opaque
 
     return NULL == saveLayerPaint ||
            NULL == dbmrPaint ||
            (is_simple(*saveLayerPaint) && dbmrPaint->getColor() == layerColor);
 }
 
 // Fold the saveLayer's alpha into the drawBitmapRect and remove the saveLayer
 // and restore
 static void apply_1(SkDebugCanvas* canvas, int curCommand) {
-    SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
+    SkSaveLayerCommand* saveLayer =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand);
     const SkPaint* saveLayerPaint = saveLayer->paint();
 
     // if (NULL == saveLayerPaint) the dbmr's paint doesn't need to be changed
     if (NULL != saveLayerPaint) {
-        DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+3);
+        SkDrawBitmapRectCommand* dbmr =
+            (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+3);
         SkPaint* dbmrPaint = dbmr->paint();
 
         if (NULL == dbmrPaint) {
             dbmr->setPaint(*saveLayerPaint);
         } else {
             SkColor newColor = SkColorSetA(dbmrPaint->getColor(),
                                            SkColorGetA(saveLayerPaint->getColor()));
             dbmrPaint->setColor(newColor);
         }
     }
@@ skipping 10 matching lines @@
 // where the rect is entirely within the clip and the clip is an intersect
 static bool check_2(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+4 ||
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         DRAW_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
         return false;
     }
 
-    ClipRect* cr = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawRectC* dr = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* cr =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawRectCommand* dr =
+        (SkDrawRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     if (SkRegion::kIntersect_Op != cr->op()) {
         return false;
     }
 
     return cr->rect().contains(dr->rect());
 }
 
 // Remove everything but the drawRect
 static void apply_2(SkDebugCanvas* canvas, int curCommand) {
@@ skipping 11 matching lines @@
 // where the rect entirely encloses the clip
 static bool check_3(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+4 ||
         CLIP_RRECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         DRAW_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
         return false;
     }
 
-    ClipRRect* crr = (ClipRRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawRectC* dr  = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRRectCommand* crr =
+        (SkClipRRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawRectCommand* dr  =
+        (SkDrawRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     if (SkRegion::kIntersect_Op != crr->op()) {
         return false;
     }
 
     return dr->rect().contains(crr->rrect().rect());
 }
 
 // Replace everything with a drawRRect with the paint from the drawRect
 // and the AA settings from the clipRRect
 static void apply_3(SkDebugCanvas* canvas, int curCommand) {
 
     canvas->deleteDrawCommandAt(curCommand+3);    // restore
 
-    ClipRRect* crr = (ClipRRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawRectC* dr  = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRRectCommand* crr =
+        (SkClipRRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawRectCommand* dr  =
+        (SkDrawRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     // TODO: could skip paint re-creation if the AA settings already match
     SkPaint newPaint = dr->paint();
     newPaint.setAntiAlias(crr->doAA());
-    DrawRRect* drr = new DrawRRect(crr->rrect(), newPaint);
+    SkDrawRRectCommand* drr = new SkDrawRRectCommand(crr->rrect(), newPaint);
     canvas->setDrawCommandAt(curCommand+2, drr);
 
     canvas->deleteDrawCommandAt(curCommand+1);    // clipRRect
     canvas->deleteDrawCommandAt(curCommand);      // save
 }
 
 // Check for:
 //    SAVE
 //        CLIP_RECT
 //        DRAW_BITMAP_RECT_TO_RECT
 //    RESTORE
 // where the rect and drawBitmapRect dst exactly match
 static bool check_4(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+4 ||
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
         return false;
     }
 
-    ClipRect* cr = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawBitmapRect* dbmr  = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* cr =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawBitmapRectCommand* dbmr  =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     if (SkRegion::kIntersect_Op != cr->op()) {
         return false;
     }
 
     return dbmr->dstRect() == cr->rect();
 }
 
 // Remove everything but the drawBitmapRect
 static void apply_4(SkDebugCanvas* canvas, int curCommand) {
     canvas->deleteDrawCommandAt(curCommand+3);    // restore
     // drawBitmapRectToRect
     canvas->deleteDrawCommandAt(curCommand+1);    // clipRect
     canvas->deleteDrawCommandAt(curCommand);      // save
 }
 
 // Check for:
 //    TRANSLATE
 // where the translate is zero
 static bool check_5(SkDebugCanvas* canvas, int curCommand) {
     if (TRANSLATE != canvas->getDrawCommandAt(curCommand)->getType()) {
         return false;
     }
 
-    Translate* t = (Translate*) canvas->getDrawCommandAt(curCommand);
+    SkTranslateCommand* t =
+        (SkTranslateCommand*) canvas->getDrawCommandAt(curCommand);
 
     return 0 == t->x() && 0 == t->y();
 }
 
 // Just remove the translate
 static void apply_5(SkDebugCanvas* canvas, int curCommand) {
     canvas->deleteDrawCommandAt(curCommand);    // translate
 }
 
 // Check for:
 //    SCALE
 // where the scale is 1,1
 static bool check_6(SkDebugCanvas* canvas, int curCommand) {
     if (SCALE != canvas->getDrawCommandAt(curCommand)->getType()) {
         return false;
     }
 
-    Scale* s = (Scale*) canvas->getDrawCommandAt(curCommand);
+    SkScaleCommand* s = (SkScaleCommand*) canvas->getDrawCommandAt(curCommand);
 
     return SK_Scalar1 == s->x() && SK_Scalar1 == s->y();
 }
 
 // Just remove the scale
 static void apply_6(SkDebugCanvas* canvas, int curCommand) {
     canvas->deleteDrawCommandAt(curCommand);   // scale
 }
 
 // Check for:
@@ skipping 29 matching lines @@
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+7)->getType() ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+8)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+9)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+10)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+11)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+12)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+13)->getType()) {
         return false;
     }
 
-    ClipRect* clip0 = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    SaveLayer* saveLayer0 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+2);
-    ClipRect* clip1 = (ClipRect*) canvas->getDrawCommandAt(curCommand+4);
-    SaveLayer* saveLayer1 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+5);
-    ClipRect* clip2 = (ClipRect*) canvas->getDrawCommandAt(curCommand+7);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+8);
+    SkClipRectCommand* clip0 =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkSaveLayerCommand* saveLayer0 =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* clip1 =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+4);
+    SkSaveLayerCommand* saveLayer1 =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand+5);
+    SkClipRectCommand* clip2 =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+7);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+8);
 
     if (clip0->doAA() || clip1->doAA() || clip2->doAA()) {
         return false;
     }
 
     if (SkRegion::kIntersect_Op != clip0->op() ||
         SkRegion::kIntersect_Op != clip1->op() ||
         SkRegion::kIntersect_Op != clip2->op()) {
         return false;
     }
@@ skipping 48 matching lines @@
         }
     }
 
     return true;
 }
 
 // Reduce to a single drawBitmapRectToRect call by folding the clipRect's into
 // the src and dst Rects and the saveLayer paints into the drawBitmapRectToRect's
 // paint.
 static void apply_7(SkDebugCanvas* canvas, int curCommand) {
-    SaveLayer* saveLayer0 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+2);
-    SaveLayer* saveLayer1 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+5);
-    ClipRect* clip2 = (ClipRect*) canvas->getDrawCommandAt(curCommand+7);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+8);
+    SkSaveLayerCommand* saveLayer0 =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand+2);
+    SkSaveLayerCommand* saveLayer1 =
+        (SkSaveLayerCommand*) canvas->getDrawCommandAt(curCommand+5);
+    SkClipRectCommand* clip2 =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+7);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+8);
 
     SkScalar newSrcLeft = dbmr->srcRect()->fLeft + clip2->rect().fLeft - dbmr->dstRect().fLeft;
     SkScalar newSrcTop = dbmr->srcRect()->fTop + clip2->rect().fTop - dbmr->dstRect().fTop;
 
     SkRect newSrc = SkRect::MakeXYWH(newSrcLeft, newSrcTop,
                                      clip2->rect().width(), clip2->rect().height());
 
     dbmr->setSrcRect(newSrc);
     dbmr->setDstRect(clip2->rect());
 
@@ skipping 58 matching lines @@
 //      the clip rect is BW and a subset of the drawBitmapRectToRect's dest rect
 static bool check_8(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+4 ||
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
         return false;
     }
 
-    ClipRect* clip = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* clip =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     if (clip->doAA() || SkRegion::kIntersect_Op != clip->op()) {
         return false;
     }
 
     // The src->dest mapping needs to be 1-to-1
     if (NULL == dbmr->srcRect()) {
         if (dbmr->bitmap().width() != dbmr->dstRect().width() ||
             dbmr->bitmap().height() != dbmr->dstRect().height()) {
             return false;
         }
     } else {
         if (dbmr->srcRect()->width() != dbmr->dstRect().width() ||
             dbmr->srcRect()->height() != dbmr->dstRect().height()) {
             return false;
         }
     }
 
     if (!dbmr->dstRect().contains(clip->rect())) {
         return false;
     }
 
     return true;
 }
 
 // Fold the clipRect into the drawBitmapRectToRect's src and dest rects
 static void apply_8(SkDebugCanvas* canvas, int curCommand) {
-    ClipRect* clip = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* clip =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     SkScalar newSrcLeft, newSrcTop;
 
     if (NULL != dbmr->srcRect()) {
         newSrcLeft = dbmr->srcRect()->fLeft + clip->rect().fLeft - dbmr->dstRect().fLeft;
         newSrcTop  = dbmr->srcRect()->fTop + clip->rect().fTop - dbmr->dstRect().fTop;
     } else {
         newSrcLeft = clip->rect().fLeft - dbmr->dstRect().fLeft;
         newSrcTop  = clip->rect().fTop - dbmr->dstRect().fTop;
     }
@@ skipping 19 matching lines @@
 //      clipRect is BW and encloses the DBMR2R's dest rect
 static bool check_9(SkDebugCanvas* canvas, int curCommand) {
     if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
         canvas->getSize() <= curCommand+4 ||
         CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
         DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
         RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
         return false;
     }
 
-    ClipRect* clip = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
-    DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+2);
+    SkClipRectCommand* clip =
+        (SkClipRectCommand*) canvas->getDrawCommandAt(curCommand+1);
+    SkDrawBitmapRectCommand* dbmr =
+        (SkDrawBitmapRectCommand*) canvas->getDrawCommandAt(curCommand+2);
 
     if (clip->doAA() || SkRegion::kIntersect_Op != clip->op()) {
         return false;
     }
 
     if (!clip->rect().contains(dbmr->dstRect())) {
         return false;
     }
 
     return true;
@@ skipping 206 matching lines @@
 
     SkGraphics::Term();
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif