SkBitmap and SkPixelRef no longer need lock/unlock

ui/gfx/icon_util.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/icon_util.h"
 
 #include <memory>
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
@@ skipping 101 matching lines @@
     // All images should have one of the kIconDimensions sizes.
     DCHECK_GT(image.Width(), 0);
     DCHECK_LE(image.Width(), IconUtil::kLargeIconSize);
     DCHECK_GT(image.Height(), 0);
     DCHECK_LE(image.Height(), IconUtil::kLargeIconSize);
 
     SkBitmap bitmap = image.AsBitmap();
 
     // Only 32 bit ARGB bitmaps are supported. We also make sure the bitmap has
     // been properly initialized.
-    SkAutoLockPixels bitmap_lock(bitmap);
     if ((bitmap.colorType() != kN32_SkColorType) ||
         (bitmap.getPixels() == NULL)) {
       return false;
     }
 
     // Special case: Icons exactly 256x256 are stored in PNG format.
     if (image.Width() == IconUtil::kLargeIconSize &&
         image.Height() == IconUtil::kLargeIconSize) {
       *png_bytes = image.As1xPNGBytes();
     } else {
@@ skipping 27 matching lines @@
   256   // Used by Vista onwards for large icons.
 };
 
 const size_t IconUtil::kNumIconDimensions = arraysize(kIconDimensions);
 const size_t IconUtil::kNumIconDimensionsUpToMediumSize = 9;
 
 base::win::ScopedHICON IconUtil::CreateHICONFromSkBitmap(
     const SkBitmap& bitmap) {
   // Only 32 bit ARGB bitmaps are supported. We also try to perform as many
   // validations as we can on the bitmap.
-  SkAutoLockPixels bitmap_lock(bitmap);
   if ((bitmap.colorType() != kN32_SkColorType) ||
       (bitmap.width() <= 0) || (bitmap.height() <= 0) ||
       (bitmap.getPixels() == NULL))
     return base::win::ScopedHICON();
 
   // We start by creating a DIB which we'll use later on in order to create
   // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert
   // may contain an alpha channel and the V5 header allows us to specify the
   // alpha mask for the DIB.
   BITMAPV5HEADER bitmap_header;
@@ skipping 199 matching lines @@
 SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon,
                                                  const gfx::Size& s) {
   DCHECK(icon);
   DCHECK(!s.IsEmpty());
 
   // Allocating memory for the SkBitmap object. We are going to create an ARGB
   // bitmap so we should set the configuration appropriately.
   SkBitmap bitmap;
   bitmap.allocN32Pixels(s.width(), s.height());
   bitmap.eraseARGB(0, 0, 0, 0);
-  SkAutoLockPixels bitmap_lock(bitmap);
 
   // Now we should create a DIB so that we can use ::DrawIconEx in order to
   // obtain the icon's image.
   BITMAPV5HEADER h;
   InitializeBitmapHeader(&h, s.width(), s.height());
   HDC hdc = ::GetDC(NULL);
   uint32_t* bits;
   HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h),
       DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
   DCHECK(dib);
@@ skipping 232 matching lines @@
   // opaque.
   unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image);
   unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER);
   CopySkBitmapBitsIntoIconBuffer(bitmap, xor_mask_addr, xor_mask_size);
   *image_byte_count = bytes_in_resource;
 }
 
 void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
                                               unsigned char* buffer,
                                               size_t buffer_size) {
-  SkAutoLockPixels bitmap_lock(bitmap);
   unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels());
   size_t bitmap_size = bitmap.height() * bitmap.width() * 4;
   DCHECK_EQ(buffer_size, bitmap_size);
   for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) {
     memcpy(buffer + bitmap_size - bitmap.width() * 4 - i,
            bitmap_ptr + i,
            bitmap.width() * 4);
   }
 }
 
@@ skipping 48 matching lines @@
   // Once we compute the size for a singe AND mask scan line, we multiply that
   // number by the image height in order to get the total number of bytes for
   // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
   // for the monochrome bitmap representing the AND mask.
   size_t and_line_length = (bitmap.width() + 7) >> 3;
   and_line_length = (and_line_length + 3) & ~3;
   size_t and_mask_size = and_line_length * bitmap.height();
   size_t masks_size = *xor_mask_size + and_mask_size;
   *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
 }