[tracing] fix a data race in MemoryDumpManager

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 <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/compiler_specific.h"
@@ skipping 265 matching lines @@
   RequestGlobalDump(dump_type, MemoryDumpCallback());
 }
 
 // Creates a memory dump for the current process and appends it to the trace.
 void MemoryDumpManager::CreateProcessDump(const MemoryDumpRequestArgs& args,
                                           const MemoryDumpCallback& callback) {
   scoped_refptr<ProcessMemoryDumpHolder> pmd_holder(
       new ProcessMemoryDumpHolder(args, session_state_, callback));
   ProcessMemoryDump* pmd = &pmd_holder->process_memory_dump;
   bool did_any_provider_dump = false;
+  bool did_post_any_async_task = false;
 
   // Iterate over the active dump providers and invoke OnMemoryDump(pmd).
   // The MDM guarantees linearity (at most one MDP is active within one
   // process) and thread-safety (MDM enforces the right locking when entering /
   // leaving the MDP.OnMemoryDump() call). This is to simplify the clients'
   // design
   // and not let the MDPs worry about locking.
   // As regards thread affinity, depending on the MDP configuration (see
   // memory_dump_provider.h), the OnMemoryDump() invocation can happen:
   //  - Synchronousy on the MDM thread, when MDP.task_runner() is not set.
@@ skipping 11 matching lines @@
         continue;
       }
       if (mdp_info->disabled)
         continue;
       if (mdp_info->task_runner) {
         // The OnMemoryDump() call must be posted.
         bool did_post_async_task = mdp_info->task_runner->PostTask(
             FROM_HERE, Bind(&MemoryDumpManager::ContinueAsyncProcessDump,
                             Unretained(this), Unretained(mdp), pmd_holder));
         // The thread underlying the TaskRunner might have gone away.
-        if (did_post_async_task)
+        if (did_post_async_task) {
           ++pmd_holder->num_pending_async_requests;
+          did_post_any_async_task = true;
+        }
       } else {
         // Invoke the dump provider synchronously.
         did_any_provider_dump |= InvokeDumpProviderLocked(mdp, pmd);
       }
     }
   }  // AutoLock
 
   // If at least one synchronous provider did dump and there are no pending
   // asynchronous requests, add the dump to the trace and invoke the callback
   // straight away (FinalizeDumpAndAddToTrace() takes care of the callback).
-  if (did_any_provider_dump && pmd_holder->num_pending_async_requests == 0)
+  if (did_any_provider_dump && !did_post_any_async_task)
     FinalizeDumpAndAddToTrace(pmd_holder);
 }
 
 // Invokes the MemoryDumpProvider.OnMemoryDump(), taking care of the fail-safe
 // logic which disables the dumper when failing (crbug.com/461788).
 bool MemoryDumpManager::InvokeDumpProviderLocked(MemoryDumpProvider* mdp,
                                                  ProcessMemoryDump* pmd) {
   lock_.AssertAcquired();
   bool dump_successful = mdp->OnMemoryDump(pmd);
   if (!dump_successful) {
@@ skipping 75 matching lines @@
 
 MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo(
     const scoped_refptr<SingleThreadTaskRunner>& task_runner)
     : task_runner(task_runner), disabled(false) {
 }
 MemoryDumpManager::MemoryDumpProviderInfo::~MemoryDumpProviderInfo() {
 }
 
 }  // namespace trace_event
 }  // namespace base