SkBitmap and SkPixelRef no longer need lock/unlock

ui/gfx/skbitmap_operations_unittest.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 <stdint.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 13 matching lines @@
          abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) <= 2 &&
          abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) <= 2;
 }
 
 inline bool MultipliedColorsClose(uint32_t a, uint32_t b) {
   return ColorsClose(SkUnPreMultiply::PMColorToColor(a),
                      SkUnPreMultiply::PMColorToColor(b));
 }
 
 bool BitmapsClose(const SkBitmap& a, const SkBitmap& b) {
-  SkAutoLockPixels a_lock(a);
-  SkAutoLockPixels b_lock(b);
-
   for (int y = 0; y < a.height(); y++) {
     for (int x = 0; x < a.width(); x++) {
       SkColor a_pixel = *a.getAddr32(x, y);
       SkColor b_pixel = *b.getAddr32(x, y);
       if (!ColorsClose(a_pixel, b_pixel))
         return false;
     }
   }
   return true;
 }
@@ skipping 13 matching lines @@
 }
 
 // The reference (i.e., old) implementation of |CreateHSLShiftedBitmap()|.
 SkBitmap ReferenceCreateHSLShiftedBitmap(
     const SkBitmap& bitmap,
     color_utils::HSL hsl_shift) {
   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);
 
     for (int x = 0; x < bitmap.width(); ++x) {
       tinted_pixels[x] = SkPreMultiplyColor(color_utils::HSLShift(
           SkUnPreMultiply::PMColorToColor(pixels[x]), hsl_shift));
     }
   }
@@ skipping 12 matching lines @@
 
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       int i = y * src_w + x;
       *src.getAddr32(x, y) =
           SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
     }
   }
 
   SkBitmap inverted = SkBitmapOperations::CreateInvertedBitmap(src);
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels inverted_lock(inverted);
 
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       int i = y * src_w + x;
       EXPECT_EQ(static_cast<unsigned int>((255 - i) % 255),
                 SkColorGetA(*inverted.getAddr32(x, y)));
       EXPECT_EQ(static_cast<unsigned int>(255 - (i % 255)),
                 SkColorGetR(*inverted.getAddr32(x, y)));
       EXPECT_EQ(static_cast<unsigned int>(255 - (i * 4 % 255)),
                 SkColorGetG(*inverted.getAddr32(x, y)));
@@ skipping 18 matching lines @@
       *src_a.getAddr32(x, y) = SkColorSetARGB(255, 0, i * 2 % 255, i % 255);
       *src_b.getAddr32(x, y) =
           SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
       i++;
     }
   }
 
   // Shift to red.
   SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
     src_a, src_b, 0.5);
-  SkAutoLockPixels srca_lock(src_a);
-  SkAutoLockPixels srcb_lock(src_b);
-  SkAutoLockPixels blended_lock(blended);
 
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       int i = y * src_w + x;
       EXPECT_EQ(static_cast<unsigned int>((255 + ((255 - i) % 255)) / 2),
                 SkColorGetA(*blended.getAddr32(x, y)));
       EXPECT_EQ(static_cast<unsigned int>(i % 255 / 2),
                 SkColorGetR(*blended.getAddr32(x, y)));
       EXPECT_EQ((static_cast<unsigned int>((i * 2) % 255 + (i * 4) % 255) / 2),
                 SkColorGetG(*blended.getAddr32(x, y)));
@@ skipping 14 matching lines @@
   alpha.allocN32Pixels(src_w, src_h);
   for (int y = 0, i = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       *alpha.getAddr32(x, y) = SkPackARGB32(i % 256, 0, 0, 0);
       i++;
     }
   }
 
   SkBitmap masked = SkBitmapOperations::CreateMaskedBitmap(src, alpha);
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels alpha_lock(alpha);
-  SkAutoLockPixels masked_lock(masked);
-
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       int alpha_pixel = *alpha.getAddr32(x, y);
       int src_pixel = *src.getAddr32(x, y);
       int masked_pixel = *masked.getAddr32(x, y);
 
       int scale = SkAlpha255To256(SkGetPackedA32(alpha_pixel));
 
       int src_a = (src_pixel >> SK_A32_SHIFT) & 0xFF;
       int src_r = (src_pixel >> SK_R32_SHIFT) & 0xFF;
@@ skipping 25 matching lines @@
     for (int x = 0; x < src_w; x++) {
       *src.getAddr32(x, y) = SkPreMultiplyColor(SkColorSetARGB((i + 128) % 255,
           (i + 128) % 255, (i + 64) % 255, (i + 0) % 255));
       i++;
     }
   }
 
   color_utils::HSL hsl = { -1, -1, -1 };
   SkBitmap shifted = ReferenceCreateHSLShiftedBitmap(src, hsl);
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels shifted_lock(shifted);
-
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       SkColor src_pixel = *src.getAddr32(x, y);
       SkColor shifted_pixel = *shifted.getAddr32(x, y);
       EXPECT_TRUE(MultipliedColorsClose(src_pixel, shifted_pixel)) <<
           "source: (a,r,g,b) = (" << SkColorGetA(src_pixel) << "," <<
                                      SkColorGetR(src_pixel) << "," <<
                                      SkColorGetG(src_pixel) << "," <<
                                      SkColorGetB(src_pixel) << "); " <<
           "shifted: (a,r,g,b) = (" << SkColorGetA(shifted_pixel) << "," <<
@@ skipping 15 matching lines @@
       *src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255);
       i++;
     }
   }
 
   // Shift to red.
   color_utils::HSL hsl = { 0, -1, -1 };
 
   SkBitmap shifted = SkBitmapOperations::CreateHSLShiftedBitmap(src, hsl);
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels shifted_lock(shifted);
-
   for (int y = 0, i = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       EXPECT_TRUE(ColorsClose(shifted.getColor(x, y),
                               SkColorSetARGB(255, i % 255, 0, 0)));
       i++;
     }
   }
 }
 
 // Validate HSL shift.
@@ skipping 34 matching lines @@
 TEST(SkBitmapOperationsTest, CreateCroppedBitmap) {
   int src_w = 16, src_h = 16;
   SkBitmap src;
   FillDataToBitmap(src_w, src_h, &src);
 
   SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(src, 4, 4,
                                                               8, 8);
   ASSERT_EQ(8, cropped.width());
   ASSERT_EQ(8, cropped.height());
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels cropped_lock(cropped);
   for (int y = 4; y < 12; y++) {
     for (int x = 4; x < 12; x++) {
       EXPECT_EQ(*src.getAddr32(x, y),
                 *cropped.getAddr32(x - 4, y - 4));
     }
   }
 }
 
 // Test whether our cropping correctly wraps across image boundaries.
 TEST(SkBitmapOperationsTest, CreateCroppedBitmapWrapping) {
   int src_w = 16, src_h = 16;
   SkBitmap src;
   FillDataToBitmap(src_w, src_h, &src);
 
   SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(
       src, src_w / 2, src_h / 2, src_w, src_h);
   ASSERT_EQ(src_w, cropped.width());
   ASSERT_EQ(src_h, cropped.height());
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels cropped_lock(cropped);
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       EXPECT_EQ(*src.getAddr32(x, y),
                 *cropped.getAddr32((x + src_w / 2) % src_w,
                                    (y + src_h / 2) % src_h));
     }
   }
 }
 
 TEST(SkBitmapOperationsTest, DownsampleByTwo) {
@@ skipping 26 matching lines @@
   *input.getAddr32(2, 1) = 0xFF000000;
   *input.getAddr32(0, 2) = 0xFF000000;
   *input.getAddr32(1, 2) = 0xFFFFFFFF;
   *input.getAddr32(2, 2) = 0xFF808080;
 
   SkBitmap result = SkBitmapOperations::DownsampleByTwo(input);
   EXPECT_EQ(2, result.width());
   EXPECT_EQ(2, result.height());
 
   // Some of the values are off-by-one due to rounding.
-  SkAutoLockPixels lock(result);
   EXPECT_EQ(0x9f404040, *result.getAddr32(0, 0));
   EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(1, 0));
   EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(0, 1));
   EXPECT_EQ(0xFF808080, *result.getAddr32(1, 1));
 }
 
 // Test edge cases for DownsampleByTwo.
 TEST(SkBitmapOperationsTest, DownsampleByTwoSmall) {
   SkPMColor reference = 0xFF4080FF;
 
   // Test a 1x1 bitmap.
   SkBitmap one_by_one;
   one_by_one.allocN32Pixels(1, 1);
   *one_by_one.getAddr32(0, 0) = reference;
   SkBitmap result = SkBitmapOperations::DownsampleByTwo(one_by_one);
-  SkAutoLockPixels lock1(result);
   EXPECT_EQ(1, result.width());
   EXPECT_EQ(1, result.height());
   EXPECT_EQ(reference, *result.getAddr32(0, 0));
 
   // Test an n by 1 bitmap.
   SkBitmap one_by_n;
   one_by_n.allocN32Pixels(300, 1);
   result = SkBitmapOperations::DownsampleByTwo(one_by_n);
-  SkAutoLockPixels lock2(result);
   EXPECT_EQ(300, result.width());
   EXPECT_EQ(1, result.height());
 
   // Test a 1 by n bitmap.
   SkBitmap n_by_one;
   n_by_one.allocN32Pixels(1, 300);
   result = SkBitmapOperations::DownsampleByTwo(n_by_one);
-  SkAutoLockPixels lock3(result);
   EXPECT_EQ(1, result.width());
   EXPECT_EQ(300, result.height());
 
   // Test an empty bitmap
   SkBitmap empty;
   result = SkBitmapOperations::DownsampleByTwo(empty);
   EXPECT_TRUE(result.isNull());
   EXPECT_EQ(0, result.width());
   EXPECT_EQ(0, result.height());
 }
@@ skipping 31 matching lines @@
   // Set PMColors into the bitmap
   *input.getAddr32(0, 0) = SkPackARGB32NoCheck(0x80, 0x00, 0x00, 0x00);
   *input.getAddr32(1, 0) = SkPackARGB32NoCheck(0x80, 0x80, 0x80, 0x80);
   *input.getAddr32(0, 1) = SkPackARGB32NoCheck(0xFF, 0x00, 0xCC, 0x88);
   *input.getAddr32(1, 1) = SkPackARGB32NoCheck(0x00, 0x00, 0xCC, 0x88);
 
   SkBitmap result = SkBitmapOperations::UnPreMultiply(input);
   EXPECT_EQ(2, result.width());
   EXPECT_EQ(2, result.height());
 
-  SkAutoLockPixels lock(result);
   EXPECT_EQ(0x80000000, *result.getAddr32(0, 0));
   EXPECT_EQ(0x80FFFFFF, *result.getAddr32(1, 0));
   EXPECT_EQ(0xFF00CC88, *result.getAddr32(0, 1));
   EXPECT_EQ(0x00000000u, *result.getAddr32(1, 1));  // "Division by zero".
 }
 
 TEST(SkBitmapOperationsTest, CreateTransposedBitmap) {
   SkBitmap input;
   input.allocN32Pixels(2, 3);
 
   for (int x = 0; x < input.width(); ++x) {
     for (int y = 0; y < input.height(); ++y) {
       *input.getAddr32(x, y) = x * input.width() + y;
     }
   }
 
   SkBitmap result = SkBitmapOperations::CreateTransposedBitmap(input);
   EXPECT_EQ(3, result.width());
   EXPECT_EQ(2, result.height());
 
-  SkAutoLockPixels lock(result);
   for (int x = 0; x < input.width(); ++x) {
     for (int y = 0; y < input.height(); ++y) {
       EXPECT_EQ(*input.getAddr32(x, y), *result.getAddr32(y, x));
     }
   }
 }
 
 void DrawRectWithColor(SkCanvas* canvas,
                        int left,
                        int top,
@@ skipping 38 matching lines @@
   rotate270 = SkBitmapOperations::Rotate(src,
                                          SkBitmapOperations::ROTATION_270_CW);
 
   ASSERT_EQ(rotate90.width(), src.height());
   ASSERT_EQ(rotate90.height(), src.width());
   ASSERT_EQ(rotate180.width(), src.width());
   ASSERT_EQ(rotate180.height(), src.height());
   ASSERT_EQ(rotate270.width(), src.height());
   ASSERT_EQ(rotate270.height(), src.width());
 
-  SkAutoLockPixels lock_src(src);
-  SkAutoLockPixels lock_90(rotate90);
-  SkAutoLockPixels lock_180(rotate180);
-  SkAutoLockPixels lock_270(rotate270);
-
   for (int x=0; x < src_w; ++x) {
     for (int y=0; y < src_h; ++y) {
       ASSERT_EQ(*src.getAddr32(x,y), *rotate90.getAddr32(src_h - (y+1),x));
       ASSERT_EQ(*src.getAddr32(x,y), *rotate270.getAddr32(y, src_w - (x+1)));
       ASSERT_EQ(*src.getAddr32(x,y),
                 *rotate180.getAddr32(src_w - (x+1), src_h - (y+1)));
     }
   }
 }