Add the methods to change and get a posix file permission to file_util.

base/file_util_unittest.cc

Index: base/file_util_unittest.cc
diff --git a/base/file_util_unittest.cc b/base/file_util_unittest.cc
index 55f2039e4519d23183898a8b7bda990f1860ba6a..a69d8add41e745f289c726e7f7bbe66cf69e4fbd 100644
--- a/base/file_util_unittest.cc
+++ b/base/file_util_unittest.cc
@@ -111,24 +111,6 @@ bool DeleteReparsePoint(HANDLE source) {
 #endif
 
 #if defined(OS_POSIX)
-// Provide a simple way to change the permissions bits on |path| in tests.
-// ASSERT failures will return, but not stop the test.  Caller should wrap
-// calls to this function in ASSERT_NO_FATAL_FAILURE().
-void ChangePosixFilePermissions(const FilePath& path,
-                                mode_t mode_bits_to_set,
-                                mode_t mode_bits_to_clear) {
-  ASSERT_FALSE(mode_bits_to_set & mode_bits_to_clear)
-      << "Can't set and clear the same bits.";
-
-  struct stat stat_buf;
-  ASSERT_EQ(0, stat(path.value().c_str(), &stat_buf));
-
-  mode_t updated_mode_bits = stat_buf.st_mode;
-  updated_mode_bits |= mode_bits_to_set;
-  updated_mode_bits &= ~mode_bits_to_clear;
-
-  ASSERT_EQ(0, chmod(path.value().c_str(), updated_mode_bits));
-}
 #endif  // defined(OS_POSIX)
 
 const wchar_t bogus_content[] = L"I'm cannon fodder.";
@@ -667,7 +649,6 @@ TEST_F(FileUtilTest, CreateAndReadSymlinks) {
   ASSERT_FALSE(file_util::ReadSymbolicLink(missing, &result));
 }
 
-
 // The following test of NormalizeFilePath() require that we create a symlink.
 // This can not be done on Windows before Vista.  On Vista, creating a symlink
 // requires privilege "SeCreateSymbolicLinkPrivilege".
@@ -784,6 +765,138 @@ TEST_F(FileUtilTest, DeleteSymlinkToNonExistentFile) {
   // Make sure the symbolic link is deleted
   EXPECT_FALSE(file_util::IsLink(file_link));
 }
+
+TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
+  // Create a file path
+  FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
+  EXPECT_FALSE(file_util::PathExists(file_name));
+
+  char buffer[32] = "hello";
+  std::string data(buffer);
+
+  // Write file
+  EXPECT_EQ(static_cast<int>(data.length()),
+            file_util::WriteFile(file_name, data.c_str(), data.length()));
+  EXPECT_TRUE(file_util::PathExists(file_name));
+
+  // Meke sure the file is readable
+  mode_t mode;
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(S_IRUSR, static_cast<int>(mode) & S_IRUSR);
+
+  // Get rid of the read permission
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(file_name, 0u, S_IRUSR));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(0, static_cast<int>(mode) & S_IRUSR);
+  // Make sure the file can't be read
+  EXPECT_EQ(-1, file_util::ReadFile(file_name, buffer, sizeof(buffer)));
+
+  // Give the read permission
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(file_name, S_IRUSR, 0u));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(S_IRUSR, static_cast<int>(mode) & S_IRUSR);
+  // Make sure the file can be read
+  EXPECT_EQ(static_cast<int>(data.length()),
+            file_util::ReadFile(file_name, buffer, sizeof(buffer)));
+
+  // Delete the file
+  EXPECT_TRUE(file_util::Delete(file_name, false));
+  EXPECT_FALSE(file_util::PathExists(file_name));
+}
+
+TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
+  // Create a file path
+  FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
+  EXPECT_FALSE(file_util::PathExists(file_name));
+
+  char buffer[32] = "hello";
+  std::string data(buffer);
+
+  // Write file
+  EXPECT_EQ(static_cast<int>(data.length()),
+            file_util::WriteFile(file_name, data.c_str(), data.length()));
+  EXPECT_TRUE(file_util::PathExists(file_name));
+
+  // Meke sure the file is writable
+  mode_t mode;
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(S_IWUSR, static_cast<int>(mode) & S_IWUSR);
+  EXPECT_TRUE(file_util::PathIsWritable(file_name));
+
+  // Get rid of the write permission
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(file_name, 0u, S_IWUSR));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(0, static_cast<int>(mode) & S_IWUSR);
+  // Make sure the file can't be write
+  EXPECT_EQ(-1,
+            file_util::WriteFile(file_name, data.c_str(), data.length()));
+  EXPECT_FALSE(file_util::PathIsWritable(file_name));
+
+  // Give read permission
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(file_name, S_IWUSR, 0u));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_EQ(S_IWUSR, static_cast<int>(mode) & S_IWUSR);
+  // Make sure the file can be write
+  EXPECT_EQ(static_cast<int>(data.length()),
+            file_util::WriteFile(file_name, data.c_str(), data.length()));
+  EXPECT_TRUE(file_util::PathIsWritable(file_name));
+
+  // Delete the file
+  EXPECT_TRUE(file_util::Delete(file_name, false));
+  EXPECT_FALSE(file_util::PathExists(file_name));
+}
+
+TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
+  // Create a directory path
+  FilePath subdir_path =
+      temp_dir_.path().Append(FPL("PermissionTest1"));
+  file_util::CreateDirectory(subdir_path);
+  ASSERT_TRUE(file_util::PathExists(subdir_path));
+
+  // Create a dummy file to enumerate
+  FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
+  EXPECT_FALSE(file_util::PathExists(file_name));
+  char buffer[32] = "hello";
+  std::string data(buffer);
+  EXPECT_EQ(static_cast<int>(data.length()),
+            file_util::WriteFile(file_name, data.c_str(), data.length()));
+  EXPECT_TRUE(file_util::PathExists(file_name));
+
+  // Meke sure the file is the all permissions
+  mode_t mode;
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_EQ(S_IRWXU, static_cast<int>(mode) & S_IRWXU);
+
+  // Get rid of the permissions from the directory
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(subdir_path, 0u, S_IRWXU));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_EQ(0, static_cast<int>(mode) & S_IRWXU);
+
+  // Make sure the file in the directory can't be enumerated.
+  file_util::FileEnumerator f1(subdir_path, true,
+                               file_util::FileEnumerator::FILES);
+  EXPECT_TRUE(file_util::PathExists(subdir_path));
+  FindResultCollector c1(f1);
+  EXPECT_EQ(c1.size(), 0);
+  EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
+
+  // Give the permissions to the directory
+  EXPECT_TRUE(file_util::ChangePosixFilePermissions(subdir_path, S_IRWXU, 0u));
+  EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_EQ(S_IRWXU, static_cast<int>(mode) & S_IRWXU);
+
+  // Make sure the file in the directory can be enumerated.
+  file_util::FileEnumerator f2(subdir_path, true,
+                               file_util::FileEnumerator::FILES);
+  FindResultCollector c2(f2);
+  EXPECT_TRUE(c2.HasFile(file_name));
+  EXPECT_EQ(c2.size(), 1);
+
+  // Delete the file
+  EXPECT_TRUE(file_util::Delete(subdir_path, true));
+  EXPECT_FALSE(file_util::PathExists(subdir_path));
+}
+
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
@@ -2003,11 +2116,11 @@ class VerifyPathControlledByUserTest : public FileUtilTest {
     mode_t disabled_permissions =
         S_IRWXO;   // Other users can't read, write, traverse.
 
-    ASSERT_NO_FATAL_FAILURE(
-        ChangePosixFilePermissions(
+    ASSERT_TRUE(
+        file_util::ChangePosixFilePermissions(
             base_dir_, enabled_permissions, disabled_permissions));
-    ASSERT_NO_FATAL_FAILURE(
-        ChangePosixFilePermissions(
+    ASSERT_TRUE(
+        file_util::ChangePosixFilePermissions(
             sub_dir_, enabled_permissions, disabled_permissions));
   }
 
@@ -2088,12 +2201,12 @@ TEST_F(VerifyPathControlledByUserTest, OwnershipChecks) {
   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));
+  ASSERT_TRUE(
+      file_util:: ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
 
   // We control these paths.
   EXPECT_TRUE(
@@ -2131,12 +2244,12 @@ TEST_F(VerifyPathControlledByUserTest, OwnershipChecks) {
 
 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));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH|S_IWGRP));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH|S_IWGRP));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, 0u, S_IWOTH|S_IWGRP));
 
   // Any group is okay because the path is not group-writable.
   EXPECT_TRUE(
@@ -2174,12 +2287,12 @@ TEST_F(VerifyPathControlledByUserTest, GroupWriteTest) {
 
 
   // 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_TRUE(
+      file_util::ChangePosixFilePermissions(base_dir_, S_IWGRP, 0u));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, S_IWGRP, 0u));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, S_IWGRP, 0u));
 
   // Now |ok_gids_| works, but |bad_gids_| fails.
   EXPECT_TRUE(
@@ -2224,12 +2337,12 @@ TEST_F(VerifyPathControlledByUserTest, GroupWriteTest) {
 
 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));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
 
   // Initialy, we control all parts of the path.
   EXPECT_TRUE(
@@ -2243,8 +2356,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
           sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make base_dir_ world-writable.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(base_dir_, S_IWOTH, 0u));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(base_dir_, S_IWOTH, 0u));
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
@@ -2256,8 +2369,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
           sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make sub_dir_ world writable.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(sub_dir_, S_IWOTH, 0u));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, S_IWOTH, 0u));
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
@@ -2269,8 +2382,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
           sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make text_file_ world writable.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(text_file_, S_IWOTH, 0u));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, S_IWOTH, 0u));
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
@@ -2282,8 +2395,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
           sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make sub_dir_ non-world writable.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
@@ -2295,8 +2408,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
           sub_dir_, text_file_, uid_, ok_gids_));
 
   // Make base_dir_ non-world-writable.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
@@ -2309,8 +2422,8 @@ TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
 
   // Back to the initial state: Nothing is writable, so every path
   // should pass.
-  ASSERT_NO_FATAL_FAILURE(
-      ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
+  ASSERT_TRUE(
+      file_util::ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));