New first run sequence for Windows.

chrome/browser/first_run_win.cc

 // Copyright (c) 2010 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.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <set>
 #include <sstream>
 
 // TODO(port): trim this include list once first run has been refactored fully.
 #include "app/app_switches.h"
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/object_watcher.h"
 #include "base/path_service.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/registry.h"
 #include "base/scoped_comptr_win.h"
 #include "base/string_util.h"
+#include "base/win_util.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/hang_monitor/hung_window_detector.h"
 #include "chrome/browser/importer/importer.h"
 #include "chrome/browser/importer/importer_data_types.h"
+#include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/shell_integration.h"
-#include "chrome/browser/views/first_run_view.h"
+#include "chrome/browser/views/first_run_search_engine_view.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "google_update_idl.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "views/background.h"
 #include "views/controls/button/image_button.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/button/radio_button.h"
 #include "views/controls/image_view.h"
 #include "views/controls/label.h"
 #include "views/controls/link.h"
 #include "views/focus/accelerator_handler.h"
 #include "views/grid_layout.h"
 #include "views/standard_layout.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_win.h"
 #include "views/window/window.h"
+#include "views/window/window_delegate.h"
+#include "views/window/window_win.h"
 
 namespace {
 
 bool GetNewerChromeFile(FilePath* path) {
   if (!PathService::Get(base::DIR_EXE, path))
     return false;
   *path = path->Append(installer_util::kChromeNewExe);
   return true;
 }
 
@@ skipping 252 matching lines @@
     if (installer_util::GetDistroBooleanPreference(prefs.get(),
         installer_util::master_preferences::
             kSearchEngineExperimentRandomizePref,
         &value) && value) {
       out_prefs->randomize_search_engine_experiment = true;
     }
     // Set the first run bubble to minimal.
     FirstRun::SetMinimalFirstRunBubblePref();
   }
 
+  // History is imported automatically, unless turned off in master_prefs.
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kDistroImportHistoryPref, &value)
+      && !value) {
+    out_prefs->dont_import_items |= importer::HISTORY;
+  }
+
+  // Home page is imported automatically only in organic builds, and can be
+  // turned off in master_prefs.
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kDistroImportHomePagePref, &value)
+      && !value) {
+    out_prefs->dont_import_items |= importer::HOME_PAGE;
+  }
+
+  // Bookmarks are never imported unless specifically turned on.
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kDistroImportBookmarksPref, &value)
+      && value) {
+    out_prefs->do_import_items |= importer::FAVORITES;
+  }
+
   // Note we are skipping all other master preferences if skip-first-run-ui
-  // is *not* specified.
+  // is *not* specified. (That is, we continue only if skipping first run ui.)
   if (!installer_util::GetDistroBooleanPreference(prefs.get(),
       installer_util::master_preferences::kDistroSkipFirstRunPref, &value) ||
       !value)
     return true;
 
   // From here on we won't show first run so we need to do the work to show the
   // bubble anyway, unless it's already been explicitly suppressed.
   FirstRun::SetShowFirstRunBubblePref(true);
 
   // We need to be able to create the first run sentinel or else we cannot
   // proceed because ImportSettings will launch the importer process which
   // would end up here if the sentinel is not present.
   if (!FirstRun::CreateSentinel())
     return false;
 
   if (installer_util::GetDistroBooleanPreference(prefs.get(),
       installer_util::master_preferences::kDistroShowWelcomePage, &value) &&
       value)
     FirstRun::SetShowWelcomePagePref();
 
-  if (installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kDistroImportHistoryPref, &value) &&
-      value)
-    import_items += importer::HISTORY;
-  if (installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kDistroImportBookmarksPref, &value) &&
-      value)
-    import_items += importer::FAVORITES;
-  if (installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kDistroImportHomePagePref, &value) &&
-      value)
-    import_items += importer::HOME_PAGE;
-
   std::wstring import_bookmarks_path;
   installer_util::GetDistroStringPreference(prefs.get(),
       installer_util::master_preferences::kDistroImportBookmarksFromFilePref,
       &import_bookmarks_path);
 
   if (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<ImporterHost> importer_host = new ImporterHost();
     if (!FirstRun::ImportSettings(NULL,
@@ skipping 91 matching lines @@
 }
 
 // static
 bool Upgrade::IsUpdatePendingRestart() {
   FilePath new_chrome_exe;
   if (!GetNewerChromeFile(&new_chrome_exe))
     return false;
   return file_util::PathExists(new_chrome_exe);
 }
 
-bool OpenFirstRunDialog(Profile* profile,
-                        bool homepage_defined,
-                        int import_items,
-                        int dont_import_items,
-                        bool search_engine_experiment,
-                        bool randomize_search_engine_experiment,
-                        ProcessSingleton* process_singleton) {
-  DCHECK(profile);
-  DCHECK(process_singleton);
-
-  // We need the FirstRunView to outlive its parent, as we retrieve the accept
-  // state from it after the dialog has been closed.
-  scoped_ptr<FirstRunView> first_run_view(
-      new FirstRunView(profile,
-                       homepage_defined,
-                       import_items,
-                       dont_import_items,
-                       search_engine_experiment,
-                       randomize_search_engine_experiment));
-  first_run_view->set_parent_owned(false);
-  views::Window* first_run_ui = views::Window::CreateChromeWindow(
-      NULL, gfx::Rect(), first_run_view.get());
-  DCHECK(first_run_ui);
-
-  // We need to avoid dispatching new tabs when we are doing the import
-  // because that will lead to data corruption or a crash. Lock() does that.
-  // If a CopyData message does come in while the First Run UI is visible,
-  // then we will attempt to set first_run_ui as the foreground window.
-  process_singleton->Lock(first_run_ui->GetNativeWindow());
-
-  first_run_ui->Show();
-
-  // We must now run a message loop (will be terminated when the First Run UI
-  // is closed) so that the window can receive messages and we block the
-  // browser window from showing up. We pass the accelerator handler here so
-  // that keyboard accelerators (Enter, Esc, etc) work in the dialog box.
-  views::AcceleratorHandler accelerator_handler;
-  MessageLoopForUI::current()->Run(&accelerator_handler);
-  process_singleton->Unlock();
-
-  return first_run_view->accepted();
-}
-
 namespace {
 
 // This class is used by FirstRun::ImportSettings to determine when the import
 // process has ended and what was the result of the operation as reported by
 // the process exit code. This class executes in the context of the main chrome
 // process.
 class ImportProcessRunner : public base::ObjectWatcher::Delegate {
  public:
   // The constructor takes the importer process to watch and then it does a
   // message loop blocking wait until the process ends. This object now owns
@@ skipping 90 matching lines @@
 
   if (!StringToInt(v[1], options))
     return false;
 
   *window = reinterpret_cast<HWND>(StringToInt64(v[2]));
   return true;
 }
 
 }  // namespace
 
+void FirstRun::AutoImport(Profile* profile,
+    bool homepage_defined,
+    int import_items,
+    int dont_import_items,
+    bool search_engine_experiment,
+    bool randomize_search_engine_experiment,
+    ProcessSingleton* process_singleton) {
+  FirstRun::CreateChromeDesktopShortcut();
+  // Windows 7 has deprecated the quick launch bar.
+  if (win_util::GetWinVersion() < win_util::WINVERSION_WIN7)
+    CreateChromeQuickLaunchShortcut();
+
+  scoped_refptr<ImporterHost> importer_host;
+  importer_host = new ImporterHost();
+  int items = 0;
+  // History and home page are always imported unless turned off in
+  // master_preferences.
+  if (!(dont_import_items & importer::HISTORY))
+    items = items | importer::HISTORY;
+  if (!((dont_import_items & importer::HOME_PAGE) || homepage_defined))
+    items = items | importer::HOME_PAGE;
+
+  // Search engine and bookmarks are never imported unless turned on
+  // in master_preferences.
+  if (import_items & importer::SEARCH_ENGINES)
+    items = items | importer::SEARCH_ENGINES;
+  if (import_items & importer::FAVORITES)
+    items = items | importer::FAVORITES;
+  // We need to avoid dispatching new tabs when we are importing because
+  // that will lead to data corruption or a crash. Because there is no UI for
+  // the import process, we pass NULL as the window to bring to the foreground
+  // when a CopyData message comes in; this causes the message to be silently
+  // discarded, which is the correct behavior during the import process.
+  process_singleton->Lock(NULL);
+
+  // Index 0 is the default browser.
+  FirstRun::ImportSettings(profile,
+      importer_host->GetSourceProfileInfoAt(0).browser_type, items, NULL);
+  UserMetrics::RecordAction(UserMetricsAction("FirstRunDef_Accept"));
+
+  // Launch the search engine dialog only if build is organic.
+  std::wstring brand;
+  GoogleUpdateSettings::GetBrand(&brand);
+  if (GoogleUpdateSettings::IsOrganic(brand)) {
+    // The home page string may be set in the preferences, but the user should
+    // initially use Chrome with the NTP as home page in organic builds.
+    profile->GetPrefs()->SetBoolean(prefs::kHomePageIsNewTabPage, true);
+
+    // Search engine dialog is shown in organic builds unless overridden by
+    // master_preferences.
+    if (!(import_items & importer::SEARCH_ENGINES)) {
+      views::Window* search_engine_dialog = views::Window::CreateChromeWindow(
+          NULL,
+          gfx::Rect(),
+          new FirstRunSearchEngineView(profile,
+          randomize_search_engine_experiment));
+      DCHECK(search_engine_dialog);
+
+      search_engine_dialog->Show();
+      views::AcceleratorHandler accelerator_handler;
+      MessageLoopForUI::current()->Run(&accelerator_handler);
+      search_engine_dialog->Close();
+    }
+  }
+
+  process_singleton->Unlock();
+  FirstRun::CreateSentinel();
+}
+
 bool FirstRun::ImportSettings(Profile* profile, int browser_type,
                               int items_to_import,
                               const std::wstring& import_bookmarks_path,
                               HWND parent_window) {
   const CommandLine& cmdline = *CommandLine::ForCurrentProcess();
   CommandLine import_cmd(cmdline.GetProgram());
   // Propagate user data directory switch.
   if (cmdline.HasSwitch(switches::kUserDataDir)) {
     import_cmd.AppendSwitchWithValue(
         switches::kUserDataDir,
@@ skipping 373 matching lines @@
 
 Upgrade::TryResult Upgrade::ShowTryChromeDialog(size_t version) {
   if (version > 10000) {
     // This is a test value. We want to make sure we exercise
     // returning this early. See EarlyReturnTest test harness.
     return Upgrade::TD_NOT_NOW;
   }
   TryChromeDialog td;
   return td.ShowModal();
 }