Duplicate process handle in process_metrics_win.cc

base/process/process_metrics_win.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 <windows.h>
 #include <psapi.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 23 matching lines @@
 ProcessMetrics::~ProcessMetrics() { }
 
 // static
 std::unique_ptr<ProcessMetrics> ProcessMetrics::CreateProcessMetrics(
     ProcessHandle process) {
   return WrapUnique(new ProcessMetrics(process));
 }
 
 size_t ProcessMetrics::GetPagefileUsage() const {
   PROCESS_MEMORY_COUNTERS pmc;
-  if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) {
+  if (GetProcessMemoryInfo(process_.Get(), &pmc, sizeof(pmc))) {
     return pmc.PagefileUsage;
   }
   return 0;
 }
 
 // Returns the peak space allocated for the pagefile, in bytes.
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
   PROCESS_MEMORY_COUNTERS pmc;
-  if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) {
+  if (GetProcessMemoryInfo(process_.Get(), &pmc, sizeof(pmc))) {
     return pmc.PeakPagefileUsage;
   }
   return 0;
 }
 
 // Returns the current working set size, in bytes.
 size_t ProcessMetrics::GetWorkingSetSize() const {
   PROCESS_MEMORY_COUNTERS pmc;
-  if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) {
+  if (GetProcessMemoryInfo(process_.Get(), &pmc, sizeof(pmc))) {
     return pmc.WorkingSetSize;
   }
   return 0;
 }
 
 // Returns the peak working set size, in bytes.
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
   PROCESS_MEMORY_COUNTERS pmc;
-  if (GetProcessMemoryInfo(process_, &pmc, sizeof(pmc))) {
+  if (GetProcessMemoryInfo(process_.Get(), &pmc, sizeof(pmc))) {
     return pmc.PeakWorkingSetSize;
   }
   return 0;
 }
 
 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
                                     size_t* shared_bytes) const {
   // PROCESS_MEMORY_COUNTERS_EX is not supported until XP SP2.
   // GetProcessMemoryInfo() will simply fail on prior OS. So the requested
   // information is simply not available. Hence, we will return 0 on unsupported
   // OSes. Unlike most Win32 API, we don't need to initialize the "cb" member.
   PROCESS_MEMORY_COUNTERS_EX pmcx;
   if (private_bytes &&
-      GetProcessMemoryInfo(process_,
+      GetProcessMemoryInfo(process_.Get(),
                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmcx),
                            sizeof(pmcx))) {
     *private_bytes = pmcx.PrivateUsage;
   }
 
   if (shared_bytes) {
     WorkingSetKBytes ws_usage;
     if (!GetWorkingSetKBytes(&ws_usage))
       return false;
 
     *shared_bytes = ws_usage.shared * 1024;
   }
 
   return true;
 }
 
 void ProcessMetrics::GetCommittedKBytes(CommittedKBytes* usage) const {
   MEMORY_BASIC_INFORMATION mbi = {0};
   size_t committed_private = 0;
   size_t committed_mapped = 0;
   size_t committed_image = 0;
   void* base_address = NULL;
-  while (VirtualQueryEx(process_, base_address, &mbi, sizeof(mbi)) ==
-      sizeof(mbi)) {
+  while (VirtualQueryEx(process_.Get(), base_address, &mbi, sizeof(mbi)) ==
+         sizeof(mbi)) {
     if (mbi.State == MEM_COMMIT) {
       if (mbi.Type == MEM_PRIVATE) {
         committed_private += mbi.RegionSize;
       } else if (mbi.Type == MEM_MAPPED) {
         committed_mapped += mbi.RegionSize;
       } else if (mbi.Type == MEM_IMAGE) {
         committed_image += mbi.RegionSize;
       } else {
         NOTREACHED();
       }
@@ skipping 27 matching lines @@
     // Use UncheckedMalloc here because this can be called from the code
     // that handles low memory condition.
     return UncheckedMalloc(size, reinterpret_cast<void**>(&buffer_));
   }
 
   const PSAPI_WORKING_SET_INFORMATION* operator ->() const { return buffer_; }
 
   size_t GetPageEntryCount() const { return number_of_entries; }
 
   // This function is used to get page entries for a process.
-  bool QueryPageEntries(const ProcessHandle& process_) {
+  bool QueryPageEntries(const ProcessHandle& process) {
     int retries = 5;
     number_of_entries = 4096;  // Just a guess.
 
     for (;;) {
       size_t buffer_size =
           sizeof(PSAPI_WORKING_SET_INFORMATION) +
           (number_of_entries * sizeof(PSAPI_WORKING_SET_BLOCK));
 
       if (!Reserve(buffer_size))
         return false;
 
       // On success, |buffer_| is populated with info about the working set of
-      // |process_|. On ERROR_BAD_LENGTH failure, increase the size of the
+      // |process|. On ERROR_BAD_LENGTH failure, increase the size of the
       // buffer and try again.
-      if (QueryWorkingSet(process_, buffer_, buffer_size))
+      if (QueryWorkingSet(process, buffer_, buffer_size))
         break;  // Success
 
       if (GetLastError() != ERROR_BAD_LENGTH)
         return false;
 
       number_of_entries = buffer_->NumberOfEntries;
 
       // Maybe some entries are being added right now. Increase the buffer to
       // take that into account. Increasing by 10% should generally be enough,
       // especially considering the potentially low memory condition during the
@@ skipping 36 matching lines @@
 
 bool ProcessMetrics::GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const {
   size_t ws_private = 0;
   size_t ws_shareable = 0;
   size_t ws_shared = 0;
 
   DCHECK(ws_usage);
   memset(ws_usage, 0, sizeof(*ws_usage));
 
   WorkingSetInformationBuffer buffer;
-  if (!buffer.QueryPageEntries(process_))
+  if (!buffer.QueryPageEntries(process_.Get()))
     return false;
 
   size_t num_page_entries = buffer.GetPageEntryCount();
   for (size_t i = 0; i < num_page_entries; i++) {
     if (buffer->WorkingSetInfo[i].Shared) {
       ws_shareable++;
       if (buffer->WorkingSetInfo[i].ShareCount > 1)
         ws_shared++;
     } else {
       ws_private++;
     }
   }
 
   ws_usage->priv = ws_private * PAGESIZE_KB;
   ws_usage->shareable = ws_shareable * PAGESIZE_KB;
   ws_usage->shared = ws_shared * PAGESIZE_KB;
 
   return true;
 }
 
 // This function calculates the proportional set size for a process.
 bool ProcessMetrics::GetProportionalSetSizeBytes(uint64_t* pss_bytes) const {
   double ws_pss = 0.0;
 
   WorkingSetInformationBuffer buffer;
-  if (!buffer.QueryPageEntries(process_))
+  if (!buffer.QueryPageEntries(process_.Get()))
     return false;
 
   size_t num_page_entries = buffer.GetPageEntryCount();
   for (size_t i = 0; i < num_page_entries; i++) {
     if (buffer->WorkingSetInfo[i].Shared &&
         buffer->WorkingSetInfo[i].ShareCount > 0)
       ws_pss += 1.0 / buffer->WorkingSetInfo[i].ShareCount;
     else
       ws_pss += 1.0;
   }
 
   *pss_bytes = static_cast<uint64_t>(ws_pss * GetPageSize());
   return true;
 }
 
 static uint64_t FileTimeToUTC(const FILETIME& ftime) {
   LARGE_INTEGER li;
   li.LowPart = ftime.dwLowDateTime;
   li.HighPart = ftime.dwHighDateTime;
   return li.QuadPart;
 }
 
 double ProcessMetrics::GetCPUUsage() {
   FILETIME creation_time;
   FILETIME exit_time;
   FILETIME kernel_time;
   FILETIME user_time;
 
-  if (!GetProcessTimes(process_, &creation_time, &exit_time,
-                       &kernel_time, &user_time)) {
+  if (!GetProcessTimes(process_.Get(), &creation_time, &exit_time, &kernel_time,
+                       &user_time)) {
     // We don't assert here because in some cases (such as in the Task Manager)
     // we may call this function on a process that has just exited but we have
     // not yet received the notification.
     return 0;
   }
   int64_t system_time =
       (FileTimeToUTC(kernel_time) + FileTimeToUTC(user_time)) /
       processor_count_;
   TimeTicks time = TimeTicks::Now();
 
@@ skipping 12 matching lines @@
     return 0;
 
 
   last_system_time_ = system_time;
   last_cpu_time_ = time;
 
   return static_cast<double>(system_time_delta * 100.0) / time_delta;
 }
 
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
-  return GetProcessIoCounters(process_, io_counters) != FALSE;
+  return GetProcessIoCounters(process_.Get(), io_counters) != FALSE;
 }
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process)
-    : process_(process),
-      processor_count_(SysInfo::NumberOfProcessors()),
-      last_system_time_(0) {}
+    : processor_count_(SysInfo::NumberOfProcessors()), last_system_time_(0) {
+  if (process) {
+    HANDLE duplicate_handle;
+    BOOL result = ::DuplicateHandle(::GetCurrentProcess(), process,
+                                    ::GetCurrentProcess(), &duplicate_handle,
+                                    PROCESS_QUERY_INFORMATION, FALSE, 0);
+    DCHECK(result);
+    process_.Set(duplicate_handle);
+  }
+}
 
 size_t GetSystemCommitCharge() {
   // Get the System Page Size.
   SYSTEM_INFO system_info;
   GetSystemInfo(&system_info);
 
   PERFORMANCE_INFORMATION info;
   if (!GetPerformanceInfo(&info, sizeof(info))) {
     DLOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
@@ skipping 19 matching lines @@
 
   meminfo->total = mem_status.ullTotalPhys / 1024;
   meminfo->avail_phys = mem_status.ullAvailPhys / 1024;
   meminfo->swap_total = mem_status.ullTotalPageFile / 1024;
   meminfo->swap_free = mem_status.ullAvailPageFile / 1024;
 
   return true;
 }
 
 }  // namespace base