Convert chrome/common to std::unique_ptr

chrome/common/service_process_util.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 "chrome/common/service_process_util.h"
 
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/sha1.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 92 matching lines @@
     const std::string& append_str) {
   std::string versioned_str;
   versioned_str.append(version_info::GetVersionNumber());
   versioned_str.append(append_str);
   return GetServiceProcessScopedName(versioned_str);
 }
 
 // Reads the named shared memory to get the shared data. Returns false if no
 // matching shared memory was found.
 bool GetServiceProcessData(std::string* version, base::ProcessId* pid) {
-  scoped_ptr<base::SharedMemory> shared_mem_service_data;
+  std::unique_ptr<base::SharedMemory> shared_mem_service_data;
   shared_mem_service_data.reset(new base::SharedMemory());
   ServiceProcessSharedData* service_data = NULL;
   if (shared_mem_service_data.get() &&
       shared_mem_service_data->Open(GetServiceProcessSharedMemName(), true) &&
       shared_mem_service_data->Map(sizeof(ServiceProcessSharedData))) {
     service_data = reinterpret_cast<ServiceProcessSharedData*>(
         shared_mem_service_data->memory());
     // Make sure the version in shared memory is null-terminated. If it is not,
     // treat it as invalid.
     if (version && memchr(service_data->service_process_version, '\0',
@@ skipping 17 matching lines @@
 #if defined(OS_WIN)
   std::string user_data_dir_path = base::WideToUTF8(user_data_dir.value());
 #elif defined(OS_POSIX)
   std::string user_data_dir_path = user_data_dir.value();
 #endif  // defined(OS_WIN)
   std::string hash = base::SHA1HashString(user_data_dir_path);
   std::string hex_hash = base::HexEncode(hash.c_str(), hash.length());
   return hex_hash + "." + append_str;
 }
 
-scoped_ptr<base::CommandLine> CreateServiceProcessCommandLine() {
+std::unique_ptr<base::CommandLine> CreateServiceProcessCommandLine() {
   base::FilePath exe_path;
   PathService::Get(content::CHILD_PROCESS_EXE, &exe_path);
   DCHECK(!exe_path.empty()) << "Unable to get service process binary name.";
-  scoped_ptr<base::CommandLine> command_line(new base::CommandLine(exe_path));
+  std::unique_ptr<base::CommandLine> command_line(
+      new base::CommandLine(exe_path));
   command_line->AppendSwitchASCII(switches::kProcessType,
                                   switches::kServiceProcess);
 
 #if defined(OS_WIN)
   if (startup_metric_utils::GetPreReadOptions().use_prefetch_argument)
     command_line->AppendArg(switches::kPrefetchArgumentOther);
 #endif  // defined(OS_WIN)
 
   static const char* const kSwitchesToCopy[] = {
     switches::kCloudPrintSetupProxy,
@@ skipping 74 matching lines @@
 }
 
 bool ServiceProcessState::CreateSharedData() {
   if (version_info::GetVersionNumber().length() >= kMaxVersionStringLength) {
     NOTREACHED() << "Version string length is << "
                  << version_info::GetVersionNumber().length()
                  << " which is longer than" << kMaxVersionStringLength;
     return false;
   }
 
-  scoped_ptr<base::SharedMemory> shared_mem_service_data(
+  std::unique_ptr<base::SharedMemory> shared_mem_service_data(
       new base::SharedMemory());
   if (!shared_mem_service_data.get())
     return false;
 
   uint32_t alloc_size = sizeof(ServiceProcessSharedData);
   // TODO(viettrungluu): Named shared memory is deprecated (crbug.com/345734).
   if (!shared_mem_service_data->CreateNamedDeprecated
           (GetServiceProcessSharedMemName(), true, alloc_size))
     return false;
 
@@ skipping 10 matching lines @@
   shared_data->service_process_pid = base::GetCurrentProcId();
   shared_mem_service_data_.reset(shared_mem_service_data.release());
   return true;
 }
 
 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
   return ::GetServiceProcessChannel();
 }
 
 #endif  // !OS_MACOSX