The Tor Browser / file revision

 /*

  * 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

 #include "SkTypes.h"

 #include "SkBitmap.h"

 #include "SkDeque.h"

 #include "SkClipStack.h"

 #include "SkPaint.h"

 #include "SkRefCnt.h"

 #include "SkPath.h"

 #include "SkRegion.h"

 #include "SkXfermode.h"

 // if not defined, we always assume ClipToLayer for saveLayer()

 //#define SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG

 //#define SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG

 //#define SK_SUPPORT_LEGACY_GETCLIPTYPE

 //#define SK_SUPPORT_LEGACY_GETTOTALCLIP

 //#define SK_SUPPORT_LEGACY_GETTOPDEVICE

 class SkBounder;

 class SkBaseDevice;

 class SkDraw;

 class SkDrawFilter;

 class SkMetaData;

 class SkPicture;

 class SkRRect;

 class SkSurface;

 class SkSurface_Base;

 class GrContext;

 class GrRenderTarget;

 /** \class SkCanvas

     A Canvas encapsulates all of the state about drawing into a device (bitmap).

     This includes a reference to the device itself, and a stack of matrix/clip

     values. For any given draw call (e.g. drawRect), the geometry of the object

     being drawn is transformed by the concatenation of all the matrices in the

     stack. The transformed geometry is clipped by the intersection of all of

     the clips in the stack.

     While the Canvas holds the state of the drawing device, the state (style)

     of the object being drawn is held by the Paint, which is provided as a

     parameter to each of the draw() methods. The Paint holds attributes such as

     color, typeface, textSize, strokeWidth, shader (e.g. gradients, patterns),

     etc.

 */

 class SK_API SkCanvas : public SkRefCnt {

 public:

     SK_DECLARE_INST_COUNT(SkCanvas)

     /**

      *  Attempt to allocate an offscreen raster canvas, matching the ImageInfo.

      *  On success, return a new canvas that will draw into that offscreen.

      *

      *  The caller can access the pixels after drawing into this canvas by

      *  calling readPixels() or peekPixels().

      *

      *  If the requested ImageInfo is opaque (either the colortype is

      *  intrinsically opaque like RGB_565, or the info's alphatype is kOpaque)

      *  then the pixel memory may be uninitialized. Otherwise, the pixel memory

      *  will be initialized to 0, which is interpreted as transparent.

      *

      *  On failure, return NULL. This can fail for several reasons:

      *  1. the memory allocation failed (e.g. request is too large)

      *  2. invalid ImageInfo (e.g. negative dimensions)

      *  3. unsupported ImageInfo for a canvas

      *      - kUnknown_SkColorType, kIndex_8_SkColorType

      *      - kIgnore_SkAlphaType

      *      - this list is not complete, so others may also be unsupported

      *

      *  Note: it is valid to request a supported ImageInfo, but with zero

      *  dimensions.

      */

     static SkCanvas* NewRaster(const SkImageInfo&);

     static SkCanvas* NewRasterN32(int width, int height) {

         return NewRaster(SkImageInfo::MakeN32Premul(width, height));

     }

     /**

      *  Attempt to allocate raster canvas, matching the ImageInfo, that will draw directly into the

      *  specified pixels. To access the pixels after drawing to them, the caller should call

      *  flush() or call peekPixels(...).

      *

      *  On failure, return NULL. This can fail for several reasons:

      *  1. invalid ImageInfo (e.g. negative dimensions)

      *  2. unsupported ImageInfo for a canvas

      *      - kUnknown_SkColorType, kIndex_8_SkColorType

      *      - kIgnore_SkAlphaType

      *      - this list is not complete, so others may also be unsupported

      *

      *  Note: it is valid to request a supported ImageInfo, but with zero

      *  dimensions.

      */

     static SkCanvas* NewRasterDirect(const SkImageInfo&, void*, size_t);

     static SkCanvas* NewRasterDirectN32(int width, int height, SkPMColor* pixels, size_t rowBytes) {

         return NewRasterDirect(SkImageInfo::MakeN32Premul(width, height), pixels, rowBytes);

     }

     /**

      *  Creates an empty canvas with no backing device/pixels, and zero

      *  dimensions.

      */

     SkCanvas();

     /**

      *  Creates a canvas of the specified dimensions, but explicitly not backed

      *  by any device/pixels. Typically this use used by subclasses who handle

      *  the draw calls in some other way.

      */

     SkCanvas(int width, int height);

     /** Construct a canvas with the specified device to draw into.

         @param device   Specifies a device for the canvas to draw into.

     */

     explicit SkCanvas(SkBaseDevice* device);

     /** Construct a canvas with the specified bitmap to draw into.

         @param bitmap   Specifies a bitmap for the canvas to draw into. Its

                         structure are copied to the canvas.

     */

     explicit SkCanvas(const SkBitmap& bitmap);

     virtual ~SkCanvas();

     SkMetaData& getMetaData();

     /**

      *  Return ImageInfo for this canvas. If the canvas is not backed by pixels

      *  (cpu or gpu), then the info's ColorType will be kUnknown_SkColorType.

      */

     SkImageInfo imageInfo() const;

     ///////////////////////////////////////////////////////////////////////////

     /**

      *  Trigger the immediate execution of all pending draw operations.

      */

     void flush();

     /**

      * Gets the size of the base or root layer in global canvas coordinates. The

      * origin of the base layer is always (0,0). The current drawable area may be

      * smaller (due to clipping or saveLayer).

      */

     SkISize getBaseLayerSize() const;

     /**

      *  DEPRECATED: call getBaseLayerSize

      */

     SkISize getDeviceSize() const { return this->getBaseLayerSize(); }

     /**

      *  DEPRECATED.

      *  Return the canvas' device object, which may be null. The device holds

      *  the bitmap of the pixels that the canvas draws into. The reference count

      *  of the returned device is not changed by this call.

      */

     SkBaseDevice* getDevice() const;

     /**

      *  saveLayer() can create another device (which is later drawn onto

      *  the previous device). getTopDevice() returns the top-most device current

      *  installed. Note that this can change on other calls like save/restore,

      *  so do not access this device after subsequent canvas calls.

      *  The reference count of the device is not changed.

      *

      * @param updateMatrixClip If this is true, then before the device is

      *        returned, we ensure that its has been notified about the current

      *        matrix and clip. Note: this happens automatically when the device

      *        is drawn to, but is optional here, as there is a small perf hit

      *        sometimes.

      */

 #ifndef SK_SUPPORT_LEGACY_GETTOPDEVICE

 private:

 #endif

     SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const;

 public:

     /**

      *  Create a new surface matching the specified info, one that attempts to

      *  be maximally compatible when used with this canvas.

      */

     SkSurface* newSurface(const SkImageInfo&);

     /**

      * Return the GPU context of the device that is associated with the canvas.

      * For a canvas with non-GPU device, NULL is returned.

      */

     GrContext* getGrContext();

     ///////////////////////////////////////////////////////////////////////////

     /**

      *  If the canvas has writable pixels in its top layer (and is not recording to a picture

      *  or other non-raster target) and has direct access to its pixels (i.e. they are in

      *  local RAM) return the address of those pixels, and if not null,

      *  return the ImageInfo and rowBytes. The returned address is only valid

      *  while the canvas object is in scope and unchanged. Any API calls made on

      *  canvas (or its parent surface if any) will invalidate the

      *  returned address (and associated information).

      *

      *  On failure, returns NULL and the info and rowBytes parameters are

      *  ignored.

      */

     void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes);

     /**

      *  If the canvas has readable pixels in its base layer (and is not recording to a picture

      *  or other non-raster target) and has direct access to its pixels (i.e. they are in

      *  local RAM) return the const-address of those pixels, and if not null,

      *  return the ImageInfo and rowBytes. The returned address is only valid

      *  while the canvas object is in scope and unchanged. Any API calls made on

      *  canvas (or its parent surface if any) will invalidate the

      *  returned address (and associated information).

      *

      *  On failure, returns NULL and the info and rowBytes parameters are

      *  ignored.

      */

     const void* peekPixels(SkImageInfo* info, size_t* rowBytes);

     /**

      * This enum can be used with read/writePixels to perform a pixel ops to or

      * from an 8888 config other than Skia's native config (SkPMColor). There

      * are three byte orders supported: native, BGRA, and RGBA. Each has a

      * premultiplied and unpremultiplied variant.

      *

      * Components of a 8888 pixel can be packed/unpacked from a 32bit word using

      * either byte offsets or shift values. Byte offsets are endian-invariant

      * while shifts are not. BGRA and RGBA configs are defined by byte

      * orderings. The native config is defined by shift values (SK_A32_SHIFT,

      * ..., SK_B32_SHIFT).

      */

     enum Config8888 {

         /**

          * Skia's native order specified by:

          *      SK_A32_SHIFT, SK_R32_SHIFT, SK_G32_SHIFT, and SK_B32_SHIFT

          *

          * kNative_Premul_Config8888 is equivalent to SkPMColor

          * kNative_Unpremul_Config8888 has the same component order as SkPMColor

          * but is not premultiplied.

          */

         kNative_Premul_Config8888,

         kNative_Unpremul_Config8888,

         /**

          * low byte to high byte: B, G, R, A.

          */

         kBGRA_Premul_Config8888,

         kBGRA_Unpremul_Config8888,

         /**

          * low byte to high byte: R, G, B, A.

          */

         kRGBA_Premul_Config8888,

         kRGBA_Unpremul_Config8888

     };

     /**

      *  On success (returns true), copy the canvas pixels into the bitmap.

      *  On failure, the bitmap parameter is left unchanged and false is

      *  returned.

      *

      *  The canvas' pixels are converted to the bitmap's config. The only

      *  supported config is kARGB_8888_Config, though this is likely to be

      *  relaxed in  the future. The meaning of config kARGB_8888_Config is

      *  modified by the enum param config8888. The default value interprets

      *  kARGB_8888_Config as SkPMColor

      *

      *  If the bitmap has pixels already allocated, the canvas pixels will be

      *  written there. If not, bitmap->allocPixels() will be called

      *  automatically. If the bitmap is backed by a texture readPixels will

      *  fail.

      *

      *  The actual pixels written is the intersection of the canvas' bounds, and

      *  the rectangle formed by the bitmap's width,height and the specified x,y.

      *  If bitmap pixels extend outside of that intersection, they will not be

      *  modified.

      *

      *  Other failure conditions:

      *    * If the canvas is backed by a non-raster device (e.g. PDF) then

      *       readPixels will fail.

      *    * If bitmap is texture-backed then readPixels will fail. (This may be

      *       relaxed in the future.)

      *

      *  Example that reads the entire canvas into a bitmap using the native

      *  SkPMColor:

      *    SkISize size = canvas->getDeviceSize();

      *    bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,

      *                                                   size.fHeight);

      *    if (canvas->readPixels(bitmap, 0, 0)) {

      *       // use the pixels

      *    }

      */

     bool readPixels(SkBitmap* bitmap,

                     int x, int y,

                     Config8888 config8888 = kNative_Premul_Config8888);

     /**

      * DEPRECATED: This will be removed as soon as webkit is no longer relying

      * on it. The bitmap is resized to the intersection of srcRect and the

      * canvas bounds. New pixels are always allocated on success. Bitmap is

      * unmodified on failure.

      */

     bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);

 #ifdef SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG

     /**

      *  DEPRECATED

      *  Similar to draw sprite, this method will copy the pixels in bitmap onto

      *  the canvas, with the top/left corner specified by (x, y). The canvas'

      *  pixel values are completely replaced: there is no blending.

      *

      *  Currently if bitmap is backed by a texture this is a no-op. This may be

      *  relaxed in the future.

      *

      *  If the bitmap has config kARGB_8888_Config then the config8888 param

      *  will determines how the pixel valuess are intepreted. If the bitmap is

      *  not kARGB_8888_Config then this parameter is ignored.

      *

      *  Note: If you are recording drawing commands on this canvas to

      *  SkPicture, writePixels() is ignored!

      */

     void writePixels(const SkBitmap& bitmap, int x, int y, Config8888 config8888);

 #endif

     /**

      *  This method affects the pixels in the base-layer, and operates in pixel coordinates,

      *  ignoring the matrix and clip.

      *

      *  The specified ImageInfo and (x,y) offset specifies a rectangle: target.

      *

      *      target.setXYWH(x, y, info.width(), info.height());

      *

      *  Target is intersected with the bounds of the base-layer. If this intersection is not empty,

      *  then we have two sets of pixels (of equal size), the "src" specified by info+pixels+rowBytes

      *  and the "dst" by the canvas' backend. Replace the dst pixels with the corresponding src

      *  pixels, performing any colortype/alphatype transformations needed (in the case where the

      *  src and dst have different colortypes or alphatypes).

      *

      *  This call can fail, returning false, for several reasons:

      *  - If the src colortype/alphatype cannot be converted to the canvas' types

      *  - If this canvas is not backed by pixels (e.g. picture or PDF)

      */

     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);

     ///////////////////////////////////////////////////////////////////////////

     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

     };

     /** 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

                      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()

     */

     int save(SaveFlags flags = kMatrixClip_SaveFlag);

     /** 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

         @return The value to pass to restoreToCount() to balance this save()

     */

     int saveLayer(const SkRect* bounds, const SkPaint* paint,

                   SaveFlags flags = kARGB_ClipLayer_SaveFlag);

     /** 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

         @return The value to pass to restoreToCount() to balance this save()

     */

     int saveLayerAlpha(const SkRect* bounds, U8CPU alpha,

                        SaveFlags flags = kARGB_ClipLayer_SaveFlag);

     /** 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

         a new canvas is 1.

     */

     int getSaveCount() const;

     /** Efficient way to pop any calls to save() that happened after the save

         count reached saveCount. It is an error for saveCount to be greater than

         getSaveCount(). To pop all the way back to the initial matrix/clip context

         pass saveCount == 1.

         @param saveCount    The number of save() levels to restore from

     */

     void restoreToCount(int saveCount);

     /** Returns true if drawing is currently going to a layer (from saveLayer)

      *  rather than to the root device.

      */

     virtual bool isDrawingToLayer() const;

     /** Preconcat the current matrix with the specified translation

         @param dx   The distance to translate in X

         @param dy   The distance to translate in Y

         returns true if the operation succeeded (e.g. did not overflow)

     */

     bool translate(SkScalar dx, SkScalar dy);

     /** Preconcat the current matrix with the specified scale.

         @param sx   The amount to scale in X

         @param sy   The amount to scale in Y

         returns true if the operation succeeded (e.g. did not overflow)

     */

     bool scale(SkScalar sx, SkScalar sy);

     /** Preconcat the current matrix with the specified rotation.

         @param degrees  The amount to rotate, in degrees

         returns true if the operation succeeded (e.g. did not overflow)

     */

     bool rotate(SkScalar degrees);

     /** Preconcat the current matrix with the specified skew.

         @param sx   The amount to skew in X

         @param sy   The amount to skew in Y

         returns true if the operation succeeded (e.g. did not overflow)

     */

     bool skew(SkScalar sx, SkScalar sy);

     /** Preconcat the current matrix with the specified matrix.

         @param matrix   The matrix to preconcatenate with the current matrix

         @return true if the operation succeeded (e.g. did not overflow)

     */

     bool concat(const SkMatrix& matrix);

     /** Replace the current matrix with a copy of the specified matrix.

         @param matrix The matrix that will be copied into the current matrix.

     */

     void setMatrix(const SkMatrix& matrix);

     /** Helper for setMatrix(identity). Sets the current matrix to identity.

     */

     void resetMatrix();

     /**

      *  Modify the current clip with the specified rectangle.

      *  @param rect The rect to combine with the current clip

      *  @param op The region op to apply to the current clip

      *  @param doAntiAlias true if the clip should be antialiased

      */

     void clipRect(const SkRect& rect,

                   SkRegion::Op op = SkRegion::kIntersect_Op,

                   bool doAntiAlias = false);

     /**

      *  Modify the current clip with the specified SkRRect.

      *  @param rrect The rrect to combine with the current clip

      *  @param op The region op to apply to the current clip

      *  @param doAntiAlias true if the clip should be antialiased

      */

     void clipRRect(const SkRRect& rrect,

                    SkRegion::Op op = SkRegion::kIntersect_Op,

                    bool doAntiAlias = false);

     /**

      *  Modify the current clip with the specified path.

      *  @param path The path to combine with the current clip

      *  @param op The region op to apply to the current clip

      *  @param doAntiAlias true if the clip should be antialiased

      */

     void clipPath(const SkPath& path,

                   SkRegion::Op op = SkRegion::kIntersect_Op,

                   bool doAntiAlias = false);

     /** EXPERIMENTAL -- only used for testing

         Set to false to force clips to be hard, even if doAntiAlias=true is

         passed to clipRect or clipPath.

      */

     void setAllowSoftClip(bool allow) {

         fAllowSoftClip = allow;

     }

     /** EXPERIMENTAL -- only used for testing

         Set to simplify clip stack using path ops.

      */

     void setAllowSimplifyClip(bool allow) {

         fAllowSimplifyClip = allow;

     }

     /** Modify the current clip with the specified region. Note that unlike

         clipRect() and clipPath() which transform their arguments by the current

         matrix, clipRegion() assumes its argument is already in device

         coordinates, and so no transformation is performed.

         @param deviceRgn    The region to apply to the current clip

         @param op The region op to apply to the current clip

     */

     void clipRegion(const SkRegion& deviceRgn,

                     SkRegion::Op op = SkRegion::kIntersect_Op);

     /** Helper for clipRegion(rgn, kReplace_Op). Sets the current clip to the

         specified region. This does not intersect or in any other way account

         for the existing clip region.

         @param deviceRgn The region to copy into the current clip.

     */

     void setClipRegion(const SkRegion& deviceRgn) {

         this->clipRegion(deviceRgn, SkRegion::kReplace_Op);

     }

     /** Return true if the specified rectangle, after being transformed by the

         current matrix, would lie completely outside of the current clip. Call

         this to check if an area you intend to draw into is clipped out (and

         therefore you can skip making the draw calls).

         @param rect the rect to compare with the current clip

         @return true if the rect (transformed by the canvas' matrix) does not

                      intersect with the canvas' clip

     */

     bool quickReject(const SkRect& rect) const;

     /** Return true if the specified path, after being transformed by the

         current matrix, would lie completely outside of the current clip. Call

         this to check if an area you intend to draw into is clipped out (and

         therefore you can skip making the draw calls). Note, for speed it may

         return false even if the path itself might not intersect the clip

         (i.e. the bounds of the path intersects, but the path does not).

         @param path The path to compare with the current clip

         @return true if the path (transformed by the canvas' matrix) does not

                      intersect with the canvas' clip

     */

     bool quickReject(const SkPath& path) const;

     /** Return true if the horizontal band specified by top and bottom is

         completely clipped out. This is a conservative calculation, meaning

         that it is possible that if the method returns false, the band may still

         in fact be clipped out, but the converse is not true. If this method

         returns true, then the band is guaranteed to be clipped out.

         @param top  The top of the horizontal band to compare with the clip

         @param bottom The bottom of the horizontal and to compare with the clip

         @return true if the horizontal band is completely clipped out (i.e. does

                      not intersect the current clip)

     */

     bool quickRejectY(SkScalar top, SkScalar bottom) const {

         SkASSERT(top <= bottom);

 #ifndef SK_WILL_NEVER_DRAW_PERSPECTIVE_TEXT

         // TODO: add a hasPerspective method similar to getLocalClipBounds. This

         // would cache the SkMatrix::hasPerspective result. Alternatively, have

         // the MC stack just set a hasPerspective boolean as it is updated.

         if (this->getTotalMatrix().hasPerspective()) {

             // TODO: consider implementing some half-plane test between the

             // two Y planes and the device-bounds (i.e., project the top and

             // bottom Y planes and then determine if the clip bounds is completely

             // outside either one).

             return false;

         }

 #endif

         const SkRect& clipR = this->getLocalClipBounds();

         // In the case where the clip is empty and we are provided with a

         // negative top and positive bottom parameter then this test will return

         // false even though it will be clipped. We have chosen to exclude that

         // check as it is rare and would result double the comparisons.

         return top >= clipR.fBottom || bottom <= clipR.fTop;

     }

     /** Return the bounds of the current clip (in local coordinates) in the

         bounds parameter, and return true if it is non-empty. This can be useful

         in a way similar to quickReject, in that it tells you that drawing

         outside of these bounds will be clipped out.

     */

     virtual bool getClipBounds(SkRect* bounds) const;

     /** Return the bounds of the current clip, in device coordinates; returns

         true if non-empty. Maybe faster than getting the clip explicitly and

         then taking its bounds.

     */

     virtual bool getClipDeviceBounds(SkIRect* bounds) const;

     /** Fill the entire canvas' bitmap (restricted to the current clip) with the

         specified ARGB color, using the specified mode.

         @param a    the alpha component (0..255) of the color to fill the canvas

         @param r    the red component (0..255) of the color to fill the canvas

         @param g    the green component (0..255) of the color to fill the canvas

         @param b    the blue component (0..255) of the color to fill the canvas

         @param mode the mode to apply the color in (defaults to SrcOver)

     */

     void drawARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b,

                   SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode);

     /** Fill the entire canvas' bitmap (restricted to the current clip) with the

         specified color and mode.

         @param color    the color to draw with

         @param mode the mode to apply the color in (defaults to SrcOver)

     */

     void drawColor(SkColor color,

                    SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode);

     /**

      *  This erases the entire drawing surface to the specified color,

      *  irrespective of the clip. It does not blend with the previous pixels,

      *  but always overwrites them.

      *

      *  It is roughly equivalent to the following:

      *      canvas.save();

      *      canvas.clipRect(hugeRect, kReplace_Op);

      *      paint.setColor(color);

      *      paint.setXfermodeMode(kSrc_Mode);

      *      canvas.drawPaint(paint);

      *      canvas.restore();

      *  though it is almost always much more efficient.

      */

     virtual void clear(SkColor);

     /**

      *  Fill the entire canvas' bitmap (restricted to the current clip) with the

      *  specified paint.

      *  @param paint    The paint used to fill the canvas

      */

     virtual void drawPaint(const SkPaint& paint);

     enum PointMode {

         /** drawPoints draws each point separately */

         kPoints_PointMode,

         /** drawPoints draws each pair of points as a line segment */

         kLines_PointMode,

         /** drawPoints draws the array of points as a polygon */

         kPolygon_PointMode

     };

     /** Draw a series of points, interpreted based on the PointMode mode. For

         all modes, the count parameter is interpreted as the total number of

         points. For kLine mode, count/2 line segments are drawn.

         For kPoint mode, each point is drawn centered at its coordinate, and its

         size is specified by the paint's stroke-width. It draws as a square,

         unless the paint's cap-type is round, in which the points are drawn as

         circles.

         For kLine mode, each pair of points is drawn as a line segment,

         respecting the paint's settings for cap/join/width.

         For kPolygon mode, the entire array is drawn as a series of connected

         line segments.

         Note that, while similar, kLine and kPolygon modes draw slightly

         differently than the equivalent path built with a series of moveto,

         lineto calls, in that the path will draw all of its contours at once,

         with no interactions if contours intersect each other (think XOR

         xfermode). drawPoints always draws each element one at a time.

         @param mode     PointMode specifying how to draw the array of points.

         @param count    The number of points in the array

         @param pts      Array of points to draw

         @param paint    The paint used to draw the points

     */

     virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[],

                             const SkPaint& paint);

     /** Helper method for drawing a single point. See drawPoints() for a more

         details.

     */

     void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint);

     /** Draws a single pixel in the specified color.

         @param x        The X coordinate of which pixel to draw

         @param y        The Y coordiante of which pixel to draw

         @param color    The color to draw

     */

     void drawPoint(SkScalar x, SkScalar y, SkColor color);

     /** Draw a line segment with the specified start and stop x,y coordinates,

         using the specified paint. NOTE: since a line is always "framed", the

         paint's Style is ignored.

         @param x0    The x-coordinate of the start point of the line

         @param y0    The y-coordinate of the start point of the line

         @param x1    The x-coordinate of the end point of the line

         @param y1    The y-coordinate of the end point of the line

         @param paint The paint used to draw the line

     */

     void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,

                   const SkPaint& paint);

     /** Draw the specified rectangle using the specified paint. The rectangle

         will be filled or stroked based on the Style in the paint.

         @param rect     The rect to be drawn

         @param paint    The paint used to draw the rect

     */

     virtual void drawRect(const SkRect& rect, const SkPaint& paint);

     /** Draw the specified rectangle using the specified paint. The rectangle

         will be filled or framed based on the Style in the paint.

         @param rect     The rect to be drawn

         @param paint    The paint used to draw the rect

     */

     void drawIRect(const SkIRect& rect, const SkPaint& paint) {

         SkRect r;

         r.set(rect);    // promotes the ints to scalars

         this->drawRect(r, paint);

     }

     /** Draw the specified rectangle using the specified paint. The rectangle

         will be filled or framed based on the Style in the paint.

         @param left     The left side of the rectangle to be drawn

         @param top      The top side of the rectangle to be drawn

         @param right    The right side of the rectangle to be drawn

         @param bottom   The bottom side of the rectangle to be drawn

         @param paint    The paint used to draw the rect

     */

     void drawRectCoords(SkScalar left, SkScalar top, SkScalar right,

                         SkScalar bottom, const SkPaint& paint);

     /** Draw the specified oval using the specified paint. The oval will be

         filled or framed based on the Style in the paint.

         @param oval     The rectangle bounds of the oval to be drawn

         @param paint    The paint used to draw the oval

     */

     virtual void drawOval(const SkRect& oval, const SkPaint&);

     /**

      *  Draw the specified RRect using the specified paint The rrect will be filled or stroked

      *  based on the Style in the paint.

      *

      *  @param rrect    The round-rect to draw

      *  @param paint    The paint used to draw the round-rect

      */

     virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint);

     /**

      *  Draw the annulus formed by the outer and inner rrects. The results

      *  are undefined if the outer does not contain the inner.

      */

     void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint&);

     /** Draw the specified circle using the specified paint. If radius is <= 0,

         then nothing will be drawn. The circle will be filled

         or framed based on the Style in the paint.

         @param cx       The x-coordinate of the center of the cirle to be drawn

         @param cy       The y-coordinate of the center of the cirle to be drawn

         @param radius   The radius of the cirle to be drawn

         @param paint    The paint used to draw the circle

     */

     void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius,

                     const SkPaint& paint);

     /** Draw the specified arc, which will be scaled to fit inside the

         specified oval. If the sweep angle is >= 360, then the oval is drawn

         completely. Note that this differs slightly from SkPath::arcTo, which

         treats the sweep angle mod 360.

         @param oval The bounds of oval used to define the shape of the arc

         @param startAngle Starting angle (in degrees) where the arc begins

         @param sweepAngle Sweep angle (in degrees) measured clockwise

         @param useCenter true means include the center of the oval. For filling

                          this will draw a wedge. False means just use the arc.

         @param paint    The paint used to draw the arc

     */

     void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,

                  bool useCenter, const SkPaint& paint);

     /** Draw the specified round-rect using the specified paint. The round-rect

         will be filled or framed based on the Style in the paint.

         @param rect     The rectangular bounds of the roundRect to be drawn

         @param rx       The x-radius of the oval used to round the corners

         @param ry       The y-radius of the oval used to round the corners

         @param paint    The paint used to draw the roundRect

     */

     void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry,

                        const SkPaint& paint);

     /** Draw the specified path using the specified paint. The path will be

         filled or framed based on the Style in the paint.

         @param path     The path to be drawn

         @param paint    The paint used to draw the path

     */

     virtual void drawPath(const SkPath& path, const SkPaint& paint);

     /** Draw the specified bitmap, with its top/left corner at (x,y), using the

         specified paint, transformed by the current matrix. Note: if the paint

         contains a maskfilter that generates a mask which extends beyond the

         bitmap's original width/height, then the bitmap will be drawn as if it

         were in a Shader with CLAMP mode. Thus the color outside of the original

         width/height will be the edge color replicated.

         If a shader is present on the paint it will be ignored, except in the

         case where the bitmap is kA8_Config. In that case, the color is

         generated by the shader.

         @param bitmap   The bitmap to be drawn

         @param left     The position of the left side of the bitmap being drawn

         @param top      The position of the top side of the bitmap being drawn

         @param paint    The paint used to draw the bitmap, or NULL

     */

     virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,

                             const SkPaint* paint = NULL);

     enum DrawBitmapRectFlags {

         kNone_DrawBitmapRectFlag            = 0x0,

         /**

          *  When filtering is enabled, allow the color samples outside of

          *  the src rect (but still in the src bitmap) to bleed into the

          *  drawn portion

          */

         kBleed_DrawBitmapRectFlag           = 0x1,

     };

     /** Draw the specified bitmap, with the specified matrix applied (before the

         canvas' matrix is applied).

         @param bitmap   The bitmap to be drawn

         @param src      Optional: specify the subset of the bitmap to be drawn

         @param dst      The destination rectangle where the scaled/translated

                         image will be drawn

         @param paint    The paint used to draw the bitmap, or NULL

     */

     virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,

                                       const SkRect& dst,

                                       const SkPaint* paint = NULL,

                                       DrawBitmapRectFlags flags = kNone_DrawBitmapRectFlag);

     void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst,

                         const SkPaint* paint = NULL) {

         this->drawBitmapRectToRect(bitmap, NULL, dst, paint, kNone_DrawBitmapRectFlag);

     }

     void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* isrc,

                         const SkRect& dst, const SkPaint* paint = NULL,

                         DrawBitmapRectFlags flags = kNone_DrawBitmapRectFlag) {

         SkRect realSrcStorage;

         SkRect* realSrcPtr = NULL;

         if (isrc) {

             realSrcStorage.set(*isrc);

             realSrcPtr = &realSrcStorage;

         }

         this->drawBitmapRectToRect(bitmap, realSrcPtr, dst, paint, flags);

     }

     virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,

                                   const SkPaint* paint = NULL);

     /**

      *  Draw the bitmap stretched differentially to fit into dst.

      *  center is a rect within the bitmap, and logically divides the bitmap

      *  into 9 sections (3x3). For example, if the middle pixel of a [5x5]

      *  bitmap is the "center", then the center-rect should be [2, 2, 3, 3].

      *

      *  If the dst is >= the bitmap size, then...

      *  - The 4 corners are not stretched at all.

      *  - The sides are stretched in only one axis.

      *  - The center is stretched in both axes.

      * Else, for each axis where dst < bitmap,

      *  - The corners shrink proportionally

      *  - The sides (along the shrink axis) and center are not drawn

      */

     virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,

                                 const SkRect& dst, const SkPaint* paint = NULL);

     /** Draw the specified bitmap, with its top/left corner at (x,y),

         NOT transformed by the current matrix. Note: if the paint

         contains a maskfilter that generates a mask which extends beyond the

         bitmap's original width/height, then the bitmap will be drawn as if it

         were in a Shader with CLAMP mode. Thus the color outside of the original

         width/height will be the edge color replicated.

         @param bitmap   The bitmap to be drawn

         @param left     The position of the left side of the bitmap being drawn

         @param top      The position of the top side of the bitmap being drawn

         @param paint    The paint used to draw the bitmap, or NULL

     */

     virtual void drawSprite(const SkBitmap& bitmap, int left, int top,

                             const SkPaint* paint = NULL);

     /** Draw the text, with origin at (x,y), using the specified paint.

         The origin is interpreted based on the Align setting in the paint.

         @param text The text to be drawn

         @param byteLength   The number of bytes to read from the text parameter

         @param x        The x-coordinate of the origin of the text being drawn

         @param y        The y-coordinate of the origin of the text being drawn

         @param paint    The paint used for the text (e.g. color, size, style)

     */

     virtual void drawText(const void* text, size_t byteLength, SkScalar x,

                           SkScalar y, const SkPaint& paint);

     /** Draw the text, with each character/glyph origin specified by the pos[]

         array. The origin is interpreted by the Align setting in the paint.

         @param text The text to be drawn

         @param byteLength   The number of bytes to read from the text parameter

         @param pos      Array of positions, used to position each character

         @param paint    The paint used for the text (e.g. color, size, style)

         */

     virtual void drawPosText(const void* text, size_t byteLength,

                              const SkPoint pos[], const SkPaint& paint);

     /** Draw the text, with each character/glyph origin specified by the x

         coordinate taken from the xpos[] array, and the y from the constY param.

         The origin is interpreted by the Align setting in the paint.

         @param text The text to be drawn

         @param byteLength   The number of bytes to read from the text parameter

         @param xpos     Array of x-positions, used to position each character

         @param constY   The shared Y coordinate for all of the positions

         @param paint    The paint used for the text (e.g. color, size, style)

         */

     virtual void drawPosTextH(const void* text, size_t byteLength,

                               const SkScalar xpos[], SkScalar constY,

                               const SkPaint& paint);

     /** Draw the text, with origin at (x,y), using the specified paint, along

         the specified path. The paint's Align setting determins where along the

         path to start the text.

         @param text The text to be drawn

         @param byteLength   The number of bytes to read from the text parameter

         @param path         The path the text should follow for its baseline

         @param hOffset      The distance along the path to add to the text's

                             starting position

         @param vOffset      The distance above(-) or below(+) the path to

                             position the text

         @param paint        The paint used for the text

     */

     void drawTextOnPathHV(const void* text, size_t byteLength,

                           const SkPath& path, SkScalar hOffset,

                           SkScalar vOffset, const SkPaint& paint);

     /** Draw the text, with origin at (x,y), using the specified paint, along

         the specified path. The paint's Align setting determins where along the

         path to start the text.

         @param text The text to be drawn

         @param byteLength   The number of bytes to read from the text parameter

         @param path         The path the text should follow for its baseline

         @param matrix       (may be null) Applied to the text before it is

                             mapped onto the path

         @param paint        The paint used for the text

         */

     virtual void drawTextOnPath(const void* text, size_t byteLength,

                                 const SkPath& path, const SkMatrix* matrix,

                                 const SkPaint& paint);

     /** PRIVATE / EXPERIMENTAL -- do not call

         Perform back-end analysis/optimization of a picture. This may attach

         optimization data to the picture which can be used by a later

         drawPicture call.

         @param picture The recorded drawing commands to analyze/optimize

     */

     void EXPERIMENTAL_optimize(SkPicture* picture);

     /** Draw the picture into this canvas. This method effective brackets the

         playback of the picture's draw calls with save/restore, so the state

         of this canvas will be unchanged after this call.

         @param picture The recorded drawing commands to playback into this

                        canvas.

     */

     virtual void drawPicture(SkPicture& picture);

     enum VertexMode {

         kTriangles_VertexMode,

         kTriangleStrip_VertexMode,

         kTriangleFan_VertexMode

     };

     /** Draw the array of vertices, interpreted as triangles (based on mode).

         @param vmode How to interpret the array of vertices

         @param vertexCount The number of points in the vertices array (and

                     corresponding texs and colors arrays if non-null)

         @param vertices Array of vertices for the mesh

         @param texs May be null. If not null, specifies the coordinate

                     in _texture_ space (not uv space) for each vertex.

         @param colors May be null. If not null, specifies a color for each

                       vertex, to be interpolated across the triangle.

         @param xmode Used if both texs and colors are present. In this

                     case the colors are combined with the texture using mode,

                     before being drawn using the paint. If mode is null, then

                     kModulate_Mode is used.

         @param indices If not null, array of indices to reference into the

                     vertex (texs, colors) array.

         @param indexCount number of entries in the indices array (if not null)

         @param paint Specifies the shader/texture if present.

     */

     virtual void drawVertices(VertexMode vmode, int vertexCount,

                               const SkPoint vertices[], const SkPoint texs[],

                               const SkColor colors[], SkXfermode* xmode,

                               const uint16_t indices[], int indexCount,

                               const SkPaint& paint);

     /** Send a blob of data to the canvas.

         For canvases that draw, this call is effectively a no-op, as the data

         is not parsed, but just ignored. However, this call exists for

         subclasses like SkPicture's recording canvas, that can store the data

         and then play it back later (via another call to drawData).

      */

     virtual void drawData(const void* data, size_t length) {

         // do nothing. Subclasses may do something with the data

     }

     /** Add comments. beginCommentGroup/endCommentGroup open/close a new group.

         Each comment added via addComment is notionally attached to its

         enclosing group. Top-level comments simply belong to no group.

      */

     virtual void beginCommentGroup(const char* description) {

         // do nothing. Subclasses may do something

     }

     virtual void addComment(const char* kywd, const char* value) {

         // do nothing. Subclasses may do something

     }

     virtual void endCommentGroup() {

         // do nothing. Subclasses may do something

     }

     /**

      *  With this call the client asserts that subsequent draw operations (up to the

      *  matching popCull()) are fully contained within the given bounding box. The assertion

      *  is not enforced, but the information might be used to quick-reject command blocks,

      *  so an incorrect bounding box may result in incomplete rendering.

      */

     void pushCull(const SkRect& cullRect) {

         ++fCullCount;

         this->onPushCull(cullRect);

     }

     /**

      *  Terminates the current culling block, and restores the previous one (if any).

      */

     void popCull() {

         if (fCullCount > 0) {

             --fCullCount;

             this->onPopCull();

         }

     }

     //////////////////////////////////////////////////////////////////////////

     /** Get the current bounder object.

         The bounder's reference count is unchaged.

         @return the canva's bounder (or NULL).

     */

     SkBounder*  getBounder() const { return fBounder; }

     /** Set a new bounder (or NULL).

         Pass NULL to clear any previous bounder.

         As a convenience, the parameter passed is also returned.

         If a previous bounder exists, its reference count is decremented.

         If bounder is not NULL, its reference count is incremented.

         @param bounder the new bounder (or NULL) to be installed in the canvas

         @return the set bounder object

     */

     virtual SkBounder* setBounder(SkBounder* bounder);

     /** Get the current filter object. The filter's reference count is not

         affected. The filter is saved/restored, just like the matrix and clip.

         @return the canvas' filter (or NULL).

     */

     SkDrawFilter* getDrawFilter() const;

     /** Set the new filter (or NULL). Pass NULL to clear any existing filter.

         As a convenience, the parameter is returned. If an existing filter

         exists, its refcnt is decrement. If the new filter is not null, its

         refcnt is incremented. The filter is saved/restored, just like the

         matrix and clip.

         @param filter the new filter (or NULL)

         @return the new filter

     */

     virtual SkDrawFilter* setDrawFilter(SkDrawFilter* filter);

     //////////////////////////////////////////////////////////////////////////

     /**

      *  Return true if the current clip is empty (i.e. nothing will draw).

      *  Note: this is not always a free call, so it should not be used

      *  more often than necessary. However, once the canvas has computed this

      *  result, subsequent calls will be cheap (until the clip state changes,

      *  which can happen on any clip..() or restore() call.

      */

     virtual bool isClipEmpty() const;

     /**

      *  Returns true if the current clip is just a (non-empty) rectangle.

      *  Returns false if the clip is empty, or if it is complex.

      */

     virtual bool isClipRect() const;

     /** Return the current matrix on the canvas.

         This does not account for the translate in any of the devices.

         @return The current matrix on the canvas.

     */

     const SkMatrix& getTotalMatrix() const;

 #ifdef SK_SUPPORT_LEGACY_GETCLIPTYPE

     enum ClipType {

         kEmpty_ClipType = 0,

         kRect_ClipType,

         kComplex_ClipType

     };

     /** Returns a description of the total clip; may be cheaper than

         getting the clip and querying it directly.

     */

     virtual ClipType getClipType() const;

 #endif

 #ifdef SK_SUPPORT_LEGACY_GETTOTALCLIP

     /** DEPRECATED -- need to move this guy to private/friend

      *  Return the current device clip (concatenation of all clip calls).

      *  This does not account for the translate in any of the devices.

      *  @return the current device clip (concatenation of all clip calls).

      */

     const SkRegion& getTotalClip() const;

 #endif

     /** Return the clip stack. The clip stack stores all the individual

      *  clips organized by the save/restore frame in which they were

      *  added.

      *  @return the current clip stack ("list" of individual clip elements)

      */

     const SkClipStack* getClipStack() const {

         return &fClipStack;

     }

     class ClipVisitor {

     public:

         virtual ~ClipVisitor();

         virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;

         virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;

         virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;

     };

     /**

      *  Replays the clip operations, back to front, that have been applied to

      *  the canvas, calling the appropriate method on the visitor for each

      *  clip. All clips have already been transformed into device space.

      */

     void replayClips(ClipVisitor*) const;

     ///////////////////////////////////////////////////////////////////////////

     /** After calling saveLayer(), there can be any number of devices that make

         up the top-most drawing area. LayerIter can be used to iterate through

         those devices. Note that the iterator is only valid until the next API

         call made on the canvas. Ownership of all pointers in the iterator stays

         with the canvas, so none of them should be modified or deleted.

     */

     class SK_API LayerIter /*: SkNoncopyable*/ {

     public:

         /** Initialize iterator with canvas, and set values for 1st device */

         LayerIter(SkCanvas*, bool skipEmptyClips);

         ~LayerIter();

         /** Return true if the iterator is done */

         bool done() const { return fDone; }

         /** Cycle to the next device */

         void next();

         // These reflect the current device in the iterator

         SkBaseDevice*   device() const;

         const SkMatrix& matrix() const;

         const SkRegion& clip() const;

         const SkPaint&  paint() const;

         int             x() const;

         int             y() const;

     private:

         // used to embed the SkDrawIter object directly in our instance, w/o

         // having to expose that class def to the public. There is an assert

         // in our constructor to ensure that fStorage is large enough

         // (though needs to be a compile-time-assert!). We use intptr_t to work

         // safely with 32 and 64 bit machines (to ensure the storage is enough)

         intptr_t          fStorage[32];

         class SkDrawIter* fImpl;    // this points at fStorage

         SkPaint           fDefaultPaint;

         bool              fDone;

     };

     // don't call

     const SkRegion& internal_private_getTotalClip() const;

     // don't call

     void internal_private_getTotalClipAsPath(SkPath*) const;

     // don't call

     GrRenderTarget* internal_private_accessTopLayerRenderTarget();

 protected:

     // default impl defers to getDevice()->newSurface(info)

     virtual SkSurface* onNewSurface(const SkImageInfo&);

     // default impl defers to its device

     virtual const void* onPeekPixels(SkImageInfo*, size_t* rowBytes);

     virtual void* onAccessTopLayerPixels(SkImageInfo*, size_t* rowBytes);

     // Subclass save/restore notifiers.

     // Overriders should call the corresponding INHERITED method up the inheritance chain.

     // willSaveLayer()'s return value may suppress full layer allocation.

     enum SaveLayerStrategy {

         kFullLayer_SaveLayerStrategy,

         kNoLayer_SaveLayerStrategy

     };

     virtual void willSave(SaveFlags);

     virtual SaveLayerStrategy willSaveLayer(const SkRect*, const SkPaint*, SaveFlags);

     virtual void willRestore();

     virtual void didTranslate(SkScalar, SkScalar);

     virtual void didScale(SkScalar, SkScalar);

     virtual void didRotate(SkScalar);

     virtual void didSkew(SkScalar, SkScalar);

     virtual void didConcat(const SkMatrix&);

     virtual void didSetMatrix(const SkMatrix&);

     virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&);

     enum ClipEdgeStyle {

         kHard_ClipEdgeStyle,

         kSoft_ClipEdgeStyle

     };

     virtual void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle);

     virtual void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle);

     virtual void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle);

     virtual void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op);

     // Returns the canvas to be used by DrawIter. Default implementation

     // returns this. Subclasses that encapsulate an indirect canvas may

     // need to overload this method. The impl must keep track of this, as it

     // is not released or deleted by the caller.

     virtual SkCanvas* canvasForDrawIter();

     // Clip rectangle bounds. Called internally by saveLayer.

     // returns false if the entire rectangle is entirely clipped out

     // If non-NULL, The imageFilter parameter will be used to expand the clip

     // and offscreen bounds for any margin required by the filter DAG.

     bool clipRectBounds(const SkRect* bounds, SaveFlags flags,

                         SkIRect* intersection,

                         const SkImageFilter* imageFilter = NULL);

     // Called by child classes that override clipPath and clipRRect to only

     // track fast conservative clip bounds, rather than exact clips.

     void updateClipConservativelyUsingBounds(const SkRect&, SkRegion::Op,

                                              bool inverseFilled);

     // notify our surface (if we have one) that we are about to draw, so it

     // can perform copy-on-write or invalidate any cached images

     void predrawNotify();

     virtual void onPushCull(const SkRect& cullRect);

     virtual void onPopCull();

 private:

     class MCRec;

     SkClipStack fClipStack;

     SkDeque     fMCStack;

     // points to top of stack

     MCRec*      fMCRec;

     // the first N recs that can fit here mean we won't call malloc

     uint32_t    fMCRecStorage[32];

     SkBounder*  fBounder;

     int         fSaveLayerCount;    // number of successful saveLayer calls

     int         fCullCount;         // number of active culls

     SkMetaData* fMetaData;

     SkSurface_Base*  fSurfaceBase;

     SkSurface_Base* getSurfaceBase() const { return fSurfaceBase; }

     void setSurfaceBase(SkSurface_Base* sb) {

         fSurfaceBase = sb;

     }

     friend class SkSurface_Base;

     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()

     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.

      */

     SkBaseDevice* setRootDevice(SkBaseDevice* device);

     /**

      * Gets the size/origin of the top level layer in global canvas coordinates. We don't want this

      * to be public because it exposes decisions about layer sizes that are internal to the canvas.

      */

     SkISize getTopLayerSize() const;

     SkIPoint getTopLayerOrigin() const;

     // internal methods are not virtual, so they can safely be called by other

     // canvas apis, without confusing subclasses (like SkPictureRecording)

     void internalDrawBitmap(const SkBitmap&, const SkMatrix& m, const SkPaint* paint);

     void internalDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,

                                 const SkRect& dst, const SkPaint* paint,

                                 DrawBitmapRectFlags flags);

     void internalDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,

                                 const SkRect& dst, const SkPaint* paint);

     void internalDrawPaint(const SkPaint& paint);

     int internalSaveLayer(const SkRect* bounds, const SkPaint* paint,

                           SaveFlags, bool justForImageFilter, SaveLayerStrategy strategy);

     void internalDrawDevice(SkBaseDevice*, int x, int y, const SkPaint*);

     // 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);

     /*  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) {

             if (!this->getClipBounds(&fCachedLocalClipBounds)) {

                 fCachedLocalClipBounds.setEmpty();

             }

             fCachedLocalClipBoundsDirty = false;

         }

         return fCachedLocalClipBounds;

     }

     class AutoValidateClip : ::SkNoncopyable {

     public:

         explicit AutoValidateClip(SkCanvas* canvas) : fCanvas(canvas) {

             fCanvas->validateClip();

         }

         ~AutoValidateClip() { fCanvas->validateClip(); }

     private:

         const SkCanvas* fCanvas;

     };

 #ifdef SK_DEBUG

     void validateClip() const;

 #else

     void validateClip() const {}

 #endif

     typedef SkRefCnt INHERITED;

 };

 /** Stack helper class to automatically call restoreToCount() on the canvas

     when this object goes out of scope. Use this to guarantee that the canvas

     is restored to a known state.

 */

 class SkAutoCanvasRestore : SkNoncopyable {

 public:

     SkAutoCanvasRestore(SkCanvas* canvas, bool doSave) : fCanvas(canvas), fSaveCount(0) {

         if (fCanvas) {

             fSaveCount = canvas->getSaveCount();

             if (doSave) {

                 canvas->save();

             }

         }

     }

     ~SkAutoCanvasRestore() {

         if (fCanvas) {

             fCanvas->restoreToCount(fSaveCount);

         }

     }

     /**

      *  Perform the restore now, instead of waiting for the destructor. Will

      *  only do this once.

      */

     void restore() {

         if (fCanvas) {

             fCanvas->restoreToCount(fSaveCount);

             fCanvas = NULL;

         }

     }

 private:

     SkCanvas*   fCanvas;

     int         fSaveCount;

 };

 #define SkAutoCanvasRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoCanvasRestore)

 /** Stack helper class to automatically open and close a comment block

  */

 class SkAutoCommentBlock : SkNoncopyable {

 public:

     SkAutoCommentBlock(SkCanvas* canvas, const char* description) {

         fCanvas = canvas;

         if (NULL != fCanvas) {

             fCanvas->beginCommentGroup(description);

         }

     }

     ~SkAutoCommentBlock() {

         if (NULL != fCanvas) {

             fCanvas->endCommentGroup();

         }

     }

 private:

     SkCanvas* fCanvas;

 };

 #define SkAutoCommentBlock(...) SK_REQUIRE_LOCAL_VAR(SkAutoCommentBlock)

 /**

  *  If the caller wants read-only access to the pixels in a canvas, it can just

  *  call canvas->peekPixels(), since that is the fastest way to "peek" at the

  *  pixels on a raster-backed canvas.

  *

  *  If the canvas has pixels, but they are not readily available to the CPU

  *  (e.g. gpu-backed), then peekPixels() will fail, but readPixels() will

  *  succeed (though be slower, since it will return a copy of the pixels).

  *

  *  SkAutoROCanvasPixels encapsulates these two techniques, trying first to call

  *  peekPixels() (for performance), but if that fails, calling readPixels() and

  *  storing the copy locally.

  *

  *  The caller must respect the restrictions associated with peekPixels(), since

  *  that may have been called: The returned information is invalidated if...

  *      - any API is called on the canvas (or its parent surface if present)

  *      - the canvas goes out of scope

  */

 class SkAutoROCanvasPixels : SkNoncopyable {

 public:

     SkAutoROCanvasPixels(SkCanvas* canvas);

     // returns NULL on failure

     const void* addr() const { return fAddr; }

     // undefined if addr() == NULL

     size_t rowBytes() const { return fRowBytes; }

     // undefined if addr() == NULL

     const SkImageInfo& info() const { return fInfo; }

     // helper that, if returns true, installs the pixels into the bitmap. Note

     // that the bitmap may reference the address returned by peekPixels(), so

     // the caller must respect the restrictions associated with peekPixels().

     bool asROBitmap(SkBitmap*) const;

 private:

     SkBitmap    fBitmap;    // used if peekPixels() fails

     const void* fAddr;      // NULL on failure

     SkImageInfo fInfo;

     size_t      fRowBytes;

 };

 #endif