Restore KeyedServiceFactory diagnostics for context use-after-destroy.

components/keyed_service/core/dependency_manager.cc

 // Copyright 2014 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 "components/keyed_service/core/dependency_manager.h"
 
 #include "base/bind.h"
+#include "base/debug/dump_without_crashing.h"
 #include "base/logging.h"
 #include "base/supports_user_data.h"
 #include "components/keyed_service/core/keyed_service_base_factory.h"
 
 #ifndef NDEBUG
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #endif  // NDEBUG
 
 DependencyManager::DependencyManager() {
@@ skipping 25 matching lines @@
 
   for (auto* dependency_node : construction_order) {
     KeyedServiceBaseFactory* factory =
         static_cast<KeyedServiceBaseFactory*>(dependency_node);
     factory->RegisterPrefsIfNecessaryForContext(context, pref_registry);
   }
 }
 
 void DependencyManager::CreateContextServices(base::SupportsUserData* context,
                                               bool is_testing_context) {
-#ifndef NDEBUG
-  MarkContextLiveForTesting(context);
-#endif
+  MarkContextLive(context);
 
   std::vector<DependencyNode*> construction_order;
   if (!dependency_graph_.GetConstructionOrder(&construction_order)) {
     NOTREACHED();
   }
 
 #ifndef NDEBUG
   DumpContextDependencies(context);
 #endif
 
@@ skipping 19 matching lines @@
 #ifndef NDEBUG
   DumpContextDependencies(context);
 #endif
 
   for (auto* dependency_node : destruction_order) {
     KeyedServiceBaseFactory* factory =
         static_cast<KeyedServiceBaseFactory*>(dependency_node);
     factory->ContextShutdown(context);
   }
 
-#ifndef NDEBUG
   // The context is now dead to the rest of the program.
   dead_context_pointers_.insert(context);
-#endif
 
   for (auto* dependency_node : destruction_order) {
     KeyedServiceBaseFactory* factory =
         static_cast<KeyedServiceBaseFactory*>(dependency_node);
     factory->ContextDestroyed(context);
   }
 }
 
-#ifndef NDEBUG
 void DependencyManager::AssertContextWasntDestroyed(
-    base::SupportsUserData* context) {
+    base::SupportsUserData* context) const {
   if (dead_context_pointers_.find(context) != dead_context_pointers_.end()) {
+#if DCHECK_IS_ON()
     NOTREACHED() << "Attempted to access a context that was ShutDown(). "
                  << "This is most likely a heap smasher in progress. After "
                  << "KeyedService::Shutdown() completes, your service MUST "
                  << "NOT refer to depended services again.";
+#else   // DCHECK_IS_ON()
+    // We want to see all possible use-after-destroy in production environment.
+    base::debug::DumpWithoutCrashing();
+#endif  // DCHECK_IS_ON()
   }
 }
 
-void DependencyManager::MarkContextLiveForTesting(
-    base::SupportsUserData* context) {
+void DependencyManager::MarkContextLive(base::SupportsUserData* context) {
   dead_context_pointers_.erase(context);
 }
 
+#ifndef NDEBUG
 namespace {
 
 std::string KeyedServiceBaseFactoryGetNodeName(DependencyNode* node) {
   return static_cast<KeyedServiceBaseFactory*>(node)->name();
 }
 
 }  // namespace
 
 void DependencyManager::DumpDependenciesAsGraphviz(
     const std::string& top_level_name,
     const base::FilePath& dot_file) const {
   DCHECK(!dot_file.empty());
   std::string contents = dependency_graph_.DumpAsGraphviz(
       top_level_name, base::Bind(&KeyedServiceBaseFactoryGetNodeName));
   base::WriteFile(dot_file, contents.c_str(), contents.size());
 }
 #endif  // NDEBUG