Replace scoped_ptr with std::unique_ptr in //ui

ui/gl/gl_image_memory.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 "ui/gl/gl_image_memory.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 182 matching lines @@
     case BufferFormat::UYVY_422:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 template <typename F>
-scoped_ptr<uint8_t[]> GLES2RGBData(const gfx::Size& size,
-                                   BufferFormat format,
-                                   size_t stride,
-                                   const uint8_t* data,
-                                   F const& data_to_rgb,
-                                   GLenum* data_format,
-                                   GLenum* data_type,
-                                   GLint* data_row_length) {
+std::unique_ptr<uint8_t[]> GLES2RGBData(const gfx::Size& size,
+                                        BufferFormat format,
+                                        size_t stride,
+                                        const uint8_t* data,
+                                        F const& data_to_rgb,
+                                        GLenum* data_format,
+                                        GLenum* data_type,
+                                        GLint* data_row_length) {
   TRACE_EVENT2("gpu", "GLES2RGBData", "width", size.width(), "height",
                size.height());
 
   // Four-byte row alignment as specified by glPixelStorei with argument
   // GL_UNPACK_ALIGNMENT set to 4.
   size_t gles2_rgb_data_stride = (size.width() * 3 + 3) & ~3;
-  scoped_ptr<uint8_t[]> gles2_rgb_data(
+  std::unique_ptr<uint8_t[]> gles2_rgb_data(
       new uint8_t[gles2_rgb_data_stride * size.height()]);
 
   for (int y = 0; y < size.height(); ++y) {
     for (int x = 0; x < size.width(); ++x) {
       data_to_rgb(&data[y * stride + x * 4],
                   &gles2_rgb_data[y * gles2_rgb_data_stride + x * 3]);
     }
   }
 
   *data_format = GL_RGB;
   *data_type = GL_UNSIGNED_BYTE;
   *data_row_length = size.width();
   return gles2_rgb_data;
 }
 
-scoped_ptr<uint8_t[]> GLES2Data(const gfx::Size& size,
-                                BufferFormat format,
-                                size_t stride,
-                                const uint8_t* data,
-                                GLenum* data_format,
-                                GLenum* data_type,
-                                GLint* data_row_length) {
+std::unique_ptr<uint8_t[]> GLES2Data(const gfx::Size& size,
+                                     BufferFormat format,
+                                     size_t stride,
+                                     const uint8_t* data,
+                                     GLenum* data_format,
+                                     GLenum* data_type,
+                                     GLint* data_row_length) {
   TRACE_EVENT2("gpu", "GLES2Data", "width", size.width(), "height",
                size.height());
 
   switch (format) {
     case BufferFormat::RGBX_8888:
       return GLES2RGBData(size, format, stride,
                           data, [](const uint8_t* src, uint8_t* dst) {
                             dst[0] = src[0];
                             dst[1] = src[1];
                             dst[2] = src[2];
                           }, data_format, data_type, data_row_length);
     case BufferFormat::BGRX_8888:
       return GLES2RGBData(size, format, stride,
                           data, [](const uint8_t* src, uint8_t* dst) {
                             dst[0] = src[2];
                             dst[1] = src[1];
                             dst[2] = src[0];
                           }, data_format, data_type, data_row_length);
     case BufferFormat::RGBA_4444:
     case BufferFormat::RGBA_8888:
     case BufferFormat::BGRA_8888:
     case BufferFormat::R_8: {
       size_t gles2_data_stride =
           RowSizeForBufferFormat(size.width(), format, 0);
       if (stride == gles2_data_stride ||
           gfx::g_driver_gl.ext.b_GL_EXT_unpack_subimage)
         return nullptr;  // No data conversion needed
 
-      scoped_ptr<uint8_t[]> gles2_data(
+      std::unique_ptr<uint8_t[]> gles2_data(
           new uint8_t[gles2_data_stride * size.height()]);
       for (int y = 0; y < size.height(); ++y) {
         memcpy(&gles2_data[y * gles2_data_stride], &data[y * stride],
                gles2_data_stride);
       }
       *data_row_length = size.width();
       return gles2_data;
     }
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
@@ skipping 79 matching lines @@
 
   if (IsCompressedFormat(format_)) {
     glCompressedTexImage2D(
         target, 0, TextureFormat(format_), size_.width(), size_.height(), 0,
         static_cast<GLsizei>(BufferSizeForBufferFormat(size_, format_)),
         memory_);
   } else {
     GLenum data_format = DataFormat(format_);
     GLenum data_type = DataType(format_);
     GLint data_row_length = DataRowLength(stride_, format_);
-    scoped_ptr<uint8_t[]> gles2_data;
+    std::unique_ptr<uint8_t[]> gles2_data;
 
     if (gfx::GLContext::GetCurrent()->GetVersionInfo()->is_es) {
       gles2_data = GLES2Data(size_, format_, stride_, memory_, &data_format,
                              &data_type, &data_row_length);
     }
 
     if (data_row_length != size_.width())
       glPixelStorei(GL_UNPACK_ROW_LENGTH, data_row_length);
 
     glTexImage2D(target, 0, TextureFormat(format_), size_.width(),
@@ skipping 29 matching lines @@
 
     glCompressedTexSubImage2D(
         target, 0, offset.x(), offset.y(), rect.width(), rect.height(),
         DataFormat(format_),
         static_cast<GLsizei>(BufferSizeForBufferFormat(rect.size(), format_)),
         data);
   } else {
     GLenum data_format = DataFormat(format_);
     GLenum data_type = DataType(format_);
     GLint data_row_length = DataRowLength(stride_, format_);
-    scoped_ptr<uint8_t[]> gles2_data;
+    std::unique_ptr<uint8_t[]> gles2_data;
 
     if (gfx::GLContext::GetCurrent()->GetVersionInfo()->is_es) {
       gles2_data = GLES2Data(rect.size(), format_, stride_, data, &data_format,
                              &data_type, &data_row_length);
     }
 
     if (data_row_length != rect.width())
       glPixelStorei(GL_UNPACK_ROW_LENGTH, data_row_length);
 
     glTexSubImage2D(target, 0, offset.x(), offset.y(), rect.width(),
@@ skipping 15 matching lines @@
   return false;
 }
 
 // static
 unsigned GLImageMemory::GetInternalFormatForTesting(BufferFormat format) {
   DCHECK(ValidFormat(format));
   return TextureFormat(format);
 }
 
 }  // namespace gl