add SkCanvas::drawDRRect

src/core/SkPictureRecord.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 "SkPictureRecord.h"
 #include "SkTSearch.h"
 #include "SkPixelRef.h"
@@ skipping 93 matching lines @@
         0,  // SAVE - no paint
         0,  // SAVE_LAYER - see below - this paint's location varies
         0,  // SCALE - no paint
         0,  // SET_MATRIX - no paint
         0,  // SKEW - no paint
         0,  // TRANSLATE - no paint
         0,  // NOOP - no paint
         0,  // BEGIN_GROUP - no paint
         0,  // COMMENT - no paint
         0,  // END_GROUP - no paint
+        1,  // DRAWDRRECT - right after op code
     };
 
-    SkASSERT(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1);
+    SK_COMPILE_ASSERT(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1,
+                      need_to_be_in_sync);
     SkASSERT((unsigned)op <= (unsigned)LAST_DRAWTYPE_ENUM);
 
     int overflow = 0;
     if (0 != (opSize & ~MASK_24) || opSize == MASK_24) {
         // This op's size overflows so an extra uint32_t will be written
         // after the op code
         overflow = sizeof(uint32_t);
     }
 
     if (SAVE_LAYER == op) {
@@ skipping 329 matching lines @@
 
     if (kSaveLayerWithBoundsSize == result[0].fSize) {
         // The saveLayer's bound can offset where the dbm is drawn
         return false;
     }
 
     return merge_savelayer_paint_into_drawbitmp(writer, paintDict,
                                                 result[0], result[3]);
 }
 
+static bool is_drawing_op(DrawType op) {
+    return (op > CONCAT && op < ROTATE) || DRAW_DRRECT == op;
+}
+
 /*
  *  Restore has just been called (but not recorded), so look back at the
  *  matching save(), and see if we can eliminate the pair of them, due to no
  *  intervening matrix/clip calls.
  *
  *  If so, update the writer and return true, in which case we won't even record
  *  the restore() call. If we still need the restore(), return false.
  */
 static bool collapse_save_clip_restore(SkWriter32* writer, int32_t offset,
                                        SkPaintDictionary* paintDict) {
@@ skipping 28 matching lines @@
         return false;
     }
 
     // Walk forward until we get back to either a draw-verb (abort) or we hit
     // our restore (success).
     int32_t saveOffset = offset;
 
     offset += opSize;
     while (offset < restoreOffset) {
         op = peek_op_and_size(writer, offset, &opSize);
-        if ((op > CONCAT && op < ROTATE) || (SAVE_LAYER == op)) {
+        if (is_drawing_op(op) || (SAVE_LAYER == op)) {
             // drawing verb, abort
             return false;
         }
         offset += opSize;
     }
 
 #ifdef TRACK_COLLAPSE_STATS
     gCollapseCount += 1;
     SkDebugf("Collapse [%d out of %d] %g%spn", gCollapseCount, gCollapseCalls,
              (double)gCollapseCount / gCollapseCalls, "%");
@@ skipping 536 matching lines @@
         uint32_t initialOffset, size;
         size = 2 * kUInt32Size + SkRRect::kSizeInMemory;
         initialOffset = this->addDraw(DRAW_RRECT, &size);
         SkASSERT(initialOffset+getPaintOffset(DRAW_RRECT, size) == fWriter.bytesWritten());
         this->addPaint(paint);
         this->addRRect(rrect);
         this->validate(initialOffset, size);
     }
 }
 
+void SkPictureRecord::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
+                                   const SkPaint& paint) {
+    
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+    fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
+#endif
+    
+    // op + paint index + rrects
+    uint32_t initialOffset, size;
+    size = 2 * kUInt32Size + SkRRect::kSizeInMemory * 2;
+    initialOffset = this->addDraw(DRAW_DRRECT, &size);
+    SkASSERT(initialOffset+getPaintOffset(DRAW_DRRECT, size) == fWriter.bytesWritten());
+    this->addPaint(paint);
+    this->addRRect(outer);
+    this->addRRect(inner);
+    this->validate(initialOffset, size);
+}
+
 void SkPictureRecord::drawPath(const SkPath& path, const SkPaint& paint) {
 
 #ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
     fMCMgr.call(SkMatrixClipStateMgr::kOther_CallType);
 #endif
 
     // op + paint index + path index
     uint32_t size = 3 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PATH, &size);
     SkASSERT(initialOffset+getPaintOffset(DRAW_PATH, size) == fWriter.bytesWritten());
@@ skipping 691 matching lines @@
 void SkPictureRecord::validateRegions() const {
     int count = fRegions.count();
     SkASSERT((unsigned) count < 0x1000);
     for (int index = 0; index < count; index++) {
         const SkFlatData* region = fRegions[index];
         SkASSERT(region);
 //        region->validate();
     }
 }
 #endif