remove all references to legacy Config8888

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
 
 #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"
 
-//#define SK_SUPPORT_LEGACY_READPIXELSCONFIG
-
-#ifdef SK_SUPPORT_LEGACY_READPIXELSCONFIG
-    #ifndef SK_SUPPORT_LEGACY_CONFIG8888
-        #define SK_SUPPORT_LEGACY_CONFIG8888
-    #endif
-#endif
-
 // if not defined, we always assume ClipToLayer for saveLayer()
 //#define SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
 
 
 //#define SK_SUPPORT_LEGACY_GETCLIPTYPE
 //#define SK_SUPPORT_LEGACY_GETTOTALCLIP
 //#define SK_SUPPORT_LEGACY_GETTOPDEVICE
 
 class SkBounder;
 class SkBaseDevice;
@@ skipping 191 matching lines @@
      *  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);
 
-#ifdef SK_SUPPORT_LEGACY_CONFIG8888
-    /**
-     * 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
-    };
-#endif
-
-#ifdef SK_SUPPORT_LEGACY_READPIXELSCONFIG
-    /**
-     *  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);
-#endif
-
     /**
      *  Copy the pixels from the base-layer into the specified buffer (pixels + rowBytes),
      *  converting them into the requested format (SkImageInfo). The base-layer pixels are read
      *  starting at the specified (x,y) location in the coordinate system of the base-layer.
      *
      *  The specified ImageInfo and (x,y) offset specifies a source rectangle
      *
      *      srcR(x, y, info.width(), info.height());
      *
      *  SrcR is intersected with the bounds of the base-layer. If this intersection is not empty,
@@ skipping 512 matching lines @@
     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
+        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
     */
     virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                             const SkPaint* paint = NULL);
 
@@ skipping 642 matching lines @@
     bool asROBitmap(SkBitmap*) const;
 
 private:
     SkBitmap    fBitmap;    // used if peekPixels() fails
     const void* fAddr;      // NULL on failure
     SkImageInfo fInfo;
     size_t      fRowBytes;
 };
 
 #endif