Store a stacktrace of PrefService destruction in PrefChangeRegistrar

base/prefs/pref_member.cc

 // Copyright (c) 2012 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/prefs/pref_member.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+// TODO(battre): Delete this. See crbug.com/373435.
+#include "base/debug/alias.h"
 #include "base/location.h"
 #include "base/prefs/pref_service.h"
 #include "base/value_conversions.h"
 
 using base::MessageLoopProxy;
 
 namespace subtle {
 
 PrefMemberBase::PrefMemberBase()
     : prefs_(NULL),
@@ skipping 21 matching lines @@
   // Check that the preference is registered.
   DCHECK(prefs_->FindPreference(pref_name_.c_str()))
       << pref_name << " not registered.";
 
   // Add ourselves as a pref observer so we can keep our local value in sync.
   prefs_->AddPrefObserver(pref_name, this);
 }
 
 void PrefMemberBase::Destroy() {
   if (prefs_ && !pref_name_.empty()) {
+    // TODO(battre): Delete this. See crbug.com/373435.
+    if (!pref_service_destruction_.empty()) {
+      // The PrefService is already destroyed, so the following call to
+      // service_->RemovePrefObserver would crash anyway. When the PrefService
+      // was destroyed, it stored a stacktrack of the destruction in
+      // pref_service_destruction_. We save this on the stack in the minidump to
+      // understand what happens.
+      char tmp[2048];
+      const int copy =
+          std::min<int>(sizeof(tmp) - 1, pref_service_destruction_.length());
+      memcpy(tmp, pref_service_destruction_.c_str(), copy);
+      tmp[copy] = '\0';
+      base::debug::Alias(tmp);
+      CHECK(false) << tmp;
+    }
     prefs_->RemovePrefObserver(pref_name_.c_str(), this);
     prefs_ = NULL;
   }
 }
 
 void PrefMemberBase::MoveToThread(
     const scoped_refptr<MessageLoopProxy>& message_loop) {
   VerifyValuePrefName();
   // Load the value from preferences if it hasn't been loaded so far.
   if (!internal())
     UpdateValueFromPref(base::Closure());
   internal()->MoveToThread(message_loop);
 }
 
 void PrefMemberBase::OnPreferenceChanged(PrefService* service,
                                          const std::string& pref_name) {
   VerifyValuePrefName();
   UpdateValueFromPref((!setting_value_ && !observer_.is_null()) ?
       base::Bind(observer_, pref_name) : base::Closure());
 }
 
+// TODO(battre): Delete this. See crbug.com/373435.
+void PrefMemberBase::SetPrefServiceDestructionTrace(
+    const std::string& stacktrace) {
+  pref_service_destruction_ = stacktrace;
+}
+
 void PrefMemberBase::UpdateValueFromPref(const base::Closure& callback) const {
   VerifyValuePrefName();
   const PrefService::Preference* pref =
       prefs_->FindPreference(pref_name_.c_str());
   DCHECK(pref);
   if (!internal())
     CreateInternal();
   internal()->UpdateValue(pref->GetValue()->DeepCopy(),
                           pref->IsManaged(),
                           pref->IsUserModifiable(),
@@ skipping 136 matching lines @@
   base::ListValue list_value;
   list_value.AppendStrings(value);
   prefs()->Set(pref_name().c_str(), list_value);
 }
 
 template <>
 bool PrefMember<std::vector<std::string> >::Internal::UpdateValueInternal(
     const base::Value& value) const {
   return subtle::PrefMemberVectorStringUpdate(value, &value_);
 }