change pixelref to not inherit from SkFlattenable

include/core/SkPixelRef.h

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
@@ skipping 13 matching lines @@
      *  reasons, simple malloc-based subclasses call setPreLocked() to skip
      *  the overhead of implementing these calls.
      *
      *  This build-flag disables that optimization, to add in debugging our
      *  call-sites, to ensure that they correctly balance their calls of
      *  lock and unlock.
      */
 //    #define SK_IGNORE_PIXELREF_SETPRELOCKED
 #endif
 
+#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
+    // we only support unflattening, not flattening
+    #define SK_PIXELREF_BASECLASS   SkFlattenable
+#else
+    #define SK_PIXELREF_BASECLASS   SkRefCnt
+#endif
+
 class SkColorTable;
 class SkData;
 struct SkIRect;
 class SkMutex;
 
 class GrTexture;
 
 /** \class SkPixelRef
 
     This class is the smart container for pixel memory, and is used with
     SkBitmap. A pixelref is installed into a bitmap, and then the bitmap can
     access the actual pixel memory by calling lockPixels/unlockPixels.
 
     This class can be shared/accessed between multiple threads.
 */
-class SK_API SkPixelRef : public SkFlattenable {
+class SK_API SkPixelRef : public SK_PIXELREF_BASECLASS {
 public:
     SK_DECLARE_INST_COUNT(SkPixelRef)
 
     explicit SkPixelRef(const SkImageInfo&);
     SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex);
     virtual ~SkPixelRef();
 
     const SkImageInfo& info() const {
         return fInfo;
     }
@@ skipping 183 matching lines @@
     virtual void globalRef(void* data=NULL);
 
     /**
      *  Release a "global" ref on this object.
      *  The default implementation just calls unref(), but subclasses can override
      *  this method to implement additional behavior.
      */
     virtual void globalUnref();
 #endif
 
+#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
     SK_DEFINE_FLATTENABLE_TYPE(SkPixelRef)
+#endif
 
     // Register a listener that may be called the next time our generation ID changes.
     //
     // We'll only call the listener if we're confident that we are the only SkPixelRef with this
     // generation ID.  If our generation ID changes and we decide not to call the listener, we'll
     // never call it: you must add a new listener for each generation ID change.  We also won't call
     // the listener when we're certain no one knows what our generation ID is.
     //
     // This can be used to invalidate caches keyed by SkPixelRef generation ID.
     struct GenIDChangeListener {
@@ skipping 53 matching lines @@
      */
     virtual size_t getAllocatedSizeInBytes() const;
 
     /** Return the mutex associated with this pixelref. This value is assigned
         in the constructor, and cannot change during the lifetime of the object.
     */
     SkBaseMutex* mutex() const { return fMutex; }
 
     // serialization
     SkPixelRef(SkReadBuffer&, SkBaseMutex*);
-    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // only call from constructor. Flags this to always be locked, removing
     // the need to grab the mutex and call onLockPixels/onUnlockPixels.
     // Performance tweak to avoid those calls (esp. in multi-thread use case).
     void setPreLocked(void*, size_t rowBytes, SkColorTable*);
 
 private:
     SkBaseMutex*    fMutex; // must remain in scope for the life of this object
 
     // mostly const. fInfo.fAlpahType can be changed at runtime.
@@ skipping 18 matching lines @@
     void needsNewGenID();
     void callGenIDChangeListeners();
 
     void setMutex(SkBaseMutex* mutex);
 
     // When copying a bitmap to another with the same shape and config, we can safely
     // clone the pixelref generation ID too, which makes them equivalent under caching.
     friend class SkBitmap;  // only for cloneGenID
     void cloneGenID(const SkPixelRef&);
 
-    typedef SkFlattenable INHERITED;
+#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE { sk_throw(); }
+#endif
+
+    typedef SK_PIXELREF_BASECLASS INHERITED;
 };
 
 class SkPixelRefFactory : public SkRefCnt {
 public:
     /**
      *  Allocate a new pixelref matching the specified ImageInfo, allocating
      *  the memory for the pixels. If the ImageInfo requires a ColorTable,
      *  the pixelref will ref() the colortable.
      *  On failure return NULL.
      */
     virtual SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) = 0;
 };
 
 #endif