Process names, and predictable thread and process ordering in about:tracing

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 <map>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
@@ skipping 424 matching lines @@
   // Allows resurrecting our singleton instance post-AtExit processing.
   static void Resurrect();
 
   // 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);
   }
 
   void SetProcessID(int process_id);
+  void SetProcessSortIndex(int sort_index);
+  void SetProcessLabel(int label_id, const std::string& current_label);
+  void SetThreadSortIndex(int thread_id, int sort_index);
 
   // Allow setting an offset between the current TimeTicks time and the time
   // that should be reported.
   void SetTimeOffset(TimeDelta offset);
 
   size_t GetObserverCountForTest() const;
 
  private:
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
@@ skipping 39 matching lines @@
 
    private:
     TraceLog* trace_log_;
     NotificationCallback callback_copy_;
     int notification_;
   };
 
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
-  void AddThreadNameMetadataEvents();
+  void AddMetadataEvents();
 
 #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 num_traces_recorded_;
   NotificationCallback notification_callback_;
   scoped_ptr<TraceBuffer> logged_events_;
   EventCallback event_callback_;
   bool dispatching_to_observer_list_;
   std::vector<EnabledStateObserver*> enabled_state_observer_list_;
 
+  std::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_;
   base::hash_map<int, std::stack<TimeTicks> > thread_event_start_times_;
   base::hash_map<std::string, int> thread_colors_;
 
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
   TimeDelta time_offset_;
@@ skipping 10 matching lines @@
 
   CategoryFilter category_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_