Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/compositor/gl_helper.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 "content/browser/compositor/gl_helper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 77 matching lines @@
   }
 
   content::GLHelper::ScalerInterface* scaler() const { return scaler_.get(); }
   TextureFrameBufferPair* texture_and_framebuffer() {
     return &texture_and_framebuffer_;
   }
   GLuint texture() const { return texture_and_framebuffer_.texture(); }
 
  private:
   TextureFrameBufferPair texture_and_framebuffer_;
-  scoped_ptr<content::GLHelper::ScalerInterface> scaler_;
+  std::unique_ptr<content::GLHelper::ScalerInterface> scaler_;
 
   DISALLOW_COPY_AND_ASSIGN(ScalerHolder);
 };
 
 }  // namespace
 
 namespace content {
 typedef GLHelperReadbackSupport::FormatSupport FormatSupport;
 
 // Implements GLHelper::CropScaleReadbackAndCleanTexture and encapsulates
@@ skipping 204 matching lines @@
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
     GLHelper::ScalerQuality quality_;
     ReadbackSwizzle swizzle_;
     ScalerHolder scaler_;
-    scoped_ptr<content::GLHelperScaling::ShaderInterface> pass1_shader_;
-    scoped_ptr<content::GLHelperScaling::ShaderInterface> pass2_shader_;
+    std::unique_ptr<content::GLHelperScaling::ShaderInterface> pass1_shader_;
+    std::unique_ptr<content::GLHelperScaling::ShaderInterface> pass2_shader_;
     TextureFrameBufferPair y_;
     ScopedTexture uv_;
     TextureFrameBufferPair u_;
     TextureFrameBufferPair v_;
 
     DISALLOW_COPY_AND_ASSIGN(ReadbackYUV_MRT);
   };
 
   // Copies the block of pixels specified with |src_subrect| from |src_texture|,
   // scales it to |dst_size|, writes it into a texture, and returns its ID.
@@ skipping 79 matching lines @@
     // Use GL_RGBA for destination/temporary texture unless we're working with
     // 16-bit data
     if (color_type == kRGB_565_SkColorType) {
       format = GL_RGB;
       type = GL_UNSIGNED_SHORT_5_6_5;
     }
 
     gl_->TexImage2D(GL_TEXTURE_2D, 0, format, dst_size.width(),
                     dst_size.height(), 0, format, type, NULL);
   }
-  scoped_ptr<ScalerInterface> scaler(
+  std::unique_ptr<ScalerInterface> scaler(
       helper_->CreateScaler(quality, src_size, src_subrect, dst_size,
                             vertically_flip_texture, swizzle));
   scaler->Scale(src_texture, dst_texture);
   return dst_texture;
 }
 
 GLuint GLHelper::CopyTextureToImpl::EncodeTextureAsGrayscale(
     GLuint src_texture,
     const gfx::Size& src_size,
     gfx::Size* const encoded_texture_size,
     bool vertically_flip_texture,
     bool swizzle) {
   GLuint dst_texture = 0u;
   gl_->GenTextures(1, &dst_texture);
   // The size of the encoded texture.
   *encoded_texture_size =
       gfx::Size((src_size.width() + 3) / 4, src_size.height());
   {
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
     gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, encoded_texture_size->width(),
                     encoded_texture_size->height(), 0, GL_RGBA,
                     GL_UNSIGNED_BYTE, NULL);
   }
 
   helper_->InitScalerImpl();
-  scoped_ptr<ScalerInterface> grayscale_scaler(
+  std::unique_ptr<ScalerInterface> grayscale_scaler(
       helper_->scaler_impl_.get()->CreatePlanarScaler(
           src_size,
           gfx::Rect(0, 0, (src_size.width() + 3) & ~3, src_size.height()),
           *encoded_texture_size, vertically_flip_texture, swizzle,
           kRGBtoGrayscaleColorWeights));
   grayscale_scaler->Scale(src_texture, dst_texture);
   return dst_texture;
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackAsync(
@@ skipping 334 matching lines @@
   GLuint shader = gl_->CreateShader(type);
   GLint length = strlen(source);
   gl_->ShaderSource(shader, 1, &source, &length);
   gl_->CompileShader(shader);
   GLint compile_status = 0;
   gl_->GetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     GLint log_length = 0;
     gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
     if (log_length) {
-      scoped_ptr<GLchar[]> log(new GLchar[log_length]);
+      std::unique_ptr<GLchar[]> log(new GLchar[log_length]);
       GLsizei returned_log_length = 0;
       gl_->GetShaderInfoLog(shader, log_length, &returned_log_length,
                             log.get());
       LOG(ERROR) << std::string(log.get(), returned_log_length);
     }
     gl_->DeleteShader(shader);
     return 0;
   }
   return shader;
 }
@@ skipping 401 matching lines @@
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool flip_vertically,
     bool use_mrt) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(
       quality, src_size, src_subrect, dst_size, flip_vertically, use_mrt);
 }
 
 }  // namespace content