Implement about:tracing UI for the sampling profiler (Chromium part)

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 137 matching lines @@
 
   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 size_t Capacity() const = 0;
   virtual const TraceEvent& GetEventAt(size_t index) const = 0;
+  virtual TraceBuffer* Clone() 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
@@ skipping 143 matching lines @@
 
   // Retrieves the current CategoryFilter.
   const CategoryFilter& GetCurrentCategoryFilter();
 
   Options trace_options() const { return trace_options_; }
 
   // Enables tracing. See CategoryFilter comments for details
   // on how to control what categories will be traced.
   void SetEnabled(const CategoryFilter& category_filter, Options options);
 
-  // Disable tracing for all categories.
+  // Disables tracing for all categories.
   void SetDisabled();
   bool IsEnabled() { return !!enable_count_; }
 
+  // Enables continuous sampling tracing.
+  void SetContinuousSamplingEnabled();
+
+  // Disables continuous sampling tracing.
+  void SetContinuousSamplingDisabled();
+
   // The number of times we have begun recording traces. If tracing is off,
   // returns -1. If tracing is on, then it returns the number of times we have
   // recorded a trace. By watching for this number to increment, you can
   // passively discover when a new trace has begun. This is then used to
   // implement the TRACE_EVENT_IS_NEW_TRACE() primitive.
   int GetNumTracesRecorded();
 
 #if defined(OS_ANDROID)
   void StartATrace();
   void StopATrace();
@@ skipping 42 matching lines @@
                                 unsigned char flags);
   void SetEventCallback(EventCallback cb);
 
   // Flush all collected events to the given output callback. The callback will
   // be called one or more times with IPC-bite-size chunks. The string format is
   // undefined. Use TraceResultBuffer to convert one or more trace strings to
   // JSON.
   typedef base::Callback<void(const scoped_refptr<base::RefCountedString>&)>
       OutputCallback;
   void Flush(const OutputCallback& cb);
+  void FlushContinuousSamplingTracing(const OutputCallback& cb);
 
   // 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
@@ skipping 38 matching lines @@
                      const std::string& event_name);
   // Cancel the watch event. If tracing is enabled, this may race with the
   // watch event notification firing.
   void CancelWatchEvent();
 
   int process_id() const { return process_id_; }
 
   // Exposed for unittesting:
 
   void InstallWaitableEventForSamplingTesting(WaitableEvent* waitable_event);
+  void InstallWaitableEventForContinuousSamplingTesting(
+      WaitableEvent* waitable_event);
 
   // Allows deleting our singleton instance.
   static void DeleteForTesting();
 
   // Allow tests to inspect TraceEvents.
   size_t GetEventsSize() const { return logged_events_->Size(); }
   const TraceEvent& GetEventAt(size_t index) const {
     return logged_events_->GetEventAt(index);
   }
 
@@ skipping 70 matching lines @@
 
    private:
     TraceLog* trace_log_;
     NotificationCallback callback_copy_;
     int notification_;
   };
 
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
-  void AddMetadataEvents();
+  void AddMetadataEvents(unsigned char flags);
 
 #if defined(OS_ANDROID)
   void SendToATrace(char phase,
                     const char* category_group,
                     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,
                     scoped_ptr<ConvertableToTraceFormat> convertable_values[],
                     unsigned char flags);
   static void ApplyATraceEnabledFlag(unsigned char* category_group_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_;
+  int continuous_sampling_enable_count_;
   int num_traces_recorded_;
   NotificationCallback notification_callback_;
   scoped_ptr<TraceBuffer> logged_events_;
+  scoped_ptr<TraceBuffer> continuous_sampling_logged_events_;
   EventCallback event_callback_;
   bool dispatching_to_observer_list_;
   std::vector<EnabledStateObserver*> enabled_state_observer_list_;
 
   std::string process_name_;
   base::hash_map<int, std::string> process_labels_;
   int process_sort_index_;
   base::hash_map<int, int> thread_sort_indices_;
 
   base::hash_map<int, std::string> thread_names_;
@@ skipping 10 matching lines @@
   // Allow tests to wake up when certain events occur.
   const unsigned char* watch_category_;
   std::string watch_event_name_;
 
   Options trace_options_;
 
   // Sampling thread handles.
   scoped_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
+  // Continuous sampling thread handles.
+  // TODO(haraken): Merge this thread with the normal sampling thread.
+  //                Currently we launch two sampling threads when we
+  //                record normal tracing with enabling continuous sampling.
+  scoped_ptr<TraceSamplingThread> continuous_sampling_thread_;
+  PlatformThreadHandle continuous_sampling_thread_handle_;
+
   CategoryFilter category_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_