Attempt at fixing crash during importing. As far as I can tell from...

chrome/browser/importer/importer.cc

 // Copyright (c) 2006-2008 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/importer/importer.h"
 
 #include <map>
 #include <set>
 
 #include "app/gfx/favicon_size.h"
@@ skipping 379 matching lines @@
   }
 
   // Encode our bitmap as a PNG.
   gfx::PNGCodec::EncodeBGRASkBitmap(decoded, false, png_data);
   return true;
 }
 
 // ImporterHost.
 
 ImporterHost::ImporterHost()
-    : observer_(NULL),
+    : profile_(NULL),
+      observer_(NULL),
       task_(NULL),
       importer_(NULL),
       file_loop_(g_browser_process->file_thread()->message_loop()),
       waiting_for_bookmarkbar_model_(false),
+      installed_bookmark_observer_(false),
       is_source_readable_(true),
       headless_(false),
       parent_window_(NULL) {
   importer_list_.DetectSourceProfiles();
 }
 
 ImporterHost::ImporterHost(MessageLoop* file_loop)
-    : observer_(NULL),
+    : profile_(NULL),
+      observer_(NULL),
       task_(NULL),
       importer_(NULL),
       file_loop_(file_loop),
       waiting_for_bookmarkbar_model_(false),
+      installed_bookmark_observer_(false),
       is_source_readable_(true),
       headless_(false),
       parent_window_(NULL) {
   importer_list_.DetectSourceProfiles();
 }
 
 ImporterHost::~ImporterHost() {
   if (NULL != importer_)
     importer_->Release();
+  if (installed_bookmark_observer_) {
+    DCHECK(profile_);  // Only way for waiting_for_bookmarkbar_model_ to be true
+                       // is if we have a profile.
+    profile_->GetBookmarkModel()->RemoveObserver(this);
+  }
 }
 
 void ImporterHost::Loaded(BookmarkModel* model) {
   DCHECK(model->IsLoaded());
   model->RemoveObserver(this);
   waiting_for_bookmarkbar_model_ = false;
+  installed_bookmark_observer_ = false;
 
   std::vector<GURL> starred_urls;
   model->GetBookmarks(&starred_urls);
   importer_->set_import_to_bookmark_bar(starred_urls.size() == 0);
   InvokeTaskIfDone();
 }
 
+void ImporterHost::BookmarkModelBeingDeleted(BookmarkModel* model) {
+  installed_bookmark_observer_ = false;
+}
+
 void ImporterHost::Observe(NotificationType type,
                            const NotificationSource& source,
                            const NotificationDetails& details) {
   DCHECK(type == NotificationType::TEMPLATE_URL_MODEL_LOADED);
   registrar_.RemoveAll();
   InvokeTaskIfDone();
 }
 
 void ImporterHost::ShowWarningDialog() {
   if (headless_) {
@@ skipping 31 matching lines @@
     importer_ = NULL;
     ImportEnded();
   }
 }
 
 void ImporterHost::StartImportSettings(const ProfileInfo& profile_info,
                                        Profile* target_profile,
                                        uint16 items,
                                        ProfileWriter* writer,
                                        bool first_run) {
+  DCHECK(!profile_);  // We really only support importing from one host at a
+                      // time.
+  profile_ = target_profile;
   // Preserves the observer and creates a task, since we do async import
   // so that it doesn't block the UI. When the import is complete, observer
   // will be notified.
   writer_ = writer;
   importer_ = importer_list_.CreateImporterByType(profile_info.browser_type);
   // If we fail to create Importer, exit as we can not do anything.
   if (!importer_) {
     ImportEnded();
     return;
   }
@@ skipping 57 matching lines @@
       is_source_readable_ = false;
     }
   }
 #endif
 
   // BookmarkModel should be loaded before adding IE favorites. So we observe
   // the BookmarkModel if needed, and start the task after it has been loaded.
   if ((items & FAVORITES) && !writer_->BookmarkModelIsLoaded()) {
     target_profile->GetBookmarkModel()->AddObserver(this);
     waiting_for_bookmarkbar_model_ = true;
+    installed_bookmark_observer_ = true;
   }
 
   // Observes the TemplateURLModel if needed to import search engines from the
   // other browser. We also check to see if we're importing bookmarks because
   // we can import bookmark keywords from Firefox as search engines.
   if ((items & SEARCH_ENGINES) || (items & FAVORITES)) {
     if (!writer_->TemplateURLModelIsLoaded()) {
       TemplateURLModel* model = target_profile->GetTemplateURLModel();
       registrar_.Add(this, NotificationType::TEMPLATE_URL_MODEL_LOADED,
                      Source<TemplateURLModel>(model));
@@ skipping 35 matching lines @@
   if (observer_)
     observer_->ImportStarted();
 }
 
 void ImporterHost::ImportEnded() {
   firefox_lock_.reset();  // Release the Firefox profile lock.
   if (observer_)
     observer_->ImportEnded();
   Release();
 }