Convert //base to use std::unique_ptr

base/files/memory_mapped_file_unittest.cc

 // Copyright 2014 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 "base/files/memory_mapped_file.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace base {
 
 namespace {
 
 // Create a temporary buffer and fill it with a watermark sequence.
-scoped_ptr<uint8_t[]> CreateTestBuffer(size_t size, size_t offset) {
-  scoped_ptr<uint8_t[]> buf(new uint8_t[size]);
+std::unique_ptr<uint8_t[]> CreateTestBuffer(size_t size, size_t offset) {
+  std::unique_ptr<uint8_t[]> buf(new uint8_t[size]);
   for (size_t i = 0; i < size; ++i)
     buf.get()[i] = static_cast<uint8_t>((offset + i) % 253);
   return buf;
 }
 
 // Check that the watermark sequence is consistent with the |offset| provided.
 bool CheckBufferContents(const uint8_t* data, size_t size, size_t offset) {
-  scoped_ptr<uint8_t[]> test_data(CreateTestBuffer(size, offset));
+  std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, offset));
   return memcmp(test_data.get(), data, size) == 0;
 }
 
 class MemoryMappedFileTest : public PlatformTest {
  protected:
   void SetUp() override {
     PlatformTest::SetUp();
     CreateTemporaryFile(&temp_file_path_);
   }
 
   void TearDown() override { EXPECT_TRUE(DeleteFile(temp_file_path_, false)); }
 
   void CreateTemporaryTestFile(size_t size) {
     File file(temp_file_path_,
               File::FLAG_CREATE_ALWAYS | File::FLAG_READ | File::FLAG_WRITE);
     EXPECT_TRUE(file.IsValid());
 
-    scoped_ptr<uint8_t[]> test_data(CreateTestBuffer(size, 0));
+    std::unique_ptr<uint8_t[]> test_data(CreateTestBuffer(size, 0));
     size_t bytes_written =
         file.Write(0, reinterpret_cast<char*>(test_data.get()), size);
     EXPECT_EQ(size, bytes_written);
     file.Close();
   }
 
   const FilePath temp_file_path() const { return temp_file_path_; }
 
  private:
   FilePath temp_file_path_;
@@ skipping 106 matching lines @@
   map.Initialize(std::move(file), region);
   ASSERT_EQ(kPartialSize, map.length());
   ASSERT_TRUE(map.data() != NULL);
   EXPECT_TRUE(map.IsValid());
   ASSERT_TRUE(CheckBufferContents(map.data(), kPartialSize, kOffset));
 }
 
 }  // namespace
 
 }  // namespace base