Adding raw tracing to trace framework.

base/debug/trace_event_impl.h

 // 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.
 
 
 #ifndef BASE_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include "build/build_config.h"
 
@@ skipping 263 matching lines @@
                     long long threshold,
                     unsigned char flags);
   static void AddTraceEventEtw(char phase,
                                const char* name,
                                const void* id,
                                const char* extra);
   static void AddTraceEventEtw(char phase,
                                const char* name,
                                const void* id,
                                const std::string& extra);
+  int 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);
 
   // For every matching event, a notification will be fired. NOTE: the
   // notification will fire for each matching event that has already occurred
   // since tracing was started (including before tracing if the process was
   // started with tracing turned on).
   void SetWatchEvent(const std::string& category_name,
                      const std::string& event_name);
   // Cancel the watch event. If tracing is enabled, this may race with the
   // watch event notification firing.
   void CancelWatchEvent();
@@ skipping 54 matching lines @@
   void SendToATrace(char phase,
                     const char* category,
                     const char* name,
                     int num_args,
                     const char** arg_names,
                     const unsigned char* arg_types,
                     const unsigned long long* arg_values);
   void AddClockSyncMetadataEvents();
 #endif
 
+  int 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);
+
   // TODO(nduca): switch to per-thread trace buffers to reduce thread
   // synchronization.
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   bool enabled_;
   NotificationCallback notification_callback_;
   std::vector<TraceEvent> logged_events_;
   std::vector<std::string> included_categories_;
   std::vector<std::string> excluded_categories_;
   bool dispatching_to_observer_list_;
   ObserverList<EnabledStateChangedObserver> enabled_state_observer_list_;
 
   base::hash_map<int, std::string> thread_names_;
 
+  base::hash_map<std::string, int> fake_thread_names_;
+  int next_fake_thread_id_;
+
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
   // Allow tests to wake up when certain events occur.
   const unsigned char* watch_category_;
   std::string watch_event_name_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_