Performance monitor stats gathering.

chrome/browser/performance_monitor/performance_monitor.h

 // 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.
 
 #ifndef CHROME_BROWSER_PERFORMANCE_MONITOR_PERFORMANCE_MONITOR_H_
 #define CHROME_BROWSER_PERFORMANCE_MONITOR_PERFORMANCE_MONITOR_H_
 
+#include <map>
+#include <string>
+
 #include "base/callback.h"
 #include "base/file_path.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
+#include "base/process.h"
+#include "base/process_util.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/event.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 
 namespace performance_monitor {
 class Database;
 
 class PerformanceMonitor : public content::NotificationObserver {
  public:
   typedef base::Callback<void(const std::string&)> StateValueCallback;
 
+  typedef std::map<base::ProcessHandle,
+                   linked_ptr<base::ProcessMetrics> > MetricsMap;
+
   // Set the path which the PerformanceMonitor should use for the database files
   // constructed. This must be done prior to the initialization of the
   // PerformanceMonitor. Returns true on success, false on failure (failure
   // likely indicates that PerformanceMonitor has already been started at the
   // time of the call).
   bool SetDatabasePath(const FilePath& path);
 
   // Returns the current PerformanceMonitor instance if one exists; otherwise
   // constructs a new PerformanceMonitor.
   static PerformanceMonitor* GetInstance();
 
   // Begins the initialization process for the PerformanceMonitor in order to
   // start collecting data.
   void Start();
 
+  // Gathers CPU usage and memory usage of all Chrome processes.
+  void GatherStatisticsOnBackgroundThread();
+
   // content::NotificationObserver
   // Wait for various notifications; insert events into the database upon
   // occurance.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   Database* database() { return database_.get(); }
   FilePath database_path() { return database_path_; }
 
@@ skipping 15 matching lines @@
 
   // Check the previous Chrome version from the Database and determine if
   // it has been updated. If it has, insert an event in the database.
   void CheckForVersionUpdateOnBackgroundThread();
 
   // Wrapper function for inserting events into the database.
   void AddEvent(scoped_ptr<Event> event);
 
   void AddEventOnBackgroundThread(scoped_ptr<Event> event);
 
+  // Gathers the CPU usage of every Chrome process that has been running since
+  // the last call to GatherStatistics().
+  void GatherCPUUsageOnBackgroundThread();
+
+  // Gathers the memory usage of every process in the current list of processes.
+  void GatherMemoryUsageOnBackgroundThread();
+
+  // Updates the ProcessMetrics map with the current list of processes.
+  void UpdateMetricsMapOnBackgroundThread();
+
   // Gets the corresponding value of |key| from the database, and then runs
   // |callback| on the UI thread with that value as a parameter.
   void GetStateValueOnBackgroundThread(
       const std::string& key,
       const StateValueCallback& callback);
 
   // Notify any listeners that PerformanceMonitor has finished the initializing.
   void NotifyInitialized();
 
   // The location at which the database files are stored; if empty, the database
   // will default to '<user_data_dir>/performance_monitor_dbs'.
   FilePath database_path_;
 
   scoped_ptr<Database> database_;
 
+  // A map of currently running ProcessHandles to ProcessMetrics.
+  MetricsMap metrics_map_;
+
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(PerformanceMonitor);
 };
 
 }  // namespace performance_monitor
 
 #endif  // CHROME_BROWSER_PERFORMANCE_MONITOR_PERFORMANCE_MONITOR_H_