Update tracing framework to optionally use a ringbuffer.

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 190 matching lines @@
   // meaningful if |IsEnabled()| is true.
   void GetEnabledTraceCategories(std::vector<std::string>* included_out,
                                  std::vector<std::string>* excluded_out);
 
   // Disable tracing for all categories.
   void SetDisabled();
   // Helper method to enable/disable tracing for all categories.
   void SetEnabled(bool enabled);
   bool IsEnabled() { return !!enable_count_; }
 
+  void SetContinuousTracing(bool continuous_tracing) {

[nduca, 2013/02/12 19:42:22]

I like it, but can we make it a mode and a required argument on the enable call?
That way we can correctly fail when two different callers enable the system but
in two different modes [which can happen]. And, correclty handle the case where
someone tries to mutate the logging mode when tracing is active.

[dsinclair, 2013/02/25 19:04:34]

Done.

+    continuous_tracing_ = continuous_tracing;
+  }
+  bool GetContinuousTracing() { return continuous_tracing_; }
+
 #if defined(OS_ANDROID)
   static void InitATrace();
 #endif
 
   // Enabled state listeners give a callback when tracing is enabled or
   // disabled. This can be used to tie into other library's tracing systems
   // on-demand.
   class EnabledStateChangedObserver {
    public:
     virtual ~EnabledStateChangedObserver() { }
@@ skipping 136 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);
   static void ApplyATraceEnabledFlag(unsigned char* category_enabled);
 #endif
 
+  void AddEvent(const TraceEvent& event);
+
   // TODO(nduca): switch to per-thread trace buffers to reduce thread
   // synchronization.
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   int enable_count_;
   NotificationCallback notification_callback_;
   std::vector<TraceEvent> logged_events_;
+  bool continuous_tracing_;

[nduca, 2013/02/12 19:42:22]

Hm... can you factor out logged_events and logged_events_newest_/oldest_ to be a
class that is the Log object? I think it'd benefit us architecturally to have
this just be a log->AddEvent and then just have two log implementations.

[dsinclair, 2013/02/15 19:38:55]

Done.

+  uint32 logged_events_newest_;
+  uint32 logged_events_oldest_;
   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_;
 
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
   TimeDelta time_offset_;
 
   // 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_