Allow tracing in third_party libraries

base/debug/trace_event.cc

 // 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.
 
 #include "base/debug/trace_event.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 29 matching lines @@
 // before throwing them away.
 const size_t kTraceEventBufferSize = 500000;
 const size_t kTraceEventBatchSize = 1000;
 
 #define TRACE_EVENT_MAX_CATEGORIES 100
 
 namespace {
 
 // Specify these values when the corresponding argument of AddTraceEvent is not
 // used.
-static const char* kNoArgName = NULL;
-static const int kNoArgValue = 0;
+static const int kZeroArgs = 0;
+static const char** kNoArgNames = NULL;
+static const uint8* kNoArgTypes = NULL;
+static const uint64* kNoArgValues = NULL;
 static const int kNoThreshholdBeginId = -1;
 static const int64 kNoThresholdValue = 0;
-static const int kNoEventId = 0;
+static const uint64 kNoEventId = 0;
 
-TraceCategory g_categories[TRACE_EVENT_MAX_CATEGORIES] = {
-  { "tracing already shutdown", false },
-  { "tracing categories exhausted; must increase TRACE_EVENT_MAX_CATEGORIES",
-    false },
-  { "__metadata",
-    false }
+// Parallel arrays g_categories and g_category_enabled are separate so that
+// a pointer to a member of g_category_enabled can be easily converted to an
+// index into g_categories. This allows macros to deal only with bool enabled
+// pointers from g_category_enabled, and we can convert internally to determine
+// the category name from the bool enabled pointer.
+const char* g_categories[TRACE_EVENT_MAX_CATEGORIES] = {
+  "tracing already shutdown",
+  "tracing categories exhausted; must increase TRACE_EVENT_MAX_CATEGORIES",
+  "__metadata",
 };
-const TraceCategory* const g_category_already_shutdown =
-    &g_categories[0];
-const TraceCategory* const g_category_categories_exhausted =
-    &g_categories[1];
-const TraceCategory* const g_category_metadata =
-    &g_categories[2];
+volatile bool g_category_enabled[TRACE_EVENT_MAX_CATEGORIES] = { false };
+const int g_category_already_shutdown = 0;
+const int g_category_categories_exhausted = 1;
+const int g_category_metadata = 2;
 int g_category_index = 3; // skip initial 3 categories
 
 // The most-recently captured name of the current thread
 LazyInstance<ThreadLocalPointer<const char>,
              LeakyLazyInstanceTraits<ThreadLocalPointer<const char> > >
     g_current_thread_name = LAZY_INSTANCE_INITIALIZER;
 
-}  // namespace
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// TraceValue
-//
-////////////////////////////////////////////////////////////////////////////////
-
-void TraceValue::AppendAsJSON(std::string* out) const {
+void AppendValueAsJSON(uint8 type,
+                       TraceEvent::TraceValue value,
+                       std::string* out) {
   std::string::size_type start_pos;
-  switch (type_) {
-    case TRACE_TYPE_BOOL:
-      *out += as_bool() ? "true" : "false";
+  switch (type) {
+    case TRACE_VALUE_TYPE_BOOL:
+      *out += value.as_bool ? "true" : "false";
       break;
-    case TRACE_TYPE_UINT:
-      StringAppendF(out, "%" PRIu64, as_uint());
+    case TRACE_VALUE_TYPE_UINT:
+      StringAppendF(out, "%" PRIu64, value.as_uint);
       break;
-    case TRACE_TYPE_INT:
-      StringAppendF(out, "%" PRId64, as_int());
+    case TRACE_VALUE_TYPE_INT:
+      StringAppendF(out, "%" PRId64, value.as_int);
       break;
-    case TRACE_TYPE_DOUBLE:
-      StringAppendF(out, "%f", as_double());
+    case TRACE_VALUE_TYPE_DOUBLE:
+      StringAppendF(out, "%f", value.as_double);
       break;
-    case TRACE_TYPE_POINTER:
+    case TRACE_VALUE_TYPE_POINTER:
       // JSON only supports double and int numbers.
       // So as not to lose bits from a 64-bit pointer, output as a hex string.
       StringAppendF(out, "\"%" PRIx64 "\"", static_cast<uint64>(
                                      reinterpret_cast<intptr_t>(
-                                     as_pointer())));
+                                     value.as_pointer)));
       break;
-    case TRACE_TYPE_STRING:
-    case TRACE_TYPE_STATIC_STRING:
+    case TRACE_VALUE_TYPE_STRING:
+    case TRACE_VALUE_TYPE_COPY_STRING:
       *out += "\"";
       start_pos = out->size();
-      *out += as_string() ? as_string() : "NULL";
+      *out += value.as_string ? value.as_string : "NULL";
       // insert backslash before special characters for proper json format.
       while ((start_pos = out->find_first_of("\\\"", start_pos)) !=
              std::string::npos) {
         out->insert(start_pos, 1, '\\');
         // skip inserted escape character and following character.
         start_pos += 2;
       }
       *out += "\"";
       break;
     default:
       NOTREACHED() << "Don't know how to print this value";
       break;
   }
 }
 
+}  // namespace
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceID
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TraceID::TraceID(void* rhs) {
-  data_ = base::debug::TraceLog::GetInstance()->GetIntraProcessID(
-      static_cast<uint64>(reinterpret_cast<uintptr_t>(rhs)));
+  data_ = TRACE_EVENT_API_GET_ID_FROM_POINTER(rhs);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceEvent
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
 size_t GetAllocLength(const char* str) { return str ? strlen(str) + 1 : 0; }
 
 // Copies |*member| into |*buffer|, sets |*member| to point to this new
 // location, and then advances |*buffer| by the amount written.
 void CopyTraceEventParameter(char** buffer,
                              const char** member,
                              const char* end) {
   if (*member) {
     size_t written = strlcpy(*buffer, *member, end - *buffer) + 1;
     DCHECK_LE(static_cast<int>(written), end - *buffer);
     *member = *buffer;
     *buffer += written;
   }
 }
 
 }  // namespace
 
 TraceEvent::TraceEvent()
     : id_(0u),
-      category_(NULL),
+      category_enabled_(NULL),
       name_(NULL),
       thread_id_(0),
       phase_(TRACE_EVENT_PHASE_BEGIN),
       flags_(0) {
   arg_names_[0] = NULL;
   arg_names_[1] = NULL;
 }
 
 TraceEvent::TraceEvent(int thread_id,
                        TimeTicks timestamp,
-                       TraceEventPhase phase,
-                       const TraceCategory* category,
+                       char phase,
+                       const volatile bool* category_enabled,
                        const char* name,
-                       TraceID id,
-                       const char* arg1_name, const TraceValue& arg1_val,
-                       const char* arg2_name, const TraceValue& arg2_val,
-                       TraceEventFlags flags)
+                       uint64 id,
+                       int num_args,
+                       const char** arg_names,
+                       const uint8* arg_types,
+                       const uint64* arg_values,
+                       uint8 flags)
     : timestamp_(timestamp),
       id_(id),
-      category_(category),
+      category_enabled_(category_enabled),
       name_(name),
       thread_id_(thread_id),
       phase_(phase),
       flags_(flags) {
-  COMPILE_ASSERT(kTraceMaxNumArgs == 2, TraceEvent_arg_count_out_of_sync);
-  arg_names_[0] = arg1_name;
-  arg_names_[1] = arg2_name;
-  arg_values_[0] = arg1_val;
-  arg_values_[1] = arg2_val;
+  // 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];
+  }
+  for (; i < kTraceMaxNumArgs; ++i) {
+    arg_names_[i] = NULL;
+    arg_values_[i].as_uint = 0u;
+    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);
-    alloc_size += GetAllocLength(arg1_name);
-    alloc_size += GetAllocLength(arg2_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 arg1_is_copy = (arg1_val.type() == TraceValue::TRACE_TYPE_STRING);
-  bool arg2_is_copy = (arg2_val.type() == TraceValue::TRACE_TYPE_STRING);
-
-  // We only take a copy of arg_vals if they are of type string (not static
-  // string), regardless of the |copy| flag.
-  if (arg1_is_copy)
-    alloc_size += GetAllocLength(arg1_val.as_string());
-  if (arg2_is_copy)
-    alloc_size += GetAllocLength(arg2_val.as_string());
+  bool arg_is_copy[kTraceMaxNumArgs];
+  for (i = 0; i < num_args; ++i) {
+    // 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 base::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);
-      CopyTraceEventParameter(&ptr, &arg_names_[0], end);
-      CopyTraceEventParameter(&ptr, &arg_names_[1], end);
+      for (i = 0; i < num_args; ++i)
+        CopyTraceEventParameter(&ptr, &arg_names_[i], end);
     }
-    if (arg1_is_copy)
-      CopyTraceEventParameter(&ptr, arg_values_[0].as_assignable_string(), end);
-    if (arg2_is_copy)
-      CopyTraceEventParameter(&ptr, arg_values_[1].as_assignable_string(), end);
+    for (i = 0; i < num_args; ++i) {
+      if (arg_is_copy[i])
+        CopyTraceEventParameter(&ptr, &arg_values_[i].as_string, end);
+    }
     DCHECK_EQ(end, ptr) << "Overrun by " << ptr - end;
   }
 }
 
 TraceEvent::~TraceEvent() {
 }
 
 void TraceEvent::AppendEventsAsJSON(const std::vector<TraceEvent>& events,
                                     size_t start,
                                     size_t count,
                                     std::string* out) {
   for (size_t i = 0; i < count && start + i < events.size(); ++i) {
     if (i > 0)
       *out += ",";
     events[i + start].AppendAsJSON(out);
   }
 }
 
 void TraceEvent::AppendAsJSON(std::string* out) const {
-  const char phase_char = GetPhaseChar(phase_);
   int64 time_int64 = timestamp_.ToInternalValue();
   int process_id = TraceLog::GetInstance()->process_id();
   // Category name checked at category creation time.
   DCHECK(!strchr(name_, '"'));
   StringAppendF(out,
       "{\"cat\":\"%s\",\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64 ","
       "\"ph\":\"%c\",\"name\":\"%s\",\"args\":{",
-      category_->name,
+      TraceLog::GetCategoryName(category_enabled_),
       process_id,
       thread_id_,
       time_int64,
-      phase_char,
+      phase_,
       name_);
 
   // Output argument names and values, stop at first NULL argument name.
-  for (size_t i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
+  for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
     if (i > 0)
       *out += ",";
     *out += "\"";
     *out += arg_names_[i];
     *out += "\":";
-    arg_values_[i].AppendAsJSON(out);
+    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 "\"", id_.data());
+    StringAppendF(out, ",\"id\":\"%" PRIx64 "\"", id_);
   *out += "}";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceResultBuffer
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TraceResultBuffer::OutputCallback
@@ skipping 45 matching lines @@
 }
 
 TraceLog::TraceLog()
     : enabled_(false) {
   SetProcessID(static_cast<int>(base::GetCurrentProcId()));
 }
 
 TraceLog::~TraceLog() {
 }
 
-const TraceCategory* TraceLog::GetCategory(const char* name) {
+const volatile bool* TraceLog::GetCategoryEnabled(const char* name) {
   TraceLog* tracelog = GetInstance();
   if (!tracelog){
-    DCHECK(!g_category_already_shutdown->enabled);
-    return g_category_already_shutdown;
+    DCHECK(!g_category_enabled[g_category_already_shutdown]);
+    return &g_category_enabled[g_category_already_shutdown];
   }
-  return tracelog->GetCategoryInternal(name);
+  return tracelog->GetCategoryEnabledInternal(name);
+}
+
+const char* TraceLog::GetCategoryName(const volatile bool* category_enabled) {
+  // Calculate the index of the category by finding category_enabled in
+  // g_category_enabled array.
+  uintptr_t category_begin = reinterpret_cast<uintptr_t>(g_category_enabled);
+  uintptr_t category_ptr = reinterpret_cast<uintptr_t>(category_enabled);
+  DCHECK(category_ptr >= category_begin &&
+         category_ptr < reinterpret_cast<uintptr_t>(g_category_enabled +
+                                               TRACE_EVENT_MAX_CATEGORIES)) <<
+      "out of bounds category pointer";
+  uintptr_t category_index =
+      (category_ptr - category_begin) / sizeof(g_category_enabled[0]);
+  return g_categories[category_index];
 }
 
 static void EnableMatchingCategory(int category_index,
                                    const std::vector<std::string>& patterns,
                                    bool is_included) {
   std::vector<std::string>::const_iterator ci = patterns.begin();
   bool is_match = false;
   for (; ci != patterns.end(); ++ci) {
-    is_match = MatchPattern(g_categories[category_index].name, ci->c_str());
+    is_match = MatchPattern(g_categories[category_index], ci->c_str());
     if (is_match)
       break;
   }
-  ANNOTATE_BENIGN_RACE(&g_categories[category_index].enabled,
+  ANNOTATE_BENIGN_RACE(&g_category_enabled[category_index],
                        "trace_event category enabled");
-  g_categories[category_index].enabled = is_match ? is_included : !is_included;
+  g_category_enabled[category_index] = is_match ? is_included : !is_included;
 }
 
 // Enable/disable each category based on the category filters in |patterns|.
 // If the category name matches one of the patterns, its enabled status is set
 // to |is_included|. Otherwise its enabled status is set to !|is_included|.
 static void EnableMatchingCategories(const std::vector<std::string>& patterns,
                                      bool is_included) {
   for (int i = 0; i < g_category_index; i++)
     EnableMatchingCategory(i, patterns, is_included);
 }
 
-const TraceCategory* TraceLog::GetCategoryInternal(const char* name) {
+const volatile bool* TraceLog::GetCategoryEnabledInternal(const char* name) {
   AutoLock lock(lock_);
   DCHECK(!strchr(name, '"')) << "Category names may not contain double quote";
 
   // Search for pre-existing category matching this name
   for (int i = 0; i < g_category_index; i++) {
-    if (strcmp(g_categories[i].name, name) == 0)
-      return &g_categories[i];
+    if (strcmp(g_categories[i], name) == 0)
+      return &g_category_enabled[i];
   }
 
   // Create a new category
   DCHECK(g_category_index < TRACE_EVENT_MAX_CATEGORIES) <<
       "must increase TRACE_EVENT_MAX_CATEGORIES";
   if (g_category_index < TRACE_EVENT_MAX_CATEGORIES) {
     int new_index = g_category_index++;
-    g_categories[new_index].name = name;
-    DCHECK(!g_categories[new_index].enabled);
+    g_categories[new_index] = name;
+    DCHECK(!g_category_enabled[new_index]);
     if (enabled_) {
       // Note that if both included and excluded_categories are empty, the else
       // clause below excludes nothing, thereby enabling this category.
       if (!included_categories_.empty())
         EnableMatchingCategory(new_index, included_categories_, true);
       else
         EnableMatchingCategory(new_index, excluded_categories_, false);
     } else {
-      ANNOTATE_BENIGN_RACE(&g_categories[new_index].enabled,
+      ANNOTATE_BENIGN_RACE(&g_category_enabled[new_index],
                            "trace_event category enabled");
-      g_categories[new_index].enabled = false;
+      g_category_enabled[new_index] = false;
     }
-    return &g_categories[new_index];
+    return &g_category_enabled[new_index];
   } else {
-    return g_category_categories_exhausted;
+    return &g_category_enabled[g_category_categories_exhausted];
   }
 }
 
 void TraceLog::GetKnownCategories(std::vector<std::string>* categories) {
   AutoLock lock(lock_);
   for (int i = 0; i < g_category_index; i++)
-    categories->push_back(g_categories[i].name);
+    categories->push_back(g_categories[i]);
 }
 
 void TraceLog::SetEnabled(const std::vector<std::string>& included_categories,
                           const std::vector<std::string>& excluded_categories) {
   AutoLock lock(lock_);
   if (enabled_)
     return;
   logged_events_.reserve(1024);
   enabled_ = true;
   included_categories_ = included_categories;
@@ skipping 40 matching lines @@
 void TraceLog::SetDisabled() {
   {
     AutoLock lock(lock_);
     if (!enabled_)
       return;
 
     enabled_ = false;
     included_categories_.clear();
     excluded_categories_.clear();
     for (int i = 0; i < g_category_index; i++)
-      g_categories[i].enabled = false;
+      g_category_enabled[i] = false;
     AddThreadNameMetadataEvents();
     AddClockSyncMetadataEvents();
   }  // release lock
   Flush();
 }
 
 void TraceLog::SetEnabled(bool enabled) {
   if (enabled)
     SetEnabled(std::vector<std::string>(), std::vector<std::string>());
   else
@@ skipping 32 matching lines @@
     scoped_refptr<RefCountedString> json_events_str_ptr =
         new RefCountedString();
     TraceEvent::AppendEventsAsJSON(previous_logged_events,
                                    i,
                                    kTraceEventBatchSize,
                                    &(json_events_str_ptr->data));
     output_callback_copy.Run(json_events_str_ptr);
   }
 }
 
-int TraceLog::AddTraceEvent(TraceEventPhase phase,
-                            const TraceCategory* category,
+int TraceLog::AddTraceEvent(char phase,
+                            const volatile bool* category_enabled,
                             const char* name,
-                            TraceID id,
-                            const char* arg1_name, TraceValue arg1_val,
-                            const char* arg2_name, TraceValue arg2_val,
+                            uint64 id,
+                            int num_args,
+                            const char** arg_names,
+                            const uint8* arg_types,
+                            const uint64* arg_values,
                             int threshold_begin_id,
                             int64 threshold,
-                            TraceEventFlags flags) {
+                            uint8 flags) {
   DCHECK(name);
   TimeTicks now = TimeTicks::HighResNow();
   BufferFullCallback buffer_full_callback_copy;
   int ret_begin_id = -1;
   {
     AutoLock lock(lock_);
-    if (!category->enabled)
+    if (!*category_enabled)
       return -1;
     if (logged_events_.size() >= kTraceEventBufferSize)
       return -1;
 
     int thread_id = static_cast<int>(PlatformThread::CurrentId());
 
     const char* new_name = PlatformThread::GetName();
     // Check if the thread name has been set or changed since the previous
     // call (if any), but don't bother if the new name is empty. Note this will
     // not detect a thread name change within the same char* buffer address: we
@@ skipping 33 matching lines @@
         // Remove begin event and do not add end event.
         // This will be expensive if there have been other events in the
         // mean time (should be rare).
         logged_events_.erase(logged_events_.begin() + begin_i);
         return -1;
       }
     }
     ret_begin_id = static_cast<int>(logged_events_.size());
     logged_events_.push_back(
         TraceEvent(thread_id,
-                   now, phase, category, name, id,
-                   arg1_name, arg1_val,
-                   arg2_name, arg2_val,
+                   now, phase, category_enabled, name, id,
+                   num_args, arg_names, arg_types, arg_values,
                    flags));
 
     if (logged_events_.size() == kTraceEventBufferSize) {
       buffer_full_callback_copy = buffer_full_callback_;
     }
   }  // release lock
 
   if (!buffer_full_callback_copy.is_null())
     buffer_full_callback_copy.Run();
 
   return ret_begin_id;
 }
 
-void TraceLog::AddTraceEventEtw(TraceEventPhase phase,
+void TraceLog::AddTraceEventEtw(char phase,
                                 const char* name,
                                 const void* id,
                                 const char* extra) {
 #if defined(OS_WIN)
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
-  INTERNAL_TRACE_EVENT_ADD(phase,
-      "ETW Trace Event", name, "id", id, "extra", TRACE_STR_COPY(extra),
-      TRACE_EVENT_FLAG_COPY);
+  INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
+                           TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
 }
 
-void TraceLog::AddTraceEventEtw(TraceEventPhase phase,
+void TraceLog::AddTraceEventEtw(char phase,
                                 const char* name,
                                 const void* id,
                                 const std::string& extra)
 {
 #if defined(OS_WIN)
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
-  INTERNAL_TRACE_EVENT_ADD(phase,
-      "ETW Trace Event", name, "id", id, "extra", extra,
-      TRACE_EVENT_FLAG_COPY);
+  INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
+                           TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
 }
 
-int TraceLog::AddCounterEvent(const TraceCategory* category,
-                              const char* name,
-                              TraceID id,
-                              const char* value1_name, int32 value1_val,
-                              const char* value2_name, int32 value2_val,
-                              TraceEventFlags flags) {
-  return AddTraceEvent(TRACE_EVENT_PHASE_COUNTER,
-                       category,
-                       name,
-                       id,
-                       value1_name, value1_val,
-                       value2_name, value2_val,
-                       -1, 0,
-                       flags);
+void TraceLog::AddCounterEvent(const volatile bool* category_enabled,
+                               const char* name,
+                               uint64 id,
+                               const char* value1_name, int32 value1_val,
+                               const char* value2_name, int32 value2_val,
+                               uint8 flags) {
+  int num_args = value2_name ? 2 : 1;
+  const char* arg_names[2] = {value1_name, value2_name};
+  uint8 arg_types[2];
+  uint64 arg_values[2];
+  base::debug::internal::SetTraceValue(value1_val, &arg_types[0],
+                                       &arg_values[0]);
+  base::debug::internal::SetTraceValue(value2_val, &arg_types[1],
+                                       &arg_values[1]);
+  AddTraceEvent(TRACE_EVENT_PHASE_COUNTER,
+                category_enabled,
+                name,
+                id,
+                num_args,
+                arg_names,
+                arg_types,
+                arg_values,
+                kNoThreshholdBeginId, kNoThresholdValue,
+                flags);
 }
 
 void TraceLog::AddClockSyncMetadataEvents() {
 #if defined(OS_ANDROID)
   // Since Android does not support sched_setaffinity, we cannot establish clock
   // sync unless the scheduler clock is set to global. If the trace_clock file
   // can't be read, we will assume the kernel doesn't support tracing and do
   // nothing.
   std::string clock_mode;
   if (!file_util::ReadFileToString(
@@ skipping 26 matching lines @@
     return;
   }
 #endif
 }
 
 void TraceLog::AddThreadNameMetadataEvents() {
   lock_.AssertAcquired();
   for(base::hash_map<int, std::string>::iterator it = thread_names_.begin();
       it != thread_names_.end();
       it++) {
-    if (!it->second.empty())
+    if (!it->second.empty()) {
+      int num_args = 1;
+      const char* arg_name = "name";
+      uint8 arg_type;
+      uint64 arg_value;
+      base::debug::internal::SetTraceValue(it->second, &arg_type, &arg_value);
       logged_events_.push_back(
           TraceEvent(it->first,
                      TimeTicks(), TRACE_EVENT_PHASE_METADATA,
-                     g_category_metadata, "thread_name", 0,
-                     "name", it->second,
-                     NULL, 0,
+                     &g_category_enabled[g_category_metadata],
+                     "thread_name", kNoEventId,
+                     num_args, &arg_name, &arg_type, &arg_value,
                      TRACE_EVENT_FLAG_NONE));
+    }
   }
 }
 
 void TraceLog::DeleteForTesting() {
   DeleteTraceLogForTesting::Delete();
 }
 
 void TraceLog::Resurrect() {
   StaticMemorySingletonTraits<TraceLog>::Resurrect();
 }
 
 void TraceLog::SetProcessID(int process_id) {
   process_id_ = process_id;
   // Create a FNV hash from the process ID for XORing.
   // See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
   uint64 offset_basis = 14695981039346656037ull;
   uint64 fnv_prime = 1099511628211ull;
   unsigned long long pid = static_cast<unsigned long long>(process_id_);
   process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
 }
 
 namespace internal {
 
-void TraceEndOnScopeClose::Initialize(const TraceCategory* category,
+void TraceEndOnScopeClose::Initialize(const volatile bool* category_enabled,
                                       const char* name) {
-  data_.category = category;
+  data_.category_enabled = category_enabled;
   data_.name = name;
   p_data_ = &data_;
 }
 
 void TraceEndOnScopeClose::AddEventIfEnabled() {
   // Only called when p_data_ is non-null.
-  if (p_data_->category->enabled) {
-    base::debug::TraceLog::GetInstance()->AddTraceEvent(
+  if (*p_data_->category_enabled) {
+    TRACE_EVENT_API_ADD_TRACE_EVENT(
         TRACE_EVENT_PHASE_END,
-        p_data_->category,
+        p_data_->category_enabled,
         p_data_->name, kNoEventId,
-        kNoArgName, kNoArgValue, kNoArgName, kNoArgValue,
+        kZeroArgs, kNoArgNames, kNoArgTypes, kNoArgValues,
         kNoThreshholdBeginId, kNoThresholdValue, TRACE_EVENT_FLAG_NONE);
   }
 }
 
-void TraceEndOnScopeCloseThreshold::Initialize(const TraceCategory* category,
-                                               const char* name,
-                                               int threshold_begin_id,
-                                               int64 threshold) {
-  data_.category = category;
+void TraceEndOnScopeCloseThreshold::Initialize(
+                                      const volatile bool* category_enabled,
+                                      const char* name,
+                                      int threshold_begin_id,
+                                      int64 threshold) {
+  data_.category_enabled = category_enabled;
   data_.name = name;
   data_.threshold_begin_id = threshold_begin_id;
   data_.threshold = threshold;
   p_data_ = &data_;
 }
 
 void TraceEndOnScopeCloseThreshold::AddEventIfEnabled() {
   // Only called when p_data_ is non-null.
-  if (p_data_->category->enabled) {
-    base::debug::TraceLog::GetInstance()->AddTraceEvent(
+  if (*p_data_->category_enabled) {
+    TRACE_EVENT_API_ADD_TRACE_EVENT(
         TRACE_EVENT_PHASE_END,
-        p_data_->category,
+        p_data_->category_enabled,
         p_data_->name, kNoEventId,
-        kNoArgName, kNoArgValue, kNoArgName, kNoArgValue,
+        kZeroArgs, kNoArgNames, kNoArgTypes, kNoArgValues,
         p_data_->threshold_begin_id, p_data_->threshold,
         TRACE_EVENT_FLAG_NONE);
   }
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base