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 opNum, int type) {

[scroggo, 2013/05/22 14:11:07]

I find opNum a little confusing. I was assuming that it meant a number
associated with that type of operation, as opposed to the index in the stream of
this instance of the operation.

Maybe that's just me though. opIndex is the only other name I can think of, and
it may be no clearer. I understood it once I saw opNum++ below.

[robertphillips, 2013/05/22 18:51:28]

I think opIndex is a bit clearer - done.

+    return false;
 }
 
-void SkPicturePlayback::postDraw(size_t offset) {
+void SkPicturePlayback::postDraw(int opNum) {
 }
 #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 opNum = -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 {
+            opNum++;
+            if (this->preDraw(opNum, 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(opNum);
 #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