base: Add blame context

base/trace_event/blame_context.cc

+// Copyright 2016 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/trace_event/blame_context.h"
+
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
+
+namespace base {
+namespace trace_event {
+
+BlameContext::BlameContext(const char* category,
+                           const char* name,
+                           const char* type,
+                           const char* scope,
+                           int64_t id,
+                           const BlameContext* parent_context)
+    : category_(category),
+      name_(name),
+      type_(type),
+      scope_(scope),
+      id_(id),
+      parent_scope_(parent_context ? parent_context->scope() : nullptr),
+      parent_id_(parent_context ? parent_context->id() : 0),
+#ifndef NDEBUG

[Primiano Tucci (use gerrit), 2016/03/21 17:12:55]

Should this be just:
#if DCHECK_IS_ON() ?

and use just DCHECK below when you actually want to check?
Otherwise you'll end up relying on the relationship between dcheck and debug=1
which is getting more and more losely copuled (e.g., dcheck_always_on,
crrev.com/1814423002).

Also that would also make the code more readable

[Sami, 2016/03/21 18:26:10]

Good idea, thanks. It turned out I still needed to guard the DCHECKs with
DCHECK_IS_ON() since otherwise they won't build in release mode. This looked a
little messy so I simplified to just reusing category_group_enabled_ for this.

+      was_initialized_(false),
+#endif
+      category_group_enabled_(nullptr) {
+  DCHECK(!parent_context || !std::strcmp(name_, parent_context->name()))
+      << "Parent blame context must have the same name";
+}
+
+BlameContext::~BlameContext() {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  TRACE_EVENT_API_ADD_TRACE_EVENT(
+      TRACE_EVENT_PHASE_DELETE_OBJECT, category_group_enabled_, type_, scope_,
+      id_, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID);
+  trace_event::TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
+}
+
+void BlameContext::Enter() {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_ENTER_CONTEXT,
+                                  category_group_enabled_, name_, scope_, id_,
+                                  0 /* num_args */, nullptr, nullptr, nullptr,
+                                  nullptr, TRACE_EVENT_FLAG_HAS_ID);
+}
+
+void BlameContext::Leave() {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_LEAVE_CONTEXT,
+                                  category_group_enabled_, name_, scope_, id_,
+                                  0 /* num_args */, nullptr, nullptr, nullptr,
+                                  nullptr, TRACE_EVENT_FLAG_HAS_ID);
+}
+
+void BlameContext::TakeSnapshot() {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  if (!*category_group_enabled_)

[Primiano Tucci (use gerrit), 2016/03/21 17:12:55]

Isn't TRACE_EVENT_API_ADD_TRACE_EVENT supposed to make this a no-op for you?
Or are you earlying out regardless for performance reasons?

[Sami, 2016/03/21 18:26:10]

Yes, it'll be a no-op, but I also want to avoid the work of preparing the
snapshot.

+    return;
+  scoped_ptr<trace_event::TracedValue> snapshot(new trace_event::TracedValue);
+  AsValueInto(snapshot.get());
+  static const char* kArgName = "snapshot";
+  const int kNumArgs = 1;
+  unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
+  scoped_ptr<trace_event::ConvertableToTraceFormat> arg_values[1] = {
+      std::move(snapshot)};
+  TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SNAPSHOT_OBJECT,
+                                  category_group_enabled_, type_, scope_, id_,
+                                  kNumArgs, &kArgName, arg_types, nullptr,
+                                  arg_values, TRACE_EVENT_FLAG_HAS_ID);
+}
+
+void BlameContext::OnTraceLogEnabled() {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  TakeSnapshot();
+}
+
+void BlameContext::OnTraceLogDisabled() {}
+
+void BlameContext::AsValueInto(trace_event::TracedValue* state) {
+#ifndef NDEBUG
+  DCHECK(was_initialized_);
+#endif
+  if (!parent_id_)
+    return;
+  state->BeginDictionary("parent");
+  state->SetString("id_ref", StringPrintf("0x%" PRIx64, parent_id_));
+  state->SetString("scope", parent_scope_);
+  state->EndDictionary();
+}
+
+void BlameContext::Initialize() {
+#ifndef NDEBUG
+  was_initialized_ = true;
+#endif
+  category_group_enabled_ =
+      TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_);
+  TRACE_EVENT_API_ADD_TRACE_EVENT(
+      TRACE_EVENT_PHASE_CREATE_OBJECT, category_group_enabled_, type_, scope_,
+      id_, 0, nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID);
+  trace_event::TraceLog::GetInstance()->AddEnabledStateObserver(this);
+  TakeSnapshot();
+}
+
+}  // namespace trace_event
+}  // namespace base