Add BytesRead metric to CPM

chrome/browser/performance_monitor/performance_monitor.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/browser/performance_monitor/performance_monitor.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
   if (!base::StringToInt64(time, &time_int64))
     return false;
   *output = base::Time::FromInternalValue(time_int64);
   return true;
 }
 
 }  // namespace
 
 namespace performance_monitor {
 
-PerformanceMonitor::PerformanceMonitor() : database_(NULL) {
+bool PerformanceMonitor::enabled_ = false;
+
+PerformanceMonitor::PerformanceMonitor() : bytes_read_(0),
+                                           database_(NULL) {
 }
 
 PerformanceMonitor::~PerformanceMonitor() {
 }
 
 bool PerformanceMonitor::SetDatabasePath(const FilePath& path) {
   if (!database_.get()) {
     database_path_ = path;
     return true;
   }
@@ skipping 12 matching lines @@
       FROM_HERE,
       base::Bind(&PerformanceMonitor::InitOnBackgroundThread,
                  base::Unretained(this)),
       base::Bind(&PerformanceMonitor::FinishInit,
                  base::Unretained(this)));
 }
 
 void PerformanceMonitor::InitOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   database_ = Database::Create(database_path_);
+
+  // Initialize bytes_read_ to the value in the database; if there isn't a
+  // recording in the database, bytes_read_ stays at 0.
+  MetricInfo info;
+  if (database_->GetRecentStatsForActivityAndMetric(METRIC_BYTES_READ, &info))
+    bytes_read_ = info.value;
 }
 
 void PerformanceMonitor::FinishInit() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RegisterForNotifications();
   CheckForUncleanExits();
   BrowserThread::PostBlockingPoolSequencedTask(
       Database::kDatabaseSequenceToken,
       FROM_HERE,
       base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
@@ skipping 130 matching lines @@
                                                      const std::string& value) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   database_->AddMetric(type, value);
 }
 
 void PerformanceMonitor::NotifyInitialized() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
       content::Source<PerformanceMonitor>(this),
       content::NotificationService::NoDetails());
+
+  enabled_ = true;

[Yoyo Zhou, 2012/08/18 01:48:56]

It might be a little misleading to have this be set late in the startup, and yet
be called 'enabled', which seems like a property set at browser startup.

[Devlin, 2012/08/21 19:46:46]

Done.

 }
 
 void PerformanceMonitor::GatherStatisticsOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  database_->AddMetric(METRIC_BYTES_READ, base::Int64ToString(bytes_read_));
+
   // Because the CPU usage is gathered as an average since the last time the
   // function was called, while the memory usage is gathered as an instantaneous
   // usage, the CPU usage is gathered before the metrics map is wiped.
   GatherCPUUsageOnBackgroundThread();
   UpdateMetricsMapOnBackgroundThread();
   GatherMemoryUsageOnBackgroundThread();
 }
 
 void PerformanceMonitor::GatherCPUUsageOnBackgroundThread() {
   if (metrics_map_.size()) {
@@ skipping 93 matching lines @@
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (std::set<std::string>::const_iterator iter = active_profiles->begin();
        iter != active_profiles->end(); ++iter) {
     database_->AddStateValue(kStateProfilePrefix + *iter, time);
   }
 }
 
 void PerformanceMonitor::DoTimedCollections() {
   UpdateLiveProfiles();
+
+  BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
+                 base::Unretained(this)));
+}
+
+void PerformanceMonitor::BytesRead(int bytes_read) {

[eaugusti, 2012/08/21 17:17:26]

IO thread only?

[Devlin, 2012/08/21 19:46:46]

Done.

+  bytes_read_ += bytes_read;
 }
 
 void PerformanceMonitor::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       AddExtensionEvent(EVENT_EXTENSION_INSTALL,
                         content::Details<Extension>(details).ptr());
       break;
@@ skipping 103 matching lines @@
 
   // Determine the type of crash.
   EventType type =
       details.status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
       EVENT_KILLED_BY_OS_CRASH : EVENT_RENDERER_CRASH;
 
   AddEvent(util::CreateCrashEvent(base::Time::Now(), type));
 }
 
 }  // namespace performance_monitor