Replace scoped_ptr with unique_ptr in webrtc/base/

webrtc/base/filerotatingstream_unittest.cc

 /*
  *  Copyright 2015 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 <memory>
+
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/filerotatingstream.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"
 
 namespace rtc {
 
 class FileRotatingStreamTest : public ::testing::Test {
@@ skipping 29 matching lines @@
     EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
     EXPECT_TRUE(stream_->Flush());
   }
 
   // Checks that the stream reads in the expected contents and then returns an
   // end of stream result.
   void VerifyStreamRead(const char* expected_contents,
                         const size_t expected_length,
                         const std::string& dir_path,
                         const char* file_prefix) {
-    scoped_ptr<FileRotatingStream> stream;
+    std::unique_ptr<FileRotatingStream> stream;
     stream.reset(new FileRotatingStream(dir_path, file_prefix));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }
 
   void VerifyFileContents(const char* expected_contents,
                           const size_t expected_length,
                           const std::string& file_path) {
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
-    scoped_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<FileStream> stream(Filesystem::OpenFile(file_path, "r"));
     EXPECT_TRUE(stream);
     if (!stream) {
       return;
     }
     EXPECT_EQ(rtc::SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     size_t file_size = 0;
     EXPECT_TRUE(stream->GetSize(&file_size));
     EXPECT_EQ(file_size, expected_length);
   }
 
-  scoped_ptr<FileRotatingStream> stream_;
+  std::unique_ptr<FileRotatingStream> stream_;
   std::string dir_path_;
 };
 
 const char* FileRotatingStreamTest::kFilePrefix = "FileRotatingStreamTest";
 const size_t FileRotatingStreamTest::kMaxFileSize = 2;
 
 // Tests that stream state is correct before and after Open / Close.
 TEST_F(FileRotatingStreamTest, State) {
   Init("FileRotatingStreamTestState", kFilePrefix, kMaxFileSize, 3);
 
   EXPECT_EQ(SS_CLOSED, stream_->GetState());
   ASSERT_TRUE(stream_->Open());
   EXPECT_EQ(SS_OPEN, stream_->GetState());
   stream_->Close();
   EXPECT_EQ(SS_CLOSED, stream_->GetState());
 }
 
 // Tests that nothing is written to file when data of length zero is written.
 TEST_F(FileRotatingStreamTest, EmptyWrite) {
   Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);
 
   ASSERT_TRUE(stream_->Open());
   WriteAndFlush("a", 0);
 
   std::string logfile_path = stream_->GetFilePath(0);
-  scoped_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
+  std::unique_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
   size_t file_size = 0;
   EXPECT_TRUE(stream->GetSize(&file_size));
   EXPECT_EQ(0u, file_size);
 }
 
 // Tests that a write operation followed by a read returns the expected data
 // and writes to the expected files.
 TEST_F(FileRotatingStreamTest, WriteAndRead) {
   Init("FileRotatingStreamTestWriteAndRead", kFilePrefix, kMaxFileSize, 3);
 
@@ skipping 80 matching lines @@
   void WriteAndFlush(const void* data, const size_t data_len) {
     EXPECT_EQ(SR_SUCCESS, stream_->WriteAll(data, data_len, nullptr, nullptr));
     EXPECT_TRUE(stream_->Flush());
   }
 
   // Checks that the stream reads in the expected contents and then returns an
   // end of stream result.
   void VerifyStreamRead(const char* expected_contents,
                         const size_t expected_length,
                         const std::string& dir_path) {
-    scoped_ptr<CallSessionFileRotatingStream> stream(
+    std::unique_ptr<CallSessionFileRotatingStream> stream(
         new CallSessionFileRotatingStream(dir_path));
     ASSERT_TRUE(stream->Open());
     size_t read = 0;
     size_t stream_size = 0;
     EXPECT_TRUE(stream->GetSize(&stream_size));
-    scoped_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
+    std::unique_ptr<uint8_t[]> buffer(new uint8_t[expected_length]);
     EXPECT_EQ(SR_SUCCESS,
               stream->ReadAll(buffer.get(), expected_length, &read, nullptr));
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }
 
-  scoped_ptr<CallSessionFileRotatingStream> stream_;
+  std::unique_ptr<CallSessionFileRotatingStream> stream_;
   std::string dir_path_;
 };
 
 // Tests that writing and reading to a stream with the smallest possible
 // capacity works.
 TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadSmallest", 4);
 
   ASSERT_TRUE(stream_->Open());
   std::string message("abcde");
@@ skipping 16 matching lines @@
                    dir_path_);
 }
 
 // Tests that writing and reading to a stream with capacity greater than 4MB
 // behaves correctly.
 TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);
 
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 8; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
-  scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1, 2, 6, 7};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }
 
 // Tests that writing and reading to a stream where only the first file is
 // written to behaves correctly.
 TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
        6 * 1024 * 1024);
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 2; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
-  scoped_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }
 
 }  // namespace rtc