memory-infra: Don't invoke all dump providers in SUMMARY_ONLY mode

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 302 matching lines @@
 }
 
 void MemoryDumpManager::RegisterDumpProviderInternal(
     MemoryDumpProvider* mdp,
     const char* name,
     scoped_refptr<SequencedTaskRunner> task_runner,
     const MemoryDumpProvider::Options& options) {
   if (dumper_registrations_ignored_for_testing_)
     return;
 
+  // A handful of MDPs are required to compute the summary struct these are
+  // 'whitelisted for summary mode'. These MDPs are a subset of those which
+  // have small enough performance overhead that it is resonable to run them
+  // in the background while the user is doing other things. Those MDPs are
+  // 'whitelisted for background mode'.
   bool whitelisted_for_background_mode = IsMemoryDumpProviderWhitelisted(name);
-  scoped_refptr<MemoryDumpProviderInfo> mdpinfo =
-      new MemoryDumpProviderInfo(mdp, name, std::move(task_runner), options,
-                                 whitelisted_for_background_mode);
+  bool whitelisted_for_summary_mode =
+      IsMemoryDumpProviderWhitelistedForSummary(name);
+
+  scoped_refptr<MemoryDumpProviderInfo> mdpinfo = new MemoryDumpProviderInfo(
+      mdp, name, std::move(task_runner), options,
+      whitelisted_for_background_mode, whitelisted_for_summary_mode);
 
   if (options.is_fast_polling_supported) {
     DCHECK(!mdpinfo->task_runner) << "MemoryDumpProviders capable of fast "
                                      "polling must NOT be thread bound.";
   }
 
   {
     AutoLock lock(lock_);
     bool already_registered = !dump_providers_.insert(mdpinfo).second;
     // This actually happens in some tests which don't have a clean tear-down
@@ skipping 219 matching lines @@
 
   // If we are in background tracing, we should invoke only the whitelisted
   // providers. Ignore other providers and continue.
   if (pmd_async_state->req_args.level_of_detail ==
           MemoryDumpLevelOfDetail::BACKGROUND &&
       !mdpinfo->whitelisted_for_background_mode) {
     pmd_async_state->pending_dump_providers.pop_back();
     return SetupNextMemoryDump(std::move(pmd_async_state));
   }
 
+  // If we are in summary mode, we only need to invoke the providers
+  // whitelisted for summary mode.
+  if (pmd_async_state->req_args.dump_type == MemoryDumpType::SUMMARY_ONLY &&
+      !mdpinfo->whitelisted_for_summary_mode) {
+    pmd_async_state->pending_dump_providers.pop_back();
+    return SetupNextMemoryDump(std::move(pmd_async_state));
+  }
+
   // If the dump provider did not specify a task runner affinity, dump on
   // |dump_thread_|.
   SequencedTaskRunner* task_runner = mdpinfo->task_runner.get();
   if (!task_runner) {
     DCHECK(mdpinfo->options.dumps_on_single_thread_task_runner);
     task_runner = pmd_async_state->dump_thread_task_runner.get();
     DCHECK(task_runner);
   }
 
   if (mdpinfo->options.dumps_on_single_thread_task_runner &&
@@ skipping 311 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