Remove memory category from chrome://tracing

base/trace_event/trace_event_memory.cc

Index: base/trace_event/trace_event_memory.cc
diff --git a/base/trace_event/trace_event_memory.cc b/base/trace_event/trace_event_memory.cc
deleted file mode 100644
index 187bf7469bff0fe26e6847a90873fb4f02536141..0000000000000000000000000000000000000000
--- a/base/trace_event/trace_event_memory.cc
+++ /dev/null
@@ -1,438 +0,0 @@
-// Copyright 2013 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/trace_event_memory.h"
-
-#include <utility>
-
-#include "base/debug/leak_annotations.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "base/threading/thread_local_storage.h"
-#include "base/trace_event/trace_event.h"
-
-namespace base {
-namespace trace_event {
-
-namespace {
-
-// Maximum number of nested TRACE_EVENT scopes to record. Must be less than
-// or equal to HeapProfileTable::kMaxStackDepth / 2 because we record two
-// entries on the pseudo-stack per scope.
-const size_t kMaxScopeDepth = 16;
-
-/////////////////////////////////////////////////////////////////////////////
-// Holds a memory dump until the tracing system needs to serialize it.
-class MemoryDumpHolder : public base::trace_event::ConvertableToTraceFormat {
- public:
-  // Takes ownership of dump, which must be a JSON string, allocated with
-  // malloc() and NULL terminated.
-  explicit MemoryDumpHolder(char* dump) : dump_(dump) {}
-
-  // base::trace_event::ConvertableToTraceFormat overrides:
-  void AppendAsTraceFormat(std::string* out) const override {
-    AppendHeapProfileAsTraceFormat(dump_, out);
-  }
-
- private:
-  ~MemoryDumpHolder() override { free(dump_); }
-
-  char* dump_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryDumpHolder);
-};
-
-/////////////////////////////////////////////////////////////////////////////
-// Records a stack of TRACE_MEMORY events. One per thread is required.
-struct TraceMemoryStack {
-  TraceMemoryStack() : scope_depth(0) {
-    memset(scope_data, 0, kMaxScopeDepth * sizeof(scope_data[0]));
-  }
-
-  // Depth of the currently nested TRACE_EVENT scopes. Allowed to be greater
-  // than kMaxScopeDepth so we can match scope pushes and pops even if we don't
-  // have enough space to store the EventData.
-  size_t scope_depth;
-
-  // Stack of categories and names.
-  ScopedTraceMemory::ScopeData scope_data[kMaxScopeDepth];
-};
-
-// Pointer to a TraceMemoryStack per thread.
-base::ThreadLocalStorage::StaticSlot tls_trace_memory_stack = TLS_INITIALIZER;
-
-// Clean up memory pointed to by our thread-local storage.
-void DeleteStackOnThreadCleanup(void* value) {
-  TraceMemoryStack* stack = static_cast<TraceMemoryStack*>(value);
-  delete stack;
-}
-
-// Initializes the thread-local TraceMemoryStack pointer.
-void InitThreadLocalStorage() {
-  if (tls_trace_memory_stack.initialized())
-    return;
-  // Initialize the thread-local storage key.
-  tls_trace_memory_stack.Initialize(&DeleteStackOnThreadCleanup);
-}
-
-// Clean up thread-local-storage in the main thread.
-void CleanupThreadLocalStorage() {
-  if (!tls_trace_memory_stack.initialized())
-    return;
-  TraceMemoryStack* stack =
-      static_cast<TraceMemoryStack*>(tls_trace_memory_stack.Get());
-  delete stack;
-  tls_trace_memory_stack.Set(NULL);
-  // Intentionally do not release the thread-local-storage key here, that is,
-  // do not call tls_trace_memory_stack.Free(). Other threads have lazily
-  // created pointers in thread-local-storage via GetTraceMemoryStack() below.
-  // Those threads need to run the DeleteStack() destructor function when they
-  // exit. If we release the key the destructor will not be called and those
-  // threads will not clean up their memory.
-}
-
-// Returns the thread-local trace memory stack for the current thread, creating
-// one if needed. Returns NULL if the thread-local storage key isn't
-// initialized, which indicates that heap profiling isn't running.
-TraceMemoryStack* GetTraceMemoryStack() {
-  TraceMemoryStack* stack =
-      static_cast<TraceMemoryStack*>(tls_trace_memory_stack.Get());
-  // Lazily initialize TraceMemoryStack objects for new threads.
-  if (!stack) {
-    stack = new TraceMemoryStack;
-    tls_trace_memory_stack.Set(stack);
-  }
-  return stack;
-}
-
-// Returns a "pseudo-stack" of pointers to trace event categories and names.
-// Because tcmalloc stores one pointer per stack frame this converts N nested
-// trace events into N * 2 pseudo-stack entries. Thus this macro invocation:
-//    TRACE_EVENT0("category1", "name1");
-//    TRACE_EVENT0("category2", "name2");
-// becomes this pseudo-stack:
-//    stack_out[0] = "category1"
-//    stack_out[1] = "name1"
-//    stack_out[2] = "category2"
-//    stack_out[3] = "name2"
-// Returns int instead of size_t to match the signature required by tcmalloc.
-int GetPseudoStack(int skip_count_ignored, void** stack_out) {
-  // If the tracing system isn't fully initialized, just skip this allocation.
-  // Attempting to initialize will allocate memory, causing this function to
-  // be called recursively from inside the allocator.
-  if (!tls_trace_memory_stack.initialized() || !tls_trace_memory_stack.Get())
-    return 0;
-  TraceMemoryStack* stack =
-      static_cast<TraceMemoryStack*>(tls_trace_memory_stack.Get());
-  // Copy at most kMaxScopeDepth scope entries.
-  const size_t count = std::min(stack->scope_depth, kMaxScopeDepth);
-  // Notes that memcpy() works for zero bytes.
-  memcpy(stack_out,
-         stack->scope_data,
-         count * sizeof(stack->scope_data[0]));
-  // Each item in the trace event stack contains both name and category so tell
-  // tcmalloc that we have returned |count| * 2 stack frames.
-  return static_cast<int>(count * 2);
-}
-
-}  // namespace
-
-//////////////////////////////////////////////////////////////////////////////
-
-TraceMemoryController::TraceMemoryController(
-    scoped_refptr<SingleThreadTaskRunner> task_runner,
-    HeapProfilerStartFunction heap_profiler_start_function,
-    HeapProfilerStopFunction heap_profiler_stop_function,
-    GetHeapProfileFunction get_heap_profile_function)
-    : task_runner_(std::move(task_runner)),
-      heap_profiler_start_function_(heap_profiler_start_function),
-      heap_profiler_stop_function_(heap_profiler_stop_function),
-      get_heap_profile_function_(get_heap_profile_function),
-      weak_factory_(this) {
-  // Force the "memory" category to show up in the trace viewer.
-  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("memory"), "init");
-  // Watch for the tracing system being enabled.
-  TraceLog::GetInstance()->AddEnabledStateObserver(this);
-}
-
-TraceMemoryController::~TraceMemoryController() {
-  if (dump_timer_.IsRunning())
-    StopProfiling();
-  TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
-}
-
-// base::trace_event::TraceLog::EnabledStateChangedObserver overrides:
-void TraceMemoryController::OnTraceLogEnabled() {
-  // Check to see if tracing is enabled for the memory category.
-  bool enabled;
-  TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory"),
-                                     &enabled);
-  if (!enabled)
-    return;
-  DVLOG(1) << "OnTraceLogEnabled";
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&TraceMemoryController::StartProfiling,
-                                    weak_factory_.GetWeakPtr()));
-}
-
-void TraceMemoryController::OnTraceLogDisabled() {
-  // The memory category is always disabled before OnTraceLogDisabled() is
-  // called, so we cannot tell if it was enabled before. Always try to turn
-  // off profiling.
-  DVLOG(1) << "OnTraceLogDisabled";
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&TraceMemoryController::StopProfiling,
-                                    weak_factory_.GetWeakPtr()));
-}
-
-void TraceMemoryController::StartProfiling() {
-  // Watch for the tracing framework sending enabling more than once.
-  if (dump_timer_.IsRunning())
-    return;
-  DVLOG(1) << "Starting trace memory";
-  InitThreadLocalStorage();
-  ScopedTraceMemory::set_enabled(true);
-  // Call ::HeapProfilerWithPseudoStackStart().
-  heap_profiler_start_function_(&GetPseudoStack);
-  const int kDumpIntervalSeconds = 5;
-  dump_timer_.Start(FROM_HERE,
-                    TimeDelta::FromSeconds(kDumpIntervalSeconds),
-                    base::Bind(&TraceMemoryController::DumpMemoryProfile,
-                               weak_factory_.GetWeakPtr()));
-}
-
-void TraceMemoryController::DumpMemoryProfile() {
-  // Don't trace allocations here in the memory tracing system.
-  INTERNAL_TRACE_MEMORY(TRACE_DISABLED_BY_DEFAULT("memory"),
-                        TRACE_MEMORY_IGNORE);
-
-  DVLOG(1) << "DumpMemoryProfile";
-  // MemoryDumpHolder takes ownership of this string. See GetHeapProfile() in
-  // tcmalloc for details.
-  char* dump = get_heap_profile_function_();
-  const int kSnapshotId = 1;
-  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
-      TRACE_DISABLED_BY_DEFAULT("memory"),
-      "memory::Heap",
-      kSnapshotId,
-      scoped_refptr<ConvertableToTraceFormat>(new MemoryDumpHolder(dump)));
-}
-
-void TraceMemoryController::StopProfiling() {
-  // Watch for the tracing framework sending disabled more than once.
-  if (!dump_timer_.IsRunning())
-    return;
-  DVLOG(1) << "Stopping trace memory";
-  dump_timer_.Stop();
-  ScopedTraceMemory::set_enabled(false);
-  CleanupThreadLocalStorage();
-  // Call ::HeapProfilerStop().
-  heap_profiler_stop_function_();
-}
-
-bool TraceMemoryController::IsTimerRunningForTest() const {
-  return dump_timer_.IsRunning();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-// static
-bool ScopedTraceMemory::enabled_ = false;
-
-void ScopedTraceMemory::Initialize(const char* category, const char* name) {
-  DCHECK(enabled_);
-  // Get our thread's copy of the stack.
-  TraceMemoryStack* trace_memory_stack = GetTraceMemoryStack();
-  const size_t index = trace_memory_stack->scope_depth;
-  // Don't record data for deeply nested scopes, but continue to increment
-  // |stack_depth| so we can match pushes and pops.
-  if (index < kMaxScopeDepth) {
-    ScopeData& event = trace_memory_stack->scope_data[index];
-    event.category = category;
-    event.name = name;
-  }
-  trace_memory_stack->scope_depth++;
-}
-
-void ScopedTraceMemory::Destroy() {
-  DCHECK(enabled_);
-  // Get our thread's copy of the stack.
-  TraceMemoryStack* trace_memory_stack = GetTraceMemoryStack();
-  // The tracing system can be turned on with ScopedTraceMemory objects
-  // allocated on the stack, so avoid potential underflow as they are destroyed.
-  if (trace_memory_stack->scope_depth > 0)
-    trace_memory_stack->scope_depth--;
-}
-
-// static
-void ScopedTraceMemory::InitForTest() {
-  InitThreadLocalStorage();
-  enabled_ = true;
-}
-
-// static
-void ScopedTraceMemory::CleanupForTest() {
-  enabled_ = false;
-  CleanupThreadLocalStorage();
-}
-
-// static
-int ScopedTraceMemory::GetStackDepthForTest() {
-  TraceMemoryStack* stack = GetTraceMemoryStack();
-  return static_cast<int>(stack->scope_depth);
-}
-
-// static
-ScopedTraceMemory::ScopeData ScopedTraceMemory::GetScopeDataForTest(
-    int stack_index) {
-  TraceMemoryStack* stack = GetTraceMemoryStack();
-  return stack->scope_data[stack_index];
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-void AppendHeapProfileAsTraceFormat(const char* input, std::string* output) {
-  // Heap profile output has a header total line, then a list of stacks with
-  // memory totals, like this:
-  //
-  // heap profile:    357:    55227 [ 14653:  2624014] @ heapprofile
-  //    95:    40940 [   649:   114260] @ 0x7fa7f4b3be13
-  //    77:    32546 [   742:   106234] @
-  //    68:     4195 [  1087:    98009] @ 0x7fa7fa9b9ba0 0x7fa7f4b3be13
-  //
-  // MAPPED_LIBRARIES:
-  // 1be411fc1000-1be4139e4000 rw-p 00000000 00:00 0
-  // 1be4139e4000-1be4139e5000 ---p 00000000 00:00 0
-  // ...
-  //
-  // Skip input after MAPPED_LIBRARIES.
-  std::string input_string;
-  const char* mapped_libraries = strstr(input, "MAPPED_LIBRARIES");
-  if (mapped_libraries) {
-    input_string.assign(input, mapped_libraries - input);
-  } else {
-    input_string.assign(input);
-  }
-
-  std::vector<std::string> lines = base::SplitString(
-      input_string, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (lines.empty()) {
-    DLOG(WARNING) << "No lines found";
-    return;
-  }
-
-  // Handle the initial summary line.
-  output->append("[");
-  AppendHeapProfileTotalsAsTraceFormat(lines[0], output);
-
-  // Handle the following stack trace lines.
-  for (size_t i = 1; i < lines.size(); i++)
-    AppendHeapProfileLineAsTraceFormat(lines[i], output);
-  output->append("]\n");
-}
-
-void AppendHeapProfileTotalsAsTraceFormat(const std::string& line,
-                                          std::string* output) {
-  // This is what a line looks like:
-  // heap profile:    357:    55227 [ 14653:  2624014] @ heapprofile
-  //
-  // The numbers represent total allocations since profiling was enabled.
-  // From the example above:
-  //     357 = Outstanding allocations (mallocs - frees)
-  //   55227 = Outstanding bytes (malloc bytes - free bytes)
-  //   14653 = Total allocations (mallocs)
-  // 2624014 = Total bytes (malloc bytes)
-  std::vector<std::string> tokens = base::SplitString(
-      line, " :[]@", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  if (tokens.size() < 4) {
-    DLOG(WARNING) << "Invalid totals line " << line;
-    return;
-  }
-  DCHECK_EQ(tokens[0], "heap");
-  DCHECK_EQ(tokens[1], "profile");
-  output->append("{\"current_allocs\": ");
-  output->append(tokens[2]);
-  output->append(", \"current_bytes\": ");
-  output->append(tokens[3]);
-  output->append(", \"trace\": \"\"}");
-}
-
-bool AppendHeapProfileLineAsTraceFormat(const std::string& line,
-                                        std::string* output) {
-  // This is what a line looks like:
-  //    68:     4195 [  1087:    98009] @ 0x7fa7fa9b9ba0 0x7fa7f4b3be13
-  //
-  // The numbers represent allocations for a particular stack trace since
-  // profiling was enabled. From the example above:
-  //    68 = Outstanding allocations (mallocs - frees)
-  //  4195 = Outstanding bytes (malloc bytes - free bytes)
-  //  1087 = Total allocations (mallocs)
-  // 98009 = Total bytes (malloc bytes)
-  //
-  // 0x7fa7fa9b9ba0 0x7fa7f4b3be13 = Stack trace represented as pointers to
-  //                                 static strings from trace event categories
-  //                                 and names.
-  std::vector<std::string> tokens = base::SplitString(
-      line, " :[]@", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  // It's valid to have no stack addresses, so only require 4 tokens.
-  if (tokens.size() < 4) {
-    DLOG(WARNING) << "Invalid line " << line;
-    return false;
-  }
-  // Don't bother with stacks that have no current allocations.
-  if (tokens[0] == "0")
-    return false;
-  output->append(",\n");
-  output->append("{\"current_allocs\": ");
-  output->append(tokens[0]);
-  output->append(", \"current_bytes\": ");
-  output->append(tokens[1]);
-  output->append(", \"trace\": \"");
-
-  // Convert pairs of "stack addresses" into category and name strings.
-  const std::string kSingleQuote = "'";
-  for (size_t t = 4; t < tokens.size(); t += 2) {
-    // Casting strings into pointers is ugly but otherwise tcmalloc would need
-    // to gain a special output serializer just for pseudo-stacks.
-    const char* trace_category = StringFromHexAddress(tokens[t]);
-    DCHECK_LT(t + 1, tokens.size());
-    const char* trace_name = StringFromHexAddress(tokens[t + 1]);
-
-    // TODO(jamescook): Report the trace category and name separately to the
-    // trace viewer and allow it to decide what decorations to apply. For now
-    // just hard-code a decoration for posted tasks (toplevel).
-    std::string trace_string(trace_name);
-    if (!strcmp(trace_category, "toplevel"))
-      trace_string.append("->PostTask");
-
-    // Some trace name strings have double quotes, convert them to single.
-    ReplaceChars(trace_string, "\"", kSingleQuote, &trace_string);
-
-    output->append(trace_string);
-
-    // Trace viewer expects a trailing space.
-    output->append(" ");
-  }
-  output->append("\"}");
-  return true;
-}
-
-const char* StringFromHexAddress(const std::string& hex_address) {
-  uint64 address = 0;
-  if (!base::HexStringToUInt64(hex_address, &address))
-    return "error";
-  if (!address)
-    return "null";
-  // Note that this cast handles 64-bit to 32-bit conversion if necessary.
-  return reinterpret_cast<const char*>(address);
-}
-
-}  // namespace trace_event
-}  // namespace base