Convert a few components from scoped_ptr to std::unique_ptr

components/crash/content/browser/crash_handler_host_linux.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 "components/crash/content/browser/crash_handler_host_linux.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 39 matching lines @@
 
 const size_t kNumFDs = 1;
 // The length of the control message:
 const size_t kControlMsgSize =
     CMSG_SPACE(kNumFDs * sizeof(int)) + CMSG_SPACE(sizeof(struct ucred));
 // The length of the regular payload:
 const size_t kCrashContextSize = sizeof(ExceptionHandler::CrashContext);
 
 // Handles the crash dump and frees the allocated BreakpadInfo struct.
 void CrashDumpTask(CrashHandlerHostLinux* handler,
-                   scoped_ptr<BreakpadInfo> info) {
+                   std::unique_ptr<BreakpadInfo> info) {
   if (handler->IsShuttingDown() && info->upload) {
     base::DeleteFile(base::FilePath(info->filename), false);
 #if defined(ADDRESS_SANITIZER)
     base::DeleteFile(base::FilePath(info->log_filename), false);
 #endif
     return;
   }
 
   HandleCrashDump(*info);
   delete[] info->filename;
@@ skipping 72 matching lines @@
   // A process has crashed and has signaled us by writing a datagram
   // to the death signal socket. The datagram contains the crash context needed
   // for writing the minidump as well as a file descriptor and a credentials
   // block so that they can't lie about their pid.
   //
   // The message sender is in components/crash/content/app/breakpad_linux.cc.
 
   struct msghdr msg = {0};
   struct iovec iov[kCrashIovSize];
 
-  scoped_ptr<char[]> crash_context(new char[kCrashContextSize]);
+  std::unique_ptr<char[]> crash_context(new char[kCrashContextSize]);
 #if defined(ADDRESS_SANITIZER)
-  scoped_ptr<char[]> asan_report(new char[kMaxAsanReportSize + 1]);
+  std::unique_ptr<char[]> asan_report(new char[kMaxAsanReportSize + 1]);
 #endif
 
-  scoped_ptr<CrashKeyStorage> crash_keys(new CrashKeyStorage);
+  std::unique_ptr<CrashKeyStorage> crash_keys(new CrashKeyStorage);
   google_breakpad::SerializedNonAllocatingMap* serialized_crash_keys;
   size_t crash_keys_size = crash_keys->Serialize(
       const_cast<const google_breakpad::SerializedNonAllocatingMap**>(
           &serialized_crash_keys));
 
   char* tid_buf_addr = NULL;
   int tid_fd = -1;
   uint64_t uptime;
   size_t oom_size;
   char control[kControlMsgSize];
@@ skipping 123 matching lines @@
     // trust the TID passed by the crashing process.
     LOG(WARNING) << "Could not translate tid - assuming crashing thread is "
         "thread group leader; syscall_supported=" << syscall_supported;
     crashing_tid = crashing_pid;
   }
 
   ExceptionHandler::CrashContext* bad_context =
       reinterpret_cast<ExceptionHandler::CrashContext*>(crash_context.get());
   bad_context->tid = crashing_tid;
 
-  scoped_ptr<BreakpadInfo> info(new BreakpadInfo);
+  std::unique_ptr<BreakpadInfo> info(new BreakpadInfo);
 
   info->fd = -1;
   info->process_type_length = process_type_.length();
   // Freed in CrashDumpTask().
   char* process_type_str = new char[info->process_type_length + 1];
   process_type_.copy(process_type_str, info->process_type_length);
   process_type_str[info->process_type_length] = '\0';
   info->process_type = process_type_str;
 
-  // Memory released from scoped_ptrs below are also freed in CrashDumpTask().
+  // Memory released from std::unique_ptrs below are also freed in
+  // CrashDumpTask().
   info->crash_keys = crash_keys.release();
 #if defined(ADDRESS_SANITIZER)
   asan_report[kMaxAsanReportSize] = '\0';
   info->asan_report_str = asan_report.release();
   info->asan_report_length = strlen(info->asan_report_str);
 #endif
 
   info->process_start_time = uptime;
   info->oom_size = oom_size;
 #if defined(OS_ANDROID)
   // Nothing gets uploaded in android.
   info->upload = false;
 #else
   info->upload = upload_;
 #endif
 
 
   BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(
       worker_pool_token_,
       FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::WriteDumpFile,
                  base::Unretained(this),
                  base::Passed(&info),
                  base::Passed(&crash_context),
                  crashing_pid,
                  signal_fd.release()));
 }
 
-void CrashHandlerHostLinux::WriteDumpFile(scoped_ptr<BreakpadInfo> info,
-                                          scoped_ptr<char[]> crash_context,
+void CrashHandlerHostLinux::WriteDumpFile(std::unique_ptr<BreakpadInfo> info,
+                                          std::unique_ptr<char[]> crash_context,
                                           pid_t crashing_pid,
                                           int signal_fd) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       worker_pool_token_));
 
   // Set |info->distro| here because base::GetLinuxDistro() needs to run on a
   // blocking thread.
   std::string distro = base::GetLinuxDistro();
   info->distro_length = distro.length();
   // Freed in CrashDumpTask().
@@ skipping 44 matching lines @@
   info->pid = crashing_pid;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::QueueCrashDumpTask,
                  base::Unretained(this),
                  base::Passed(&info),
                  signal_fd));
 }
 
-void CrashHandlerHostLinux::QueueCrashDumpTask(scoped_ptr<BreakpadInfo> info,
-                                               int signal_fd) {
+void CrashHandlerHostLinux::QueueCrashDumpTask(
+    std::unique_ptr<BreakpadInfo> info,
+    int signal_fd) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Send the done signal to the process: it can exit now.
   struct msghdr msg = {0};
   struct iovec done_iov;
   done_iov.iov_base = const_cast<char*>("\x42");
   done_iov.iov_len = 1;
   msg.msg_iov = &done_iov;
   msg.msg_iovlen = 1;
 
@@ skipping 12 matching lines @@
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
 
 bool CrashHandlerHostLinux::IsShuttingDown() const {
   return shutting_down_;
 }
 
 }  // namespace breakpad