protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
// jostle the clip regions each time to prevent caching
fClipRect.offset((i % 2) == 0 ? SkIntToScalar(10) : SkIntToScalar(-10), 0);
fClipPath.reset();
canvas->restore();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkPoint offset = SkPoint::Make(0, 0);
this->recurse(canvas, 0, offset);
}
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkPaint paint;
this->setupPaint(&paint);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkAAClip clip;
if (fDoPath) {
clip.setPath(fPath, &fRegion, fDoAA);
protected:
virtual const char* onGetName() { return "aaclip_setregion"; }
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; ++i) {
SkAAClip clip;
clip.setRegion(fRegion);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
SkAutoTUnref<SkImageFilter> bicubic(SkBicubicImageFilter::CreateMitchell(fScale));
paint.setImageFilter(bicubic);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->save();
canvas->clipRect(r);
canvas->drawOval(r, paint);
fBitmap.setIsVolatile(fIsVolatile);
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkIPoint dim = this->getSize();
SkRandom rand;
const SkScalar x0 = SkIntToScalar(-bitmap.width() / 2);
const SkScalar y0 = SkIntToScalar(-bitmap.height() / 2);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
return fFullName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkISize dim = canvas->getDeviceSize();
if (fFlags & kScale_Flag) {
const SkScalar x = SkIntToScalar(dim.fWidth) / 2;
canvas->rotate(SkIntToScalar(35));
canvas->translate(-x, -y);
}
- INHERITED::onDraw(canvas);
+ INHERITED::onDraw(loops, canvas);
}
virtual void setupPaint(SkPaint* paint) SK_OVERRIDE {
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom rand;
SkPaint paint;
paint.setFilterLevel(fFilterLevel);
paint.setAlpha(fAlpha);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawBitmapRectToRect(fBitmap, &fSrcR, fDstR, &paint);
}
}
fMatrix.setScale( scale(), scale() );
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkPaint paint;
this->setupPaint(&paint);
preBenchSetup();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
doScaleImage();
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
paint.setAntiAlias(true);
SkRandom rand;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400,
rand.nextUScalar1() * 400);
r.offset(fRadius, fRadius);
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setImageFilter(new SkBlurImageFilter(fSigmaX, fSigmaY))->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawBitmap(fCheckerboard, 0, 0, &paint);
}
}
fName = name;
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkPaint paint;
this->setupPaint(&paint);
preBenchSetup(r);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
makeBlurryRect(r);
}
}
SkScalarCeilToInt(fRRect.rect().height()));
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkLayerDrawLooper* looper = new SkLayerDrawLooper;
{
SkLayerDrawLooper::LayerInfo info;
loopedPaint.setAntiAlias(true);
loopedPaint.setColor(SK_ColorCYAN);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawRect(fRRect.rect(), dullPaint);
canvas->drawRRect(fRRect, loopedPaint);
}
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
bool sizeChanged = false;
if (canvas->getDeviceSize() != fSize) {
fSize = canvas->getDeviceSize();
}
}
- for (int frame = 0; frame < this->getLoops(); ++frame) {
+ for (int frame = 0; frame < loops; ++frame) {
canvas->clear(0xFFE0F0E0);
}
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
switch (fType) {
case kChecksum_ChecksumType: {
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
volatile uint32_t result = SkChecksum::Compute(fData, sizeof(fData));
sk_ignore_unused_variable(result);
}
} break;
case kMD5_ChecksumType: {
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkMD5 md5;
md5.update(reinterpret_cast<uint8_t*>(fData), sizeof(fData));
SkMD5::Digest digest;
}
} break;
case kSHA1_ChecksumType: {
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkSHA1 sha1;
sha1.update(reinterpret_cast<uint8_t*>(fData), sizeof(fData));
SkSHA1::Digest digest;
}
} break;
case kMurmur3_ChecksumType: {
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
volatile uint32_t result = SkChecksum::Murmur3(fData, sizeof(fData));
sk_ignore_unused_variable(result);
}
protected:
virtual const char* onGetName() { return "chrome_scrollGmail"; }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkDEBUGCODE(this->validateBounds(canvas));
SkPaint paint;
this->setupPaint(&paint);
for (int i = 0; i < N; i++) {
SkRect current;
setRectangle(current, i);
- for (int j = 0; j < this->getLoops() * gmailScrollingRectSpec[i*3]; j++) {
+ for (int j = 0; j < loops * gmailScrollingRectSpec[i*3]; j++) {
canvas->drawRect(current, paint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- fProc(this->getLoops(), fPaint, fText, sizeof(fText), NGLYPHS);
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ fProc(loops, fPaint, fText, sizeof(fText), NGLYPHS);
}
private:
return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bright_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.4f) {
SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness));
SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, dim));
return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright_gray_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f));
SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness));
paint.setImageFilter(grayscale);
return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_bright_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> grayscale(make_grayscale());
SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, grayscale));
paint.setImageFilter(brightness);
return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_bright_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue));
paint.setImageFilter(brightness);
return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright_blue_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f));
SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness));
paint.setImageFilter(blue);
return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f));
paint.setImageFilter(brightness);
canvas->drawRect(r, paint);
return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> blue(make_mode_blue());
paint.setImageFilter(blue);
canvas->drawRect(r, paint);
return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkImageFilter> grayscale(make_grayscale());
paint.setImageFilter(grayscale);
canvas->drawRect(r, paint);
return isSmall() ? "table_colorfilter_small" : "table_colorfilter_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkColorFilter> table_filter(make_table_filter());
paint.setColorFilter(table_filter);
canvas->drawRect(r, paint);
return isSmall() ? "luma_colorfilter_small" : "luma_colorfilter_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = getFilterRect();
SkPaint paint;
paint.setColor(SK_ColorRED);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkAutoTUnref<SkColorFilter> luma_filter(SkLumaColorFilter::Create());
paint.setColorFilter(luma_filter);
canvas->drawRect(r, paint);
virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
const SkPMColor src = 0xAB998877, dst = 0x66334455;
volatile SkPMColor junk = 0;
- for (int i = 0; i < 10*this->getLoops(); ++i) {
+ for (int i = 0; i < 10*loops; ++i) {
for (size_t j = 0; j <= 256; j++) {
const unsigned scale = fScales[j];
if (kFast && kScale) {
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
if (fDrawCoverage) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
fDraw.drawPathCoverage(fPath, fPaint);
}
} else {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
fDraw.drawPath(fPath, fPaint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
this->setupPaint(&paint);
paint.setStyle(SkPaint::kStroke_Style);
canvas->clipRect(r);
}
- this->handlePath(canvas, path, paint, this->getLoops());
+ this->handlePath(canvas, path, paint, loops);
}
virtual void handlePath(SkCanvas* canvas, const SkPath& path,
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkPath dst;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
fPE->filterPath(&dst, fPath, &rec, NULL);
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
this->setupPaint(&paint);
paint.setStrokeWidth(fStrokeWidth);
paint.setStrokeCap(fIsRound ? SkPaint::kRound_Cap : SkPaint::kSquare_Cap);
paint.setPathEffect(fPE);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
canvas->drawLine(10 * SK_Scalar1, 10 * SK_Scalar1,
640 * SK_Scalar1, 10 * SK_Scalar1, paint);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint p;
this->setupPaint(&p);
p.setColor(SK_ColorBLACK);
{ SkIntToScalar(640), 0 }
};
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
pts[0].fY = pts[1].fY = SkIntToScalar(i % 480);
canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint p;
this->setupPaint(&p);
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(fStrokeWidth);
p.setPathEffect(fPathEffect);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, p);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); i++) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; i++) {
SkBitmap bm;
SkImageDecoder::DecodeFile(FLAGS_decodeBenchFilename[0],
&bm,
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkBaseDevice *device = canvas->getDevice()->createCompatibleDevice(
SkBitmap::kARGB_8888_Config, CANVAS_WIDTH, CANVAS_HEIGHT, false);
device->unref();
initDeferredCanvas(deferredCanvas);
- drawInDeferredCanvas(deferredCanvas);
+ drawInDeferredCanvas(loops, deferredCanvas);
finalizeDeferredCanvas(deferredCanvas);
deferredCanvas->flush();
}
virtual void initDeferredCanvas(SkDeferredCanvas* canvas) = 0;
- virtual void drawInDeferredCanvas(SkDeferredCanvas* canvas) = 0;
+ virtual void drawInDeferredCanvas(const int loops, SkDeferredCanvas* canvas) = 0;
virtual void finalizeDeferredCanvas(SkDeferredCanvas* canvas) = 0;
SkString fName;
canvas->setNotificationClient(&fNotificationClient);
}
- virtual void drawInDeferredCanvas(SkDeferredCanvas* canvas) SK_OVERRIDE {
+ virtual void drawInDeferredCanvas(const int loops, SkDeferredCanvas* canvas) SK_OVERRIDE {
SkRect rect;
rect.setXYWH(0, 0, 10, 10);
SkPaint paint;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->save(SkCanvas::kMatrixClip_SaveFlag);
canvas->translate(SkIntToScalar(i * 27 % CANVAS_WIDTH), SkIntToScalar(i * 13 % CANVAS_HEIGHT));
canvas->drawRect(rect, paint);
"DeferredSurfaceCopy_nonDiscardable";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
// The canvas is not actually used for this test except to provide
// configuration information: gpu, multisampling, size, etc?
SkImageInfo info;
SkAutoTUnref<SkDeferredCanvas> drawingCanvas(SkDeferredCanvas::Create(surface));
surface->unref();
- for (int iteration = 0; iteration < this->getLoops(); iteration++) {
+ for (int iteration = 0; iteration < loops; iteration++) {
drawingCanvas->clear(0);
SkAutoTUnref<SkImage> image(drawingCanvas->newImageSnapshot());
SkPaint paint;
return this->isSmall() ? "displacement_zero_small" : "displacement_zero_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
// No displacement effect
(SkDisplacementMapEffect::kR_ChannelSelectorType,
SkDisplacementMapEffect::kG_ChannelSelectorType, 0.0f, displ)))->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
this->drawClippedBitmap(canvas, 0, 0, paint);
}
}
return isSmall() ? "displacement_alpha_small" : "displacement_alpha_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
// Displacement, with 1 alpha component (which isn't pre-multiplied)
paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
(SkDisplacementMapEffect::kB_ChannelSelectorType,
SkDisplacementMapEffect::kA_ChannelSelectorType, 16.0f, displ)))->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
drawClippedBitmap(canvas, 100, 0, paint);
}
}
return isSmall() ? "displacement_full_small" : "displacement_full_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
SkAutoTUnref<SkImageFilter> displ(SkNEW_ARGS(SkBitmapSource, (fCheckerboard)));
// Displacement, with 2 non-alpha components
paint.setImageFilter(SkNEW_ARGS(SkDisplacementMapEffect,
(SkDisplacementMapEffect::kR_ChannelSelectorType,
SkDisplacementMapEffect::kB_ChannelSelectorType, 32.0f, displ)))->unref();
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
this->drawClippedBitmap(canvas, 200, 0, paint);
}
}
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
paint.setColor(fColors[i % N]);
canvas->drawRect(fRects[i % N], paint);
}
return "fontcache";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
this->setupPaint(&paint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
const uint16_t* array = gUniqueGlyphIDs;
while (*array != gUniqueGlyphIDs_Sentinel) {
int count = count_glyphs(array);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
paint.measureText(array, count * sizeof(uint16_t));
}
array += count + 1; // skip the sentinel
return "fontefficiency";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
static bool gDone;
if (gDone) {
return;
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
paint.setLCDRenderText(fDoLCD);
bool prev = gSkSuppressFontCachePurgeSpew;
gSkSuppressFontCachePurgeSpew = true;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
// this is critical - we want to time the creation process, so we
// explicitly flush our cache before each run
SkGraphics::PurgeFontCache();
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom scaleRand;
SkRandom transRand;
SkRandom rotRand;
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode))->unref();
- for (int i = 0; i < this->getLoops(); ++i, ++fNumSaved) {
+ for (int i = 0; i < loops; ++i, ++fNumSaved) {
if (0 == i % kNumBeforeClear) {
if (kPartial_Clear == fClear) {
for (int j = 0; j < fNumSaved; ++j) {
return "grmemorypool_stack";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkRandom r;
enum {
kMaxObjects = 4 * (1 << 10),
// We delete if a random [-1, 1] fixed pt is < the thresh. Otherwise,
// we allocate. We start allocate-biased and ping-pong to delete-biased
SkFixed delThresh = -SK_FixedHalf;
- const int kSwitchThreshPeriod = this->getLoops() / (2 * kMaxObjects);
+ const int kSwitchThreshPeriod = loops / (2 * kMaxObjects);
int s = 0;
int count = 0;
- for (int i = 0; i < this->getLoops(); i++, ++s) {
+ for (int i = 0; i < loops; i++, ++s) {
if (kSwitchThreshPeriod == s) {
delThresh = -delThresh;
s = 0;
return "grmemorypool_random";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkRandom r;
enum {
kMaxObjects = 4 * (1 << 10),
};
SkAutoTDelete<A> objects[kMaxObjects];
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
uint32_t idx = r.nextRangeU(0, kMaxObjects-1);
if (NULL == objects[idx].get()) {
objects[idx].reset(new A);
return "grmemorypool_queue";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkRandom r;
A* objects[M];
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
uint32_t count = r.nextRangeU(0, M-1);
for (uint32_t i = 0; i < count; i++) {
objects[i] = new A;
return "grresourcecache_add";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
GrGpu* gpu = canvas->getGrContext()->getGpu();
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
GrResourceCache cache(CACHE_SIZE_COUNT, CACHE_SIZE_BYTES);
populate_cache(&cache, gpu, DUPLICATE_COUNT);
populate_cache(&cache, gpu, RESOURCE_COUNT);
return "grresourcecache_find";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
GrGpu* gpu = canvas->getGrContext()->getGpu();
GrResourceCache cache(CACHE_SIZE_COUNT, CACHE_SIZE_BYTES);
populate_cache(&cache, gpu, DUPLICATE_COUNT);
populate_cache(&cache, gpu, RESOURCE_COUNT);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
for (int k = 0; k < RESOURCE_COUNT; ++k) {
check_cache_contents_or_die(&cache, k);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
paint.setShader(fShader);
SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
- for (int i = 0; i < this->getLoops() * kRepeat; i++) {
+ for (int i = 0; i < loops * kRepeat; i++) {
switch (fGeomType) {
case kRect_GeomType:
canvas->drawRect(r, paint);
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
{ SkIntToScalar(100), SkIntToScalar(100) },
};
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
const int gray = i % 256;
const int alpha = fHasAlpha ? gray : 0xFF;
SkColor colors[] = {
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint(fPaint);
this->setupPaint(&paint);
path.transform(m);
}
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawPath(path, paint);
}
}
return "imagecache";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
if (fCache.getBytesUsed() == 0) {
this->populateCache();
}
SkBitmap tmp;
// search for a miss (-1 scale)
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
(void)fCache.findAndLock(fBM, -1, -1, &tmp);
}
}
}
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
#ifdef SK_DEBUG
if (!fValid) {
SkDebugf("stream was invalid: %s\n", fName.c_str());
#endif
// Decode a bunch of times
SkBitmap bm;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkDEBUGCODE(bool success =) SkImageDecoder::DecodeStream(&fStream, &bm);
#ifdef SK_DEBUG
if (!success) {
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
- int n = this->getLoops() * this->mulLoopCount();
+ virtual void onDraw(const int loops, SkCanvas*) {
+ int n = loops * this->mulLoopCount();
for (int i = 0; i < n; i++) {
this->performTest(fDst, fFx, fDx, kBuffer);
}
LightingBaseBench(bool small) : fIsSmall(small) { }
protected:
- void draw(SkCanvas* canvas, SkImageFilter* imageFilter) const {
+ void draw(const int loops, SkCanvas* canvas, SkImageFilter* imageFilter) const {
SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
SkPaint paint;
paint.setImageFilter(imageFilter)->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawRect(r, paint);
}
}
return fIsSmall ? "lightingpointlitdiffuse_small" : "lightingpointlitdiffuse_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreatePointLitDiffuse(getPointLocation(), getWhite(),
- getSurfaceScale(), getKd()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreatePointLitDiffuse(getPointLocation(),
+ getWhite(),
+ getSurfaceScale(),
+ getKd()));
}
private:
return fIsSmall ? "lightingdistantlitdiffuse_small" : "lightingdistantlitdiffuse_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreateDistantLitDiffuse(getDistantDirection(),
- getWhite(), getSurfaceScale(), getKd()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreateDistantLitDiffuse(getDistantDirection(),
+ getWhite(),
+ getSurfaceScale(),
+ getKd()));
}
private:
return fIsSmall ? "lightingspotlitdiffuse_small" : "lightingspotlitdiffuse_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreateSpotLitDiffuse(getSpotLocation(),
- getSpotTarget(), getSpotExponent(), getCutoffAngle(), getWhite(), getSurfaceScale(),
- getKd()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreateSpotLitDiffuse(getSpotLocation(),
+ getSpotTarget(),
+ getSpotExponent(),
+ getCutoffAngle(),
+ getWhite(),
+ getSurfaceScale(),
+ getKd()));
}
private:
return fIsSmall ? "lightingpointlitspecular_small" : "lightingpointlitspecular_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreatePointLitSpecular(getPointLocation(), getWhite(),
- getSurfaceScale(), getKs(), getShininess()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreatePointLitSpecular(getPointLocation(),
+ getWhite(),
+ getSurfaceScale(),
+ getKs(),
+ getShininess()));
}
private:
return fIsSmall ? "lightingdistantlitspecular_small" : "lightingdistantlitspecular_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreateDistantLitSpecular(getDistantDirection(),
- getWhite(), getSurfaceScale(), getKs(), getShininess()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreateDistantLitSpecular(getDistantDirection(),
+ getWhite(),
+ getSurfaceScale(),
+ getKs(),
+ getShininess()));
}
private:
return fIsSmall ? "lightingspotlitspecular_small" : "lightingspotlitspecular_large";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- draw(canvas, SkLightingImageFilter::CreateSpotLitSpecular(getSpotLocation(),
- getSpotTarget(), getSpotExponent(), getCutoffAngle(), getWhite(), getSurfaceScale(),
- getKs(), getShininess()));
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ draw(loops, canvas, SkLightingImageFilter::CreateSpotLitSpecular(getSpotLocation(),
+ getSpotTarget(),
+ getSpotExponent(),
+ getCutoffAngle(),
+ getWhite(),
+ getSurfaceScale(),
+ getKs(),
+ getShininess()));
}
private:
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
this->setupPaint(&paint);
paint.setAntiAlias(fDoAA);
paint.setStrokeWidth(fStrokeWidth);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawPoints(SkCanvas::kLines_PointMode, PTS, fPts, paint);
}
}
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
const int h = fIsSmall ? FILTER_HEIGHT_SMALL : FILTER_HEIGHT_LARGE;
SkPaint paint;
SkIntToScalar(w / 2),
SkIntToScalar(h / 2)), 100))->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawBitmap(fCheckerboard, 0, 0, &paint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
- int n = this->getLoops() * this->mulLoopCount();
+ virtual void onDraw(const int loops, SkCanvas*) {
+ int n = loops * this->mulLoopCount();
for (int i = 0; i < n; i++) {
this->performTest(fDst, fSrc, kBuffer);
}
}
protected:
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
IsFiniteProc proc = fProc;
const float* data = fData;
// do this so the compiler won't throw away the function call
int counter = 0;
if (proc) {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < N - 4; ++i) {
counter += proc(&data[i]);
}
}
} else {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < N - 4; ++i) {
const SkRect* r = reinterpret_cast<const SkRect*>(&data[i]);
if (false) { // avoid bit rot, suppress warning
virtual void process(float) {}
protected:
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SkRandom rand;
float accum = 0;
const float* data = fData;
if (fFast) {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < ARRAY; ++i) {
accum += fast_floor(data[i]);
}
this->process(accum);
}
} else {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < ARRAY; ++i) {
accum += sk_float_floor(data[i]);
}
virtual void process(int) {}
protected:
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
int accum = 0;
if (fUsePortable) {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < ARRAY; ++i) {
accum += SkCLZ_portable(fData[i]);
}
this->process(accum);
}
} else {
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < ARRAY; ++i) {
accum += SkCLZ(fData[i]);
}
virtual void process(int) {}
protected:
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
int accum = 0;
- for (int j = 0; j < this->getLoops(); ++j) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < ARRAY; ++i) {
accum += fVec[i].normalize();
}
FixedMathBench() {
SkRandom rand;
- for (int i = 0; i < this->getLoops(); ++i) {
- fData[i%N] = rand.nextSScalar1();
+ for (int i = 0; i < N; ++i) {
+ fData[i] = rand.nextSScalar1();
}
}
}
protected:
- virtual void onDraw(SkCanvas*) {
- for (int j = 0; j < this->getLoops(); ++j) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int j = 0; j < loops; ++j) {
for (int i = 0; i < N - 4; ++i) {
fResult[i] = SkFloatToFixed(fData[i]);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
volatile T a = 0, b = 0;
T div = 0, mod = 0;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
if ((T)i == 0) continue; // Small T will wrap around.
SkTDivMod((T)(i+1), (T)i, &div, &mod);
a ^= div;
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); i++) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; i++) {
this->performTest();
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); i++) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; i++) {
this->performTest();
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
paint.setAntiAlias(true);
SkRandom rand;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400,
rand.nextUScalar1() * 400);
paint.setImageFilter(fFilter);
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
size_t inc = fMinSize >> 4;
SkASSERT(inc > 0);
size_t total = fMinSize * 64;
SkChunkAlloc alloc(fMinSize);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
size_t size = 0;
int calls = 0;
while (size < total) {
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); i++) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; i++) {
int* zeros = fUseCalloc ? calloc(fNum) : malloc_bzero(fNum);
if (fRead) {
volatile int x = 15;
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
this->performTest();
}
}
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r = fIsSmall ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMALL) :
SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARGE);
SkPaint paint;
paint.setImageFilter(mergeBitmaps())->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawRect(r, paint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
paint.setAntiAlias(true);
SkRandom rand;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400,
rand.nextUScalar1() * 400);
r.offset(fRadius, fRadius);
return "mutex";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
SK_DECLARE_STATIC_MUTEX(mu);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
mu.acquire();
mu.release();
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint(fPaint);
this->setupPaint(&paint);
path.transform(m);
}
- int count = this->getLoops();
+ int count = loops;
if (fFlags & kBig_Flag) {
count >>= 2;
}
fPaths.reset(kPathCnt);
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
this->makePath(&fPaths[i & (kPathCnt - 1)]);
}
this->restartMakingPaths();
}
this->finishedMakingPaths();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
fCopies[idx] = fPaths[idx];
}
}
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
if (fInPlace) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
fPaths[i & (kPathCnt - 1)].transform(fMatrix);
}
} else {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
fPaths[idx].transform(fMatrix, &fTransformed[idx]);
}
this->finishedMakingPaths();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
}
this->finishedMakingPaths();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
switch (fType) {
case kAdd_AddType:
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
SkPath result = fPaths0[idx];
result.addPath(fPaths1[idx]);
}
break;
case kAddTrans_AddType:
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
SkPath result = fPaths0[idx];
result.addPath(fPaths1[idx], 2 * SK_Scalar1, 5 * SK_Scalar1);
}
break;
case kAddMatrix_AddType:
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
SkPath result = fPaths0[idx];
result.addPath(fPaths1[idx], fMatrix);
}
break;
case kReverseAdd_AddType:
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
SkPath result = fPaths0[idx];
result.reverseAddPath(fPaths1[idx]);
}
break;
case kReversePathTo_AddType:
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
int idx = i & (kPathCnt - 1);
SkPath result = fPaths0[idx];
result.reversePathTo(fPaths1[idx]);
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint;
paint.setColor(SK_ColorBLACK);
SkRect r;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkScalar radius = rand.nextUScalar1() * 3;
r.fLeft = rand.nextUScalar1() * 300;
r.fTop = rand.nextUScalar1() * 300;
SkASSERT(path->isConvex());
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom rand;
SkRect r;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkPaint paint;
paint.setColor(0xff000000 | rand.nextU());
paint.setAntiAlias(true);
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
const SkRect& rect = fQueryRects[i % kQueryRectCnt];
fParity = fParity != fPath.conservativelyContainsRect(rect);
}
return "ratquad-chop-0.5";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkConic dst[2];
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
fRQ.chopAt(0.5f, dst);
}
}
return "ratquad-chop-half";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkConic dst[2];
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
fRQ.chop(dst);
}
}
return "conic-compute-error";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkVector err;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
fConics[j].computeAsQuadError(&err);
}
return "conic-asQuadTol";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
fConics[j].asQuadTol(SK_ScalarHalf);
}
return "conic-quadPow2";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
+ for (int i = 0; i < loops; ++i) {
for (int j = 0; j < CONICS; ++j) {
fConics[j].computeQuadPOW2(SK_ScalarHalf);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
if (fRaw) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkPath::RawIter iter(fPath);
SkPath::Verb verb;
SkPoint pts[4];
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { }
}
} else {
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkPath::Iter iter(fPath, false);
SkPath::Verb verb;
SkPoint pts[4];
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
- for (int i = 0; i < this->getLoops(); ++i){
+ for (int i = 0; i < loops; ++i){
//create a random 16x16 bitmap
fillRandomBits(H * STRIDE, (char*) &bits);
return "perlinnoise";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- this->test(canvas, 0, 0, SkPerlinNoiseShader::kFractalNoise_Type,
- 0.1f, 0.1f, 3, 0, false);
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ this->test(loops, canvas, 0, 0, SkPerlinNoiseShader::kFractalNoise_Type,
+ 0.1f, 0.1f, 3, 0, false);
}
private:
canvas->restore();
}
- void test(SkCanvas* canvas, int x, int y, SkPerlinNoiseShader::Type type,
+ void test(const int loops, SkCanvas* canvas, int x, int y, SkPerlinNoiseShader::Type type,
float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed,
bool stitchTiles) {
SkShader* shader = (type == SkPerlinNoiseShader::kFractalNoise_Type) ?
SkPaint paint;
paint.setShader(shader)->unref();
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
this->drawClippedRect(canvas, x, y, paint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPicture picture;
recordCanvas(pCanvas);
picture.endRecording();
- const SkPoint translateDelta = getTranslateDelta(this->getLoops());
+ const SkPoint translateDelta = getTranslateDelta(loops);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
picture.draw(canvas);
canvas->translate(translateDelta.fX, translateDelta.fY);
}
DictionaryRecordBench() : INHERITED("dictionaries") {}
protected:
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkAutoTDelete<SkPicture> picture;
SkCanvas* canvas = NULL;
- const SkPoint translateDelta = getTranslateDelta(this->getLoops());
+ const SkPoint translateDelta = getTranslateDelta(loops);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
if (0 == i % kMaxLoopsPerCanvas) {
picture.reset(SkNEW(SkPicture));
canvas = picture->beginRecording(PICTURE_WIDTH, PICTURE_HEIGHT);
UniquePaintDictionaryRecordBench() : INHERITED("unique_paint_dictionary") { }
protected:
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkRandom rand;
SkPaint paint;
SkAutoTDelete<SkPicture> picture;
SkCanvas* canvas = NULL;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
if (0 == i % kMaxLoopsPerCanvas) {
picture.reset(SkNEW(SkPicture));
canvas = picture->beginRecording(PICTURE_WIDTH, PICTURE_HEIGHT);
ObjCount = 100, // number of unique paint objects
};
protected:
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkPicture picture;
SkCanvas* canvas = picture.beginRecording(PICTURE_WIDTH, PICTURE_HEIGHT);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawPaint(fPaint[i % ObjCount]);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
canvas->clear(SK_ColorBLACK);
SkISize size = canvas->getDeviceSize();
bmp2.setConfig(SkBitmap::kARGB_8888_Config, size.width(),
size.height());
- for (int loop = 0; loop < this->getLoops(); ++loop) {
+ for (int loop = 0; loop < loops; ++loop) {
// Unpremul -> Premul
canvas->writePixels(bmp1, 0, 0, fUnPremulConfig);
// Premul -> Unpremul
virtual const char* onGetName() SK_OVERRIDE {
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom rand;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
for (int j = 0; j < NUM_BUILD_RECTS; ++j) {
fTree->insert(reinterpret_cast<void*>(j), fProc(rand, j, NUM_BUILD_RECTS),
fBulkLoad);
fTree->flushDeferredInserts();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom rand;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkTDArray<void*> hits;
SkIRect query;
switch(fQuery) {
return "readpix";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
canvas->clear(SK_ColorBLACK);
SkISize size = canvas->getDeviceSize();
bitmap.setConfig(SkBitmap::kARGB_8888_Config, kWindowSize, kWindowSize);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
for (int x = 0; x < kNumStepsX; ++x) {
for (int y = 0; y < kNumStepsY; ++y) {
canvas->readPixels(&bitmap, x * offX, y * offY);
}
virtual const char* onGetName() { return computeName("rects"); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
if (fStroke > 0) {
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SkIntToScalar(fStroke));
}
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
paint.setColor(fColors[i % N]);
this->setupPaint(&paint);
this->drawThisRect(canvas, fRects[i % N], paint);
}
protected:
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkScalar gSizes[] = {
SkIntToScalar(7), 0
};
SkPaint paint;
paint.setStrokeCap(SkPaint::kRound_Cap);
- for (int loop = 0; loop < this->getLoops(); loop++) {
+ for (int loop = 0; loop < loops; loop++) {
for (size_t i = 0; i < sizes; i++) {
paint.setStrokeWidth(gSizes[i]);
this->setupPaint(&paint);
return "aarects";
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
static const SkScalar kHalfRectSize = 0.75f;
SkPaint paint;
SkRect r = { -kHalfRectSize, -kHalfRectSize, kHalfRectSize, kHalfRectSize };
int rot = 0;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
// Draw small aa rects in a grid across the screen
for (SkScalar y = kHalfRectSize+SK_Scalar1; y < H; y += 2*kHalfRectSize+2) {
for (SkScalar x = kHalfRectSize+SK_Scalar1; x < W; x += 2*kHalfRectSize+2) {
}
protected:
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkScalar gSizes[] = {
SkIntToScalar(13), SkIntToScalar(24)
};
SkShader::kClamp_TileMode);
paint.setShader(s)->unref();
}
- for (int loop = 0; loop < this->getLoops(); loop++) {
+ for (int loop = 0; loop < loops; loop++) {
for (size_t i = 0; i < sizes; i++) {
switch (_type) {
case kMaskOpaque:
return "rectori";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRandom Random;
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkScalar blurSigma = Random.nextRangeScalar(1.5f, 25.0f);
SkScalar size = Random.nextRangeScalar(20*blurSigma, 50*blurSigma);
return "ref_cnt_stack";
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; ++i) {
SkRefCnt ref;
for (int j = 0; j < M; ++j) {
ref.ref();
return "ref_cnt_heap";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
char memory[sizeof(PlacedRefCnt)];
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
PlacedRefCnt* ref = new (memory) PlacedRefCnt();
for (int j = 0; j < M; ++j) {
ref->ref();
return "ref_cnt_new";
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; ++i) {
SkRefCnt* ref = new SkRefCnt();
for (int j = 0; j < M; ++j) {
ref->ref();
return "ref_cnt_stack_weak";
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; ++i) {
SkWeakRefCnt ref;
for (int j = 0; j < M; ++j) {
ref.ref();
return "ref_cnt_heap_weak";
}
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
char memory[sizeof(PlacedWeakRefCnt)];
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
PlacedWeakRefCnt* ref = new (memory) PlacedWeakRefCnt();
for (int j = 0; j < M; ++j) {
ref->ref();
return "ref_cnt_new_weak";
}
- virtual void onDraw(SkCanvas*) {
- for (int i = 0; i < this->getLoops(); ++i) {
+ virtual void onDraw(const int loops, SkCanvas*) {
+ for (int i = 0; i < loops; ++i) {
SkWeakRefCnt* ref = new SkWeakRefCnt();
for (int j = 0; j < M; ++j) {
ref->ref();
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
Proc proc = fProc;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
proc(fA, fB);
}
}
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas*) {
+ virtual void onDraw(const int loops, SkCanvas*) {
Proc proc = fProc;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
proc(fA, fB);
}
}
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkPaint paint(fPaint);
this->setupPaint(&paint);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawPaint(paint);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
- for (int i = 0; i < this->getLoops(); i++) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
+ for (int i = 0; i < loops; i++) {
this->performTest();
}
}
return "rect_bounds";
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkRect r;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
r.set(fPts, PTS);
}
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
const SkIPoint dim = this->getSize();
SkRandom rand;
const SkScalar y0 = SkIntToScalar(-10);
paint.setTextSize(SkIntToScalar(12));
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
canvas->drawText(fText.c_str(), fText.size(), x, y, paint);
}
paint.setTextSize(SkIntToScalar(48));
- for (int i = 0; i < this->getLoops() / 4 ; i++) {
+ for (int i = 0; i < loops / 4 ; i++) {
SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
canvas->drawText(fText.c_str(), fText.size(), x, y, paint);
fForceFilter = false;
fDither = SkTriState::kDefault;
fOrMask = fClearMask = 0;
- fLoops = 1;
}
const char* SkBenchmark::getName() {
this->onPreDraw();
}
-void SkBenchmark::draw(SkCanvas* canvas) {
- this->onDraw(canvas);
+void SkBenchmark::draw(const int loops, SkCanvas* canvas) {
+ this->onDraw(loops, canvas);
}
void SkBenchmark::postDraw() {
// before the initial draw.
void preDraw();
- void draw(SkCanvas*);
+ // Bench framework can tune loops to be large enough for stable timing.
+ void draw(const int loops, SkCanvas*);
// Call after draw, allows the benchmark to do cleanup work outside of the
// timer. When a benchmark is repeatedly drawn, this is only called once
fClearMask = clearMask;
}
- // The bench framework calls this to control the runtime of a bench.
- void setLoops(int loops) {
- fLoops = loops;
- }
-
- // Each bench should do its main work in a loop like this:
- // for (int i = 0; i < this->getLoops(); i++) { <work here> }
- int getLoops() const { return fLoops; }
-
static void SetResourcePath(const char* resPath) { gResourcePath.set(resPath); }
static SkString& GetResourcePath() { return gResourcePath; }
virtual const char* onGetName() = 0;
virtual void onPreDraw() {}
- virtual void onDraw(SkCanvas*) = 0;
+ // Each bench should do its main work in a loop like this:
+ // for (int i = 0; i < loops; i++) { <work here> }
+ virtual void onDraw(const int loops, SkCanvas*) = 0;
virtual void onPostDraw() {}
virtual SkIPoint onGetSize();
bool fForceFilter;
SkTriState::State fDither;
uint32_t fOrMask, fClearMask;
- int fLoops;
static SkString gResourcePath;
typedef SkRefCnt INHERITED;
}
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
if (!fValid) {
#ifdef SK_DEBUG
SkDebugf("stream was invalid: %s\n", fFilename.c_str());
}
// Decode a bunch of times
SkBitmap bm;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkDEBUGCODE(bool success =) fDecoder->decode(&fStream, &bm,
SkImageDecoder::kDecodePixels_Mode);
#ifdef SK_DEBUG
gRec[fType].fProc(fUnsorted.get());
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
SkAutoTMalloc<int> sorted(N);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
memcpy(sorted.get(), fUnsorted.get(), N*sizeof(int));
fSortProc(sorted.get());
#ifdef SK_DEBUG
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
fRec.fCanvas = canvas;
this->setupPaint(&fRec.fPaint);
fRec.fPaint.setStyle(SkPaint::kStroke_Style);
fRec.fPaint.setStrokeJoin(fJoin);
fRec.fPaint.setStrokeWidth(5);
- fProc(&fRec, this->getLoops());
+ fProc(&fRec, loops);
}
private:
return "tablebench";
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint cellPaint;
cellPaint.setColor(0xFFFFFFF);
SkPaint borderPaint;
borderPaint.setColor(0xFFCCCCCC);
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
for (int row = 0; row < kNumRows; ++row) {
for (int col = 0; col < kNumCols; ++col) {
SkRect cell = SkRect::MakeLTRB(col * kCellWidth,
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
const SkIPoint dim = this->getSize();
SkRandom rand;
canvas->translate(SK_Scalar1, SK_Scalar1);
}
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
if (fDoPos) {
canvas->drawPosText(fText.c_str(), fText.size(), fPos, paint);
} else {
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint(fPaint);
this->setupPaint(&paint);
paint.setFilterLevel(fDoFilter ? SkPaint::kLow_FilterLevel
SkPaint bgPaint;
bgPaint.setColor(SK_ColorWHITE);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
if (fDoTrans) {
canvas->drawRect(r, bgPaint);
}
protected:
virtual const char* onGetName() { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) {
SkPaint paint;
this->setupPaint(&paint);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode, PTS,
fPts, NULL, fColors, NULL, fIdx, IDX, paint);
}
return fName.c_str();
}
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkISize size = canvas->getDeviceSize();
canvas->clear(0xFFFF0000);
bmp.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height());
canvas->readPixels(&bmp, 0, 0);
- for (int loop = 0; loop < this->getLoops(); ++loop) {
+ for (int loop = 0; loop < loops; ++loop) {
canvas->writePixels(bmp, 0, 0, fConfig);
}
}
return "writer";
}
- virtual void onDraw(SkCanvas*) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE {
static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz";
static const size_t gLen = strlen(gStr);
SkWriter32 writer(256 * 4);
- for (int i = 0; i < this->getLoops(); i++) {
+ for (int i = 0; i < loops; i++) {
for (size_t j = 0; j <= gLen; j++) {
writer.writeString(gStr, j);
}
protected:
virtual const char* onGetName() SK_OVERRIDE { return fName.c_str(); }
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
SkISize size = canvas->getDeviceSize();
SkRandom random;
- for (int i = 0; i < this->getLoops(); ++i) {
+ for (int i = 0; i < loops; ++i) {
SkPaint paint;
paint.setXfermode(fXfermode.get());
paint.setColor(random.nextU());
protected:
virtual const char* onGetName() SK_OVERRIDE { return "xfermode_create"; }
- virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- for (int outer = 0; outer < this->getLoops() * 10; ++outer) {
+ virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
+ for (int outer = 0; outer < loops * 10; ++outer) {
for (int i = 0; i <= SkXfermode::kLastMode; ++i) {
SkXfermode* xfer = SkXfermode::Create(SkXfermode::Mode(i));
SkSafeUnref(xfer);
canvas.reset(SkRef(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
break;
case kPictureRecord_BenchMode:
- bench->draw(recordFrom.beginRecording(dim.fX, dim.fY, kRecordFlags));
+ bench->draw(1, recordFrom.beginRecording(dim.fX, dim.fY, kRecordFlags));
recordFrom.endRecording();
canvas.reset(SkRef(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
break;
// Save and restore around each call to draw() to guarantee a pristine canvas.
SkAutoCanvasRestore saveRestore(canvas, true/*also save*/);
+ int loops;
if (frameIntervalComputed && loopCount > loopsPerFrame) {
- bench->setLoops(loopsPerFrame);
+ loops = loopsPerFrame;
loopCount -= loopsPerFrame;
} else {
- bench->setLoops(loopCount);
+ loops = loopCount;
loopCount = 0;
}
if (benchMode == kPictureRecord_BenchMode) {
recordFrom.draw(canvas);
} else {
- bench->draw(canvas);
+ bench->draw(loops, canvas);
}
if (kDeferredSilent_BenchMode == benchMode) {