remvoe duplicate impl for SkImageInfo flattening

Revert "Revert "PixelRef now returns (nearly) everything that is currently in SkBitmap. The goal is to refactor bitmap later to remove redundancy, and more interestingly, remove the chance for a disconnect between the actual (pixelref) rowbytes and config, and the one claimed by the bitmap.""""""

This reverts commit eabd6b2ed4e494b323c08f32358f45950a0368c3.

BUG=

Review URL: https://codereview.chromium.org/108773003

git-svn-id: http://skia.googlecode.com/svn/trunk@12624 2bbb7eff-a529-9590-31e7-b0007b416f81

1 files changed, 111 insertions, 20 deletions

diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index f229e9de34..613491a3aa 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -1,27 +1,105 @@
-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "SkMallocPixelRef.h"
 #include "SkBitmap.h"
 #include "SkFlattenableBuffers.h"
 
-SkMallocPixelRef::SkMallocPixelRef(void* storage, size_t size,
-                                   SkColorTable* ctable, bool ownPixels) {
-    if (NULL == storage) {
-        SkASSERT(ownPixels);
-        storage = sk_malloc_throw(size);
+static bool check_info(const SkImageInfo& info, SkColorTable* ctable) {
+    if (info.fWidth < 0 ||
+        info.fHeight < 0 ||
+        (unsigned)info.fColorType > (unsigned)kLastEnum_SkColorType ||
+        (unsigned)info.fAlphaType > (unsigned)kLastEnum_SkAlphaType)
+    {
+        return false;
+    }
+    
+    // these seem like good checks, but currently we have (at least) tests
+    // that expect the pixelref to succeed even when there is a mismatch
+    // with colortables. fix?
+#if 0
+    if (kIndex8_SkColorType == info.fColorType && NULL == ctable) {
+        return false;
+    }
+    if (kIndex8_SkColorType != info.fColorType && NULL != ctable) {
+        return false;
+    }
+#endif
+    return true;
+}
+
+SkMallocPixelRef* SkMallocPixelRef::NewDirect(const SkImageInfo& info,
+                                              void* addr,
+                                              size_t rowBytes,
+                                              SkColorTable* ctable) {
+    if (!check_info(info, ctable)) {
+        return NULL;
+    }
+    return SkNEW_ARGS(SkMallocPixelRef, (info, addr, rowBytes, ctable, false));
+}
+
+SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info,
+                                                size_t requestedRowBytes,
+                                                SkColorTable* ctable) {
+    if (!check_info(info, ctable)) {
+        return NULL;
+    }
+
+    int32_t minRB = info.minRowBytes();
+    if (minRB < 0) {
+        return NULL;    // allocation will be too large
+    }
+    if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) {
+        return NULL;    // cannot meet requested rowbytes
+    }
+
+    int32_t rowBytes;
+    if (requestedRowBytes) {
+        rowBytes = requestedRowBytes;
+    } else {
+        rowBytes = minRB;
     }
+
+    Sk64 bigSize;
+    bigSize.setMul(info.fHeight, rowBytes);
+    if (!bigSize.is32()) {
+        return NULL;
+    }
+
+    size_t size = bigSize.get32();
+    void* addr = sk_malloc_flags(size, 0);
+    if (NULL == addr) {
+        return NULL;
+    }
+
+    return SkNEW_ARGS(SkMallocPixelRef, (info, addr, rowBytes, ctable, true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
+                                   size_t rowBytes, SkColorTable* ctable,
+                                   bool ownsPixels)
+    : SkPixelRef(info)
+    , fOwnPixels(ownsPixels)
+{
+    SkASSERT(check_info(info, ctable));
+    SkASSERT(rowBytes >= info.minRowBytes());
+
+    if (kIndex_8_SkColorType != info.fColorType) {
+        ctable = NULL;
+    }
+
     fStorage = storage;
-    fSize = size;
     fCTable = ctable;
+    fRB = rowBytes;
     SkSafeRef(ctable);
-    fOwnPixels = ownPixels;
-
-    this->setPreLocked(fStorage, fCTable);
+    
+    this->setPreLocked(fStorage, fRB, fCTable);
 }
 
 SkMallocPixelRef::~SkMallocPixelRef() {
@@ -31,19 +109,30 @@ SkMallocPixelRef::~SkMallocPixelRef() {
     }
 }
 
-void* SkMallocPixelRef::onLockPixels(SkColorTable** ct) {
-    *ct = fCTable;
-    return fStorage;
+bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) {
+    rec->fPixels = fStorage;
+    rec->fRowBytes = fRB;
+    rec->fColorTable = fCTable;
+    return true;
 }
 
 void SkMallocPixelRef::onUnlockPixels() {
     // nothing to do
 }
 
+size_t SkMallocPixelRef::getAllocatedSizeInBytes() const {
+    return this->info().getSafeSize(fRB);
+}
+
 void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
-    buffer.writeByteArray(fStorage, fSize);
+    buffer.write32(fRB);
+
+    // TODO: replace this bulk write with a chunky one that can trim off any
+    // trailing bytes on each scanline (in case rowbytes > width*size)
+    size_t size = this->info().getSafeSize(fRB);
+    buffer.writeByteArray(fStorage, size);
     buffer.writeBool(fCTable != NULL);
     if (fCTable) {
         fCTable->writeToBuffer(buffer);
@@ -51,16 +140,18 @@ void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
 }
 
 SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer)
-        : INHERITED(buffer, NULL) {
-    fSize = buffer.getArrayCount();
-    fStorage = sk_malloc_throw(fSize);
-    buffer.readByteArray(fStorage, fSize);
+    : INHERITED(buffer, NULL)
+    , fOwnPixels(true)
+{
+    fRB = buffer.read32();
+    size_t size = this->info().getSafeSize(fRB);
+    fStorage = sk_malloc_throw(size);
+    buffer.readByteArray(fStorage, size);
     if (buffer.readBool()) {
         fCTable = SkNEW_ARGS(SkColorTable, (buffer));
     } else {
         fCTable = NULL;
     }
-    fOwnPixels = true;
 
-    this->setPreLocked(fStorage, fCTable);
+    this->setPreLocked(fStorage, fRB, fCTable);
 }