SkBitmap and SkPixelRef no longer need lock/unlock

chrome/browser/android/thumbnail/thumbnail_cache.cc

 // Copyright 2014 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/android/thumbnail/thumbnail_cache.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 484 matching lines @@
   if (!WriteBigEndianToFile(file, kCompressedKey))
     return false;
 
   if (!WriteBigEndianToFile(file, content_size.width()))
     return false;
 
   if (!WriteBigEndianToFile(file, content_size.height()))
     return false;
 
   // Write ETC1 header.
-  compressed_data->lockPixels();
-
   unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
   etc1_pkm_format_header(etc1_buffer,
                          compressed_data->info().width(),
                          compressed_data->info().height());
 
   int header_bytes_written = file.WriteAtCurrentPos(
       reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
   if (header_bytes_written != ETC_PKM_HEADER_SIZE)
     return false;
 
   int data_size = etc1_get_encoded_data_size(
       compressed_data->info().width(),
       compressed_data->info().height());
   int pixel_bytes_written = file.WriteAtCurrentPos(
       reinterpret_cast<char*>(compressed_data->pixels()),
       data_size);
   if (pixel_bytes_written != data_size)
     return false;
 
-  compressed_data->unlockPixels();
-
   if (!WriteBigEndianToFile(file, kCurrentExtraVersion))
     return false;
 
   if (!WriteBigEndianFloatToFile(file, 1.f / scale))
     return false;
 
   return true;
 }
 
 }  // anonymous namespace
@@ skipping 30 matching lines @@
 
 void ThumbnailCache::CompressionTask(
     SkBitmap raw_data,
     gfx::Size encoded_size,
     const base::Callback<void(sk_sp<SkPixelRef>, const gfx::Size&)>&
         post_compression_task) {
   sk_sp<SkPixelRef> compressed_data;
   gfx::Size content_size;
 
   if (!raw_data.empty()) {
-    SkAutoLockPixels raw_data_lock(raw_data);
     gfx::Size raw_data_size(raw_data.width(), raw_data.height());
     size_t pixel_size = 4;  // Pixel size is 4 bytes for kARGB_8888_Config.
     size_t stride = pixel_size * raw_data_size.width();
 
     size_t encoded_bytes =
         etc1_get_encoded_data_size(encoded_size.width(), encoded_size.height());
     SkImageInfo info = SkImageInfo::Make(encoded_size.width(),
                                          encoded_size.height(),
                                          kUnknown_SkColorType,
                                          kUnpremul_SkAlphaType);
     sk_sp<SkData> etc1_pixel_data(SkData::MakeUninitialized(encoded_bytes));
     sk_sp<SkPixelRef> etc1_pixel_ref(SkMallocPixelRef::MakeWithData(
         info, 0, NULL, std::move(etc1_pixel_data)));
 
-    etc1_pixel_ref->lockPixels();
     bool success = etc1_encode_image(
         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
         raw_data_size.width(),
         raw_data_size.height(),
         pixel_size,
         stride,
         reinterpret_cast<unsigned char*>(etc1_pixel_ref->pixels()),
         encoded_size.width(),
         encoded_size.height());
     etc1_pixel_ref->setImmutable();
-    etc1_pixel_ref->unlockPixels();
 
     if (success) {
       compressed_data = std::move(etc1_pixel_ref);
       content_size = raw_data_size;
     }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
@@ skipping 238 matching lines @@
 
   if (compressed_data.get()) {
     gfx::Size buffer_size = gfx::Size(compressed_data->info().width(),
                                       compressed_data->info().height());
 
     SkBitmap raw_data;
     raw_data.allocPixels(SkImageInfo::Make(buffer_size.width(),
                                            buffer_size.height(),
                                            kRGBA_8888_SkColorType,
                                            kOpaque_SkAlphaType));
-    SkAutoLockPixels raw_data_lock(raw_data);
-    compressed_data->lockPixels();
     success = etc1_decode_image(
         reinterpret_cast<unsigned char*>(compressed_data->pixels()),
         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
         buffer_size.width(),
         buffer_size.height(),
         raw_data.bytesPerPixel(),
         raw_data.rowBytes());
-    compressed_data->unlockPixels();
     raw_data.setImmutable();
 
     if (!success) {
       // Leave raw_data_small empty for consistency with other failure modes.
     } else if (content_size == buffer_size) {
       // Shallow copy the pixel reference.
       raw_data_small = raw_data;
     } else {
       // The content size is smaller than the buffer size (likely because of
       // a power-of-two rounding), so deep copy the bitmap.
       raw_data_small.allocPixels(SkImageInfo::Make(content_size.width(),
                                                    content_size.height(),
                                                    kRGBA_8888_SkColorType,
                                                    kOpaque_SkAlphaType));
-      SkAutoLockPixels raw_data_small_lock(raw_data_small);
       SkCanvas small_canvas(raw_data_small);
       small_canvas.drawBitmap(raw_data, 0, 0);
       raw_data_small.setImmutable();
     }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(post_decompression_callback, success, raw_data_small));
 }
 
 ThumbnailCache::ThumbnailMetaData::ThumbnailMetaData() {
 }
 
 ThumbnailCache::ThumbnailMetaData::ThumbnailMetaData(
     const base::Time& current_time,
     const GURL& url)
     : capture_time_(current_time), url_(url) {
 }
 
 std::pair<SkBitmap, float> ThumbnailCache::CreateApproximation(
     const SkBitmap& bitmap,
     float scale) {
   DCHECK(!bitmap.empty());
   DCHECK_GT(scale, 0);
-  SkAutoLockPixels bitmap_lock(bitmap);
   float new_scale = 1.f / kApproximationScaleFactor;
 
   gfx::Size dst_size = gfx::ScaleToFlooredSize(
       gfx::Size(bitmap.width(), bitmap.height()), new_scale);
   SkBitmap dst_bitmap;
   dst_bitmap.allocPixels(SkImageInfo::Make(dst_size.width(),
                                            dst_size.height(),
                                            bitmap.info().colorType(),
                                            bitmap.info().alphaType()));
   dst_bitmap.eraseColor(0);
-  SkAutoLockPixels dst_bitmap_lock(dst_bitmap);
-
   SkCanvas canvas(dst_bitmap);
   canvas.scale(new_scale, new_scale);
   canvas.drawBitmap(bitmap, 0, 0, NULL);
   dst_bitmap.setImmutable();
 
   return std::make_pair(dst_bitmap, new_scale * scale);
 }
 
 void ThumbnailCache::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
     cache_.Clear();
     approximation_cache_.Clear();
   }
 }