start to remove lockPixels from bitmapshader

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
@@ skipping 123 matching lines @@
      *  return a ref to its data. If the pixelRef
      *  is uncompressed or otherwise does not have this form, return NULL.
      *
      *  If non-null is returned, the caller is responsible for calling unref()
      *  on the data when it is finished.
      */
     SkData* refEncodedData() {
         return this->onRefEncodedData();
     }
 
+    /**
+     *  Return a decoded instance of this pixelRef in bitmap. If this cannot be
+     *  done, return false and ignore bitmap.
+     *  pow2 is the requeste power-of-two downscale that the caller needs. This
+     *  can be ignored, and the "original" size can be returned, but if the
+     *  underlying codec can efficiently return a smaller size, that should be
+     *  done.
+     *  If this returns true, then bitmap must be "locked" and point to the
+     *  pixels for this pixelref.
+     */
+    bool decodeInto(int pow2, SkBitmap* bitmap) {
+        SkASSERT(pow2 >= 0);
+        return this->onDecodeInto(pow2, bitmap);
+    }
+
     /** Are we really wrapping a texture instead of a bitmap?
      */
     virtual GrTexture* getTexture() { return NULL; }
 
     bool readPixels(SkBitmap* dst, const SkIRect* subset = NULL);
 
     /**
      *  Makes a deep copy of this PixelRef, respecting the requested config.
      *  @param config Desired config.
      *  @param subset Subset of this PixelRef to copy. Must be fully contained within the bounds of
@@ skipping 29 matching lines @@
     virtual void* onLockPixels(SkColorTable**) = 0;
     /** 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.
     */
     virtual void onUnlockPixels() = 0;
 
     /** Default impl returns true */
     virtual bool onLockPixelsAreWritable() const;
 
+    virtual bool onDecodeInto(int pow2, SkBitmap* bitmap);
+
     /**
      *  For pixelrefs that don't have access to their raw pixels, they may be
      *  able to make a copy of them (e.g. if the pixels are on the GPU).
      *
      *  The base class implementation returns false;
      */
     virtual bool onReadPixels(SkBitmap* dst, const SkIRect* subsetOrNull);
 
     // default impl returns NULL.
     virtual SkData* onRefEncodedData();
@@ skipping 31 matching lines @@
     bool    fIsImmutable;
     // only ever set in constructor, const after that
     bool    fPreLocked;
 
     void setMutex(SkBaseMutex* mutex);
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif