Add searching features to new TraceEventVector class for tests.

base/test/trace_event_analyzer.cc

Index: base/test/trace_event_analyzer.cc
diff --git a/base/test/trace_event_analyzer.cc b/base/test/trace_event_analyzer.cc
index 183f29a93af04fdc4e2e05a224f598596352ba2c..26e397f423e48c1600793af42b4613d8df55554a 100644
--- a/base/test/trace_event_analyzer.cc
+++ b/base/test/trace_event_analyzer.cc
@@ -615,7 +615,7 @@ namespace {
 // Search |events| for |query| and add matches to |output|.
 size_t FindMatchingEvents(const std::vector<TraceEvent>& events,
                           const Query& query,
-                          TraceAnalyzer::TraceEventVector* output) {
+                          TraceEventVector* output) {
   for (size_t i = 0; i < events.size(); ++i) {
     if (query.Evaluate(events[i]))
       output->push_back(&events[i]);
@@ -648,6 +648,122 @@ bool ParseEventsFromJson(const std::string& json,
 
 }  // namespace
 
+// TraceEventVector
+
+bool TraceEventVector::GetRateStats(RateStats* stats) {
+  // Need at least 3 events to calculate rate stats.
+  if (size() < 3) {
+    LOG(ERROR) << "Not enough events: " << size();
+    return false;
+  }
+
+  std::vector<double> deltas;
+  double delta_sum = 0.0;
+  size_t num_deltas = size() - 1;
+  for (size_t i = 0; i < num_deltas; ++i) {
+    double delta = at(i + 1)->timestamp - at(i)->timestamp;
+    if (delta < 0.0) {
+      LOG(ERROR) << "Events are out of order";
+      return false;
+    }
+    deltas.push_back(delta);
+    delta_sum += delta;
+  }
+
+  stats->min_us = *std::min_element(deltas.begin(), deltas.end());
+  stats->max_us = *std::max_element(deltas.begin(), deltas.end());
+  stats->mean_us = delta_sum / static_cast<double>(num_deltas);
+
+  double sum_mean_offsets_squared = 0.0;
+  for (size_t i = 0; i < num_deltas; ++i) {
+    double offset = fabs(deltas[i] - stats->mean_us);
+    sum_mean_offsets_squared += offset * offset;
+  }
+  stats->standard_deviation_us =

[Paweł Hajdan Jr., 2011/12/12 17:21:51]

Isn't this standard deviation code being duplicated? If so, please extract the
common parts.

[jbates, 2011/12/12 22:00:32]

This is just a code move, so no duplication.

+      sum_mean_offsets_squared / static_cast<double>(num_deltas - 1);
+
+  return true;
+}
+
+bool TraceEventVector::FindFirstOf(Query query,
+                                   size_t position,
+                                   size_t* return_index) const {
+  for (size_t i = position; i < size(); ++i) {
+    if (query.Evaluate(*at(i))) {
+      *return_index = i;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool TraceEventVector::FindLastOf(Query query,
+                                  size_t position,
+                                  size_t* return_index) const {
+  if (empty())
+    return false;
+  position = (position < size()) ? position : size() - 1;
+  for (;;) {

[Paweł Hajdan Jr., 2011/12/12 17:21:51]

nit: Why not "while (true)"? It's generally more descriptive.

[jbates, 2011/12/12 22:00:32]

Grepping base/ for 'for (;;)' turns up slightly more occurrences than 'while
(true)' although both are used throughout our code. I guess this is left to
personal preference. I've read that MSVC can generate better code with for (;;).
It also is possible to get compiler warnings with while (true) (see
http://msdn.microsoft.com/en-us/library/6t66728h(v=vs.80).aspx), but I guess we
disable that warning.

+    if (query.Evaluate(*at(position))) {
+      *return_index = position;
+      return true;
+    }
+    if (position == 0)
+      return false;
+    --position;
+  }
+  return false;
+}
+
+bool TraceEventVector::FindClosest(Query query,
+                                   size_t position,
+                                   size_t* return_closest,
+                                   size_t* return_second_closest) const {
+  if (empty() || position >= size())
+    return false;
+  size_t closest = size();
+  size_t second_closest = size();
+  for (size_t i = 0; i < size(); ++i) {
+    if (!query.Evaluate(*at(i)))
+      continue;
+    if (closest == size()) {
+      closest = i;
+      continue;
+    }
+    if (fabs(at(i)->timestamp - at(position)->timestamp) <
+        fabs(at(closest)->timestamp - at(position)->timestamp)) {
+      second_closest = closest;
+      closest = i;
+    } else if (second_closest == size()) {
+      second_closest = i;
+    }
+  }
+
+  if (closest < size() &&
+      (!return_second_closest || second_closest < size())) {
+    *return_closest = closest;
+    if (return_second_closest)
+      *return_second_closest = second_closest;
+    return true;
+  }
+
+  return false;
+}
+
+int TraceEventVector::CountMatches(Query query,
+                                   size_t begin_position,
+                                   size_t end_position) const {
+  if (begin_position >= size())
+    return 0;
+  end_position = (end_position < size()) ? end_position : size();
+  int count = 0;
+  for (size_t i = begin_position; i < end_position; ++i) {
+    if (query.Evaluate(*at(i)))
+      ++count;
+  }
+  return count;
+}
+
 // TraceAnalyzer
 
 TraceAnalyzer::TraceAnalyzer() : allow_assocation_changes_(true) {
@@ -739,6 +855,19 @@ void TraceAnalyzer::AssociateEvents(const Query& first,
   }
 }
 
+void TraceAnalyzer::MergeAssociatedEventArgs() {
+  for (size_t i = 0; i < raw_events_.size(); ++i) {
+    if (raw_events_[i].other_event) {
+      raw_events_[i].arg_numbers.insert(
+          raw_events_[i].other_event->arg_numbers.begin(),
+          raw_events_[i].other_event->arg_numbers.end());
+      raw_events_[i].arg_strings.insert(
+          raw_events_[i].other_event->arg_strings.begin(),
+          raw_events_[i].other_event->arg_strings.end());
+    }
+  }
+}
+
 size_t TraceAnalyzer::FindEvents(const Query& query, TraceEventVector* output) {
   allow_assocation_changes_ = false;
   output->clear();
@@ -758,41 +887,6 @@ const std::string& TraceAnalyzer::GetThreadName(
   return thread_names_[thread];
 }
 
-bool TraceAnalyzer::GetRateStats(const TraceEventVector& events, Stats* stats) {
-  // Need at least 3 events to calculate rate stats.
-  if (events.size() < 3) {
-    LOG(ERROR) << "Not enough events: " << events.size();
-    return false;
-  }
-
-  std::vector<double> deltas;
-  double delta_sum = 0.0;
-  size_t num_deltas = events.size() - 1;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double delta = events[i + 1]->timestamp - events[i]->timestamp;
-    if (delta < 0.0) {
-      LOG(ERROR) << "Events are out of order";
-      return false;
-    }
-    deltas.push_back(delta);
-    delta_sum += delta;
-  }
-
-  stats->min_us = *std::min_element(deltas.begin(), deltas.end());
-  stats->max_us = *std::max_element(deltas.begin(), deltas.end());
-  stats->mean_us = delta_sum / static_cast<double>(num_deltas);
-
-  double sum_mean_offsets_squared = 0.0;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double offset = fabs(deltas[i] - stats->mean_us);
-    sum_mean_offsets_squared += offset * offset;
-  }
-  stats->standard_deviation_us =
-      sum_mean_offsets_squared / static_cast<double>(num_deltas - 1);
-
-  return true;
-}
-
 void TraceAnalyzer::ParseMetadata() {
   for (size_t i = 0; i < raw_events_.size(); ++i) {
     TraceEvent& this_event = raw_events_[i];