change pixelref to not inherit from SkFlattenable

src/core/SkPixelRef.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 "SkPixelRef.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ skipping 90 matching lines @@
                                                 const_cast<SkAlphaType*>(&fInfo.fAlphaType)));
 
     this->setMutex(mutex);
     fRec.zero();
     fLockCount = 0;
     this->needsNewGenID();
     fIsImmutable = false;
     fPreLocked = false;
 }
 
+#ifdef SK_SUPPORT_LEGACY_PIXELREF_UNFLATTENABLE
 static SkImageInfo read_info(SkReadBuffer& buffer) {
     SkImageInfo info;
     info.unflatten(buffer);
     return info;
 }
 
 SkPixelRef::SkPixelRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
         : INHERITED(buffer)
         , fInfo(read_info(buffer))
 {
     SkDEBUGCODE(SkAlphaType alphaType;)
     SkASSERT(SkColorTypeValidateAlphaType(fInfo.colorType(), fInfo.alphaType(), &alphaType));
     SkASSERT(fInfo.fAlphaType == alphaType);
 
     this->setMutex(mutex);
     fRec.zero();
     fLockCount = 0;
     fIsImmutable = buffer.readBool();
     fGenerationID = buffer.readUInt();
     fUniqueGenerationID = false;  // Conservatively assuming the original still exists.
     fPreLocked = false;
 }
+#endif
 
 SkPixelRef::~SkPixelRef() {
     this->callGenIDChangeListeners();
 }
 
 void SkPixelRef::needsNewGenID() {
     fGenerationID = 0;
     fUniqueGenerationID = false;
 }
 
 void SkPixelRef::cloneGenID(const SkPixelRef& that) {
     // This is subtle.  We must call that.getGenerationID() to make sure its genID isn't 0.
     this->fGenerationID = that.getGenerationID();
     this->fUniqueGenerationID = false;
     that.fUniqueGenerationID = false;
 }
 
 void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
     // only call me in your constructor, otherwise fLockCount tracking can get
     // out of sync.
     fRec.fPixels = pixels;
     fRec.fColorTable = ctable;
     fRec.fRowBytes = rowBytes;
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
     fPreLocked = true;
 #endif
 }
 
-void SkPixelRef::flatten(SkWriteBuffer& buffer) const {
-    this->INHERITED::flatten(buffer);
-    fInfo.flatten(buffer);
-    buffer.writeBool(fIsImmutable);
-    // We write the gen ID into the picture for within-process recording. This
-    // is safe since the same genID will never refer to two different sets of
-    // pixels (barring overflow). However, each process has its own "namespace"
-    // of genIDs. So for cross-process recording we write a zero which will
-    // trigger assignment of a new genID in playback.
-    if (buffer.isCrossProcess()) {
-        buffer.writeUInt(0);
-    } else {
-        buffer.writeUInt(fGenerationID);
-        fUniqueGenerationID = false;  // Conservative, a copy is probably about to exist.
-    }
-}
-
 bool SkPixelRef::lockPixels(LockRec* rec) {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
         SkAutoMutexAcquire  ac(*fMutex);
 
         if (1 == ++fLockCount) {
             SkASSERT(fRec.isZero());
 
             LockRec rec;
@@ skipping 114 matching lines @@
 
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPixelRef::globalRef(void* data) {
     this->ref();
 }
 
 void SkPixelRef::globalUnref() {
     this->unref();
 }
 #endif