Replace SkPicture(SkStream) constructors with a factory.

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 219 matching lines @@
     }
 #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<bool>& deletedCommands) {
-        if (success) {
-            *success = false;
-        }
-        fRecord = NULL;
-        fPlayback = NULL;
-        fWidth = fHeight = 0;
-
+    static SkTimedPicture* CreateTimedPicture(SkStream* stream,
+                                              SkPicture::InstallPixelRefProc proc,
+                                              const SkTDArray<bool>& deletedCommands) {
         SkPictInfo info;
-
-        if (!stream->read(&info, sizeof(info))) {
-            return;
-        }
-        if (SkPicture::PICTURE_VERSION != info.fVersion) {
-            return;
+        if (!StreamIsSKP(stream, &info)) {
+            return NULL;
         }
 
-        if (stream->readBool()) {
-            fPlayback = SkNEW_ARGS(SkTimedPicturePlayback,
-                                   (stream, info, proc, deletedCommands));
-        }
+        SkTimedPicturePlayback* playback = SkNEW_ARGS(SkTimedPicturePlayback,
+                                                      (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;
-        }
+        return SkNEW_ARGS(SkTimedPicture, (playback, info.fWidth, info.fHeight));
     }
 
     void resetTimes() { ((SkTimedPicturePlayback*) fPlayback)->resetTimes(); }
 
     int count() const { return ((SkTimedPicturePlayback*) fPlayback)->count(); }
 
     // return the fraction of the total time this command consumed
     double time(int index) const { return ((SkTimedPicturePlayback*) fPlayback)->time(index); }
 
     const SkTDArray<double>* typeTimes() const { return ((SkTimedPicturePlayback*) fPlayback)->typeTimes(); }
 
     double totTime() const { return ((SkTimedPicturePlayback*) fPlayback)->totTime(); }
 
 private:
     // disallow default ctor b.c. we don't have a good way to setup the fPlayback 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;
 };
 
 // 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,
                         sk_tools::PictureRenderer* renderer,
@@ skipping 36 matching lines @@
         return;
     }
 
     SkFILEStream inputStream;
 
     inputStream.setPath(fFileName.c_str());
     if (!inputStream.isValid()) {
         return;
     }
 
-    bool success = false;
-    SkTimedPicture picture(&inputStream, &success, &SkImageDecoder::DecodeMemory,
-                           fSkipCommands);
-    if (!success) {
+    SkAutoTUnref<SkTimedPicture> picture(SkTimedPicture::CreateTimedPicture(&inputStream,
+                                         &SkImageDecoder::DecodeMemory, fSkipCommands));
+    if (NULL == picture.get()) {
         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:
     //
     //                       tile mode           simple mode
@@ skipping 15 matching lines @@
 #if SK_SUPPORT_GPU
     if (Qt::Checked == fSettingsWidget.getGLCheckBox()->checkState()) {
         renderer->setDeviceType(sk_tools::PictureRenderer::kGPU_DeviceType);
     }
 #endif
 
 #endif
 
     static const int kNumRepeats = 10;
 
-    run(&picture, renderer, kNumRepeats);
+    run(picture.get(), renderer, kNumRepeats);
 
-    SkASSERT(picture.count() == fListWidget.count());
+    SkASSERT(picture->count() == fListWidget.count());
 
     // extract the individual command times from the SkTimedPlaybackPicture
-    for (int i = 0; i < picture.count(); ++i) {
-        double temp = picture.time(i);
+    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);
+    setupOverviewText(picture->typeTimes(), picture->totTime(), kNumRepeats);
 }
 
 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 494 matching lines @@
         if (f.contains(r))
             fDirectoryWidget.addItem(f);
     }
 }
 
 void SkDebuggerGUI::loadPicture(const SkString& fileName) {
     fFileName = fileName;
     fLoading = true;
     SkStream* stream = SkNEW_ARGS(SkFILEStream, (fileName.c_str()));
 
-    bool success = false;
+    SkPicture* picture = SkPicture::CreateFromStream(stream);
 
-    SkPicture* picture = SkNEW_ARGS(SkPicture,
-                                    (stream, &success, &SkImageDecoder::DecodeMemory));
-
-    if (!success) {
+    if (NULL == picture) {
         QMessageBox::critical(this, "Error loading file", "Couldn't read file, sorry.");
         SkSafeUnref(stream);
         return;
     }
 
     fCanvasWidget.resetWidgetTransform();
     fDebugger.loadPicture(picture);
 
     fSkipCommands.setCount(fDebugger.getSize());
     for (int i = 0; i < fSkipCommands.count(); ++i) {
@@ skipping 80 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);
 }