Return unique_ptrs from base::ProcessMetrics.

base/process/process_metrics_mac.cc

 // Copyright (c) 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 "base/process/process_metrics.h"
 
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/sysctl.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
+#include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 
 #if !defined(TASK_POWER_INFO)
 // Doesn't exist in the 10.6 or 10.7 SDKs.
 #define TASK_POWER_INFO        21
 struct task_power_info {
         uint64_t                total_user;
         uint64_t                total_system;
         uint64_t                task_interrupt_wakeups;
         uint64_t                task_platform_idle_wakeups;
@@ skipping 44 matching lines @@
   } else if (type == CPU_TYPE_X86_64) {
     return addr >= SHARED_REGION_BASE_X86_64 &&
            addr < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64);
   } else {
     return false;
   }
 }
 
 }  // namespace
 
-SystemMemoryInfoKB::SystemMemoryInfoKB() {
-  total = 0;
-  free = 0;
-}
+SystemMemoryInfoKB::SystemMemoryInfoKB() : total(0), free(0) {}
 
 SystemMemoryInfoKB::SystemMemoryInfoKB(const SystemMemoryInfoKB& other) =
     default;
 
 // Getting a mach task from a pid for another process requires permissions in
 // general, so there doesn't really seem to be a way to do these (and spinning
 // up ps to fetch each stats seems dangerous to put in a base api for anyone to
 // call). Child processes ipc their port, so return something if available,
 // otherwise return 0.
 
 // static
-ProcessMetrics* ProcessMetrics::CreateProcessMetrics(
+std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
     ProcessHandle process,
     PortProvider* port_provider) {
-  return new ProcessMetrics(process, port_provider);
+  return WrapUnique(new ProcessMetrics(process, port_provider));
 }
 
 size_t ProcessMetrics::GetPagefileUsage() const {
   task_basic_info_64 task_info_data;
   if (!GetTaskInfo(TaskForPid(process_), &task_info_data))
     return 0;
   return task_info_data.virtual_size;
 }
 
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
@@ skipping 27 matching lines @@
     DLOG(ERROR) << "Invalid process";
     return false;
   }
 
   cpu_type_t cpu_type;
   if (!GetCPUTypeForProcess(process_, &cpu_type))
     return false;
 
   // The same region can be referenced multiple times. To avoid double counting
   // we need to keep track of which regions we've already counted.
-  base::hash_set<int> seen_objects;
+  hash_set<int> seen_objects;
 
   // We iterate through each VM region in the task's address map. For shared
   // memory we add up all the pages that are marked as shared. Like libtop we
   // try to avoid counting pages that are also referenced by other tasks. Since
   // we don't have access to the VM regions of other tasks the only hint we have
   // is if the address is in the shared region area.
   //
   // Private memory is much simpler. We simply count the pages that are marked
   // as private or copy on write (COW).
   //
@@ skipping 231 matching lines @@
     return false;
   }
 
   meminfo->free = static_cast<int>(
       (vm_info.free_count - vm_info.speculative_count) * PAGE_SIZE / 1024);
 
   return true;
 }
 
 }  // namespace base