diff --git a/src/third_party/skia/tools/PictureBenchmark.cpp b/src/third_party/skia/tools/PictureBenchmark.cpp
new file mode 100644
index 0000000..15b6173
--- /dev/null
+++ b/src/third_party/skia/tools/PictureBenchmark.cpp
@@ -0,0 +1,253 @@
+/*
+ * 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 "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)
+, fRenderer(NULL)
+, fTimerResult(TimerData::kAvg_Result)
+, fTimerTypes(0)
+, fTimeIndividualTiles(false)
+, fPurgeDecodedTex(false)
+, fPreprocess(false)
+, fWriter(NULL)
+{}
+
+PictureBenchmark::~PictureBenchmark() {
+    SkSafeUnref(fRenderer);
+}
+
+void PictureBenchmark::setTimersToShow(bool wall,
+                                       bool truncatedWall,
+                                       bool cpu,
+                                       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;
+}
+
+Timer* PictureBenchmark::setupTimer(bool useGLTimer) {
+#if SK_SUPPORT_GPU
+    if (useGLTimer && fRenderer != NULL && fRenderer->isUsingGpuDevice()) {
+        return SkNEW_ARGS(Timer, (fRenderer->getGLContext()));
+    }
+#endif
+    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) {
+        return;
+    }
+
+    SkASSERT(fRenderer != NULL);
+    if (NULL == fRenderer) {
+        return;
+    }
+
+    fRenderer->init(pict, NULL, NULL, NULL, false);
+
+    // We throw this away to remove first time effects (such as paging in this program)
+    fRenderer->setup();
+
+    if (fPreprocess) {
+        if (fRenderer->getCanvas()) {
+            fRenderer->getCanvas()->EXPERIMENTAL_optimize(fRenderer->getPicture());
+        }
+    }
+
+    fRenderer->render(NULL);
+    fRenderer->resetState(true);   // flush, swapBuffers and Finish
+
+    if (fPurgeDecodedTex) {
+        fRenderer->purgeTextures();
+    }
+
+    bool usingGpu = false;
+#if SK_SUPPORT_GPU
+    usingGpu = fRenderer->isUsingGpuDevice();
+#endif
+
+    uint32_t timerTypes = fTimerTypes;
+    if (!usingGpu) {
+        timerTypes &= ~TimerData::kGpu_Flag;
+    }
+
+    SkString timeFormat;
+    if (TimerData::kPerIter_Result == fTimerResult) {
+        timeFormat = fRenderer->getPerIterTimeFormat();
+    } else {
+        timeFormat = fRenderer->getNormalTimeFormat();
+    }
+
+    static const int kNumInnerLoops = 10;
+    int numOuterLoops = 1;
+    int numInnerLoops = fRepeats;
+
+    if (TimerData::kPerIter_Result == fTimerResult && fRepeats > 1) {
+        // interpret this flag combination to mean: generate 'fRepeats'
+        // numbers by averaging each rendering 'kNumInnerLoops' times
+        numOuterLoops = fRepeats;
+        numInnerLoops = kNumInnerLoops;
+    }
+
+    if (fTimeIndividualTiles) {
+        TiledPictureRenderer* tiledRenderer = fRenderer->getTiledRenderer();
+        SkASSERT(tiledRenderer && tiledRenderer->supportsTimingIndividualTiles());
+        if (NULL == tiledRenderer || !tiledRenderer->supportsTimingIndividualTiles()) {
+            return;
+        }
+        int xTiles, yTiles;
+        if (!tiledRenderer->tileDimensions(xTiles, yTiles)) {
+            return;
+        }
+
+        int x, y;
+        while (tiledRenderer->nextTile(x, y)) {
+            // There are two timers, which will behave slightly differently:
+            // 1) longRunningTimer, along with perTileTimerData, will time how long it takes to draw
+            // one tile fRepeats times, and take the average. As such, it will not respect the
+            // logPerIter or printMin options, since it does not know the time per iteration. It
+            // will also be unable to call flush() for each tile.
+            // 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<Timer> longRunningTimer(this->setupTimer());
+            TimerData longRunningTimerData(numOuterLoops);
+
+            for (int outer = 0; outer < numOuterLoops; ++outer) {
+                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()));
+
+                    if (fPurgeDecodedTex) {
+                        fRenderer->purgeTextures();
+                    }
+                }
+                longRunningTimer->truncatedEnd();
+                tiledRenderer->resetState(true);       // flush, swapBuffers and Finish
+                longRunningTimer->end();
+                SkAssertResult(longRunningTimerData.appendTimes(longRunningTimer.get()));
+            }
+
+            fWriter->logRenderer(tiledRenderer);
+            fWriter->tileMeta(x, y, xTiles, yTiles);
+
+            // TODO(borenet): Turn off per-iteration tile time reporting for now.
+            // Avoiding logging the time for every iteration for each tile cuts
+            // down on data file size by a significant amount. Re-enable this once
+            // we're loading the bench data directly into a data store and are no
+            // longer generating SVG graphs.
+#if 0
+            fWriter->tileData(
+                    &perTileTimerData,
+                    timeFormat.c_str(),
+                    fTimerResult,
+                    timerTypes);
+#endif
+
+            if (fPurgeDecodedTex) {
+                fWriter->addTileFlag(PictureResultsWriter::kPurging);
+            }
+            fWriter->addTileFlag(PictureResultsWriter::kAvg);
+            fWriter->tileData(
+                &longRunningTimerData,
+                tiledRenderer->getNormalTimeFormat().c_str(),
+                TimerData::kAvg_Result,
+                timerTypes,
+                numInnerLoops);
+        }
+    } else {
+        SkAutoTDelete<Timer> longRunningTimer(this->setupTimer());
+        TimerData longRunningTimerData(numOuterLoops);
+
+        for (int outer = 0; outer < numOuterLoops; ++outer) {
+            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
+                perRunTimer->end();
+
+                SkAssertResult(perRunTimerData.appendTimes(perRunTimer.get()));
+
+                if (fPurgeDecodedTex) {
+                    fRenderer->purgeTextures();
+                }
+            }
+            longRunningTimer->truncatedEnd();
+            fRenderer->resetState(true);        // flush, swapBuffers and Finish
+            longRunningTimer->end();
+            SkAssertResult(longRunningTimerData.appendTimes(longRunningTimer.get()));
+        }
+
+        fWriter->logRenderer(fRenderer);
+        if (fPurgeDecodedTex) {
+            fWriter->addTileFlag(PictureResultsWriter::kPurging);
+        }
+
+        // Beware - since the per-run-timer doesn't ever include a glFinish it can
+        // report a lower time then the long-running-timer
+#if 0
+        fWriter->tileData(
+                &perRunTimerData,
+                timeFormat.c_str(),
+                fTimerResult,
+                timerTypes);
+#else
+        fWriter->tileData(
+                &longRunningTimerData,
+                timeFormat.c_str(),
+                fTimerResult,
+                timerTypes,
+                numInnerLoops);
+#endif
+    }
+
+    fRenderer->end();
+}
+
+}