Split up trace_event.h into trace_event_impl.h and add webkitplatform support.

base/debug/trace_event.cc

Index: base/debug/trace_event.cc
diff --git a/base/debug/trace_event.cc b/base/debug/trace_event.cc
index c5547697ee822920492f7ef7f1cf0e50b7f9843c..be77d5ac298287c376f897c41fd7b842330cb394 100644
--- a/base/debug/trace_event.cc
+++ b/base/debug/trace_event.cc
@@ -4,747 +4,6 @@
 
 #include "base/debug/trace_event.h"
 
-#include <algorithm>
-
-#include "base/bind.h"
-#include "base/file_util.h"
-#include "base/format_macros.h"
-#include "base/lazy_instance.h"
-#include "base/memory/singleton.h"
-#include "base/process_util.h"
-#include "base/stringprintf.h"
-#include "base/string_tokenizer.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local.h"
-#include "base/utf_string_conversions.h"
-#include "base/stl_util.h"
-#include "base/sys_info.h"
-#include "base/time.h"
-
-#if defined(OS_WIN)
-#include "base/debug/trace_event_win.h"
-#endif
-
-class DeleteTraceLogForTesting {
- public:
-  static void Delete() {
-    Singleton<base::debug::TraceLog,
-              StaticMemorySingletonTraits<base::debug::TraceLog> >::OnExit(0);
-  }
-};
-
-namespace base {
-namespace debug {
-
-// Controls the number of trace events we will buffer in-memory
-// before throwing them away.
-const size_t kTraceEventBufferSize = 500000;
-const size_t kTraceEventBatchSize = 1000;
-
-#define TRACE_EVENT_MAX_CATEGORIES 100
-
-namespace {
-
-// 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 char enabled
-// pointers from g_category_enabled, and we can convert internally to determine
-// the category name from the char enabled pointer.
-const char* g_categories[TRACE_EVENT_MAX_CATEGORIES] = {
-  "tracing already shutdown",
-  "tracing categories exhausted; must increase TRACE_EVENT_MAX_CATEGORIES",
-  "__metadata",
-};
-// The enabled flag is char instead of bool so that the API can be used from C.
-unsigned char g_category_enabled[TRACE_EVENT_MAX_CATEGORIES] = { 0 };
-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;
-
-void AppendValueAsJSON(unsigned char type,
-                       TraceEvent::TraceValue value,
-                       std::string* out) {
-  std::string::size_type start_pos;
-  switch (type) {
-    case TRACE_VALUE_TYPE_BOOL:
-      *out += value.as_bool ? "true" : "false";
-      break;
-    case TRACE_VALUE_TYPE_UINT:
-      StringAppendF(out, "%" PRIu64, static_cast<uint64>(value.as_uint));
-      break;
-    case TRACE_VALUE_TYPE_INT:
-      StringAppendF(out, "%" PRId64, static_cast<int64>(value.as_int));
-      break;
-    case TRACE_VALUE_TYPE_DOUBLE:
-      StringAppendF(out, "%f", value.as_double);
-      break;
-    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>(
-                                     value.as_pointer)));
-      break;
-    case TRACE_VALUE_TYPE_STRING:
-    case TRACE_VALUE_TYPE_COPY_STRING:
-      *out += "\"";
-      start_pos = out->size();
-      *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
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// 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_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,
-                       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)
-    : 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];
-  }
-  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);
-    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) {
-    // 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);
-      for (i = 0; i < num_args; ++i)
-        CopyTraceEventParameter(&ptr, &arg_names_[i], 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 {
-  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\":{",
-      TraceLog::GetCategoryName(category_enabled_),
-      process_id,
-      thread_id_,
-      time_int64,
-      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);
-  }
-  *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_));
-  *out += "}";
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// TraceResultBuffer
-//
-////////////////////////////////////////////////////////////////////////////////
-
-TraceResultBuffer::OutputCallback
-    TraceResultBuffer::SimpleOutput::GetCallback() {
-  return base::Bind(&SimpleOutput::Append, base::Unretained(this));
-}
-
-void TraceResultBuffer::SimpleOutput::Append(
-    const std::string& json_trace_output) {
-  json_output += json_trace_output;
-}
-
-TraceResultBuffer::TraceResultBuffer() : append_comma_(false) {
-}
-
-TraceResultBuffer::~TraceResultBuffer() {
-}
-
-void TraceResultBuffer::SetOutputCallback(
-    const OutputCallback& json_chunk_callback) {
-  output_callback_ = json_chunk_callback;
-}
-
-void TraceResultBuffer::Start() {
-  append_comma_ = false;
-  output_callback_.Run("[");
-}
-
-void TraceResultBuffer::AddFragment(const std::string& trace_fragment) {
-  if (append_comma_)
-    output_callback_.Run(",");
-  append_comma_ = true;
-  output_callback_.Run(trace_fragment);
-}
-
-void TraceResultBuffer::Finish() {
-  output_callback_.Run("]");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// TraceLog
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// static
-TraceLog* TraceLog::GetInstance() {
-  return Singleton<TraceLog, StaticMemorySingletonTraits<TraceLog> >::get();
-}
-
-TraceLog::TraceLog()
-    : enabled_(false) {
-  SetProcessID(static_cast<int>(base::GetCurrentProcId()));
-}
-
-TraceLog::~TraceLog() {
-}
-
-const unsigned char* TraceLog::GetCategoryEnabled(const char* name) {
-  TraceLog* tracelog = GetInstance();
-  if (!tracelog) {
-    DCHECK(!g_category_enabled[g_category_already_shutdown]);
-    return &g_category_enabled[g_category_already_shutdown];
-  }
-  return tracelog->GetCategoryEnabledInternal(name);
-}
-
-const char* TraceLog::GetCategoryName(const unsigned char* 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,
-                                   unsigned char 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], ci->c_str());
-    if (is_match)
-      break;
-  }
-  ANNOTATE_BENIGN_RACE(&g_category_enabled[category_index],
-                       "trace_event category enabled");
-  g_category_enabled[category_index] = is_match ?
-      is_included : (is_included ^ 1);
-}
-
-// 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,
-                                     unsigned char is_included) {
-  for (int i = 0; i < g_category_index; i++)
-    EnableMatchingCategory(i, patterns, is_included);
-}
-
-const unsigned char* 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) == 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;
-    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_, 1);
-      else
-        EnableMatchingCategory(new_index, excluded_categories_, 0);
-    } else {
-      ANNOTATE_BENIGN_RACE(&g_category_enabled[new_index],
-                           "trace_event category enabled");
-      g_category_enabled[new_index] = 0;
-    }
-    return &g_category_enabled[new_index];
-  } else {
-    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]);
-}
-
-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;
-  excluded_categories_ = excluded_categories;
-  // Note that if both included and excluded_categories are empty, the else
-  // clause below excludes nothing, thereby enabling all categories.
-  if (!included_categories_.empty())
-    EnableMatchingCategories(included_categories_, 1);
-  else
-    EnableMatchingCategories(excluded_categories_, 0);
-}
-
-void TraceLog::SetEnabled(const std::string& categories) {
-  std::vector<std::string> included, excluded;
-  // Tokenize list of categories, delimited by ','.
-  StringTokenizer tokens(categories, ",");
-  while (tokens.GetNext()) {
-    bool is_included = true;
-    std::string category = tokens.token();
-    // Excluded categories start with '-'.
-    if (category.at(0) == '-') {
-      // Remove '-' from category string.
-      category = category.substr(1);
-      is_included = false;
-    }
-    if (is_included)
-      included.push_back(category);
-    else
-      excluded.push_back(category);
-  }
-  SetEnabled(included, excluded);
-}
-
-void TraceLog::GetEnabledTraceCategories(
-    std::vector<std::string>* included_out,
-    std::vector<std::string>* excluded_out) {
-  AutoLock lock(lock_);
-  if (enabled_) {
-    *included_out = included_categories_;
-    *excluded_out = excluded_categories_;
-  }
-}
-
-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_category_enabled[i] = 0;
-    AddThreadNameMetadataEvents();
-    AddClockSyncMetadataEvents();
-  }  // release lock
-  Flush();
-}
-
-void TraceLog::SetEnabled(bool enabled) {
-  if (enabled)
-    SetEnabled(std::vector<std::string>(), std::vector<std::string>());
-  else
-    SetDisabled();
-}
-
-float TraceLog::GetBufferPercentFull() const {
-  return (float)((double)logged_events_.size()/(double)kTraceEventBufferSize);
-}
-
-void TraceLog::SetOutputCallback(const TraceLog::OutputCallback& cb) {
-  AutoLock lock(lock_);
-  output_callback_ = cb;
-}
-
-void TraceLog::SetBufferFullCallback(const TraceLog::BufferFullCallback& cb) {
-  AutoLock lock(lock_);
-  buffer_full_callback_ = cb;
-}
-
-void TraceLog::Flush() {
-  std::vector<TraceEvent> previous_logged_events;
-  OutputCallback output_callback_copy;
-  {
-    AutoLock lock(lock_);
-    previous_logged_events.swap(logged_events_);
-    output_callback_copy = output_callback_;
-  }  // release lock
-
-  if (output_callback_copy.is_null())
-    return;
-
-  for (size_t i = 0;
-       i < previous_logged_events.size();
-       i += kTraceEventBatchSize) {
-    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(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,
-                            int threshold_begin_id,
-                            long long threshold,
-                            unsigned char flags) {
-  DCHECK(name);
-  TimeTicks now = TimeTicks::HighResNow();
-  BufferFullCallback buffer_full_callback_copy;
-  int ret_begin_id = -1;
-  {
-    AutoLock lock(lock_);
-    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
-    // favor common case performance over corner case correctness.
-    if (new_name != g_current_thread_name.Get().Get() &&
-        new_name && *new_name) {
-      g_current_thread_name.Get().Set(new_name);
-      base::hash_map<int, std::string>::iterator existing_name =
-          thread_names_.find(thread_id);
-      if (existing_name == thread_names_.end()) {
-        // This is a new thread id, and a new name.
-        thread_names_[thread_id] = new_name;
-      } else {
-        // This is a thread id that we've seen before, but potentially with a
-        // new name.
-        std::vector<base::StringPiece> existing_names;
-        Tokenize(existing_name->second, ",", &existing_names);
-        bool found = std::find(existing_names.begin(),
-                               existing_names.end(),
-                               new_name) != existing_names.end();
-        if (!found) {
-          existing_name->second.push_back(',');
-          existing_name->second.append(new_name);
-        }
-      }
-    }
-
-    if (threshold_begin_id > -1) {
-      DCHECK(phase == TRACE_EVENT_PHASE_END);
-      size_t begin_i = static_cast<size_t>(threshold_begin_id);
-      // Return now if there has been a flush since the begin event was posted.
-      if (begin_i >= logged_events_.size())
-        return -1;
-      // Determine whether to drop the begin/end pair.
-      TimeDelta elapsed = now - logged_events_[begin_i].timestamp();
-      if (elapsed < TimeDelta::FromMicroseconds(threshold)) {
-        // 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_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(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,
-                           TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
-}
-
-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,
-                           TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
-}
-
-void TraceLog::AddCounterEvent(const unsigned char* category_enabled,
-                               const char* name,
-                               unsigned long long id,
-                               const char* value1_name, int value1_val,
-                               const char* value2_name, int value2_val,
-                               unsigned char flags) {
-  int num_args = value2_name ? 2 : 1;
-  const char* arg_names[2] = {value1_name, value2_name};
-  unsigned char arg_types[2];
-  unsigned long long arg_values[2];
-  trace_event_internal::SetTraceValue(value1_val, &arg_types[0],
-                                      &arg_values[0]);
-  trace_event_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,
-                trace_event_internal::kNoThreshholdBeginId,
-                trace_event_internal::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(
-          FilePath("/sys/kernel/debug/tracing/trace_clock"),
-          &clock_mode))
-    return;
-
-  if (clock_mode != "local [global]\n") {
-    DLOG(WARNING) <<
-        "The kernel's tracing clock must be set to global in order for " <<
-        "trace_event to be synchronized with . Do this by\n" <<
-        "  echo global > /sys/kerel/debug/tracing/trace_clock";
-    return;
-  }
-
-  // Android's kernel trace system has a trace_marker feature: this is a file on
-  // debugfs that takes the written data and pushes it onto the trace
-  // buffer. So, to establish clock sync, we write our monotonic clock into that
-  // trace buffer.
-  TimeTicks now = TimeTicks::HighResNow();
-
-  double now_in_seconds = now.ToInternalValue() / 1000000.0;
-  std::string marker =
-      StringPrintf("trace_event_clock_sync: parent_ts=%f\n",
-                   now_in_seconds);
-  if (file_util::WriteFile(
-          FilePath("/sys/kernel/debug/tracing/trace_marker"),
-          marker.c_str(), marker.size()) == -1) {
-    DLOG(WARNING) << "Couldn't write to /sys/kernel/debug/tracing/trace_marker";
-    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()) {
-      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);
-      logged_events_.push_back(
-          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,
-                     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.
-  unsigned long long offset_basis = 14695981039346656037ull;
-  unsigned long long fnv_prime = 1099511628211ull;
-  unsigned long long pid = static_cast<unsigned long long>(process_id_);
-  process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
-}
-
-}  // namespace debug
-}  // namespace base
-
 namespace trace_event_internal {
 
 void TraceEndOnScopeClose::Initialize(const unsigned char* category_enabled,