Turning on MultiProfile by default for ChromeOS

chrome/browser/prefs/pref_hash_browsertest.cc

 // Copyright 2014 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 <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_CHROMEOS)
+#include "chromeos/chromeos_switches.h"
+#endif
+
 namespace {
 
 // An observer that returns back to test code after a new profile is
 // initialized.
 void OnUnblockOnProfileCreation(const base::Closure& callback,
                                 Profile* profile,
                                 Profile::CreateStatus status) {
   switch (status) {
     case Profile::CREATE_STATUS_CREATED:
       // Wait for CREATE_STATUS_INITIALIZED.
@@ skipping 54 matching lines @@
   PrefHashBrowserTest()
       : is_unloaded_profile_seeding_allowed_(
             IsUnloadedProfileSeedingAllowed()) {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     InProcessBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         switches::kForceFieldTrials,
         std::string(chrome_prefs::internals::kSettingsEnforcementTrialName) +
             "/" + GetParam() + "/");
+#if defined(OS_CHROMEOS)
+    command_line->AppendSwitch(
+        chromeos::switches::kIgnoreUserProfileMappingForTests);
+#endif
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     // Force the delayed PrefHashStore update task to happen immediately with
     // no domain check (bots are on a domain).
     chrome_prefs::DisableDelaysAndDomainCheckForTesting();
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     // content::RunAllPendingInMessageLoop() is already called before
@@ skipping 38 matching lines @@
 #define MAYBE_PRE_InitializeUnloadedProfiles DISABLED_PRE_InitializeUnloadedProfiles
 #define MAYBE_InitializeUnloadedProfiles DISABLED_InitializeUnloadedProfiles
 #else
 #define MAYBE_PRE_PRE_InitializeUnloadedProfiles PRE_PRE_InitializeUnloadedProfiles
 #define MAYBE_PRE_InitializeUnloadedProfiles PRE_InitializeUnloadedProfiles
 #define MAYBE_InitializeUnloadedProfiles InitializeUnloadedProfiles
 #endif
 
 IN_PROC_BROWSER_TEST_P(PrefHashBrowserTest,
                        MAYBE_PRE_PRE_InitializeUnloadedProfiles) {
-  if (!profiles::IsMultipleProfilesEnabled())
-    return;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Create an additional profile.
   const base::FilePath new_path =
       profile_manager->GenerateNextProfileDirectoryPath();
   const scoped_refptr<content::MessageLoopRunner> runner(
       new content::MessageLoopRunner);
   profile_manager->CreateProfileAsync(
       new_path,
       base::Bind(&OnUnblockOnProfileCreation, runner->QuitClosure()),
       base::string16(),
       base::string16(),
       std::string());
 
   // Spin to allow profile creation to take place, loop is terminated
   // by OnUnblockOnProfileCreation when the profile is created.
   runner->Run();
 
   // No profile should have gone through the unloaded profile initialization in
   // this phase as both profiles should have been loaded normally.
   EXPECT_EQ(
       0, GetTrackedPrefHistogramCount(
              "Settings.TrackedPreferencesAlternateStoreVersionUpdatedFrom",
              true));
 }
 
 IN_PROC_BROWSER_TEST_P(PrefHashBrowserTest,
                        MAYBE_PRE_InitializeUnloadedProfiles) {
-  if (!profiles::IsMultipleProfilesEnabled())
-    return;
-
   // Creating the profile would have initialized its hash store. Also, we don't
   // know whether the newly created or original profile will be launched (does
   // creating a profile cause it to be the most recently used?).
 
   // So we will find the profile that isn't loaded, reset its hash store, and
   // then verify in the _next_ launch that it is, indeed, restored despite not
   // having been loaded.
 
   const base::DictionaryValue* hashes =
       g_browser_process->local_state()->GetDictionary(
@@ skipping 14 matching lines @@
   // this phase (resetting the unloaded profile's PrefHashStore should only
   // force initialization in the next phase's startup).
   EXPECT_EQ(
       0, GetTrackedPrefHistogramCount(
              "Settings.TrackedPreferencesAlternateStoreVersionUpdatedFrom",
              true));
 }
 
 IN_PROC_BROWSER_TEST_P(PrefHashBrowserTest,
                        MAYBE_InitializeUnloadedProfiles) {
-  if (!profiles::IsMultipleProfilesEnabled())
-    return;
-
   const base::DictionaryValue* hashes =
       g_browser_process->local_state()->GetDictionary(
           prefs::kProfilePreferenceHashes);
 
   // The deleted hash collection should be restored only if the current
   // SettingsEnforcement group allows it.
   if (is_unloaded_profile_seeding_allowed_) {
     EXPECT_EQ(4U, hashes->size());
 
     // Verify that the initialization truly did occur in this phase's startup;
@@ skipping 73 matching lines @@
     PrefHashBrowserTestInstance,
     PrefHashBrowserTest,
     testing::Values(
         chrome_prefs::internals::kSettingsEnforcementGroupNoEnforcement,
         chrome_prefs::internals::kSettingsEnforcementGroupEnforceOnload,
         chrome_prefs::internals::kSettingsEnforcementGroupEnforceAlways,
         chrome_prefs::internals::
             kSettingsEnforcementGroupEnforceAlwaysWithExtensions,
         chrome_prefs::internals::
             kSettingsEnforcementGroupEnforceAlwaysWithExtensionsAndDSE));