Making the MemoryDumpManager less aggressive in disabling dump providers on failures.

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 135 matching lines @@
 void InitializeThreadLocalEventBufferIfSupported() {
   TraceLog::GetInstance()->InitializeThreadLocalEventBufferIfSupported();
 }
 
 }  // namespace
 
 // static
 const char* const MemoryDumpManager::kTraceCategoryForTesting = kTraceCategory;
 
 // static
+const int MemoryDumpManager::kMaxConsecutiveFailuresCount = 3;
+
+// 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) {
@@ skipping 176 matching lines @@
   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) {
-    LOG(ERROR) << "The memory dumper failed, possibly due to sandboxing "
-                  "(crbug.com/461788), disabling it for current process. Try "
-                  "restarting chrome with the --no-sandbox switch.";
-    dump_providers_.find(mdp)->second.disabled = true;
+  MemoryDumpProviderInfo* mdp_info = &dump_providers_.find(mdp)->second;
+  if (dump_successful) {
+    mdp_info->consecutive_failures = 0;
+  } else {
+    // Disable the MDP if it fails kMaxConsecutiveFailuresCount times
+    // consecutively.
+    mdp_info->consecutive_failures++;
+    if (mdp_info->consecutive_failures >= kMaxConsecutiveFailuresCount) {
+      mdp_info->disabled = true;
+      LOG(ERROR) << "The memory dumper failed, possibly due to sandboxing "
+                    "(crbug.com/461788), disabling it for current process. Try "
+                    "restarting chrome with the --no-sandbox switch.";
+    }
   }
   return dump_successful;
 }
 
 // This is posted to arbitrary threads as a continuation of CreateProcessDump(),
 // when one or more MemoryDumpProvider(s) require the OnMemoryDump() call to
 // happen on a different thread.
 void MemoryDumpManager::ContinueAsyncProcessDump(
     MemoryDumpProvider* mdp,
     scoped_refptr<ProcessMemoryDumpHolder> pmd_holder) {
@@ skipping 35 matching lines @@
     // Disable all the providers.
     for (auto it = dump_providers_.begin(); it != dump_providers_.end(); ++it)
       it->second.disabled = true;
     return;
   }
 
   session_state_ = new MemoryDumpSessionState();
   for (auto it = dump_providers_.begin(); it != dump_providers_.end(); ++it) {
     MemoryDumpProviderInfo& mdp_info = it->second;
     mdp_info.disabled = false;
+    mdp_info.consecutive_failures = 0;
     if (mdp_info.task_runner) {
       // The thread local event buffer must be initialized at this point as it
       // registers its own dump provider (for tracing overhead acounting).
       // The registration cannot happen lazily during the first TRACE_EVENT*
       // as it might end up registering the ThreadLocalEventBuffer while
       // in onMemoryDump(), which will deadlock.
       mdp_info.task_runner->PostTask(
           FROM_HERE, Bind(&InitializeThreadLocalEventBufferIfSupported));
     }
   }
@@ skipping 10 matching lines @@
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   AutoLock lock(lock_);
   periodic_dump_timer_.Stop();
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
   session_state_ = nullptr;
 }
 
 MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo(
     const scoped_refptr<SingleThreadTaskRunner>& task_runner)
-    : task_runner(task_runner), disabled(false) {
+    : task_runner(task_runner), consecutive_failures(0), disabled(false) {
 }
 MemoryDumpManager::MemoryDumpProviderInfo::~MemoryDumpProviderInfo() {
 }
 
 }  // namespace trace_event
 }  // namespace base