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"
@@ skipping 10 matching lines @@
 #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 {
+ 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();

[Joao da Silva, 2013/03/12 13:32:05]

#include "base/message_loop.h"

[gab, 2013/03/25 16:00:43]

Done.

+  }
+
+  void set_should_quit_message_loop() {
+    should_quit_message_loop_ = true;
+  }
+
+  bool ended() {

[Joao da Silva, 2013/03/12 13:32:05]

nit: const method

[gab, 2013/03/25 16:00:43]

Note that this is a pure move from first_run_posix.cc, but sure.

+    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())) {
@@ skipping 13 matching lines @@
   // 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,
+                    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.

[cpu_(ooo_6.6-7.5), 2013/03/11 20:54:20]

don't we watch the process handle and get the exit code?

[gab, 2013/03/12 12:32:19]

That's a pure copy/paste from first_run_posix.cc; I figured since the Windows
one is no longer used I would remove it from the platform specific section (or I
could leave it there and make the Windows impl NOTREACHED()...

+  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(
-      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());

[cpu_(ooo_6.6-7.5), 2013/03/11 20:56:05]

where did the rlz stuff go?

[gab, 2013/03/12 12:32:19]

Down in SetupMasterPrefsFromInstallPrefs() beside every other pref mapped from
|install_prefs| to |out_prefs|.

[Joao da Silva, 2013/03/12 13:32:05]

SetRLZPref() used to happen before potentially returning EULA_EXIT_NOW, but not
that exit path comes before. Is it OK not to set the RLZ prefs with returning
EULA_EXIT_NOW?

[gab, 2013/03/25 16:00:43]

Returning EULA_EXIT_NOW means the user refused the EULA and the browser will
immediately exit
(https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/chr...).

SetRLZPref() is only setting some in-memory state which is irrelevant if exiting
the browser immediately.

Also note that the First Run sentinel hasn't been created at that point so if
Chrome is launched again and the EULA accepted it will still go through the full
First Run experience.

+    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::SetDefaultBrowser(install_prefs.get());
+  }
 
-  internal::SetupMasterPrefsFromInstallPrefs(*install_prefs, out_prefs);
-
-  internal::SetImportPreferencesAndLaunchImport(out_prefs, install_prefs.get());
-  internal::SetDefaultBrowser(install_prefs.get());
+  internal::SetImportPreferencesAndLaunchImport(out_prefs);
 
   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();
 #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