SkBitmap::Config is deprecated, use SkColorType instead

ui/gfx/android/java_bitmap.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/android/java_bitmap.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/jni_string.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 JavaBitmap::~JavaBitmap() {
   int err = AndroidBitmap_unlockPixels(AttachCurrentThread(), bitmap_);
   DCHECK(!err);
 }
 
 // static
 bool JavaBitmap::RegisterJavaBitmap(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-static int SkBitmapConfigToBitmapFormat(SkBitmap::Config bitmap_config) {
-  switch (bitmap_config) {
-    case SkBitmap::kA8_Config:
+static int SkColorTypeToBitmapFormat(SkColorType color_type) {
+  switch (color_type) {
+    case kAlpha_8_SkColorType:
       return BITMAP_FORMAT_ALPHA_8;
-    case SkBitmap::kARGB_4444_Config:
+    case kARGB_4444_SkColorType:
       return BITMAP_FORMAT_ARGB_4444;
-    case SkBitmap::kARGB_8888_Config:
+    case kN32_SkColorType:

[msw, 2014/07/08 16:52:07]

nit q: this kN32_SkColorType could be kBGRA_8888_SkColorType and then yields
BITMAP_FORMAT_ARGB_8888, should this switch handle the possible channel ordering
difference?

[reed1, 2014/07/08 17:02:37]

kN32_SkColorType is an exact match for the legacy SkBitmap::kARGB_8888_Config :
both map to whatever the compile-time swizzle was set for skia's renderer. I
think this is the right change for this CL.

Part of the motivation for switching to SkColorType (and SkImageInfo in the
larger sense) is to allow for exactly this sort of expansion : supporting
natively RGBA and BGRA in the same build (and premul and unpremul). That change
will come later.

       return BITMAP_FORMAT_ARGB_8888;
-    case SkBitmap::kRGB_565_Config:
+    case kRGB_565_SkColorType:
       return BITMAP_FORMAT_RGB_565;
-    case SkBitmap::kNo_Config:
+    case kUnknown_SkColorType:
     default:
       NOTREACHED();
       return BITMAP_FORMAT_NO_CONFIG;
   }
 }
 
 ScopedJavaLocalRef<jobject> CreateJavaBitmap(int width,
                                              int height,
-                                             SkBitmap::Config bitmap_config) {
+                                             SkColorType color_type) {
   DCHECK_GT(width, 0);
   DCHECK_GT(height, 0);
-  int java_bitmap_config = SkBitmapConfigToBitmapFormat(bitmap_config);
+  int java_bitmap_config = SkColorTypeToBitmapFormat(color_type);
   return Java_BitmapHelper_createBitmap(
       AttachCurrentThread(), width, height, java_bitmap_config);
 }
 
 ScopedJavaLocalRef<jobject> CreateJavaBitmapFromAndroidResource(
     const char* name,
     gfx::Size size) {
   DCHECK(name);
   DCHECK(!size.IsEmpty());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> jname(ConvertUTF8ToJavaString(env, name));
   return Java_BitmapHelper_decodeDrawableResource(
       env, jname.obj(), size.width(), size.height());
 }
 
 ScopedJavaLocalRef<jobject> ConvertToJavaBitmap(const SkBitmap* skbitmap) {
   DCHECK(skbitmap);
   DCHECK(!skbitmap->isNull());
-  SkBitmap::Config bitmap_config = skbitmap->config();
-  DCHECK((bitmap_config == SkBitmap::kRGB_565_Config) ||
-         (bitmap_config == SkBitmap::kARGB_8888_Config));
+  SkColorType color_type = skbitmap->colorType();
+  DCHECK((color_type == kRGB_565_SkColorType) ||
+         (color_type == kN32_SkColorType));
   ScopedJavaLocalRef<jobject> jbitmap = CreateJavaBitmap(
-      skbitmap->width(), skbitmap->height(), bitmap_config);
+      skbitmap->width(), skbitmap->height(), color_type);
   SkAutoLockPixels src_lock(*skbitmap);
   JavaBitmap dst_lock(jbitmap.obj());
   void* src_pixels = skbitmap->getPixels();
   void* dst_pixels = dst_lock.pixels();
   memcpy(dst_pixels, src_pixels, skbitmap->getSize());
 
   return jbitmap;
 }
 
 SkBitmap CreateSkBitmapFromJavaBitmap(const JavaBitmap& jbitmap) {
@@ skipping 13 matching lines @@
     LOG(FATAL) << " Failed to allocate bitmap of size " << src_size.width()
                << "x" << src_size.height() << " stride=" << jbitmap.stride();
   }
   const void* src_pixels = jbitmap.pixels();
   void* dst_pixels = skbitmap.getPixels();
   memcpy(dst_pixels, src_pixels, skbitmap.getSize());
 
   return skbitmap;
 }
 
-SkBitmap::Config ConvertToSkiaConfig(jobject bitmap_config) {
+SkColorType ConvertToSkiaColorType(jobject bitmap_config) {
   int jbitmap_config = Java_BitmapHelper_getBitmapFormatForConfig(
       AttachCurrentThread(), bitmap_config);
   switch (jbitmap_config) {
     case BITMAP_FORMAT_ALPHA_8:
-      return SkBitmap::kA8_Config;
+      return kAlpha_8_SkColorType;
     case BITMAP_FORMAT_ARGB_4444:
-      return SkBitmap::kARGB_4444_Config;
+      return kARGB_4444_SkColorType;
     case BITMAP_FORMAT_ARGB_8888:
-      return SkBitmap::kARGB_8888_Config;
+      return kN32_SkColorType;
     case BITMAP_FORMAT_RGB_565:
-      return SkBitmap::kRGB_565_Config;
+      return kRGB_565_SkColorType;
     case BITMAP_FORMAT_NO_CONFIG:
     default:
-      return SkBitmap::kNo_Config;
+      return kUnknown_SkColorType;
   }
 }
 
 }  //  namespace gfx