[tracing] Add method to create "weak" global dumps

content/common/discardable_shared_memory_heap.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/discardable_shared_memory_heap.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
@@ skipping 405 matching lines @@
 
   // Emit an ownership edge towards a global allocator dump node. This allows
   // to avoid double-counting segments when both browser and child process emit
   // them. In the special case of single-process-mode, this will be the only
   // dumper active and the single ownership edge will become a no-op in the UI.
   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
   base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid =
       GetSegmentGUIDForTracing(tracing_process_id, segment_id);
-  pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid);
+  base::trace_event::MemoryAllocatorDump* global_dump =
+      pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid);
+
+  // Set the dump as weak so that it is invalidated if the browser had purged
+  // the segment.
+  global_dump->set_flags(base::trace_event::MemoryAllocatorDump::Flags::WEAK);

[petrcermak, 2016/01/13 17:46:14]

This will work as long as there is no other user of the global dump within the
process. However, even if there's another user of the global dump who created it
first *without* the weak flag, the global dump will now be weak. We want the
inverse semantics. To address this, I think that it would be better to add the
following method:

  pmd->GetOrCreateWeakSharedGlobalAllocatorDump(shared_segment_guid);

which would simply return an existing global dump (possibly strong) or create a
new one and mark is as weak. On the other hand, the existing method:

  pmd->GetOrCreateSharedGlobalAllocatorDump(shared_segment_guid);

would mark an existing global dump as strong and return it, or create a new one
(and keep it marked as strong).

The only issue here is combinatorial explosion of the method signatures.

ssid, primiano: WDYT?

[ssid, 2016/01/15 17:14:56]

Done.

 
   // The size is added to the global dump so that it gets propagated to both the
   // dumps associated.
-  pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
-      ->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
-                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                  allocated_objects_size_in_bytes);
+  global_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                         allocated_objects_size_in_bytes);
 
   // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
   // the tracing UI will account the effective size of the segment to the child.
   const int kImportance = 2;
   pmd->AddOwnershipEdge(segment_dump->guid(), shared_segment_guid, kImportance);
 }
 
 // static
 base::trace_event::MemoryAllocatorDumpGuid
 DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing(
@@ skipping 19 matching lines @@
   ScopedVector<ScopedMemorySegment>::const_iterator it =
       std::find_if(memory_segments_.begin(), memory_segments_.end(),
                    [span](const ScopedMemorySegment* segment) {
                      return segment->ContainsSpan(span);
                    });
   DCHECK(it != memory_segments_.end());
   return (*it)->CreateMemoryAllocatorDump(span, block_size_, name, pmd);
 }
 
 }  // namespace content