Move OpenProcessHandle to Process::Open.

chrome/test/perf/perf_test.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/test/perf/perf_test.h"
 
 #include <stdio.h>
 
 #include "base/logging.h"
+#include "base/process/process.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "testing/perf/perf_test.h"
 
 namespace perf_test {
 
 void PrintIOPerfInfo(const std::string& test_name,
                      const ChromeProcessList& chrome_processes,
                      base::ProcessId browser_pid) {
@@ skipping 25 matching lines @@
   size_t write_byte_b = 0;
   size_t write_byte_r = 0;
   size_t other_byte_b = 0;
   size_t other_byte_r = 0;
   size_t total_byte_b = 0;
   size_t total_byte_r = 0;
 
   std::string output;
   ChromeProcessList::const_iterator it;
   for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
-    base::ProcessHandle process_handle;
-    if (!base::OpenProcessHandle(*it, &process_handle)) {
+    base::Process process = base::Process::Open(*it);
+    if (!process.IsValid()) {
       NOTREACHED();
       return output;
     }
 
     // TODO(sgk):  if/when base::ProcessMetrics returns real stats on mac:
     // scoped_ptr<base::ProcessMetrics> process_metrics(
-    //     base::ProcessMetrics::CreateProcessMetrics(process_handle));
+    //     base::ProcessMetrics::CreateProcessMetrics(process.Handle()));
     scoped_ptr<ChromeTestProcessMetrics> process_metrics(
-        ChromeTestProcessMetrics::CreateProcessMetrics(process_handle));
+        ChromeTestProcessMetrics::CreateProcessMetrics(process.Handle()));
     base::IoCounters io_counters;
     memset(&io_counters, 0, sizeof(io_counters));
 
     if (process_metrics.get()->GetIOCounters(&io_counters)) {
       // Print out IO performance.  We assume that the values can be
       // converted to size_t (they're reported as ULONGLONG, 64-bit numbers).
       std::string chrome_name = (*it == browser_pid) ? "_b" : "_r";
 
       size_t read_op = static_cast<size_t>(io_counters.ReadOperationCount);
       size_t write_op = static_cast<size_t>(io_counters.WriteOperationCount);
@@ skipping 26 matching lines @@
         read_op_r += read_op;
         write_op_r += write_op;
         other_op_r += other_op;
         total_op_r += total_op;
         read_byte_r += read_byte;
         write_byte_r += write_byte;
         other_byte_r += other_byte;
         total_byte_r += total_byte;
       }
     }
-
-    base::CloseProcessHandle(process_handle);
   }
 
   std::string t_name(test_name);
   AppendResult(output,
                "read_op_b",
                std::string(),
                "r_op_b" + t_name,
                read_op_b,
                "ops",
                false);
@@ skipping 137 matching lines @@
   size_t browser_peak_working_set_size = 0;
   size_t renderer_total_peak_virtual_size = 0;
   size_t renderer_total_peak_working_set_size = 0;
   size_t renderer_single_peak_virtual_size = 0;
   size_t renderer_single_peak_working_set_size = 0;
 #endif
 
   std::string output;
   ChromeProcessList::const_iterator it;
   for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
-    base::ProcessHandle process_handle;
-    if (!base::OpenProcessHandle(*it, &process_handle)) {
+    base::Process process = base::Process::Open(*it);
+    if (!process.IsValid()) {
       NOTREACHED();
       return output;
     }
 
     // TODO(sgk):  if/when base::ProcessMetrics returns real stats on mac:
     // scoped_ptr<base::ProcessMetrics> process_metrics(
-    //     base::ProcessMetrics::CreateProcessMetrics(process_handle));
+    //     base::ProcessMetrics::CreateProcessMetrics(process.Handle()));
     scoped_ptr<ChromeTestProcessMetrics> process_metrics(
-        ChromeTestProcessMetrics::CreateProcessMetrics(process_handle));
+        ChromeTestProcessMetrics::CreateProcessMetrics(process.Handle()));
 
     size_t current_virtual_size = process_metrics->GetPagefileUsage();
     size_t current_working_set_size = process_metrics->GetWorkingSetSize();
 
     if (*it == browser_pid) {
       browser_virtual_size = current_virtual_size;
       browser_working_set_size = current_working_set_size;
     } else {
       renderer_virtual_size += current_virtual_size;
       renderer_working_set_size += current_working_set_size;
@@ skipping 11 matching lines @@
       if (peak_virtual_size > renderer_single_peak_virtual_size) {
         renderer_single_peak_virtual_size = peak_virtual_size;
       }
       if (peak_working_set_size > renderer_single_peak_working_set_size) {
         renderer_single_peak_working_set_size = peak_working_set_size;
       }
       renderer_total_peak_virtual_size += peak_virtual_size;
       renderer_total_peak_working_set_size += peak_working_set_size;
     }
 #endif
-
-    base::CloseProcessHandle(process_handle);
   }
 
   std::string trace_name(test_name);
 #if defined(OS_WIN)
   AppendResult(output, "vm_peak_b", "", "vm_pk_b" + trace_name,
                browser_peak_virtual_size, "bytes",
                false /* not important */);
   AppendResult(output, "ws_peak_b", "", "ws_pk_b" + trace_name,
                browser_peak_working_set_size, "bytes",
                false /* not important */);
@@ skipping 78 matching lines @@
                std::string(),
                "proc_" + trace_name,
                chrome_processes.size(),
                "count",
                false /* not important */);
 
   return output;
 }
 
 }  // namespace perf_test