remove kRLE_Index8_Config from SkBitmap

include/core/SkBitmap.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 SkBitmap_DEFINED
@@ skipping 35 matching lines @@
          *  1-bit per pixel, (0 is transparent, 1 is opaque)
          *  Valid as a destination (target of a canvas), but not valid as a src.
          *  i.e. you can draw into a 1-bit bitmap, but you cannot draw from one.
          */
         kA1_Config,
         kA8_Config,         //!< 8-bits per pixel, with only alpha specified (0 is transparent, 0xFF is opaque)
         kIndex8_Config,     //!< 8-bits per pixel, using SkColorTable to specify the colors
         kRGB_565_Config,    //!< 16-bits per pixel, (see SkColorPriv.h for packing)
         kARGB_4444_Config,  //!< 16-bits per pixel, (see SkColorPriv.h for packing)
         kARGB_8888_Config,  //!< 32-bits per pixel, (see SkColorPriv.h for packing)
-        /**
-         *  Custom compressed format, not supported on all platforms.
-         *  Cannot be used as a destination (target of a canvas).
-         *  i.e. you may be able to draw from one, but you cannot draw into one.
-         */
-        kRLE_Index8_Config,
     };
     
     // do not add this to the Config enum, otherwise the compiler will let us
     // pass this as a valid parameter for Config.
     enum {
-        kConfigCount = kRLE_Index8_Config + 1
+        kConfigCount = kARGB_8888_Config + 1
     };
 
     /**
      *  Default construct creates a bitmap with zero width and height, and no pixels.
      *  Its config is set to kNo_Config.
      */
     SkBitmap();
 
     /**
      *  Copy the settings from the src into this bitmap. If the src has pixels
@@ skipping 281 matching lines @@
      *  modifications will be lost when unlockPixels() is called.)
      */
     bool lockPixelsAreWritable() const;
 
     /** Call this to be sure that the bitmap is valid enough to be drawn (i.e.
         it has non-null pixels, and if required by its config, it has a
         non-null colortable. Returns true if all of the above are met.
     */
     bool readyToDraw() const {
         return this->getPixels() != NULL &&
-               ((this->config() != kIndex8_Config &&
-                 this->config() != kRLE_Index8_Config) ||
-                       fColorTable != NULL);
+               (this->config() != kIndex8_Config || NULL != fColorTable);
     }
 
     /** Returns the pixelRef's texture, or NULL
      */
     SkGpuTexture* getTexture() const;
 
     /** Return the bitmap's colortable, if it uses one (i.e. fConfig is
-        kIndex8_Config or kRLE_Index8_Config) and the pixels are locked.
+        kIndex8_Config) and the pixels are locked.
         Otherwise returns NULL. Does not affect the colortable's
         reference count.
     */
     SkColorTable* getColorTable() const { return fColorTable; }
 
     /** Returns a non-zero, unique value corresponding to the pixels in our
         pixelref. Each time the pixels are changed (and notifyPixelsChanged
         is called), a different generation ID will be returned. Finally, if
         their is no pixelRef then zero is returned.
     */
@@ skipping 413 matching lines @@
 
 // returns the address of the byte that contains the x coordinate
 inline uint8_t* SkBitmap::getAddr1(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(fConfig == kA1_Config);
     SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
     return (uint8_t*)fPixels + y * fRowBytes + (x >> 3);
 }
 
 #endif