Attempt to fix a crash in RulesRegistryStorageDelegate on shutdown.

chrome/browser/extensions/api/declarative/rules_registry_storage_delegate.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 "chrome/browser/extensions/api/declarative/rules_registry_storage_delegate.h"
 
 #include "base/bind.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 123 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   extensions::StateStore* store = ExtensionSystem::Get(profile)->state_store();
   if (store)
     store->RegisterKey(storage_key);
   inner_ = new Inner(profile, rules_registry, storage_key);
 }
 
 void RulesRegistryStorageDelegate::CleanupOnUIThread() {
   // The registrar must be deleted on the UI thread.
   inner_->registrar_.reset();
+  inner_->profile_ = NULL;  // no longer safe to use.
 }
 
 bool RulesRegistryStorageDelegate::IsReady() {
   DCHECK(content::BrowserThread::CurrentlyOn(inner_->rules_registry_thread_));
   return inner_->ready_;
 }
 
 void RulesRegistryStorageDelegate::OnRulesChanged(
     RulesRegistryWithCache* rules_registry,
     const std::string& extension_id) {
@@ skipping 68 matching lines @@
       }
     }
   } else if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
     CheckIfReady();
   }
 }
 
 void RulesRegistryStorageDelegate::Inner::ReadFromStorage(
     const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!profile_)
+    return;
+
   extensions::StateStore* store = ExtensionSystem::Get(profile_)->state_store();
   if (store) {
     waiting_for_extensions_.insert(extension_id);
     store->GetExtensionValue(extension_id, storage_key_,
         base::Bind(&Inner::ReadFromStorageCallback, this, extension_id));
   }
 }
 
 void RulesRegistryStorageDelegate::Inner::ReadFromStorageCallback(
     const std::string& extension_id, scoped_ptr<base::Value> value) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   content::BrowserThread::PostTask(
       rules_registry_thread_, FROM_HERE,
       base::Bind(&Inner::ReadFromStorageOnRegistryThread, this,
                  extension_id, base::Passed(value.Pass())));
 
   waiting_for_extensions_.erase(extension_id);
   CheckIfReady();
 }
 
 void RulesRegistryStorageDelegate::Inner::WriteToStorage(
     const std::string& extension_id, scoped_ptr<base::Value> value) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!profile_)
+    return;
+
   StateStore* store = ExtensionSystem::Get(profile_)->state_store();
   if (store)
     store->SetExtensionValue(extension_id, storage_key_, value.Pass());
 }
 
 void RulesRegistryStorageDelegate::Inner::CheckIfReady() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!waiting_for_extensions_.empty())
     return;
 
@@ skipping 14 matching lines @@
 void RulesRegistryStorageDelegate::Inner::NotifyReadyOnRegistryThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(rules_registry_thread_));
   if (ready_)
     return;  // we've already notified our readiness
 
   ready_ = true;
   rules_registry_->OnReady();
 }
 
 }  // namespace extensions