Split SkPicturePlayback out of SkPictureData

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"
 #include "SkImageDecoder.h"
 #include <QListWidgetItem>
 #include "PictureRenderer.h"
+#include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkPictureData.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 #if defined(SK_BUILD_FOR_WIN32)
     #include "SysTimer_windows.h"
 #elif defined(SK_BUILD_FOR_MAC)
     #include "SysTimer_mach.h"
 #elif defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_ANDROID)
@@ skipping 127 matching lines @@
     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.
-class SkTimedPicturePlayback : public SkPictureData {
+class SkTimedPicturePlayback : public SkPicturePlayback {
 public:
-    static SkTimedPicturePlayback* CreateFromStream(SkStream* stream, const SkPictInfo& info,
-                                                    SkPicture::InstallPixelRefProc proc,
-                                                    const SkTDArray<bool>& deletedCommands) {
-        // Mimics SkPictureData::CreateFromStream
-        SkAutoTDelete<SkTimedPicturePlayback> playback(SkNEW_ARGS(SkTimedPicturePlayback,
-                                                               (deletedCommands, info)));
-        if (!playback->parseStream(stream, proc)) {
-            return NULL; // we're invalid
-        }
-        return playback.detach();
-    }
 
-    SkTimedPicturePlayback(const SkTDArray<bool>& deletedCommands,
-                           const SkPictInfo& info)
-        : INHERITED(info)
+    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();
     }
 
     void resetTimes() {
         for (int i = 0; i < fTimes.count(); ++i) {
@@ skipping 61 matching lines @@
         SkASSERT(opIndex == fCurCommand);
         SkASSERT(fCurType <= LAST_DRAWTYPE_ENUM);
 
         fTimes[fCurCommand] += time;
         fTypeTimes[fCurType] += time;
         fTot += time;
     }
 #endif
 
 private:
-    typedef SkPictureData INHERITED;
+    typedef SkPicturePlayback INHERITED;
 };
 
+#if 0
 // Wrap SkPicture to allow installation of an SkTimedPicturePlayback object
 class SkTimedPicture : public SkPicture {
 public:
     static SkTimedPicture* CreateTimedPicture(SkStream* stream,
                                               SkPicture::InstallPixelRefProc proc,
                                               const SkTDArray<bool>& deletedCommands) {
         SkPictInfo info;
         if (!InternalOnly_StreamIsSKP(stream, &info)) {
             return NULL;
         }
@@ skipping 29 matching lines @@
     // disallow default ctor b.c. we don't have a good way to setup the fData ptr
     SkTimedPicture();
     // Private ctor only used by CreateTimedPicture, which has created the playback.
     SkTimedPicture(SkTimedPicturePlayback* playback, int width, int height)
         : INHERITED(playback, width, height) {}
     // disallow the copy ctor - enabling would require copying code from SkPicture
     SkTimedPicture(const SkTimedPicture& src);
 
     typedef SkPicture INHERITED;
 };
+#endif
 
 // This is a simplification of PictureBenchmark's run with the addition of
 // clearing of the times after the first pass (in resetTimes)
-void SkDebuggerGUI::run(SkTimedPicture* pict,
+void SkDebuggerGUI::run(const SkPicture* pict,
                         sk_tools::PictureRenderer* renderer,
                         int repeats) {
     SkASSERT(pict);
     if (NULL == pict) {
         return;
     }
 
     SkASSERT(renderer != NULL);
     if (NULL == renderer) {
         return;
     }
 
     renderer->init(pict, NULL, NULL, NULL, false);
 
     renderer->setup();
     renderer->render();
     renderer->resetState(true);    // flush, swapBuffers and Finish
 
+#if 0
     // We throw this away the first batch of times to remove first time effects (such as paging in this program)
     pict->resetTimes();
+#endif
 
     for (int i = 0; i < repeats; ++i) {
         renderer->setup();
         renderer->render();
         renderer->resetState(false);  // flush & swapBuffers, but don't Finish
     }
     renderer->resetState(true);    // flush, swapBuffers and Finish
 
     renderer->end();
 }
 
 void SkDebuggerGUI::actionProfile() {
     // In order to profile we pass the command offsets (that were read-in
     // in loadPicture by the SkOffsetPicture) to an SkTimedPlaybackPicture.
     // The SkTimedPlaybackPicture in turn passes the offsets to an
     // SkTimedPicturePlayback object which uses them to track the performance
     // of individual commands.
     if (fFileName.isEmpty()) {
         return;
     }
 
     SkFILEStream inputStream;
 
     inputStream.setPath(fFileName.c_str());
     if (!inputStream.isValid()) {
         return;
     }
 
-    SkAutoTUnref<SkTimedPicture> picture(SkTimedPicture::CreateTimedPicture(&inputStream,
-                                         &SkImageDecoder::DecodeMemory, fSkipCommands));
+    SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&inputStream,
+                                        &SkImageDecoder::DecodeMemory)); // , fSkipCommands));
     if (NULL == picture.get()) {
         return;
     }
 
+
+#if 0
+
     // 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:
     //
     //                       tile mode           simple mode
     // debugger                64.2ms              12.8ms
     // bench_pictures          16.9ms              12.4ms
     //
@@ skipping 28 matching lines @@
     for (int i = 0; i < picture->count(); ++i) {
         double temp = picture->time(i);
 
         QListWidgetItem* item = fListWidget.item(i);
 
         item->setData(Qt::UserRole + 4, 100.0*temp);
     }
 
     setupOverviewText(picture->typeTimes(), picture->totTime(), kNumRepeats);
     setupClipStackText();
+
+#endif
 }
 
 void SkDebuggerGUI::actionCancel() {
     for (int row = 0; row < fListWidget.count(); row++) {
         fListWidget.item(row)->setHidden(false);
     }
 }
 
 void SkDebuggerGUI::actionClearBreakpoints() {
     for (int row = 0; row < fListWidget.count(); row++) {
@@ skipping 642 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);
 }