Move BenchTimer to tools as Timer

tools/PictureBenchmark.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 "BenchTimer.h"
+#include "Timer.h"
 #include "PictureBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPicture.h"
 #include "SkString.h"
 #include "picture_utils.h"
 
 namespace sk_tools {
 
 PictureBenchmark::PictureBenchmark()
 : fRepeats(1)
@@ skipping 16 matching lines @@
                                        bool truncatedCpu,
                                        bool gpu) {
     fTimerTypes = 0;
     fTimerTypes |= wall ? TimerData::kWall_Flag : 0;
     fTimerTypes |= truncatedWall ? TimerData::kTruncatedWall_Flag : 0;
     fTimerTypes |= cpu ? TimerData::kCpu_Flag : 0;
     fTimerTypes |= truncatedCpu ? TimerData::kTruncatedCpu_Flag : 0;
     fTimerTypes |= gpu ? TimerData::kGpu_Flag : 0;
 }
 
-BenchTimer* PictureBenchmark::setupTimer(bool useGLTimer) {
+Timer* PictureBenchmark::setupTimer(bool useGLTimer) {
 #if SK_SUPPORT_GPU
     if (useGLTimer && fRenderer != NULL && fRenderer->isUsingGpuDevice()) {
-        return SkNEW_ARGS(BenchTimer, (fRenderer->getGLContext()));
+        return SkNEW_ARGS(Timer, (fRenderer->getGLContext()));
     }
 #endif
-    return SkNEW_ARGS(BenchTimer, (NULL));
+    return SkNEW_ARGS(Timer, (NULL));
 }
 
 PictureRenderer* PictureBenchmark::setRenderer(sk_tools::PictureRenderer* renderer) {
     SkRefCnt_SafeAssign(fRenderer, renderer);
     return renderer;
 }
 
 void PictureBenchmark::run(SkPicture* pict) {
     SkASSERT(pict);
     if (NULL == pict) {
@@ skipping 78 matching lines @@
             // The goal of this timer is to make up for a system timer that is not precise enough to
             // measure the small amount of time it takes to draw one tile once.
             //
             // 2) perTileTimer, along with perTileTimerData, will record each run separately, and
             // then take the average. As such, it supports logPerIter and printMin options.
             //
             // Although "legal", having two gpu timers running at the same time
             // seems to cause problems (i.e., INVALID_OPERATIONs) on several
             // platforms. To work around this, we disable the gpu timer on the
             // long running timer.
-            SkAutoTDelete<BenchTimer> longRunningTimer(this->setupTimer());
+            SkAutoTDelete<Timer> longRunningTimer(this->setupTimer());
             TimerData longRunningTimerData(numOuterLoops);
 
             for (int outer = 0; outer < numOuterLoops; ++outer) {
-                SkAutoTDelete<BenchTimer> perTileTimer(this->setupTimer(false));
+                SkAutoTDelete<Timer> perTileTimer(this->setupTimer(false));
                 TimerData perTileTimerData(numInnerLoops);
 
                 longRunningTimer->start();
                 for (int inner = 0; inner < numInnerLoops; ++inner) {
                     perTileTimer->start();
                     tiledRenderer->drawCurrentTile();
                     perTileTimer->truncatedEnd();
                     tiledRenderer->resetState(false);  // flush & swapBuffers, but don't Finish
                     perTileTimer->end();
                     SkAssertResult(perTileTimerData.appendTimes(perTileTimer.get()));
@@ skipping 29 matching lines @@
             }
             fWriter->addTileFlag(PictureResultsWriter::kAvg);
             fWriter->tileData(
                 &longRunningTimerData,
                 tiledRenderer->getNormalTimeFormat().c_str(),
                 TimerData::kAvg_Result,
                 timerTypes,
                 numInnerLoops);
         }
     } else {
-        SkAutoTDelete<BenchTimer> longRunningTimer(this->setupTimer());
+        SkAutoTDelete<Timer> longRunningTimer(this->setupTimer());
         TimerData longRunningTimerData(numOuterLoops);
 
         for (int outer = 0; outer < numOuterLoops; ++outer) {
-            SkAutoTDelete<BenchTimer> perRunTimer(this->setupTimer(false));
+            SkAutoTDelete<Timer> perRunTimer(this->setupTimer(false));
             TimerData perRunTimerData(numInnerLoops);
 
             longRunningTimer->start();
             for (int inner = 0; inner < numInnerLoops; ++inner) {
                 fRenderer->setup();
 
                 perRunTimer->start();
                 fRenderer->render(NULL);
                 perRunTimer->truncatedEnd();
                 fRenderer->resetState(false);   // flush & swapBuffers, but don't Finish
@@ skipping 37 matching lines @@
                 fTimerResult,
                 timerTypes,
                 numInnerLoops);
 #endif
     }
 
     fRenderer->end();
 }
 
 }