Make base::PendingTask support ConvertableToTraceFormat

base/pending_task.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/pending_task.h"
 
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
 #include "base/tracked_objects.h"
+#include "base/values.h"
 
 namespace base {
 
+PendingTask::TracingInfo::TracingInfo(
+    const tracked_objects::Location& posted_from)
+    : posted_from_(posted_from) {
+#if DCHECK_IS_ON()
+  // TracingInfo should only be obtained when tracing is enabled or it will
+  // generate unnecessary copies.
+  bool tracing_enabled;

[caseq, 2016/09/29 22:46:36]

considering this is hot code, you really want to keep a static pointer to the
category, rather than do category lookup each time.

[gab, 2016/10/03 15:18:57]

This is only hot code if both (1) dchecks are enabled and (2) tracing is enabled
(as verified by this very dcheck). Which IMO means a developer who's testing
tracing (not using it for performance analysis as it doesn't make much sense to
do this in a trunk build with DCHECKs).

As such I think correctness is superior to performance here and
TRACE_EVENT_CATEGORY_GROUP_ENABLED() also isn't much of a performance issue when
tracing is enabled as it's called all over the place in that case.

+  TRACE_EVENT_CATEGORY_GROUP_ENABLED("toplevel", &tracing_enabled);
+  DCHECK(tracing_enabled);
+#endif  // DCHECK_IS_ON()
+}
+
+PendingTask::TracingInfo::~TracingInfo() = default;
+
+void PendingTask::TracingInfo::AppendAsTraceFormat(std::string* out) const {
+  DictionaryValue dict;
+  dict.SetString("src_file", posted_from_.file_name());
+  dict.SetString("src_func", posted_from_.function_name());
+  std::string tmp;
+  JSONWriter::Write(dict, &tmp);
+  out->append(tmp);
+}
+
 PendingTask::PendingTask(const tracked_objects::Location& posted_from,
                          base::Closure task)
     : base::TrackingInfo(posted_from, TimeTicks()),
       task(std::move(task)),
       posted_from(posted_from),
       sequence_num(0),
       nestable(true),
       is_high_res(false) {
 }
 
 PendingTask::PendingTask(const tracked_objects::Location& posted_from,
                          base::Closure task,
                          TimeTicks delayed_run_time,
                          bool nestable)
     : base::TrackingInfo(posted_from, delayed_run_time),
       task(std::move(task)),
       posted_from(posted_from),
       sequence_num(0),
       nestable(nestable),
       is_high_res(false) {
 }
 
 PendingTask::PendingTask(PendingTask&& other) = default;
 
-PendingTask::~PendingTask() {
-}
+PendingTask::~PendingTask() = default;
 
 PendingTask& PendingTask::operator=(PendingTask&& other) = default;
 
 bool PendingTask::operator<(const PendingTask& other) const {
   // Since the top of a priority queue is defined as the "greatest" element, we
   // need to invert the comparison here.  We want the smaller time to be at the
   // top of the heap.
 
   if (delayed_run_time < other.delayed_run_time)
     return false;
 
   if (delayed_run_time > other.delayed_run_time)
     return true;
 
   // If the times happen to match, then we use the sequence number to decide.
   // Compare the difference to support integer roll-over.
   return (sequence_num - other.sequence_num) > 0;
 }
 
+std::unique_ptr<trace_event::ConvertableToTraceFormat>
+PendingTask::GetTracingInfo() const {
+  return MakeUnique<TracingInfo>(posted_from);
+}
+
 }  // namespace base