[memory-infra] Remove MemoryDumpManagerDelegate

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 166 matching lines @@
   return Singleton<MemoryDumpManager,
                    LeakySingletonTraits<MemoryDumpManager>>::get();
 }
 
 // static
 void MemoryDumpManager::SetInstanceForTesting(MemoryDumpManager* instance) {
   g_instance_for_testing = instance;
 }
 
 MemoryDumpManager::MemoryDumpManager()
-    : memory_tracing_enabled_(0),
+    : is_coordinator_(false),
+      memory_tracing_enabled_(0),
       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();
 
   strict_thread_check_blacklist_.insert(std::begin(kStrictThreadCheckBlacklist),
@@ skipping 36 matching lines @@
     CHECK(false) << "Invalid mode '" << profiling_mode << "' for "
                << switches::kEnableHeapProfiling << " flag.";
   }
 
   for (auto mdp : dump_providers_)
     mdp->dump_provider->OnHeapProfilingEnabled(true);
   heap_profiling_enabled_ = true;
 }
 
 void MemoryDumpManager::Initialize(
-    std::unique_ptr<MemoryDumpManagerDelegate> delegate) {
+    RequestGlobalDumpCallback request_dump_callback,
+    bool is_coordinator) {
   {
     AutoLock lock(lock_);
-    DCHECK(delegate);
-    DCHECK(!delegate_);
-    delegate_ = std::move(delegate);
+    DCHECK(!request_dump_callback.is_null());
+    DCHECK(request_dump_callback_.is_null());
+    request_dump_callback_ = request_dump_callback;
+    is_coordinator_ = is_coordinator;
     EnableHeapProfilingIfNeeded();
   }
 
 // Enable the core dump providers.
 #if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
   RegisterDumpProvider(MallocDumpProvider::GetInstance(), "Malloc", nullptr);
 #endif
 
 #if defined(OS_ANDROID)
   RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
@@ skipping 198 matching lines @@
 
   // Creates an async event to keep track of the global dump evolution.
   // The |wrapped_callback| will generate the ASYNC_END event and then invoke
   // the real |callback| provided by the caller.
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(
       kTraceCategory, "GlobalMemoryDump", TRACE_ID_LOCAL(guid), "dump_type",
       MemoryDumpTypeToString(dump_type), "level_of_detail",
       MemoryDumpLevelOfDetailToString(level_of_detail));
   GlobalMemoryDumpCallback wrapped_callback = Bind(&OnGlobalDumpDone, callback);
 
-  // The delegate will coordinate the IPC broadcast and at some point invoke
+  // The embedder will coordinate the IPC broadcast and at some point invoke
   // CreateProcessDump() to get a dump for the current process.
   MemoryDumpRequestArgs args = {guid, dump_type, level_of_detail};
-  delegate_->RequestGlobalMemoryDump(args, wrapped_callback);
+  request_dump_callback_.Run(args, wrapped_callback);
 }
 
 void MemoryDumpManager::GetDumpProvidersForPolling(
     std::vector<scoped_refptr<MemoryDumpProviderInfo>>* providers) {
   DCHECK(providers->empty());
   AutoLock lock(lock_);
   for (const scoped_refptr<MemoryDumpProviderInfo>& mdp : dump_providers_) {
     if (mdp->options.is_fast_polling_supported)
       providers->push_back(mdp);
   }
@@ skipping 376 matching lines @@
 
     TRACE_EVENT_API_ADD_METADATA_EVENT(
         TraceLog::GetCategoryGroupEnabled("__metadata"), "typeNames",
         "typeNames",
         MakeUnique<SessionStateConvertableProxy<TypeNameDeduplicator>>(
             session_state, &MemoryDumpSessionState::type_name_deduplicator));
   }
 
   AutoLock lock(lock_);
 
-  DCHECK(delegate_);  // At this point we must have a delegate.
+  // At this point we must have the ability to request global dumps.
+  DCHECK(!request_dump_callback_.is_null());
   session_state_ = session_state;
 
   DCHECK(!dump_thread_);
   dump_thread_ = std::move(dump_thread);
 
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 
   MemoryDumpScheduler::Config periodic_config;
   bool peak_detector_configured = false;
   for (const auto& trigger : memory_dump_config.triggers) {
@@ skipping 19 matching lines @@
 
       MemoryPeakDetector::Config peak_config;
       peak_config.polling_interval_ms = 10;
       peak_config.min_time_between_peaks_ms = trigger.min_time_between_dumps_ms;
       peak_config.enable_verbose_poll_tracing =
           trigger.level_of_detail == MemoryDumpLevelOfDetail::DETAILED;
       MemoryPeakDetector::GetInstance()->Start(peak_config);
 
       // When peak detection is enabled, trigger a dump straight away as it
       // gives a good reference point for analyzing the trace.
-      if (delegate_->IsCoordinator()) {
+      if (is_coordinator_) {
         dump_thread_->task_runner()->PostTask(
             FROM_HERE, BindRepeating(&OnPeakDetected, trigger.level_of_detail));
       }
     }
   }
 
   // Only coordinator process triggers periodic global memory dumps.
-  if (delegate_->IsCoordinator() && !periodic_config.triggers.empty()) {
+  if (is_coordinator_ && !periodic_config.triggers.empty()) {
     MemoryDumpScheduler::GetInstance()->Start(periodic_config,
                                               dump_thread_->task_runner());
   }
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   // There might be a memory dump in progress while this happens. Therefore,
   // ensure that the MDM state which depends on the tracing enabled / disabled
   // state is always accessed by the dumping methods holding the |lock_|.
   if (!subtle::NoBarrier_Load(&memory_tracing_enabled_))
@@ skipping 47 matching lines @@
   if (iter == process_dumps.end()) {
     std::unique_ptr<ProcessMemoryDump> new_pmd(
         new ProcessMemoryDump(session_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