Fix ImportDataHandler crash.

chrome/browser/ui/webui/options/import_data_handler.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/ui/webui/options/import_data_handler.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 68 matching lines @@
 void ImportDataHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "importData",
       base::Bind(&ImportDataHandler::ImportData, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "chooseBookmarksFile",
       base::Bind(&ImportDataHandler::HandleChooseBookmarksFile,
                  base::Unretained(this)));
 }
 
+void ImportDataHandler::StartImport(
+    const importer::SourceProfile& source_profile,
+    uint16 imported_items) {
+  if (!imported_items)
+    return;
+
+  // If another import is already ongoing, let it finish silently.
+  if (importer_host_)
+    importer_host_->set_observer(NULL);
+
+  base::FundamentalValue importing(true);
+  web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
+                                   importing);
+  import_did_succeed_ = false;
+
+  importer_host_ = new ExternalProcessImporterHost();
+  importer_host_->set_observer(this);
+  Profile* profile = Profile::FromWebUI(web_ui());
+  importer_host_->StartImportSettings(source_profile, profile,
+                                      imported_items,
+                                      new ProfileWriter(profile));
+
+  importer::LogImporterUseToMetrics("ImportDataHandler",
+                                    source_profile.importer_type);
+}
+
 void ImportDataHandler::ImportData(const ListValue* args) {
   std::string string_value;
 
   int browser_index;
   if (!args->GetString(0, &string_value) ||
       !base::StringToInt(string_value, &browser_index)) {
     NOTREACHED();
     return;
   }
 
   uint16 selected_items = importer::NONE;
   if (args->GetString(1, &string_value) && string_value == "true") {
     selected_items |= importer::HISTORY;
   }
   if (args->GetString(2, &string_value) && string_value == "true") {
     selected_items |= importer::FAVORITES;
   }
   if (args->GetString(3, &string_value) && string_value == "true") {
     selected_items |= importer::PASSWORDS;
   }
   if (args->GetString(4, &string_value) && string_value == "true") {
     selected_items |= importer::SEARCH_ENGINES;
   }
 
   const importer::SourceProfile& source_profile =
       importer_list_->GetSourceProfileAt(browser_index);
   uint16 supported_items = source_profile.services_supported;
 
-  uint16 import_services = (selected_items & supported_items);
-  if (import_services) {
-    base::FundamentalValue state(true);
-    web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
-                                     state);
-    import_did_succeed_ = false;
-
-    importer_host_ = new ExternalProcessImporterHost();
-    importer_host_->set_observer(this);
-    Profile* profile = Profile::FromWebUI(web_ui());
-    importer_host_->StartImportSettings(source_profile, profile,
-                                        import_services,
-                                        new ProfileWriter(profile));
-
-    importer::LogImporterUseToMetrics("ImportDataHandler",
-                                      source_profile.importer_type);
+  uint16 imported_items = (selected_items & supported_items);
+  if (imported_items) {
+    StartImport(source_profile, imported_items);
   } else {
     LOG(WARNING) << "There were no settings to import from '"
         << source_profile.importer_name << "'.";
   }
 }
 
 void ImportDataHandler::OnSourceProfilesLoaded() {
   InitializePage();
 }
 
@@ skipping 53 matching lines @@
     web_ui()->CallJavascriptFunction("ImportDataOverlay.confirmSuccess");
   } else {
     base::FundamentalValue state(false);
     web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
                                      state);
     web_ui()->CallJavascriptFunction("ImportDataOverlay.dismiss");
   }
 }
 
 void ImportDataHandler::FileSelected(const base::FilePath& path,
-                                     int index,
-                                     void* params) {
-  base::FundamentalValue importing(true);
-  web_ui()->CallJavascriptFunction("ImportDataOverlay.setImportingState",
-                                   importing);
-  import_did_succeed_ = false;
-
-  importer_host_ = new ExternalProcessImporterHost();
-  importer_host_->set_observer(this);
+                                     int /*index*/,
+                                     void* /*params*/) {
 
   importer::SourceProfile source_profile;
   source_profile.importer_type = importer::TYPE_BOOKMARKS_FILE;
   source_profile.source_path = path;
 
-  Profile* profile = Profile::FromWebUI(web_ui());
-
-  importer_host_->StartImportSettings(
-      source_profile, profile, importer::FAVORITES, new ProfileWriter(profile));
+  StartImport(source_profile, importer::FAVORITES);
 }
 
 void ImportDataHandler::HandleChooseBookmarksFile(const base::ListValue* args) {
   DCHECK(args && args->empty());
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
 
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html"));
 
   Browser* browser =
       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents());
 
   select_file_dialog_->SelectFile(ui::SelectFileDialog::SELECT_OPEN_FILE,
                                   base::string16(),
                                   base::FilePath(),
                                   &file_type_info,
                                   0,
                                   base::FilePath::StringType(),
                                   browser->window()->GetNativeWindow(),
                                   NULL);
 }
 
 }  // namespace options