Remove offsetcanvas from debugger

src/core/SkPicturePlayback.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkTypeface.h"
@@ skipping 607 matching lines @@
     }
 
     void recordSkip(size_t bytes) {
         fCount += 1;
         fSize += bytes;
     }
 };
 #endif
 
 #ifdef SK_DEVELOPER
-size_t SkPicturePlayback::preDraw(size_t offset, int type) {
-    return 0;
+bool SkPicturePlayback::preDraw(int opIndex, int type) {
+    return false;
 }
 
-void SkPicturePlayback::postDraw(size_t offset) {
+void SkPicturePlayback::postDraw(int opIndex) {
 }
 #endif
 
 /*
  * 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 read_op_and_size + 'size' is the offset
  * to the next chunk's op code. This also means that the size of a chunk
  * with no arguments (just an opcode) will be 4.
  */
@@ skipping 62 matching lines @@
     }
 
     // Record this, so we can concat w/ it if we encounter a setMatrix()
     SkMatrix initialMatrix = canvas.getTotalMatrix();
     int originalSaveCount = canvas.getSaveCount();
 
 #ifdef SK_BUILD_FOR_ANDROID
     fAbortCurrentPlayback = false;
 #endif
 
+#ifdef SK_DEVELOPER
+    int opIndex = -1;
+#endif
+
     while (!reader.eof()) {
         if (callback && callback->abortDrawing()) {
             canvas.restoreToCount(originalSaveCount);
             return;
         }
 #ifdef SK_BUILD_FOR_ANDROID
         if (fAbortCurrentPlayback) {
             return;
         }
 #endif
 
         size_t curOffset = reader.offset();
         uint32_t size;
         DrawType op = read_op_and_size(&reader, &size);
         size_t skipTo = 0;
-#ifdef SK_DEVELOPER
-        // TODO: once chunk sizes are in all .skps just use
-        // "curOffset + size"
-        skipTo = this->preDraw(curOffset, op);
-#endif
-        if (0 == skipTo && NOOP == op) {
+        if (NOOP == op) {
             // NOOPs are to be ignored - do not propagate them any further
             skipTo = curOffset + size;
+#ifdef SK_DEVELOPER
+        } else {
+            opIndex++;
+            if (this->preDraw(opIndex, op)) {
+                skipTo = curOffset + size;
+            }
+#endif
         }
 
         if (0 != skipTo) {
             if (it.isValid()) {
                 // If using a bounding box hierarchy, advance the state tree
                 // iterator until at or after skipTo
                 uint32_t adjustedSkipTo;
                 do {
                     adjustedSkipTo = it.draw();
                 } while (adjustedSkipTo < skipTo);
@@ skipping 268 matching lines @@
             case TRANSLATE: {
                 SkScalar dx = reader.readScalar();
                 SkScalar dy = reader.readScalar();
                 canvas.translate(dx, dy);
             } break;
             default:
                 SkASSERT(0);
         }
 
 #ifdef SK_DEVELOPER
-        this->postDraw(curOffset);
+        this->postDraw(opIndex);
 #endif
 
         if (it.isValid()) {
             uint32_t skipTo = it.draw();
             if (kDrawComplete == skipTo) {
                 break;
             }
             reader.setOffset(skipTo);
         }
     }
@@ skipping 555 matching lines @@
     for (index = 0; index < fRegionCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "region%p, ", &fRegions[index]);
     if (fRegionCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif