move all Config specific APIs into SkBitmapConfig.cpp -- Config is deprecated

src/core/SkMipMap.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMipMap.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 105 matching lines @@
     int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
     if (!sk_64_isS32(size)) {
         return NULL;
     }
     return (Level*)sk_malloc_throw(sk_64_asS32(size));
 }
 
 SkMipMap* SkMipMap::Build(const SkBitmap& src) {
     void (*proc)(SkBitmap* dst, int x, int y, const SkBitmap& src);
 
-    const SkBitmap::Config config = src.config();
-    switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+    const SkColorType ct = src.colorType();
+    switch (ct) {
+        case kRGBA_8888_SkColorType:
+        case kBGRA_8888_SkColorType:
             proc = downsampleby2_proc32;
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             proc = downsampleby2_proc16;
             break;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             proc = downsampleby2_proc4444;
             break;
-        case SkBitmap::kIndex8_Config:
-        case SkBitmap::kA8_Config:
         default:
             return NULL; // don't build mipmaps for these configs
     }
 
     SkAutoLockPixels alp(src);
     if (!src.readyToDraw()) {
         return NULL;
     }
 
     // whip through our loop to compute the exact size needed
     size_t  size = 0;
     int     countLevels = 0;
     {
         int width = src.width();
         int height = src.height();
         for (;;) {
             width >>= 1;
             height >>= 1;
             if (0 == width || 0 == height) {
                 break;
             }
-            size += SkBitmap::ComputeRowBytes(config, width) * height;
+            size += SkColorTypeMinRowBytes(ct, width) * height;
             countLevels += 1;
         }
     }
     if (0 == countLevels) {
         return NULL;
     }
 
     Level* levels = SkMipMap::AllocLevels(countLevels, size);
     if (NULL == levels) {
         return NULL;
     }
 
     uint8_t*    baseAddr = (uint8_t*)&levels[countLevels];
     uint8_t*    addr = baseAddr;
     int         width = src.width();
     int         height = src.height();
     uint32_t    rowBytes;
     SkBitmap    srcBM(src);
 
     for (int i = 0; i < countLevels; ++i) {
         width >>= 1;
         height >>= 1;
-        rowBytes = SkToU32(SkBitmap::ComputeRowBytes(config, width));
+        rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
 
         levels[i].fPixels   = addr;
         levels[i].fWidth    = width;
         levels[i].fHeight   = height;
         levels[i].fRowBytes = rowBytes;
         levels[i].fScale    = (float)width / src.width();
 
+        SkImageInfo info = SkImageInfo::Make(width, height, ct,
+                                             srcBM.alphaType());
         SkBitmap dstBM;
-        dstBM.setConfig(config, width, height, rowBytes);
-        dstBM.setPixels(addr);
+        dstBM.installPixels(info, addr, rowBytes, NULL, NULL);
+        dstBM.lockPixels();
 
         srcBM.lockPixels();
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
                 proc(&dstBM, x, y, srcBM);
             }
         }
         srcBM.unlockPixels();
 
         srcBM = dstBM;
@@ skipping 43 matching lines @@
     }
 
     if (level > fCount) {
         level = fCount;
     }
     if (levelPtr) {
         *levelPtr = fLevels[level - 1];
     }
     return true;
 }