Fixed up SkTimedPicturePlayback

debugger/QT/SkDebuggerGUI.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 "SkDebuggerGUI.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
@@ skipping 138 matching lines @@
 }
 
 void SkDebuggerGUI::showDeletes() {
     fDeletesActivated = !fDeletesActivated;
     for (int row = 0; row < fListWidget.count(); row++) {
         QListWidgetItem *item = fListWidget.item(row);
         item->setHidden(fDebugger.isCommandVisible(row) && fDeletesActivated);
     }
 }
 
-// The timed picture playback uses the SkPictureData's profiling stubs
-// to time individual commands. The offsets are needed to map SkPicture
-// offsets to individual commands.
+// The timed picture playback just steps through every operation timing
+// each one individually. Note that each picture should be replayed multiple 
+// times (via calls to 'draw') before each command's time is accessed via 'time'.
 class SkTimedPicturePlayback : public SkPicturePlayback {
 public:
 
     SkTimedPicturePlayback(const SkPicture* picture, const SkTDArray<bool>& deletedCommands)
         : INHERITED(picture)
         , fSkipCommands(deletedCommands)
         , fTot(0.0)
         , fCurCommand(0) {
         fTimes.setCount(deletedCommands.count());
         fTypeTimes.setCount(LAST_DRAWTYPE_ENUM+1);
         this->resetTimes();
     }
 
+    virtual void draw(SkCanvas* canvas, SkDrawPictureCallback* callback) SK_OVERRIDE {
+        AutoResetOpID aroi(this);
+        SkASSERT(0 == fCurOffset);
+
+        SkReader32 reader(fPictureData->opData()->bytes(), fPictureData->opData()->size());
+
+        // Record this, so we can concat w/ it if we encounter a setMatrix()
+        SkMatrix initialMatrix = canvas->getTotalMatrix();
+
+        SkAutoCanvasRestore acr(canvas, false);
+
+        int opIndex = -1;
+
+        while (!reader.eof()) {
+            if (NULL != callback && callback->abortDrawing()) {
+                return;
+            }
+
+            fCurOffset = reader.offset();
+            uint32_t size;
+            DrawType op = ReadOpAndSize(&reader, &size);
+            if (NOOP == op) {
+                // NOOPs are to be ignored - do not propagate them any further
+                reader.setOffset(fCurOffset + size);
+                continue;
+            }
+
+            opIndex++;
+
+            if (this->preDraw(opIndex, op)) {
+                // This operation is disabled in the debugger's GUI
+                reader.setOffset(fCurOffset + size);
+                continue;
+            }
+
+            this->handleOp(&reader, op, size, canvas, initialMatrix);
+
+            this->postDraw(opIndex);
+        }
+    }
+
     void resetTimes() {
         for (int i = 0; i < fTimes.count(); ++i) {
             fTimes[i] = 0.0;
         }
         for (int i = 0; i < fTypeTimes.count(); ++i) {
             fTypeTimes[i] = 0.0f;
         }
         fTot = 0.0;
     }
 
     int count() const { return fTimes.count(); }
 
+    // Return the fraction of the total time consumed by the index-th operation
     double time(int index) const { return fTimes[index] / fTot; }
 
     const SkTDArray<double>* typeTimes() const { return &fTypeTimes; }
 
     double totTime() const { return fTot; }
 
 protected:
     SysTimer fTimer;
     SkTDArray<bool> fSkipCommands; // has the command been deleted in the GUI?
     SkTDArray<double> fTimes;   // sum of time consumed for each command
     SkTDArray<double> fTypeTimes; // sum of time consumed for each type of command (e.g., drawPath)
     double fTot;                // total of all times in 'fTimes'
+
     int fCurType;
     int fCurCommand;            // the current command being executed/timed
 
-#ifdef SK_DEVELOPER
-    virtual bool preDraw(int opIndex, int type) SK_OVERRIDE {
+    bool preDraw(int opIndex, int type) {
         fCurCommand = opIndex;
 
         if (fSkipCommands[fCurCommand]) {
             return true;
         }
 
         fCurType = type;
         // The SkDebugCanvas doesn't recognize these types. This class needs to
         // convert or else we'll wind up with a mismatch between the type counts
         // the debugger displays and the profile times.
         if (DRAW_POS_TEXT_TOP_BOTTOM == type) {
             fCurType = DRAW_POS_TEXT;
         } else if (DRAW_POS_TEXT_H_TOP_BOTTOM == type) {
             fCurType = DRAW_POS_TEXT_H;
         }
 
 #if defined(SK_BUILD_FOR_WIN32)
         // CPU timer doesn't work well on Windows
         fTimer.startWall();
 #else
         fTimer.startCpu();
 #endif
 
         return false;
     }
 
-    virtual void postDraw(int opIndex) SK_OVERRIDE {
+    void postDraw(int opIndex) {
 #if defined(SK_BUILD_FOR_WIN32)
         // CPU timer doesn't work well on Windows
         double time = fTimer.endWall();
 #else
         double time = fTimer.endCpu();
 #endif
 
         SkASSERT(opIndex == fCurCommand);
         SkASSERT(fCurType <= LAST_DRAWTYPE_ENUM);
 
         fTimes[fCurCommand] += time;
         fTypeTimes[fCurType] += time;
         fTot += time;
     }
-#endif
 
 private:
     typedef SkPicturePlayback INHERITED;
 };
 
 #if 0
 // Wrap SkPicture to allow installation of an SkTimedPicturePlayback object
 class SkTimedPicture : public SkPicture {
 public:
     static SkTimedPicture* CreateTimedPicture(SkStream* stream,
@@ skipping 811 matching lines @@
     }
 
     // NOTE(chudy): Makes first item unselectable.
     QStandardItemModel* model = qobject_cast<QStandardItemModel*>(
             fFilter.model());
     QModelIndex firstIndex = model->index(0, fFilter.modelColumn(),
             fFilter.rootModelIndex());
     QStandardItem* firstItem = model->itemFromIndex(firstIndex);
     firstItem->setSelectable(false);
 }