SkBitmap and SkPixelRef no longer need lock/unlock

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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <algorithm>
 
 #include "base/logging.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/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 
 // static
 SkBitmap SkBitmapOperations::CreateInvertedBitmap(const SkBitmap& image) {
   DCHECK(image.colorType() == kN32_SkColorType);
 
-  SkAutoLockPixels lock_image(image);
-
   SkBitmap inverted;
   inverted.allocN32Pixels(image.width(), image.height());
 
   for (int y = 0; y < image.height(); ++y) {
     uint32_t* image_row = image.getAddr32(0, y);
     uint32_t* dst_row = inverted.getAddr32(0, y);
 
     for (int x = 0; x < image.width(); ++x) {
       uint32_t image_pixel = image_row[x];
       dst_row[x] = (image_pixel & 0xFF000000) |
@@ skipping 15 matching lines @@
   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);
-  SkAutoLockPixels lock_second(second);
-
   SkBitmap blended;
   blended.allocN32Pixels(first.width(), first.height());
 
   double first_alpha = 1 - alpha;
 
   for (int y = 0; y < first.height(); ++y) {
     uint32_t* first_row = first.getAddr32(0, y);
     uint32_t* second_row = second.getAddr32(0, y);
     uint32_t* dst_row = blended.getAddr32(0, y);
 
@@ skipping 22 matching lines @@
                                                 const SkBitmap& alpha) {
   DCHECK(rgb.width() == alpha.width());
   DCHECK(rgb.height() == alpha.height());
   DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
   DCHECK(rgb.colorType() == kN32_SkColorType);
   DCHECK(alpha.colorType() == kN32_SkColorType);
 
   SkBitmap masked;
   masked.allocN32Pixels(rgb.width(), rgb.height());
 
-  SkAutoLockPixels lock_rgb(rgb);
-  SkAutoLockPixels lock_alpha(alpha);
-  SkAutoLockPixels lock_masked(masked);
-
   for (int y = 0; y < masked.height(); ++y) {
     uint32_t* rgb_row = rgb.getAddr32(0, y);
     uint32_t* alpha_row = alpha.getAddr32(0, y);
     uint32_t* dst_row = masked.getAddr32(0, y);
 
     for (int x = 0; x < masked.width(); ++x) {
       unsigned alpha = SkGetPackedA32(alpha_row[x]);
       unsigned scale = SkAlpha255To256(alpha);
       dst_row[x] = SkAlphaMulQ(rgb_row[x], scale);
     }
@@ skipping 13 matching lines @@
   DCHECK(mask.colorType() == kN32_SkColorType);
 
   SkBitmap background;
   background.allocN32Pixels(mask.width(), mask.height());
 
   double bg_a = SkColorGetA(color);
   double bg_r = SkColorGetR(color) * (bg_a / 255.0);
   double bg_g = SkColorGetG(color) * (bg_a / 255.0);
   double bg_b = SkColorGetB(color) * (bg_a / 255.0);
 
-  SkAutoLockPixels lock_mask(mask);
-  SkAutoLockPixels lock_image(image);
-  SkAutoLockPixels lock_background(background);
-
   for (int y = 0; y < mask.height(); ++y) {
     uint32_t* dst_row = background.getAddr32(0, y);
     uint32_t* image_row = image.getAddr32(0, y % image.height());
     uint32_t* mask_row = mask.getAddr32(0, y);
 
     for (int x = 0; x < mask.width(); ++x) {
       uint32_t image_pixel = image_row[x % image.width()];
 
       double img_a = SkColorGetA(image_pixel);
       double img_r = SkColorGetR(image_pixel);
@@ skipping 351 matching lines @@
 
   HSLShift::LineProcessor line_proc =
       HSLShift::kLineProcessors[H_op][S_op][L_op];
 
   DCHECK(bitmap.empty() == false);
   DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   SkBitmap shifted;
   shifted.allocN32Pixels(bitmap.width(), bitmap.height());
 
-  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() == kN32_SkColorType);
 
   SkBitmap cropped;
   cropped.allocN32Pixels(dst_w, dst_h);
 
-  SkAutoLockPixels lock_source(source);
-  SkAutoLockPixels lock_cropped(cropped);
-
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < dst_h; ++y) {
     int y_pix = (src_y + y) % source.height();
     while (y_pix < 0)
       y_pix += source.height();
 
     uint32_t* source_row = source.getAddr32(0, y_pix);
     uint32_t* dst_row = cropped.getAddr32(0, y);
 
     for (int x = 0; x < dst_w; ++x) {
@@ skipping 25 matching lines @@
 
 // static
 SkBitmap SkBitmapOperations::DownsampleByTwo(const SkBitmap& bitmap) {
   // Handle the nop case.
   if ((bitmap.width() <= 1) || (bitmap.height() <= 1))
     return bitmap;
 
   SkBitmap result;
   result.allocN32Pixels((bitmap.width() + 1) / 2, (bitmap.height() + 1) / 2);
 
-  SkAutoLockPixels lock(bitmap);
-
   const int resultLastX = result.width() - 1;
   const int srcLastX = bitmap.width() - 1;
 
   for (int dest_y = 0; dest_y < result.height(); ++dest_y) {
     const int src_y = dest_y << 1;
     const SkPMColor* SK_RESTRICT cur_src0 = bitmap.getAddr32(0, src_y);
     const SkPMColor* SK_RESTRICT cur_src1 = cur_src0;
     if (src_y + 1 < bitmap.height())
       cur_src1 = bitmap.getAddr32(0, src_y + 1);
 
@@ skipping 46 matching lines @@
   if (bitmap.isNull())
     return bitmap;
   if (bitmap.isOpaque())
     return bitmap;
 
   const SkImageInfo& opaque_info =
       bitmap.info().makeAlphaType(kOpaque_SkAlphaType);
   SkBitmap opaque_bitmap;
   opaque_bitmap.allocPixels(opaque_info);
 
-  {
-    SkAutoLockPixels bitmap_lock(bitmap);
-    SkAutoLockPixels opaque_bitmap_lock(opaque_bitmap);
-    for (int y = 0; y < opaque_bitmap.height(); y++) {
-      for (int x = 0; x < opaque_bitmap.width(); x++) {
-        uint32_t src_pixel = *bitmap.getAddr32(x, y);
-        uint32_t* dst_pixel = opaque_bitmap.getAddr32(x, y);
-        SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(src_pixel);
-        *dst_pixel = unmultiplied;
-      }
+  for (int y = 0; y < opaque_bitmap.height(); y++) {
+    for (int x = 0; x < opaque_bitmap.width(); x++) {
+      uint32_t src_pixel = *bitmap.getAddr32(x, y);
+      uint32_t* dst_pixel = opaque_bitmap.getAddr32(x, y);
+      SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(src_pixel);
+      *dst_pixel = unmultiplied;
     }
   }
 
   return opaque_bitmap;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateTransposedBitmap(const SkBitmap& image) {
   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_t* image_row = image.getAddr32(0, y);
     for (int x = 0; x < image.width(); ++x) {
       uint32_t* dst = transposed.getAddr32(y, x);
       *dst = image_row[x];
     }
   }
 
   return transposed;
 }
@@ skipping 87 matching lines @@
   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;
 }