Fixes for first run path....

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>
 
@@ skipping 145 matching lines @@
   if (terms.empty())
     return false;
   FilePath temp_dir;
   if (!file_util::GetTempDir(&temp_dir))
     return false;
   *eula_path = temp_dir.Append(L"chrome_eula_iframe.html");
   return (file_util::WriteFile(*eula_path, terms.data(), terms.size()) > 0);
 }
 
 // Helper class that performs delayed first-run tasks that need more of the
-// chrome infrastructure to be up an running before they can be attempted.
-class FirsRunDelayedTasks : public NotificationObserver {
+// chrome infrastructure to be up and running before they can be attempted.
+class FirstRunDelayedTasks : public NotificationObserver {
  public:
   enum Tasks {
     NO_TASK,
     INSTALL_EXTENSIONS
   };
 
-  explicit FirsRunDelayedTasks(Tasks task) {
+  explicit FirstRunDelayedTasks(Tasks task) {
     if (task == INSTALL_EXTENSIONS) {
       registrar_.Add(this, NotificationType::EXTENSIONS_READY,
                      NotificationService::AllSources());
     }
     registrar_.Add(this, NotificationType::BROWSER_CLOSED,
                    NotificationService::AllSources());
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     // After processing the notification we always delete ourselves.
     if (type.value == NotificationType::EXTENSIONS_READY)
       DoExtensionWork(Source<Profile>(source).ptr()->GetExtensionsService());
     delete this;
     return;
   }
 
  private:
   // Private ctor forces it to be created only in the heap.
-  ~FirsRunDelayedTasks() {}
+  ~FirstRunDelayedTasks() {}
 
   // The extension work is to basically trigger an extension update check.
   // If the extension specified in the master pref is older than the live
   // extension it will get updated which is the same as get it installed.
   void DoExtensionWork(ExtensionsService* service) {
     if (!service)
       return;
     service->updater()->CheckNow();
     return;
   }
@@ skipping 91 matching lines @@
     return true;
 
   // The master prefs are regular prefs so we can just copy the file
   // to the default place and they just work.
   if (!file_util::CopyFile(master_prefs, user_prefs))
     return true;
 
   DictionaryValue* extensions = 0;
   if (installer_util::HasExtensionsBlock(prefs.get(), &extensions)) {
     LOG(INFO) << "Extensions block found in master preferences";
-    new FirsRunDelayedTasks(FirsRunDelayedTasks::INSTALL_EXTENSIONS);
+    new FirstRunDelayedTasks(FirstRunDelayedTasks::INSTALL_EXTENSIONS);
   }
 
-  // Add a special exception for import_search_engine preference.
-  // Even though we skip all other import_* preferences below, if
-  // skip-first-run-ui is not specified, we make exception for this one
-  // preference.
+  // If the search engine dialog is not shown, the search engine is set to
+  // Google unless master_preferences specifically turns on search engine
+  // import.
   int import_items = 0;
   if (installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kDistroImportSearchPref, &value)) {
-    if (value) {
-      import_items += importer::SEARCH_ENGINES;
-      out_prefs->do_import_items += importer::SEARCH_ENGINES;
-    } else {
-      out_prefs->dont_import_items += importer::SEARCH_ENGINES;
-    }
+      installer_util::master_preferences::kDistroImportSearchPref, &value)
+      && value) {
+    import_items |= importer::SEARCH_ENGINES;
+    out_prefs->do_import_items |= importer::SEARCH_ENGINES;
   }
 
+  // Check to see if search engine logos should be randomized.
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kSearchEngineExperimentRandomizePref,
+      &value) && value)
+    out_prefs->randomize_search_engine_experiment = true;
+
   // If we're suppressing the first-run bubble, set that preference now.
   // Otherwise, wait until the user has completed first run to set it, so the
   // user is guaranteed to see the bubble iff he or she has completed the first
   // run process.
   if (installer_util::GetDistroBooleanPreference(prefs.get(),
       installer_util::master_preferences::kDistroSuppressFirstRunBubble,
       &value) && value)
     FirstRun::SetShowFirstRunBubblePref(false);
 
-  if (InSearchExperimentLocale() &&
-      installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kSearchEngineExperimentPref,
-      &value) && value) {
-    // Set the first run dialog to include the search choice window.
-    out_prefs->run_search_engine_experiment = true;
-    // Check to see if search engine logos should be randomized.
-    if (installer_util::GetDistroBooleanPreference(prefs.get(),
-        installer_util::master_preferences::
-            kSearchEngineExperimentRandomizePref,
-        &value) && value) {
-      out_prefs->randomize_search_engine_experiment = true;
+
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kDistroImportHistoryPref, &value)) {
+    if (value) {
+      import_items |= importer::HISTORY;
+    } else {
+      // Automatic history import can be turned off in master_prefs.
+      out_prefs->dont_import_items |= importer::HISTORY;
     }
-    // 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;
+      installer_util::master_preferences::kDistroImportHomePagePref, &value)) {
+    if (value) {
+      import_items |= importer::HOME_PAGE;
+    } else {
+      // Automatic home page import can be turned off in master_prefs.
+      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) {
+    import_items |= importer::FAVORITES;
     out_prefs->do_import_items |= importer::FAVORITES;
   }
 
+  if (installer_util::GetDistroBooleanPreference(prefs.get(),
+      installer_util::master_preferences::kMakeChromeDefaultForUser, &value) &&
+      value)
+    ShellIntegration::SetAsDefaultBrowser();
+
+  // TODO(mirandac): Refactor skip-first-run-ui process into regular first run
+  // import process.  http://crbug.com/49647
   // Note we are skipping all other master preferences if skip-first-run-ui
   // 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();
 
   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,
           importer_host->GetSourceProfileInfoAt(0).browser_type,
           import_items, import_bookmarks_path, NULL)) {
       LOG(WARNING) << "silent import failed";
     }
   }
 
-  if (installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kMakeChromeDefaultForUser, &value) &&
-      value)
-    ShellIntegration::SetAsDefaultBrowser();
-
   return false;
 }
 
 bool Upgrade::IsBrowserAlreadyRunning() {
   static HANDLE handle = NULL;
   std::wstring exe;
   PathService::Get(base::FILE_EXE, &exe);
   std::replace(exe.begin(), exe.end(), '\\', '!');
   std::transform(exe.begin(), exe.end(), exe.begin(), tolower);
   exe = L"Global\\" + exe;
@@ skipping 245 matching lines @@
           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();
     }
   }
 
+  FirstRun::SetShowFirstRunBubblePref(true);
+  // Set the first run bubble to minimal.
+  FirstRun::SetMinimalFirstRunBubblePref();
+
   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());
@@ skipping 377 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();
 }