memory-infra: rename service folder to memory_instrumentation

base/trace_event/memory_dump_manager.cc

 // Copyright 2015 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_dump_manager.h"
 
 #include <inttypes.h>
 #include <stdio.h>
 
 #include <algorithm>
@@ skipping 139 matching lines @@
 // static
 MemoryDumpManager* MemoryDumpManager::GetInstance() {
   if (g_instance_for_testing)
     return g_instance_for_testing;
 
   return Singleton<MemoryDumpManager,
                    LeakySingletonTraits<MemoryDumpManager>>::get();
 }
 
 // static
-void MemoryDumpManager::SetInstanceForTesting(MemoryDumpManager* instance) {
-  g_instance_for_testing = instance;
+std::unique_ptr<MemoryDumpManager>
+MemoryDumpManager::CreateInstanceForTesting() {
+  std::unique_ptr<MemoryDumpManager> instance(new MemoryDumpManager());

[hjd, 2017/05/22 10:46:29]

nit: MakeUnique?

[Primiano Tucci (use gerrit), 2017/05/22 11:42:36]

ah good point, I tried, but this can't be: the ctor is private due to Singleton
and MakeUnique can't use it (as technically MakeUnique is outside of this
class). so I think this should stay as it is.

+  g_instance_for_testing = instance.get();
+  return instance;
 }
 
 MemoryDumpManager::MemoryDumpManager()
     : is_coordinator_(false),
       tracing_process_id_(kInvalidTracingProcessId),
       dumper_registrations_ignored_for_testing_(false),
       heap_profiling_enabled_(false) {
   g_next_guid.GetNext();  // Make sure that first guid is not zero.
 
   // At this point the command line may not be initialized but we try to
   // enable the heap profiler to capture allocations as soon as possible.
   EnableHeapProfilingIfNeeded();
 }
 
 MemoryDumpManager::~MemoryDumpManager() {
   Thread* dump_thread = nullptr;
   {
     AutoLock lock(lock_);
     if (dump_thread_) {
       dump_thread = dump_thread_.get();
     }
   }
   if (dump_thread) {
     dump_thread->Stop();
   }
   AutoLock lock(lock_);
   dump_thread_.reset();
+  g_instance_for_testing = nullptr;
 }
 
 void MemoryDumpManager::EnableHeapProfilingIfNeeded() {
   if (heap_profiling_enabled_)
     return;
 
   if (!CommandLine::InitializedForCurrentProcess() ||
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableHeapProfiling))
     return;
@@ skipping 705 matching lines @@
   if (iter == process_dumps.end()) {
     std::unique_ptr<ProcessMemoryDump> new_pmd(
         new ProcessMemoryDump(heap_profiler_serialization_state, dump_args));
     iter = process_dumps.insert(std::make_pair(pid, std::move(new_pmd))).first;
   }
   return iter->second.get();
 }
 
 }  // namespace trace_event
 }  // namespace base