Add cpu count to trace metadata

base/test/trace_event_analyzer.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 "base/test/trace_event_analyzer.h"
 
 #include <algorithm>
 #include <math.h>
 #include <set>
 
@@ skipping 616 matching lines @@
       number_(0) {
   type_ = (unary_op < OP_ADD ?
            QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
 }
 
 namespace {
 
 // Search |events| for |query| and add matches to |output|.
 size_t FindMatchingEvents(const std::vector<TraceEvent>& events,
                           const Query& query,
-                          TraceEventVector* output) {
+                          TraceEventVector* output,
+                          bool ignore_metadata_events) {
   for (size_t i = 0; i < events.size(); ++i) {
+    if (ignore_metadata_events && events[i].phase == TRACE_EVENT_PHASE_METADATA)
+      continue;
     if (query.Evaluate(events[i]))
       output->push_back(&events[i]);
   }
   return output->size();
 }
 
 bool ParseEventsFromJson(const std::string& json,
                          std::vector<TraceEvent>* output) {
   scoped_ptr<base::Value> root;
   root.reset(base::JSONReader::Read(json));
@@ skipping 13 matching lines @@
     }
   }
 
   return true;
 }
 
 }  // namespace
 
 // TraceAnalyzer
 
-TraceAnalyzer::TraceAnalyzer() : allow_assocation_changes_(true) {
-}
+TraceAnalyzer::TraceAnalyzer()
+    : ignore_metadata_events_(false),
+      allow_assocation_changes_(true) {}
 
 TraceAnalyzer::~TraceAnalyzer() {
 }
 
 // static
 TraceAnalyzer* TraceAnalyzer::Create(const std::string& json_events) {
   scoped_ptr<TraceAnalyzer> analyzer(new TraceAnalyzer());
   if (analyzer->SetEvents(json_events))
     return analyzer.release();
   return NULL;
@@ skipping 97 matching lines @@
           other->arg_strings.begin(),
           other->arg_strings.end());
       other = other->other_event;
     }
   }
 }
 
 size_t TraceAnalyzer::FindEvents(const Query& query, TraceEventVector* output) {
   allow_assocation_changes_ = false;
   output->clear();
-  return FindMatchingEvents(raw_events_, query, output);
+  return FindMatchingEvents(
+      raw_events_, query, output, ignore_metadata_events_);
 }
 
 const TraceEvent* TraceAnalyzer::FindFirstOf(const Query& query) {
   TraceEventVector output;
   if (FindEvents(query, &output) > 0)
     return output.front();
   return NULL;
 }
 
 const TraceEvent* TraceAnalyzer::FindLastOf(const Query& query) {
@@ skipping 152 matching lines @@
   end_position = (end_position < events.size()) ? end_position : events.size();
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer