Replace chrome_process_filter with chrome_process_util.

chrome/test/memory_test/memory_test.cc

 // Copyright (c) 2006-2008 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/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_process_filter.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
+#include "chrome/test/chrome_process_util.h"
 #include "chrome/test/ui/ui_test.h"
 #include "chrome/test/perf/mem_usage.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 namespace {
 
 static const wchar_t kTempDirName[] = L"memory_test_profile";
 
 class MemoryTest : public UITest {
@@ skipping 233 matching lines @@
     PrintMemoryUsageInfo(test_name);
     std::string trace_name(test_name);
     trace_name.append("_cc");
 
     PrintResult("commit_charge", "", trace_name,
                 commit_size / 1024, "kb", true /* important */);
   }
 
   void PrintIOPerfInfo(const char* test_name) {
     printf("\n");
-    BrowserProcessFilter chrome_filter(user_data_dir_);
-    base::NamedProcessIterator
-        chrome_process_itr(chrome::kBrowserProcessExecutableName,
-                           &chrome_filter);
 
-    const PROCESSENTRY32* chrome_entry;
-    while (chrome_entry = chrome_process_itr.NextProcessEntry()) {
-      uint32 pid = chrome_entry->th32ProcessID;
-      HANDLE process_handle = OpenProcess(PROCESS_QUERY_INFORMATION,
-                                          false,
-                                          pid);
-      if (process_handle == NULL) {
-        wprintf(L"Error opening process %d: %d\n", pid, GetLastError());
-        continue;
-      }
+    FilePath data_dir(FilePath::FromWStringHack(user_data_dir()));
+    int browser_process_pid = ChromeBrowserProcessId(data_dir);
+    ChromeProcessList chrome_processes(GetRunningChromeProcesses(data_dir));
 
+    ChromeProcessList::const_iterator it;
+    for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
       scoped_ptr<base::ProcessMetrics> process_metrics;
       IO_COUNTERS io_counters;
+      base::ProcessHandle process_handle;
+      if (!base::OpenProcessHandle(*it, &process_handle)) {
+        NOTREACHED();
+      }
       process_metrics.reset(
           base::ProcessMetrics::CreateProcessMetrics(process_handle));
       ZeroMemory(&io_counters, sizeof(io_counters));
 
       if (process_metrics.get()->GetIOCounters(&io_counters)) {
-        std::string chrome_name =
-            (pid == chrome_filter.browser_process_id()) ? "_b" : "_r";
+        std::string chrome_name = (*it == browser_process_pid) ? "_b" : "_r";
 
         // Print out IO performance.  We assume that the values can be
         // converted to size_t (they're reported as ULONGLONG, 64-bit numbers).
         PrintResult("read_op", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.ReadOperationCount), "",
                     false /* not important */);
         PrintResult("write_op", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.WriteOperationCount), "",
                     false /* not important */);
         PrintResult("other_op", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.OtherOperationCount), "",
                     false /* not important */);
         PrintResult("read_byte", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.ReadTransferCount / 1024),
                     "kb", false /* not important */);
         PrintResult("write_byte", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.WriteTransferCount / 1024),
                     "kb", false /* not important */);
         PrintResult("other_byte", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.OtherTransferCount / 1024),
                     "kb", false /* not important */);
       }
+
+      base::CloseProcessHandle(process_handle);
     }
   }
 
   void PrintMemoryUsageInfo(const char* test_name) {
     printf("\n");
-    BrowserProcessFilter chrome_filter(user_data_dir_);
-    base::NamedProcessIterator
-        chrome_process_itr(chrome::kBrowserProcessExecutableName,
-                           &chrome_filter);
+
+    FilePath data_dir(FilePath::FromWStringHack(user_data_dir()));
+    int browser_process_pid = ChromeBrowserProcessId(data_dir);
+    ChromeProcessList chrome_processes(GetRunningChromeProcesses(data_dir));
 
     size_t browser_virtual_size = 0;
     size_t browser_working_set_size = 0;
     size_t virtual_size = 0;
     size_t working_set_size = 0;
     size_t num_chrome_processes = 0;
-    const PROCESSENTRY32* chrome_entry;
-    while (chrome_entry = chrome_process_itr.NextProcessEntry()) {
-      uint32 pid = chrome_entry->th32ProcessID;
+    ChromeProcessList::const_iterator it;
+    for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
       size_t peak_virtual_size;
       size_t current_virtual_size;
       size_t peak_working_set_size;
       size_t current_working_set_size;
-      if (GetMemoryInfo(pid, &peak_virtual_size, &current_virtual_size,
+      if (GetMemoryInfo(*it, &peak_virtual_size, &current_virtual_size,
                         &peak_working_set_size, &current_working_set_size)) {
-        if (pid == chrome_filter.browser_process_id()) {
+        if (*it == browser_process_pid) {
           browser_virtual_size = current_virtual_size;
           browser_working_set_size = current_working_set_size;
         }
         virtual_size += current_virtual_size;
         working_set_size += current_working_set_size;
         num_chrome_processes++;
       }
     }
 
     std::string trace_name(test_name);
@@ skipping 75 matching lines @@
   RunTest("1t", 1);
 }
 
 TEST_F(MemoryTest, FiveTabTest) {
   RunTest("5t", 5);
 }
 
 TEST_F(MemoryTest, TwelveTabTest) {
   RunTest("12t", 12);
 }