Replace scoped_ptr with std::unique_ptr in //ui

ui/gfx/image/image.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/image/image.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_png_rep.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_source.h"
 
 #if !defined(OS_IOS)
 #include "ui/gfx/codec/png_codec.h"
 #endif
@@ skipping 106 matching lines @@
   ImageSkiaRepSet image_skia_reps_;
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(PNGImageSource);
 };
 
 ImageSkia* ImageSkiaFromPNG(
     const std::vector<ImagePNGRep>& image_png_reps) {
   if (image_png_reps.empty())
     return GetErrorImageSkia();
-  scoped_ptr<PNGImageSource> image_source(new PNGImageSource);
+  std::unique_ptr<PNGImageSource> image_source(new PNGImageSource);
 
   for (size_t i = 0; i < image_png_reps.size(); ++i) {
     if (!image_source->AddPNGData(image_png_reps[i]))
       return GetErrorImageSkia();
   }
   const gfx::Size& size = image_source->size();
   DCHECK(!size.IsEmpty());
   if (size.IsEmpty())
     return GetErrorImageSkia();
   return new ImageSkia(image_source.release(), size);
@@ skipping 94 matching lines @@
 
     return *size_cache_;
   }
 
   const std::vector<ImagePNGRep>& image_reps() const { return image_png_reps_; }
 
  private:
   std::vector<ImagePNGRep> image_png_reps_;
 
   // Cached to avoid having to parse the raw data multiple times.
-  mutable scoped_ptr<gfx::Size> size_cache_;
+  mutable std::unique_ptr<gfx::Size> size_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepPNG);
 };
 
 class ImageRepSkia : public ImageRep {
  public:
   // Takes ownership of |image|.
   explicit ImageRepSkia(ImageSkia* image)
       : ImageRep(Image::kImageRepSkia),
         image_(image) {
   }
 
   ~ImageRepSkia() override {}
 
   int Width() const override { return image_->width(); }
 
   int Height() const override { return image_->height(); }
 
   gfx::Size Size() const override { return image_->size(); }
 
   ImageSkia* image() { return image_.get(); }
 
  private:
-  scoped_ptr<ImageSkia> image_;
+  std::unique_ptr<ImageSkia> image_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
 };
 
 #if defined(OS_IOS)
 class ImageRepCocoaTouch : public ImageRep {
  public:
   explicit ImageRepCocoaTouch(UIImage* image)
       : ImageRep(Image::kImageRepCocoaTouch),
         image_(image) {
@@ skipping 111 matching lines @@
   std::vector<ImagePNGRep> filtered;
   for (size_t i = 0; i < image_reps.size(); ++i) {
     if (image_reps[i].raw_data.get() && image_reps[i].raw_data->size())
       filtered.push_back(image_reps[i]);
   }
 
   if (filtered.empty())
     return;
 
   storage_ = new internal::ImageStorage(Image::kImageRepPNG);
-  AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG(filtered)));
+  AddRepresentation(base::WrapUnique(new internal::ImageRepPNG(filtered)));
 }
 
 Image::Image(const ImageSkia& image) {
   if (!image.isNull()) {
     storage_ = new internal::ImageStorage(Image::kImageRepSkia);
     AddRepresentation(
-        make_scoped_ptr(new internal::ImageRepSkia(new ImageSkia(image))));
+        base::WrapUnique(new internal::ImageRepSkia(new ImageSkia(image))));
   }
 }
 
 #if defined(OS_IOS)
 Image::Image(UIImage* image)
     : storage_(new internal::ImageStorage(Image::kImageRepCocoaTouch)) {
   if (image)
-    AddRepresentation(make_scoped_ptr(new internal::ImageRepCocoaTouch(image)));
+    AddRepresentation(
+        base::WrapUnique(new internal::ImageRepCocoaTouch(image)));
 }
 #elif defined(OS_MACOSX)
 Image::Image(NSImage* image) {
   if (image) {
     storage_ = new internal::ImageStorage(Image::kImageRepCocoa);
-    AddRepresentation(make_scoped_ptr(new internal::ImageRepCocoa(image)));
+    AddRepresentation(base::WrapUnique(new internal::ImageRepCocoa(image)));
   }
 }
 #endif
 
 Image::Image(const Image& other) : storage_(other.storage_) {
 }
 
 Image& Image::operator=(const Image& other) {
   storage_ = other.storage_;
   return *this;
@@ skipping 30 matching lines @@
 }
 
 const SkBitmap* Image::ToSkBitmap() const {
   // Possibly create and cache an intermediate ImageRepSkia.
   return ToImageSkia()->bitmap();
 }
 
 const ImageSkia* Image::ToImageSkia() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
   if (!rep) {
-    scoped_ptr<internal::ImageRep> scoped_rep;
+    std::unique_ptr<internal::ImageRep> scoped_rep;
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         scoped_rep.reset(new internal::ImageRepSkia(
             internal::ImageSkiaFromPNG(png_rep->image_reps())));
         break;
       }
 #if defined(OS_IOS)
       case kImageRepCocoaTouch: {
@@ skipping 19 matching lines @@
     CHECK(scoped_rep);
     rep = AddRepresentation(std::move(scoped_rep));
   }
   return rep->AsImageRepSkia()->image();
 }
 
 #if defined(OS_IOS)
 UIImage* Image::ToUIImage() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepCocoaTouch, false);
   if (!rep) {
-    scoped_ptr<internal::ImageRep> scoped_rep;
+    std::unique_ptr<internal::ImageRep> scoped_rep;
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         scoped_rep.reset(new internal::ImageRepCocoaTouch(
             internal::CreateUIImageFromPNG(png_rep->image_reps())));
         break;
       }
       case kImageRepSkia: {
         internal::ImageRepSkia* skia_rep =
             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
         UIImage* image = UIImageFromImageSkia(*skia_rep->image());
         base::mac::NSObjectRetain(image);
         scoped_rep.reset(new internal::ImageRepCocoaTouch(image));
         break;
       }
       default:
         NOTREACHED();
     }
     CHECK(scoped_rep);
     rep = AddRepresentation(std::move(scoped_rep));
   }
   return rep->AsImageRepCocoaTouch()->image();
 }
 #elif defined(OS_MACOSX)
 NSImage* Image::ToNSImage() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
   if (!rep) {
-    scoped_ptr<internal::ImageRep> scoped_rep;
+    std::unique_ptr<internal::ImageRep> scoped_rep;
     CGColorSpaceRef default_representation_color_space =
         storage_->default_representation_color_space();
 
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         scoped_rep.reset(new internal::ImageRepCocoa(internal::NSImageFromPNG(
             png_rep->image_reps(), default_representation_color_space)));
         break;
@@ skipping 57 matching lines @@
           GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
       png_bytes = internal::Get1xPNGBytesFromImageSkia(skia_rep->image());
       break;
     }
     default:
       NOTREACHED();
   }
   if (!png_bytes.get() || !png_bytes->size()) {
     // Add an ImageRepPNG with no data such that the conversion is not
     // attempted each time we want the PNG bytes.
-    AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG()));
+    AddRepresentation(base::WrapUnique(new internal::ImageRepPNG()));
     return new base::RefCountedBytes();
   }
 
   // Do not insert representations for scale factors other than 1x even if
   // they are available because:
   // - Only the 1x PNG bytes can be accessed.
   // - ImageRepPNG is not used as an intermediate type in converting to a
   //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
   //   ImageRepCocoa).
   std::vector<ImagePNGRep> image_png_reps;
   image_png_reps.push_back(ImagePNGRep(png_bytes, 1.0f));
-  AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG(image_png_reps)));
+  AddRepresentation(
+      base::WrapUnique(new internal::ImageRepPNG(image_png_reps)));
   return png_bytes;
 }
 
 SkBitmap Image::AsBitmap() const {
   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
 }
 
 ImageSkia Image::AsImageSkia() const {
   return IsEmpty() ? ImageSkia() : *ToImageSkia();
 }
@@ skipping 88 matching lines @@
   RepresentationMap::const_iterator it =
       storage_->representations().find(rep_type);
   if (it == storage_->representations().end()) {
     CHECK(!must_exist);
     return NULL;
   }
   return it->second.get();
 }
 
 internal::ImageRep* Image::AddRepresentation(
-    scoped_ptr<internal::ImageRep> rep) const {
+    std::unique_ptr<internal::ImageRep> rep) const {
   CHECK(storage_.get());
   RepresentationType type = rep->type();
   auto result =
       storage_->representations().insert(std::make_pair(type, std::move(rep)));
 
   // insert should not fail (implies that there was already a representation of
   // that type in the map).
   CHECK(result.second) << "type was already in map.";
 
   return result.first->second.get();
 }
 
 }  // namespace gfx