SkBitmap and SkPixelRef no longer need lock/unlock

skia/ext/image_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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
 #include <iomanip>
@@ skipping 144 matching lines @@
 
 // DEBUG_BITMAP_GENERATION (0 or 1) controls whether the routines
 // to save the test bitmaps are present. By default the test just fails
 // without reading/writing files but it is then convenient to have
 // a simple way to make the failing tests write out the input/output images
 // to check them visually.
 #define DEBUG_BITMAP_GENERATION (0)
 
 #if DEBUG_BITMAP_GENERATION
 void SaveBitmapToPNG(const SkBitmap& bmp, const char* path) {
-  SkAutoLockPixels lock(bmp);
   std::vector<unsigned char> png;
   gfx::PNGCodec::ColorFormat color_format = gfx::PNGCodec::FORMAT_RGBA;
   if (!gfx::PNGCodec::Encode(
           reinterpret_cast<const unsigned char*>(bmp.getPixels()),
           color_format, gfx::Size(bmp.width(), bmp.height()),
           static_cast<int>(bmp.rowBytes()),
           false, std::vector<gfx::PNGCodec::Comment>(), &png)) {
     FAIL() << "Failed to encode image";
   }
 
@@ skipping 12 matching lines @@
   const int src_w = 16, src_h = 34;
   SkBitmap src;
   FillDataToBitmap(src_w, src_h, &src);
 
   // Do a resize of the full bitmap to the same size. The lanczos filter is good
   // enough that we should get exactly the same image for output.
   SkBitmap results = skia::ImageOperations::Resize(src, method, src_w, src_h);
   ASSERT_EQ(src_w, results.width());
   ASSERT_EQ(src_h, results.height());
 
-  SkAutoLockPixels src_lock(src);
-  SkAutoLockPixels results_lock(results);
   for (int y = 0; y < src_h; y++) {
     for (int x = 0; x < src_w; x++) {
       EXPECT_EQ(*src.getAddr32(x, y), *results.getAddr32(x, y));
     }
   }
 }
 
 // Types defined outside of the ResizeShouldAverageColors test to allow
 // use of the arraysize() macro.
 //
@@ skipping 44 matching lines @@
   const skia::ImageOperations::ResizeMethod method = tested_method.method;
 
   SkBitmap dest = skia::ImageOperations::Resize(src, method, dest_w, dest_h);
   ASSERT_EQ(dest_w, dest.width());
   ASSERT_EQ(dest_h, dest.height());
 
   // Check that pixels match the expected average.
   float max_observed_distance = 0.0f;
   bool all_pixels_ok = true;
 
-  SkAutoLockPixels dest_lock(dest);
-
   for (size_t pixel_index = 0;
        pixel_index < arraysize(tested_pixels);
        ++pixel_index) {
     const TestedPixel& tested_pixel = tested_pixels[pixel_index];
 
     const int   x = tested_pixel.x;
     const int   y = tested_pixel.y;
     const float max_allowed_distance =
         std::max(tested_pixel.max_color_distance,
                  tested_method.max_color_distance_override);
@@ skipping 84 matching lines @@
   SkBitmap src;
   FillDataToBitmap(src_w, src_h, &src);
 
   // Do a halving of the full bitmap.
   SkBitmap actual_results = skia::ImageOperations::Resize(
       src, skia::ImageOperations::RESIZE_BOX, src_w / 2, src_h / 2);
   ASSERT_EQ(src_w / 2, actual_results.width());
   ASSERT_EQ(src_h / 2, actual_results.height());
 
   // Compute the expected values & compare.
-  SkAutoLockPixels lock(actual_results);
   for (int y = 0; y < actual_results.height(); y++) {
     for (int x = 0; x < actual_results.width(); x++) {
       // Note that those expressions take into account the "half-pixel"
       // offset that comes into play due to considering the coordinates
       // of the center of the pixels. So x * 2 is a simplification
       // of ((x+0.5) * 2 - 1) and (x * 2 + 1) is really (x + 0.5) * 2.
       int first_x = x * 2;
       int last_x = std::min(src_w - 1, x * 2 + 1);
 
       int first_y = y * 2;
@@ skipping 33 matching lines @@
   // destination coordinate system (max = half of the original image size).
   SkIRect subset_rect = { 2, 3, 3, 6 };
   SkBitmap subset_results = skia::ImageOperations::Resize(
       src, skia::ImageOperations::RESIZE_BOX,
       src_w / 2, src_h / 2, subset_rect);
   ASSERT_EQ(subset_rect.width(), subset_results.width());
   ASSERT_EQ(subset_rect.height(), subset_results.height());
 
   // The computed subset and the corresponding subset of the original image
   // should be the same.
-  SkAutoLockPixels full_lock(full_results);
-  SkAutoLockPixels subset_lock(subset_results);
   for (int y = 0; y < subset_rect.height(); y++) {
     for (int x = 0; x < subset_rect.width(); x++) {
       ASSERT_EQ(
           *full_results.getAddr32(x + subset_rect.fLeft, y + subset_rect.fTop),
           *subset_results.getAddr32(x, y));
     }
   }
 }
 
 TEST(ImageOperations, InvalidParams) {
@@ skipping 100 matching lines @@
                                                           10 + src_x * 100,
                                                           10 + src_y * 100,
                                                           0);
     }
   }
 
   SkBitmap dst = skia::ImageOperations::Resize(
       src,
       skia::ImageOperations::RESIZE_LANCZOS3,
       dst_w, dst_h);
-  SkAutoLockPixels dst_lock(dst);
   for (int dst_y = 0; dst_y < dst_h; ++dst_y) {
     for (int dst_x = 0; dst_x < dst_w; ++dst_x) {
       float dst_x_in_src = (dst_x + 0.5) * src_w / dst_w;
       float dst_y_in_src = (dst_y + 0.5) * src_h / dst_h;
       float a = 0.0f;
       float r = 0.0f;
       float g = 0.0f;
       float b = 0.0f;
       float sum = 0.0f;
       for (int src_y = 0; src_y < src_h; ++src_y) {
@@ skipping 25 matching lines @@
       EXPECT_LE(fabs(SkColorGetA(dst_color) - a), 1.5f);
       EXPECT_LE(fabs(SkColorGetR(dst_color) - r), 1.5f);
       EXPECT_LE(fabs(SkColorGetG(dst_color) - g), 1.5f);
       EXPECT_LE(fabs(SkColorGetB(dst_color) - b), 1.5f);
       if (HasFailure()) {
         return;
       }
     }
   }
 }