Revert 34994, maybe it regressed startup perf - Fix cpu/memory measurements o...

base/process_util_posix.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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 342 matching lines @@
   return LaunchApp(argv, no_env, fds_to_remap, wait, process_handle);
 }
 
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden,
                ProcessHandle* process_handle) {
   file_handle_mapping_vector no_files;
   return LaunchApp(cl.argv(), no_files, wait, process_handle);
 }
 
-#if !defined(OS_MACOSX)
-ProcessMetrics::ProcessMetrics(ProcessHandle process)
-#else
-ProcessMetrics::ProcessMetrics(ProcessHandle process,
-                               ProcessMetrics::PortProvider* port_provider)
-#endif
-    : process_(process),
-      last_time_(0),
-      last_system_time_(0)
+ProcessMetrics::ProcessMetrics(ProcessHandle process) : process_(process),
+                                                        last_time_(0),
+                                                        last_system_time_(0)
 #if defined(OS_LINUX)
-      , last_cpu_(0)
-#elif defined (OS_MACOSX)
-      , port_provider_(port_provider)
+                                                      , last_cpu_(0)
 #endif
 {
   processor_count_ = base::SysInfo::NumberOfProcessors();
 }
 
 // static
-#if !defined(OS_MACOSX)
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
   return new ProcessMetrics(process);
 }
-#else
-ProcessMetrics* ProcessMetrics::CreateProcessMetrics(
-    ProcessHandle process,
-    ProcessMetrics::PortProvider* port_provider) {
-  return new ProcessMetrics(process, port_provider);
-}
-#endif
 
 ProcessMetrics::~ProcessMetrics() { }
 
 void EnableTerminationOnHeapCorruption() {
   // On POSIX, there nothing to do AFAIK.
 }
 
 bool EnableInProcessStackDumping() {
   // When running in an application, our code typically expects SIGPIPE
   // to be ignored.  Therefore, when testing that same code, it should run
@@ skipping 100 matching lines @@
     // If waitpid returned with an error, then the process doesn't exist
     // (which most probably means it didn't exist before our call).
     return waitpid_success;
   }
 }
 
 int64 TimeValToMicroseconds(const struct timeval& tv) {
   return tv.tv_sec * kMicrosecondsPerSecond + tv.tv_usec;
 }
 
+#if defined(OS_MACOSX)
+// TODO(port): this function only returns the *current* CPU's usage;
+// we want to return this->process_'s CPU usage.
+int ProcessMetrics::GetCPUUsage() {
+  struct timeval now;
+  struct rusage usage;
+
+  int retval = gettimeofday(&now, NULL);
+  if (retval)
+    return 0;
+  retval = getrusage(RUSAGE_SELF, &usage);
+  if (retval)
+    return 0;
+
+  int64 system_time = (TimeValToMicroseconds(usage.ru_stime) +
+                       TimeValToMicroseconds(usage.ru_utime)) /
+                        processor_count_;
+  int64 time = TimeValToMicroseconds(now);
+
+  if ((last_system_time_ == 0) || (last_time_ == 0)) {
+    // First call, just set the last values.
+    last_system_time_ = system_time;
+    last_time_ = time;
+    return 0;
+  }
+
+  int64 system_time_delta = system_time - last_system_time_;
+  int64 time_delta = time - last_time_;
+  DCHECK(time_delta != 0);
+  if (time_delta == 0)
+    return 0;
+
+  // We add time_delta / 2 so the result is rounded.
+  int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
+                             time_delta);
+
+  last_system_time_ = system_time;
+  last_time_ = time;
+
+  return cpu;
+}
+#endif
+
 // Executes the application specified by |cl| and wait for it to exit. Stores
 // the output (stdout) in |output|. If |do_search_path| is set, it searches the
 // path for the application; in that case, |envp| must be null, and it will use
 // the current environment. If |do_search_path| is false, |cl| should fully
 // specify the path of the application, and |envp| will be used as the
 // environment. Redirects stderr to /dev/null. Returns true on success
 // (application launched and exited cleanly, with exit code indicating success).
 // |output| is modified only when the function finished successfully.
 static bool GetAppOutputInternal(const CommandLine& cl, char* const envp[],
                                  std::string* output, size_t max_output,
@@ skipping 152 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                              filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base