remove (dead) SK_SUPPORT_LEGACY_DRAWDATA and SK_SUPPORT_LEGACY_CANVAS_VIRTUAL

include/core/SkCanvas.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 18 matching lines @@
 class SkPicture;
 class SkRRect;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 class GrContext;
 class GrRenderTarget;
 
 class SkCanvasState;
 
-#ifdef SK_SUPPORT_LEGACY_CANVAS_VIRTUAL
-    #define SK_LEGACY_CANVAS_VIRTUAL    virtual
-#else
-    #define SK_LEGACY_CANVAS_VIRTUAL
-#endif
-
 /** \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)
@@ skipping 552 matching lines @@
      * to optimize performance on subsequent draws. Thus, if you call this and then
      * never draw to the canvas subsequently you may pay a perfomance penalty.
      */
     void discard() { this->onDiscard(); }
 
     /**
      *  Fill the entire canvas' bitmap (restricted to the current clip) with the
      *  specified paint.
      *  @param paint    The paint used to fill the canvas
      */
-    SK_LEGACY_CANVAS_VIRTUAL void drawPaint(const SkPaint& paint);
+    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
     };
 
@@ skipping 11 matching lines @@
         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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawPoints(PointMode mode, size_t count, const SkPoint pts[],
-                                             const SkPaint& paint);
+    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
@@ skipping 10 matching lines @@
         @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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawRect(const SkRect& rect, const SkPaint& paint);
+    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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawOval(const SkRect& oval, const SkPaint&);
+    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
      */
-    SK_LEGACY_CANVAS_VIRTUAL void drawRRect(const SkRRect& rrect, const SkPaint& paint);
+    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.
@@ skipping 27 matching lines @@
         @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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawPath(const SkPath& path, const SkPaint& paint);
+    void drawPath(const SkPath& path, const SkPaint& paint);
 
     /** Draw the specified image, with its top/left corner at (x,y), using the
         specified paint, transformed by the current matrix.
 
         @param image    The image to be drawn
         @param left     The position of the left side of the image being drawn
         @param top      The position of the top side of the image being drawn
         @param paint    The paint used to draw the image, or NULL
      */
-    SK_LEGACY_CANVAS_VIRTUAL void drawImage(const SkImage* image, SkScalar left, SkScalar top,
-                           const SkPaint* paint = NULL);
+    void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = NULL);
     /** Draw the specified image, with the specified matrix applied (before the
         canvas' matrix is applied).
 
         @param image   The image to be drawn
         @param src      Optional: specify the subset of the image to be drawn
         @param dst      The destination rectangle where the scaled/translated
                         image will be drawn
         @param paint    The paint used to draw the image, or NULL
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawImageRect(const SkImage* image, const SkRect* src,
-                               const SkRect& dst,
-                               const SkPaint* paint = NULL);
+    void drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
+                       const SkPaint* paint = NULL);
 
     /** 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 kAlpha_8_SkColorType. 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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-                            const SkPaint* paint = NULL);
+    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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
-                                      const SkRect& dst,
-                                      const SkPaint* paint = NULL,
-                                      DrawBitmapRectFlags flags = kNone_DrawBitmapRectFlag);
+    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;
@@ skipping 12 matching lines @@
      *  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
      */
-    SK_LEGACY_CANVAS_VIRTUAL void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
-                                const SkRect& dst, const SkPaint* paint = NULL);
+    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
     */
-    SK_LEGACY_CANVAS_VIRTUAL void drawSprite(const SkBitmap& bitmap, int left, int top,
-                            const SkPaint* paint = NULL);
+    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)
     */
     void drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
@@ skipping 101 matching lines @@
                       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.
     */
-    SK_LEGACY_CANVAS_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);
+    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);
 
     /**
      Draw a cubic coons patch
 
      @param cubic specifies the 4 bounding cubic bezier curves of a patch with clockwise order
                     starting at the top left corner.
      @param colors specifies the colors for the corners which will be bilerp across the patch,
                     their order is clockwise starting at the top left corner.
      @param texCoords specifies the texture coordinates that will be bilerp across the patch,
                     their order is the same as the colors.
      @param xmode specifies how are the colors and the textures combined if both of them are
                     present.
      @param paint Specifies the shader/texture if present.
      */
     void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
                    const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
 
     void EXPERIMENTAL_drawDrawable(SkCanvasDrawable*);
 
-#ifdef SK_SUPPORT_LEGACY_DRAWDATA
-    /** 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*/) {}
-#endif
-
     /** 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
     }
@@ skipping 460 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     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;
 };
 
 #endif