Convert //base to use std::unique_ptr

base/strings/safe_sprintf_unittest.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 "base/strings/safe_sprintf.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <limits>
+#include <memory>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Death tests on Android are currently very flaky. No need to add more flaky
 // tests, as they just make it hard to spot real problems.
 // TODO(markus): See if the restrictions on Android can eventually be lifted.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 #define ALLOW_DEATH_TEST
 #endif
 
@@ skipping 171 matching lines @@
   EXPECT_DEATH(SafeSPrintf(buf, "%c%c", 'A'), "cur_arg < max_args");
 #endif
 }
 
 TEST(SafeSPrintfTest, ASANFriendlyBufferTest) {
   // Print into a buffer that is sized exactly to size. ASAN can verify that
   // nobody attempts to write past the end of the buffer.
   // There is a more complicated test in PrintLongString() that covers a lot
   // more edge case, but it is also harder to debug in case of a failure.
   const char kTestString[] = "This is a test";
-  scoped_ptr<char[]> buf(new char[sizeof(kTestString)]);
+  std::unique_ptr<char[]> buf(new char[sizeof(kTestString)]);
   EXPECT_EQ(static_cast<ssize_t>(sizeof(kTestString) - 1),
             SafeSNPrintf(buf.get(), sizeof(kTestString), kTestString));
   EXPECT_EQ(std::string(kTestString), std::string(buf.get()));
   EXPECT_EQ(static_cast<ssize_t>(sizeof(kTestString) - 1),
             SafeSNPrintf(buf.get(), sizeof(kTestString), "%s", kTestString));
   EXPECT_EQ(std::string(kTestString), std::string(buf.get()));
 }
 
 TEST(SafeSPrintfTest, NArgs) {
   // Pre-C++11 compilers have a different code path, that can only print
@@ skipping 143 matching lines @@
 }
 
 namespace {
 void PrintLongString(char* buf, size_t sz) {
   // Output a reasonably complex expression into a limited-size buffer.
   // At least one byte is available for writing the NUL character.
   CHECK_GT(sz, static_cast<size_t>(0));
 
   // Allocate slightly more space, so that we can verify that SafeSPrintf()
   // never writes past the end of the buffer.
-  scoped_ptr<char[]> tmp(new char[sz+2]);
+  std::unique_ptr<char[]> tmp(new char[sz + 2]);
   memset(tmp.get(), 'X', sz+2);
 
   // Use SafeSPrintf() to output a complex list of arguments:
   // - test padding and truncating %c single characters.
   // - test truncating %s simple strings.
   // - test mismatching arguments and truncating (for %d != %s).
   // - test zero-padding and truncating %x hexadecimal numbers.
   // - test outputting and truncating %d MININT.
   // - test outputting and truncating %p arbitrary pointer values.
   // - test outputting, padding and truncating NULL-pointer %s strings.
   char* out = tmp.get();
   size_t out_sz = sz;
   size_t len;
-  for (scoped_ptr<char[]> perfect_buf;;) {
+  for (std::unique_ptr<char[]> perfect_buf;;) {
     size_t needed = SafeSNPrintf(out, out_sz,
 #if defined(NDEBUG)
                             "A%2cong %s: %d %010X %d %p%7s", 'l', "string", "",
 #else
                             "A%2cong %s: %%d %010X %d %p%7s", 'l', "string",
 #endif
                             0xDEADBEEF, std::numeric_limits<intptr_t>::min(),
                             PrintLongString, static_cast<char*>(NULL)) + 1;
 
     // Various sanity checks:
@@ skipping 357 matching lines @@
   void *ptr = str;
   char buf[40];
   EXPECT_EQ(10, SafeSPrintf(buf, "%p", str));
   EXPECT_EQ("0x80000000", std::string(buf));
   EXPECT_EQ(10, SafeSPrintf(buf, "%p", ptr));
   EXPECT_EQ("0x80000000", std::string(buf));
 }
 
 }  // namespace strings
 }  // namespace base