Do not do AutoImport on Windows since the import process is already ran earlier as part of ProcessM…

chrome/browser/first_run/first_run_win.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/first_run/first_run.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
@@ skipping 256 matching lines @@
 
   importer::ShowImportProgressDialog(static_cast<uint16>(items_to_import),
       importer_host, &importer_observer,
       importer_list->GetSourceProfileForImporterType(importer_type), profile,
       true);
   importer_observer.RunLoop();
   return importer_observer.import_result();
 }
 #endif  // !defined(USE_AURA)
 
-bool ImportSettingsWin(Profile* profile,
-                       int importer_type,
+bool ImportSettingsWin(int importer_type,
                        int items_to_import,
                        const base::FilePath& import_bookmarks_path,
                        bool skip_first_run_ui) {
   if (!items_to_import && import_bookmarks_path.empty()) {
     return true;
   }
 
   const CommandLine& cmdline = *CommandLine::ForCurrentProcess();
   base::FilePath chrome_exe(cmdline.GetProgram());
   // |chrome_exe| cannot be a relative path as chrome.exe already changed its
@@ skipping 37 matching lines @@
 
   // Time to launch the process that is going to do the import.
   base::ProcessHandle import_process;
   if (!base::LaunchProcess(import_cmd, base::LaunchOptions(), &import_process))
     return false;
 
   // We block inside the import_runner ctor, pumping messages until the
   // importer process ends.
   ImportProcessRunner import_runner(import_process);
 
-  // Import process finished. Reload the prefs, because importer may set
-  // the pref value.
-  if (profile)
-    profile->GetPrefs()->ReloadPersistentPrefs();
-
   return (import_runner.exit_code() == content::RESULT_CODE_NORMAL_EXIT);
 }
 
 }  // namespace
 
 namespace first_run {
 namespace internal {
 
 void DoPostImportPlatformSpecificTasks() {
   // Trigger the Active Setup command for system-level Chromes to finish
   // configuring this user's install (e.g. per-user shortcuts).
   // Delay the task slightly to give Chrome launch I/O priority while also
   // making sure shortcuts are created promptly to avoid annoying the user by
   // re-creating shortcuts he previously deleted.
   static const int64 kTiggerActiveSetupDelaySeconds = 5;
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
   } else if (!InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())) {
     content::BrowserThread::GetBlockingPool()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&InstallUtil::TriggerActiveSetupCommand),
         base::TimeDelta::FromSeconds(kTiggerActiveSetupDelaySeconds));
   }
 }
 
-bool ImportSettings(Profile* profile,
-                    scoped_refptr<ImporterHost> importer_host,
-                    scoped_refptr<ImporterList> importer_list,
-                    int items_to_import) {
-  return ImportSettingsWin(
-      profile,
-      importer_list->GetSourceProfileAt(0).importer_type,
-      items_to_import,
-      base::FilePath(),
-      false);
-}
-
 bool GetFirstRunSentinelFilePath(base::FilePath* path) {
   return GetSentinelFilePath(chrome::kFirstRunSentinel, path);
 }
 
-void SetImportPreferencesAndLaunchImport(
-    MasterPrefs* out_prefs,
-    installer::MasterPreferences* install_prefs) {
-  std::string import_bookmarks_path;
-  install_prefs->GetString(
-      installer::master_preferences::kDistroImportBookmarksFromFilePref,
-      &import_bookmarks_path);
-
-  if (!IsOrganicFirstRun()) {
-    // If search engines aren't explicitly imported, don't import.
-    if (!(out_prefs->do_import_items & importer::SEARCH_ENGINES)) {
-      out_prefs->dont_import_items |= importer::SEARCH_ENGINES;
-    }
-    // If home page isn't explicitly imported, don't import.
-    if (!(out_prefs->do_import_items & importer::HOME_PAGE)) {
-      out_prefs->dont_import_items |= importer::HOME_PAGE;
-    }
-    // If history isn't explicitly forbidden, do import.
-    if (!(out_prefs->dont_import_items & importer::HISTORY)) {
-      out_prefs->do_import_items |= importer::HISTORY;
-    }
-  }
-
-  if (out_prefs->do_import_items || !import_bookmarks_path.empty()) {
-    // There is something to import from the default browser. This launches
-    // the importer process and blocks until done or until it fails.
-    scoped_refptr<ImporterList> importer_list(new ImporterList(NULL));
-    importer_list->DetectSourceProfilesHack();
-    if (!ImportSettingsWin(
-        NULL, importer_list->GetSourceProfileAt(0).importer_type,
-        out_prefs->do_import_items, base::FilePath::FromWStringHack(UTF8ToWide(
-                                        import_bookmarks_path)), true)) {
-      LOG(WARNING) << "silent import failed";
-    }
-  }
-}
-
 bool ShowPostInstallEULAIfNeeded(installer::MasterPreferences* install_prefs) {
   if (IsEULANotAccepted(install_prefs)) {
     // Show the post-installation EULA. This is done by setup.exe and the
     // result determines if we continue or not. We wait here until the user
     // dismisses the dialog.
 
     // The actual eula text is in a resource in chrome. We extract it to
     // a text file so setup.exe can use it as an inner frame.
     base::FilePath inner_html;
     if (WriteEULAtoTempFile(&inner_html)) {
@@ skipping 26 matching lines @@
 int ImportNow(Profile* profile, const CommandLine& cmdline) {
   int return_code = internal::ImportBookmarkFromFileIfNeeded(profile, cmdline);
 #if !defined(USE_AURA)
   if (cmdline.HasSwitch(switches::kImport)) {
     return_code = ImportFromBrowser(profile, cmdline);
   }
 #endif
   return return_code;
 }
 
+// On Windows this is the complete import (i.e., AutoImport() is skipped).
+// TODO(gab): Merge this into AutoImport() as part of http://crbug.com/22142
+void LaunchInitialImport(MasterPrefs* out_prefs) {
+  if (!internal::IsOrganicFirstRun()) {
+    // If search engines aren't explicitly imported, don't import.
+    if (!(out_prefs->do_import_items & importer::SEARCH_ENGINES)) {
+      out_prefs->dont_import_items |= importer::SEARCH_ENGINES;
+    }
+    // If home page isn't explicitly imported, don't import.
+    if (!(out_prefs->do_import_items & importer::HOME_PAGE)) {
+      out_prefs->dont_import_items |= importer::HOME_PAGE;
+    }
+    // If history isn't explicitly forbidden, do import.
+    if (!(out_prefs->dont_import_items & importer::HISTORY)) {
+      out_prefs->do_import_items |= importer::HISTORY;
+    }
+  }
+
+  if (out_prefs->do_import_items || !out_prefs->import_bookmarks_path.empty()) {
+    // There is something to import from the default browser. This launches
+    // the importer process and blocks until done or until it fails.
+    scoped_refptr<ImporterList> importer_list(new ImporterList(NULL));
+    importer_list->DetectSourceProfilesHack();
+    internal::g_profile_import_exited_successfully = ImportSettingsWin(
+        importer_list->GetSourceProfileAt(0).importer_type,
+        out_prefs->do_import_items,
+        base::FilePath::FromWStringHack(UTF8ToWide(
+            out_prefs->import_bookmarks_path)),
+        true);
+    if (!internal::g_profile_import_exited_successfully)
+      LOG(WARNING) << "silent import failed";
+  }
+  internal::g_did_perform_profile_import = true;
+}
+
 base::FilePath MasterPrefsPath() {
   // The standard location of the master prefs is next to the chrome binary.
   base::FilePath master_prefs;
   if (!PathService::Get(base::DIR_EXE, &master_prefs))
     return base::FilePath();
   return master_prefs.AppendASCII(installer::kDefaultMasterPrefs);
 }
 
 }  // namespace first_run