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 16 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
+#include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 const uint32 kAccessFlags = base::kProcessAccessDuplicateHandle |
                             base::kProcessAccessQueryInformation |
                             base::kProcessAccessTerminate |
                             base::kProcessAccessWaitForTermination;
 
 std::string TimeToString(base::Time time) {
   int64 time_int64 = time.ToInternalValue();
   return base::Int64ToString(time_int64);
 }
 
 bool StringToTime(std::string time, base::Time* output) {
   int64 time_int64 = 0;
   if (!base::StringToInt64(time, &time_int64))
     return false;
   *output = base::Time::FromInternalValue(time_int64);
   return true;
 }
 
 }  // namespace
 
 namespace performance_monitor {
 
+bool PerformanceMonitor::initialized_ = false;
+
+PerformanceMonitor::ByteCount::ByteCount() : disk(0), network(0) { }
+
 PerformanceMonitor::PerformanceMonitor() : database_(NULL) {
 }
 
 PerformanceMonitor::~PerformanceMonitor() {
 }
 
 bool PerformanceMonitor::SetDatabasePath(const FilePath& path) {
   if (!database_.get()) {
     database_path_ = path;
     return true;
@@ skipping 13 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 each member of bytes_read_ to the value in the database; if
+  // there isn't a recording in the database, the value stays at 0.
+  MetricInfo info;
+  if (database_->GetRecentStatsForActivityAndMetric(METRIC_DISK_BYTES_READ,
+                                                    &info)) {
+    bytes_read_.disk = info.value;
+  }
+  if (database_->GetRecentStatsForActivityAndMetric(METRIC_NETWORK_BYTES_READ,
+                                                    &info)) {
+    bytes_read_.network = 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());
+
+  initialized_ = true;
 }
 
 void PerformanceMonitor::GatherStatisticsOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  database_->AddMetric(METRIC_DISK_BYTES_READ,
+                       base::Int64ToString(bytes_read_.disk));

[battre, 2012/08/21 20:37:33]

If you access bytes_read_ here, you must be on the IO thread.

[Devlin, 2012/08/21 22:51:52]

Done.

+  database_->AddMetric(METRIC_NETWORK_BYTES_READ,
+                       base::Int64ToString(bytes_read_.network));
+
   // 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(const net::URLRequest& request,
+                                   const int bytes_read) {
+  // Strictly speaking, we don't care that this is done on the I/O thread - we
+  // only care that it is always done on the *same* thread. This should be the
+  // only place which modifies the value of bytes_read_; thus we avoid race
+  // conditions (inserting into the database is not a race condition, because if
+  // it is not inserted in one iteration, it will be in the next, and it was
+  // close enough to justify being in either one).
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (request.url().SchemeIsFile())
+    bytes_read_.disk += bytes_read;
+  else
+    bytes_read_.network += 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