SkBitmap and SkPixelRef no longer need lock/unlock

ui/gfx/color_analysis.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/color_analysis.h"
 
 #include <limits.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 122 matching lines @@
   uint32_t counter_;
 
   // The weight of the cluster, determined by how many points were used
   // to generate the previous centroid.
   uint32_t weight_;
 };
 
 // Un-premultiplies each pixel in |bitmap| into an output |buffer|. Requires
 // approximately 10 microseconds for a 16x16 icon on an Intel Core i5.
 void UnPreMultiply(const SkBitmap& bitmap, uint32_t* buffer, int buffer_size) {
-  SkAutoLockPixels auto_lock(bitmap);
   uint32_t* in = static_cast<uint32_t*>(bitmap.getPixels());
   uint32_t* out = buffer;
   int pixel_count = std::min(bitmap.width() * bitmap.height(), buffer_size);
   for (int i = 0; i < pixel_count; ++i)
     *out++ = SkUnPreMultiply::PMColorToColor(*in++);
 }
 
 // Prominent color utilities ---------------------------------------------------
 
 // A color value with an associated weight.
@@ skipping 203 matching lines @@
 //   different color profiles.
 //   * This code doesn't try to heuristically derive missing colors from
 //   existing colors.
 SkColor CalculateProminentColor(const SkBitmap& bitmap,
                                 const HSL& lower_bound,
                                 const HSL& upper_bound,
                                 const HSL& goal) {
   DCHECK(!bitmap.empty());
   DCHECK(!bitmap.isNull());
 
-  SkAutoLockPixels auto_lock(bitmap);
   const uint32_t* pixels = static_cast<uint32_t*>(bitmap.getPixels());
   const int pixel_count = bitmap.width() * bitmap.height();
 
   // For better performance, only consider at most 10k pixels (evenly
   // distributed throughout the image). This has a very minor impact on the
   // outcome but improves runtime substantially for large images. 10,007 is a
   // prime number to reduce the chance of picking an unrepresentative sample.
   constexpr int kMaxConsideredPixels = 10007;
   const int pixel_increment = std::max(1, pixel_count / kMaxConsideredPixels);
   std::unordered_map<SkColor, int> color_counts(kMaxConsideredPixels);
@@ skipping 393 matching lines @@
       upper_bound.s = 0.4f;
       goal.s = 0.3f;
       break;
   }
 
   return CalculateProminentColor(bitmap, lower_bound, upper_bound, goal);
 }
 
 gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
   // First need basic stats to normalize each channel separately.
-  SkAutoLockPixels bitmap_lock(bitmap);
   gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
   if (!bitmap.getPixels())
     return covariance;
 
   // Assume ARGB_8888 format.
   DCHECK(bitmap.colorType() == kN32_SkColorType);
 
   int64_t r_sum = 0;
   int64_t g_sum = 0;
   int64_t b_sum = 0;
@@ skipping 58 matching lines @@
           static_cast<double>(bb_sum) / pixel_n -
               static_cast<double>(b_sum * b_sum) / pixel_n / pixel_n));
   return covariance;
 }
 
 bool ApplyColorReduction(const SkBitmap& source_bitmap,
                          const gfx::Vector3dF& color_transform,
                          bool fit_to_range,
                          SkBitmap* target_bitmap) {
   DCHECK(target_bitmap);
-  SkAutoLockPixels source_lock(source_bitmap);
-  SkAutoLockPixels target_lock(*target_bitmap);
-
   DCHECK(source_bitmap.getPixels());
   DCHECK(target_bitmap->getPixels());
   DCHECK_EQ(kN32_SkColorType, source_bitmap.colorType());
   DCHECK_EQ(kAlpha_8_SkColorType, target_bitmap->colorType());
   DCHECK_EQ(source_bitmap.height(), target_bitmap->height());
   DCHECK_EQ(source_bitmap.width(), target_bitmap->width());
   DCHECK(!source_bitmap.empty());
 
   // Elements of color_transform are explicitly off-loaded to local values for
   // efficiency reasons. Note that in practice images may correspond to entire
@@ skipping 65 matching lines @@
   gfx::Matrix3F covariance = ComputeColorCovariance(source_bitmap);
   gfx::Matrix3F eigenvectors = gfx::Matrix3F::Zeros();
   gfx::Vector3dF eigenvals = covariance.SolveEigenproblem(&eigenvectors);
   gfx::Vector3dF principal = eigenvectors.get_column(0);
   if (eigenvals == gfx::Vector3dF() || principal == gfx::Vector3dF())
     return false;  // This may happen for some edge cases.
   return ApplyColorReduction(source_bitmap, principal, true, target_bitmap);
 }
 
 }  // color_utils