c/browser, c/common, components O-P: Change ScopedTempDir::path() to GetPath()

chrome/browser/profiles/profile_manager_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 115 matching lines @@
   };
 
   ProfileManagerTest()
       : local_state_(TestingBrowserProcess::GetGlobal()) {
   }
 
   void SetUp() override {
     // Create a new temporary directory, and store the path
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     TestingBrowserProcess::GetGlobal()->SetProfileManager(
-        new UnittestProfileManager(temp_dir_.path()));
+        new UnittestProfileManager(temp_dir_.GetPath()));
 
 #if defined(OS_CHROMEOS)
     base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
     cl->AppendSwitch(switches::kTestType);
     chromeos::WallpaperManager::Initialize();
 #endif
   }
 
   void TearDown() override {
     TestingBrowserProcess::GetGlobal()->SetProfileManager(NULL);
     base::RunLoop().RunUntilIdle();
 #if defined(OS_CHROMEOS)
     chromeos::WallpaperManager::Shutdown();
 #endif
   }
 
   // Helper function to create a profile with |name| for a profile |manager|.
   void CreateProfileAsync(ProfileManager* manager,
                           const std::string& name,
                           bool is_supervised,
                           MockObserver* mock_observer) {
-    manager->CreateProfileAsync(
-        temp_dir_.path().AppendASCII(name),
-        base::Bind(&MockObserver::OnProfileCreated,
-                   base::Unretained(mock_observer)),
-        base::UTF8ToUTF16(name),
-        profiles::GetDefaultAvatarIconUrl(0),
-        is_supervised ? "Dummy ID" : std::string());
+    manager->CreateProfileAsync(temp_dir_.GetPath().AppendASCII(name),
+                                base::Bind(&MockObserver::OnProfileCreated,
+                                           base::Unretained(mock_observer)),
+                                base::UTF8ToUTF16(name),
+                                profiles::GetDefaultAvatarIconUrl(0),
+                                is_supervised ? "Dummy ID" : std::string());
   }
 
   // Helper function to add a profile with |profile_name| to |profile_manager|'s
   // ProfileAttributesStorage, and return the profile created.
   Profile* AddProfileToStorage(ProfileManager* profile_manager,
                                const std::string& path_suffix,
                                const base::string16& profile_name) {
     ProfileAttributesStorage& storage =
         profile_manager->GetProfileAttributesStorage();
     size_t num_profiles = storage.GetNumberOfProfiles();
-    base::FilePath path = temp_dir_.path().AppendASCII(path_suffix);
+    base::FilePath path = temp_dir_.GetPath().AppendASCII(path_suffix);
     storage.AddProfile(path, profile_name, std::string(), base::string16(), 0,
                        std::string());
     EXPECT_EQ(num_profiles + 1u, storage.GetNumberOfProfiles());
     return profile_manager->GetProfile(path);
   }
 
 #if defined(OS_CHROMEOS)
   // Helper function to register an user with id |user_id| and create profile
   // with a correct path.
   void RegisterUser(const std::string& user_id) {
@@ skipping 17 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
 
 #if defined(OS_CHROMEOS)
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ProfileManagerTest);
 };
 
 TEST_F(ProfileManagerTest, GetProfile) {
-  base::FilePath dest_path = temp_dir_.path();
+  base::FilePath dest_path = temp_dir_.GetPath();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create a profile.
   Profile* profile = profile_manager->GetProfile(dest_path);
   EXPECT_TRUE(profile);
 
   // The profile already exists when we call GetProfile. Just load it.
   EXPECT_EQ(profile, profile_manager->GetProfile(dest_path));
@@ skipping 40 matching lines @@
   user_manager->SwitchActiveUser(test_account_id);
 
   profile_manager->Observe(
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::NotificationService::AllSources(),
       content::Details<const user_manager::User>(active_user));
   base::FilePath expected_logged_in(
       chromeos::ProfileHelper::GetUserProfileDir(active_user->username_hash()));
   EXPECT_EQ(expected_logged_in.value(),
             profile_manager->GetInitialProfileDir().value());
-  VLOG(1) << temp_dir_.path().Append(
-      profile_manager->GetInitialProfileDir()).value();
+  VLOG(1) << temp_dir_.GetPath()
+                 .Append(profile_manager->GetInitialProfileDir())
+                 .value();
 }
 
 #endif
 
 TEST_F(ProfileManagerTest, CreateAndUseTwoProfiles) {
-  base::FilePath dest_path1 = temp_dir_.path();
+  base::FilePath dest_path1 = temp_dir_.GetPath();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 
-  base::FilePath dest_path2 = temp_dir_.path();
+  base::FilePath dest_path2 = temp_dir_.GetPath();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profiles.
   TestingProfile* profile1 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(profile1);
 
   TestingProfile* profile2 =
@@ skipping 141 matching lines @@
   EXPECT_FALSE(storage.GetAllProfilesAttributesSortedByName()[1u]->IsOmitted());
 }
 
 TEST_F(ProfileManagerTest, AddProfileToStorageCheckOmitted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ProfileAttributesStorage& storage =
       profile_manager->GetProfileAttributesStorage();
   EXPECT_EQ(0u, storage.GetNumberOfProfiles());
 
   const base::FilePath supervised_path =
-      temp_dir_.path().AppendASCII("Supervised");
+      temp_dir_.GetPath().AppendASCII("Supervised");
   TestingProfile* supervised_profile =
       new TestingProfile(supervised_path, NULL);
   supervised_profile->GetPrefs()->SetString(prefs::kSupervisedUserId, "An ID");
 
   // RegisterTestingProfile adds the profile to the cache and takes ownership.
   profile_manager->RegisterTestingProfile(supervised_profile, true, false);
   EXPECT_EQ(1u, storage.GetNumberOfProfiles());
   EXPECT_TRUE(storage.GetAllProfilesAttributesSortedByName()[0u]->IsOmitted());
 
-  const base::FilePath nonsupervised_path = temp_dir_.path().AppendASCII(
-      "Non-Supervised");
+  const base::FilePath nonsupervised_path =
+      temp_dir_.GetPath().AppendASCII("Non-Supervised");
   TestingProfile* nonsupervised_profile = new TestingProfile(nonsupervised_path,
                                                              NULL);
   profile_manager->RegisterTestingProfile(nonsupervised_profile, true, false);
 
   EXPECT_EQ(2u, storage.GetNumberOfProfiles());
   ProfileAttributesEntry* entry;
   ASSERT_TRUE(storage.GetProfileAttributesWithPath(supervised_path, &entry));
   EXPECT_TRUE(entry->IsOmitted());
 
   ASSERT_TRUE(storage.GetProfileAttributesWithPath(nonsupervised_path, &entry));
   EXPECT_FALSE(entry->IsOmitted());
 }
 
 TEST_F(ProfileManagerTest, GetGuestProfilePath) {
   base::FilePath guest_path = ProfileManager::GetGuestProfilePath();
-  base::FilePath expected_path = temp_dir_.path();
+  base::FilePath expected_path = temp_dir_.GetPath();
   expected_path = expected_path.Append(chrome::kGuestProfileDir);
   EXPECT_EQ(expected_path, guest_path);
 }
 
 TEST_F(ProfileManagerTest, GetSystemProfilePath) {
   base::FilePath system_profile_path = ProfileManager::GetSystemProfilePath();
-  base::FilePath expected_path = temp_dir_.path();
+  base::FilePath expected_path = temp_dir_.GetPath();
   expected_path = expected_path.Append(chrome::kSystemProfileDir);
   EXPECT_EQ(expected_path, system_profile_path);
 }
 
 class UnittestGuestProfileManager : public UnittestProfileManager {
  public:
   explicit UnittestGuestProfileManager(const base::FilePath& user_data_dir)
       : UnittestProfileManager(user_data_dir) {}
 
  protected:
   Profile* CreateProfileHelper(const base::FilePath& file_path) override {
     TestingProfile::Builder builder;
     builder.SetGuestSession();
     builder.SetPath(file_path);
     TestingProfile* testing_profile = builder.Build().release();
     return testing_profile;
   }
 };
 
 class ProfileManagerGuestTest : public ProfileManagerTest  {
  protected:
   void SetUp() override {
     // Create a new temporary directory, and store the path
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     TestingBrowserProcess::GetGlobal()->SetProfileManager(
-        new UnittestGuestProfileManager(temp_dir_.path()));
+        new UnittestGuestProfileManager(temp_dir_.GetPath()));
 
 #if defined(OS_CHROMEOS)
     base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
     // This switch is needed to skip non-test specific behavior in
     // ProfileManager (accessing DBusThreadManager).
     cl->AppendSwitch(switches::kTestType);
 
     cl->AppendSwitch(chromeos::switches::kGuestSession);
     cl->AppendSwitch(::switches::kIncognito);
 
@@ skipping 84 matching lines @@
       storage.GetAllProfilesAttributes();
   entries[0u]->SetBackgroundStatus(false);
   entries[1u]->SetBackgroundStatus(true);
 
   profile_manager->AutoloadProfiles();
 
   EXPECT_EQ(0u, profile_manager->GetLoadedProfiles().size());
 }
 
 TEST_F(ProfileManagerTest, InitProfileUserPrefs) {
-  base::FilePath dest_path = temp_dir_.path();
+  base::FilePath dest_path = temp_dir_.GetPath();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   Profile* profile;
 
   // Successfully create the profile
   profile = profile_manager->GetProfile(dest_path);
   ASSERT_TRUE(profile);
 
   // Check that the profile name is non empty
   std::string profile_name =
       profile->GetPrefs()->GetString(prefs::kProfileName);
   EXPECT_FALSE(profile_name.empty());
 
   // Check that the profile avatar index is valid
   size_t avatar_index =
       profile->GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
   EXPECT_TRUE(profiles::IsDefaultAvatarIconIndex(
       avatar_index));
 }
 
 // Tests that a new profile's entry in the profile info cache is setup with the
 // same values that are in the profile prefs.
 TEST_F(ProfileManagerTest, InitProfileInfoCacheForAProfile) {
-  base::FilePath dest_path = temp_dir_.path();
+  base::FilePath dest_path = temp_dir_.GetPath();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("New Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profile
   Profile* profile = profile_manager->GetProfile(dest_path);
   ASSERT_TRUE(profile);
 
   std::string profile_name =
       profile->GetPrefs()->GetString(prefs::kProfileName);
@@ skipping 36 matching lines @@
   // GetLastUsedProfileAllowedByPolicy() returns the incognito Profile when
   // incognito mode is forced.
   IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::FORCED);
   EXPECT_TRUE(
       profile_manager->GetLastUsedProfileAllowedByPolicy()->IsOffTheRecord());
 }
 
 #if !defined(OS_ANDROID)
 // There's no Browser object on Android.
 TEST_F(ProfileManagerTest, LastOpenedProfiles) {
-  base::FilePath dest_path1 = temp_dir_.path();
+  base::FilePath dest_path1 = temp_dir_.GetPath();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 
-  base::FilePath dest_path2 = temp_dir_.path();
+  base::FilePath dest_path2 = temp_dir_.GetPath();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profiles.
   TestingProfile* profile1 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(profile1);
 
   TestingProfile* profile2 =
@@ skipping 42 matching lines @@
   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(1U, last_opened_profiles.size());
   EXPECT_EQ(profile2, last_opened_profiles[0]);
 
   browser2.reset();
   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(0U, last_opened_profiles.size());
 }
 
 TEST_F(ProfileManagerTest, LastOpenedProfilesAtShutdown) {
-  base::FilePath dest_path1 = temp_dir_.path();
+  base::FilePath dest_path1 = temp_dir_.GetPath();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
 
-  base::FilePath dest_path2 = temp_dir_.path();
+  base::FilePath dest_path2 = temp_dir_.GetPath();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profiles.
   TestingProfile* profile1 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(profile1);
 
   TestingProfile* profile2 =
@@ skipping 27 matching lines @@
   browser1.reset();
   browser2.reset();
 
   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(2U, last_opened_profiles.size());
   EXPECT_EQ(profile1, last_opened_profiles[0]);
   EXPECT_EQ(profile2, last_opened_profiles[1]);
 }
 
 TEST_F(ProfileManagerTest, LastOpenedProfilesDoesNotContainIncognito) {
-  base::FilePath dest_path1 = temp_dir_.path();
+  base::FilePath dest_path1 = temp_dir_.GetPath();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("New Profile 1"));
-  base::FilePath dest_path2 = temp_dir_.path();
+  base::FilePath dest_path2 = temp_dir_.GetPath();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("New Profile 2"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profiles.
   TestingProfile* profile1 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(profile1);
 
   std::vector<Profile*> last_opened_profiles =
@@ skipping 38 matching lines @@
 
   browser1.reset();
   last_opened_profiles = profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(0U, last_opened_profiles.size());
 }
 #endif  // !defined(OS_ANDROID)
 
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
 // There's no Browser object on Android and there's no multi-profiles on Chrome.
 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastProfile) {
-  base::FilePath dest_path = temp_dir_.path();
+  base::FilePath dest_path = temp_dir_.GetPath();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("Ephemeral Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   TestingProfile* profile =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path));
   ASSERT_TRUE(profile);
   profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
 
   // Here the last used profile is still the "Default" profile.
   Profile* last_used_profile = profile_manager->GetLastUsedProfile();
   EXPECT_NE(profile, last_used_profile);
 
   // Create a browser for the profile.
   Browser::CreateParams profile_params(profile);
   std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&profile_params));
   last_used_profile = profile_manager->GetLastUsedProfile();
   EXPECT_NE(profile, last_used_profile);
 
   // Close the browser.
   browser.reset();
   last_used_profile = profile_manager->GetLastUsedProfile();
   EXPECT_NE(profile, last_used_profile);
 }
 
 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastOpenedAtShutdown) {
-  base::FilePath dest_path1 = temp_dir_.path();
+  base::FilePath dest_path1 = temp_dir_.GetPath();
   dest_path1 = dest_path1.Append(FILE_PATH_LITERAL("Normal Profile"));
 
-  base::FilePath dest_path2 = temp_dir_.path();
+  base::FilePath dest_path2 = temp_dir_.GetPath();
   dest_path2 = dest_path2.Append(FILE_PATH_LITERAL("Ephemeral Profile 1"));
 
-  base::FilePath dest_path3 = temp_dir_.path();
+  base::FilePath dest_path3 = temp_dir_.GetPath();
   dest_path3 = dest_path3.Append(FILE_PATH_LITERAL("Ephemeral Profile 2"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Successfully create the profiles.
   TestingProfile* normal_profile =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(normal_profile);
 
   // Add one ephemeral profile which should not end up in this list.
@@ skipping 94 matching lines @@
   EXPECT_EQ("Profile 1", local_state->GetString(prefs::kProfileLastUsed));
 }
 
 TEST_F(ProfileManagerTest, ActiveProfileDeleted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
   // Create and load two profiles.
   const std::string profile_name1 = "New Profile 1";
   const std::string profile_name2 = "New Profile 2";
-  base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
-  base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
+  base::FilePath dest_path1 = temp_dir_.GetPath().AppendASCII(profile_name1);
+  base::FilePath dest_path2 = temp_dir_.GetPath().AppendASCII(profile_name2);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(3));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   CreateProfileAsync(profile_manager, profile_name2, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2u, profile_manager->GetLoadedProfiles().size());
@@ skipping 15 matching lines @@
 }
 
 TEST_F(ProfileManagerTest, LastProfileDeleted) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
   ProfileAttributesStorage& storage =
       profile_manager->GetProfileAttributesStorage();
 
   // Create and load a profile.
   const std::string profile_name1 = "New Profile 1";
-  base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
+  base::FilePath dest_path1 = temp_dir_.GetPath().AppendASCII(profile_name1);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(1));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
   EXPECT_EQ(1u, storage.GetNumberOfProfiles());
 
   // Set it as the active profile.
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kProfileLastUsed, profile_name1);
 
   // Delete the active profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   // A new profile should have been created
   const std::string profile_name2 = "Profile 1";
-  base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
+  base::FilePath dest_path2 = temp_dir_.GetPath().AppendASCII(profile_name2);
 
   EXPECT_EQ(dest_path2, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name2, local_state->GetString(prefs::kProfileLastUsed));
   EXPECT_EQ(dest_path2, storage.GetAllProfilesAttributes()[0u]->GetPath());
 }
 
 TEST_F(ProfileManagerTest, LastProfileDeletedWithGuestActiveProfile) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
   ProfileAttributesStorage& storage =
       profile_manager->GetProfileAttributesStorage();
 
   // Create and load a profile.
   const std::string profile_name1 = "New Profile 1";
-  base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
+  base::FilePath dest_path1 = temp_dir_.GetPath().AppendASCII(profile_name1);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
 
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, profile_manager->GetLoadedProfiles().size());
   EXPECT_EQ(1u, storage.GetNumberOfProfiles());
@@ skipping 19 matching lines @@
   local_state->SetString(prefs::kProfileLastUsed, guest_profile_name);
 
   // Delete the other profile.
   profile_manager->ScheduleProfileForDeletion(dest_path1,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   // A new profile should have been created.
   const std::string profile_name2 = "Profile 1";
-  base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
+  base::FilePath dest_path2 = temp_dir_.GetPath().AppendASCII(profile_name2);
 
   EXPECT_EQ(3u, profile_manager->GetLoadedProfiles().size());
   EXPECT_EQ(1u, storage.GetNumberOfProfiles());
   EXPECT_EQ(dest_path2, storage.GetAllProfilesAttributes()[0u]->GetPath());
 }
 
 TEST_F(ProfileManagerTest, ProfileDisplayNameResetsDefaultName) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
@@ skipping 196 matching lines @@
 #if defined(OS_MACOSX)
 // These tests are for a Mac-only code path that assumes the browser
 // process isn't killed when all browser windows are closed.
 TEST_F(ProfileManagerTest, ActiveProfileDeletedNeedsToLoadNextProfile) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
   // Create and load one profile, and just create a second profile.
   const std::string profile_name1 = "New Profile 1";
   const std::string profile_name2 = "New Profile 2";
-  base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
-  base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
+  base::FilePath dest_path1 = temp_dir_.GetPath().AppendASCII(profile_name1);
+  base::FilePath dest_path2 = temp_dir_.GetPath().AppendASCII(profile_name2);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   // Track the profile, but don't load it.
   ProfileAttributesStorage& storage =
       profile_manager->GetProfileAttributesStorage();
@@ skipping 26 matching lines @@
 // the next active profile has also been marked for deletion, so the
 // ProfileManager needs to recursively select a different next profile.
 TEST_F(ProfileManagerTest, ActiveProfileDeletedNextProfileDeletedToo) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ASSERT_TRUE(profile_manager);
 
   // Create and load one profile, and create two more profiles.
   const std::string profile_name1 = "New Profile 1";
   const std::string profile_name2 = "New Profile 2";
   const std::string profile_name3 = "New Profile 3";
-  base::FilePath dest_path1 = temp_dir_.path().AppendASCII(profile_name1);
-  base::FilePath dest_path2 = temp_dir_.path().AppendASCII(profile_name2);
-  base::FilePath dest_path3 = temp_dir_.path().AppendASCII(profile_name3);
+  base::FilePath dest_path1 = temp_dir_.GetPath().AppendASCII(profile_name1);
+  base::FilePath dest_path2 = temp_dir_.GetPath().AppendASCII(profile_name2);
+  base::FilePath dest_path3 = temp_dir_.GetPath().AppendASCII(profile_name3);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer, OnProfileCreated(
       testing::NotNull(), NotFail())).Times(testing::AtLeast(2));
   CreateProfileAsync(profile_manager, profile_name1, false, &mock_observer);
   base::RunLoop().RunUntilIdle();
 
   // Create the other profiles, but don't load them. Assign a fake avatar icon
   // to ensure that profiles in the profile attributes storage are sorted by the
   // profile name, and not randomly by the avatar name.
@@ skipping 27 matching lines @@
                          dest_path2.BaseName().MaybeAsASCII());
   profile_manager->ScheduleProfileForDeletion(dest_path2,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
 }
 #endif  // !defined(OS_MACOSX)