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 <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/timer.h"
 
 // Older style trace macros with explicit id and extra data
 // Only these macros result in publishing data to ETW as currently implemented.
 #define TRACE_EVENT_BEGIN_ETW(name, id, extra) \
@@ skipping 82 matching lines @@
   const char* arg_names_[kTraceMaxNumArgs];
   const unsigned char* category_enabled_;
   const char* name_;
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
   int thread_id_;
   char phase_;
   unsigned char flags_;
   unsigned char arg_types_[kTraceMaxNumArgs];
 };
 
+// TraceBuffer holds the events as they are collected.
+class BASE_EXPORT TraceBuffer {
+ public:
+  virtual ~TraceBuffer() {}
+
+  virtual void AddEvent(const TraceEvent& event) = 0;
+  virtual bool HasMoreEvents() const = 0;
+  virtual const TraceEvent& NextEvent() = 0;
+  virtual bool IsFull() const = 0;
+  virtual size_t CountEnabledByName(const unsigned char* category,
+                                    const std::string& event_name) const = 0;
+  virtual size_t Size() const = 0;
+  virtual const TraceEvent& GetEventAt(size_t index) const = 0;
+};
 
 // TraceResultBuffer collects and converts trace fragments returned by TraceLog
 // to JSON output.
 class BASE_EXPORT TraceResultBuffer {
  public:
   typedef base::Callback<void(const std::string&)> OutputCallback;
 
   // If you don't need to stream JSON chunks out efficiently, and just want to
   // get a complete JSON string after calling Finish, use this struct to collect
   // JSON trace output.
@@ skipping 40 matching lines @@
     // The trace buffer does not flush dynamically, so when it fills up,
     // subsequent trace events will be dropped. This callback is generated when
     // the trace buffer is full. The callback must be thread safe.
     TRACE_BUFFER_FULL = 1 << 0,
     // A subscribed trace-event occurred.
     EVENT_WATCH_NOTIFICATION = 1 << 1
   };
 
   // Options determines how the trace buffer stores data.
   enum Options {
+    // Record until the trace buffer is full.
     RECORD_UNTIL_FULL = 1 << 0,
+
+    // Record until the user ends the trace. The trace buffer is a fixed size
+    // and we use it as a ring buffer during recording.
+    RECORD_CONTINUOUSLY = 1 << 1,
+
     // Enable the sampling profiler.
-    ENABLE_SAMPLING = 1 << 1,
+    ENABLE_SAMPLING = 1 << 2
   };
 
   static TraceLog* GetInstance();
 
   // Convert the given string to trace options. Defaults to RECORD_UNTIL_FULL if
   // the string does not provide valid options.
   static Options TraceOptionsFromString(const std::string& str);
 
   // Get set of known categories. This can change as new code paths are reached.
   // The known categories are inserted into |categories|.
@@ skipping 145 matching lines @@
 
   void InstallWaitableEventForSamplingTesting(WaitableEvent* waitable_event);
 
   // Allows deleting our singleton instance.
   static void DeleteForTesting();
 
   // Allows resurrecting our singleton instance post-AtExit processing.
   static void Resurrect();
 
   // Allow tests to inspect TraceEvents.
-  size_t GetEventsSize() const { return logged_events_.size(); }
+  size_t GetEventsSize() const { return logged_events_->Size(); }
   const TraceEvent& GetEventAt(size_t index) const {
-    DCHECK(index < logged_events_.size());
-    return logged_events_[index];
+    return logged_events_->GetEventAt(index);
   }
 
   void SetProcessID(int process_id);
 
   // Allow setting an offset between the current TimeTicks time and the time
   // that should be reported.
   void SetTimeOffset(TimeDelta offset);
 
  private:
   // This allows constructor and destructor to be private and usable only
@@ skipping 45 matching lines @@
                     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,
                     unsigned char flags);
   static void ApplyATraceEnabledFlag(unsigned char* category_enabled);
 #endif
 
+  TraceBuffer* GetTraceBuffer();
+
   // 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_;
+  scoped_ptr<TraceBuffer> logged_events_;
   EventCallback event_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_;
 
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
@@ skipping 11 matching lines @@
   scoped_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_