rename SkCanvasDrawable to SkDrawable, and make public

src/core/SkPictureRecorder.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 "SkCanvasDrawable.h"
 #include "SkData.h"
+#include "SkDrawable.h"
 #include "SkLayerInfo.h"
 #include "SkPictureRecorder.h"
 #include "SkRecord.h"
 #include "SkRecordDraw.h"
 #include "SkRecorder.h"
 #include "SkRecordOpts.h"
 #include "SkTypes.h"
 
 SkPictureRecorder::SkPictureRecorder() {}
 
@@ skipping 24 matching lines @@
     SkRecordOptimize(fRecord);
 
     SkAutoTUnref<SkLayerInfo> saveLayerData;
 
     if (fBBH && (fFlags & kComputeSaveLayerInfo_RecordFlag)) {
         SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
 
         saveLayerData.reset(SkNEW_ARGS(SkLayerInfo, (key)));
     }
 
-    SkCanvasDrawableList* drawableList = fRecorder->getDrawableList();
+    SkDrawableList* drawableList = fRecorder->getDrawableList();
     SkPicture::SnapshotArray* pictList = drawableList ? drawableList->newDrawableSnapshot() : NULL;
 
     if (fBBH.get()) {
         if (saveLayerData) {
             SkRecordComputeLayers(fCullRect, *fRecord, pictList, fBBH.get(), saveLayerData);
         } else {
             SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
         }
     }
 
@@ skipping 10 matching lines @@
 
     return pict;
 }
 
 void SkPictureRecorder::partialReplay(SkCanvas* canvas) const {
     if (NULL == canvas) {
         return;
     }
 
     int drawableCount = 0;
-    SkCanvasDrawable* const* drawables = NULL;
-    SkCanvasDrawableList* drawableList = fRecorder->getDrawableList();
+    SkDrawable* const* drawables = NULL;
+    SkDrawableList* drawableList = fRecorder->getDrawableList();
     if (drawableList) {
         drawableCount = drawableList->count();
         drawables = drawableList->begin();
     }
     SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, NULL/*bbh*/, NULL/*callback*/);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-class SkRecordedDrawable : public SkCanvasDrawable {
-    SkAutoTUnref<SkRecord>              fRecord;
-    SkAutoTUnref<SkBBoxHierarchy>       fBBH;
-    SkAutoTDelete<SkCanvasDrawableList> fDrawableList;
-    const SkRect                        fBounds;
-    const bool                          fDoSaveLayerInfo;
+class SkRecordedDrawable : public SkDrawable {
+    SkAutoTUnref<SkRecord>          fRecord;
+    SkAutoTUnref<SkBBoxHierarchy>   fBBH;
+    SkAutoTDelete<SkDrawableList>   fDrawableList;
+    const SkRect                    fBounds;
+    const bool                      fDoSaveLayerInfo;
 
 public:
-    SkRecordedDrawable(SkRecord* record, SkBBoxHierarchy* bbh, SkCanvasDrawableList* drawableList,
+    SkRecordedDrawable(SkRecord* record, SkBBoxHierarchy* bbh, SkDrawableList* drawableList,
                        const SkRect& bounds, bool doSaveLayerInfo)
         : fRecord(SkRef(record))
         , fBBH(SkSafeRef(bbh))
         , fDrawableList(drawableList)   // we take ownership
         , fBounds(bounds)
         , fDoSaveLayerInfo(doSaveLayerInfo)
     {}
 
 protected:
     SkRect onGetBounds() SK_OVERRIDE { return fBounds; }
 
     void onDraw(SkCanvas* canvas) SK_OVERRIDE {
-        SkCanvasDrawable* const* drawables = NULL;
+        SkDrawable* const* drawables = NULL;
         int drawableCount = 0;
         if (fDrawableList) {
             drawables = fDrawableList->begin();
             drawableCount = fDrawableList->count();
         }
         SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, fBBH, NULL/*callback*/);
     }
 
     SkPicture* onNewPictureSnapshot() SK_OVERRIDE {
         SkPicture::SnapshotArray* pictList = NULL;
@@ skipping 18 matching lines @@
 
         SkPicture* pict = SkNEW_ARGS(SkPicture, (fBounds, fRecord, pictList, fBBH));
 
         if (saveLayerData) {
             pict->EXPERIMENTAL_addAccelData(saveLayerData);
         }
         return pict;
     }
 };
 
-SkCanvasDrawable* SkPictureRecorder::EXPERIMENTAL_endRecordingAsDrawable() {
+SkDrawable* SkPictureRecorder::endRecordingAsDrawable() {
     // TODO: delay as much of this work until just before first playback?
     SkRecordOptimize(fRecord);
 
     if (fBBH.get()) {
         SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
     }
 
-    SkCanvasDrawable* drawable = SkNEW_ARGS(SkRecordedDrawable,
-                                            (fRecord, fBBH, fRecorder->detachDrawableList(),
-                                             fCullRect,
-                                             SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag)));
+    SkDrawable* drawable = SkNEW_ARGS(SkRecordedDrawable,
+                                        (fRecord, fBBH, fRecorder->detachDrawableList(),
+                                         fCullRect,
+                                         SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag)));
 
     // release our refs now, so only the drawable will be the owner.
     fRecorder.reset(NULL);
     fRecord.reset(NULL);
     fBBH.reset(NULL);
 
     return drawable;
 }