stop calling SkBitmap::flatten

include/core/SkBitmap.h

 /*
  * Copyright 2006 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 SkBitmap_DEFINED
 #define SkBitmap_DEFINED
 
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkImageInfo.h"
 #include "SkPoint.h"
 #include "SkRefCnt.h"
 
 struct SkMask;
 struct SkIRect;
 struct SkRect;
 class SkPaint;
 class SkPixelRef;
 class SkPixelRefFactory;
 class SkRegion;
 class SkString;
 class GrTexture;
 
+//#define SK_SUPPORT_LEGACY_BITMAPFLATTEN
+
 /** \class SkBitmap
 
     The SkBitmap class specifies a raster bitmap. A bitmap has an integer width
     and height, and a format (config), and a pointer to the actual pixels.
     Bitmaps can be drawn into a SkCanvas, but they are also used to specify the
     target of a SkCanvas' drawing operations.
     A const SkBitmap exposes getAddr(), which lets a caller write its pixels;
     the constness is considered to apply to the bitmap's configuration, not
     its contents.
 */
@@ skipping 647 matching lines @@
         @param allocator Allocator used to allocate the pixelref for the dst
                          bitmap. If this is null, the standard HeapAllocator
                          will be used.
         @param offset If not null, it is set to top-left coordinate to position
                       the returned bitmap so that it visually lines up with the
                       original
     */
     bool extractAlpha(SkBitmap* dst, const SkPaint* paint, Allocator* allocator,
                       SkIPoint* offset) const;
 
+#ifdef SK_SUPPORT_LEGACY_BITMAPFLATTEN
     /** The following two functions provide the means to both flatten and
         unflatten the bitmap AND its pixels into the provided buffer.
         It is recommended that you do not call these functions directly,
         but instead call the write/readBitmap functions on the respective
         buffers as they can optimize the recording process and avoid recording
         duplicate bitmaps and pixelRefs.
      */
     void flatten(SkWriteBuffer&) const;
+#else
+private:
+#endif
     void unflatten(SkReadBuffer&);
+public:
 
     SkDEBUGCODE(void validate() const;)
 
     class Allocator : public SkRefCnt {
     public:
         SK_DECLARE_INST_COUNT(Allocator)
 
         /** Allocate the pixel memory for the bitmap, given its dimensions and
             config. Return true on success, where success means either setPixels
             or setPixelRef was called. The pixels need not be locked when this
@@ skipping 76 matching lines @@
                                      size_t   rowBytes);
     static size_t ComputeSafeSize(Config   config,
                                   uint32_t width,
                                   uint32_t height,
                                   size_t   rowBytes);
 
     /*  Unreference any pixelrefs or colortables
     */
     void freePixels();
     void updatePixelsFromRef() const;
+    
+    static void WriteRawPixels(SkWriteBuffer*, const SkBitmap&);
+    static SkPixelRef* ReadRawPixels(SkReadBuffer*);
 
+    friend class SkBitmapSource;    // unflatten
+    friend class SkReadBuffer;      // unflatten, rawpixels
+    friend class SkWriteBuffer;     // rawpixels
     friend struct SkBitmapProcState;
 };
 
 class SkAutoLockPixels : SkNoncopyable {
 public:
     SkAutoLockPixels(const SkBitmap& bm, bool doLock = true) : fBitmap(bm) {
         fDidLock = doLock;
         if (doLock) {
             bm.lockPixels();
         }
@@ skipping 97 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Helpers until we can fully deprecate SkBitmap::Config
 //
 extern SkBitmap::Config SkColorTypeToBitmapConfig(SkColorType);
 extern SkColorType SkBitmapConfigToColorType(SkBitmap::Config);
 
 #endif