Revert "SkBitmap now really stores SkImageInfo -- config is just a ruse"

src/core/SkBitmap.cpp

 
 /*
  * Copyright 2008 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 "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkFlattenable.h"
 #include "SkImagePriv.h"
 #include "SkMallocPixelRef.h"
 #include "SkMask.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkPixelRef.h"
 #include "SkThread.h"
 #include "SkUnPreMultiply.h"
 #include "SkUtils.h"
 #include "SkValidationUtils.h"
 #include "SkPackBits.h"
 #include <new>
 
-static bool reset_return_false(SkBitmap* bm) {
-    bm->reset();
-    return false;
-}
-
 struct MipLevel {
     void*       fPixels;
     uint32_t    fRowBytes;
     uint32_t    fWidth, fHeight;
 };
 
 struct SkBitmap::MipMap : SkNoncopyable {
     int32_t fRefCnt;
     int     fLevelCount;
 //  MipLevel    fLevel[fLevelCount];
@@ skipping 81 matching lines @@
     return *this;
 }
 
 void SkBitmap::swap(SkBitmap& other) {
     SkTSwap(fColorTable, other.fColorTable);
     SkTSwap(fPixelRef, other.fPixelRef);
     SkTSwap(fPixelRefOrigin, other.fPixelRefOrigin);
     SkTSwap(fPixelLockCount, other.fPixelLockCount);
     SkTSwap(fMipMap, other.fMipMap);
     SkTSwap(fPixels, other.fPixels);
-    SkTSwap(fInfo, other.fInfo);
     SkTSwap(fRowBytes, other.fRowBytes);
+    SkTSwap(fWidth, other.fWidth);
+    SkTSwap(fHeight, other.fHeight);
+    SkTSwap(fConfig, other.fConfig);
+    SkTSwap(fAlphaType, other.fAlphaType);
     SkTSwap(fFlags, other.fFlags);
+    SkTSwap(fBytesPerPixel, other.fBytesPerPixel);
 
     SkDEBUGCODE(this->validate();)
 }
 
 void SkBitmap::reset() {
     this->freePixels();
     sk_bzero(this, sizeof(*this));
 }
 
-SkBitmap::Config SkBitmap::config() const {
-    return SkColorTypeToBitmapConfig(fInfo.colorType());
-}
-
 int SkBitmap::ComputeBytesPerPixel(SkBitmap::Config config) {
     int bpp;
     switch (config) {
         case kNo_Config:
             bpp = 0;   // not applicable
             break;
         case kA8_Config:
         case kIndex8_Config:
             bpp = 1;
             break;
         case kRGB_565_Config:
         case kARGB_4444_Config:
             bpp = 2;
             break;
         case kARGB_8888_Config:
             bpp = 4;
             break;
         default:
             SkDEBUGFAIL("unknown config");
             bpp = 0;   // error
             break;
     }
     return bpp;
 }
 
 size_t SkBitmap::ComputeRowBytes(Config c, int width) {
-    return SkColorTypeMinRowBytes(SkBitmapConfigToColorType(c), width);
+    if (width < 0) {
+        return 0;
+    }
+
+    int64_t rowBytes = 0;
+
+    switch (c) {
+        case kNo_Config:
+            break;
+        case kA8_Config:
+        case kIndex8_Config:
+            rowBytes = width;
+            break;
+        case kRGB_565_Config:
+        case kARGB_4444_Config:
+            // assign and then shift, so we don't overflow int
+            rowBytes = width;
+            rowBytes <<= 1;
+            break;
+        case kARGB_8888_Config:
+            // assign and then shift, so we don't overflow int
+            rowBytes = width;
+            rowBytes <<= 2;
+            break;
+        default:
+            SkDEBUGFAIL("unknown config");
+            break;
+    }
+    return sk_64_isS32(rowBytes) ? sk_64_asS32(rowBytes) : 0;
 }
 
 int64_t SkBitmap::ComputeSize64(Config config, int width, int height) {
-    SkColorType ct = SkBitmapConfigToColorType(config);
-    int64_t rowBytes = sk_64_mul(SkColorTypeBytesPerPixel(ct), width);
+    int64_t rowBytes = sk_64_mul(ComputeBytesPerPixel(config), width);
     return rowBytes * height;
 }
 
 size_t SkBitmap::ComputeSize(Config c, int width, int height) {
     int64_t size = SkBitmap::ComputeSize64(c, width, height);
     return sk_64_isS32(size) ? sk_64_asS32(size) : 0;
 }
 
 int64_t SkBitmap::ComputeSafeSize64(Config config,
                                     uint32_t width,
                                     uint32_t height,
                                     size_t rowBytes) {
-    SkImageInfo info = SkImageInfo::Make(width, height,
-                                         SkBitmapConfigToColorType(config),
-                                         kPremul_SkAlphaType);
-    return info.getSafeSize64(rowBytes);
+    int64_t safeSize = 0;
+    if (height > 0) {
+        int64_t lastRow = sk_64_mul(ComputeBytesPerPixel(config), width);
+        safeSize = sk_64_mul(height - 1, rowBytes) + lastRow;
+    }
+    SkASSERT(safeSize >= 0);
+    return safeSize;
 }
 
 size_t SkBitmap::ComputeSafeSize(Config config,
                                  uint32_t width,
                                  uint32_t height,
                                  size_t rowBytes) {
     int64_t safeSize = ComputeSafeSize64(config, width, height, rowBytes);
     int32_t safeSize32 = (int32_t)safeSize;
 
     if (safeSize32 != safeSize) {
         safeSize32 = 0;
     }
     return safeSize32;
 }
 
 void SkBitmap::getBounds(SkRect* bounds) const {
     SkASSERT(bounds);
     bounds->set(0, 0,
-                SkIntToScalar(fInfo.fWidth), SkIntToScalar(fInfo.fHeight));
+                SkIntToScalar(fWidth), SkIntToScalar(fHeight));
 }
 
 void SkBitmap::getBounds(SkIRect* bounds) const {
     SkASSERT(bounds);
-    bounds->set(0, 0, fInfo.fWidth, fInfo.fHeight);
+    bounds->set(0, 0, fWidth, fHeight);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static bool validate_alphaType(SkColorType colorType, SkAlphaType alphaType,
+static bool validate_alphaType(SkBitmap::Config config, SkAlphaType alphaType,
                                SkAlphaType* canonical = NULL) {
-    switch (colorType) {
-        case kUnknown_SkColorType:
+    switch (config) {
+        case SkBitmap::kNo_Config:
             alphaType = kIgnore_SkAlphaType;
             break;
-        case kAlpha_8_SkColorType:
+        case SkBitmap::kA8_Config:
             if (kUnpremul_SkAlphaType == alphaType) {
                 alphaType = kPremul_SkAlphaType;
             }
             // fall-through
-        case kIndex_8_SkColorType:
-        case kARGB_4444_SkColorType:
-        case kRGBA_8888_SkColorType:
-        case kBGRA_8888_SkColorType:
+        case SkBitmap::kIndex8_Config:
+        case SkBitmap::kARGB_4444_Config:
+        case SkBitmap::kARGB_8888_Config:
             if (kIgnore_SkAlphaType == alphaType) {
                 return false;
             }
             break;
-        case kRGB_565_SkColorType:
+        case SkBitmap::kRGB_565_Config:
             alphaType = kOpaque_SkAlphaType;
             break;
         default:
             return false;
     }
     if (canonical) {
         *canonical = alphaType;
     }
     return true;
 }
 
-bool SkBitmap::setConfig(const SkImageInfo& info, size_t rowBytes) {
-    // require that rowBytes fit in 31bits
-    int64_t mrb = info.minRowBytes64();
-    if ((int32_t)mrb != mrb) {
-        return reset_return_false(this);
-    }
-    if ((int64_t)rowBytes != (int32_t)rowBytes) {
-        return reset_return_false(this);
-    }
-
-    if (info.width() < 0 || info.height() < 0) {
-        return reset_return_false(this);
-    }
-
-    if (kUnknown_SkColorType == info.colorType()) {
-        rowBytes = 0;
-    } else if (0 == rowBytes) {
-        rowBytes = (size_t)mrb;
-    } else if (rowBytes < info.minRowBytes()) {
-        return reset_return_false(this);
-    }
-
-    this->freePixels();
-
-    fInfo = info;
-    fRowBytes = SkToU32(rowBytes);
-    return true;
-}
-
 bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes,
                          SkAlphaType alphaType) {
-    SkColorType ct = SkBitmapConfigToColorType(config);
-    return this->setConfig(SkImageInfo::Make(width, height, ct, alphaType),
-                           rowBytes);
+    if ((width | height) < 0) {
+        goto BAD_CONFIG;
+    }
+    if (rowBytes == 0) {
+        rowBytes = SkBitmap::ComputeRowBytes(config, width);
+        if (0 == rowBytes && kNo_Config != config && width > 0) {
+            goto BAD_CONFIG;
+        }
+    }
+
+    if (!validate_alphaType(config, alphaType, &alphaType)) {
+        goto BAD_CONFIG;
+    }
+
+    this->freePixels();
+
+    fConfig     = SkToU8(config);
+    fAlphaType  = SkToU8(alphaType);
+    fWidth      = width;
+    fHeight     = height;
+    fRowBytes   = SkToU32(rowBytes);
+
+    fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(config);
+
+    SkDEBUGCODE(this->validate();)
+    return true;
+
+    // if we got here, we had an error, so we reset the bitmap to empty
+BAD_CONFIG:
+    this->reset();
+    return false;
+}
+
+bool SkBitmap::setConfig(const SkImageInfo& info, size_t rowBytes) {
+    return this->setConfig(SkImageInfoToBitmapConfig(info), info.fWidth,
+                           info.fHeight, rowBytes, info.fAlphaType);
 }
 
 bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
-    if (!validate_alphaType(fInfo.fColorType, alphaType, &alphaType)) {
+    if (!validate_alphaType(this->config(), alphaType, &alphaType)) {
         return false;
     }
-    if (fInfo.fAlphaType != alphaType) {
-        fInfo.fAlphaType = alphaType;
+    if (fAlphaType != alphaType) {
+        fAlphaType = SkToU8(alphaType);
         if (fPixelRef) {
             fPixelRef->changeAlphaType(alphaType);
         }
     }
     return true;
 }
 
 void SkBitmap::updatePixelsFromRef() const {
     if (NULL != fPixelRef) {
         if (fPixelLockCount > 0) {
             SkASSERT(fPixelRef->isLocked());
 
             void* p = fPixelRef->pixels();
             if (NULL != p) {
                 p = (char*)p
                     + fPixelRefOrigin.fY * fRowBytes
-                    + fPixelRefOrigin.fX * fInfo.bytesPerPixel();
+                    + fPixelRefOrigin.fX * fBytesPerPixel;
             }
             fPixels = p;
             fColorTable = fPixelRef->colorTable();
         } else {
             SkASSERT(0 == fPixelLockCount);
             fPixels = NULL;
             fColorTable = NULL;
         }
     }
 }
@@ skipping 19 matching lines @@
         case SkBitmap::kNo_Config:
         default:
             return false;
     }
     if (ctOut) {
         *ctOut = ct;
     }
     return true;
 }
 
+bool SkBitmap::asImageInfo(SkImageInfo* info) const {
+    SkColorType ct;
+    if (!config_to_colorType(this->config(), &ct)) {
+        return false;
+    }
+    if (info) {
+        info->fWidth = fWidth;
+        info->fHeight = fHeight;
+        info->fAlphaType = this->alphaType();
+        info->fColorType = ct;
+    }
+    return true;
+}
+
 SkPixelRef* SkBitmap::setPixelRef(SkPixelRef* pr, int dx, int dy) {
 #ifdef SK_DEBUG
     if (pr) {
         SkImageInfo info;
         if (this->asImageInfo(&info)) {
             const SkImageInfo& prInfo = pr->info();
             SkASSERT(info.fWidth <= prInfo.fWidth);
             SkASSERT(info.fHeight <= prInfo.fHeight);
             SkASSERT(info.fColorType == prInfo.fColorType);
             switch (prInfo.fAlphaType) {
                 case kIgnore_SkAlphaType:
-                    SkASSERT(fInfo.fAlphaType == kIgnore_SkAlphaType);
+                    SkASSERT(fAlphaType == kIgnore_SkAlphaType);
                     break;
                 case kOpaque_SkAlphaType:
                 case kPremul_SkAlphaType:
                     SkASSERT(info.fAlphaType == kOpaque_SkAlphaType ||
                              info.fAlphaType == kPremul_SkAlphaType);
                     break;
                 case kUnpremul_SkAlphaType:
                     SkASSERT(info.fAlphaType == kOpaque_SkAlphaType ||
                              info.fAlphaType == kUnpremul_SkAlphaType);
                     break;
@@ skipping 77 matching lines @@
     HeapAllocator stdalloc;
 
     if (NULL == allocator) {
         allocator = &stdalloc;
     }
     return allocator->allocPixelRef(this, ctable);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static bool reset_return_false(SkBitmap* bm) {
+    bm->reset();
+    return false;
+}
+
 bool SkBitmap::allocPixels(const SkImageInfo& info, SkPixelRefFactory* factory,
                            SkColorTable* ctable) {
     if (kIndex_8_SkColorType == info.fColorType && NULL == ctable) {
         return reset_return_false(this);
     }
     if (!this->setConfig(info)) {
         return reset_return_false(this);
     }
 
     SkMallocPixelRef::PRFactory defaultFactory;
@@ skipping 35 matching lines @@
 }
 
 bool SkBitmap::allocConfigPixels(Config config, int width, int height,
                                  bool isOpaque) {
     SkColorType ct;
     if (!config_to_colorType(config, &ct)) {
         return false;
     }
 
     SkAlphaType at = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+    if (!validate_alphaType(config, at, &at)) {
+        return false;
+    }
+
     return this->allocPixels(SkImageInfo::Make(width, height, ct, at));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkBitmap::freePixels() {
     // if we're gonna free the pixels, we certainly need to free the mipmap
     this->freeMipMap();
 
     if (NULL != fPixelRef) {
@@ skipping 51 matching lines @@
     }
 
     dst->setPixelRef(pr)->unref();
     // since we're already allocated, we lockPixels right away
     dst->lockPixels();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+size_t SkBitmap::getSafeSize() const {
+    // This is intended to be a size_t version of ComputeSafeSize64(), just
+    // faster. The computation is meant to be identical.
+    return (fHeight ? ((fHeight - 1) * fRowBytes) +
+            ComputeRowBytes(this->config(), fWidth): 0);
+}
+
 bool SkBitmap::copyPixelsTo(void* const dst, size_t dstSize,
                             size_t dstRowBytes, bool preserveDstPad) const {
 
     if (0 == dstRowBytes) {
         dstRowBytes = fRowBytes;
     }
 
-    if (dstRowBytes < fInfo.minRowBytes() ||
-        dst == NULL || (getPixels() == NULL && pixelRef() == NULL)) {
+    if (dstRowBytes < ComputeRowBytes(this->config(), fWidth) ||
+        dst == NULL || (getPixels() == NULL && pixelRef() == NULL))
         return false;
-    }
 
     if (!preserveDstPad && static_cast<uint32_t>(dstRowBytes) == fRowBytes) {
         size_t safeSize = this->getSafeSize();
         if (safeSize > dstSize || safeSize == 0)
             return false;
         else {
             SkAutoLockPixels lock(*this);
             // This implementation will write bytes beyond the end of each row,
             // excluding the last row, if the bitmap's stride is greater than
             // strictly required by the current config.
             memcpy(dst, getPixels(), safeSize);
 
             return true;
         }
     } else {
         // If destination has different stride than us, then copy line by line.
-        if (fInfo.getSafeSize(dstRowBytes) > dstSize) {
+        if (ComputeSafeSize(this->config(), fWidth, fHeight, dstRowBytes) >
+            dstSize)
             return false;
-        } else {
+        else {
             // Just copy what we need on each line.
-            size_t rowBytes = fInfo.minRowBytes();
+            size_t rowBytes = ComputeRowBytes(this->config(), fWidth);
             SkAutoLockPixels lock(*this);
             const uint8_t* srcP = reinterpret_cast<const uint8_t*>(getPixels());
             uint8_t* dstP = reinterpret_cast<uint8_t*>(dst);
-            for (int row = 0; row < fInfo.fHeight;
+            for (uint32_t row = 0; row < fHeight;
                  row++, srcP += fRowBytes, dstP += dstRowBytes) {
                 memcpy(dstP, srcP, rowBytes);
             }
 
             return true;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 23 matching lines @@
     }
 }
 
 void* SkBitmap::getAddr(int x, int y) const {
     SkASSERT((unsigned)x < (unsigned)this->width());
     SkASSERT((unsigned)y < (unsigned)this->height());
 
     char* base = (char*)this->getPixels();
     if (base) {
         base += y * this->rowBytes();
-        switch (this->colorType()) {
-            case kRGBA_8888_SkColorType:
-            case kBGRA_8888_SkColorType:
+        switch (this->config()) {
+            case SkBitmap::kARGB_8888_Config:
                 base += x << 2;
                 break;
-            case kARGB_4444_SkColorType:
-            case kRGB_565_SkColorType:
+            case SkBitmap::kARGB_4444_Config:
+            case SkBitmap::kRGB_565_Config:
                 base += x << 1;
                 break;
-            case kAlpha_8_SkColorType:
-            case kIndex_8_SkColorType:
+            case SkBitmap::kA8_Config:
+            case SkBitmap::kIndex8_Config:
                 base += x;
                 break;
+                break;
             default:
                 SkDEBUGFAIL("Can't return addr for config");
                 base = NULL;
                 break;
         }
     }
     return base;
 }
 
 SkColor SkBitmap::getColor(int x, int y) const {
@@ skipping 117 matching lines @@
                              U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
 #ifdef SK_DEBUG
     SkDEBUGCODE(this->validate();)
     SkASSERT(!area.isEmpty());
     {
         SkIRect total = { 0, 0, this->width(), this->height() };
         SkASSERT(total.contains(area));
     }
 #endif
 
-    switch (fInfo.colorType()) {
-        case kUnknown_SkColorType:
-        case kIndex_8_SkColorType:
-            return; // can't erase
-        default:
-            break;
+    if (kNo_Config == fConfig || kIndex8_Config == fConfig) {
+        return;
     }
 
     SkAutoLockPixels alp(*this);
     // perform this check after the lock call
     if (!this->readyToDraw()) {
         return;
     }
 
     int height = area.height();
     const int width = area.width();
     const int rowBytes = fRowBytes;
 
     // make rgb premultiplied
     if (255 != a) {
         r = SkAlphaMul(r, a);
         g = SkAlphaMul(g, a);
         b = SkAlphaMul(b, a);
     }
 
-    switch (this->colorType()) {
-        case kAlpha_8_SkColorType: {
+    switch (fConfig) {
+        case kA8_Config: {
             uint8_t* p = this->getAddr8(area.fLeft, area.fTop);
             while (--height >= 0) {
                 memset(p, a, width);
                 p += rowBytes;
             }
             break;
         }
-        case kARGB_4444_SkColorType:
-        case kRGB_565_SkColorType: {
+        case kARGB_4444_Config:
+        case kRGB_565_Config: {
             uint16_t* p = this->getAddr16(area.fLeft, area.fTop);;
             uint16_t v;
 
-            if (kARGB_4444_SkColorType == this->colorType()) {
+            if (kARGB_4444_Config == fConfig) {
                 v = pack_8888_to_4444(a, r, g, b);
             } else {
                 v = SkPackRGB16(r >> (8 - SK_R16_BITS),
                                 g >> (8 - SK_G16_BITS),
                                 b >> (8 - SK_B16_BITS));
             }
             while (--height >= 0) {
                 sk_memset16(p, v, width);
                 p = (uint16_t*)((char*)p + rowBytes);
             }
             break;
         }
-        case kPMColor_SkColorType: {
-            // what to do about BGRA or RGBA (which ever is != PMColor ?
-            // for now we don't support them.
+        case kARGB_8888_Config: {
             uint32_t* p = this->getAddr32(area.fLeft, area.fTop);
             uint32_t  v = SkPackARGB32(a, r, g, b);
 
             while (--height >= 0) {
                 sk_memset32(p, v, width);
                 p = (uint32_t*)((char*)p + rowBytes);
             }
             break;
         }
-        default:
-            return; // no change, so don't call notifyPixelsChanged()
     }
 
     this->notifyPixelsChanged();
 }
 
 void SkBitmap::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
     SkIRect area = { 0, 0, this->width(), this->height() };
     if (!area.isEmpty()) {
         this->internalErase(area, a, r, g, b);
     }
@@ skipping 95 matching lines @@
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
 
     // if we have a texture, first get those pixels
     SkBitmap tmpSrc;
     const SkBitmap* src = this;
 
     if (fPixelRef) {
         SkIRect subset;
-        subset.setXYWH(fPixelRefOrigin.fX, fPixelRefOrigin.fY,
-                       fInfo.width(), fInfo.height());
+        subset.setXYWH(fPixelRefOrigin.fX, fPixelRefOrigin.fY, fWidth, fHeight);
         if (fPixelRef->readPixels(&tmpSrc, &subset)) {
             SkASSERT(tmpSrc.width() == this->width());
             SkASSERT(tmpSrc.height() == this->height());
 
             // did we get lucky and we can just return tmpSrc?
             if (tmpSrc.config() == dstConfig && NULL == alloc) {
                 dst->swap(tmpSrc);
                 // If the result is an exact copy, clone the gen ID.
                 if (dst->pixelRef() && dst->pixelRef()->info() == fPixelRef->info()) {
                     dst->pixelRef()->cloneGenID(*fPixelRef);
@@ skipping 93 matching lines @@
 
         paint.setDither(true);
         canvas.drawBitmap(*src, 0, 0, &paint);
     }
 
     dst->swap(tmpDst);
     return true;
 }
 
 bool SkBitmap::deepCopyTo(SkBitmap* dst, Config dstConfig) const {
-    const SkColorType dstCT = SkBitmapConfigToColorType(dstConfig);
-
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
 
     // If we have a PixelRef, and it supports deep copy, use it.
     // Currently supported only by texture-backed bitmaps.
     if (fPixelRef) {
         SkPixelRef* pixelRef = fPixelRef->deepCopy(dstConfig);
         if (pixelRef) {
             uint32_t rowBytes;
-            if (this->colorType() == dstCT) {
+            if (dstConfig == fConfig) {
                 // Since there is no subset to pass to deepCopy, and deepCopy
                 // succeeded, the new pixel ref must be identical.
                 SkASSERT(fPixelRef->info() == pixelRef->info());
                 pixelRef->cloneGenID(*fPixelRef);
                 // Use the same rowBytes as the original.
                 rowBytes = fRowBytes;
             } else {
                 // With the new config, an appropriate fRowBytes will be computed by setConfig.
                 rowBytes = 0;
             }
-
-            SkImageInfo info = fInfo;
-            info.fColorType = dstCT;
-            if (!dst->setConfig(info, rowBytes)) {
-                return false;
-            }
+            dst->setConfig(dstConfig, fWidth, fHeight, rowBytes);
             dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
             return true;
         }
     }
 
     if (this->getTexture()) {
         return false;
     } else {
         return this->copyTo(dst, dstConfig, NULL);
     }
@@ skipping 382 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 enum {
     SERIALIZE_PIXELTYPE_NONE,
     SERIALIZE_PIXELTYPE_REF_DATA
 };
 
 void SkBitmap::flatten(SkWriteBuffer& buffer) const {
-    fInfo.flatten(buffer);
+    buffer.writeInt(fWidth);
+    buffer.writeInt(fHeight);
     buffer.writeInt(fRowBytes);
+    buffer.writeInt(fConfig);
+    buffer.writeInt(fAlphaType);
 
     if (fPixelRef) {
         if (fPixelRef->getFactory()) {
             buffer.writeInt(SERIALIZE_PIXELTYPE_REF_DATA);
             buffer.writeInt(fPixelRefOrigin.fX);
             buffer.writeInt(fPixelRefOrigin.fY);
             buffer.writeFlattenable(fPixelRef);
             return;
         }
         // if we get here, we can't record the pixels
         buffer.writeInt(SERIALIZE_PIXELTYPE_NONE);
     } else {
         buffer.writeInt(SERIALIZE_PIXELTYPE_NONE);
     }
 }
 
 void SkBitmap::unflatten(SkReadBuffer& buffer) {
     this->reset();
 
-    SkImageInfo info;
-    info.unflatten(buffer);
-    size_t rowBytes = buffer.readInt();
-    buffer.validate((info.width() >= 0) && (info.height() >= 0) &&
-                    SkColorTypeIsValid(info.fColorType) &&
-                    SkAlphaTypeIsValid(info.fAlphaType) &&
-                    validate_alphaType(info.fColorType, info.fAlphaType) &&
-                    info.validRowBytes(rowBytes));
+    int width = buffer.readInt();
+    int height = buffer.readInt();
+    int rowBytes = buffer.readInt();
+    Config config = (Config)buffer.readInt();
+    SkAlphaType alphaType = (SkAlphaType)buffer.readInt();
+    buffer.validate((width >= 0) && (height >= 0) && (rowBytes >= 0) &&
+                    SkIsValidConfig(config) && validate_alphaType(config, alphaType));
 
-    bool configIsValid = this->setConfig(info, rowBytes);
-    buffer.validate(configIsValid);
+    bool configIsValid = this->setConfig(config, width, height, rowBytes, alphaType);
+    // Note : Using (fRowBytes >= (fWidth * fBytesPerPixel)) in the following test can create false
+    //        positives if the multiplication causes an integer overflow. Use the division instead.
+    buffer.validate(configIsValid && (fBytesPerPixel > 0) &&
+                    ((fRowBytes / fBytesPerPixel) >= fWidth));
 
     int reftype = buffer.readInt();
     if (buffer.validate((SERIALIZE_PIXELTYPE_REF_DATA == reftype) ||
                         (SERIALIZE_PIXELTYPE_NONE == reftype))) {
         switch (reftype) {
             case SERIALIZE_PIXELTYPE_REF_DATA: {
                 SkIPoint origin;
                 origin.fX = buffer.readInt();
                 origin.fY = buffer.readInt();
-                size_t offset = origin.fY * rowBytes + origin.fX * info.bytesPerPixel();
+                size_t offset = origin.fY * rowBytes + origin.fX * fBytesPerPixel;
                 SkPixelRef* pr = buffer.readPixelRef();
                 if (!buffer.validate((NULL == pr) ||
                        (pr->getAllocatedSizeInBytes() >= (offset + this->getSafeSize())))) {
                     origin.setZero();
                 }
                 SkSafeUnref(this->setPixelRef(pr, origin));
                 break;
             }
             case SERIALIZE_PIXELTYPE_NONE:
                 break;
@@ skipping 12 matching lines @@
 }
 
 SkBitmap::RLEPixels::~RLEPixels() {
     sk_free(fYPtrs);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkBitmap::validate() const {
-    fInfo.validate();
-    SkASSERT(fInfo.validRowBytes(fRowBytes));
+    SkASSERT(fConfig < kConfigCount);
+    SkASSERT(fRowBytes >= (unsigned)ComputeRowBytes((Config)fConfig, fWidth));
     uint8_t allFlags = kImageIsOpaque_Flag | kImageIsVolatile_Flag | kImageIsImmutable_Flag;
 #ifdef SK_BUILD_FOR_ANDROID
     allFlags |= kHasHardwareMipMap_Flag;
 #endif
     SkASSERT(fFlags <= allFlags);
     SkASSERT(fPixelLockCount >= 0);
+    SkASSERT((uint8_t)ComputeBytesPerPixel((Config)fConfig) == fBytesPerPixel);
 
     if (fPixels) {
         SkASSERT(fPixelRef);
         SkASSERT(fPixelLockCount > 0);
         SkASSERT(fPixelRef->isLocked());
         SkASSERT(fPixelRef->rowBytes() == fRowBytes);
         SkASSERT(fPixelRefOrigin.fX >= 0);
         SkASSERT(fPixelRefOrigin.fY >= 0);
-        SkASSERT(fPixelRef->info().width() >= (int)this->width() + fPixelRefOrigin.fX);
-        SkASSERT(fPixelRef->info().fHeight >= (int)this->height() + fPixelRefOrigin.fY);
-        SkASSERT(fPixelRef->rowBytes() >= fInfo.minRowBytes());
+        SkASSERT(fPixelRef->info().fWidth >= (int)fWidth + fPixelRefOrigin.fX);
+        SkASSERT(fPixelRef->info().fHeight >= (int)fHeight + fPixelRefOrigin.fY);
+        SkASSERT(fPixelRef->rowBytes() >= fWidth * fBytesPerPixel);
     } else {
         SkASSERT(NULL == fColorTable);
     }
 }
 #endif
 
 #ifdef SK_DEVELOPER
 void SkBitmap::toString(SkString* str) const {
 
     static const char* gConfigNames[kConfigCount] = {
@@ skipping 25 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-void SkImageInfo::validate() const {
-    SkASSERT(fWidth >= 0);
-    SkASSERT(fHeight >= 0);
-    SkASSERT(SkColorTypeIsValid(fColorType));
-    SkASSERT(SkAlphaTypeIsValid(fAlphaType));
-}
-#endif