Refactor Metrics

chrome/browser/performance_monitor/database.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/database.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ skipping 227 matching lines @@
 
   for (it->Seek(start_key);
        it->Valid() && it->key().ToString() < end_key;
        it->Next()) {
     results.push_back(ActiveIntervalToTimeRange(it->key().ToString(),
                                                 it->value().ToString()));
   }
   return results;
 }
 
-Database::EventList Database::GetEvents(EventType type, const base::Time& start,
-                                        const base::Time& end) {
+Database::EventVector Database::GetEvents(EventType type,
+                                          const base::Time& start,
+                                          const base::Time& end) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  EventList events;
+  EventVector events;
   std::string start_key = CreateEventKey(start, EVENT_UNDEFINED);
   std::string end_key = CreateEventKey(end, EVENT_NUMBER_OF_EVENTS);
   scoped_ptr<leveldb::Iterator> it(event_db_->NewIterator(read_options_));
   for (it->Seek(start_key);
        it->Valid() && it->key().ToString() <= end_key;
        it->Next()) {
     if (type != EVENT_UNDEFINED) {
       EventType key_type = EventKeyToEventType(it->key().ToString());
       if (key_type != type)
         continue;
@@ skipping 22 matching lines @@
   scoped_ptr<leveldb::Iterator> it(event_db_->NewIterator(read_options_));
   for (it->Seek(start_key);
        it->Valid() && it->key().ToString() <= end_key;
        it->Next()) {
     EventType key_type = EventKeyToEventType(it->key().ToString());
     results.insert(key_type);
   }
   return results;
 }
 
-bool Database::AddMetric(const std::string& activity, MetricType metric,
+bool Database::AddMetric(const std::string& activity,
+                         MetricType metric,
                          const std::string& value) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   UpdateActiveInterval();
   base::Time timestamp = clock_->GetTime();
   std::string recent_key = CreateRecentKey(timestamp, metric, activity);
   std::string metric_key = CreateMetricKey(timestamp, metric, activity);
   std::string recent_map_key = CreateRecentMapKey(metric, activity);
   // Use recent_map_ to quickly find the key that must be removed.
   RecentMap::iterator old_it = recent_map_.find(recent_map_key);
   if (old_it != recent_map_.end())
     recent_db_->Delete(write_options_, old_it->second);
   recent_map_[recent_map_key] = recent_key;
   leveldb::Status recent_status =
       recent_db_->Put(write_options_, recent_key, value);
   leveldb::Status metric_status =
       metric_db_->Put(write_options_, metric_key, value);
   return recent_status.ok() && metric_status.ok();
 }
 
-std::vector<const MetricDetails*> Database::GetActiveMetrics(
-    const base::Time& start, const base::Time& end) {
+Database::MetricTypeSet Database::GetActiveMetrics(const base::Time& start,
+                                                   const base::Time& end) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  std::vector<const MetricDetails*> results;
   std::string recent_start_key = CreateRecentKey(
       start, static_cast<MetricType>(0), std::string());
   std::string recent_end_key = CreateRecentKey(
       end, METRIC_NUMBER_OF_METRICS, std::string());
   std::string recent_end_of_time_key = CreateRecentKey(
       clock_->GetTime(), METRIC_NUMBER_OF_METRICS, std::string());
 
-  std::set<MetricType> active_metrics;
+  MetricTypeSet active_metrics;
   // Get all the guaranteed metrics.
   scoped_ptr<leveldb::Iterator> recent_it(
       recent_db_->NewIterator(read_options_));
   for (recent_it->Seek(recent_start_key);
        recent_it->Valid() && recent_it->key().ToString() <= recent_end_key;
        recent_it->Next()) {
     RecentKey split_key = SplitRecentKey(recent_it->key().ToString());
     active_metrics.insert(split_key.type);
   }
   // Get all the possible metrics (metrics that may have been updated after
   // |end|).
-  std::set<MetricType> possible_metrics;
+  MetricTypeSet possible_metrics;
   for (recent_it->Seek(recent_end_key);
        recent_it->Valid() &&
        recent_it->key().ToString() <= recent_end_of_time_key;
        recent_it->Next()) {
     RecentKey split_key = SplitRecentKey(recent_it->key().ToString());
     possible_metrics.insert(split_key.type);
   }
-  std::set<MetricType>::iterator possible_it;
+  MetricTypeSet::iterator possible_it;
   scoped_ptr<leveldb::Iterator> metric_it(
       metric_db_->NewIterator(read_options_));
   for (possible_it = possible_metrics.begin();
        possible_it != possible_metrics.end();
        ++possible_it) {
     std::string metric_start_key = CreateMetricKey(start, *possible_it,
                                                    std::string());
     std::string metric_end_key = CreateMetricKey(end, *possible_it,
                                                  std::string());
     metric_it->Seek(metric_start_key);
     // Stats in the timerange from any activity makes the metric active.
     if (metric_it->Valid() && metric_it->key().ToString() <= metric_end_key) {
       active_metrics.insert(*possible_it);
     }
   }
-  std::set<MetricType>::iterator it;
-  for (it = active_metrics.begin(); it != active_metrics.end(); ++it)
-    results.push_back(GetMetricDetails(*it));
 
-  return results;
+  return active_metrics;
 }
 
-std::vector<std::string> Database::GetActiveActivities(
-    MetricType metric_type, const base::Time& start) {
+std::set<std::string> Database::GetActiveActivities(MetricType metric_type,
+                                                    const base::Time& start) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  std::vector<std::string> results;
+  std::set<std::string> results;
   std::string start_key = CreateRecentKey(
       start, static_cast<MetricType>(0), std::string());
   scoped_ptr<leveldb::Iterator> it(recent_db_->NewIterator(read_options_));
   for (it->Seek(start_key); it->Valid(); it->Next()) {
     RecentKey split_key = SplitRecentKey(it->key().ToString());
     if (split_key.type == metric_type)
-      results.push_back(split_key.activity);
+      results.insert(split_key.activity);
   }
   return results;
 }
 
-bool Database::GetRecentStatsForActivityAndMetric(
-    const std::string& activity,
-    MetricType metric,
-    MetricInfo* info) {
+bool Database::GetRecentStatsForActivityAndMetric(const std::string& activity,
+                                                  MetricType metric_type,
+                                                  Metric* metric) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  std::string recent_map_key = CreateRecentMapKey(metric, activity);
+  std::string recent_map_key = CreateRecentMapKey(metric_type, activity);
   if (!ContainsKey(recent_map_, recent_map_key))
     return false;
   std::string recent_key = recent_map_[recent_map_key];
 
   std::string result;
   leveldb::Status status = recent_db_->Get(read_options_, recent_key, &result);
   if (status.ok())
-    *info = MetricInfo(SplitRecentKey(recent_key).time, result);
+    *metric = Metric(SplitRecentKey(recent_key).time, result);
   return status.ok();
 }
 
-Database::MetricInfoVector Database::GetStatsForActivityAndMetric(
-    const std::string& activity, MetricType metric_type,
-    const base::Time& start, const base::Time& end) {
+Database::MetricVector Database::GetStatsForActivityAndMetric(
+    const std::string& activity,
+    MetricType metric_type,
+    const base::Time& start,
+    const base::Time& end) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  MetricInfoVector results;
+  MetricVector results;
   std::string start_key = CreateMetricKey(start, metric_type, activity);
   std::string end_key = CreateMetricKey(end, metric_type, activity);
   scoped_ptr<leveldb::Iterator> it(metric_db_->NewIterator(read_options_));
   for (it->Seek(start_key);
        it->Valid() && it->key().ToString() <= end_key;
        it->Next()) {
     MetricKey split_key = SplitMetricKey(it->key().ToString());
     if (split_key.activity == activity)
-      results.push_back(MetricInfo(split_key.time, it->value().ToString()));
+      results.push_back(Metric(split_key.time, it->value().ToString()));
   }
   return results;
 }
 
 Database::MetricVectorMap Database::GetStatsForMetricByActivity(
-    MetricType metric_type, const base::Time& start, const base::Time& end) {
+    MetricType metric_type,
+    const base::Time& start,
+    const base::Time& end) {
   CHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   MetricVectorMap results;
   std::string start_key = CreateMetricKey(start, metric_type, std::string());
   std::string end_key = CreateMetricKey(end, metric_type, std::string());
   scoped_ptr<leveldb::Iterator> it(metric_db_->NewIterator(read_options_));
   for (it->Seek(start_key);
        it->Valid() && it->key().ToString() <= end_key;
        it->Next()) {
     MetricKey split_key = SplitMetricKey(it->key().ToString());
     if (!results[split_key.activity].get()) {
       results[split_key.activity] =
-          linked_ptr<MetricInfoVector>(new MetricInfoVector());
+          linked_ptr<MetricVector >(new MetricVector());
     }
     results[split_key.activity]->push_back(
-        MetricInfo(split_key.time, it->value().ToString()));
+        Metric(split_key.time, it->value().ToString()));
   }
   return results;
 }
 
 Database::Database(const FilePath& path)
     : path_(path),
       read_options_(leveldb::ReadOptions()),
       write_options_(leveldb::WriteOptions()) {
   InitDBs();
   LoadRecents();
@@ skipping 78 matching lines @@
     start_time_key_ = CreateActiveIntervalKey(current_time);
     end_time = start_time_key_;
   } else {
     end_time = CreateActiveIntervalKey(clock_->GetTime());
   }
   last_update_time_ = current_time;
   active_interval_db_->Put(write_options_, start_time_key_, end_time);
 }
 
 }  // namespace performance_monitor