Revert "Revert "change SkColorTable to be immutable""

src/images/SkImageDecoder_libpng.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkImageDecoder.h"
@@ skipping 630 matching lines @@
 
 typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
 
 bool SkPNGImageDecoder::decodePalette(png_structp png_ptr, png_infop info_ptr,
                                       bool *hasAlphap, bool *reallyHasAlphap,
                                       SkColorTable **colorTablep) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
     int numTrans;
-    bool reallyHasAlpha = false;
-    SkColorTable* colorTable = NULL;
 
     png_get_PLTE(png_ptr, info_ptr, &palette, &numPalette);
 
     /*  BUGGY IMAGE WORKAROUND
 
         We hit some images (e.g. fruit_.png) who contain bytes that are == colortable_count
         which is a problem since we use the byte as an index. To work around this we grow
         the colortable by 1 (if its < 256) and duplicate the last color into that slot.
     */
     int colorCount = numPalette + (numPalette < 256);
+    SkPMColor colorStorage[256];    // worst-case storage
+    SkPMColor* colorPtr = colorStorage;
 
-    colorTable = SkNEW_ARGS(SkColorTable, (colorCount));
-
-    SkPMColor* colorPtr = colorTable->lockColors();
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         png_get_tRNS(png_ptr, info_ptr, &trans, &numTrans, NULL);
         *hasAlphap = (numTrans > 0);
     } else {
         numTrans = 0;
-        colorTable->setFlags(colorTable->getFlags() | SkColorTable::kColorsAreOpaque_Flag);
     }
+
     // check for bad images that might make us crash
     if (numTrans > numPalette) {
         numTrans = numPalette;
     }
 
     int index = 0;
     int transLessThanFF = 0;
 
     // Choose which function to use to create the color table. If the final destination's
     // config is unpremultiplied, the color table will store unpremultiplied colors.
     PackColorProc proc;
     if (this->getRequireUnpremultipliedColors()) {
         proc = &SkPackARGB32NoCheck;
     } else {
         proc = &SkPreMultiplyARGB;
     }
     for (; index < numTrans; index++) {
         transLessThanFF |= (int)*trans - 0xFF;
         *colorPtr++ = proc(*trans++, palette->red, palette->green, palette->blue);
         palette++;
     }
-    reallyHasAlpha |= (transLessThanFF < 0);
+    bool reallyHasAlpha = (transLessThanFF < 0);
 
     for (; index < numPalette; index++) {
         *colorPtr++ = SkPackARGB32(0xFF, palette->red, palette->green, palette->blue);
         palette++;
     }
 
     // see BUGGY IMAGE WORKAROUND comment above
     if (numPalette < 256) {
         *colorPtr = colorPtr[-1];
     }
-    colorTable->unlockColors(true);
-    *colorTablep = colorTable;
+
+    SkAlphaType alphaType = kOpaque_SkAlphaType;
+    if (reallyHasAlpha) {
+        if (this->getRequireUnpremultipliedColors()) {
+            alphaType = kUnpremul_SkAlphaType;
+        } else {
+            alphaType = kPremul_SkAlphaType;
+        }
+    }
+
+    *colorTablep = SkNEW_ARGS(SkColorTable,
+                              (colorStorage, colorCount, alphaType));
     *reallyHasAlphap = reallyHasAlpha;
     return true;
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 
 bool SkPNGImageDecoder::onBuildTileIndex(SkStreamRewindable* sk_stream, int *width, int *height) {
     png_structp png_ptr;
     png_infop   info_ptr;
 
@@ skipping 524 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? SkNEW(SkPNGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libpng_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_png);
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);