SkBitmap::Config is deprecated, use SkColorType instead

content/common/gpu/client/gl_helper_readback_support.cc

 // Copyright 2014 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 "content/common/gpu/client/gl_helper_readback_support.h"
 #include "base/logging.h"
 
 namespace content {
 
 GLHelperReadbackSupport::GLHelperReadbackSupport(gpu::gles2::GLES2Interface* gl)
     : gl_(gl) {
   InitializeReadbackSupport();
 }
 
 GLHelperReadbackSupport::~GLHelperReadbackSupport() {}
 
 void GLHelperReadbackSupport::InitializeReadbackSupport() {
   // We are concerned about 16, 32-bit formats only.
   // The below are the most used 16, 32-bit formats.
   // In future if any new format support is needed that should be added here.
   // Initialize the array with FORMAT_NOT_SUPPORTED as we dont know the
   // supported formats yet.
-  for (int i = 0; i < SkBitmap::kConfigCount; ++i) {
+  for (int i = 0; i <= kLastEnum_SkColorType; ++i) {
     format_support_table_[i] = FORMAT_NOT_SUPPORTED;
   }
-  CheckForReadbackSupport(SkBitmap::kRGB_565_Config);
-  CheckForReadbackSupport(SkBitmap::kARGB_4444_Config);
-  CheckForReadbackSupport(SkBitmap::kARGB_8888_Config);
+  CheckForReadbackSupport(kRGB_565_SkColorType);
+  CheckForReadbackSupport(kARGB_4444_SkColorType);
+  CheckForReadbackSupport(kN32_SkColorType);
   // Further any formats, support should be checked here.
 }
 
 void GLHelperReadbackSupport::CheckForReadbackSupport(
-    SkBitmap::Config texture_format) {
+    SkColorType texture_format) {
   bool supports_format = false;
   switch (texture_format) {
-    case SkBitmap::kRGB_565_Config:
+    case kRGB_565_SkColorType:
       supports_format = SupportsFormat(GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
       break;
-    case SkBitmap::kARGB_8888_Config:
+    case kN32_SkColorType:
       // This is the baseline, assume always true.
       supports_format = true;
       break;
-    case SkBitmap::kARGB_4444_Config:
+    case kARGB_4444_SkColorType:
       supports_format = false;
       break;
     default:
       NOTREACHED();
       supports_format = false;
       break;
   }
-  DCHECK((int)texture_format < (int)SkBitmap::kConfigCount);
+  DCHECK((int)texture_format <= (int)kLastEnum_SkColorType);
   format_support_table_[texture_format] =
       supports_format ? FORMAT_SUPPORTED : FORMAT_NOT_SUPPORTED;
 }
 
 void GLHelperReadbackSupport::GetAdditionalFormat(GLint format, GLint type,
                                                   GLint *format_out,
                                                   GLint *type_out) {
   for (unsigned int i = 0; i < format_cache_.size(); i++) {
     if (format_cache_[i].format == format && format_cache_[i].type == type) {
       *format_out = format_cache_[i].read_format;
@@ skipping 31 matching lines @@
   bool supports_format = false;
   GLint ext_format = 0, ext_type = 0;
   GetAdditionalFormat(format, type, &ext_format, &ext_type);
   if ((ext_format == format) && (ext_type == type)) {
     supports_format = true;
   }
   return supports_format;
 }
 
 bool GLHelperReadbackSupport::IsReadbackConfigSupported(
-    SkBitmap::Config texture_format) {
+    SkColorType texture_format) {
   switch (format_support_table_[texture_format]) {
     case FORMAT_SUPPORTED:
       return true;
     case FORMAT_NOT_SUPPORTED:
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace content