Convert //base to use std::unique_ptr

base/debug/stack_trace_posix.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/debug/stack_trace.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <map>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
-#include "base/memory/free_deleter.h"
-
 #if defined(__GLIBCXX__)
 #include <cxxabi.h>
 #endif
 #if !defined(__UCLIBC__)
 #include <execinfo.h>
 #endif
 
 #if defined(OS_MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include "base/debug/debugger.h"
 #include "base/debug/proc_maps_linux.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/free_deleter.h"
 #include "base/memory/singleton.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 
 #if defined(USE_SYMBOLIZE)
 #include "base/third_party/symbolize/symbolize.h"
 #endif
 
@@ skipping 40 matching lines @@
     std::string::size_type mangled_end =
         text->find_first_not_of(kSymbolCharacters, mangled_start);
     if (mangled_end == std::string::npos) {
       mangled_end = text->size();
     }
     std::string mangled_symbol =
         text->substr(mangled_start, mangled_end - mangled_start);
 
     // Try to demangle the mangled symbol candidate.
     int status = 0;
-    scoped_ptr<char, base::FreeDeleter> demangled_symbol(
+    std::unique_ptr<char, base::FreeDeleter> demangled_symbol(
         abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
     if (status == 0) {  // Demangling is successful.
       // Remove the mangled symbol.
       text->erase(mangled_start, mangled_end - mangled_start);
       // Insert the demangled symbol.
       text->insert(mangled_start, demangled_symbol.get());
       // Next time, we'll start right after the demangled symbol we inserted.
       search_from = mangled_start + strlen(demangled_symbol.get());
     } else {
       // Failed to demangle.  Retry after the "_Z" we just found.
@@ skipping 60 matching lines @@
       handler->HandleOutput("<unknown>");
 
     handler->HandleOutput("\n");
   }
 #else
   bool printed = false;
 
   // Below part is async-signal unsafe (uses malloc), so execute it only
   // when we are not executing the signal handler.
   if (in_signal_handler == 0) {
-    scoped_ptr<char*, FreeDeleter>
-        trace_symbols(backtrace_symbols(trace, size));
+    std::unique_ptr<char*, FreeDeleter> trace_symbols(
+        backtrace_symbols(trace, size));
     if (trace_symbols.get()) {
       for (size_t i = 0; i < size; ++i) {
         std::string trace_symbol = trace_symbols.get()[i];
         DemangleSymbols(&trace_symbol);
         handler->HandleOutput(trace_symbol.c_str());
         handler->HandleOutput("\n");
       }
 
       printed = true;
     }
@@ skipping 610 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base