Convert //base to use std::unique_ptr

base/pickle_unittest.cc

 // Copyright (c) 2012 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/pickle.h"
+
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/pickle.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 const bool testbool1 = false;
 const bool testbool2 = true;
@@ skipping 132 matching lines @@
     EXPECT_DEATH(ignore_result(iter.ReadLong(&outlong)), "");
 #endif
   } else {
     EXPECT_TRUE(iter.ReadLong(&outlong));
     EXPECT_EQ(testint64, outlong);
   }
 }
 
 // Tests that we can handle really small buffers.
 TEST(PickleTest, SmallBuffer) {
-  scoped_ptr<char[]> buffer(new char[1]);
+  std::unique_ptr<char[]> buffer(new char[1]);
 
   // We should not touch the buffer.
   Pickle pickle(buffer.get(), 1);
 
   PickleIterator iter(pickle);
   int data;
   EXPECT_FALSE(iter.ReadInt(&data));
 }
 
 // Tests that we can handle improper headers.
@@ skipping 145 matching lines @@
   const char* start = reinterpret_cast<const char*>(pickle.data());
   const char* end = start + pickle.size();
 
   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end));
   EXPECT_TRUE(NULL == Pickle::FindNext(pickle.header_size_, start, end - 1));
   EXPECT_TRUE(end == Pickle::FindNext(pickle.header_size_, start, end + 1));
 }
 
 TEST(PickleTest, FindNextWithIncompleteHeader) {
   size_t header_size = sizeof(Pickle::Header);
-  scoped_ptr<char[]> buffer(new char[header_size - 1]);
+  std::unique_ptr<char[]> buffer(new char[header_size - 1]);
   memset(buffer.get(), 0x1, header_size - 1);
 
   const char* start = buffer.get();
   const char* end = start + header_size - 1;
 
   EXPECT_TRUE(NULL == Pickle::FindNext(header_size, start, end));
 }
 
 #if defined(COMPILER_MSVC)
 #pragma warning(push)
 #pragma warning(disable: 4146)
 #endif
 TEST(PickleTest, FindNextOverflow) {
   size_t header_size = sizeof(Pickle::Header);
   size_t header_size2 = 2 * header_size;
   size_t payload_received = 100;
-  scoped_ptr<char[]> buffer(new char[header_size2 + payload_received]);
+  std::unique_ptr<char[]> buffer(new char[header_size2 + payload_received]);
   const char* start = buffer.get();
   Pickle::Header* header = reinterpret_cast<Pickle::Header*>(buffer.get());
   const char* end = start + header_size2 + payload_received;
   // It is impossible to construct an overflow test otherwise.
   if (sizeof(size_t) > sizeof(header->payload_size) ||
       sizeof(uintptr_t) > sizeof(header->payload_size))
     return;
 
   header->payload_size = -(reinterpret_cast<uintptr_t>(start) + header_size2);
   EXPECT_TRUE(NULL == Pickle::FindNext(header_size2, start, end));
@@ skipping 23 matching lines @@
   EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(1));
   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(-1));
   EXPECT_TRUE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes));
   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(bytes + 1));
   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MAX));
   EXPECT_FALSE(PickleIterator(pickle).GetReadPointerAndAdvance(INT_MIN));
 }
 
 TEST(PickleTest, Resize) {
   size_t unit = Pickle::kPayloadUnit;
-  scoped_ptr<char[]> data(new char[unit]);
+  std::unique_ptr<char[]> data(new char[unit]);
   char* data_ptr = data.get();
   for (size_t i = 0; i < unit; i++)
     data_ptr[i] = 'G';
 
   // construct a message that will be exactly the size of one payload unit,
   // note that any data will have a 4-byte header indicating the size
   const size_t payload_size_after_header = unit - sizeof(uint32_t);
   Pickle pickle;
   pickle.WriteData(
       data_ptr, static_cast<int>(payload_size_after_header - sizeof(uint32_t)));
@@ skipping 254 matching lines @@
   {
     TestingPickle pickle;
     base::PickleSizer sizer;
     pickle.WriteBytes(testdata, testdatalen);
     sizer.AddBytes(testdatalen);
     EXPECT_EQ(sizer.payload_size(), pickle.payload_size());
   }
 }
 
 }  // namespace base