Reverting r12665 & r12666 (Remove duplicate impl for SkImageInfo flattening) due to Chromium/Blink …

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
 
 #include "SkBitmap.h"
 #include "SkRefCnt.h"
 #include "SkString.h"
 #include "SkFlattenable.h"
-#include "SkImageInfo.h"
 #include "SkTDArray.h"
 
-//#define SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR
-
-#define SK_SUPPORT_LEGACY_ONLOCKPIXELS
+#define SK_SUPPORT_LEGACY_PIXELREF_CONSTRUCTOR
 
 #ifdef SK_DEBUG
     /**
      *  Defining SK_IGNORE_PIXELREF_SETPRELOCKED will force all pixelref
      *  subclasses to correctly handle lock/unlock pixels. For performance
      *  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
@@ skipping 30 matching lines @@
     SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex);
     virtual ~SkPixelRef();
 
     const SkImageInfo& info() const {
         return fInfo;
     }
 
     /** Return the pixel memory returned from lockPixels, or null if the
         lockCount is 0.
     */
-    void* pixels() const { return fRec.fPixels; }
+    void* pixels() const { return fPixels; }
 
     /** Return the current colorTable (if any) if pixels are locked, or null.
     */
-    SkColorTable* colorTable() const { return fRec.fColorTable; }
+    SkColorTable* colorTable() const { return fColorTable; }
 
     /**
-     *  To access the actual pixels of a pixelref, it must be "locked".
-     *  Calling lockPixels returns a LockRec struct (on success).
-     */
-    struct LockRec {
-        void*           fPixels;
-        SkColorTable*   fColorTable;
-        size_t          fRowBytes;
-        
-        void zero() { sk_bzero(this, sizeof(*this)); }
-
-        bool isZero() const {
-            return NULL == fPixels && NULL == fColorTable && 0 == fRowBytes;
-        }
-    };
-    
-    /**
      *  Returns true if the lockcount > 0
      */
     bool isLocked() const { return fLockCount > 0; }
 
     SkDEBUGCODE(int getLockCount() const { return fLockCount; })
 
-    /**
-     *  Call to access the pixel memory. Return true on success. Balance this
-     *  with a call to unlockPixels().
-     */
-    bool lockPixels();
-
-    /**
-     *  Call to access the pixel memory. On success, return true and fill out
-     *  the specified rec. On failure, return false and ignore the rec parameter.
-     *  Balance this with a call to unlockPixels().
-     */
-    bool lockPixels(LockRec* rec);
-
+    /** Call to access the pixel memory, which is returned. Balance with a call
+        to unlockPixels().
+    */
+    void lockPixels();
     /** Call to balanace a previous call to lockPixels(). Returns the pixels
         (or null) after the unlock. NOTE: lock calls can be nested, but the
         matching number of unlock calls must be made in order to free the
         memory (if the subclass implements caching/deferred-decoding.)
     */
     void unlockPixels();
 
     /**
      *  Some bitmaps can return a copy of their pixels for lockPixels(), but
      *  that copy, if modified, will not be pushed back. These bitmaps should
@@ skipping 136 matching lines @@
     // This can be used to invalidate caches keyed by SkPixelRef generation ID.
     struct GenIDChangeListener {
         virtual ~GenIDChangeListener() {}
         virtual void onChange() = 0;
     };
 
     // Takes ownership of listener.
     void addGenIDChangeListener(GenIDChangeListener* listener);
 
 protected:
-#ifdef SK_SUPPORT_LEGACY_ONLOCKPIXELS
-    virtual void* onLockPixels(SkColorTable**);
-    virtual bool onNewLockPixels(LockRec*);
-#else
+    /** Called when the lockCount goes from 0 to 1. The caller will have already
+        acquire a mutex for thread safety, so this method need not do that.
+    */
+    virtual void* onLockPixels(SkColorTable**) = 0;
+ 
     /**
-     *  On success, returns true and fills out the LockRec for the pixels. On
-     *  failure returns false and ignores the LockRec parameter.
+     *  Called when the lock count goes from 1 to 0. The caller will have
+     *  already acquire a mutex for thread safety, so this method need not do
+     *  that.
      *
-     *  The caller will have already acquired a mutex for thread safety, so this
-     *  method need not do that.
-     */
-    virtual bool onNewLockPixels(LockRec*) = 0;
-#endif
-
-    /**
-     *  Balancing the previous successful call to onNewLockPixels. The locked
-     *  pixel address will no longer be referenced, so the subclass is free to
-     *  move or discard that memory.
-     *
-     *  The caller will have already acquired a mutex for thread safety, so this
-     *  method need not do that.
+     *  If the previous call to onLockPixels failed (i.e. returned NULL), then
+     *  the onUnlockPixels will NOT be called.
      */
     virtual void onUnlockPixels() = 0;
 
     /** Default impl returns true */
     virtual bool onLockPixelsAreWritable() const;
 
     // returns false;
     virtual bool onImplementsDecodeInto();
     // returns false;
     virtual bool onDecodeInto(int pow2, SkBitmap* bitmap);
@@ skipping 24 matching lines @@
     */
     SkBaseMutex* mutex() const { return fMutex; }
 
     // serialization
     SkPixelRef(SkFlattenableReadBuffer&, SkBaseMutex*);
     virtual void flatten(SkFlattenableWriteBuffer&) 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*);
+    void setPreLocked(void* pixels, SkColorTable* ctable);
 
 private:
     SkBaseMutex*    fMutex; // must remain in scope for the life of this object
     // FIXME: fInfo should be const once we remove old constructor that does
     // not set it.
     SkImageInfo     fInfo;
-    
-    // LockRec is only valid if we're in a locked state (isLocked())
-    LockRec         fRec;
+
+    void*           fPixels;
+    SkColorTable*   fColorTable;    // we do not track ownership, subclass does
     int             fLockCount;
 
     mutable uint32_t fGenerationID;
     mutable bool     fUniqueGenerationID;
 
     SkTDArray<GenIDChangeListener*> fGenIDChangeListeners;  // pointers are owned
 
     SkString    fURI;
 
     // can go from false to true, but never from true to false
     bool    fIsImmutable;
     // only ever set in constructor, const after that
     bool    fPreLocked;
 
     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;
 };
 
 #endif