Revert of setConfig -> setInfo

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"
@@ skipping 184 matching lines @@
             break;
         default:
             return false;
     }
     if (canonical) {
         *canonical = alphaType;
     }
     return true;
 }
 
-bool SkBitmap::setInfo(const SkImageInfo& origInfo, size_t rowBytes) {
+bool SkBitmap::setConfig(const SkImageInfo& origInfo, size_t rowBytes) {
     SkImageInfo info = origInfo;
 
     if (!validate_alphaType(info.fColorType, info.fAlphaType,
                             &info.fAlphaType)) {
         return reset_return_false(this);
     }
 
     // require that rowBytes fit in 31bits
     int64_t mrb = info.minRowBytes64();
     if ((int32_t)mrb != mrb) {
@@ skipping 18 matching lines @@
     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->setInfo(SkImageInfo::Make(width, height, ct, alphaType), rowBytes);
+    return this->setConfig(SkImageInfo::Make(width, height, ct, alphaType),
+                           rowBytes);
 }
 
 bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
     if (!validate_alphaType(fInfo.fColorType, alphaType, &alphaType)) {
         return false;
     }
     if (fInfo.fAlphaType != alphaType) {
         fInfo.fAlphaType = alphaType;
         if (fPixelRef) {
             fPixelRef->changeAlphaType(alphaType);
@@ skipping 156 matching lines @@
     return allocator->allocPixelRef(this, ctable);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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->setInfo(info)) {
+    if (!this->setConfig(info)) {
         return reset_return_false(this);
     }
 
     SkMallocPixelRef::PRFactory defaultFactory;
     if (NULL == factory) {
         factory = &defaultFactory;
     }
 
     SkPixelRef* pr = factory->create(info, ctable);
     if (NULL == pr) {
         return reset_return_false(this);
     }
     this->setPixelRef(pr)->unref();
 
     // TODO: lockPixels could/should return bool or void*/NULL
     this->lockPixels();
     if (NULL == this->getPixels()) {
         return reset_return_false(this);
     }
     return true;
 }
 
 bool SkBitmap::installPixels(const SkImageInfo& info, void* pixels, size_t rb, SkColorTable* ct,
                              void (*releaseProc)(void* addr, void* context), void* context) {
-    if (!this->setInfo(info, rb)) {
+    if (!this->setConfig(info, rb)) {
         this->reset();
         return false;
     }
 
     SkPixelRef* pr = SkMallocPixelRef::NewWithProc(info, rb, ct, pixels, releaseProc, context);
     if (!pr) {
         this->reset();
         return false;
     }
 
@@ skipping 419 matching lines @@
     srcRect.set(0, 0, this->width(), this->height());
     if (!r.intersect(srcRect, subset)) {
         return false;   // r is empty (i.e. no intersection)
     }
 
     if (fPixelRef->getTexture() != NULL) {
         // Do a deep copy
         SkPixelRef* pixelRef = fPixelRef->deepCopy(this->config(), &subset);
         if (pixelRef != NULL) {
             SkBitmap dst;
-            dst.setInfo(SkImageInfo::Make(subset.width(), subset.height(),
-                                          this->colorType(), this->alphaType()));
+            dst.setConfig(SkImageInfo::Make(subset.width(), subset.height(),
+                                            this->colorType(), this->alphaType()));
             dst.setIsVolatile(this->isVolatile());
             dst.setPixelRef(pixelRef)->unref();
             SkDEBUGCODE(dst.validate());
             result->swap(dst);
             return true;
         }
     }
 
     // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
     // exited above.
     SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
     SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
 
     SkBitmap dst;
-    dst.setInfo(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
-                this->rowBytes());
+    dst.setConfig(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
+                  this->rowBytes());
     dst.setIsVolatile(this->isVolatile());
 
     if (fPixelRef) {
         SkIPoint origin = fPixelRefOrigin;
         origin.fX += r.fLeft;
         origin.fY += r.fTop;
         // share the pixelref with a custom offset
         dst.setPixelRef(fPixelRef, origin);
     }
     SkDEBUGCODE(dst.validate();)
@@ skipping 72 matching lines @@
         return false;
     }
 
     // The only way to be readyToDraw is if fPixelRef is non NULL.
     SkASSERT(fPixelRef != NULL);
 
     SkImageInfo dstInfo = src->info();
     dstInfo.fColorType = dstColorType;
 
     SkBitmap tmpDst;
-    if (!tmpDst.setInfo(dstInfo)) {
+    if (!tmpDst.setConfig(dstInfo)) {
         return false;
     }
 
     // allocate colortable if srcConfig == kIndex8_Config
     SkAutoTUnref<SkColorTable> ctable;
     if (dstColorType == kIndex_8_SkColorType) {
         // TODO: can we just ref() the src colortable? Is it reentrant-safe?
         ctable.reset(SkNEW_ARGS(SkColorTable, (*src->getColorTable())));
     }
     if (!tmpDst.allocPixels(alloc, ctable)) {
@@ skipping 87 matching lines @@
         if (pixelRef) {
             uint32_t rowBytes;
             if (this->colorType() == dstCT) {
                 // 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 setInfo.
+                // With the new config, an appropriate fRowBytes will be computed by setConfig.
                 rowBytes = 0;
             }
 
             SkImageInfo info = fInfo;
             info.fColorType = dstCT;
-            if (!dst->setInfo(info, rowBytes)) {
+            if (!dst->setConfig(info, rowBytes)) {
                 return false;
             }
             dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
             return true;
         }
     }
 
     if (this->getTexture()) {
         return false;
     } else {
@@ skipping 89 matching lines @@
     // compute our (larger?) dst bounds if we have a filter
     if (NULL != filter) {
         identity.reset();
         srcM.fImage = NULL;
         if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
             goto NO_FILTER_CASE;
         }
         dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
     } else {
     NO_FILTER_CASE:
-        tmpBitmap.setInfo(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
+        tmpBitmap.setConfig(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
         if (!tmpBitmap.allocPixels(allocator, NULL)) {
             // Allocation of pixels for alpha bitmap failed.
             SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                     tmpBitmap.width(), tmpBitmap.height());
             return false;
         }
         GetBitmapAlpha(*this, tmpBitmap.getAddr8(0, 0), srcM.fRowBytes);
         if (offset) {
             offset->set(0, 0);
         }
         tmpBitmap.swap(*dst);
         return true;
     }
     srcM.fImage = SkMask::AllocImage(srcM.computeImageSize());
     SkAutoMaskFreeImage srcCleanup(srcM.fImage);
 
     GetBitmapAlpha(*this, srcM.fImage, srcM.fRowBytes);
     if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
         goto NO_FILTER_CASE;
     }
     SkAutoMaskFreeImage dstCleanup(dstM.fImage);
 
-    tmpBitmap.setInfo(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
-                      dstM.fRowBytes);
+    tmpBitmap.setConfig(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
+                        dstM.fRowBytes);
     if (!tmpBitmap.allocPixels(allocator, NULL)) {
         // Allocation of pixels for alpha bitmap failed.
         SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                 tmpBitmap.width(), tmpBitmap.height());
         return false;
     }
     memcpy(tmpBitmap.getPixels(), dstM.fImage, dstM.computeImageSize());
     if (offset) {
         offset->set(dstM.fBounds.fLeft, dstM.fBounds.fTop);
     }
@@ skipping 69 matching lines @@
         SkASSERT(srcRow == dstRow); // first row does not need to be moved
     }
 
     SkAutoTUnref<SkColorTable> ctable;
     if (buffer->readBool()) {
         ctable.reset(SkNEW_ARGS(SkColorTable, (*buffer)));
     }
 
     SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewWithData(info, info.minRowBytes(),
                                                               ctable.get(), data.get()));
-    bitmap->setInfo(pr->info());
+    bitmap->setConfig(pr->info());
     bitmap->setPixelRef(pr, 0, 0);
     return true;
 }
 
 enum {
     SERIALIZE_PIXELTYPE_NONE,
     SERIALIZE_PIXELTYPE_REF_DATA
 };
 
 void SkBitmap::legacyUnflatten(SkReadBuffer& buffer) {
     this->reset();
 
     SkImageInfo info;
     info.unflatten(buffer);
     size_t rowBytes = buffer.readInt();
     if (!buffer.validate((info.width() >= 0) && (info.height() >= 0) &&
                          SkColorTypeIsValid(info.fColorType) &&
                          SkAlphaTypeIsValid(info.fAlphaType) &&
                          validate_alphaType(info.fColorType, info.fAlphaType) &&
                          info.validRowBytes(rowBytes))) {
         return;
     }
 
-    bool configIsValid = this->setInfo(info, rowBytes);
+    bool configIsValid = this->setConfig(info, rowBytes);
     buffer.validate(configIsValid);
 
     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();
@@ skipping 105 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif