Convert //third_party from scoped_ptr to std::unique_ptr

third_party/crashpad/crashpad/util/mach/task_memory.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 50 matching lines @@
   DCHECK_GE(user_address, vm_address);
   DCHECK_LE(user_address, vm_end);
   DCHECK_GE(user_end, vm_address);
   DCHECK_LE(user_end, vm_end);
 }
 
 TaskMemory::TaskMemory(task_t task) : task_(task) {
 }
 
 bool TaskMemory::Read(mach_vm_address_t address, size_t size, void* buffer) {
-  scoped_ptr<MappedMemory> memory = ReadMapped(address, size);
+  std::unique_ptr<MappedMemory> memory = ReadMapped(address, size);
   if (!memory) {
     return false;
   }
 
   memcpy(buffer, memory->data(), size);
   return true;
 }
 
-scoped_ptr<TaskMemory::MappedMemory> TaskMemory::ReadMapped(
-    mach_vm_address_t address, size_t size) {
+std::unique_ptr<TaskMemory::MappedMemory> TaskMemory::ReadMapped(
+    mach_vm_address_t address,
+    size_t size) {
   if (size == 0) {
-    return scoped_ptr<MappedMemory>(new MappedMemory(0, 0, 0, 0));
+    return std::unique_ptr<MappedMemory>(new MappedMemory(0, 0, 0, 0));
   }
 
   mach_vm_address_t region_address = mach_vm_trunc_page(address);
   mach_vm_size_t region_size =
       mach_vm_round_page(address - region_address + size);
 
   vm_offset_t region;
   mach_msg_type_number_t region_count;
   kern_return_t kr =
       mach_vm_read(task_, region_address, region_size, &region, &region_count);
   if (kr != KERN_SUCCESS) {
     MACH_LOG(WARNING, kr) << base::StringPrintf(
         "mach_vm_read(0x%llx, 0x%llx)", region_address, region_size);
-    return scoped_ptr<MappedMemory>();
+    return std::unique_ptr<MappedMemory>();
   }
 
   DCHECK_EQ(region_count, region_size);
-  return scoped_ptr<MappedMemory>(
+  return std::unique_ptr<MappedMemory>(
       new MappedMemory(region, region_size, address - region_address, size));
 }
 
 bool TaskMemory::ReadCString(mach_vm_address_t address, std::string* string) {
   return ReadCStringInternal(address, false, 0, string);
 }
 
 bool TaskMemory::ReadCStringSizeLimited(mach_vm_address_t address,
                                         mach_vm_size_t size,
                                         std::string* string) {
@@ skipping 11 matching lines @@
     }
   } else {
     size = PAGE_SIZE;
   }
 
   std::string local_string;
   mach_vm_address_t read_address = address;
   do {
     mach_vm_size_t read_length =
         std::min(size, PAGE_SIZE - (read_address % PAGE_SIZE));
-    scoped_ptr<MappedMemory> read_region =
+    std::unique_ptr<MappedMemory> read_region =
         ReadMapped(read_address, read_length);
     if (!read_region) {
       return false;
     }
 
     const char* read_region_data =
         reinterpret_cast<const char*>(read_region->data());
     size_t read_region_data_length = strnlen(read_region_data, read_length);
     local_string.append(read_region_data, read_region_data_length);
     if (read_region_data_length < read_length) {
       string->swap(local_string);
       return true;
     }
 
     if (has_size) {
       size -= read_length;
     }
     read_address = mach_vm_trunc_page(read_address + read_length);
   } while ((!has_size || size > 0) && read_address > address);
 
   LOG(WARNING) << base::StringPrintf("unterminated string at 0x%llx", address);
   return false;
 }
 
 }  // namespace crashpad