Added group policies to enable/disable importing of data from other browsers.

chrome/browser/first_run/first_run.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/first_run/first_run_dialog.h"
 #include "chrome/browser/first_run/first_run_import_observer.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/prefs/pref_service.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/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
@@ skipping 66 matching lines @@
 // static
 bool FirstRun::ProcessMasterPreferences(const FilePath& user_data_dir,
                                         MasterPrefs* out_prefs) {
   DCHECK(!user_data_dir.empty());
 
   // The standard location of the master prefs is next to the chrome binary.
   FilePath master_prefs;
   if (!PathService::Get(base::DIR_EXE, &master_prefs))
     return true;
   master_prefs = master_prefs.AppendASCII(installer::kDefaultMasterPrefs);
-
   installer::MasterPreferences prefs(master_prefs);
   if (!prefs.read_from_file())
     return true;
 
   out_prefs->new_tabs = prefs.GetFirstRunTabs();
 
   bool value = false;
 
 #if defined(OS_WIN)
   // RLZ is currently a Windows-only phenomenon.  When it comes to the Mac/
@@ skipping 101 matching lines @@
     if (value) {
       out_prefs->do_import_items |= importer::HOME_PAGE;
     } else {
       out_prefs->dont_import_items |= importer::HOME_PAGE;
     }
   }
 
   // Bookmarks are never imported unless specifically turned on.
   if (prefs.GetBool(
           installer::master_preferences::kDistroImportBookmarksPref,
-          &value) && value) {
-    out_prefs->do_import_items |= importer::FAVORITES;
+          &value)) {
+    if (value) {

[James Hawkins, 2011/08/01 19:41:51]

Optional, but recommended: Don't use braces for one line logic blocks.

[simo, 2011/08/02 09:08:14]

Done.

+      out_prefs->do_import_items |= importer::FAVORITES;
+    } else {
+      out_prefs->dont_import_items |= importer::FAVORITES;
+    }
   }
 
   if (prefs.GetBool(
           installer::master_preferences::kMakeChromeDefaultForUser,
           &value) && value) {
     out_prefs->make_chrome_default = true;
   }
 
   // TODO(mirandac): Refactor skip-first-run-ui process into regular first run
   // import process.  http://crbug.com/49647
@@ skipping 274 matching lines @@
 
   scoped_refptr<ImporterList> importer_list(new ImporterList);
   importer_list->DetectSourceProfilesHack();
 
   // Do import if there is an available profile for us to import.
   if (importer_list->count() > 0) {
     // Don't show the warning dialog if import fails.
     importer_host->set_headless();
     int items = 0;
 
-    // History is always imported unless turned off in master_preferences.
-    if (!(dont_import_items & importer::HISTORY))
-      items = items | importer::HISTORY;
-    // Home page is imported in organic builds only unless turned off or
-    // defined in master_preferences.
     if (IsOrganicFirstRun()) {
-      if (!(dont_import_items & importer::HOME_PAGE) && !homepage_defined)
-        items = items | importer::HOME_PAGE;
-    } else {
-      if (import_items & importer::HOME_PAGE)
-        items = items | importer::HOME_PAGE;
-    }
-    // Search engines are only imported in certain builds unless overridden
-    // in master_preferences. Search engines are not imported automatically
-    // if the user already has a user preferences directory.
-    if (IsOrganicFirstRun()) {
-      if (!(dont_import_items & importer::SEARCH_ENGINES) &&
-          !local_state_file_exists) {
-        items = items | importer::SEARCH_ENGINES;
+      // Home page is imported in organic builds only unless turned off or
+      // defined in master_preferences.
+      if (homepage_defined) {
+        dont_import_items |= importer::HOME_PAGE;
+        if (import_items & importer::HOME_PAGE)
+          import_items &= ~importer::HOME_PAGE;
       }
-    } else if (import_items & importer::SEARCH_ENGINES) {
-        items = items | importer::SEARCH_ENGINES;
+      // Search engines are not imported automatically in organic builds if the
+      // user already has a user preferences directory.
+      if (local_state_file_exists) {
+        dont_import_items |= importer::SEARCH_ENGINES;
+        if (import_items & importer::SEARCH_ENGINES)
+          import_items &= ~importer::SEARCH_ENGINES;
+      }
     }
 
-    // Bookmarks are never imported, unless turned on in master_preferences.
-    if (import_items & importer::FAVORITES)
-      items = items | importer::FAVORITES;
+    PrefService* user_prefs = profile->GetPrefs();
+
+    SetImportItem(user_prefs,
+                  prefs::kImportHistory,
+                  import_items,
+                  dont_import_items,
+                  importer::HISTORY,
+                  items);
+    SetImportItem(user_prefs,
+                  prefs::kImportHomepage,
+                  import_items,
+                  dont_import_items,
+                  importer::HOME_PAGE,
+                  items);
+    SetImportItem(user_prefs,
+                  prefs::kImportSearchEngine,
+                  import_items,
+                  dont_import_items,
+                  importer::SEARCH_ENGINES,
+                  items);
+    SetImportItem(user_prefs,
+                  prefs::kImportBookmarks,
+                  import_items,
+                  dont_import_items,
+                  importer::FAVORITES,
+                  items);
 
     ImportSettings(profile, importer_host, importer_list, items);
   }
 
   UserMetrics::RecordAction(UserMetricsAction("FirstRunDef_Accept"));
 
   // Launch the search engine dialog only for certain builds, and only if the
   // user has not already set preferences.
   if (IsOrganicFirstRun() && !local_state_file_exists) {
     // The home page string may be set in the preferences, but the user should
@@ skipping 14 matching lines @@
     // Set the first run bubble to minimal.
     FirstRun::SetMinimalFirstRunBubblePref();
   }
   FirstRun::SetShowWelcomePagePref();
   FirstRun::SetPersonalDataManagerFirstRunPref();
 
   process_singleton->Unlock();
   FirstRun::CreateSentinel();
 }
 
+// static
+void FirstRun::SetImportItem(PrefService* user_prefs,
+                             const char* pref_path,
+                             int import_items,
+                             int dont_import_items,
+                             importer::ImportItem import_type,
+                             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;
+  bool master_pref = (import_items & ~dont_import_items) & import_type;
+
+  if (import_type == importer::HISTORY
+      || ((import_type != importer::FAVORITES) && 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;
+  } else { // no policy (recommended or managed) is set
+    if (should_import)
+      items |= import_type;
+  }
+
+  user_prefs->ClearPref(pref_path);
+}
+
 #if defined(OS_POSIX)
 namespace {
 
 // 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),
@@ skipping 52 matching lines @@
   if (!observer->ended()) {
     observer->set_should_quit_message_loop();
     MessageLoop::current()->Run();
   }
 
   // Unfortunately there's no success/fail signal in ImporterHost.
   return true;
 }
 
 #endif  // OS_POSIX