SkBitmap and SkPixelRef no longer need lock/unlock

content/browser/renderer_host/render_widget_host_view_android.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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 266 matching lines @@
   if (holder) {
     holder->ReleaseIfPossible();
   }
 }
 
 void CopyFromCompositingSurfaceFinished(
     const ReadbackRequestCallback& callback,
     std::unique_ptr<cc::SingleReleaseCallback> release_callback,
     std::unique_ptr<SkBitmap> bitmap,
     const base::TimeTicks& start_time,
-    std::unique_ptr<SkAutoLockPixels> bitmap_pixels_lock,
     scoped_refptr<PendingReadbackLock> readback_lock,
     bool result) {
   TRACE_EVENT0(
       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
-  bitmap_pixels_lock.reset();
   gpu::SyncToken sync_token;
   if (result) {
     display_compositor::GLHelper* gl_helper = GetPostReadbackGLHelper();
     if (gl_helper)
       gl_helper->GenerateSyncToken(&sync_token);
   }
 
   // PostTask() to make sure the |readback_lock| is released. Also do this
   // synchronous GPU operation in a clean callstack.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
@@ skipping 73 matching lines @@
   std::unique_ptr<SkBitmap> bitmap(new SkBitmap);
   if (!bitmap->tryAllocPixels(SkImageInfo::Make(output_size_in_pixel.width(),
                                                 output_size_in_pixel.height(),
                                                 color_type,
                                                 kOpaque_SkAlphaType))) {
     scoped_callback_runner.ReplaceClosure(
         base::Bind(callback, SkBitmap(), READBACK_BITMAP_ALLOCATION_FAILURE));
     return;
   }
 
-  std::unique_ptr<SkAutoLockPixels> bitmap_pixels_lock(
-      new SkAutoLockPixels(*bitmap));
   uint8_t* pixels = static_cast<uint8_t*>(bitmap->getPixels());
 
   ignore_result(scoped_callback_runner.Release());
 
   gl_helper->CropScaleReadbackAndCleanMailbox(
       texture_mailbox.mailbox(), texture_mailbox.sync_token(), result->size(),
       gfx::Rect(result->size()), output_size_in_pixel, pixels, color_type,
       base::Bind(&CopyFromCompositingSurfaceFinished, callback,
                  base::Passed(&release_callback), base::Passed(&bitmap),
-                 start_time, base::Passed(&bitmap_pixels_lock), readback_lock),
+                 start_time, readback_lock),
       display_compositor::GLHelper::SCALER_QUALITY_GOOD);
 }
 
 void RecordToolTypeForActionDown(const ui::MotionEventAndroid& event) {
   ui::MotionEventAndroid::Action action = event.GetAction();
   if (action == ui::MotionEventAndroid::ACTION_DOWN ||
       action == ui::MotionEventAndroid::ACTION_POINTER_DOWN ||
       action == ui::MotionEventAndroid::ACTION_BUTTON_PRESS) {
     UMA_HISTOGRAM_ENUMERATION("Event.AndroidActionDown.ToolType",
                               event.GetToolType(0),
@@ skipping 1787 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content