Remove offsetcanvas from debugger

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 "SkGraphics.h"
 #include "SkImageDecoder.h"
@@ skipping 126 matching lines @@
                 && fDeletesActivated);
     }
 }
 
 // The timed picture playback uses the SkPicturePlayback's profiling stubs
 // to time individual commands. The offsets are needed to map SkPicture
 // offsets to individual commands.
 class SkTimedPicturePlayback : public SkPicturePlayback {
 public:
     SkTimedPicturePlayback(SkStream* stream, const SkPictInfo& info,
-                           SkPicture::InstallPixelRefProc proc, const SkTDArray<size_t>& offsets,
+                           SkPicture::InstallPixelRefProc proc, 
                            const SkTDArray<bool>& deletedCommands)
         : INHERITED(stream, info, proc)
-        , fOffsets(offsets)
         , fSkipCommands(deletedCommands)
         , fTot(0.0)
         , fCurCommand(0) {
-        fTimes.setCount(fOffsets.count());
+        fTimes.setCount(deletedCommands.count());
         fTypeTimes.setCount(LAST_DRAWTYPE_ENUM+1);
         this->resetTimes();
     }
 
     void resetTimes() {
-        for (int i = 0; i < fOffsets.count(); ++i) {
+        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(); }
 
     double time(int index) const { return fTimes[index] / fTot; }
 
     const SkTDArray<double>* typeTimes() const { return &fTypeTimes; }
 
     double totTime() const { return fTot; }
 
 protected:
     BenchSysTimer fTimer;
-    SkTDArray<size_t> fOffsets; // offset in the SkPicture for each command
     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'
-    size_t fCurOffset;
     int fCurType;
     int fCurCommand;            // the current command being executed/timed
 
-    virtual size_t preDraw(size_t offset, int type) {
-        // This search isn't as bad as it seems. In normal playback mode, the
-        // base class steps through the commands in order and can only skip ahead
-        // a bit on a clip. This class is only used during profiling so we
-        // don't have to worry about forward/backward scrubbing through commands.
-        for (int i = 0; offset != fOffsets[fCurCommand]; ++i) {
-            fCurCommand = (fCurCommand+1) % fOffsets.count();
-            SkASSERT(i <= fOffsets.count()); // should always find the offset in the list
+#ifdef SK_DEVELOPER
+    virtual bool preDraw(int opIndex, int type) SK_OVERRIDE {
+        fCurCommand = opIndex;
+
+        if (fSkipCommands[fCurCommand]) {
+            return true;
         }
 
-        if (fSkipCommands[fCurCommand]) {
-            while (fCurCommand < fSkipCommands.count() && fSkipCommands[fCurCommand]) {
-                ++fCurCommand;
-            }
-            if (fCurCommand == fSkipCommands.count()) {
-                // Signal SkPicturePlayback to stop playing back
-                return SK_MaxU32;
-            }
-            return fOffsets[fCurCommand];
-        }
-
-        fCurOffset = offset;
         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 0;
+        return false;
     }
 
-    virtual void postDraw(size_t offset) {
+    virtual void postDraw(int opIndex) SK_OVERRIDE {
 #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(offset == fCurOffset);
+        SkASSERT(opIndex == fCurCommand);
         SkASSERT(fCurType <= LAST_DRAWTYPE_ENUM);
 
         fTimes[fCurCommand] += time;
         fTypeTimes[fCurType] += time;
         fTot += time;
     }
+#endif
 
 private:
     typedef SkPicturePlayback INHERITED;
 };
 
 // Wrap SkPicture to allow installation of an SkTimedPicturePlayback object
 class SkTimedPicture : public SkPicture {
 public:
     explicit SkTimedPicture(SkStream* stream, bool* success, SkPicture::InstallPixelRefProc proc,
-                            const SkTDArray<size_t>& offsets,
                             const SkTDArray<bool>& deletedCommands) {
         if (success) {
             *success = false;
         }
         fRecord = NULL;
         fPlayback = NULL;
         fWidth = fHeight = 0;
 
         SkPictInfo info;
 
         if (!stream->read(&info, sizeof(info))) {
             return;
         }
         if (SkPicture::PICTURE_VERSION != info.fVersion) {
             return;
         }
 
         if (stream->readBool()) {
             fPlayback = SkNEW_ARGS(SkTimedPicturePlayback,
-                                   (stream, info, proc, offsets, deletedCommands));
+                                   (stream, info, proc, deletedCommands));
         }
 
         // do this at the end, so that they will be zero if we hit an error.
         fWidth = info.fWidth;
         fHeight = info.fHeight;
         if (success) {
             *success = true;
         }
     }
 
@@ skipping 62 matching lines @@
 
     SkFILEStream inputStream;
 
     inputStream.setPath(fFileName.c_str());
     if (!inputStream.isValid()) {
         return;
     }
 
     bool success = false;
     SkTimedPicture picture(&inputStream, &success, &SkImageDecoder::DecodeMemory,
-                           fOffsets, fSkipCommands);
+                           fSkipCommands);
     if (!success) {
         return;
     }
 
     // For now this #if allows switching between tiled and simple rendering
     // modes. Eventually this will be accomplished via the GUI
 #if 0
     // With the current batch of SysTimers, profiling in tiled mode
     // gets swamped by the timing overhead:
     //
@@ skipping 539 matching lines @@
     QDir dir(path);
     QRegExp r(".skp");
     fDirectoryWidget.clear();
     const QStringList files = dir.entryList();
     foreach (QString f, files) {
         if (f.contains(r))
             fDirectoryWidget.addItem(f);
     }
 }
 
-// SkOffsetPicturePlayback records the offset of each command in the picture.
-// These are needed by the profiling system.
-class SkOffsetPicturePlayback : public SkPicturePlayback {
-public:
-    SkOffsetPicturePlayback(SkStream* stream, const SkPictInfo& info,
-                            SkPicture::InstallPixelRefProc proc)
-        : INHERITED(stream, info, proc) {
-    }
-
-    const SkTDArray<size_t>& offsets() const { return fOffsets; }
-
-protected:
-    SkTDArray<size_t> fOffsets;
-
-    virtual size_t preDraw(size_t offset, int type) {
-        *fOffsets.append() = offset;
-        return 0;
-    }
-
-private:
-    typedef SkPicturePlayback INHERITED;
-};
-
-// Picture to wrap an SkOffsetPicturePlayback.
-class SkOffsetPicture : public SkPicture {
-public:
-    SkOffsetPicture(SkStream* stream, bool* success, SkPicture::InstallPixelRefProc proc) {
-        if (success) {
-            *success = false;
-        }
-        fRecord = NULL;
-        fPlayback = NULL;
-        fWidth = fHeight = 0;
-
-        SkPictInfo info;
-
-        if (!stream->read(&info, sizeof(info))) {
-            return;
-        }
-        if (PICTURE_VERSION != info.fVersion) {
-            return;
-        }
-
-        if (stream->readBool()) {
-            fPlayback = SkNEW_ARGS(SkOffsetPicturePlayback, (stream, info, proc));
-        }
-
-        // do this at the end, so that they will be zero if we hit an error.
-        fWidth = info.fWidth;
-        fHeight = info.fHeight;
-        if (success) {
-            *success = true;
-        }
-    }
-
-    const SkTDArray<size_t>& offsets() const {
-        return ((SkOffsetPicturePlayback*) fPlayback)->offsets();
-    }
-
-private:
-    // disallow default ctor b.c. we don't have a good way to setup the fPlayback ptr
-    SkOffsetPicture();
-    // disallow the copy ctor - enabling would require copying code from SkPicture
-    SkOffsetPicture(const SkOffsetPicture& src);
-
-    typedef SkPicture INHERITED;
-};
-
-
-
 void SkDebuggerGUI::loadPicture(const SkString& fileName) {
     fFileName = fileName;
     fLoading = true;
     SkStream* stream = SkNEW_ARGS(SkFILEStream, (fileName.c_str()));
 
     bool success = false;
 
-    SkOffsetPicture* picture = SkNEW_ARGS(SkOffsetPicture,
-                                          (stream, &success, &SkImageDecoder::DecodeMemory));
+    SkPicture* picture = SkNEW_ARGS(SkPicture,
+                                    (stream, &success, &SkImageDecoder::DecodeMemory));
 
     if (!success) {
         QMessageBox::critical(this, "Error loading file", "Couldn't read file, sorry.");
         SkSafeUnref(stream);
         return;
     }
 
     fCanvasWidget.resetWidgetTransform();
     fDebugger.loadPicture(picture);
 
-    fOffsets = picture->offsets();
-
-    fSkipCommands.setCount(fOffsets.count());
-    for (int i = 0; i < fOffsets.count(); ++i) {
+    fSkipCommands.setCount(fDebugger.getSize());
+    for (int i = 0; i < fSkipCommands.count(); ++i) {
         fSkipCommands[i] = false;
     }
 
     SkSafeUnref(stream);
     SkSafeUnref(picture);
 
     // Will this automatically clear out due to nature of refcnt?
     SkTArray<SkString>* commands = fDebugger.getDrawCommandsAsStrings();
 
-    // If SkPicturePlayback is compiled w/o SK_PICTURE_PROFILING_STUBS
-    // the offset count will always be zero
-    SkASSERT(0 == fOffsets.count() || commands->count() == fOffsets.count());
-    if (commands->count() == fOffsets.count()) {
-        fActionProfile.setDisabled(false);
-    }
+    fActionProfile.setDisabled(false);
 
     /* fDebugCanvas is reinitialized every load picture. Need it to retain value
      * of the visibility filter.
      * TODO(chudy): This should be deprecated since fDebugger is not
      * recreated.
      * */
     fDebugger.highlightCurrentCommand(fSettingsWidget.getVisibilityButton()->isChecked());
 
     setupListWidget(commands);
     setupComboBox(commands);
@@ skipping 58 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);
 }