[tracing] Only add totals from discardable memory in background mode

content/common/host_discardable_shared_memory_manager.cc

 // Copyright 2014 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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 204 matching lines @@
   return base::WrapUnique(new DiscardableMemoryImpl(
       std::move(memory),
       base::Bind(
           &HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
           base::Unretained(this), new_id, ChildProcessHost::kInvalidUniqueID)));
 }
 
 bool HostDiscardableSharedMemoryManager::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
+  if (args.level_of_detail ==
+      base::trace_event::MemoryDumpLevelOfDetail::BACKGROUND) {
+    base::trace_event::MemoryAllocatorDump* total_dump =
+        pmd->CreateAllocatorDump("discardable");
+    total_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                          base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                          GetBytesAllocated());

[Primiano Tucci (use gerrit), 2016/06/02 19:31:41]

can you call this without the lock?

[ssid, 2016/06/03 00:27:47]

Hmm, we can only be stalling the memory-infra thread with this lock.
If we are holding lock, then it just reads the value and returns. So, we are not
stalling other threads.

+    return true;
+  }
+
   base::AutoLock lock(lock_);
   for (const auto& process_entry : processes_) {
     const int child_process_id = process_entry.first;
     const MemorySegmentMap& process_segments = process_entry.second;
     for (const auto& segment_entry : process_segments) {
       const int segment_id = segment_entry.first;
       const MemorySegment* segment = segment_entry.second.get();
       if (!segment->memory()->mapped_size())
         continue;
 
@@ skipping 305 matching lines @@
     return;
 
   enforce_memory_policy_pending_ = true;
   DCHECK(enforce_memory_policy_task_runner_);
   enforce_memory_policy_task_runner_->PostDelayedTask(
       FROM_HERE, enforce_memory_policy_callback_,
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content