Convert //remoting to use std::unique_ptr

remoting/codec/video_encoder_vpx.cc

 // Copyright 2013 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 "remoting/codec/video_encoder_vpx.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "remoting/base/util.h"
 #include "remoting/proto/video.pb.h"
 #include "third_party/libyuv/include/libyuv/convert_from_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
 extern "C" {
 #define VPX_CODEC_DISABLE_COMPAT 1
@@ skipping 122 matching lines @@
   DCHECK_EQ(VPX_CODEC_OK, ret) << "Failed to set screen content mode";
 
   // Set cyclic refresh (aka "top-off") only for lossy encoding.
   int aq_mode = lossless_encode ? kVp9AqModeNone : kVp9AqModeCyclicRefresh;
   ret = vpx_codec_control(codec, VP9E_SET_AQ_MODE, aq_mode);
   DCHECK_EQ(VPX_CODEC_OK, ret) << "Failed to set aq mode";
 }
 
 void FreeImageIfMismatched(bool use_i444,
                            const webrtc::DesktopSize& size,
-                           scoped_ptr<vpx_image_t>* out_image,
-                           scoped_ptr<uint8_t[]>* out_image_buffer) {
+                           std::unique_ptr<vpx_image_t>* out_image,
+                           std::unique_ptr<uint8_t[]>* out_image_buffer) {
   if (*out_image) {
     const vpx_img_fmt_t desired_fmt =
         use_i444 ? VPX_IMG_FMT_I444 : VPX_IMG_FMT_I420;
     if (!size.equals(webrtc::DesktopSize((*out_image)->w, (*out_image)->h)) ||
         (*out_image)->fmt != desired_fmt) {
       out_image_buffer->reset();
       out_image->reset();
     }
   }
 }
 
 void CreateImage(bool use_i444,
                  const webrtc::DesktopSize& size,
-                 scoped_ptr<vpx_image_t>* out_image,
-                 scoped_ptr<uint8_t[]>* out_image_buffer) {
+                 std::unique_ptr<vpx_image_t>* out_image,
+                 std::unique_ptr<uint8_t[]>* out_image_buffer) {
   DCHECK(!size.is_empty());
   DCHECK(!*out_image_buffer);
   DCHECK(!*out_image);
 
-  scoped_ptr<vpx_image_t> image(new vpx_image_t());
+  std::unique_ptr<vpx_image_t> image(new vpx_image_t());
   memset(image.get(), 0, sizeof(vpx_image_t));
 
   // libvpx seems to require both to be assigned.
   image->d_w = size.width();
   image->w = size.width();
   image->d_h = size.height();
   image->h = size.height();
 
   // libvpx should derive chroma shifts from|fmt| but currently has a bug:
   // https://code.google.com/p/webm/issues/detail?id=627
@@ skipping 17 matching lines @@
   // if the image is not padded out to the next macroblock: crbug.com/119633.
   // Pad the Y, U and V planes' height out to compensate.
   // Assuming macroblocks are 16x16, aligning the planes' strides above also
   // macroblock aligned them.
   static_assert(kMacroBlockSize == 16, "macroblock_size_not_16");
   const int y_rows = ((image->h - 1) & ~(kMacroBlockSize-1)) + kMacroBlockSize;
   const int uv_rows = y_rows >> image->y_chroma_shift;
 
   // Allocate a YUV buffer large enough for the aligned data & padding.
   const int buffer_size = y_stride * y_rows + 2*uv_stride * uv_rows;
-  scoped_ptr<uint8_t[]> image_buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[buffer_size]);
 
   // Reset image value to 128 so we just need to fill in the y plane.
   memset(image_buffer.get(), 128, buffer_size);
 
   // Fill in the information for |image_|.
   unsigned char* uchar_buffer =
       reinterpret_cast<unsigned char*>(image_buffer.get());
   image->planes[0] = uchar_buffer;
   image->planes[1] = image->planes[0] + y_stride * y_rows;
   image->planes[2] = image->planes[1] + uv_stride * uv_rows;
   image->stride[0] = y_stride;
   image->stride[1] = uv_stride;
   image->stride[2] = uv_stride;
 
   *out_image = std::move(image);
   *out_image_buffer = std::move(image_buffer);
 }
 
 } // namespace
 
 // static
-scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP8() {
-  return make_scoped_ptr(new VideoEncoderVpx(false));
+std::unique_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP8() {
+  return base::WrapUnique(new VideoEncoderVpx(false));
 }
 
 // static
-scoped_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP9() {
-  return make_scoped_ptr(new VideoEncoderVpx(true));
+std::unique_ptr<VideoEncoderVpx> VideoEncoderVpx::CreateForVP9() {
+  return base::WrapUnique(new VideoEncoderVpx(true));
 }
 
 VideoEncoderVpx::~VideoEncoderVpx() {}
 
 void VideoEncoderVpx::SetTickClockForTests(base::TickClock* tick_clock) {
   clock_ = tick_clock;
 }
 
 void VideoEncoderVpx::SetLosslessEncode(bool want_lossless) {
   if (use_vp9_ && (want_lossless != lossless_encode_)) {
     lossless_encode_ = want_lossless;
     if (codec_)
       Configure(webrtc::DesktopSize(codec_->config.enc->g_w,
                                     codec_->config.enc->g_h));
   }
 }
 
 void VideoEncoderVpx::SetLosslessColor(bool want_lossless) {
   if (use_vp9_ && (want_lossless != lossless_color_)) {
     lossless_color_ = want_lossless;
     // TODO(wez): Switch to ConfigureCodec() path once libvpx supports it.
     // See https://code.google.com/p/webm/issues/detail?id=913.
     //if (codec_)
     //  Configure(webrtc::DesktopSize(codec_->config.enc->g_w,
     //                                codec_->config.enc->g_h));
     codec_.reset();
   }
 }
 
-scoped_ptr<VideoPacket> VideoEncoderVpx::Encode(
+std::unique_ptr<VideoPacket> VideoEncoderVpx::Encode(
     const webrtc::DesktopFrame& frame) {
   DCHECK_LE(32, frame.size().width());
   DCHECK_LE(32, frame.size().height());
 
   // If there is nothing to encode, and nothing to top-off, then return nothing.
   if (frame.updated_region().is_empty() && !encode_unchanged_frame_)
     return nullptr;
 
   // Create or reconfigure the codec to match the size of |frame|.
   if (!codec_ ||
@@ skipping 37 matching lines @@
     // If the encoder output no changes then there's nothing left to top-off.
     encode_unchanged_frame_ = !updated_region.is_empty();
   }
 
   // Read the encoded data.
   vpx_codec_iter_t iter = nullptr;
   bool got_data = false;
 
   // TODO(hclam): Make sure we get exactly one frame from the packet.
   // TODO(hclam): We should provide the output buffer to avoid one copy.
-  scoped_ptr<VideoPacket> packet(
+  std::unique_ptr<VideoPacket> packet(
       helper_.CreateVideoPacketWithUpdatedRegion(frame, updated_region));
   packet->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
 
   while (!got_data) {
     const vpx_codec_cx_pkt_t* vpx_packet =
         vpx_codec_get_cx_data(codec_.get(), &iter);
     if (!vpx_packet)
       continue;
 
     switch (vpx_packet->kind) {
@@ skipping 202 matching lines @@
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting