Adding raw tracing to trace framework.

base/debug/trace_event_impl.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/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 330 matching lines @@
 }
 
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, StaticMemorySingletonTraits<TraceLog> >::get();
 }
 
 TraceLog::TraceLog()
     : enabled_(false),
       dispatching_to_observer_list_(false),
+      next_fake_thread_id_(-1),
       watch_category_(NULL) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
   // traced or not, so we allow races on the enabled flag to keep the trace
   // macros fast.
   // TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
   // ANNOTATE_BENIGN_RACE_SIZED(g_category_enabled, sizeof(g_category_enabled),
   //                            "trace_event category enabled");
   for (int i = 0; i < TRACE_EVENT_MAX_CATEGORIES; ++i) {
     ANNOTATE_BENIGN_RACE(&g_category_enabled[i],
@@ skipping 226 matching lines @@
     scoped_refptr<RefCountedString> json_events_str_ptr =
         new RefCountedString();
     TraceEvent::AppendEventsAsJSON(previous_logged_events,
                                    i,
                                    kTraceEventBatchSize,
                                    &(json_events_str_ptr->data()));
     cb.Run(json_events_str_ptr);
   }
 }
 
+int TraceLog::AddTraceRawEvent(char phase,
+                               const unsigned char* category_enabled,
+                               const char* thread_name,
+                               const char* name,
+                               int64 timestamp,
+                               unsigned long long id,
+                               int num_args,
+                               const char** arg_names,
+                               const unsigned char* arg_types,
+                               const unsigned long long* arg_values,
+                               int threshold_begin_id,
+                               long long threshold,
+                               unsigned char flags) {
+  DCHECK(thread_name);
+  DCHECK(name);
+  TimeTicks now = TimeTicks::FromInternalValue(timestamp);
+  NotificationHelper notifier(this);
+  int ret_begin_id = -1;
+  {
+    AutoLock lock(lock_);
+    if (!*category_enabled)
+      return -1;
+    if (logged_events_.size() >= kTraceEventBufferSize)
+      return -1;
+
+    int thread_id;
+    base::hash_map<std::string, int>::iterator existing_id =
+        fake_thread_names_.find(thread_name);
+    if (existing_id == fake_thread_names_.end()) {
+      // This is a new thread name, add a new id.
+      thread_id = next_fake_thread_id_;
+      next_fake_thread_id_--;
+
+      fake_thread_names_[thread_name] = thread_id;
+      thread_names_[thread_id] = thread_name;
+    } else {
+      thread_id = existing_id->second;
+    }
+
+    ret_begin_id = AddTraceEventInternal(notifier, now, phase, category_enabled,
+                                         thread_id, name, id, num_args,
+                                         arg_names, arg_types, arg_values,
+                                         threshold_begin_id, threshold, flags);
+  }  // release lock
+
+  notifier.SendNotificationIfAny();
+
+  return ret_begin_id;
+}
+
 int TraceLog::AddTraceEvent(char phase,
                             const unsigned char* category_enabled,
                             const char* name,
                             unsigned long long id,
                             int num_args,
                             const char** arg_names,
                             const unsigned char* arg_types,
                             const unsigned long long* arg_values,
                             int threshold_begin_id,
                             long long threshold,
@@ skipping 38 matching lines @@
         bool found = std::find(existing_names.begin(),
                                existing_names.end(),
                                new_name) != existing_names.end();
         if (!found) {
           existing_name->second.push_back(',');
           existing_name->second.append(new_name);
         }
       }
     }
 
-    if (threshold_begin_id > -1) {
-      DCHECK(phase == TRACE_EVENT_PHASE_END);
-      size_t begin_i = static_cast<size_t>(threshold_begin_id);
-      // Return now if there has been a flush since the begin event was posted.
-      if (begin_i >= logged_events_.size())
-        return -1;
-      // Determine whether to drop the begin/end pair.
-      TimeDelta elapsed = now - logged_events_[begin_i].timestamp();
-      if (elapsed < TimeDelta::FromMicroseconds(threshold)) {
-        // Remove begin event and do not add end event.
-        // This will be expensive if there have been other events in the
-        // mean time (should be rare).
-        logged_events_.erase(logged_events_.begin() + begin_i);
-        return -1;
-      }
-    }
-
-    if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
-      id ^= process_id_hash_;
-
-    ret_begin_id = static_cast<int>(logged_events_.size());
-    logged_events_.push_back(
-        TraceEvent(thread_id,
-                   now, phase, category_enabled, name, id,
-                   num_args, arg_names, arg_types, arg_values,
-                   flags));
-
-    if (logged_events_.size() == kTraceEventBufferSize)
-      notifier.AddNotificationWhileLocked(TRACE_BUFFER_FULL);
-
-    if (watch_category_ == category_enabled && watch_event_name_ == name)
-      notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
+    ret_begin_id = AddTraceEventInternal(notifier, now, phase, category_enabled,
+                                         thread_id, name, id, num_args,
+                                         arg_names, arg_types, arg_values,
+                                         threshold_begin_id, threshold, flags);
   }  // release lock
 
   notifier.SendNotificationIfAny();
 
   return ret_begin_id;
 }
+
+int TraceLog::AddTraceEventInternal(NotificationHelper& notifier,
+                                    TimeTicks timestamp,
+                                    char phase,
+                                    const unsigned char* category_enabled,
+                                    int thread_id,
+                                    const char* name,
+                                    unsigned long long id,
+                                    int num_args,
+                                    const char** arg_names,
+                                    const unsigned char* arg_types,
+                                    const unsigned long long* arg_values,
+                                    int threshold_begin_id,
+                                    long long threshold,
+                                    unsigned char flags) {
+  if (threshold_begin_id > -1) {
+    DCHECK(phase == TRACE_EVENT_PHASE_END);
+    size_t begin_i = static_cast<size_t>(threshold_begin_id);
+    // Return now if there has been a flush since the begin event was posted.
+    if (begin_i >= logged_events_.size())
+      return -1;
+    // Determine whether to drop the begin/end pair.
+    TimeDelta elapsed = timestamp - logged_events_[begin_i].timestamp();
+    if (elapsed < TimeDelta::FromMicroseconds(threshold)) {
+      // Remove begin event and do not add end event.
+      // This will be expensive if there have been other events in the
+      // mean time (should be rare).
+      logged_events_.erase(logged_events_.begin() + begin_i);
+      return -1;
+    }
+  }
+
+  if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
+    id ^= process_id_hash_;
+
+  int ret_begin_id = static_cast<int>(logged_events_.size());
+  logged_events_.push_back(
+      TraceEvent(thread_id,
+                 timestamp, phase, category_enabled, name, id,
+                 num_args, arg_names, arg_types, arg_values,
+                 flags));
+
+  if (logged_events_.size() == kTraceEventBufferSize)
+    notifier.AddNotificationWhileLocked(TRACE_BUFFER_FULL);
+
+  if (watch_category_ == category_enabled && watch_event_name_ == name)
+    notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
+
+  return ret_begin_id;
+}
 
 void TraceLog::AddTraceEventEtw(char phase,
                                 const char* name,
                                 const void* id,
                                 const char* extra) {
 #if defined(OS_WIN)
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
   INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
                            TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
@@ skipping 81 matching lines @@
   // Create a FNV hash from the process ID for XORing.
   // See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
   unsigned long long offset_basis = 14695981039346656037ull;
   unsigned long long fnv_prime = 1099511628211ull;
   unsigned long long pid = static_cast<unsigned long long>(process_id_);
   process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
 }
 
 }  // namespace debug
 }  // namespace base