Add aligned case to game bench

bench/GameBench.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 "SkBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkString.h"
 
 
 // This bench simulates the calls Skia sees from various HTML5 canvas
 // game bench marks
 class GameBench : public SkBenchmark {
 public:
     enum Type {
         kScale_Type,
         kTranslate_Type,
         kRotate_Type
     };
 
-    GameBench(void* param, Type type, bool partialClear)
+    GameBench(void* param, Type type, bool partialClear, bool aligned = false)
         : INHERITED(param)
         , fType(type)
         , fPartialClear(partialClear)
+        , fAligned(aligned)
         , fName("game")
         , fNumSaved(0)
         , fInitialized(false) {
 
         switch (fType) {
         case kScale_Type:
             fName.append("_scale");
             break;
         case kTranslate_Type:
             fName.append("_trans");
             break;
         case kRotate_Type:
             fName.append("_rot");
             break;
         };
 
+        if (aligned) {
+            fName.append("_aligned");
+        }
+
         if (partialClear) {
             fName.append("_partial");
         } else {
             fName.append("_full");
         }
 
         // It's HTML 5 canvas, so always AA
         fName.append("_aa");
     }
 
@@ skipping 68 matching lines @@
 
                 fNumSaved = 0;
             }
 
             SkASSERT(fNumSaved < kNumBeforeClear);
 
             canvas->setMatrix(SkMatrix::I());
 
             fSaved[fNumSaved][0] = transRand.nextRangeScalar(0.0f, maxTransX);
             fSaved[fNumSaved][1] = transRand.nextRangeScalar(0.0f, maxTransY);
+            if (fAligned) {
+                // make the translations integer aligned
+                fSaved[fNumSaved][0] = SkScalarFloorToScalar(fSaved[fNumSaved][0]);
+                fSaved[fNumSaved][1] = SkScalarFloorToScalar(fSaved[fNumSaved][1]);
+            }
 
             mat.setTranslate(fSaved[fNumSaved][0], fSaved[fNumSaved][1]);
 
             if (kScale_Type == fType) {
                 fSaved[fNumSaved][2] = scaleRand.nextRangeScalar(0.5f, 1.5f);
                 mat.preScale(fSaved[fNumSaved][2], fSaved[fNumSaved][2]);
             } else if (kRotate_Type == fType) {
                 fSaved[fNumSaved][2] = rotRand.nextRangeScalar(0.0f, 360.0f);
                 mat.preRotate(fSaved[fNumSaved][2]);
             }
@@ skipping 10 matching lines @@
     static const int kNumRects = 100;
     static const int kNumBeforeClear = 10;
 #else
     static const int kNumRects = 5000;
     static const int kNumBeforeClear = 300;
 #endif
 
 
     Type     fType;
     bool     fPartialClear;
+    bool     fAligned;
     SkString fName;
     int      fNumSaved; // num draws stored in 'fSaved'
     bool     fInitialized;
 
     // 0 & 1 are always x & y translate. 2 is either scale or rotate.
     SkScalar fSaved[kNumBeforeClear][3];
     SkBitmap fCheckerboard;
 
     // Note: the resulting checker board has transparency
     void makeCheckerboard() {
@@ skipping 17 matching lines @@
             }
         }
     }
 
     typedef SkBenchmark INHERITED;
 };
 
 // Partial clear
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kScale_Type, false)); )
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type, false)); )
+DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type, false, true)); )
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kRotate_Type, false)); )
 
 // Full clear
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kScale_Type, true)); )
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type, true)); )
+DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kTranslate_Type, true, true)); )
 DEF_BENCH( return SkNEW_ARGS(GameBench, (p, GameBench::kRotate_Type, true)); )