SkBitmap and SkPixelRef no longer need lock/unlock

chrome/browser/thumbnails/content_analysis.cc

 // Copyright (c) 2013 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 "chrome/browser/thumbnails/content_analysis.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 216 matching lines @@
 
 }  // namespace
 
 namespace thumbnailing_utils {
 
 void ApplyGaussianGradientMagnitudeFilter(SkBitmap* input_bitmap,
                                           float kernel_sigma) {
   // The purpose of this function is to highlight salient
   // (attention-attracting?) features of the image for use in image
   // retargeting.
-  SkAutoLockPixels source_lock(*input_bitmap);
   DCHECK(input_bitmap);
   DCHECK(input_bitmap->getPixels());
   DCHECK_EQ(kAlpha_8_SkColorType, input_bitmap->colorType());
 
   // To perform computations we will need one intermediate buffer. It can
   // very well be just another bitmap.
   const SkISize image_size = SkISize::Make(input_bitmap->width(),
                                            input_bitmap->height());
   SkBitmap intermediate;
   intermediate.allocPixels(input_bitmap->info().makeWH(image_size.width(),
@@ skipping 128 matching lines @@
     }
   }
 }
 
 void ExtractImageProfileInformation(const SkBitmap& input_bitmap,
                                     const gfx::Rect& area,
                                     const gfx::Size& target_size,
                                     bool apply_log,
                                     std::vector<float>* rows,
                                     std::vector<float>* columns) {
-  SkAutoLockPixels source_lock(input_bitmap);
   DCHECK(rows);
   DCHECK(columns);
   DCHECK(input_bitmap.getPixels());
   DCHECK_EQ(kAlpha_8_SkColorType, input_bitmap.colorType());
   DCHECK_GE(area.x(), 0);
   DCHECK_GE(area.y(), 0);
   DCHECK_LE(area.right(), input_bitmap.width());
   DCHECK_LE(area.bottom(), input_bitmap.height());
 
   // Make sure rows and columns are allocated and initialized to 0.
@@ skipping 260 matching lines @@
   } else {
     included_columns->resize(column_profile.size());
     for (size_t i = 0; i < column_profile.size(); ++i)
       (*included_columns)[i] = column_profile[i] > column_threshold;
   }
 }
 
 SkBitmap ComputeDecimatedImage(const SkBitmap& bitmap,
                                const std::vector<bool>& rows,
                                const std::vector<bool>& columns) {
-  SkAutoLockPixels source_lock(bitmap);
   DCHECK(bitmap.getPixels());
   DCHECK_GT(bitmap.bytesPerPixel(), 0);
   DCHECK_EQ(bitmap.width(), static_cast<int>(columns.size()));
   DCHECK_EQ(bitmap.height(), static_cast<int>(rows.size()));
 
   unsigned target_row_count = std::count(rows.begin(), rows.end(), true);
   unsigned target_column_count = std::count(
       columns.begin(), columns.end(), true);
 
   if (target_row_count == 0 || target_column_count == 0)
@@ skipping 86 matching lines @@
                                  target_size,
                                  &included_rows,
                                  &included_columns);
 
   // Use the original image and computed inclusion vectors to create a resized
   // image.
   return ComputeDecimatedImage(source_bitmap, included_rows, included_columns);
 }
 
 }  // namespace thumbnailing_utils