Added support to trace_event for passing static string arguments without copy

base/debug/trace_event.h

 // Copyright (c) 2011 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.
 
 // Trace events are for tracking application performance.
 //
 // Events are issued against categories. Whereas LOG's
 // categories are statically defined, TRACE categories are created
 // implicitly with a string. For example:
 //   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
@@ skipping 78 matching lines @@
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/timer.h"
 
+// Short hand convenience macro for specifying unscoped strings as argument
+// values to avoid allocating/copying. The string pointer must remain valid
+// until tracing is disabled.
+#define TRACE_STATIC_STR(str) base::debug::TraceValue::StaticString(str)
+
 // 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) \
   base::debug::TraceLog::AddTraceEventEtw( \
       base::debug::TRACE_EVENT_PHASE_BEGIN, \
       name, reinterpret_cast<const void*>(id), extra);
 
 #define TRACE_EVENT_END_ETW(name, id, extra) \
   base::debug::TraceLog::AddTraceEventEtw( \
       base::debug::TRACE_EVENT_PHASE_END, \
@@ skipping 197 matching lines @@
 // low, we want constant size storage here.
 class BASE_EXPORT TraceValue {
  public:
   enum Type {
     TRACE_TYPE_UNDEFINED,
     TRACE_TYPE_BOOL,
     TRACE_TYPE_UINT,
     TRACE_TYPE_INT,
     TRACE_TYPE_DOUBLE,
     TRACE_TYPE_POINTER,
-    TRACE_TYPE_STRING
+    TRACE_TYPE_STRING,
+    TRACE_TYPE_STATIC_STRING
   };
 
   TraceValue() : type_(TRACE_TYPE_UNDEFINED) {
     value_.as_uint = 0ull;
   }
   TraceValue(bool rhs) : type_(TRACE_TYPE_BOOL) {
     value_.as_bool = rhs;
   }
   TraceValue(uint64 rhs) : type_(TRACE_TYPE_UINT) {
     value_.as_uint = rhs;
@@ skipping 21 matching lines @@
   }
   TraceValue(double rhs) : type_(TRACE_TYPE_DOUBLE) {
     value_.as_double = rhs;
   }
   TraceValue(const void* rhs) : type_(TRACE_TYPE_POINTER) {
     value_.as_pointer = rhs;
   }
   TraceValue(const char* rhs) : type_(TRACE_TYPE_STRING) {
     value_.as_string = rhs;
   }
+  // User this if your string is already global and does not need to be copied.
+  static TraceValue StaticString(const char* rhs) {
+    return TraceValue(rhs, 0);

[scheib, 2011/08/29 21:46:09]

nit: Can you just call the string constructor and then set the type after? Would
elide the detail of the magic 2nd param to solve overloading, and the private
constructor?
E.g. this function calls
TraceValue t = TraceValue(rhs);
t.type_ = TRACE_TYPE_STATIC_STRING;
return t;

[jbates, 2011/08/29 22:22:20]

Done.

+  }
 
   void AppendAsJSON(std::string* out) const;
 
   Type type() const {
     return type_;
   }
   uint64 as_uint() const {
     DCHECK_EQ(TRACE_TYPE_UINT, type_);
     return value_.as_uint;
   }
   bool as_bool() const {
     DCHECK_EQ(TRACE_TYPE_BOOL, type_);
     return value_.as_bool;
   }
   int64 as_int() const {
     DCHECK_EQ(TRACE_TYPE_INT, type_);
     return value_.as_int;
   }
   double as_double() const {
     DCHECK_EQ(TRACE_TYPE_DOUBLE, type_);
     return value_.as_double;
   }
   const void* as_pointer() const {
     DCHECK_EQ(TRACE_TYPE_POINTER, type_);
     return value_.as_pointer;
   }
   const char* as_string() const {
-    DCHECK_EQ(TRACE_TYPE_STRING, type_);
+    DCHECK(type_ == TRACE_TYPE_STRING || type_ == TRACE_TYPE_STATIC_STRING);
     return value_.as_string;
   }
   const char** as_assignable_string() {
     DCHECK_EQ(TRACE_TYPE_STRING, type_);
     return &value_.as_string;
   }
 
  private:
   union Value {
     bool as_bool;
     uint64 as_uint;
     int64 as_int;
     double as_double;
     const void* as_pointer;
     const char* as_string;
   };
 
+  TraceValue(const char* rhs, int ignore) : type_(TRACE_TYPE_STATIC_STRING) {
+    (void)ignore;
+    value_.as_string = rhs;
+  }
+
   Type type_;
   Value value_;
 };
 
 // Output records are "Events" and can be obtained via the
 // OutputCallback whenever the tracing system decides to flush. This
 // can happen at any time, on any thread, or you can programatically
 // force it to happen.
 class TraceEvent {
  public:
@@ skipping 11 matching lines @@
 
   // Serialize event data to JSON
   static void AppendEventsAsJSON(const std::vector<TraceEvent>& events,
                                  size_t start,
                                  size_t count,
                                  std::string* out);
   void AppendAsJSON(std::string* out) const;
 
   TimeTicks timestamp() const { return timestamp_; }
 
+  // Exposed for unittesting:
+
+  const base::RefCountedString* parameter_copy_storage() const {
+    return parameter_copy_storage_.get();
+  }
+
+  const char* name() const { return name_; }
+
  private:
   unsigned long process_id_;
   unsigned long thread_id_;
   TimeTicks timestamp_;
   TraceEventPhase phase_;
   const TraceCategory* category_;
   const char* name_;
   const char* arg_names_[kTraceMaxNumArgs];
   TraceValue arg_values_[kTraceMaxNumArgs];
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
@@ skipping 51 matching lines @@
                                const char* name,
                                const void* id,
                                const char* extra);
   static void AddTraceEventEtw(TraceEventPhase phase,
                                const char* name,
                                const void* id,
                                const std::string& extra) {
     AddTraceEventEtw(phase, name, id, extra.c_str());
   }
 
-  // Exposed for unittesting only, allows resurrecting our
-  // singleton instance post-AtExit processing.
+  // Exposed for unittesting:
+
+  // 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 {
+    DCHECK(index < logged_events_.size());
+    return logged_events_[index];
+  }
+
  private:
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct StaticMemorySingletonTraits<TraceLog>;
 
   TraceLog();
   ~TraceLog();
   const TraceCategory* GetCategoryInternal(const char* name);
   void AddCurrentMetadataEvents();
 
@@ skipping 75 matching lines @@
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_