WIP -- separate out Parts from SkPaint

include/core/SkPaint.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 SkPaint_DEFINED
 #define SkPaint_DEFINED
 
-#include "SkColor.h"
+#include "SkPaintParts.h"
 #include "SkDrawLooper.h"
 #include "SkMatrix.h"
 #include "SkXfermode.h"
+
 #ifdef SK_BUILD_FOR_ANDROID
-#include "SkPaintOptionsAndroid.h"
+    #include "SkPaintOptionsAndroid.h"
 #endif
 
-class SkAnnotation;
-class SkAutoGlyphCache;
-class SkColorFilter;
-class SkDescriptor;
-struct SkDeviceProperties;
-class SkReadBuffer;
-class SkWriteBuffer;
-struct SkGlyph;
-struct SkRect;
-class SkGlyphCache;
-class SkImageFilter;
-class SkMaskFilter;
-class SkPath;
-class SkPathEffect;
-struct SkPoint;
-class SkRasterizer;
-class SkShader;
-class SkTypeface;
-
 typedef const SkGlyph& (*SkDrawCacheProc)(SkGlyphCache*, const char**,
                                            SkFixed x, SkFixed y);
 
 typedef const SkGlyph& (*SkMeasureCacheProc)(SkGlyphCache*, const char**);
 
 #define kBicubicFilterBitmap_Flag kHighQualityFilterBitmap_Flag
 
 /** \class SkPaint
 
     The SkPaint class holds the style and color information about how to draw
     geometries, text and bitmaps.
 */
 
 class SK_API SkPaint {
 public:
     SkPaint();
     SkPaint(const SkPaint& paint);
     ~SkPaint();
 
+    operator const SkPaintParts& () const { return fParts; }
+
     SkPaint& operator=(const SkPaint&);
 
     SK_API friend bool operator==(const SkPaint& a, const SkPaint& b);
     friend bool operator!=(const SkPaint& a, const SkPaint& b) {
         return !(a == b);
     }
 
     void flatten(SkWriteBuffer&) const;
     void unflatten(SkReadBuffer&);
 
@@ skipping 11 matching lines @@
                               subpixel glyphs, in which case TARGET_LCD or
                               TARGET_LCD_V is used>
     */
     enum Hinting {
         kNo_Hinting            = 0,
         kSlight_Hinting        = 1,
         kNormal_Hinting        = 2,     //!< this is the default
         kFull_Hinting          = 3
     };
 
-    Hinting getHinting() const {
-        return static_cast<Hinting>(fHinting);
-    }
-
+    Hinting getHinting() const { return (Hinting)fParts.getHinting(); }
     void setHinting(Hinting hintingLevel);
 
     /** Specifies the bit values that are stored in the paint's flags.
     */
     enum Flags {
         kAntiAlias_Flag       = 0x01,   //!< mask to enable antialiasing
         kDither_Flag          = 0x04,   //!< mask to enable dithering
         kUnderlineText_Flag   = 0x08,   //!< mask to enable underline text
         kStrikeThruText_Flag  = 0x10,   //!< mask to enable strike-thru text
         kFakeBoldText_Flag    = 0x20,   //!< mask to enable fake-bold text
         kLinearText_Flag      = 0x40,   //!< mask to enable linear-text
         kSubpixelText_Flag    = 0x80,   //!< mask to enable subpixel text positioning
         kDevKernText_Flag     = 0x100,  //!< mask to enable device kerning text
         kLCDRenderText_Flag   = 0x200,  //!< mask to enable subpixel glyph renderering
         kEmbeddedBitmapText_Flag = 0x400, //!< mask to enable embedded bitmap strikes
         kAutoHinting_Flag     = 0x800,  //!< mask to force Freetype's autohinter
         kVerticalText_Flag    = 0x1000,
         kGenA8FromLCD_Flag    = 0x2000, // hack for GDI -- do not use if you can help it
         kDistanceFieldTextTEMP_Flag = 0x4000, //!< TEMPORARY mask to enable distance fields
                                               // currently overrides LCD and subpixel rendering
         // when adding extra flags, note that the fFlags member is specified
         // with a bit-width and you'll have to expand it.
 
         kAllFlags = 0xFFFF
     };
 
     /** Return the paint's flags. Use the Flag enum to test flag values.
         @return the paint's flags (see enums ending in _Flag for bit masks)
     */
-    uint32_t getFlags() const { return fFlags; }
+    uint32_t getFlags() const { return fParts.getFlags(); }
 
     /** Set the paint's flags. Use the Flag enum to specific flag values.
         @param flags    The new flag bits for the paint (see Flags enum)
     */
     void setFlags(uint32_t flags);
 
     /** Helper for getFlags(), returning true if kAntiAlias_Flag bit is set
         @return true if the antialias bit is set in the paint's flags.
         */
     bool isAntiAlias() const {
@@ skipping 160 matching lines @@
         kNone_FilterLevel,
         kLow_FilterLevel,
         kMedium_FilterLevel,
         kHigh_FilterLevel
     };
 
     /**
      *  Return the filter level. This affects the quality (and performance) of
      *  drawing scaled images.
      */
-    FilterLevel getFilterLevel() const { return (FilterLevel)fFilterLevel; }
+    FilterLevel getFilterLevel() const { return (FilterLevel)fParts.getFilterLevel(); }
 
     /**
      *  Set the filter level. This affects the quality (and performance) of
      *  drawing scaled images.
      */
     void setFilterLevel(FilterLevel);
 
     /**
      *  If the predicate is true, set the filterLevel to Low, else set it to
      *  None.
@@ skipping 27 matching lines @@
     };
     enum {
         kStyleCount = kStrokeAndFill_Style + 1
     };
 
     /** Return the paint's style, used for controlling how primitives'
         geometries are interpreted (except for drawBitmap, which always assumes
         kFill_Style).
         @return the paint's Style
     */
-    Style getStyle() const { return (Style)fStyle; }
+    Style getStyle() const { return (Style)fParts.getStyle(); }
 
     /** Set the paint's style, used for controlling how primitives'
         geometries are interpreted (except for drawBitmap, which always assumes
         Fill).
         @param style    The new style to set in the paint
     */
     void setStyle(Style style);
 
     /** Return the paint's color. Note that the color is a 32bit value
         containing alpha as well as r,g,b. This 32bit value is not
         premultiplied, meaning that its alpha can be any value, regardless of
         the values of r,g,b.
         @return the paint's color (and alpha).
     */
-    SkColor getColor() const { return fColor; }
+    SkColor getColor() const { return fParts.fColor; }
 
     /** Set the paint's color. Note that the color is a 32bit value containing
         alpha as well as r,g,b. This 32bit value is not premultiplied, meaning
         that its alpha can be any value, regardless of the values of r,g,b.
         @param color    The new color (including alpha) to set in the paint.
     */
     void setColor(SkColor color);
 
     /** Helper to getColor() that just returns the color's alpha value.
         @return the alpha component of the paint's color.
         */
-    uint8_t getAlpha() const { return SkToU8(SkColorGetA(fColor)); }
+    uint8_t getAlpha() const { return SkToU8(SkColorGetA(this->getColor())); }
 
     /** Helper to setColor(), that only assigns the color's alpha value,
         leaving its r,g,b values unchanged.
         @param a    set the alpha component (0..255) of the paint's color.
     */
     void setAlpha(U8CPU a);
 
     /** Helper to setColor(), that takes a,r,g,b and constructs the color value
         using SkColorSetARGB()
         @param a    The new alpha component (0..255) of the paint's color.
         @param r    The new red component (0..255) of the paint's color.
         @param g    The new green component (0..255) of the paint's color.
         @param b    The new blue component (0..255) of the paint's color.
     */
     void setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
 
     /** Return the width for stroking.
         <p />
         A value of 0 strokes in hairline mode.
         Hairlines always draw 1-pixel wide, regardless of the matrix.
         @return the paint's stroke width, used whenever the paint's style is
                 Stroke or StrokeAndFill.
     */
-    SkScalar getStrokeWidth() const { return fWidth; }
+    SkScalar getStrokeWidth() const { return fParts.getStrokeWidth(); }
 
     /** Set the width for stroking.
         Pass 0 to stroke in hairline mode.
         Hairlines always draw 1-pixel wide, regardless of the matrix.
         @param width set the paint's stroke width, used whenever the paint's
                      style is Stroke or StrokeAndFill.
     */
     void setStrokeWidth(SkScalar width);
 
     /** Return the paint's stroke miter value. This is used to control the
         behavior of miter joins when the joins angle is sharp.
         @return the paint's miter limit, used whenever the paint's style is
                 Stroke or StrokeAndFill.
     */
-    SkScalar getStrokeMiter() const { return fMiterLimit; }
+    SkScalar getStrokeMiter() const { return fParts.getStrokeMiter(); }
 
     /** Set the paint's stroke miter value. This is used to control the
         behavior of miter joins when the joins angle is sharp. This value must
         be >= 0.
         @param miter    set the miter limit on the paint, used whenever the
                         paint's style is Stroke or StrokeAndFill.
     */
     void setStrokeMiter(SkScalar miter);
 
     /** Cap enum specifies the settings for the paint's strokecap. This is the
@@ skipping 19 matching lines @@
 
         kJoinCount,
         kDefault_Join = kMiter_Join
     };
 
     /** Return the paint's stroke cap type, controlling how the start and end
         of stroked lines and paths are treated.
         @return the line cap style for the paint, used whenever the paint's
                 style is Stroke or StrokeAndFill.
     */
-    Cap getStrokeCap() const { return (Cap)fCapType; }
+    Cap getStrokeCap() const { return (Cap)fParts.getStrokeCap(); }
 
     /** Set the paint's stroke cap type.
         @param cap  set the paint's line cap style, used whenever the paint's
                     style is Stroke or StrokeAndFill.
     */
     void setStrokeCap(Cap cap);
 
     /** Return the paint's stroke join type.
         @return the paint's line join style, used whenever the paint's style is
                 Stroke or StrokeAndFill.
     */
-    Join getStrokeJoin() const { return (Join)fJoinType; }
+    Join getStrokeJoin() const { return (Join)fParts.getStrokeJoin(); }
 
     /** Set the paint's stroke join type.
         @param join set the paint's line join style, used whenever the paint's
                     style is Stroke or StrokeAndFill.
     */
     void setStrokeJoin(Join join);
 
     /**
      *  Applies any/all effects (patheffect, stroking) to src, returning the
      *  result in dst. The result is that drawing src with this paint will be
      *  the same as drawing dst with a default paint (at least from the
      *  geometric perspective).
      *
      *  @param src  input path
      *  @param dst  output path (may be the same as src)
      *  @param cullRect If not null, the dst path may be culled to this rect.
      *  @return     true if the path should be filled, or false if it should be
      *              drawn with a hairline (width == 0)
      */
     bool getFillPath(const SkPath& src, SkPath* dst,
                      const SkRect* cullRect = NULL) const;
 
     /** Get the paint's shader object.
         <p />
       The shader's reference count is not affected.
         @return the paint's shader (or NULL)
     */
-    SkShader* getShader() const { return fShader; }
+    SkShader* getShader() const { return fParts.fShader; }
 
     /** Set or clear the shader object.
      *  Shaders specify the source color(s) for what is being drawn. If a paint
      *  has no shader, then the paint's color is used. If the paint has a
      *  shader, then the shader's color(s) are use instead, but they are
      *  modulated by the paint's alpha. This makes it easy to create a shader
      *  once (e.g. bitmap tiling or gradient) and then change its transparency
      *  w/o having to modify the original shader... only the paint's alpha needs
      *  to be modified.
      *
      *  There is an exception to this only-respect-paint's-alpha rule: If the shader only generates
      *  alpha (e.g. SkShader::CreateBitmapShader(bitmap, ...) where bitmap's colortype is kAlpha_8)
      *  then the shader will use the paint's entire color to "colorize" its output (modulating the
      *  bitmap's alpha with the paint's color+alpha).
      *
      *  Pass NULL to clear any previous shader.
      *  As a convenience, the parameter passed is also returned.
      *  If a previous shader exists, its reference count is decremented.
      *  If shader is not NULL, its reference count is incremented.
      *  @param shader   May be NULL. The shader to be installed in the paint
      *  @return         shader
      */
     SkShader* setShader(SkShader* shader);
 
     /** Get the paint's colorfilter. If there is a colorfilter, its reference
         count is not changed.
         @return the paint's colorfilter (or NULL)
     */
-    SkColorFilter* getColorFilter() const { return fColorFilter; }
+    SkColorFilter* getColorFilter() const { return fParts.fColorFilter; }
 
     /** Set or clear the paint's colorfilter, returning the parameter.
         <p />
         If the paint already has a filter, its reference count is decremented.
         If filter is not NULL, its reference count is incremented.
         @param filter   May be NULL. The filter to be installed in the paint
         @return         filter
     */
     SkColorFilter* setColorFilter(SkColorFilter* filter);
 
     /** Get the paint's xfermode object.
         <p />
       The xfermode's reference count is not affected.
         @return the paint's xfermode (or NULL)
     */
-    SkXfermode* getXfermode() const { return fXfermode; }
+    SkXfermode* getXfermode() const { return fParts.fXfermode; }
 
     /** Set or clear the xfermode object.
         <p />
         Pass NULL to clear any previous xfermode.
         As a convenience, the parameter passed is also returned.
         If a previous xfermode exists, its reference count is decremented.
         If xfermode is not NULL, its reference count is incremented.
         @param xfermode May be NULL. The new xfermode to be installed in the
                         paint
         @return         xfermode
     */
     SkXfermode* setXfermode(SkXfermode* xfermode);
 
     /** Create an xfermode based on the specified Mode, and assign it into the
         paint, returning the mode that was set. If the Mode is SrcOver, then
         the paint's xfermode is set to null.
      */
     SkXfermode* setXfermodeMode(SkXfermode::Mode);
 
     /** Get the paint's patheffect object.
         <p />
       The patheffect reference count is not affected.
         @return the paint's patheffect (or NULL)
     */
-    SkPathEffect* getPathEffect() const { return fPathEffect; }
+    SkPathEffect* getPathEffect() const { return fParts.fPathEffect; }
 
     /** Set or clear the patheffect object.
         <p />
         Pass NULL to clear any previous patheffect.
         As a convenience, the parameter passed is also returned.
         If a previous patheffect exists, its reference count is decremented.
         If patheffect is not NULL, its reference count is incremented.
         @param effect   May be NULL. The new patheffect to be installed in the
                         paint
         @return         effect
     */
     SkPathEffect* setPathEffect(SkPathEffect* effect);
 
     /** Get the paint's maskfilter object.
         <p />
       The maskfilter reference count is not affected.
         @return the paint's maskfilter (or NULL)
     */
-    SkMaskFilter* getMaskFilter() const { return fMaskFilter; }
+    SkMaskFilter* getMaskFilter() const { return fParts.fMaskFilter; }
 
     /** Set or clear the maskfilter object.
         <p />
         Pass NULL to clear any previous maskfilter.
         As a convenience, the parameter passed is also returned.
         If a previous maskfilter exists, its reference count is decremented.
         If maskfilter is not NULL, its reference count is incremented.
         @param maskfilter   May be NULL. The new maskfilter to be installed in
                             the paint
         @return             maskfilter
     */
     SkMaskFilter* setMaskFilter(SkMaskFilter* maskfilter);
 
     // These attributes are for text/fonts
 
     /** Get the paint's typeface object.
         <p />
         The typeface object identifies which font to use when drawing or
         measuring text. The typeface reference count is not affected.
         @return the paint's typeface (or NULL)
     */
-    SkTypeface* getTypeface() const { return fTypeface; }
+    SkTypeface* getTypeface() const { return fParts.fTypeface; }
 
     /** Set or clear the typeface object.
         <p />
         Pass NULL to clear any previous typeface.
         As a convenience, the parameter passed is also returned.
         If a previous typeface exists, its reference count is decremented.
         If typeface is not NULL, its reference count is incremented.
         @param typeface May be NULL. The new typeface to be installed in the
                         paint
         @return         typeface
     */
     SkTypeface* setTypeface(SkTypeface* typeface);
 
     /** Get the paint's rasterizer (or NULL).
         <p />
         The raster controls how paths/text are turned into alpha masks.
         @return the paint's rasterizer (or NULL)
     */
-    SkRasterizer* getRasterizer() const { return fRasterizer; }
+    SkRasterizer* getRasterizer() const { return fParts.fRasterizer; }
 
     /** Set or clear the rasterizer object.
         <p />
         Pass NULL to clear any previous rasterizer.
         As a convenience, the parameter passed is also returned.
         If a previous rasterizer exists in the paint, its reference count is
         decremented. If rasterizer is not NULL, its reference count is
         incremented.
         @param rasterizer May be NULL. The new rasterizer to be installed in
                           the paint.
         @return           rasterizer
     */
     SkRasterizer* setRasterizer(SkRasterizer* rasterizer);
 
-    SkImageFilter* getImageFilter() const { return fImageFilter; }
+    SkImageFilter* getImageFilter() const { return fParts.fImageFilter; }
     SkImageFilter* setImageFilter(SkImageFilter*);
 
-    SkAnnotation* getAnnotation() const { return fAnnotation; }
+    SkAnnotation* getAnnotation() const { return fParts.fAnnotation; }
     SkAnnotation* setAnnotation(SkAnnotation*);
 
     /**
      *  Returns true if there is an annotation installed on this paint, and
      *  the annotation specifics no-drawing.
      */
     SK_ATTR_DEPRECATED("use getAnnotation and check for non-null")
     bool isNoDrawAnnotation() const { return this->getAnnotation() != NULL; }
 
     /**
      *  Return the paint's SkDrawLooper (if any). Does not affect the looper's
      *  reference count.
      */
-    SkDrawLooper* getLooper() const { return fLooper; }
+    SkDrawLooper* getLooper() const { return fParts.fLooper; }
 
     /**
      *  Set or clear the looper object.
      *  <p />
      *  Pass NULL to clear any previous looper.
      *  As a convenience, the parameter passed is also returned.
      *  If a previous looper exists in the paint, its reference count is
      *  decremented. If looper is not NULL, its reference count is
      *  incremented.
      *  @param looper May be NULL. The new looper to be installed in the paint.
      *  @return looper
      */
     SkDrawLooper* setLooper(SkDrawLooper* looper);
 
     enum Align {
         kLeft_Align,
         kCenter_Align,
         kRight_Align,
     };
     enum {
         kAlignCount = 3
     };
 
     /** Return the paint's Align value for drawing text.
         @return the paint's Align value for drawing text.
     */
-    Align   getTextAlign() const { return (Align)fTextAlign; }
+    Align   getTextAlign() const { return (Align)fParts.getTextAlign(); }
 
     /** Set the paint's text alignment.
         @param align set the paint's Align value for drawing text.
     */
     void    setTextAlign(Align align);
 
     /** Return the paint's text size.
         @return the paint's text size.
     */
-    SkScalar getTextSize() const { return fTextSize; }
+    SkScalar getTextSize() const { return fParts.getTextSize(); }
 
     /** Set the paint's text size. This value must be > 0
         @param textSize set the paint's text size.
     */
     void setTextSize(SkScalar textSize);
 
     /** Return the paint's horizontal scale factor for text. The default value
         is 1.0.
         @return the paint's scale factor in X for drawing/measuring text
     */
-    SkScalar getTextScaleX() const { return fTextScaleX; }
+    SkScalar getTextScaleX() const { return fParts.getTextScaleX(); }
 
     /** Set the paint's horizontal scale factor for text. The default value
         is 1.0. Values > 1.0 will stretch the text wider. Values < 1.0 will
         stretch the text narrower.
         @param scaleX   set the paint's scale factor in X for drawing/measuring
                         text.
     */
     void setTextScaleX(SkScalar scaleX);
 
     /** Return the paint's horizontal skew factor for text. The default value
         is 0.
         @return the paint's skew factor in X for drawing text.
     */
-    SkScalar getTextSkewX() const { return fTextSkewX; }
+    SkScalar getTextSkewX() const { return fParts.getTextSkewX(); }
 
     /** Set the paint's horizontal skew factor for text. The default value
         is 0. For approximating oblique text, use values around -0.25.
         @param skewX set the paint's skew factor in X for drawing text.
     */
     void setTextSkewX(SkScalar skewX);
 
     /** Describes how to interpret the text parameters that are passed to paint
         methods like measureText() and getTextWidths().
     */
     enum TextEncoding {
         kUTF8_TextEncoding,     //!< the text parameters are UTF8
         kUTF16_TextEncoding,    //!< the text parameters are UTF16
         kUTF32_TextEncoding,    //!< the text parameters are UTF32
         kGlyphID_TextEncoding   //!< the text parameters are glyph indices
     };
 
-    TextEncoding getTextEncoding() const { return (TextEncoding)fTextEncoding; }
+    TextEncoding getTextEncoding() const { return (TextEncoding)fParts.getTextEncoding(); }
 
     void setTextEncoding(TextEncoding encoding);
 
     struct FontMetrics {
         /** Flags which indicate the confidence level of various metrics.
             A set flag indicates that the metric may be trusted.
         */
         enum FontMetricsFlags {
             kUnderlineThinknessIsValid_Flag = 1 << 0,
             kUnderlinePositionIsValid_Flag = 1 << 1,
@@ skipping 267 matching lines @@
     static SkMatrix* SetTextMatrix(SkMatrix* matrix, SkScalar size,
                                    SkScalar scaleX, SkScalar skewX) {
         matrix->setScale(size * scaleX, size);
         if (skewX) {
             matrix->postSkew(skewX, 0);
         }
         return matrix;
     }
 
     SkMatrix* setTextMatrix(SkMatrix* matrix) const {
-        return SetTextMatrix(matrix, fTextSize, fTextScaleX, fTextSkewX);
+        return SetTextMatrix(matrix, fParts.fTextSize, fParts.fTextScaleX, fParts.fTextSkewX);
     }
 
     SK_TO_STRING_NONVIRT()
 
     struct FlatteningTraits {
         static void Flatten(SkWriteBuffer& buffer, const SkPaint& paint);
         static void Unflatten(SkReadBuffer& buffer, SkPaint* paint);
     };
 
 private:
-    SkTypeface*     fTypeface;
-    SkPathEffect*   fPathEffect;
-    SkShader*       fShader;
-    SkXfermode*     fXfermode;
-    SkMaskFilter*   fMaskFilter;
-    SkColorFilter*  fColorFilter;
-    SkRasterizer*   fRasterizer;
-    SkDrawLooper*   fLooper;
-    SkImageFilter*  fImageFilter;
-    SkAnnotation*   fAnnotation;
+    SkPaintParts    fParts;
+    uint32_t        fDirtyBits;
+    
+#ifdef SK_BUILD_FOR_ANDROID
+    SkPaintOptionsAndroid fPaintOptionsAndroid;
+    // In order for the == operator to work properly this must be the last field
+    // in the struct so that we can do a memcmp to this field's offset.
+    uint32_t        fGenerationID;
+#endif
 
-    SkScalar        fTextSize;
-    SkScalar        fTextScaleX;
-    SkScalar        fTextSkewX;
-    SkColor         fColor;
-    SkScalar        fWidth;
-    SkScalar        fMiterLimit;
-    union {
-        struct {
-            // all of these bitfields should add up to 32
-            unsigned        fFlags : 16;
-            unsigned        fTextAlign : 2;
-            unsigned        fCapType : 2;
-            unsigned        fJoinType : 2;
-            unsigned        fStyle : 2;
-            unsigned        fTextEncoding : 2;  // 3 values
-            unsigned        fHinting : 2;
-            unsigned        fFilterLevel : 2;
-            //unsigned      fFreeBits : 2;
-        };
-        uint32_t fBitfields;
-    };
-    uint32_t fDirtyBits;
-
-    uint32_t getBitfields() const { return fBitfields; }
+    uint32_t getBitfields() const { return fParts.fBitfields; }
     void setBitfields(uint32_t bitfields);
 
     SkDrawCacheProc    getDrawCacheProc() const;
     SkMeasureCacheProc getMeasureCacheProc(TextBufferDirection dir,
                                            bool needFullMetrics) const;
 
     SkScalar measure_text(SkGlyphCache*, const char* text, size_t length,
                           int* count, SkRect* bounds) const;
 
     SkGlyphCache* detachCache(const SkDeviceProperties* deviceProperties, const SkMatrix*) const;
@@ skipping 47 matching lines @@
 
     friend class SkAutoGlyphCache;
     friend class SkCanvas;
     friend class SkDraw;
     friend class SkGraphics; // So Term() can be called.
     friend class SkPDFDevice;
     friend class GrBitmapTextContext;
     friend class GrDistanceFieldTextContext;
     friend class SkTextToPathIter;
     friend class SkCanonicalizePaint;
-
-#ifdef SK_BUILD_FOR_ANDROID
-    SkPaintOptionsAndroid fPaintOptionsAndroid;
-
-    // In order for the == operator to work properly this must be the last field
-    // in the struct so that we can do a memcmp to this field's offset.
-    uint32_t        fGenerationID;
-#endif
 };
 
 #endif