Replace many skia::RefPtr with sk_sp<> in cc/

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 291 matching lines @@
     count++;
   }
 
   ReadNextThumbnail();
 }
 
 void ThumbnailCache::DecompressThumbnailFromFile(
     TabId tab_id,
     const base::Callback<void(bool, SkBitmap)>&
         post_decompress_callback) {
-  base::Callback<void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>
+  base::Callback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
       decompress_task = base::Bind(
           &ThumbnailCache::DecompressionTask, post_decompress_callback);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&ThumbnailCache::ReadTask, true, tab_id, decompress_task));
 }
 
 void ThumbnailCache::RemoveFromDisk(TabId tab_id) {
   base::Closure task =
       base::Bind(&ThumbnailCache::RemoveFromDiskTask, tab_id);
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE, task);
 }
 
 void ThumbnailCache::RemoveFromDiskTask(TabId tab_id) {
   base::FilePath file_path = GetFilePath(tab_id);
   if (base::PathExists(file_path))
     base::DeleteFile(file_path, false);
 }
 
 void ThumbnailCache::WriteThumbnailIfNecessary(
     TabId tab_id,
-    skia::RefPtr<SkPixelRef> compressed_data,
+    sk_sp<SkPixelRef> compressed_data,
     float scale,
     const gfx::Size& content_size) {
   if (write_tasks_count_ >= write_queue_max_size_)
     return;
 
   write_tasks_count_++;
 
   base::Callback<void()> post_write_task =
       base::Bind(&ThumbnailCache::PostWriteTask, weak_factory_.GetWeakPtr());
   content::BrowserThread::PostTask(content::BrowserThread::FILE,
@@ skipping 11 matching lines @@
     const base::Time& time_stamp,
     const SkBitmap& bitmap,
     float scale) {
   if (compression_tasks_count_ >= compression_queue_max_size_) {
     RemoveOnMatchedTimeStamp(tab_id, time_stamp);
     return;
   }
 
   compression_tasks_count_++;
 
-  base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>
+  base::Callback<void(sk_sp<SkPixelRef>, const gfx::Size&)>
       post_compression_task = base::Bind(&ThumbnailCache::PostCompressionTask,
                                          weak_factory_.GetWeakPtr(),
                                          tab_id,
                                          time_stamp,
                                          scale);
 
   gfx::Size raw_data_size(bitmap.width(), bitmap.height());
   gfx::Size encoded_size = GetEncodedSize(
       raw_data_size, ui_resource_provider_->SupportsETC1NonPowerOfTwo());
 
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&ThumbnailCache::CompressionTask,
                                         bitmap,
                                         encoded_size,
                                         post_compression_task),
                              true);
 }
 
 void ThumbnailCache::ReadNextThumbnail() {
   if (read_queue_.empty() || read_in_progress_)
     return;
 
   TabId tab_id = read_queue_.front();
   read_in_progress_ = true;
 
-  base::Callback<void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>
+  base::Callback<void(sk_sp<SkPixelRef>, float, const gfx::Size&)>
       post_read_task = base::Bind(
           &ThumbnailCache::PostReadTask, weak_factory_.GetWeakPtr(), tab_id);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&ThumbnailCache::ReadTask, false, tab_id, post_read_task));
 }
 
 void ThumbnailCache::MakeSpaceForNewItemIfNecessary(TabId tab_id) {
@@ skipping 58 matching lines @@
   cached_thumbnail = approximation_cache_.Get(tab_id);
   if (cached_thumbnail && cached_thumbnail->ui_resource_id() == uid)
     approximation_cache_.Remove(tab_id);
 }
 
 namespace {
 
 bool WriteToFile(base::File& file,
                  const gfx::Size& content_size,
                  const float scale,
-                 skia::RefPtr<SkPixelRef> compressed_data) {
+                 sk_sp<SkPixelRef> compressed_data) {
   if (!file.IsValid())
     return false;
 
   if (!WriteBigEndianToFile(file, kCompressedKey))
     return false;
 
   if (!WriteBigEndianToFile(file, content_size.width()))
     return false;
 
   if (!WriteBigEndianToFile(file, content_size.height()))
@@ skipping 28 matching lines @@
 
   if (!WriteBigEndianFloatToFile(file, 1.f / scale))
     return false;
 
   return true;
 }
 
 }  // anonymous namespace
 
 void ThumbnailCache::WriteTask(TabId tab_id,
-                               skia::RefPtr<SkPixelRef> compressed_data,
+                               sk_sp<SkPixelRef> compressed_data,
                                float scale,
                                const gfx::Size& content_size,
                                const base::Callback<void()>& post_write_task) {
   DCHECK(compressed_data);
 
   base::FilePath file_path = GetFilePath(tab_id);
 
   base::File file(file_path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
 
@@ skipping 11 matching lines @@
       content::BrowserThread::UI, FROM_HERE, post_write_task);
 }
 
 void ThumbnailCache::PostWriteTask() {
   write_tasks_count_--;
 }
 
 void ThumbnailCache::CompressionTask(
     SkBitmap raw_data,
     gfx::Size encoded_size,
-    const base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>&
+    const base::Callback<void(sk_sp<SkPixelRef>, const gfx::Size&)>&
         post_compression_task) {
-  skia::RefPtr<SkPixelRef> compressed_data;
+  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);
-    skia::RefPtr<SkData> etc1_pixel_data = skia::AdoptRef(
-        SkData::NewUninitialized(encoded_bytes));
-    skia::RefPtr<SkMallocPixelRef> etc1_pixel_ref = skia::AdoptRef(
+    sk_sp<SkData> etc1_pixel_data(SkData::NewUninitialized(encoded_bytes));
+    sk_sp<SkMallocPixelRef> etc1_pixel_ref(
         SkMallocPixelRef::NewWithData(info, 0, NULL, etc1_pixel_data.get()));
 
     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 = etc1_pixel_ref;
+      compressed_data = std::move(etc1_pixel_ref);
       content_size = raw_data_size;
     }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
-      base::Bind(post_compression_task, compressed_data, content_size));
+      base::Bind(post_compression_task, std::move(compressed_data),
+                 content_size));
 }
 
 void ThumbnailCache::PostCompressionTask(
     TabId tab_id,
     const base::Time& time_stamp,
     float scale,
-    skia::RefPtr<SkPixelRef> compressed_data,
+    sk_sp<SkPixelRef> compressed_data,
     const gfx::Size& content_size) {
   compression_tasks_count_--;
   if (!compressed_data) {
     RemoveOnMatchedTimeStamp(tab_id, time_stamp);
     return;
   }
 
   Thumbnail* thumbnail = cache_.Get(tab_id);
   if (thumbnail) {
     if (thumbnail->time_stamp() != time_stamp)
       return;
     thumbnail->SetCompressedBitmap(compressed_data, content_size);
     thumbnail->CreateUIResource();
   }
-  WriteThumbnailIfNecessary(tab_id, compressed_data, scale, content_size);
+  WriteThumbnailIfNecessary(tab_id, std::move(compressed_data), scale,
+                            content_size);
 }
 
 namespace {
 
 bool ReadFromFile(base::File& file,
                   gfx::Size* out_content_size,
                   float* out_scale,
-                  skia::RefPtr<SkPixelRef>* out_pixels) {
+                  sk_sp<SkPixelRef>* out_pixels) {
   if (!file.IsValid())
     return false;
 
   int key = 0;
   if (!ReadBigEndianFromFile(file, &key))
     return false;
 
   if (key != kCompressedKey)
     return false;
 
@@ skipping 37 matching lines @@
                                display_info.GetDisplayHeight());
 
   if (content_width > max_dimension
       || content_height > max_dimension
       || static_cast<size_t>(raw_width) > NextPowerOfTwo(max_dimension)
       || static_cast<size_t>(raw_height) > NextPowerOfTwo(max_dimension)) {
     return false;
   }
 
   int data_size = etc1_get_encoded_data_size(raw_width, raw_height);
-  skia::RefPtr<SkData> etc1_pixel_data =
-      skia::AdoptRef(SkData::NewUninitialized(data_size));
+  sk_sp<SkData> etc1_pixel_data(SkData::NewUninitialized(data_size));
 
   int pixel_bytes_read = file.ReadAtCurrentPos(
       reinterpret_cast<char*>(etc1_pixel_data->writable_data()),
       data_size);
 
   if (pixel_bytes_read != data_size)
     return false;
 
   SkImageInfo info = SkImageInfo::Make(raw_width,
                                        raw_height,
                                        kUnknown_SkColorType,
                                        kUnpremul_SkAlphaType);
 
-  *out_pixels = skia::AdoptRef(
+  *out_pixels = sk_sp<SkPixelRef>(
       SkMallocPixelRef::NewWithData(info,
                                     0,
                                     NULL,
                                     etc1_pixel_data.get()));
 
   int extra_data_version = 0;
   if (!ReadBigEndianFromFile(file, &extra_data_version))
     return false;
 
   *out_scale = 1.f;
   if (extra_data_version == 1) {
     if (!ReadBigEndianFloatFromFile(file, out_scale))
       return false;
 
     if (*out_scale == 0.f)
       return false;
 
     *out_scale = 1.f / *out_scale;
   }
 
   return true;
 }
 
 }// anonymous namespace
 
 void ThumbnailCache::ReadTask(
     bool decompress,
     TabId tab_id,
     const base::Callback<
-        void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>&
+        void(sk_sp<SkPixelRef>, float, const gfx::Size&)>&
         post_read_task) {
   gfx::Size content_size;
   float scale = 0.f;
-  skia::RefPtr<SkPixelRef> compressed_data;
+  sk_sp<SkPixelRef> compressed_data;
   base::FilePath file_path = GetFilePath(tab_id);
 
   if (base::PathExists(file_path)) {
     base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
 
 
     bool valid_contents = ReadFromFile(file,
                                        &content_size,
                                        &scale,
                                        &compressed_data);
     file.Close();
 
     if (!valid_contents) {
       content_size.SetSize(0, 0);
             scale = 0.f;
-            compressed_data.clear();
+            compressed_data.reset();
             base::DeleteFile(file_path, false);
     }
   }
 
   if (decompress) {
     base::WorkerPool::PostTask(
         FROM_HERE,
-        base::Bind(post_read_task, compressed_data, scale, content_size),
+        base::Bind(post_read_task, std::move(compressed_data), scale,
+                   content_size),
         true);
   } else {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
-        base::Bind(post_read_task, compressed_data, scale, content_size));
+        base::Bind(post_read_task, std::move(compressed_data), scale,
+                   content_size));
   }
 }
 
 void ThumbnailCache::PostReadTask(TabId tab_id,
-                                  skia::RefPtr<SkPixelRef> compressed_data,
+                                  sk_sp<SkPixelRef> compressed_data,
                                   float scale,
                                   const gfx::Size& content_size) {
   read_in_progress_ = false;
 
   TabIdList::iterator iter =
       std::find(read_queue_.begin(), read_queue_.end(), tab_id);
   if (iter == read_queue_.end()) {
     ReadNextThumbnail();
     return;
   }
 
   read_queue_.erase(iter);
 
   if (!cache_.Get(tab_id) && compressed_data) {
     ThumbnailMetaDataMap::iterator meta_iter =
         thumbnail_meta_data_.find(tab_id);
     base::Time time_stamp = base::Time::Now();
     if (meta_iter != thumbnail_meta_data_.end())
       time_stamp = meta_iter->second.capture_time();
 
     MakeSpaceForNewItemIfNecessary(tab_id);
     std::unique_ptr<Thumbnail> thumbnail = Thumbnail::Create(
         tab_id, time_stamp, scale, ui_resource_provider_, this);
-    thumbnail->SetCompressedBitmap(compressed_data,
+    thumbnail->SetCompressedBitmap(std::move(compressed_data),
                                    content_size);
     if (kPreferCPUMemory)
       thumbnail->CreateUIResource();
 
     cache_.Put(tab_id, std::move(thumbnail));
     NotifyObserversOfThumbnailRead(tab_id);
   }
 
   ReadNextThumbnail();
 }
@@ skipping 11 matching lines @@
   if ((thumbnail && thumbnail->time_stamp() == time_stamp) ||
       (approx_thumbnail && approx_thumbnail->time_stamp() == time_stamp)) {
     Remove(tab_id);
   }
   return;
 }
 
 void ThumbnailCache::DecompressionTask(
     const base::Callback<void(bool, SkBitmap)>&
         post_decompression_callback,
-    skia::RefPtr<SkPixelRef> compressed_data,
+    sk_sp<SkPixelRef> compressed_data,
     float scale,
     const gfx::Size& content_size) {
   SkBitmap raw_data_small;
   bool success = false;
 
   if (compressed_data.get()) {
     gfx::Size buffer_size = gfx::Size(compressed_data->info().width(),
                                       compressed_data->info().height());
 
     SkBitmap raw_data;
@@ skipping 65 matching lines @@
   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);
 }