Strip old backend recording down to essentials

src/core/SkPicturePlayback.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkPatchUtils.h"
 #include "SkPictureData.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
-#include "SkPictureStateTree.h"
 #include "SkReader32.h"
 #include "SkTextBlob.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
 /*
  * Read the next op code and chunk size from 'reader'. The returned size
  * is the entire size of the chunk (including the opcode). Thus, the
  * offset just prior to calling ReadOpAndSize + 'size' is the offset
  * to the next chunk's op code. This also means that the size of a chunk
@@ skipping 35 matching lines @@
 void get_text(SkReader32* reader, TextContainer* text) {
     size_t length = text->fByteLength = reader->readInt();
     text->fText = (const char*)reader->skip(length);
 }
 
 // FIXME: SkBitmaps are stateful, so we need to copy them to play back in multiple threads.
 static SkBitmap shallow_copy(const SkBitmap& bitmap) {
     return bitmap;
 }
 
-const SkPicture::OperationList* SkPicturePlayback::getActiveOps(const SkCanvas* canvas) {
-
-    if (fUseBBH) {
-        SkRect clipBounds;
-        if (canvas->getClipBounds(&clipBounds)) {
-            return fPictureData->getActiveOps(clipBounds);
-        }
-    }
-
-    return NULL;
-}
-
-// Initialize the state tree iterator. Return false if there is nothing left to draw.
-bool SkPicturePlayback::initIterator(SkPictureStateTree::Iterator* iter,
-                                     SkCanvas* canvas,
-                                     const SkPicture::OperationList *activeOpsList) {
-
-    if (activeOpsList) {
-        if (0 == activeOpsList->numOps()) {
-            return false;  // nothing to draw
-        }
-
-        fPictureData->initIterator(iter, activeOpsList->fOps, canvas);
-    }
-
-    return true;
-}
-
-// If 'iter' is valid use it to skip forward through the picture.
-void SkPicturePlayback::StepIterator(SkPictureStateTree::Iterator* iter, SkReader32* reader) {
-    if (iter->isValid()) {
-        uint32_t skipTo = iter->nextDraw();
-        if (SkPictureStateTree::Iterator::kDrawComplete == skipTo) {
-            reader->setOffset(reader->size());  // skip to end
-        } else {
-            reader->setOffset(skipTo);
-        }
-    }
-}
-
-// Update the iterator and state tree to catch up with the skipped ops.
-void SkPicturePlayback::SkipIterTo(SkPictureStateTree::Iterator* iter,
-                                   SkReader32* reader,
-                                   uint32_t skipTo) {
-    SkASSERT(skipTo <= reader->size());
-    SkASSERT(reader->offset() <= skipTo); // should only be skipping forward
-
-    if (iter->isValid()) {
-        // If using a bounding box hierarchy, advance the state tree
-        // iterator until at or after skipTo
-        uint32_t adjustedSkipTo;
-        do {
-            adjustedSkipTo = iter->nextDraw();
-        } while (adjustedSkipTo < skipTo);
-        skipTo = adjustedSkipTo;
-    }
-    if (SkPictureStateTree::Iterator::kDrawComplete == skipTo) {
-        reader->setOffset(reader->size());  // skip to end
-    } else {
-        reader->setOffset(skipTo);
-    }
-}
-
 void SkPicturePlayback::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) {
     AutoResetOpID aroi(this);
     SkASSERT(0 == fCurOffset);
 
-    SkAutoTDelete<const SkPicture::OperationList> activeOpsList(this->getActiveOps(canvas));
-    SkPictureStateTree::Iterator it;
-
-    if (!this->initIterator(&it, canvas, activeOpsList.get())) {
-        return;  // nothing to draw
-    }
-
     SkReader32 reader(fPictureData->opData()->bytes(), fPictureData->opData()->size());
 
-    StepIterator(&it, &reader);
-
     // Record this, so we can concat w/ it if we encounter a setMatrix()
     SkMatrix initialMatrix = canvas->getTotalMatrix();
 
     SkAutoCanvasRestore acr(canvas, false);
 
     while (!reader.eof()) {
         if (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
-            SkipIterTo(&it, &reader, fCurOffset + size);
-            continue;
-        }
 
         this->handleOp(&reader, op, size, canvas, initialMatrix);
-
-        StepIterator(&it, &reader);
     }
 }
 
 void SkPicturePlayback::handleOp(SkReader32* reader,
                                  DrawType op,
                                  uint32_t size,
                                  SkCanvas* canvas,
                                  const SkMatrix& initialMatrix) {
     switch (op) {
+        case NOOP: {
+            SkASSERT(size >= 4);
+            reader->skip(size - 4);
+        } break;
         case CLIP_PATH: {
             const SkPath& path = fPictureData->getPath(reader);
             uint32_t packed = reader->readInt();
             SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
             bool doAA = ClipParams_unpackDoAA(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
             canvas->clipPath(path, regionOp, doAA);
             if (canvas->isClipEmpty() && offsetToRestore) {
                 reader->setOffset(offsetToRestore);
@@ skipping 323 matching lines @@
             SkScalar sx = reader->readScalar();
             SkScalar sy = reader->readScalar();
             canvas->skew(sx, sy);
         } break;
         case TRANSLATE: {
             SkScalar dx = reader->readScalar();
             SkScalar dy = reader->readScalar();
             canvas->translate(dx, dy);
         } break;
         default:
-            SkASSERT(0);
+            SkASSERTF(false, "Unknown draw type: %d", op);
     }
 }