Add a ConvertableToTraceFormat type to the trace framework.

base/debug/trace_event_impl.cc

 // 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.
 
 #include "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 256 matching lines @@
 TraceEvent::TraceEvent(int thread_id,
                        TimeTicks timestamp,
                        char phase,
                        const unsigned char* category_enabled,
                        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<ConvertableToJSON> convertable_values[],
                        unsigned char flags)
     : timestamp_(timestamp),
       id_(id),
       category_enabled_(category_enabled),
       name_(name),
       thread_id_(thread_id),
       phase_(phase),
       flags_(flags) {
   // Clamp num_args since it may have been set by a third_party library.
   num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
   int i = 0;
   for (; i < num_args; ++i) {
     arg_names_[i] = arg_names[i];
-    arg_values_[i].as_uint = arg_values[i];
     arg_types_[i] = arg_types[i];
+
+    if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+      convertable_values_[i].reset(convertable_values[i].release());
+    else
+      arg_values_[i].as_uint = arg_values[i];
   }
   for (; i < kTraceMaxNumArgs; ++i) {
     arg_names_[i] = NULL;
     arg_values_[i].as_uint = 0u;
+    convertable_values_[i].reset();
     arg_types_[i] = TRACE_VALUE_TYPE_UINT;
   }
 
   bool copy = !!(flags & TRACE_EVENT_FLAG_COPY);
   size_t alloc_size = 0;
   if (copy) {
     alloc_size += GetAllocLength(name);
     for (i = 0; i < num_args; ++i) {
       alloc_size += GetAllocLength(arg_names_[i]);
       if (arg_types_[i] == TRACE_VALUE_TYPE_STRING)
         arg_types_[i] = TRACE_VALUE_TYPE_COPY_STRING;
     }
   }
 
   bool arg_is_copy[kTraceMaxNumArgs];
   for (i = 0; i < num_args; ++i) {
+    // No copying of convertable types, we retain ownership.
+    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+      continue;
+
     // We only take a copy of arg_vals if they are of type COPY_STRING.
     arg_is_copy[i] = (arg_types_[i] == TRACE_VALUE_TYPE_COPY_STRING);
     if (arg_is_copy[i])
       alloc_size += GetAllocLength(arg_values_[i].as_string);
   }
 
   if (alloc_size) {
     parameter_copy_storage_ = new RefCountedString;
     parameter_copy_storage_->data().resize(alloc_size);
     char* ptr = string_as_array(&parameter_copy_storage_->data());
     const char* end = ptr + alloc_size;
     if (copy) {
       CopyTraceEventParameter(&ptr, &name_, end);
-      for (i = 0; i < num_args; ++i)
+      for (i = 0; i < num_args; ++i) {
+        if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+          continue;
         CopyTraceEventParameter(&ptr, &arg_names_[i], end);
+      }
     }
     for (i = 0; i < num_args; ++i) {
+      if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+        continue;
       if (arg_is_copy[i])
         CopyTraceEventParameter(&ptr, &arg_values_[i].as_string, end);
     }
     DCHECK_EQ(end, ptr) << "Overrun by " << ptr - end;
   }
 }
 
+TraceEvent::TraceEvent(const TraceEvent& other)
+    : timestamp_(other.timestamp_),
+      id_(other.id_),
+      category_enabled_(other.category_enabled_),
+      name_(other.name_),
+      thread_id_(other.thread_id_),
+      phase_(other.phase_),
+      flags_(other.flags_) {
+  parameter_copy_storage_ = other.parameter_copy_storage_;
+
+  for (int i = 0; i < kTraceMaxNumArgs; ++i) {
+    arg_values_[i] = other.arg_values_[i];
+    arg_names_[i] = other.arg_names_[i];
+    arg_types_[i] = other.arg_types_[i];
+
+    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
+      // TODO(dsinclair): Is this correct? We have to release the pointer from
+      // the other scoped_ptr so we can have it.
+      convertable_values_[i].reset(
+          const_cast<TraceEvent*>(&other)->convertable_values_[i].release());
+    } else {
+      convertable_values_[i].reset();
+    }
+  }
+}
+
+TraceEvent& TraceEvent::operator=(const TraceEvent& other) {
+  if (this == &other)
+    return *this;
+
+  timestamp_ = other.timestamp_;
+  id_ = other.id_;
+  category_enabled_ = other.category_enabled_;
+  name_ = other.name_;
+  parameter_copy_storage_ = other.parameter_copy_storage_;
+  thread_id_ = other.thread_id_;
+  phase_ = other.phase_;
+  flags_ = other.flags_;
+
+  for (int i = 0; i < kTraceMaxNumArgs; ++i) {
+    arg_values_[i] = other.arg_values_[i];
+    arg_names_[i] = other.arg_names_[i];
+    arg_types_[i] = other.arg_types_[i];
+
+    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
+      // TODO(dsinclair): Is this correct? We have to release the pointer from
+      // the other scoped_ptr so we can have it.
+      convertable_values_[i].reset(
+          const_cast<TraceEvent*>(&other)->convertable_values_[i].release());
+    } else {
+      convertable_values_[i].reset();
+    }
+  }
+  return *this;
+}
+
 TraceEvent::~TraceEvent() {
 }
 
 // static
 void TraceEvent::AppendValueAsJSON(unsigned char type,
                                    TraceEvent::TraceValue value,
                                    std::string* out) {
   std::string::size_type start_pos;
   switch (type) {
     case TRACE_VALUE_TYPE_BOOL:
@@ skipping 50 matching lines @@
       phase_,
       name_);
 
   // Output argument names and values, stop at first NULL argument name.
   for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
     if (i > 0)
       *out += ",";
     *out += "\"";
     *out += arg_names_[i];
     *out += "\":";
-    AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
+
+    if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
+      convertable_values_[i]->ToJSON(*out);
+    else
+      AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
   }
   *out += "}";
 
   // If id_ is set, print it out as a hex string so we don't loose any
   // bits (it might be a 64-bit pointer).
   if (flags_ & TRACE_EVENT_FLAG_HAS_ID)
     StringAppendF(out, ",\"id\":\"%" PRIx64 "\"", static_cast<uint64>(id_));
 
   // Instant events also output their scope.
   if (phase_ == TRACE_EVENT_PHASE_INSTANT) {
@@ skipping 141 matching lines @@
       TRACE_EVENT_API_ATOMIC_LOAD(*bucket_data->bucket);
   if (!category_and_name)
     return;
   const char* const combined =
       reinterpret_cast<const char* const>(category_and_name);
   const char* category;
   const char* name;
   ExtractCategoryAndName(combined, &category, &name);
   TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SAMPLE,
                                   TraceLog::GetCategoryEnabled(category),
-                                  name,
-                                  0,
-                                  0,
-                                  NULL,
-                                  NULL,
-                                  NULL,
-                                  0);
+                                  name, 0, 0, NULL, NULL, NULL, NULL, 0);
 }
 
 void TraceSamplingThread::GetSamples() {
   for (size_t i = 0; i < sample_buckets_.size(); ++i) {
     TraceBucketData* bucket_data = &sample_buckets_[i];
     bucket_data->callback.Run(bucket_data);
   }
 }
 
 void TraceSamplingThread::RegisterSampleBucket(
@@ skipping 422 matching lines @@
           &(json_events_str_ptr->data()));
 
       if (!previous_logged_events->HasMoreEvents())
         break;
     }
 
     cb.Run(json_events_str_ptr);
   }
 }
 
-void TraceLog::AddTraceEvent(char phase,
-                             const unsigned char* category_enabled,
-                             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) {
+void TraceLog::AddTraceEvent(
+    char phase,
+    const unsigned char* category_enabled,
+    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<ConvertableToJSON> convertable_values[],
+    unsigned char flags) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
   AddTraceEventWithThreadIdAndTimestamp(phase, category_enabled, name, id,
                                         thread_id, now, num_args, arg_names,
-                                        arg_types, arg_values, flags);
+                                        arg_types, arg_values,
+                                        convertable_values, flags);
 }
 
 void TraceLog::AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const TimeTicks& timestamp,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
+    scoped_ptr<ConvertableToJSON> convertable_values[],
     unsigned char flags) {
   DCHECK(name);
 
   if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
     id ^= process_id_hash_;
 
 #if defined(OS_ANDROID)
   SendToATrace(phase, GetCategoryName(category_enabled), name, id,
                num_args, arg_names, arg_types, arg_values, flags);
 #endif
@@ skipping 36 matching lines @@
         if (!found) {
           existing_name->second.push_back(',');
           existing_name->second.append(new_name);
         }
       }
     }
 
     logged_events_->AddEvent(TraceEvent(thread_id,
         now, phase, category_enabled, name, id,
         num_args, arg_names, arg_types, arg_values,
-        flags));
+        convertable_values, flags));
 
     if (logged_events_->IsFull())
       notifier.AddNotificationWhileLocked(TRACE_BUFFER_FULL);
 
     if (watch_category_ == category_enabled && watch_event_name_ == name)
       notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
 
     event_callback_copy = event_callback_;
   }  // release lock
 
@@ skipping 61 matching lines @@
 void TraceLog::AddThreadNameMetadataEvents() {
   lock_.AssertAcquired();
   for(hash_map<int, std::string>::iterator it = thread_names_.begin();
       it != thread_names_.end();
       it++) {
     if (!it->second.empty()) {
       int num_args = 1;
       const char* arg_name = "name";
       unsigned char arg_type;
       unsigned long long arg_value;
-      trace_event_internal::SetTraceValue(it->second, &arg_type, &arg_value);
+      trace_event_internal::SetTraceValue(it->second, &arg_type, &arg_value,
+                                          NULL);
       logged_events_->AddEvent(TraceEvent(it->first,
           TimeTicks(), TRACE_EVENT_PHASE_METADATA,
           &g_category_enabled[g_category_metadata],
           "thread_name", trace_event_internal::kNoEventId,
-          num_args, &arg_name, &arg_type, &arg_value,
+          num_args, &arg_name, &arg_type, &arg_value, NULL,
           TRACE_EVENT_FLAG_NONE));
     }
   }
 }
 
 void TraceLog::InstallWaitableEventForSamplingTesting(
     WaitableEvent* waitable_event) {
   sampling_thread_->InstallWaitableEventForSamplingTesting(waitable_event);
 }
 
@@ skipping 39 matching lines @@
     name_ = name;
     TRACE_EVENT_API_ADD_TRACE_EVENT(
         TRACE_EVENT_PHASE_BEGIN,    // phase
         category_enabled_,          // category enabled
         name,                       // name
         0,                          // id
         0,                          // num_args
         NULL,                       // arg_names
         NULL,                       // arg_types
         NULL,                       // arg_values
+        NULL,                       // convertable_values
         TRACE_EVENT_FLAG_NONE);     // flags
   } else {
     category_enabled_ = NULL;
   }
 }
 
 ScopedTrace::~ScopedTrace() {
   if (category_enabled_ && *category_enabled_) {
     TRACE_EVENT_API_ADD_TRACE_EVENT(
         TRACE_EVENT_PHASE_END,   // phase
         category_enabled_,       // category enabled
         name_,                   // name
         0,                       // id
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
+        NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal