Replace scoped_ptr with unique_ptr everywhere

webrtc/tools/frame_editing/frame_editing_unittest.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 <stdio.h>
 #include <stdlib.h>
 
 #include <fstream>
+#include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/tools/frame_editing/frame_editing_lib.h"
 
 namespace webrtc {
 namespace test {
 
 const int kWidth = 352;
 const int kHeight = 288;
 const size_t kFrameSize = CalcBufferSize(kI420, kWidth, kHeight);
@@ skipping 21 matching lines @@
     num_frames_read_ = 0;
   }
   virtual void TearDown() {
     fclose(original_fid_);
     fclose(edited_fid_);
     remove(test_video_.c_str());
   }
   // Compares the frames in both streams to the end of one of the streams.
   void CompareToTheEnd(FILE* test_video_fid,
                        FILE* ref_video_fid,
-                       rtc::scoped_ptr<int[]>* ref_buffer,
-                       rtc::scoped_ptr<int[]>* test_buffer) {
+                       std::unique_ptr<int[]>* ref_buffer,
+                       std::unique_ptr<int[]>* test_buffer) {
     while (!feof(test_video_fid) && !feof(ref_video_fid)) {
       num_bytes_read_ = fread(ref_buffer->get(), 1, kFrameSize, ref_video_fid);
       if (!feof(ref_video_fid)) {
         EXPECT_EQ(kFrameSize, num_bytes_read_);
       }
       num_bytes_read_ = fread(test_buffer->get(), 1, kFrameSize,
                               test_video_fid);
       if (!feof(test_video_fid)) {
         EXPECT_EQ(kFrameSize, num_bytes_read_);
       }
       if (!feof(test_video_fid) && !feof(test_video_fid)) {
         EXPECT_EQ(0, memcmp(ref_buffer->get(), test_buffer->get(),
                             kFrameSize));
       }
     }
     // There should not be anything left in either stream.
     EXPECT_EQ(!feof(test_video_fid), !feof(ref_video_fid));
   }
   std::string reference_video_;
   std::string test_video_;
   FILE* original_fid_;
   FILE* edited_fid_;
   size_t num_bytes_read_;
-  rtc::scoped_ptr<int[]> original_buffer_;
-  rtc::scoped_ptr<int[]> edited_buffer_;
+  std::unique_ptr<int[]> original_buffer_;
+  std::unique_ptr<int[]> edited_buffer_;
   int num_frames_read_;
 };
 
 TEST_F(FrameEditingTest, ValidInPath) {
   const int kFirstFrameToProcess = 160;
   const int kInterval = -1;
   const int kLastFrameToProcess = 240;
 
   int result = EditFrames(reference_video_, kWidth, kHeight,
                           kFirstFrameToProcess, kInterval, kLastFrameToProcess,
@@ skipping 111 matching lines @@
       EXPECT_EQ(kFrameSize, num_bytes_read_);
       EXPECT_EQ(0, memcmp(original_buffer_.get(), edited_buffer_.get(),
                           kFrameSize));
     }
   }
   CompareToTheEnd(edited_fid_, original_fid_, &original_buffer_,
                   &edited_buffer_);
 }
 }  // namespace test
 }  // namespace webrtc