Add guards to metric values; erase bad events/metrics from db

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 260 matching lines @@
       FROM_HERE,
       base::Bind(&PerformanceMonitor::AddEventOnBackgroundThread,
                  base::Unretained(this),
                  base::Passed(event.Pass())));
 }
 
 void PerformanceMonitor::AddEventOnBackgroundThread(scoped_ptr<Event> event) {
   database_->AddEvent(*event.get());
 }
 
-void PerformanceMonitor::AddMetricOnBackgroundThread(MetricType type,
-                                                     const std::string& value) {
+void PerformanceMonitor::AddMetricOnBackgroundThread(Metric metric) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
-  database_->AddMetric(type, value);
+  database_->AddMetric(metric);
 }
 
 void PerformanceMonitor::NotifyInitialized() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
       content::Source<PerformanceMonitor>(this),
       content::NotificationService::NoDetails());
 
   initialized_ = true;
 }
@@ skipping 10 matching lines @@
 }
 
 void PerformanceMonitor::GatherCPUUsageOnBackgroundThread() {
   if (metrics_map_->size()) {
     double cpu_usage = 0;
     for (MetricsMap::const_iterator iter = metrics_map_->begin();
          iter != metrics_map_->end(); ++iter) {
       cpu_usage += iter->second->GetCPUUsage();
     }
 
-    database_->AddMetric(METRIC_CPU_USAGE, base::DoubleToString(cpu_usage));
+    database_->AddMetric(Metric(METRIC_CPU_USAGE,
+                                base::Time::Now(),
+                                cpu_usage));
   }
 }
 
 void PerformanceMonitor::GatherMemoryUsageOnBackgroundThread() {
   size_t private_memory_sum = 0;
   size_t shared_memory_sum = 0;
   for (MetricsMap::const_iterator iter = metrics_map_->begin();
        iter != metrics_map_->end(); ++iter) {
     size_t private_memory = 0;
     size_t shared_memory = 0;
     if (iter->second->GetMemoryBytes(&private_memory, &shared_memory)) {
       private_memory_sum += private_memory;
       shared_memory_sum += shared_memory;
     } else {
       LOG(WARNING) << "GetMemoryBytes returned NULL (platform-specific error)";
     }
   }
 
-  database_->AddMetric(METRIC_PRIVATE_MEMORY_USAGE,
-                       base::Uint64ToString(private_memory_sum));
-  database_->AddMetric(METRIC_SHARED_MEMORY_USAGE,
-                       base::Uint64ToString(shared_memory_sum));
+  database_->AddMetric(Metric(METRIC_PRIVATE_MEMORY_USAGE,
+                              base::Time::Now(),
+                              static_cast<double>(private_memory_sum)));
+  database_->AddMetric(Metric(METRIC_SHARED_MEMORY_USAGE,
+                              base::Time::Now(),
+                              static_cast<double>(shared_memory_sum)));
 }
 
 void PerformanceMonitor::UpdateMetricsMapOnBackgroundThread() {
   MetricsMap* new_map = new MetricsMap;
 
   base::ProcessId browser_pid = base::GetCurrentProcId();
   ChromeProcessList chrome_processes(GetRunningChromeProcesses(browser_pid));
   for (ChromeProcessList::const_iterator pid_iter = chrome_processes.begin();
        pid_iter != chrome_processes.end(); ++pid_iter) {
     base::ProcessHandle handle;
@@ skipping 77 matching lines @@
       FROM_HERE,
       base::Bind(&PerformanceMonitor::InsertIOData,
                  base::Unretained(this),
                  performance_data_for_io_thread_));
 }
 
 void PerformanceMonitor::InsertIOData(
     PerformanceDataForIOThread performance_data_for_io_thread) {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   database_->AddMetric(
-      METRIC_NETWORK_BYTES_READ,
-      base::Uint64ToString(performance_data_for_io_thread.network_bytes_read));
+      Metric(METRIC_NETWORK_BYTES_READ,
+             base::Time::Now(),
+             static_cast<double>(
+                 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 (initialized_ && !request.url().SchemeIsFile())
     performance_data_for_io_thread_.network_bytes_read += bytes_read;
 }
 
@@ skipping 67 matching lines @@
       const content::LoadNotificationDetails* load_details =
           content::Details<content::LoadNotificationDetails>(details).ptr();
       if (!load_details)
         break;
       BrowserThread::PostBlockingPoolSequencedTask(
           Database::kDatabaseSequenceToken,
           FROM_HERE,
           base::Bind(
               &PerformanceMonitor::AddMetricOnBackgroundThread,
               base::Unretained(this),
-              METRIC_PAGE_LOAD_TIME,
-              base::Int64ToString(load_details->load_time.ToInternalValue())));
+              Metric(METRIC_PAGE_LOAD_TIME,
+                     base::Time::Now(),
+                     static_cast<double>(
+                         load_details->load_time.ToInternalValue()))));
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void PerformanceMonitor::AddExtensionEvent(EventType type,
@@ skipping 22 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