SkImage::NewFromBitmap works with Index8

src/image/SkImage_Raster.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImage_Base.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorTable.h"
 #include "SkData.h"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
 
 class SkImage_Raster : public SkImage_Base {
 public:
-    static bool ValidArgs(const Info& info, size_t rowBytes, SkColorTable* ctable,
+    static bool ValidArgs(const Info& info, size_t rowBytes, bool hasColorTable,
                           size_t* minSize) {
         const int maxDimension = SK_MaxS32 >> 2;
 
         if (info.width() <= 0 || info.height() <= 0) {
             return false;
         }
         if (info.width() > maxDimension || info.height() > maxDimension) {
             return false;
         }
         if ((unsigned)info.colorType() > (unsigned)kLastEnum_SkColorType) {
             return false;
         }
         if ((unsigned)info.alphaType() > (unsigned)kLastEnum_SkAlphaType) {
             return false;
         }
 
         if (kUnknown_SkColorType == info.colorType()) {
             return false;
         }
 
         const bool needsCT = kIndex_8_SkColorType == info.colorType();
-        const bool hasCT = nullptr != ctable;
-        if (needsCT != hasCT) {
+        if (needsCT != hasColorTable) {
             return false;
         }
 
         if (rowBytes < SkImageMinRowBytes(info)) {
             return false;
         }
 
         size_t size = info.getSafeSize(rowBytes);
         if (0 == size) {
             return false;
@@ skipping 152 matching lines @@
     surface->getCanvas()->drawImage(this, SkIntToScalar(-subset.x()), SkIntToScalar(-subset.y()),
                                     nullptr);
     return surface->newImageSnapshot();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImage* SkImage::NewRasterCopy(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                 SkColorTable* ctable) {
     size_t size;
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, ctable, &size) || !pixels) {
+    if (!SkImage_Raster::ValidArgs(info, rowBytes, ctable != nullptr, &size) || !pixels) {
         return nullptr;
     }
 
     // Here we actually make a copy of the caller's pixel data
     SkAutoDataUnref data(SkData::NewWithCopy(pixels, size));
     return new SkImage_Raster(info, data, rowBytes, ctable, nullptr);
 }
 
 
 SkImage* SkImage::NewRasterData(const SkImageInfo& info, SkData* data, size_t rowBytes) {
     size_t size;
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, nullptr, &size) || !data) {
+    if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !data) {
         return nullptr;
     }
 
     // did they give us enough data?
     if (data->size() < size) {
         return nullptr;
     }
 
     SkColorTable* ctable = nullptr;
     return new SkImage_Raster(info, data, rowBytes, ctable, nullptr);
 }
 
 SkImage* SkImage::NewFromRaster(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                 RasterReleaseProc proc, ReleaseContext ctx) {
     size_t size;
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, nullptr, &size) || !pixels) {
+    if (!SkImage_Raster::ValidArgs(info, rowBytes, false, &size) || !pixels) {
         return nullptr;
     }
 
     SkColorTable* ctable = nullptr;
     SkAutoDataUnref data(SkData::NewWithProc(pixels, size, proc, ctx));
     return new SkImage_Raster(info, data, rowBytes, ctable, nullptr);
 }
 
 SkImage* SkNewImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr,
                                 const SkIPoint& pixelRefOrigin, size_t rowBytes,
                                 const SkSurfaceProps* props) {
-    if (!SkImage_Raster::ValidArgs(info, rowBytes, nullptr, nullptr)) {
+    if (!SkImage_Raster::ValidArgs(info, rowBytes, false, nullptr)) {
         return nullptr;
     }
     return new SkImage_Raster(info, pr, pixelRefOrigin, rowBytes, props);
 }
 
 SkImage* SkNewImageFromRasterBitmap(const SkBitmap& bm, const SkSurfaceProps* props,
                                     ForceCopyMode forceCopy) {
     SkASSERT(nullptr == bm.getTexture());
 
-    if (!SkImage_Raster::ValidArgs(bm.info(), bm.rowBytes(), nullptr, nullptr)) {
+    bool hasColorTable = false;
+    if (kIndex_8_SkColorType == bm.colorType()) {
+        SkAutoLockPixels autoLockPixels(bm);
+        hasColorTable = bm.getColorTable() != nullptr;
+    }
+
+    if (!SkImage_Raster::ValidArgs(bm.info(), bm.rowBytes(), hasColorTable, nullptr)) {
         return nullptr;
     }
 
     SkImage* image = nullptr;
     if (kYes_ForceCopyMode == forceCopy || !bm.isImmutable()) {
         SkBitmap tmp(bm);
         tmp.lockPixels();
         if (tmp.getPixels()) {
             image = SkImage::NewRasterCopy(tmp.info(), tmp.getPixels(), tmp.rowBytes(),
                                            tmp.getColorTable());
@@ skipping 24 matching lines @@
         // pixelref since the caller might call setImmutable() themselves
         // (thus changing our state).
         if (fBitmap.isImmutable()) {
             bitmap->setInfo(fBitmap.info(), fBitmap.rowBytes());
             bitmap->setPixelRef(fBitmap.pixelRef(), fBitmap.pixelRefOrigin());
             return true;
         }
     }
     return this->INHERITED::onAsLegacyBitmap(bitmap, mode);
 }