Reland of Linux: Disable DBus auto-launch

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 113 matching lines @@
       MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 }  // namespace
 
 // static
 const char* const MemoryDumpManager::kTraceCategory =
     TRACE_DISABLED_BY_DEFAULT("memory-infra");
 
 // static
-const char* const MemoryDumpManager::kLogPrefix = "Memory-infra dump";
-
-// static
 const int MemoryDumpManager::kMaxConsecutiveFailuresCount = 3;
 
 // static
 const uint64_t MemoryDumpManager::kInvalidTracingProcessId = 0;
 
 // static
 const char* const MemoryDumpManager::kSystemAllocatorPoolName =
 #if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
     MallocDumpProvider::kAllocatedObjects;
 #else
     nullptr;
 #endif
 
 // static
 MemoryDumpManager* MemoryDumpManager::GetInstance() {
   if (g_instance_for_testing)
     return g_instance_for_testing;
 
   return Singleton<MemoryDumpManager,
                    LeakySingletonTraits<MemoryDumpManager>>::get();
 }
 
 // static
 std::unique_ptr<MemoryDumpManager>
 MemoryDumpManager::CreateInstanceForTesting() {
+  DCHECK(!g_instance_for_testing);
   std::unique_ptr<MemoryDumpManager> instance(new MemoryDumpManager());
   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) {
@@ skipping 249 matching lines @@
   // to just skip it, without actually invoking the |mdp|, which might be
   // destroyed by the caller soon after this method returns.
   (*mdp_iter)->disabled = true;
   dump_providers_.erase(mdp_iter);
 }
 
 void MemoryDumpManager::RequestGlobalDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
     const GlobalMemoryDumpCallback& callback) {
-  // If |request_dump_function_| is null MDM hasn't been initialized yet.
-  if (request_dump_function_.is_null()) {
-    VLOG(1) << kLogPrefix << " failed because"
-            << " memory dump manager is not enabled.";
+  if (!is_initialized()) {
+    VLOG(1) << "RequestGlobalDump() FAIL: MemoryDumpManager is not initialized";
     if (!callback.is_null())
       callback.Run(0u /* guid */, false /* success */);
     return;
   }
 
   const uint64_t guid =
       TraceLog::GetInstance()->MangleEventId(g_next_guid.GetNext());
 
   // Creates an async event to keep track of the global dump evolution.
   // The |wrapped_callback| will generate the ASYNC_END event and then invoke
@@ skipping 16 matching lines @@
   AutoLock lock(lock_);
   for (const scoped_refptr<MemoryDumpProviderInfo>& mdp : dump_providers_) {
     if (mdp->options.is_fast_polling_supported)
       providers->push_back(mdp);
   }
 }
 
 void MemoryDumpManager::RequestGlobalDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail) {
-  RequestGlobalDump(dump_type, level_of_detail, GlobalMemoryDumpCallback());
+  auto noop_callback = [](uint64_t dump_guid, bool success) {};
+  RequestGlobalDump(dump_type, level_of_detail, Bind(noop_callback));
 }
 
 bool MemoryDumpManager::IsDumpProviderRegisteredForTesting(
     MemoryDumpProvider* provider) {
   AutoLock lock(lock_);
 
   for (const auto& info : dump_providers_) {
     if (info->dump_provider == provider)
       return true;
   }
@@ skipping 10 matching lines @@
   dump_thread_ = MakeUnique<Thread>("MemoryInfra");
   bool started = dump_thread_->Start();
   CHECK(started);
 
   return dump_thread_->task_runner();
 }
 
 void MemoryDumpManager::CreateProcessDump(
     const MemoryDumpRequestArgs& args,
     const ProcessMemoryDumpCallback& callback) {
+  if (!is_initialized()) {
+    VLOG(1) << "CreateProcessDump() FAIL: MemoryDumpManager is not initialized";
+    if (!callback.is_null()) {
+      callback.Run(args.dump_guid, false /* success */,
+                   Optional<MemoryDumpCallbackResult>());
+    }
+    return;
+  }
+
   char guid_str[20];
   sprintf(guid_str, "0x%" PRIx64, args.dump_guid);
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(kTraceCategory, "ProcessMemoryDump",
                                     TRACE_ID_LOCAL(args.dump_guid), "dump_guid",
                                     TRACE_STR_COPY(guid_str));
 
   // If argument filter is enabled then only background mode dumps should be
   // allowed. In case the trace config passed for background tracing session
   // missed the allowed modes argument, it crashes here instead of creating
   // unexpected dumps.
@@ skipping 213 matching lines @@
     callback_task_runner->PostTask(
         FROM_HERE, BindOnce(&MemoryDumpManager::FinalizeDumpAndAddToTrace,
                             Unretained(this), Passed(&pmd_async_state)));
     return;
   }
 
   TRACE_EVENT0(kTraceCategory, "MemoryDumpManager::FinalizeDumpAndAddToTrace");
 
   // The results struct to fill.
   // TODO(hjd): Transitional until we send the full PMD. See crbug.com/704203
-  base::Optional<MemoryDumpCallbackResult> result;
+  Optional<MemoryDumpCallbackResult> result;
 
   bool dump_successful = pmd_async_state->dump_successful;
 
   for (const auto& kv : pmd_async_state->process_dumps) {
     ProcessId pid = kv.first;  // kNullProcessId for the current process.
     ProcessMemoryDump* process_memory_dump = kv.second.get();
 
     // SUMMARY_ONLY dumps are just return the summarized result in the
     // ProcessMemoryDumpCallback. These shouldn't be added to the trace to
     // avoid confusing trace consumers.
@@ skipping 109 matching lines @@
 
       // When peak detection is enabled, trigger a dump straight away as it
       // gives a good reference point for analyzing the trace.
       if (is_coordinator_) {
         GetOrCreateBgTaskRunnerLocked()->PostTask(
             FROM_HERE, BindRepeating(&OnPeakDetected, trigger.level_of_detail));
       }
     }
   }
 
-  // Only coordinator process triggers periodic global memory dumps.
+  // Only coordinator process triggers periodic memory dumps.
   if (is_coordinator_ && !periodic_config.triggers.empty()) {
     MemoryDumpScheduler::GetInstance()->Start(periodic_config,
                                               GetOrCreateBgTaskRunnerLocked());
   }
 }
 
 void MemoryDumpManager::TeardownForTracing() {
   // 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_|.
@@ skipping 32 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