Update from https://crrev.com/333737

base/files/file_util_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 313 matching lines @@
   // |-> base_b
   //     |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
   //     |-> to_base_b (reparse point to temp_dir\base_b)
   //     |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
 
   FilePath base_a = temp_dir_.path().Append(FPL("base_a"));
 #if defined(OS_WIN)
   // TEMP can have a lower case drive letter.
   string16 temp_base_a = base_a.value();
   ASSERT_FALSE(temp_base_a.empty());
-  *temp_base_a.begin() = base::ToUpperASCII(*temp_base_a.begin());
+  *temp_base_a.begin() = ToUpperASCII(*temp_base_a.begin());
   base_a = FilePath(temp_base_a);
 #endif
   ASSERT_TRUE(CreateDirectory(base_a));
 
   FilePath sub_a = base_a.Append(FPL("sub_a"));
   ASSERT_TRUE(CreateDirectory(sub_a));
 
   FilePath file_txt = sub_a.Append(FPL("file.txt"));
   CreateTextFile(file_txt, bogus_content);
 
@@ skipping 185 matching lines @@
 
   // Create a subdirectory of |long_test_dir| and make |long_test_dir|
   // unreadable. We should still be able to create a temp file in the
   // subdirectory, but we won't be able to determine the long path for it. This
   // mimics the environment that some users run where their user profiles reside
   // in a location where the don't have full access to the higher level
   // directories. (Note that this assumption is true for NTFS, but not for some
   // network file systems. E.g. AFS).
   FilePath access_test_dir = long_test_dir.Append(kTestSubDirName);
   ASSERT_TRUE(CreateDirectory(access_test_dir));
-  base::FilePermissionRestorer long_test_dir_restorer(long_test_dir);
-  ASSERT_TRUE(base::MakeFileUnreadable(long_test_dir));
+  FilePermissionRestorer long_test_dir_restorer(long_test_dir);
+  ASSERT_TRUE(MakeFileUnreadable(long_test_dir));
 
   // Use the short form of the directory to create a temporary filename.
   ASSERT_TRUE(CreateTemporaryFileInDir(
       short_test_dir.Append(kTestSubDirName), &temp_file));
   EXPECT_TRUE(PathExists(temp_file));
   EXPECT_TRUE(short_test_dir.IsParent(temp_file.DirName()));
 
   // Check that the long path can't be determined for |temp_file|.
   path_buffer_length = GetLongPathName(temp_file.value().c_str(),
                                        path_buffer, MAX_PATH);
@@ skipping 1542 matching lines @@
 
   EXPECT_TRUE(ReadFileToString(file_path, NULL, 6));
 
   EXPECT_TRUE(ReadFileToString(file_path, NULL));
 
   data = "temp";
   EXPECT_FALSE(ReadFileToString(file_path_dangerous, &data));
   EXPECT_EQ(0u, data.length());
 
   // Delete test file.
-  EXPECT_TRUE(base::DeleteFile(file_path, false));
+  EXPECT_TRUE(DeleteFile(file_path, false));
 
   data = "temp";
   EXPECT_FALSE(ReadFileToString(file_path, &data));
   EXPECT_EQ(0u, data.length());
 
   data = "temp";
   EXPECT_FALSE(ReadFileToString(file_path, &data, 6));
   EXPECT_EQ(0u, data.length());
 }
 
@@ skipping 113 matching lines @@
   std::set<gid_t> ok_gids_;
   std::set<gid_t> bad_gids_;
 };
 
 TEST_F(VerifyPathControlledByUserTest, BadPaths) {
   // File does not exist.
   FilePath does_not_exist = base_dir_.AppendASCII("does")
                                      .AppendASCII("not")
                                      .AppendASCII("exist");
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, does_not_exist, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, does_not_exist, uid_, ok_gids_));
 
   // |base| not a subpath of |path|.
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, base_dir_, uid_, ok_gids_));
+  EXPECT_FALSE(VerifyPathControlledByUser(sub_dir_, base_dir_, uid_, ok_gids_));
 
   // An empty base path will fail to be a prefix for any path.
   FilePath empty;
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          empty, base_dir_, uid_, ok_gids_));
+  EXPECT_FALSE(VerifyPathControlledByUser(empty, base_dir_, uid_, ok_gids_));
 
   // Finding that a bad call fails proves nothing unless a good call succeeds.
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
 }
 
 TEST_F(VerifyPathControlledByUserTest, Symlinks) {
   // Symlinks in the path should cause failure.
 
   // Symlink to the file at the end of the path.
   FilePath file_link =  base_dir_.AppendASCII("file_link");
   ASSERT_TRUE(CreateSymbolicLink(text_file_, file_link))
       << "Failed to create symlink.";
 
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, file_link, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, file_link, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          file_link, file_link, uid_, ok_gids_));
+      VerifyPathControlledByUser(file_link, file_link, uid_, ok_gids_));
 
   // Symlink from one directory to another within the path.
   FilePath link_to_sub_dir =  base_dir_.AppendASCII("link_to_sub_dir");
   ASSERT_TRUE(CreateSymbolicLink(sub_dir_, link_to_sub_dir))
     << "Failed to create symlink.";
 
   FilePath file_path_with_link = link_to_sub_dir.AppendASCII("file.txt");
   ASSERT_TRUE(PathExists(file_path_with_link));
 
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, file_path_with_link, uid_, ok_gids_));
+  EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, file_path_with_link, uid_,
+                                          ok_gids_));
 
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          link_to_sub_dir, file_path_with_link, uid_, ok_gids_));
+  EXPECT_FALSE(VerifyPathControlledByUser(link_to_sub_dir, file_path_with_link,
+                                          uid_, ok_gids_));
 
   // Symlinks in parents of base path are allowed.
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          file_path_with_link, file_path_with_link, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(file_path_with_link,
+                                         file_path_with_link, uid_, ok_gids_));
 }
 
 TEST_F(VerifyPathControlledByUserTest, OwnershipChecks) {
   // Get a uid that is not the uid of files we create.
   uid_t bad_uid = uid_ + 1;
 
   // Make all files and directories non-world-writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
 
   // We control these paths.
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Another user does not control these paths.
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, bad_uid, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, sub_dir_, bad_uid, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, bad_uid, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, bad_uid, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, bad_uid, ok_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, bad_uid, ok_gids_));
 
   // Another group does not control the paths.
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, bad_gids_));
+      VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, bad_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, bad_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
 }
 
 TEST_F(VerifyPathControlledByUserTest, GroupWriteTest) {
   // Make all files and directories writable only by their owner.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH|S_IWGRP));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH|S_IWGRP));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH|S_IWGRP));
 
   // Any group is okay because the path is not group-writable.
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
+
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
-
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, bad_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, bad_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, bad_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
 
   // No group is okay, because we don't check the group
   // if no group can write.
   std::set<gid_t> no_gids;  // Empty set of gids.
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, no_gids));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, no_gids));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, no_gids));
-
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, no_gids));
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, text_file_, uid_, no_gids));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, no_gids));
 
   // Make all files and directories writable by their group.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(base_dir_, S_IWGRP, 0u));
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(sub_dir_, S_IWGRP, 0u));
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(text_file_, S_IWGRP, 0u));
+  ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(base_dir_, S_IWGRP, 0u));
+  ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(sub_dir_, S_IWGRP, 0u));
+  ASSERT_NO_FATAL_FAILURE(ChangePosixFilePermissions(text_file_, S_IWGRP, 0u));
 
   // Now |ok_gids_| works, but |bad_gids_| fails.
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, bad_gids_));
+      VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, bad_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, bad_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, bad_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, bad_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, bad_gids_));
 
   // Because any group in the group set is allowed,
   // the union of good and bad gids passes.
 
   std::set<gid_t> multiple_gids;
   std::set_union(
       ok_gids_.begin(), ok_gids_.end(),
       bad_gids_.begin(), bad_gids_.end(),
       std::inserter(multiple_gids, multiple_gids.begin()));
 
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, multiple_gids));
+      VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, multiple_gids));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, multiple_gids));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, multiple_gids));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, multiple_gids));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, multiple_gids));
 }
 
 TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
   // Make all files and directories non-world-writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
 
   // Initialy, we control all parts of the path.
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make base_dir_ world-writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(base_dir_, S_IWOTH, 0u));
+  EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make sub_dir_ world writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(sub_dir_, S_IWOTH, 0u));
+  EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make text_file_ world writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(text_file_, S_IWOTH, 0u));
+  EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make sub_dir_ non-world writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
+  EXPECT_FALSE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make base_dir_ non-world-writable.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_FALSE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 
   // Back to the initial state: Nothing is writable, so every path
   // should pass.
   ASSERT_NO_FATAL_FAILURE(
       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
+  EXPECT_TRUE(VerifyPathControlledByUser(base_dir_, sub_dir_, uid_, ok_gids_));
   EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, sub_dir_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          base_dir_, text_file_, uid_, ok_gids_));
-  EXPECT_TRUE(
-      base::VerifyPathControlledByUser(
-          sub_dir_, text_file_, uid_, ok_gids_));
+      VerifyPathControlledByUser(base_dir_, text_file_, uid_, ok_gids_));
+  EXPECT_TRUE(VerifyPathControlledByUser(sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #if defined(OS_ANDROID)
 TEST_F(FileUtilTest, ValidContentUriTest) {
   // Get the test image path.
   FilePath data_dir;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
   ASSERT_TRUE(PathExists(data_dir));
   FilePath image_file = data_dir.Append(FILE_PATH_LITERAL("red.png"));
   int64 image_size;
   GetFileSize(image_file, &image_size);
   EXPECT_LT(0, image_size);
 
   // Insert the image into MediaStore. MediaStore will do some conversions, and
   // return the content URI.
-  FilePath path = base::InsertImageIntoMediaStore(image_file);
+  FilePath path = InsertImageIntoMediaStore(image_file);
   EXPECT_TRUE(path.IsContentUri());
   EXPECT_TRUE(PathExists(path));
   // The file size may not equal to the input image as MediaStore may convert
   // the image.
   int64 content_uri_size;
   GetFileSize(path, &content_uri_size);
   EXPECT_EQ(image_size, content_uri_size);
 
   // We should be able to read the file.
   char* buffer = new char[image_size];
@@ skipping 15 matching lines @@
   File file = OpenContentUriForRead(path);
   EXPECT_FALSE(file.IsValid());
 }
 #endif
 
 TEST(ScopedFD, ScopedFDDoesClose) {
   int fds[2];
   char c = 0;
   ASSERT_EQ(0, pipe(fds));
   const int write_end = fds[1];
-  base::ScopedFD read_end_closer(fds[0]);
+  ScopedFD read_end_closer(fds[0]);
   {
-    base::ScopedFD write_end_closer(fds[1]);
+    ScopedFD write_end_closer(fds[1]);
   }
   // This is the only thread. This file descriptor should no longer be valid.
   int ret = close(write_end);
   EXPECT_EQ(-1, ret);
   EXPECT_EQ(EBADF, errno);
   // Make sure read(2) won't block.
   ASSERT_EQ(0, fcntl(fds[0], F_SETFL, O_NONBLOCK));
   // Reading the pipe should EOF.
   EXPECT_EQ(0, read(fds[0], &c, 1));
 }
 
 #if defined(GTEST_HAS_DEATH_TEST)
 void CloseWithScopedFD(int fd) {
-  base::ScopedFD fd_closer(fd);
+  ScopedFD fd_closer(fd);
 }
 #endif
 
 TEST(ScopedFD, ScopedFDCrashesOnCloseFailure) {
   int fds[2];
   ASSERT_EQ(0, pipe(fds));
-  base::ScopedFD read_end_closer(fds[0]);
+  ScopedFD read_end_closer(fds[0]);
   EXPECT_EQ(0, IGNORE_EINTR(close(fds[1])));
 #if defined(GTEST_HAS_DEATH_TEST)
   // This is the only thread. This file descriptor should no longer be valid.
   // Trying to close it should crash. This is important for security.
   EXPECT_DEATH(CloseWithScopedFD(fds[1]), "");
 #endif
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base