Replace scoped_ptr with unique_ptr in webrtc/modules/video_coding/

webrtc/modules/video_coding/codecs/test/videoprocessor.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
+#include <memory>
 #include <vector>
 
 #include "webrtc/system_wrappers/include/cpu_info.h"
 
 namespace webrtc {
 namespace test {
 
 TestConfig::TestConfig()
     : name(""),
       description(""),
@@ skipping 249 matching lines @@
         exclude_this_frame = true;
         break;
       default:
         assert(false);
     }
   }
 
   // Make a raw copy of the |encoded_image| buffer.
   size_t copied_buffer_size = encoded_image._length +
                               EncodedImage::GetBufferPaddingBytes(codec);
-  rtc::scoped_ptr<uint8_t[]> copied_buffer(new uint8_t[copied_buffer_size]);
+  std::unique_ptr<uint8_t[]> copied_buffer(new uint8_t[copied_buffer_size]);
   memcpy(copied_buffer.get(), encoded_image._buffer, encoded_image._length);
   // The image to feed to the decoder.
   EncodedImage copied_image;
   memcpy(&copied_image, &encoded_image, sizeof(copied_image));
   copied_image._size = copied_buffer_size;
   copied_image._buffer = copied_buffer.get();
 
   if (!exclude_this_frame) {
     stat.packets_dropped =
         packet_manipulator_->ManipulatePackets(&copied_image);
@@ skipping 46 matching lines @@
               frame_number, ret_val);
     }
     ret_val = scaler_.Scale(image, &up_image);
     assert(ret_val >= 0);
     if (ret_val < 0) {
       fprintf(stderr, "Failed to scale frame: %d, return code: %d\n",
               frame_number, ret_val);
     }
     // TODO(mikhal): Extracting the buffer for now - need to update test.
     size_t length = CalcBufferSize(kI420, up_image.width(), up_image.height());
-    rtc::scoped_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
+    std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(up_image, length, image_buffer.get());
     assert(extracted_length > 0);
     // Update our copy of the last successful frame:
     memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
     assert(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   } else {  // No resize.
     // Update our copy of the last successful frame:
     // TODO(mikhal): Add as a member function, so won't be allocated per frame.
     size_t length = CalcBufferSize(kI420, image.width(), image.height());
-    rtc::scoped_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
+    std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(image, length, image_buffer.get());
     assert(extracted_length > 0);
     memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
 
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
     assert(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   }
@@ skipping 52 matching lines @@
 }
 int32_t VideoProcessorImpl::VideoProcessorDecodeCompleteCallback::Decoded(
     VideoFrame& image) {
   // Forward to parent class.
   video_processor_->FrameDecoded(image);
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc