misc files R-U: Change ScopedTempDir::path() to GetPath()

third_party/zlib/google/zip_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 19 matching lines @@
  protected:
   enum ValidYearType {
     VALID_YEAR,
     INVALID_YEAR
   };
 
   virtual void SetUp() {
     PlatformTest::SetUp();
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    test_dir_ = temp_dir_.path();
+    test_dir_ = temp_dir_.GetPath();
 
     base::FilePath zip_path(test_dir_);
     zip_contents_.insert(zip_path.AppendASCII("foo.txt"));
     zip_path = zip_path.AppendASCII("foo");
     zip_contents_.insert(zip_path);
     zip_contents_.insert(zip_path.AppendASCII("bar.txt"));
     zip_path = zip_path.AppendASCII("bar");
     zip_contents_.insert(zip_path);
     zip_contents_.insert(zip_path.AppendASCII("baz.txt"));
     zip_contents_.insert(zip_path.AppendASCII("quux.txt"));
@@ skipping 64 matching lines @@
   // 2) Zips test.txt and extracts it back into a different location.
   // 3) Confirms that test.txt in the output directory has the specified
   //    last modification timestamp if it is valid (|valid_year| is true).
   //    If the timestamp is not supported by the zip format, the last
   //    modification defaults to the current time.
   void TestTimeStamp(const char* date_time, ValidYearType valid_year) {
     SCOPED_TRACE(std::string("TestTimeStamp(") + date_time + ")");
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
-    base::FilePath zip_file = temp_dir.path().AppendASCII("out.zip");
-    base::FilePath src_dir = temp_dir.path().AppendASCII("input");
-    base::FilePath out_dir = temp_dir.path().AppendASCII("output");
+    base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
+    base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input");
+    base::FilePath out_dir = temp_dir.GetPath().AppendASCII("output");
 
     base::FilePath src_file = src_dir.AppendASCII("test.txt");
     base::FilePath out_file = out_dir.AppendASCII("test.txt");
 
     EXPECT_TRUE(base::CreateDirectory(src_dir));
     EXPECT_TRUE(base::CreateDirectory(out_dir));
 
     base::Time test_mtime;
     ASSERT_TRUE(base::Time::FromString(date_time, &test_mtime));
 
@@ skipping 75 matching lines @@
   ASSERT_FALSE(base::PathExists(evil_file));
 }
 
 TEST_F(ZipTest, Zip) {
   base::FilePath src_dir;
   ASSERT_TRUE(GetTestDataDirectory(&src_dir));
   src_dir = src_dir.AppendASCII("test");
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath zip_file = temp_dir.path().AppendASCII("out.zip");
+  base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
 
   EXPECT_TRUE(zip::Zip(src_dir, zip_file, true));
   TestUnzipFile(zip_file, true);
 }
 
 TEST_F(ZipTest, ZipIgnoreHidden) {
   base::FilePath src_dir;
   ASSERT_TRUE(GetTestDataDirectory(&src_dir));
   src_dir = src_dir.AppendASCII("test");
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath zip_file = temp_dir.path().AppendASCII("out.zip");
+  base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip");
 
   EXPECT_TRUE(zip::Zip(src_dir, zip_file, false));
   TestUnzipFile(zip_file, false);
 }
 
 TEST_F(ZipTest, ZipNonASCIIDir) {
   base::FilePath src_dir;
   ASSERT_TRUE(GetTestDataDirectory(&src_dir));
   src_dir = src_dir.AppendASCII("test");
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   // Append 'Тест' (in cyrillic).
-  base::FilePath src_dir_russian =
-      temp_dir.path().Append(base::FilePath::FromUTF8Unsafe(
-          "\xD0\xA2\xD0\xB5\xD1\x81\xD1\x82"));
+  base::FilePath src_dir_russian = temp_dir.GetPath().Append(
+      base::FilePath::FromUTF8Unsafe("\xD0\xA2\xD0\xB5\xD1\x81\xD1\x82"));
   base::CopyDirectory(src_dir, src_dir_russian, true);
-  base::FilePath zip_file = temp_dir.path().AppendASCII("out_russian.zip");
+  base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out_russian.zip");
 
   EXPECT_TRUE(zip::Zip(src_dir_russian, zip_file, true));
   TestUnzipFile(zip_file, true);
 }
 
 TEST_F(ZipTest, ZipTimeStamp) {
   // The dates tested are arbitrary, with some constraints. The zip format can
   // only store years from 1980 to 2107 and an even number of seconds, due to it
   // using the ms dos date format.
 
@@ skipping 15 matching lines @@
 }
 
 #if defined(OS_POSIX)
 TEST_F(ZipTest, ZipFiles) {
   base::FilePath src_dir;
   ASSERT_TRUE(GetTestDataDirectory(&src_dir));
   src_dir = src_dir.AppendASCII("test");
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-  base::FilePath zip_name = temp_dir.path().AppendASCII("out.zip");
+  base::FilePath zip_name = temp_dir.GetPath().AppendASCII("out.zip");
 
   base::File zip_file(zip_name,
                       base::File::FLAG_CREATE | base::File::FLAG_WRITE);
   ASSERT_TRUE(zip_file.IsValid());
   EXPECT_TRUE(zip::ZipFiles(src_dir, zip_file_list_,
                             zip_file.GetPlatformFile()));
   zip_file.Close();
 
   zip::ZipReader reader;
   EXPECT_TRUE(reader.Open(zip_name));
@@ skipping 13 matching lines @@
 
   // test_mismatch_size.zip contains files with names from 0.txt to 7.txt with
   // sizes from 0 to 7 bytes respectively, but the metadata in the zip file says
   // the uncompressed size is 3 bytes. The ZipReader and minizip code needs to
   // be clever enough to get all the data out.
   base::FilePath test_zip_file =
       test_data_folder.AppendASCII("test_mismatch_size.zip");
 
   base::ScopedTempDir scoped_temp_dir;
   ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir());
-  const base::FilePath& temp_dir = scoped_temp_dir.path();
+  const base::FilePath& temp_dir = scoped_temp_dir.GetPath();
 
   ASSERT_TRUE(zip::Unzip(test_zip_file, temp_dir));
   EXPECT_TRUE(base::DirectoryExists(temp_dir.AppendASCII("d")));
 
   for (int i = 0; i < 8; i++) {
     SCOPED_TRACE(base::StringPrintf("Processing %d.txt", i));
     base::FilePath file_path = temp_dir.AppendASCII(
         base::StringPrintf("%d.txt", i));
     int64_t file_size = -1;
     EXPECT_TRUE(base::GetFileSize(file_path, &file_size));
     EXPECT_EQ(static_cast<int64_t>(i), file_size);
   }
 }
 
 }  // namespace