Hide SaveFlags from the public SkCanvas API.

include/core/SkCanvas.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 SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 282 matching lines @@
     bool writePixels(const SkImageInfo&, const void* pixels, size_t rowBytes, int x, int y);
 
     /**
      *  Helper for calling writePixels(info, ...) by passing its pixels and rowbytes. If the bitmap
      *  is just wrapping a texture, returns false and does nothing.
      */
     bool writePixels(const SkBitmap& bitmap, int x, int y);
 
     ///////////////////////////////////////////////////////////////////////////
 
+#ifndef SK_SUPPORT_LEGACY_SAVEFLAGS
+protected:
+#endif
     enum SaveFlags {
         /** save the matrix state, restoring it on restore() */
         kMatrix_SaveFlag            = 0x01,
         /** save the clip state, restoring it on restore() */
         kClip_SaveFlag              = 0x02,
         /** the layer needs to support per-pixel alpha */
         kHasAlphaLayer_SaveFlag     = 0x04,
         /** the layer needs to support 8-bits per color component */
         kFullColorLayer_SaveFlag    = 0x08,
         /**
          *  the layer should clip against the bounds argument
          *
          *  if SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG is undefined, this is treated as always on.
          */
         kClipToLayer_SaveFlag       = 0x10,
 
         // helper masks for common choices
         kMatrixClip_SaveFlag        = 0x03,
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
         kARGB_NoClipLayer_SaveFlag  = 0x0F,
 #endif
         kARGB_ClipLayer_SaveFlag    = 0x1F
     };
+public:
 
     /** This call saves the current matrix, clip, and drawFilter, and pushes a
         copy onto a private stack. Subsequent calls to translate, scale,
         rotate, skew, concat or clipRect, clipPath, and setDrawFilter all
         operate on this copy.
         When the balancing call to restore() is made, the previous matrix, clip,
         and drawFilter are restored.
-        @param flags The flags govern what portion of the Matrix/Clip/drawFilter
+        @param flags (deprecated) The flags govern what portion of the Matrix/Clip/drawFilter
                      state the save (and matching restore) effect. For example,
                      if only kMatrix is specified, then only the matrix state
                      will be pushed and popped. Likewise for the clip if kClip
                      is specified.  However, the drawFilter is always affected
                      by calls to save/restore.
         @return The value to pass to restoreToCount() to balance this save()
     */
+#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS
     int save(SaveFlags flags = kMatrixClip_SaveFlag);
+#else
+    int save();
+#endif
 
     /** This behaves the same as save(), but in addition it allocates an
         offscreen bitmap. All drawing calls are directed there, and only when
         the balancing call to restore() is made is that offscreen transfered to
         the canvas (or the previous layer).
         @param bounds (may be null) This rect, if non-null, is used as a hint to
                       limit the size of the offscreen, and thus drawing may be
                       clipped to it, though that clipping is not guaranteed to
                       happen. If exact clipping is desired, use clipRect().
         @param paint (may be null) This is copied, and is applied to the
                      offscreen when restore() is called
-        @param flags  LayerFlags
+        @param flags  (deprecated) LayerFlags
         @return The value to pass to restoreToCount() to balance this save()
     */
+#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS
     int saveLayer(const SkRect* bounds, const SkPaint* paint,
                   SaveFlags flags = kARGB_ClipLayer_SaveFlag);
+#else
+    int saveLayer(const SkRect* bounds, const SkPaint* paint);
+#endif
 
     /** This behaves the same as save(), but in addition it allocates an
         offscreen bitmap. All drawing calls are directed there, and only when
         the balancing call to restore() is made is that offscreen transfered to
         the canvas (or the previous layer).
         @param bounds (may be null) This rect, if non-null, is used as a hint to
                       limit the size of the offscreen, and thus drawing may be
                       clipped to it, though that clipping is not guaranteed to
                       happen. If exact clipping is desired, use clipRect().
         @param alpha  This is applied to the offscreen when restore() is called.
-        @param flags  LayerFlags
+        @param flags  (deprecated) LayerFlags
         @return The value to pass to restoreToCount() to balance this save()
     */
+#ifdef SK_SUPPORT_LEGACY_SAVEFLAGS
     int saveLayerAlpha(const SkRect* bounds, U8CPU alpha,
                        SaveFlags flags = kARGB_ClipLayer_SaveFlag);
+#else
+    int saveLayerAlpha(const SkRect* bounds, U8CPU alpha);
+#endif
 
     /** This call balances a previous call to save(), and is used to remove all
         modifications to the matrix/clip/drawFilter state since the last save
         call.
         It is an error to call restore() more times than save() was called.
     */
     void restore();
 
     /** Returns the number of matrix/clip states on the SkCanvas' private stack.
         This will equal # save() calls - # restore() calls + 1. The save count on
@@ skipping 887 matching lines @@
     friend class SkSurface_Gpu;
 
     bool fDeviceCMDirty;            // cleared by updateDeviceCMCache()
     void updateDeviceCMCache();
 
     friend class SkDrawIter;        // needs setupDrawForLayerDevice()
     friend class AutoDrawLooper;
     friend class SkLua;             // needs top layer size and offset
     friend class SkDeferredDevice;  // needs getTopDevice()
 
+    // These want to play with SaveFlags
+    friend class SkMatrixClipStateMgr;
+    friend class SkDrawCommand;
+    friend class SkObjectParser;
+
     SkBaseDevice* createLayerDevice(const SkImageInfo&);
 
     SkBaseDevice* init(SkBaseDevice*);
 
     /**
      *  DEPRECATED
      *
      *  Specify a device for this canvas to draw into. If it is not null, its
      *  reference count is incremented. If the canvas was already holding a
      *  device, its reference count is decremented. The new device is returned.
@@ skipping 22 matching lines @@
 
     // shared by save() and saveLayer()
     int internalSave(SaveFlags flags);
     void internalRestore();
     static void DrawRect(const SkDraw& draw, const SkPaint& paint,
                          const SkRect& r, SkScalar textSize);
     static void DrawTextDecorations(const SkDraw& draw, const SkPaint& paint,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y);
 
+    static bool bounds_affects_clip(SaveFlags);
+
     /*  These maintain a cache of the clip bounds in local coordinates,
         (converted to 2s-compliment if floats are slow).
      */
     mutable SkRect fCachedLocalClipBounds;
     mutable bool   fCachedLocalClipBoundsDirty;
     bool fAllowSoftClip;
     bool fAllowSimplifyClip;
 
     const SkRect& getLocalClipBounds() const {
         if (fCachedLocalClipBoundsDirty) {
@@ skipping 124 matching lines @@
     bool asROBitmap(SkBitmap*) const;
 
 private:
     SkBitmap    fBitmap;    // used if peekPixels() fails
     const void* fAddr;      // NULL on failure
     SkImageInfo fInfo;
     size_t      fRowBytes;
 };
 
 #endif