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/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(

[Nico, 2016/04/04 17:14:55]

(file doesn't iwyu for freedeleter i think)

[dcheng, 2016/04/04 17:43:38]

Note that this CL isn't attempt to address IWYU globally for everything. I'm
thinking about formulating something to make this situation less insane in the
future, but nothing concrete yet.

For this particular issue, the header is already present, just in the wrong
section. I've moved it.

+        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