Implement TRACE_COUNTER

base/debug/trace_event.cc

 // Copyright (c) 2011 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/debug/trace_event.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 205 matching lines @@
 const char* TraceEvent::GetPhaseString(TraceEventPhase phase) {
   switch(phase) {
     case TRACE_EVENT_PHASE_BEGIN:
       return "B";
     case TRACE_EVENT_PHASE_INSTANT:
       return "I";
     case TRACE_EVENT_PHASE_END:
       return "E";
     case TRACE_EVENT_PHASE_METADATA:
       return "M";
+    case TRACE_EVENT_PHASE_COUNTER:
+      return "C";
     default:
       NOTREACHED() << "Invalid phase argument";
       return "?";
   }
 }
 
 TraceEventPhase TraceEvent::GetPhase(const char* phase) {
   switch(*phase) {
     case 'B':
       return TRACE_EVENT_PHASE_BEGIN;
     case 'I':
       return TRACE_EVENT_PHASE_INSTANT;
     case 'E':
       return TRACE_EVENT_PHASE_END;
     case 'M':
       return TRACE_EVENT_PHASE_METADATA;
+    case 'C':
+      return TRACE_EVENT_PHASE_COUNTER;
     default:
       NOTREACHED() << "Invalid phase name";
       return TRACE_EVENT_PHASE_METADATA;
   }
 }
 
 void TraceEvent::AppendEventsAsJSON(const std::vector<TraceEvent>& events,
                                     size_t start,
                                     size_t count,
                                     std::string* out) {
@@ skipping 378 matching lines @@
                                 const std::string& extra)
 {
 #if defined(OS_WIN)
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
   INTERNAL_TRACE_EVENT_ADD(phase,
       "ETW Trace Event", name, "id", id, "extra", extra,
       base::debug::TraceLog::EVENT_FLAG_COPY);
 }
 
+int TraceLog::AddCounterEvent(const TraceCategory* category,
+                              const char* name,
+                              const char* value1_name, int32 value1_val,
+                              const char* value2_name, int32 value2_val,
+                              EventFlags flags) {
+  return AddTraceEvent(TRACE_EVENT_PHASE_COUNTER,
+                       category,
+                       name,
+                       value1_name, value1_val,
+                       value2_name, value2_val,
+                       -1, 0,
+                       flags);
+}
+
 void TraceLog::AddCurrentMetadataEvents() {
   lock_.AssertAcquired();
   for(base::hash_map<PlatformThreadId, std::string>::iterator it =
           thread_names_.begin();
       it != thread_names_.end();
       it++) {
     if (!it->second.empty())
       logged_events_.push_back(
           TraceEvent(static_cast<unsigned long>(base::GetCurrentProcId()),
                      it->first,
@@ skipping 55 matching lines @@
         NULL, 0, NULL, 0,
         p_data_->threshold_begin_id, p_data_->threshold,
         TraceLog::EVENT_FLAG_NONE);
   }
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base