//base: Make ScopedTempDir::path() a GetPath() with a DCHECK

base/path_service_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 "base/path_service.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/strings/string_util.h"
@@ skipping 111 matching lines @@
   }
 #endif
 }
 
 // Test that all versions of the Override function of PathService do what they
 // are supposed to do.
 TEST_F(PathServiceTest, Override) {
   int my_special_key = 666;
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath fake_cache_dir(temp_dir.path().AppendASCII("cache"));
+  FilePath fake_cache_dir(temp_dir.GetPath().AppendASCII("cache"));
   // PathService::Override should always create the path provided if it doesn't
   // exist.
   EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir));
   EXPECT_TRUE(PathExists(fake_cache_dir));
 
-  FilePath fake_cache_dir2(temp_dir.path().AppendASCII("cache2"));
+  FilePath fake_cache_dir2(temp_dir.GetPath().AppendASCII("cache2"));
   // PathService::OverrideAndCreateIfNeeded should obey the |create| parameter.
   PathService::OverrideAndCreateIfNeeded(my_special_key,
                                          fake_cache_dir2,
                                          false,
                                          false);
   EXPECT_FALSE(PathExists(fake_cache_dir2));
   EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
                                                      fake_cache_dir2,
                                                      false,
                                                      true));
   EXPECT_TRUE(PathExists(fake_cache_dir2));
 
 #if defined(OS_POSIX)
   FilePath non_existent(
-      MakeAbsoluteFilePath(temp_dir.path()).AppendASCII("non_existent"));
+      MakeAbsoluteFilePath(temp_dir.GetPath()).AppendASCII("non_existent"));
   EXPECT_TRUE(non_existent.IsAbsolute());
   EXPECT_FALSE(PathExists(non_existent));
 #if !defined(OS_ANDROID)
   // This fails because MakeAbsoluteFilePath fails for non-existent files.
   // Earlier versions of Bionic libc don't fail for non-existent files, so
   // skip this check on Android.
   EXPECT_FALSE(PathService::OverrideAndCreateIfNeeded(my_special_key,
                                                       non_existent,
                                                       false,
                                                       false));
@@ skipping 10 matching lines @@
   EXPECT_TRUE(PathService::Get(my_special_key, &path));
   EXPECT_EQ(non_existent, path);
 #endif
 }
 
 // Check if multiple overrides can co-exist.
 TEST_F(PathServiceTest, OverrideMultiple) {
   int my_special_key = 666;
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  FilePath fake_cache_dir1(temp_dir.path().AppendASCII("1"));
+  FilePath fake_cache_dir1(temp_dir.GetPath().AppendASCII("1"));
   EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir1));
   EXPECT_TRUE(PathExists(fake_cache_dir1));
   ASSERT_EQ(1, WriteFile(fake_cache_dir1.AppendASCII("t1"), ".", 1));
 
-  FilePath fake_cache_dir2(temp_dir.path().AppendASCII("2"));
+  FilePath fake_cache_dir2(temp_dir.GetPath().AppendASCII("2"));
   EXPECT_TRUE(PathService::Override(my_special_key + 1, fake_cache_dir2));
   EXPECT_TRUE(PathExists(fake_cache_dir2));
   ASSERT_EQ(1, WriteFile(fake_cache_dir2.AppendASCII("t2"), ".", 1));
 
   FilePath result;
   EXPECT_TRUE(PathService::Get(my_special_key, &result));
   // Override might have changed the path representation but our test file
   // should be still there.
   EXPECT_TRUE(PathExists(result.AppendASCII("t1")));
   EXPECT_TRUE(PathService::Get(my_special_key + 1, &result));
   EXPECT_TRUE(PathExists(result.AppendASCII("t2")));
 }
 
 TEST_F(PathServiceTest, RemoveOverride) {
   // Before we start the test we have to call RemoveOverride at least once to
   // clear any overrides that might have been left from other tests.
   PathService::RemoveOverride(DIR_TEMP);
 
   FilePath original_user_data_dir;
   EXPECT_TRUE(PathService::Get(DIR_TEMP, &original_user_data_dir));
   EXPECT_FALSE(PathService::RemoveOverride(DIR_TEMP));
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  EXPECT_TRUE(PathService::Override(DIR_TEMP, temp_dir.path()));
+  EXPECT_TRUE(PathService::Override(DIR_TEMP, temp_dir.GetPath()));
   FilePath new_user_data_dir;
   EXPECT_TRUE(PathService::Get(DIR_TEMP, &new_user_data_dir));
   EXPECT_NE(original_user_data_dir, new_user_data_dir);
 
   EXPECT_TRUE(PathService::RemoveOverride(DIR_TEMP));
   EXPECT_TRUE(PathService::Get(DIR_TEMP, &new_user_data_dir));
   EXPECT_EQ(original_user_data_dir, new_user_data_dir);
 }
 
 #if defined(OS_WIN)
@@ skipping 42 matching lines @@
     EXPECT_TRUE(PathService::Get(DIR_PROGRAM_FILES6432,
         &programfiles_dir));
     EXPECT_EQ(programfiles_dir.value(),
         FILE_PATH_LITERAL("C:\\Program Files"));
   }
 #endif
 }
 #endif
 
 }  // namespace base