memory-infra: Start disentangling tracing from memory-infra

base/trace_event/memory_tracing_observer.cc

+// Copyright 2017 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/memory_tracing_observer.h"
+
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/trace_event_argument.h"
+
+namespace base {
+namespace trace_event {
+
+namespace {
+
+const int kTraceEventNumArgs = 1;
+const char* kTraceEventArgNames[] = {"dumps"};
+const unsigned char kTraceEventArgTypes[] = {TRACE_VALUE_TYPE_CONVERTABLE};
+
+};  // namespace
+
+MemoryTracingObserver::MemoryTracingObserver(
+    TraceLog* trace_log,
+    MemoryDumpManager* memory_dump_manager) {
+  enabled_ = false;

[Primiano Tucci (use gerrit), 2017/04/21 10:10:26]

initialize these in the ctor initializer list (Ctor(...) : foo(foo), bar(bar)
{... }) so they can be const, see other comment in the h file.

[hjd, 2017/04/21 11:51:58]

Done.

+  trace_log_ = trace_log;
+  memory_dump_manager_ = memory_dump_manager;
+
+  // DCHECK(memory_dump_manager_->IsInitialized());

[Primiano Tucci (use gerrit), 2017/04/21 10:10:27]

remove this?

[hjd, 2017/04/21 11:51:57]

Done, thanks!

+
+  // If tracing was enabled before initializing MemoryDumpManager, we missed the
+  // OnTraceLogEnabled() event. Synthetize it so we can late-join the party.
+  // IsEnabled is called before adding observer to avoid calling
+  // OnTraceLogEnabled twice.
+  bool is_tracing_already_enabled = trace_log_->IsEnabled();
+  trace_log_->AddEnabledStateObserver(this);
+  if (is_tracing_already_enabled)
+    OnTraceLogEnabled();
+}
+
+MemoryTracingObserver::~MemoryTracingObserver() {
+  trace_log_->RemoveEnabledStateObserver(this);
+}
+
+void MemoryTracingObserver::OnTraceLogEnabled() {
+  if (!IsMemoryInfraTracingEnabled())
+    return;
+
+  const TraceConfig& trace_config =
+      TraceLog::GetInstance()->GetCurrentTraceConfig();
+  const TraceConfig::MemoryDumpConfig& memory_dump_config =
+      trace_config.memory_dump_config();
+
+  enabled_ = true;
+  memory_dump_manager_->Enable(memory_dump_config);
+}
+
+void MemoryTracingObserver::OnTraceLogDisabled() {
+  if (!enabled_)

[Primiano Tucci (use gerrit), 2017/04/21 10:10:27]

this extra state seems to be here only to prevent to call MDM::Disable() if we
see this wihtout seein the enable() (which shouldn't happen really, given the
code above).
I'd remove the enabled_ here and instead make sure that MDM can just no-op in
case of double-disable.

[hjd, 2017/04/21 11:51:58]

Done.

+    return;
+  memory_dump_manager_->Disable();
+  enabled_ = false;
+}
+
+// static
+void MemoryTracingObserver::MaybeAddDumpToTrace(
+    const MemoryDumpRequestArgs* req_args,
+    const ProcessId pid,
+    const ProcessMemoryDump* process_memory_dump) {
+  if (!IsMemoryInfraTracingEnabled())
+    return;
+
+  const uint64_t dump_guid = req_args->dump_guid;
+
+  std::unique_ptr<TracedValue> traced_value(new TracedValue);
+  process_memory_dump->AsValueInto(traced_value.get());
+  traced_value->SetString("level_of_detail", MemoryDumpLevelOfDetailToString(
+                                                 req_args->level_of_detail));
+  const char* const event_name = MemoryDumpTypeToString(req_args->dump_type);
+
+  std::unique_ptr<ConvertableToTraceFormat> event_value(
+      std::move(traced_value));
+  TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
+      TRACE_EVENT_PHASE_MEMORY_DUMP,
+      TraceLog::GetCategoryGroupEnabled(MemoryDumpManager::kTraceCategory),
+      event_name, trace_event_internal::kGlobalScope, dump_guid, pid,
+      kTraceEventNumArgs, kTraceEventArgNames, kTraceEventArgTypes,
+      nullptr /* arg_values */, &event_value, TRACE_EVENT_FLAG_HAS_ID);
+}
+
+// static
+bool MemoryTracingObserver::IsMemoryInfraTracingEnabled() {
+  bool enabled;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(MemoryDumpManager::kTraceCategory,
+                                     &enabled);
+  return enabled;
+}
+
+}  // namespace trace_event
+}  // namespace base