Add support for TraceEvent before the native library is loaded.

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 <stack>
 #include <string>
@@ skipping 526 matching lines @@
   // JSON. The callback can be null if the caller doesn't want any data.
   // Due to the implementation of thread-local buffers, flush can't be
   // done when tracing is enabled. If called when tracing is enabled, the
   // callback will be called directly with (empty_string, false) to indicate
   // the end of this unsuccessful flush.
   typedef base::Callback<void(const scoped_refptr<base::RefCountedString>&,
                               bool has_more_events)> OutputCallback;
   void Flush(const OutputCallback& cb);
   void FlushButLeaveBufferIntact(const OutputCallback& flush_output_callback);
 
+  // Can be called by clients to add custom events to the trace log without
+  // using the TRACE_EVENT* macros. This must only be called when category group
+  // is enabled for recording.
+  TraceEventHandle AddCustomTraceEvent(

[dsinclair, 2015/01/27 14:43:30]

Instead of AddCustomTraceEvent, I think we should either update
AddTraceEventWithThreadIdAndTimestamp to also take the thread_now or add a
variant of that method that takes thread_now. 

[Benoit L, 2015/02/09 16:34:01]

Done.

+      char phase,
+      const unsigned char* category_group_enabled,
+      const char* name,
+      int thread_id,
+      const TimeTicks& timestamp,
+      const TimeTicks& thread_time);
+
   // Called by TRACE_EVENT* macros, don't call this directly.
   // The name parameter is a category group for example:
   // TRACE_EVENT0("renderer,webkit", "WebViewImpl::HandleInputEvent")
   static const unsigned char* GetCategoryGroupEnabled(const char* name);
   static const char* GetCategoryGroupName(
       const unsigned char* category_group_enabled);
 
   // Called by TRACE_EVENT* macros, don't call this directly.
   // If |copy| is set, |name|, |arg_name1| and |arg_name2| will be deep copied
   // into the event; see "Memory scoping note" and TRACE_EVENT_COPY_XXX above.
@@ skipping 135 matching lines @@
   }
 
   TraceBuffer* trace_buffer() const { return logged_events_.get(); }
   TraceBuffer* CreateTraceBuffer();
   TraceBuffer* CreateTraceBufferVectorOfSize(size_t max_chunks);
 
   std::string EventToConsoleMessage(unsigned char phase,
                                     const TimeTicks& timestamp,
                                     TraceEvent* trace_event);
 
+  TraceEventHandle AddTraceEventInternal(
+      char phase,
+      const unsigned char* category_group_enabled,
+      const char* name,
+      unsigned long long id,
+      int thread_id,
+      const TimeTicks& timestamp,
+      const TimeTicks& thread_time,
+      int num_args,
+      const char** arg_names,
+      const unsigned char* arg_types,
+      const unsigned long long* arg_values,
+      const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
+      unsigned char flags);
+
   TraceEvent* AddEventToThreadSharedChunkWhileLocked(TraceEventHandle* handle,
                                                      bool check_buffer_is_full);
   void CheckIfBufferIsFullWhileLocked();
   void SetDisabledWhileLocked();
 
   TraceEvent* GetEventByHandleInternal(TraceEventHandle handle,
                                        OptionalAutoLock* lock);
 
   // |generation| is used in the following callbacks to check if the callback
   // is called for the flush of the current |logged_events_|.
@@ skipping 92 matching lines @@
   scoped_refptr<MessageLoopProxy> flush_message_loop_proxy_;
   subtle::AtomicWord generation_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_