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::PerformanceDataForIOThread::PerformanceDataForIOThread()
+    : network_bytes_read(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 the io thread's performance data 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_NETWORK_BYTES_READ,
+                                                    &info)) {
+    performance_data_for_io_thread_.network_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());
+
+  initialized_ = true;
 }
 
 void PerformanceMonitor::GatherStatisticsOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // 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();
@@ skipping 98 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)));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::CallInsertIOData,
+                 base::Unretained(this)));
+}
+
+void PerformanceMonitor::CallInsertIOData() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::InsertIOData,
+                 base::Unretained(this),
+                 performance_data_for_io_thread_));
+}
+
+void PerformanceMonitor::InsertIOData(
+    const PerformanceDataForIOThread& performance_data_for_io_thread) {

[battre, 2012/08/22 08:25:24]

you need to pass a copy instead of a const ref here to be thread safe.

[Devlin, 2012/08/22 16:22:05]

Done.

+  CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+  database_->AddMetric(
+      METRIC_NETWORK_BYTES_READ,
+      base::Uint64ToString(performance_data_for_io_thread.network_bytes_read));
+}
+
+void PerformanceMonitor::BytesReadOnIOThread(const net::URLRequest& request,
+                                             const int bytes_read) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!request.url().SchemeIsFile())
+    performance_data_for_io_thread_.network_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