[memory-infra] Remove thread check blacklist

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 36 matching lines @@
 #endif
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 StaticAtomicSequenceNumber g_next_guid;
 MemoryDumpManager* g_instance_for_testing = nullptr;
 
-// The list of names of dump providers that are blacklisted from strict thread
-// affinity check on unregistration. These providers could potentially cause
-// crashes on build bots if they do not unregister on right thread.
-// TODO(ssid): Fix all the dump providers to unregister if needed and clear the
-// blacklist, crbug.com/643438.
-const char* const kStrictThreadCheckBlacklist[] = {
-    "ClientDiscardableSharedMemoryManager",
-    "ContextProviderCommandBuffer",
-    "DiscardableSharedMemoryManager",
-    "FontCaches",
-    "GpuMemoryBufferVideoFramePool",
-    "IndexedDBBackingStore",
-    "Sql",
-    "ThreadLocalEventBuffer",
-    "TraceLog",
-    "URLRequestContext",
-    "VpxVideoDecoder",
-    "cc::SoftwareImageDecodeCache",
-    "cc::StagingBufferPool",
-    "gpu::BufferManager",
-    "gpu::MappedMemoryManager",
-    "gpu::RenderbufferManager",
-    "BlacklistTestDumpProvider"  // for testing
-};
-
 // Callback wrapper to hook upon the completion of RequestGlobalDump() and
 // inject trace markers.
 void OnGlobalDumpDone(GlobalMemoryDumpCallback wrapped_callback,
                       uint64_t dump_guid,
                       bool success) {
   char guid_str[20];
   sprintf(guid_str, "0x%" PRIx64, dump_guid);
   TRACE_EVENT_NESTABLE_ASYNC_END2(MemoryDumpManager::kTraceCategory,
                                   "GlobalMemoryDump", TRACE_ID_LOCAL(dump_guid),
                                   "dump_guid", TRACE_STR_COPY(guid_str),
@@ skipping 92 matching lines @@
     : is_coordinator_(false),
       is_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),
-                                        std::end(kStrictThreadCheckBlacklist));
 }
 
 MemoryDumpManager::~MemoryDumpManager() {
   AutoLock lock(lock_);
   if (dump_thread_) {
     dump_thread_->Stop();
     dump_thread_.reset();
   }
 }
 
@@ skipping 184 matching lines @@
     return;  // Not registered / already unregistered.
 
   if (take_mdp_ownership_and_delete_async) {
     // The MDP will be deleted whenever the MDPInfo struct will, that is either:
     // - At the end of this function, if no dump is in progress.
     // - Either in SetupNextMemoryDump() or InvokeOnMemoryDump() when MDPInfo is
     //   removed from |pending_dump_providers|.
     // - When the provider is removed from other clients (MemoryPeakDetector).
     DCHECK(!(*mdp_iter)->owned_dump_provider);
     (*mdp_iter)->owned_dump_provider = std::move(owned_mdp);
-  } else if (strict_thread_check_blacklist_.count((*mdp_iter)->name) == 0 ||
-             subtle::NoBarrier_Load(&is_enabled_)) {
-    // If dump provider's name is on |strict_thread_check_blacklist_|, then the
-    // DCHECK is fired only when tracing is enabled. Otherwise the DCHECK is
-    // fired even when tracing is not enabled (stricter).
-    // TODO(ssid): Remove this condition after removing all the dump providers
-    // in the blacklist and the buildbots are no longer flakily hitting the
-    // DCHECK, crbug.com/643438.
-
+  } else {
     // If you hit this DCHECK, your dump provider has a bug.
     // Unregistration of a MemoryDumpProvider is safe only if:
     // - The MDP has specified a sequenced task runner affinity AND the
     //   unregistration happens on the same task runner. So that the MDP cannot
     //   unregister and be in the middle of a OnMemoryDump() at the same time.
     // - The MDP has NOT specified a task runner affinity and its ownership is
     //   transferred via UnregisterAndDeleteDumpProviderSoon().
     // In all the other cases, it is not possible to guarantee that the
     // unregistration will not race with OnMemoryDump() calls.
     DCHECK((*mdp_iter)->task_runner &&
@@ skipping 521 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