setConfig is deprecated, use setInfo or allocPixels instead

ui/gfx/skbitmap_operations.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/skbitmap_operations.h"
 
 #include <algorithm>
 #include <string.h>
 
 #include "base/logging.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 
 // static
 SkBitmap SkBitmapOperations::CreateInvertedBitmap(const SkBitmap& image) {
-  DCHECK(image.colorType() == kPMColor_SkColorType);
+  DCHECK(image.colorType() == kN32_SkColorType);
 
   SkAutoLockPixels lock_image(image);
 
   SkBitmap inverted;
   inverted.allocN32Pixels(image.width(), image.height());
   inverted.eraseARGB(0, 0, 0, 0);
 
   for (int y = 0; y < image.height(); ++y) {
     uint32* image_row = image.getAddr32(0, y);
     uint32* dst_row = inverted.getAddr32(0, y);
 
     for (int x = 0; x < image.width(); ++x) {
       uint32 image_pixel = image_row[x];
       dst_row[x] = (image_pixel & 0xFF000000) |
                    (0x00FFFFFF - (image_pixel & 0x00FFFFFF));
     }
   }
 
   return inverted;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateSuperimposedBitmap(const SkBitmap& first,
                                                       const SkBitmap& second) {
   DCHECK(first.width() == second.width());
   DCHECK(first.height() == second.height());
   DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
-  DCHECK(first.colorType() == kPMColor_SkColorType);
+  DCHECK(first.colorType() == kN32_SkColorType);
 
   SkAutoLockPixels lock_first(first);
   SkAutoLockPixels lock_second(second);
 
   SkBitmap superimposed;
   superimposed.allocN32Pixels(first.width(), first.height());
   superimposed.eraseARGB(0, 0, 0, 0);
 
   SkCanvas canvas(superimposed);
 
@@ skipping 10 matching lines @@
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateBlendedBitmap(const SkBitmap& first,
                                                  const SkBitmap& second,
                                                  double alpha) {
   DCHECK((alpha >= 0) && (alpha <= 1));
   DCHECK(first.width() == second.width());
   DCHECK(first.height() == second.height());
   DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
-  DCHECK(first.colorType() == kPMColor_SkColorType);
+  DCHECK(first.colorType() == kN32_SkColorType);
 
   // Optimize for case where we won't need to blend anything.
   static const double alpha_min = 1.0 / 255;
   static const double alpha_max = 254.0 / 255;
   if (alpha < alpha_min)
     return first;
   else if (alpha > alpha_max)
     return second;
 
   SkAutoLockPixels lock_first(first);
@@ skipping 29 matching lines @@
 
   return blended;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateMaskedBitmap(const SkBitmap& rgb,
                                                 const SkBitmap& alpha) {
   DCHECK(rgb.width() == alpha.width());
   DCHECK(rgb.height() == alpha.height());
   DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
-  DCHECK(rgb.colorType() == kPMColor_SkColorType);
-  DCHECK(alpha.colorType() == kPMColor_SkColorType);
+  DCHECK(rgb.colorType() == kN32_SkColorType);
+  DCHECK(alpha.colorType() == kN32_SkColorType);
 
   SkBitmap masked;
   masked.allocN32Pixels(rgb.width(), rgb.height());
   masked.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_rgb(rgb);
   SkAutoLockPixels lock_alpha(alpha);
   SkAutoLockPixels lock_masked(masked);
 
   for (int y = 0; y < masked.height(); ++y) {
@@ skipping 15 matching lines @@
     }
   }
 
   return masked;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateButtonBackground(SkColor color,
                                                     const SkBitmap& image,
                                                     const SkBitmap& mask) {
-  DCHECK(image.colorType() == kPMColor_SkColorType);
-  DCHECK(mask.colorType() == kPMColor_SkColorType);
+  DCHECK(image.colorType() == kN32_SkColorType);
+  DCHECK(mask.colorType() == kN32_SkColorType);
 
   SkBitmap background;
   background.allocN32Pixels(mask.width(), mask.height());
 
   double bg_a = SkColorGetA(color);
   double bg_r = SkColorGetR(color);
   double bg_g = SkColorGetG(color);
   double bg_b = SkColorGetB(color);
 
   SkAutoLockPixels lock_mask(mask);
@@ skipping 358 matching lines @@
   // Lightness shift: 0 -> black, 0.5 -> NOP, 1 -> white.
   if (hsl_shift.l >= 0 && hsl_shift.l <= (0.5 - HSLShift::epsilon))
     L_op = HSLShift::kOpLDec;
   else if (hsl_shift.l >= (0.5 + HSLShift::epsilon))
     L_op = HSLShift::kOpLInc;
 
   HSLShift::LineProcessor line_proc =
       HSLShift::kLineProcessors[H_op][S_op][L_op];
 
   DCHECK(bitmap.empty() == false);
-  DCHECK(bitmap.colorType() == kPMColor_SkColorType);
+  DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   SkBitmap shifted;
   shifted.allocN32Pixels(bitmap.width(), bitmap.height());
   shifted.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_bitmap(bitmap);
   SkAutoLockPixels lock_shifted(shifted);
 
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < bitmap.height(); ++y) {
     SkPMColor* pixels = bitmap.getAddr32(0, y);
     SkPMColor* tinted_pixels = shifted.getAddr32(0, y);
 
     (*line_proc)(hsl_shift, pixels, tinted_pixels, bitmap.width());
   }
 
   return shifted;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateTiledBitmap(const SkBitmap& source,
                                                int src_x, int src_y,
                                                int dst_w, int dst_h) {
-  DCHECK(source.colorType() == kPMColor_SkColorType);
+  DCHECK(source.colorType() == kN32_SkColorType);
 
   SkBitmap cropped;
   cropped.allocN32Pixels(dst_w, dst_h);
   cropped.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_source(source);
   SkAutoLockPixels lock_cropped(cropped);
 
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < dst_h; ++y) {
@@ skipping 119 matching lines @@
         *dst_pixel = unmultiplied;
       }
     }
   }
 
   return opaque_bitmap;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateTransposedBitmap(const SkBitmap& image) {
-  DCHECK(image.colorType() == kPMColor_SkColorType);
+  DCHECK(image.colorType() == kN32_SkColorType);
 
   SkBitmap transposed;
   transposed.allocN32Pixels(image.height(), image.width());
 
   SkAutoLockPixels lock_image(image);
   SkAutoLockPixels lock_transposed(transposed);
 
   for (int y = 0; y < image.height(); ++y) {
     uint32* image_row = image.getAddr32(0, y);
     for (int x = 0; x < image.width(); ++x) {
       uint32* dst = transposed.getAddr32(y, x);
       *dst = image_row[x];
     }
   }
 
   return transposed;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateColorMask(const SkBitmap& bitmap,
                                              SkColor c) {
-  DCHECK(bitmap.colorType() == kPMColor_SkColorType);
+  DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   SkBitmap color_mask;
   color_mask.allocN32Pixels(bitmap.width(), bitmap.height());
   color_mask.eraseARGB(0, 0, 0, 0);
 
   SkCanvas canvas(color_mask);
 
   skia::RefPtr<SkColorFilter> color_filter = skia::AdoptRef(
       SkColorFilter::CreateModeFilter(c, SkXfermode::kSrcIn_Mode));
   SkPaint paint;
   paint.setColorFilter(color_filter.get());
   canvas.drawBitmap(bitmap, SkIntToScalar(0), SkIntToScalar(0), &paint);
   return color_mask;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateDropShadow(
     const SkBitmap& bitmap,
     const gfx::ShadowValues& shadows) {
-  DCHECK(bitmap.colorType() == kPMColor_SkColorType);
+  DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   // Shadow margin insets are negative values because they grow outside.
   // Negate them here as grow direction is not important and only pixel value
   // is of interest here.
   gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(shadows);
 
   SkBitmap image_with_shadow;
   image_with_shadow.allocN32Pixels(bitmap.width() + shadow_margin.width(),
                                    bitmap.height() + shadow_margin.height());
   image_with_shadow.eraseARGB(0, 0, 0, 0);
@@ skipping 26 matching lines @@
 
 // static
 SkBitmap SkBitmapOperations::Rotate(const SkBitmap& source,
                                     RotationAmount rotation) {
   SkBitmap result;
   SkScalar angle = SkFloatToScalar(0.0f);
 
   switch (rotation) {
    case ROTATION_90_CW:
      angle = SkFloatToScalar(90.0f);
-     result.setConfig(
-         SkBitmap::kARGB_8888_Config, source.height(), source.width());
+     result.allocN32Pixels(source.height(), source.width());
      break;
    case ROTATION_180_CW:
      angle = SkFloatToScalar(180.0f);
-     result.setConfig(
-         SkBitmap::kARGB_8888_Config, source.width(), source.height());
+     result.allocN32Pixels(source.width(), source.height());
      break;
    case ROTATION_270_CW:
      angle = SkFloatToScalar(270.0f);
-     result.setConfig(
-         SkBitmap::kARGB_8888_Config, source.height(), source.width());
+     result.allocN32Pixels(source.height(), source.width());
      break;
   }
-  result.allocPixels();
+
   SkCanvas canvas(result);
   canvas.clear(SkColorSetARGB(0, 0, 0, 0));
 
   canvas.translate(SkFloatToScalar(result.width() * 0.5f),
                    SkFloatToScalar(result.height() * 0.5f));
   canvas.rotate(angle);
   canvas.translate(-SkFloatToScalar(source.width() * 0.5f),
                    -SkFloatToScalar(source.height() * 0.5f));
   canvas.drawBitmap(source, 0, 0);
   canvas.flush();
 
   return result;
 }