Convert //cc from scoped_ptr to std::unique_ptr.

cc/tiles/software_image_decode_controller.h

 // Copyright 2016 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.
 
 #ifndef CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/atomic_sequence_num.h"
 #include "base/containers/mru_cache.h"
 #include "base/hash.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_checker.h"
@@ skipping 105 matching lines @@
   // MemoryDumpProvider overrides.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
  private:
   // DecodedImage is a convenience storage for discardable memory. It can also
   // construct an image out of SkImageInfo and stored discardable memory.
   class DecodedImage {
    public:
     DecodedImage(const SkImageInfo& info,
-                 scoped_ptr<base::DiscardableMemory> memory,
+                 std::unique_ptr<base::DiscardableMemory> memory,
                  const SkSize& src_rect_offset,
                  uint64_t tracing_id);
     ~DecodedImage();
 
     SkImage* image() const {
       DCHECK(locked_);
       return image_.get();
     }
 
     const SkSize& src_rect_offset() const { return src_rect_offset_; }
 
     bool is_locked() const { return locked_; }
     bool Lock();
     void Unlock();
 
     const base::DiscardableMemory* memory() const { return memory_.get(); }
 
     // An ID which uniquely identifies this DecodedImage within the image decode
     // controller. Used in memory tracing.
     uint64_t tracing_id() const { return tracing_id_; }
 
    private:
     bool locked_;
     SkImageInfo image_info_;
-    scoped_ptr<base::DiscardableMemory> memory_;
+    std::unique_ptr<base::DiscardableMemory> memory_;
     skia::RefPtr<SkImage> image_;
     SkSize src_rect_offset_;
     uint64_t tracing_id_;
   };
 
   // MemoryBudget is a convenience class for memory bookkeeping and ensuring
   // that we don't go over the limit when pre-decoding.
   class MemoryBudget {
    public:
     explicit MemoryBudget(size_t limit_bytes);
 
     size_t AvailableMemoryBytes() const;
     void AddUsage(size_t usage);
     void SubtractUsage(size_t usage);
     void ResetUsage();
 
    private:
     size_t GetCurrentUsageSafe() const;
 
     size_t limit_bytes_;
     base::CheckedNumeric<size_t> current_usage_bytes_;
   };
 
-  using ImageMRUCache =
-      base::HashingMRUCache<ImageKey, scoped_ptr<DecodedImage>, ImageKeyHash>;
+  using ImageMRUCache = base::HashingMRUCache<ImageKey,
+                                              std::unique_ptr<DecodedImage>,
+                                              ImageKeyHash>;
 
   // Looks for the key in the cache and returns true if it was found and was
   // successfully locked (or if it was already locked). Note that if this
   // function returns true, then a ref count is increased for the image.
   bool LockDecodedImageIfPossibleAndRef(const ImageKey& key);
 
   // Actually decode the image. Note that this function can (and should) be
   // called with no lock acquired, since it can do a lot of work. Note that it
   // can also return nullptr to indicate the decode failed.
-  scoped_ptr<DecodedImage> DecodeImageInternal(const ImageKey& key,
-                                               const DrawImage& draw_image);
+  std::unique_ptr<DecodedImage> DecodeImageInternal(
+      const ImageKey& key,
+      const DrawImage& draw_image);
 
   // Get the decoded draw image for the given key and draw_image. Note that this
   // function has to be called with no lock acquired, since it will acquire its
   // own locks and might call DecodeImageInternal above. Also note that this
   // function will use the provided key, even if
   // ImageKey::FromDrawImage(draw_image) would return a different key.
   // Note that when used internally, we still require that
   // DrawWithImageFinished() is called afterwards.
   DecodedDrawImage GetDecodedImageForDrawInternal(const ImageKey& key,
                                                   const DrawImage& draw_image);
@@ skipping 40 matching lines @@
 
   ResourceFormat format_;
 
   // Used to uniquely identify DecodedImages for memory traces.
   base::AtomicSequenceNumber next_tracing_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_