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;
   }
+  // Use this if your string is already global and does not need to be copied.
+  static TraceValue StaticString(const char* rhs) {
+    TraceValue tv(rhs);
+    tv.type_ = TRACE_TYPE_STATIC_STRING;
+    return tv;
+  }
 
   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;
@@ skipping 28 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_