Add BytesRead metric to CPM

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>
 
@@ skipping 10 matching lines @@
 #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"
 #include "content/public/browser/render_process_host.h"
 
 namespace extensions {
 class Extension;
 }
 
+namespace net {
+class URLRequest;
+}
+
 namespace performance_monitor {
 class Database;
 
+// PerformanceMonitor is a tool which will allow the user to view information
+// about Chrome's performance over a period of time. It will gather statistics
+// pertaining to performance-oriented areas (e.g. CPU usage, memory usage, and
+// network usage) and will also store information about significant events which
+// are related to performance, either being indicative (e.g. crashes) or
+// potentially causal (e.g. extension installation/uninstallation).
+//
+// Thread Safety: PerformanceMonitor lives on multiple threads. When interacting
+// with the Database, PerformanceMonitor acts on a background thread (which has
+// the sequence guaranteed by a token, Database::kDatabaseSequenceToken). At
+// other times, the PerformanceMonitor will act on the appropriate thread for
+// the task (for instance, gathering statistics about CPU and memory usage
+// is done on the background thread, but most notifications occur on the UI
+// thread).
 class PerformanceMonitor : public content::NotificationObserver {
  public:
+  struct PerformanceDataForIOThread {
+    PerformanceDataForIOThread();
+
+    uint64 network_bytes_read;
+  };
+
   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();
 
+  // Inform PerformanceMonitor that bytes have been read; if these came across
+  // the network, then increment the count accordingly.
+  void BytesReadOnIOThread(const net::URLRequest& request, const int bytes);
+
   // 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_; }
+  static bool initialized() { return initialized_; }
 
  private:
   friend struct DefaultSingletonTraits<PerformanceMonitor>;
   friend class PerformanceMonitorBrowserTest;
   FRIEND_TEST_ALL_PREFIXES(PerformanceMonitorUncleanExitBrowserTest,
                            OneProfileUncleanExit);
   FRIEND_TEST_ALL_PREFIXES(PerformanceMonitorUncleanExitBrowserTest,
                            TwoProfileUncleanExit);
+  FRIEND_TEST_ALL_PREFIXES(PerformanceMonitorBrowserTest, NetworkBytesRead);
 
   PerformanceMonitor();
   virtual ~PerformanceMonitor();
 
   // Perform any additional initialization which must be performed on a
   // background thread (e.g. constructing the database).
   void InitOnBackgroundThread();
 
   void FinishInit();
 
@@ skipping 50 matching lines @@
   // Generate an appropriate ExtensionEvent for an extension-related occurrance
   // and insert it in the database.
   void AddExtensionEvent(EventType type,
                          const extensions::Extension* extension);
 
   // Generate an appropriate CrashEvent for a renderer crash and insert it in
   // the database.
   void AddCrashEvent(
       const content::RenderProcessHost::RendererClosedDetails& details);
 
+  // Called on the IO thread, this will call InsertIOData on the background
+  // thread with a copy of the PerformanceDataForIOThread object to prevent
+  // any possible race conditions.
+  void CallInsertIOData();
+
+  // Insert the collected IO data into the database (deliberately not const & so
+  // we create a copy and it becomes thread-safe).
+  void InsertIOData(PerformanceDataForIOThread performance_data_for_io_thread);
+
+  // The store for all performance data that must be gathered from the IO
+  // thread.
+  PerformanceDataForIOThread performance_data_for_io_thread_;
+
   // 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_;
 
   // The timer to signal PerformanceMonitor to perform its timed collections.
   base::RepeatingTimer<PerformanceMonitor> timer_;
 
   content::NotificationRegistrar registrar_;
 
+  // A flag indicating whether or not PerformanceMonitor is initialized. Any
+  // external sources accessing PerformanceMonitor should either wait for
+  // the PERFORMANCE_MONITOR_INITIALIZED notification or should check this
+  // flag.
+  static bool initialized_;
+
   DISALLOW_COPY_AND_ASSIGN(PerformanceMonitor);
 };
 
 }  // namespace performance_monitor
 
 #endif  // CHROME_BROWSER_PERFORMANCE_MONITOR_PERFORMANCE_MONITOR_H_