convert //gpu to std::unique_ptr

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
 #include <list>
 #include <map>
+#include <memory>
 #include <queue>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/mailbox.h"
@@ skipping 361 matching lines @@
 // framebuffer are restored.
 class ScopedFrameBufferReadPixelHelper {
  public:
   ScopedFrameBufferReadPixelHelper(ContextState* state,
                                    GLES2DecoderImpl* decoder);
   ~ScopedFrameBufferReadPixelHelper();
 
  private:
   GLuint temp_texture_id_ = 0;
   GLuint temp_fbo_id_ = 0;
-  scoped_ptr<ScopedFrameBufferBinder> fbo_binder_;
+  std::unique_ptr<ScopedFrameBufferBinder> fbo_binder_;
   DISALLOW_COPY_AND_ASSIGN(ScopedFrameBufferReadPixelHelper);
 };
 
 // Encapsulates an OpenGL texture.
 class BackTexture {
  public:
   explicit BackTexture(MemoryTracker* memory_tracker, ContextState* state);
   ~BackTexture();
 
   // Create a new render texture.
@@ skipping 105 matching lines @@
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(BackFramebuffer);
 };
 
 struct FenceCallback {
   FenceCallback()
       : fence(gfx::GLFence::Create()) {
     DCHECK(fence);
   }
   std::vector<base::Closure> callbacks;
-  scoped_ptr<gfx::GLFence> fence;
+  std::unique_ptr<gfx::GLFence> fence;
 };
 
 // }  // anonymous namespace.
 
 // static
 const unsigned int GLES2Decoder::kDefaultStencilMask =
     static_cast<unsigned int>(-1);
 
 bool GLES2Decoder::GetServiceTextureId(uint32_t client_texture_id,
                                        uint32_t* service_texture_id) {
@@ skipping 1468 matching lines @@
   // The buffer used to simulate GL_FIXED attribs.
   GLuint fixed_attrib_buffer_id_;
 
   // The size of fiixed attrib buffer.
   GLsizei fixed_attrib_buffer_size_;
 
   // The offscreen frame buffer that the client renders to. With EGL, the
   // depth and stencil buffers are separate. With regular GL there is a single
   // packed depth stencil buffer in offscreen_target_depth_render_buffer_.
   // offscreen_target_stencil_render_buffer_ is unused.
-  scoped_ptr<BackFramebuffer> offscreen_target_frame_buffer_;
-  scoped_ptr<BackTexture> offscreen_target_color_texture_;
-  scoped_ptr<BackRenderbuffer> offscreen_target_color_render_buffer_;
-  scoped_ptr<BackRenderbuffer> offscreen_target_depth_render_buffer_;
-  scoped_ptr<BackRenderbuffer> offscreen_target_stencil_render_buffer_;
+  std::unique_ptr<BackFramebuffer> offscreen_target_frame_buffer_;
+  std::unique_ptr<BackTexture> offscreen_target_color_texture_;
+  std::unique_ptr<BackRenderbuffer> offscreen_target_color_render_buffer_;
+  std::unique_ptr<BackRenderbuffer> offscreen_target_depth_render_buffer_;
+  std::unique_ptr<BackRenderbuffer> offscreen_target_stencil_render_buffer_;
   GLenum offscreen_target_color_format_;
   GLenum offscreen_target_depth_format_;
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
   GLboolean offscreen_target_buffer_preserved_;
 
   // The copy that is saved when SwapBuffers is called.
-  scoped_ptr<BackFramebuffer> offscreen_saved_frame_buffer_;
-  scoped_ptr<BackTexture> offscreen_saved_color_texture_;
+  std::unique_ptr<BackFramebuffer> offscreen_saved_frame_buffer_;
+  std::unique_ptr<BackTexture> offscreen_saved_color_texture_;
   scoped_refptr<TextureRef>
       offscreen_saved_color_texture_info_;
 
   // The copy that is used as the destination for multi-sample resolves.
-  scoped_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
-  scoped_ptr<BackTexture> offscreen_resolved_color_texture_;
+  std::unique_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
+  std::unique_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
-  scoped_ptr<QueryManager> query_manager_;
+  std::unique_ptr<QueryManager> query_manager_;
 
-  scoped_ptr<VertexArrayManager> vertex_array_manager_;
+  std::unique_ptr<VertexArrayManager> vertex_array_manager_;
 
-  scoped_ptr<ImageManager> image_manager_;
+  std::unique_ptr<ImageManager> image_manager_;
 
   FenceSyncReleaseCallback fence_sync_release_callback_;
   WaitFenceSyncCallback wait_fence_sync_callback_;
 
   ShaderCacheCallback shader_cache_callback_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
   bool back_buffer_has_stencil_;
@@ skipping 55 matching lines @@
   bool lose_context_when_out_of_memory_;
 
   // Log extra info.
   bool service_logging_;
 
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, IOSurfaceRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
 
-  scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
-  scoped_ptr<ClearFramebufferResourceManager> clear_framebuffer_blit_;
+  std::unique_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
+  std::unique_ptr<ClearFramebufferResourceManager> clear_framebuffer_blit_;
 
   // Cached values of the currently assigned viewport dimensions.
   GLsizei viewport_max_width_;
   GLsizei viewport_max_height_;
 
   // Command buffer stats.
   base::TimeDelta total_processing_commands_time_;
 
   // States related to each manager.
   DecoderTextureState texture_state_;
   DecoderFramebufferState framebuffer_state_;
 
-  scoped_ptr<GPUTracer> gpu_tracer_;
-  scoped_ptr<GPUStateTracer> gpu_state_tracer_;
+  std::unique_ptr<GPUTracer> gpu_tracer_;
+  std::unique_ptr<GPUStateTracer> gpu_state_tracer_;
   const unsigned char* gpu_decoder_category_;
   int gpu_trace_level_;
   bool gpu_trace_commands_;
   bool gpu_debug_commands_;
 
   std::queue<linked_ptr<FenceCallback> > pending_readpixel_fences_;
 
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
@@ skipping 268 matching lines @@
   ScopedTextureBinder binder(state_, id_, GL_TEXTURE_2D);
   uint32_t image_size = 0;
   GLES2Util::ComputeImageDataSizes(
       size.width(), size.height(), 1, format, GL_UNSIGNED_BYTE, 8, &image_size,
       NULL, NULL);
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
   }
 
-  scoped_ptr<char[]> zero_data;
+  std::unique_ptr<char[]> zero_data;
   if (zero) {
     zero_data.reset(new char[image_size]);
     memset(zero_data.get(), 0, image_size);
   }
 
   glTexImage2D(GL_TEXTURE_2D,
                0,  // mip level
                format,
                size.width(),
                size.height(),
@@ skipping 1004 matching lines @@
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetBuffer(client_ids[ii])) {
       return false;
     }
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenBuffersARB(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateBuffer(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetFramebuffer(client_ids[ii])) {
       return false;
     }
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenFramebuffersEXT(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateFramebuffer(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetRenderbuffer(client_ids[ii])) {
       return false;
     }
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenRenderbuffersEXT(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateRenderbuffer(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenValuebuffersCHROMIUMHelper(GLsizei n,
                                                      const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetValuebuffer(client_ids[ii])) {
       return false;
     }
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateValuebuffer(client_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenTexturesHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetTexture(client_ids[ii])) {
       return false;
     }
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenTextures(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateTexture(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenSamplersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetSampler(client_ids[ii])) {
       return false;
     }
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   glGenSamplers(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateSampler(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenPathsCHROMIUMHelper(GLuint first_client_id,
                                               GLsizei range) {
   GLuint last_client_id;
@@ skipping 1572 matching lines @@
   }
 
   if (width < 0 || height < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "negative size");
     return;
   }
 
   // If the default framebuffer is bound but we are still rendering to an
   // FBO, translate attachment names that refer to default framebuffer
   // channels to corresponding framebuffer attachments.
-  scoped_ptr<GLenum[]> translated_attachments(new GLenum[count]);
+  std::unique_ptr<GLenum[]> translated_attachments(new GLenum[count]);
   for (GLsizei i = 0; i < count; ++i) {
     GLenum attachment = attachments[i];
     if (!framebuffer && GetBackbufferServiceId()) {
       switch (attachment) {
         case GL_COLOR_EXT:
           attachment = GL_COLOR_ATTACHMENT0;
           break;
         case GL_DEPTH_EXT:
           attachment = GL_DEPTH_ATTACHMENT;
           break;
@@ skipping 663 matching lines @@
       feature_info_->gl_version_info().is_desktop_core_profile) {
     return GL_POINT_SIZE_RANGE;
   }
   return pname;
 }
 
 void GLES2DecoderImpl::DoGetBooleanv(GLenum pname, GLboolean* params) {
   DCHECK(params);
   GLsizei num_written = 0;
   if (GetNumValuesReturnedForGLGet(pname, &num_written)) {
-    scoped_ptr<GLint[]> values(new GLint[num_written]);
+    std::unique_ptr<GLint[]> values(new GLint[num_written]);
     if (!state_.GetStateAsGLint(pname, values.get(), &num_written)) {
       GetHelper(pname, values.get(), &num_written);
     }
     for (GLsizei ii = 0; ii < num_written; ++ii) {
       params[ii] = static_cast<GLboolean>(values[ii]);
     }
   } else {
     pname = AdjustGetPname(pname);
     glGetBooleanv(pname, params);
   }
 }
 
 void GLES2DecoderImpl::DoGetFloatv(GLenum pname, GLfloat* params) {
   DCHECK(params);
   GLsizei num_written = 0;
   if (!state_.GetStateAsGLfloat(pname, params, &num_written)) {
     if (GetHelper(pname, NULL, &num_written)) {
-      scoped_ptr<GLint[]> values(new GLint[num_written]);
+      std::unique_ptr<GLint[]> values(new GLint[num_written]);
       GetHelper(pname, values.get(), &num_written);
       for (GLsizei ii = 0; ii < num_written; ++ii) {
         params[ii] = static_cast<GLfloat>(values[ii]);
       }
     } else {
       pname = AdjustGetPname(pname);
       glGetFloatv(pname, params);
     }
   }
 }
@@ skipping 1643 matching lines @@
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform1fv",
                                    Program::kUniform1f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL) {
-    scoped_ptr<GLint[]> temp(new GLint[count]);
+    std::unique_ptr<GLint[]> temp(new GLint[count]);
     for (GLsizei ii = 0; ii < count; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform1iv(real_location, count, temp.get());
   } else {
     glUniform1fv(real_location, count, value);
   }
 }
 
 void GLES2DecoderImpl::DoUniform2fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform2fv",
                                    Program::kUniform2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC2) {
     GLsizei num_values = count * 2;
-    scoped_ptr<GLint[]> temp(new GLint[num_values]);
+    std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform2iv(real_location, count, temp.get());
   } else {
     glUniform2fv(real_location, count, value);
   }
 }
 
 void GLES2DecoderImpl::DoUniform3fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform3fv",
                                    Program::kUniform3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC3) {
     GLsizei num_values = count * 3;
-    scoped_ptr<GLint[]> temp(new GLint[num_values]);
+    std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform3iv(real_location, count, temp.get());
   } else {
     glUniform3fv(real_location, count, value);
   }
 }
 
 void GLES2DecoderImpl::DoUniform4fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform4fv",
                                    Program::kUniform4f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC4) {
     GLsizei num_values = count * 4;
-    scoped_ptr<GLint[]> temp(new GLint[num_values]);
+    std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform4iv(real_location, count, temp.get());
   } else {
     glUniform4fv(real_location, count, value);
   }
 }
 
 void GLES2DecoderImpl::DoUniform2iv(
@@ skipping 708 matching lines @@
       LOCAL_SET_GL_ERROR(
           GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         attrib->CanAccess(max_accessed) &&
         attrib->type() == GL_FIXED) {
       int num_elements = attrib->size() * num_vertices;
       const int src_size = num_elements * sizeof(int32_t);
       const int dst_size = num_elements * sizeof(float);
-      scoped_ptr<float[]> data(new float[num_elements]);
+      std::unique_ptr<float[]> data(new float[num_elements]);
       const int32_t* src = reinterpret_cast<const int32_t*>(
           attrib->buffer()->GetRange(attrib->offset(), src_size));
       const int32_t* end = src + num_elements;
       float* dst = data.get();
       while (src != end) {
         *dst++ = static_cast<float>(*src++) / 65536.0f;
       }
       glBufferSubData(GL_ARRAY_BUFFER, offset, dst_size, data.get());
       glVertexAttribPointer(
           attrib->index(), attrib->size(), GL_FLOAT, false, 0,
@@ skipping 1382 matching lines @@
   int32_t max_y;
   if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
     return error::kNoError;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glReadPixels");
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
-  scoped_ptr<ScopedFrameBufferReadPixelHelper> helper;
+  std::unique_ptr<ScopedFrameBufferReadPixelHelper> helper;
   if (NeedsIOSurfaceReadbackWorkaround())
     helper.reset(new ScopedFrameBufferReadPixelHelper(&state_, this));
 
   gfx::Rect rect(x, y, width, height);  // Safe before we checked above.
   gfx::Rect max_rect(max_size);
   if (!max_rect.Contains(rect)) {
     rect.Intersect(max_rect);
     if (!rect.IsEmpty()) {
       if (y < 0) {
         pixels += static_cast<uint32_t>(-y) * padded_row_size;;
@@ skipping 778 matching lines @@
     if (!GLES2Util::ComputeImageDataSizes(
             width, tile_height, 1, format, type, state_.unpack_alignment, &size,
             NULL, NULL)) {
       return false;
     }
   } else {
     tile_height = height;
   }
 
   // Assumes the size has already been checked.
-  scoped_ptr<char[]> zero(new char[size]);
+  std::unique_ptr<char[]> zero(new char[size]);
   memset(zero.get(), 0, size);
   glBindTexture(texture->target(), texture->service_id());
 
   GLint y = 0;
   while (y < height) {
     GLint h = y + tile_height > height ? height - y : tile_height;
     glTexSubImage2D(target, level, xoffset, yoffset + y, width, h, format, type,
                     zero.get());
     y += tile_height;
   }
@@ skipping 91 matching lines @@
 
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::ClearLevel3D", "size", size);
 
   GLuint buffer_id = 0;
   glGenBuffersARB(1, &buffer_id);
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer_id);
   {
     // Include padding as some drivers incorrectly requires padding for the
     // last row.
     buffer_size += padding;
-    scoped_ptr<char[]> zero(new char[buffer_size]);
+    std::unique_ptr<char[]> zero(new char[buffer_size]);
     memset(zero.get(), 0, buffer_size);
     // TODO(zmo): Consider glMapBufferRange instead.
     glBufferData(
         GL_PIXEL_UNPACK_BUFFER, buffer_size, zero.get(), GL_STATIC_DRAW);
   }
 
   Buffer* bound_buffer = buffer_manager()->GetBufferInfoForTarget(
       &state_, GL_PIXEL_UNPACK_BUFFER);
   if (bound_buffer) {
     // If an unpack buffer is bound, we need to clear unpack parameters
@@ skipping 489 matching lines @@
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
-  scoped_ptr<int8_t[]> zero;
+  std::unique_ptr<int8_t[]> zero;
   if (!data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage2D");
   if (error == GL_NO_ERROR) {
@@ skipping 174 matching lines @@
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage3D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
-  scoped_ptr<int8_t[]> zero;
+  std::unique_ptr<int8_t[]> zero;
   if (!data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage3D");
   glCompressedTexImage3D(target, level, internal_format, width, height, depth,
                          border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage3D");
   if (error == GL_NO_ERROR) {
@@ skipping 545 matching lines @@
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the rect.
-    scoped_ptr<char[]> zero(new char[pixels_size]);
+    std::unique_ptr<char[]> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexImage2D(target, level,
                  texture_manager()->AdjustTexInternalFormat(internal_format),
                  width, height, border, format, type, zero.get());
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
@@ skipping 501 matching lines @@
   cmds::GetUniformfv::Result* result;
   GLenum result_type;
   GLsizei result_size;
   if (GetUniformSetup<GLfloat>(program, fake_location, c.params_shm_id,
                                c.params_shm_offset, &error, &real_location,
                                &service_id, &result, &result_type,
                                &result_size)) {
     if (result_type == GL_BOOL || result_type == GL_BOOL_VEC2 ||
         result_type == GL_BOOL_VEC3 || result_type == GL_BOOL_VEC4) {
       GLsizei num_values = result_size / sizeof(GLfloat);
-      scoped_ptr<GLint[]> temp(new GLint[num_values]);
+      std::unique_ptr<GLint[]> temp(new GLint[num_values]);
       glGetUniformiv(service_id, real_location, temp.get());
       GLfloat* dst = result->GetData();
       for (GLsizei ii = 0; ii < num_values; ++ii) {
         dst[ii] = (temp[ii] != 0);
       }
     } else {
       glGetUniformfv(service_id, real_location, result->GetData());
     }
   }
   return error;
@@ skipping 340 matching lines @@
     return error::kOutOfBounds;
   }
   const GLuint* shaders = GetSharedMemoryAs<const GLuint*>(
       c.shaders_shm_id, c.shaders_shm_offset, data_size);
   GLenum binaryformat = static_cast<GLenum>(c.binaryformat);
   const void* binary = GetSharedMemoryAs<const void*>(
       c.binary_shm_id, c.binary_shm_offset, length);
   if (shaders == NULL || binary == NULL) {
     return error::kOutOfBounds;
   }
-  scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+  std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
   for (GLsizei ii = 0; ii < n; ++ii) {
     Shader* shader = GetShader(shaders[ii]);
     if (!shader) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "unknown shader");
       return error::kNoError;
     }
     service_ids[ii] = shader->service_id();
   }
   // TODO(gman): call glShaderBinary
   return error::kNoError;
@@ skipping 818 matching lines @@
       return false;
     }
   }
 
   if (!features().native_vertex_array_object) {
     // Emulated VAO
     for (GLsizei ii = 0; ii < n; ++ii) {
       CreateVertexAttribManager(client_ids[ii], 0, true);
     }
   } else {
-    scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
+    std::unique_ptr<GLuint[]> service_ids(new GLuint[n]);
 
     glGenVertexArraysOES(n, service_ids.get());
     for (GLsizei ii = 0; ii < n; ++ii) {
       CreateVertexAttribManager(client_ids[ii], service_ids[ii], true);
     }
   }
 
   return true;
 }
 
@@ skipping 1883 matching lines @@
                                            transform_type, "transformType");
       return false;
     }
     *out_transform_type = transform_type;
     return true;
   }
   template <typename Cmd>
   bool GetPathNameData(const Cmd& cmd,
                        GLuint num_paths,
                        GLenum path_name_type,
-                       scoped_ptr<GLuint[]>* out_buffer) {
+                       std::unique_ptr<GLuint[]>* out_buffer) {
     DCHECK(validators_->path_name_type.IsValid(path_name_type));
     GLuint path_base = static_cast<GLuint>(cmd.pathBase);
     uint32_t shm_id = static_cast<uint32_t>(cmd.paths_shm_id);
     uint32_t shm_offset = static_cast<uint32_t>(cmd.paths_shm_offset);
     if (shm_id == 0 && shm_offset == 0) {
       error_ = error::kOutOfBounds;
       return false;
     }
     switch (path_name_type) {
       case GL_BYTE:
@@ skipping 66 matching lines @@
     *out_cover_mode = cover_mode;
     return true;
   }
 
  private:
   template <typename T>
   bool GetPathNameDataImpl(GLuint num_paths,
                            GLuint path_base,
                            uint32_t shm_id,
                            uint32_t shm_offset,
-                           scoped_ptr<GLuint[]>* out_buffer) {
+                           std::unique_ptr<GLuint[]>* out_buffer) {
     uint32_t paths_size = 0;
     if (!SafeMultiplyUint32(num_paths, sizeof(T), &paths_size)) {
       error_ = error::kOutOfBounds;
       return false;
     }
     T* paths = decoder_->GetSharedMemoryAs<T*>(shm_id, shm_offset, paths_size);
     if (!paths) {
       error_ = error::kOutOfBounds;
       return false;
     }
-    scoped_ptr<GLuint[]> result_paths(new GLuint[num_paths]);
+    std::unique_ptr<GLuint[]> result_paths(new GLuint[num_paths]);
     bool has_paths = false;
     for (GLuint i = 0; i < num_paths; ++i) {
       GLuint service_id = 0;
       // The below addition is ok even with over- and underflows.
       // There is no difference if client passes:
       //  * base==4, T=GLbyte, paths[0]==0xfa (-6)
       //  * base==0xffffffff, T=GLuint, paths[0]==0xffffffff
       //  * base==0, T=GLuint, paths[0]==0xfffffffe
       // For the all the cases, the interpretation is that
       // client intends to use the path 0xfffffffe.
@@ skipping 94 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "numCoords < 0");
     return error::kNoError;
   }
 
   GLenum coord_type = static_cast<uint32_t>(c.coordType);
   if (!validators_->path_coord_type.IsValid(static_cast<GLint>(coord_type))) {
     LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, kFunctionName, "invalid coordType");
     return error::kNoError;
   }
 
-  scoped_ptr<GLubyte[]> commands;
+  std::unique_ptr<GLubyte[]> commands;
   base::CheckedNumeric<GLsizei> num_coords_expected = 0;
 
   if (num_commands > 0) {
     uint32_t commands_shm_id = static_cast<uint32_t>(c.commands_shm_id);
     uint32_t commands_shm_offset = static_cast<uint32_t>(c.commands_shm_offset);
     if (commands_shm_id != 0 || commands_shm_offset != 0) {
       const GLubyte* shared_commands = GetSharedMemoryAs<const GLubyte*>(
           commands_shm_id, commands_shm_offset, num_commands);
       if (shared_commands) {
         commands.reset(new GLubyte[num_commands]);
@@ skipping 317 matching lines @@
   GLuint mask = 0;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetFillModeAndMask(c, &fill_mode, &mask) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glStencilFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                fill_mode, mask, transform_type, transforms);
@@ skipping 13 matching lines @@
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   ApplyDirtyState();
@@ skipping 17 matching lines @@
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetCoverMode(c, &cover_mode) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                              cover_mode, transform_type, transforms);
@@ skipping 15 matching lines @@
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetCoverMode(c, &cover_mode) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glCoverStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                cover_mode, transform_type, transforms);
@@ skipping 19 matching lines @@
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetFillModeAndMask(c, &fill_mode, &mask) ||
       !v.GetCoverMode(c, &cover_mode) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   ApplyDirtyState();
   glStencilThenCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(),
                                         0, fill_mode, mask, cover_mode,
@@ skipping 18 matching lines @@
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetCoverMode(c, &cover_mode) ||
       !v.GetTransformType(c, &transform_type))
     return v.error();
 
   if (num_paths == 0)
     return error::kNoError;
 
-  scoped_ptr<GLuint[]> paths;
+  std::unique_ptr<GLuint[]> paths;
   if (!v.GetPathNameData(c, num_paths, path_name_type, &paths))
     return v.error();
 
   const GLfloat* transforms = nullptr;
   if (!v.GetTransforms(c, num_paths, transform_type, &transforms))
     return v.error();
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   ApplyDirtyState();
@@ skipping 271 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu