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

chrome/browser/first_run/first_run.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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
+#include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/first_run/first_run_dialog.h"
 #include "chrome/browser/first_run/first_run_import_observer.h"
 #include "chrome/browser/first_run/first_run_internal.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/importer/external_process_importer_host.h"
 #include "chrome/browser/importer/importer_host.h"
 #include "chrome/browser/importer/importer_list.h"
 #include "chrome/browser/importer/importer_progress_dialog.h"
 #include "chrome/browser/importer/importer_progress_observer.h"
+#include "chrome/browser/importer/profile_writer.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 14 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "googleurl/src/gurl.h"
 
 using content::UserMetricsAction;
 
 namespace {
 
 // Flags for functions of similar name.
-bool should_show_welcome_page_ = false;
-bool should_do_autofill_personal_data_manager_first_run_ = false;
+bool g_should_show_welcome_page = false;
+bool g_should_do_autofill_personal_data_manager_first_run = false;
 
-// Flags indicating whether a first-run profile auto import was performed, and
-// whether the importer process exited successfully.
-bool did_perform_profile_import = false;
-bool profile_import_exited_successfully = false;
+// This class acts as an observer for the ImporterProgressObserver::ImportEnded
+// callback. When the import process is started, certain errors may cause
+// ImportEnded() to be called synchronously, but the typical case is that
+// ImportEnded() is called asynchronously. Thus we have to handle both cases.
+class ImportEndedObserver : public importer::ImporterProgressObserver {

[gab, 2013/03/26 15:55:25]

Moved from first_run_posix.cc

+ public:
+  ImportEndedObserver() : ended_(false),
+                          should_quit_message_loop_(false) {}
+  virtual ~ImportEndedObserver() {}
+
+  // importer::ImporterProgressObserver:
+  virtual void ImportStarted() OVERRIDE {}
+  virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
+  virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
+  virtual void ImportEnded() OVERRIDE {
+    ended_ = true;
+    if (should_quit_message_loop_)
+      MessageLoop::current()->Quit();
+  }
+
+  void set_should_quit_message_loop() {
+    should_quit_message_loop_ = true;
+  }
+
+  bool ended() const {
+    return ended_;
+  }
+
+ private:
+  // Set if the import has ended.
+  bool ended_;
+
+  // Set by the client (via set_should_quit_message_loop) if, when the import
+  // ends, this class should quit the message loop.
+  bool should_quit_message_loop_;
+};
 
 // Helper class that performs delayed first-run tasks that need more of the
 // chrome infrastructure to be up and running before they can be attempted.
 class FirstRunDelayedTasks : public content::NotificationObserver {
  public:
   enum Tasks {
     NO_TASK,
     INSTALL_EXTENSIONS
   };
 
@@ skipping 60 matching lines @@
   return ProfileManager::GetProfilePrefsPath(default_pref_dir);
 }
 
 // Sets the |items| bitfield according to whether the import data specified by
 // |import_type| should be be auto imported or not.
 void SetImportItem(PrefService* user_prefs,
                    const char* pref_path,
                    int import_items,
                    int dont_import_items,
                    importer::ImportItem import_type,
-                   int& items) {
+                   int* items) {
   // Work out whether an item is to be imported according to what is specified
   // in master preferences.
   bool should_import = false;
   bool master_pref_set =
       ((import_items | dont_import_items) & import_type) != 0;
   bool master_pref = ((import_items & ~dont_import_items) & import_type) != 0;
 
   if (import_type == importer::HISTORY ||
-      ((import_type != importer::FAVORITES) &&
-      first_run::internal::IsOrganicFirstRun())) {
+      (import_type != importer::FAVORITES &&
+       first_run::internal::IsOrganicFirstRun())) {
     // History is always imported unless turned off in master_preferences.
     // Search engines are only imported in certain builds unless overridden
     // in master_preferences.Home page is imported in organic builds only unless
     // turned off in master_preferences.
     should_import = !master_pref_set || master_pref;
   } else {
     // Bookmarks are never imported, unless turned on in master_preferences.
     // Search engine and home page import behaviour is similar in non organic
     // builds.
     should_import = master_pref_set && master_pref;
   }
 
   // If an import policy is set, import items according to policy. If no master
   // preference is set, but a corresponding recommended policy is set, import
   // item according to recommended policy. If both a master preference and a
   // recommended policy is set, the master preference wins. If neither
   // recommended nor managed policies are set, import item according to what we
   // worked out above.
   if (master_pref_set)
     user_prefs->SetBoolean(pref_path, should_import);
 
   if (!user_prefs->FindPreference(pref_path)->IsDefaultValue()) {
     if (user_prefs->GetBoolean(pref_path))
-      items |= import_type;
+      *items |= import_type;
   } else { // no policy (recommended or managed) is set
     if (should_import)
-      items |= import_type;
+      *items |= import_type;
   }
 
   user_prefs->ClearPref(pref_path);
 }
 
 // Imports bookmarks from an html file. The path to the file is provided in
 // the command line.
 int ImportFromFile(Profile* profile, const CommandLine& cmdline) {
   base::FilePath file_path =
       cmdline.GetSwitchValuePath(switches::kImportFromFile);
@@ skipping 29 matching lines @@
     std::vector<GURL>* ret) {
   ret->resize(src.size());
   std::transform(src.begin(), src.end(), ret->begin(), &UrlFromString);
 }
 
 }  // namespace
 
 namespace first_run {
 namespace internal {
 
+bool g_did_perform_profile_import = false;
+bool g_profile_import_exited_successfully = false;
+
 FirstRunState first_run_ = FIRST_RUN_UNKNOWN;
 
 static base::LazyInstance<base::FilePath> master_prefs_path_for_testing
     = LAZY_INSTANCE_INITIALIZER;
 
 installer::MasterPreferences*
     LoadMasterPrefs(base::FilePath* master_prefs_path) {
   if (!master_prefs_path_for_testing.Get().empty())
     *master_prefs_path = master_prefs_path_for_testing.Get();
   else
@@ skipping 17 matching lines @@
     return false;
 
   // The master prefs are regular prefs so we can just copy the file
   // to the default place and they just work.
   return file_util::CopyFile(master_prefs_path, user_prefs);
 }
 
 void SetupMasterPrefsFromInstallPrefs(
     const installer::MasterPreferences& install_prefs,
     MasterPrefs* out_prefs) {
+  ConvertStringVectorToGURLVector(
+      install_prefs.GetFirstRunTabs(), &out_prefs->new_tabs);
+
+  install_prefs.GetInt(installer::master_preferences::kDistroPingDelay,
+                       &out_prefs->ping_delay);
+
   bool value = false;
   if (install_prefs.GetBool(
           installer::master_preferences::kDistroImportSearchPref, &value)) {
     if (value) {
       out_prefs->do_import_items |= importer::SEARCH_ENGINES;
     } else {
       out_prefs->dont_import_items |= importer::SEARCH_ENGINES;
     }
   }
 
@@ skipping 45 matching lines @@
           &value) && value) {
     out_prefs->make_chrome_default = true;
   }
 
   if (install_prefs.GetBool(
           installer::master_preferences::kSuppressFirstRunDefaultBrowserPrompt,
           &value) && value) {
     out_prefs->suppress_first_run_default_browser_prompt = true;
   }
 
+  install_prefs.GetString(
+          installer::master_preferences::kDistroImportBookmarksFromFilePref,
+          &out_prefs->import_bookmarks_path);
+
   out_prefs->variations_seed = install_prefs.GetVariationsSeed();
 }
 
 void SetDefaultBrowser(installer::MasterPreferences* install_prefs){
   // Even on the first run we only allow for the user choice to take effect if
   // no policy has been set by the admin.
   if (!g_browser_process->local_state()->IsManagedPreference(
           prefs::kDefaultBrowserSettingEnabled)) {
     bool value = false;
     if (install_prefs->GetBool(
             installer::master_preferences::kMakeChromeDefaultForUser,
             &value) && value) {
       ShellIntegration::SetAsDefaultBrowser();
     }
   } else {
     if (g_browser_process->local_state()->GetBoolean(
             prefs::kDefaultBrowserSettingEnabled)) {
       ShellIntegration::SetAsDefaultBrowser();
     }
   }
 }
 
-void SetRLZPref(first_run::MasterPrefs* out_prefs,
-                installer::MasterPreferences* install_prefs) {
-  if (!install_prefs->GetInt(installer::master_preferences::kDistroPingDelay,
-                    &out_prefs->ping_delay)) {
-    // Default value in case master preferences is missing or corrupt,
-    // or ping_delay is missing.
-    out_prefs->ping_delay = 90;
+bool ImportSettings(Profile* profile,

[gab, 2013/03/26 15:55:25]

Moved from first_run_posix.cc

+                    scoped_refptr<ImporterHost> importer_host,
+                    scoped_refptr<ImporterList> importer_list,
+                    int items_to_import) {
+  const importer::SourceProfile& source_profile =
+      importer_list->GetSourceProfileAt(0);
+
+  // Ensure that importers aren't requested to import items that they do not
+  // support. If there is no overlap, skip.
+  items_to_import &= source_profile.services_supported;
+  if (items_to_import == 0)
+    return true;
+
+  scoped_ptr<ImportEndedObserver> observer(new ImportEndedObserver);
+  importer_host->SetObserver(observer.get());
+  importer_host->StartImportSettings(source_profile,
+                                     profile,
+                                     items_to_import,
+                                     new ProfileWriter(profile),
+                                     true);
+  // If the import process has not errored out, block on it.
+  if (!observer->ended()) {
+    observer->set_should_quit_message_loop();
+    MessageLoop::current()->Run();
   }
+
+  // Unfortunately there's no success/fail signal in ImporterHost.
+  return true;
 }
 
 // -- Platform-specific functions --
 
 #if !defined(OS_LINUX) && !defined(OS_BSD)
 bool IsOrganicFirstRun() {
   std::string brand;
   google_util::GetBrand(&brand);
   return google_util::IsOrganicFirstRun(brand);
 }
@@ skipping 74 matching lines @@
           prefs::kShowFirstRunBubbleOption) != FIRST_RUN_BUBBLE_SUPPRESS) {
     // Set the new state as long as the bubble wasn't explicitly suppressed
     // already.
     local_state->SetInteger(prefs::kShowFirstRunBubbleOption,
                             show_bubble_option);
   }
   return true;
 }
 
 void SetShouldShowWelcomePage() {
-  should_show_welcome_page_ = true;
+  g_should_show_welcome_page = true;
 }
 
 bool ShouldShowWelcomePage() {
-  bool retval = should_show_welcome_page_;
-  should_show_welcome_page_ = false;
+  bool retval = g_should_show_welcome_page;
+  g_should_show_welcome_page = false;
   return retval;
 }
 
 void SetShouldDoPersonalDataManagerFirstRun() {
-  should_do_autofill_personal_data_manager_first_run_ = true;
+  g_should_do_autofill_personal_data_manager_first_run = true;
 }
 
 bool ShouldDoPersonalDataManagerFirstRun() {
-  bool retval = should_do_autofill_personal_data_manager_first_run_;
-  should_do_autofill_personal_data_manager_first_run_ = false;
+  bool retval = g_should_do_autofill_personal_data_manager_first_run;
+  g_should_do_autofill_personal_data_manager_first_run = false;
   return retval;
 }
 
 void LogFirstRunMetric(FirstRunBubbleMetric metric) {
   UMA_HISTOGRAM_ENUMERATION("FirstRun.SearchEngineBubble", metric,
                             NUM_FIRST_RUN_BUBBLE_METRICS);
 }
 
 namespace {
 CommandLine* GetExtraArgumentsInstance() {
@@ skipping 96 matching lines @@
 #if defined(OS_CHROMEOS)
   // Chrome OS has its own out-of-box-experience code.  Create the sentinel to
   // mark the fact that we've run once but skip the full first-run flow.
   CreateSentinel();
   return SKIP_FIRST_RUN_TASKS;
 #endif
 
   base::FilePath master_prefs_path;
   scoped_ptr<installer::MasterPreferences>
       install_prefs(internal::LoadMasterPrefs(&master_prefs_path));
-  if (!install_prefs.get())
-    return DO_FIRST_RUN_TASKS;
 
-  ConvertStringVectorToGURLVector(

[gab, 2013/03/26 15:55:25]

Moved this as well and SetRLZPref() below directly into
SetupMasterPrefsFromInstallPrefs() where all such mappings belong.

-      install_prefs->GetFirstRunTabs(), &out_prefs->new_tabs);
+  // Default value in case master preferences is missing or corrupt, or
+  // ping_delay is missing.
+  out_prefs->ping_delay = 90;
+  if (install_prefs.get()) {
+    if (!internal::ShowPostInstallEULAIfNeeded(install_prefs.get()))
+      return EULA_EXIT_NOW;
 
-  internal::SetRLZPref(out_prefs, install_prefs.get());
+    if (!internal::CopyPrefFile(user_data_dir, master_prefs_path))
+      DLOG(ERROR) << "Failed to copy master_preferences to user data dir.";
 
-  if (!internal::ShowPostInstallEULAIfNeeded(install_prefs.get()))
-    return EULA_EXIT_NOW;
+    DoDelayedInstallExtensionsIfNeeded(install_prefs.get());
 
-  if (!internal::CopyPrefFile(user_data_dir, master_prefs_path))
-    DLOG(ERROR) << "Failed to copy master_preferences to user data dir.";
+    internal::SetupMasterPrefsFromInstallPrefs(*install_prefs, out_prefs);
 
-  DoDelayedInstallExtensionsIfNeeded(install_prefs.get());
-
-  internal::SetupMasterPrefsFromInstallPrefs(*install_prefs, out_prefs);
-
-  internal::SetImportPreferencesAndLaunchImport(out_prefs, install_prefs.get());
-  internal::SetDefaultBrowser(install_prefs.get());
+    internal::SetDefaultBrowser(install_prefs.get());
+  }
 
   return DO_FIRST_RUN_TASKS;
 }
 
 void AutoImport(
     Profile* profile,
     bool homepage_defined,
     int import_items,
     int dont_import_items,
     ProcessSingleton* process_singleton) {
@@ skipping 46 matching lines @@
       }
     }
 
     PrefService* user_prefs = profile->GetPrefs();
 
     SetImportItem(user_prefs,
                   prefs::kImportHistory,
                   import_items,
                   dont_import_items,
                   importer::HISTORY,
-                  items);
+                  &items);
     SetImportItem(user_prefs,
                   prefs::kImportHomepage,
                   import_items,
                   dont_import_items,
                   importer::HOME_PAGE,
-                  items);
+                  &items);
     SetImportItem(user_prefs,
                   prefs::kImportSearchEngine,
                   import_items,
                   dont_import_items,
                   importer::SEARCH_ENGINES,
-                  items);
+                  &items);
     SetImportItem(user_prefs,
                   prefs::kImportBookmarks,
                   import_items,
                   dont_import_items,
                   importer::FAVORITES,
-                  items);
+                  &items);
 
-    profile_import_exited_successfully =
+    internal::g_profile_import_exited_successfully =
         internal::ImportSettings(profile, importer_host, importer_list, items);
-    DCHECK(profile_import_exited_successfully);
+    DCHECK(internal::g_profile_import_exited_successfully);
   }
 
   content::RecordAction(UserMetricsAction("FirstRunDef_Accept"));
 
   process_singleton->Unlock();
-  first_run::CreateSentinel();

[gab, 2013/03/26 15:55:25]

Sentinel creation doesn't belong here imo. Moved into as part of the first run
tasks of chrome_browser_main

 #endif  // !defined(USE_AURA)
-  did_perform_profile_import = true;
+  internal::g_did_perform_profile_import = true;
 }
 
 void DoPostImportTasks(Profile* profile, bool make_chrome_default) {
   if (make_chrome_default &&
       ShellIntegration::CanSetAsDefaultBrowser() ==
           ShellIntegration::SET_DEFAULT_UNATTENDED) {
     ShellIntegration::SetAsDefaultBrowser();
   }
 
 #if !defined(USE_AURA)
@@ skipping 14 matching lines @@
     FirstRunBubbleLauncher::ShowFirstRunBubbleSoon();
   SetShouldShowWelcomePage();
   SetShouldDoPersonalDataManagerFirstRun();
 #endif  // !defined(USE_AURA)
 
   internal::DoPostImportPlatformSpecificTasks();
 }
 
 bool DidPerformProfileImport(bool* exited_successfully) {
   if (exited_successfully)
-    *exited_successfully = profile_import_exited_successfully;
-  return did_perform_profile_import;
+    *exited_successfully = internal::g_profile_import_exited_successfully;
+  return internal::g_did_perform_profile_import;
 }
 
 }  // namespace first_run