c/browser, c/common, components S-W: Change ScopedTempDir::path() to GetPath()

components/url_formatter/url_fixer_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 <stdlib.h>
 
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 357 matching lines @@
 
 // Test different types of file inputs to URIFixerUpper::FixupURL. This
 // doesn't go into the nice array of fixups above since the file input
 // has to exist.
 TEST(URLFixerTest, FixupFile) {
   // this "original" filename is the one we tweak to get all the variations
   base::ScopedTempDir temp_dir_;
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath original;
   ASSERT_TRUE(MakeTempFile(
-      temp_dir_.path(),
+      temp_dir_.GetPath(),
       base::FilePath(FILE_PATH_LITERAL("url fixer upper existing file.txt")),
       &original));
 
   // reference path
   GURL golden(net::FilePathToFileURL(original));
 
   // c:\foo\bar.txt -> file:///c:/foo/bar.txt (basic)
   GURL fixedup(url_formatter::FixupURL(original.AsUTF8Unsafe(), std::string()));
   EXPECT_EQ(golden, fixedup);
 
@@ skipping 64 matching lines @@
 
   EXPECT_TRUE(base::DeleteFile(original, false));
 }
 
 TEST(URLFixerTest, FixupRelativeFile) {
   base::FilePath full_path;
   base::FilePath file_part(
       FILE_PATH_LITERAL("url_fixer_upper_existing_file.txt"));
   base::ScopedTempDir temp_dir_;
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  ASSERT_TRUE(MakeTempFile(temp_dir_.path(), file_part, &full_path));
+  ASSERT_TRUE(MakeTempFile(temp_dir_.GetPath(), file_part, &full_path));
   full_path = base::MakeAbsoluteFilePath(full_path);
   ASSERT_FALSE(full_path.empty());
 
   // make sure we pass through good URLs
   for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
     FixupCase value = fixup_cases[i];
     base::FilePath input = base::FilePath::FromUTF8Unsafe(value.input);
     EXPECT_EQ(value.output,
-              url_formatter::FixupRelativeFile(temp_dir_.path(),
-                  input).possibly_invalid_spec());
+              url_formatter::FixupRelativeFile(temp_dir_.GetPath(), input)
+                  .possibly_invalid_spec());
   }
 
   // make sure the existing file got fixed-up to a file URL, and that there
   // are no backslashes
   EXPECT_TRUE(IsMatchingFileURL(
-      url_formatter::FixupRelativeFile(temp_dir_.path(),
-          file_part).possibly_invalid_spec(), full_path));
+      url_formatter::FixupRelativeFile(temp_dir_.GetPath(), file_part)
+          .possibly_invalid_spec(),
+      full_path));
   EXPECT_TRUE(base::DeleteFile(full_path, false));
 
   // create a filename we know doesn't exist and make sure it doesn't get
   // fixed up to a file URL
   base::FilePath nonexistent_file(
       FILE_PATH_LITERAL("url_fixer_upper_nonexistent_file.txt"));
-  std::string fixedup(url_formatter::FixupRelativeFile(
-      temp_dir_.path(), nonexistent_file).possibly_invalid_spec());
+  std::string fixedup(
+      url_formatter::FixupRelativeFile(temp_dir_.GetPath(), nonexistent_file)
+          .possibly_invalid_spec());
   EXPECT_NE(std::string("file:///"), fixedup.substr(0, 8));
   EXPECT_FALSE(IsMatchingFileURL(fixedup, nonexistent_file));
 
   // make a subdir to make sure relative paths with directories work, also
   // test spaces:
   // "app_dir\url fixer-upper dir\url fixer-upper existing file.txt"
   base::FilePath sub_dir(FILE_PATH_LITERAL("url fixer-upper dir"));
   base::FilePath sub_file(
       FILE_PATH_LITERAL("url fixer-upper existing file.txt"));
-  base::FilePath new_dir = temp_dir_.path().Append(sub_dir);
+  base::FilePath new_dir = temp_dir_.GetPath().Append(sub_dir);
   base::CreateDirectory(new_dir);
   ASSERT_TRUE(MakeTempFile(new_dir, sub_file, &full_path));
   full_path = base::MakeAbsoluteFilePath(full_path);
   ASSERT_FALSE(full_path.empty());
 
   // test file in the subdir
   base::FilePath relative_file = sub_dir.Append(sub_file);
   EXPECT_TRUE(IsMatchingFileURL(
-      url_formatter::FixupRelativeFile(temp_dir_.path(),
-          relative_file).possibly_invalid_spec(), full_path));
+      url_formatter::FixupRelativeFile(temp_dir_.GetPath(), relative_file)
+          .possibly_invalid_spec(),
+      full_path));
 
   // test file in the subdir with different slashes and escaping.
   base::FilePath::StringType relative_file_str = sub_dir.value() +
       FILE_PATH_LITERAL("/") + sub_file.value();
   base::ReplaceSubstringsAfterOffset(&relative_file_str, 0,
       FILE_PATH_LITERAL(" "), FILE_PATH_LITERAL("%20"));
   EXPECT_TRUE(IsMatchingFileURL(
-      url_formatter::FixupRelativeFile(temp_dir_.path(),
-          base::FilePath(relative_file_str)).possibly_invalid_spec(),
-              full_path));
+      url_formatter::FixupRelativeFile(temp_dir_.GetPath(),
+                                       base::FilePath(relative_file_str))
+          .possibly_invalid_spec(),
+      full_path));
 
   // test relative directories and duplicate slashes
   // (should resolve to the same file as above)
   relative_file_str = sub_dir.value() + FILE_PATH_LITERAL("/../") +
       sub_dir.value() + FILE_PATH_LITERAL("///./") + sub_file.value();
   EXPECT_TRUE(IsMatchingFileURL(
-      url_formatter::FixupRelativeFile(temp_dir_.path(),
-          base::FilePath(relative_file_str)).possibly_invalid_spec(),
-              full_path));
+      url_formatter::FixupRelativeFile(temp_dir_.GetPath(),
+                                       base::FilePath(relative_file_str))
+          .possibly_invalid_spec(),
+      full_path));
 
   // done with the subdir
   EXPECT_TRUE(base::DeleteFile(full_path, false));
   EXPECT_TRUE(base::DeleteFile(new_dir, true));
 
   // Test that an obvious HTTP URL isn't accidentally treated as an absolute
   // file path (on account of system-specific craziness).
   base::FilePath empty_path;
   base::FilePath http_url_path(FILE_PATH_LITERAL("http://../"));
   EXPECT_TRUE(url_formatter::FixupRelativeFile(empty_path, http_url_path)
                   .SchemeIs("http"));
 }