cc: ImageDecodes: Remove ref counting from SIDC::DecodedImage.

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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 "cc/tiles/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
@@ skipping 253 matching lines @@
 
   auto image_it = decoded_images_.Peek(key);
   if (image_it != decoded_images_.end()) {
     if (image_it->second->is_locked() || image_it->second->Lock()) {
       pending_image_tasks_.erase(key);
       return;
     }
     decoded_images_.Erase(image_it);
   }
 
-  scoped_refptr<DecodedImage> decoded_image;
+  scoped_ptr<DecodedImage> decoded_image;
   {
     base::AutoUnlock unlock(lock_);
     decoded_image = DecodeImageInternal(key, image);
   }
 
   // Erase the pending task from the queue, since the task won't be doing
   // anything useful after this function terminates. That is, if this image
   // needs to be decoded again, we have to create a new task.
   pending_image_tasks_.erase(key);
 
@@ skipping 20 matching lines @@
   // ref counts. Unlock it immediately in this case.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     decoded_image->Unlock();
   }
 
   decoded_images_.Put(key, std::move(decoded_image));
   SanityCheckState(__LINE__, true);
 }
 
-scoped_refptr<SoftwareImageDecodeController::DecodedImage>
+scoped_ptr<SoftwareImageDecodeController::DecodedImage>
 SoftwareImageDecodeController::DecodeImageInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::DecodeImageInternal", "key",
                key.ToString());
   const SkImage* image = draw_image.image();
 
   // If we can use the original decode, then we don't need to do scaling. We can
   // just read pixels into the final memory.
@@ skipping 18 matching lines @@
       bool result = image->readPixels(decoded_info, decoded_pixels->data(),
                                       decoded_info.minRowBytes(), 0, 0,
                                       SkImage::kDisallow_CachingHint);
 
       if (!result) {
         decoded_pixels->Unlock();
         return nullptr;
       }
     }
 
-    return make_scoped_refptr(new DecodedImage(
+    return make_scoped_ptr(new DecodedImage(
         decoded_info, std::move(decoded_pixels), SkSize::Make(0, 0)));
   }
 
   // If we get here, that means we couldn't use the original sized decode for
   // whatever reason. However, in all cases we do need an original decode to
   // either do a scale or to extract a subrect from the image. So, what we can
   // do is construct a key that would require a full sized decode, then get that
   // decode via GetDecodedImageForDrawInternal(), use it, and unref it. This
   // ensures that if the original sized decode is already available in any of
   // the caches, we reuse that. We also ensure that all the proper locking takes
@@ skipping 52 matching lines @@
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result);
   }
 
   // Release the original sized decode. Any other intermediate result to release
   // would be the subrect memory. However, that's in a scoped_ptr and will be
   // deleted automatically when we return.
   DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
 
-  return make_scoped_refptr(
+  return make_scoped_ptr(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
                key.ToString());
@@ skipping 10 matching lines @@
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
                "key", key.ToString());
   base::AutoLock lock(lock_);
   auto decoded_images_it = decoded_images_.Get(key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
-  scoped_refptr<DecodedImage> decoded_image;
+  scoped_ptr<DecodedImage> scoped_decoded_image;
+  DecodedImage* decoded_image = nullptr;
   if (decoded_images_it != decoded_images_.end()) {
-    decoded_image = decoded_images_it->second;
+    decoded_image = decoded_images_it->second.get();
     if (decoded_image->is_locked()) {
       RefImage(key);
       SanityCheckState(__LINE__, true);
       return DecodedDrawImage(
           decoded_image->image(), decoded_image->src_rect_offset(),
           GetScaleAdjustment(key), GetDecodedFilterQuality(key));
     } else {
+      scoped_decoded_image = std::move(decoded_images_it->second);
       decoded_images_.Erase(decoded_images_it);
     }
   }
 
   // See if another thread already decoded this image at raster time. If so, we
   // can just use that result directly.
   auto at_raster_images_it = at_raster_decoded_images_.Get(key);
   if (at_raster_images_it != at_raster_decoded_images_.end()) {
     DCHECK(at_raster_images_it->second->is_locked());
     RefAtRasterImage(key);
     SanityCheckState(__LINE__, true);
-    const scoped_refptr<DecodedImage>& at_raster_decoded_image =
-        at_raster_images_it->second;
+    DecodedImage* at_raster_decoded_image = at_raster_images_it->second.get();
     auto decoded_draw_image =
         DecodedDrawImage(at_raster_decoded_image->image(),
                          at_raster_decoded_image->src_rect_offset(),
                          GetScaleAdjustment(key), GetDecodedFilterQuality(key));
     decoded_draw_image.set_at_raster_decode(true);
     return decoded_draw_image;
   }
 
   // Now we know that we don't have a locked image, and we seem to be the first
   // thread encountering this image (that might not be true, since other threads
   // might be decoding it already). This means that we need to decode the image
   // assuming we can't lock the one we found in the cache.
   bool check_at_raster_cache = false;
   if (!decoded_image || !decoded_image->Lock()) {
     // Note that we have to release the lock, since this lock is also accessed
     // on the compositor thread. This means holding on to the lock might stall
     // the compositor thread for the duration of the decode!
     base::AutoUnlock unlock(lock_);
-    decoded_image = DecodeImageInternal(key, draw_image);
+    scoped_decoded_image = DecodeImageInternal(key, draw_image);
+    decoded_image = scoped_decoded_image.get();
 
     // Skip the image if we couldn't decode it.
     if (!decoded_image)
       return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
     check_at_raster_cache = true;
   }
 
+  DCHECK(decoded_image == scoped_decoded_image.get());
+
   // While we unlocked the lock, it could be the case that another thread
   // already decoded this already and put it in the at-raster cache. Look it up
   // first.
-  bool need_to_add_image_to_cache = true;
   if (check_at_raster_cache) {
     at_raster_images_it = at_raster_decoded_images_.Get(key);
     if (at_raster_images_it != at_raster_decoded_images_.end()) {
       // We have to drop our decode, since the one in the cache is being used by
       // another thread.
       decoded_image->Unlock();
-      decoded_image = at_raster_images_it->second;
-      need_to_add_image_to_cache = false;
+      decoded_image = at_raster_images_it->second.get();
+      scoped_decoded_image = nullptr;
     }
   }
 
   // If we really are the first ones, or if the other thread already unlocked
   // the image, then put our work into at-raster time cache.
-  if (need_to_add_image_to_cache)
-    at_raster_decoded_images_.Put(key, decoded_image);
+  if (scoped_decoded_image)
+    at_raster_decoded_images_.Put(key, std::move(scoped_decoded_image));
 
   DCHECK(decoded_image);
   DCHECK(decoded_image->is_locked());
   RefAtRasterImage(key);
   SanityCheckState(__LINE__, true);
   auto decoded_draw_image =
       DecodedDrawImage(decoded_image->image(), decoded_image->src_rect_offset(),
                        GetScaleAdjustment(key), GetDecodedFilterQuality(key));
   decoded_draw_image.set_at_raster_decode(true);
   return decoded_draw_image;
@@ skipping 52 matching lines @@
     //    2b. ... and is unlocked and...
     //       2b1. ... its ref count is 0: unlock our image and replace the
     //       existing one with ours.
     //       2b2. ... its ref count is not 0: this shouldn't be possible.
     auto image_it = decoded_images_.Peek(key);
     if (image_it == decoded_images_.end()) {
       if (decoded_images_ref_counts_.find(key) ==
           decoded_images_ref_counts_.end()) {
         at_raster_image_it->second->Unlock();
       }
-      decoded_images_.Put(key, at_raster_image_it->second);
+      decoded_images_.Put(key, std::move(at_raster_image_it->second));
     } else if (image_it->second->is_locked()) {
       at_raster_image_it->second->Unlock();
     } else {
       DCHECK(decoded_images_ref_counts_.find(key) ==
              decoded_images_ref_counts_.end());
       at_raster_image_it->second->Unlock();
       decoded_images_.Erase(image_it);
-      decoded_images_.Put(key, at_raster_image_it->second);
+      decoded_images_.Put(key, std::move(at_raster_image_it->second));
     }
     at_raster_decoded_images_.Erase(at_raster_image_it);
   }
 }
 
 bool SoftwareImageDecodeController::CanHandleImage(const ImageKey& key) {
   // TODO(vmpstr): Start handling medium filter quality as well.
   return key.filter_quality() != kMedium_SkFilterQuality;
 }
 
@@ skipping 212 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc