Replace scoped_ptr with std::unique_ptr in //ui

ui/views/painter.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/views/painter.h"
 
+#include <memory>
+
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
@@ skipping 122 matching lines @@
   ~GradientPainter() override;
 
   // Painter:
   gfx::Size GetMinimumSize() const override;
   void Paint(gfx::Canvas* canvas, const gfx::Size& size) override;
 
  private:
   // If |horizontal_| is true then the gradient is painted horizontally.
   bool horizontal_;
   // The gradient colors.
-  scoped_ptr<SkColor[]> colors_;
+  std::unique_ptr<SkColor[]> colors_;
   // The relative positions of the corresponding gradient colors.
-  scoped_ptr<SkScalar[]> pos_;
+  std::unique_ptr<SkScalar[]> pos_;
   // The number of elements in |colors_| and |pos_|.
   size_t count_;
 
   DISALLOW_COPY_AND_ASSIGN(GradientPainter);
 };
 
 GradientPainter::GradientPainter(bool horizontal,
                                  SkColor* colors,
                                  SkScalar* pos,
                                  size_t count)
@@ skipping 44 matching lines @@
   // Constructs an ImagePainter with the specified image and insets.
   ImagePainter(const gfx::ImageSkia& image, const gfx::Insets& insets);
 
   ~ImagePainter() override;
 
   // Painter:
   gfx::Size GetMinimumSize() const override;
   void Paint(gfx::Canvas* canvas, const gfx::Size& size) override;
 
  private:
-  scoped_ptr<gfx::NineImagePainter> nine_painter_;
+  std::unique_ptr<gfx::NineImagePainter> nine_painter_;
 
   DISALLOW_COPY_AND_ASSIGN(ImagePainter);
 };
 
 ImagePainter::ImagePainter(const int image_ids[])
     : nine_painter_(ui::CreateNineImagePainter(image_ids)) {
 }
 
 ImagePainter::ImagePainter(const gfx::ImageSkia& image,
                            const gfx::Insets& insets)
@@ skipping 76 matching lines @@
                                      const gfx::Insets& insets) {
   return new ImagePainter(image, insets);
 }
 
 // static
 Painter* Painter::CreateImageGridPainter(const int image_ids[]) {
   return new ImagePainter(image_ids);
 }
 
 // static
-scoped_ptr<Painter> Painter::CreateDashedFocusPainter() {
-  return make_scoped_ptr(new DashedFocusPainter(gfx::Insets()));
+std::unique_ptr<Painter> Painter::CreateDashedFocusPainter() {
+  return base::WrapUnique(new DashedFocusPainter(gfx::Insets()));
 }
 
 // static
-scoped_ptr<Painter> Painter::CreateDashedFocusPainterWithInsets(
+std::unique_ptr<Painter> Painter::CreateDashedFocusPainterWithInsets(
     const gfx::Insets& insets) {
-  return make_scoped_ptr(new DashedFocusPainter(insets));
+  return base::WrapUnique(new DashedFocusPainter(insets));
 }
 
 // static
-scoped_ptr<Painter> Painter::CreateSolidFocusPainter(
+std::unique_ptr<Painter> Painter::CreateSolidFocusPainter(
     SkColor color,
     const gfx::Insets& insets) {
-  return make_scoped_ptr(new SolidFocusPainter(color, insets));
+  return base::WrapUnique(new SolidFocusPainter(color, insets));
 }
 
 // HorizontalPainter ----------------------------------------------------------
 
 HorizontalPainter::HorizontalPainter(const int image_resource_names[]) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (int i = 0; i < 3; ++i)
     images_[i] = rb.GetImageNamed(image_resource_names[i]).ToImageSkia();
   DCHECK_EQ(images_[LEFT]->height(), images_[CENTER]->height());
   DCHECK_EQ(images_[LEFT]->height(), images_[RIGHT]->height());
@@ skipping 15 matching lines @@
   canvas->DrawImageInt(*images_[LEFT], 0, 0);
   canvas->DrawImageInt(*images_[RIGHT], size.width() - images_[RIGHT]->width(),
                        0);
   canvas->TileImageInt(
       *images_[CENTER], images_[LEFT]->width(), 0,
       size.width() - images_[LEFT]->width() - images_[RIGHT]->width(),
       images_[LEFT]->height());
 }
 
 }  // namespace views