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"
@@ skipping 39 matching lines @@
       ProfileManager::GetDefaultProfileDir(user_data_dir);
   if (create_profile_dir) {
     if (!file_util::PathExists(default_pref_dir)) {
       if (!file_util::CreateDirectory(default_pref_dir))
         return FilePath();
     }
   }
   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) {
+  // 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) &&
+      FirstRun::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);
+}
+
 }  // namespace
 
 // FirstRun -------------------------------------------------------------------
 
 FirstRun::FirstRunState FirstRun::first_run_ = FIRST_RUN_UNKNOWN;
 
 FirstRun::MasterPrefs::MasterPrefs()
     : ping_delay(0),
       homepage_defined(false),
       do_import_items(0),
@@ skipping 28 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)
+      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 86 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