diff --git a/tsl/platform/null_file_system.h b/tsl/platform/null_file_system.h
index 646d64720..8b9d69fcc 100644
--- a/tsl/platform/null_file_system.h
+++ b/tsl/platform/null_file_system.h
@@ -38,76 +38,67 @@ class NullFileSystem : public FileSystem {
 
   ~NullFileSystem() override = default;
 
-  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
-
   absl::Status NewRandomAccessFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<RandomAccessFile>* result) override {
     return errors::Unimplemented("NewRandomAccessFile unimplemented");
   }
 
   absl::Status NewWritableFile(const std::string& fname,
-                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override {
     return errors::Unimplemented("NewWritableFile unimplemented");
   }
 
   absl::Status NewAppendableFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<WritableFile>* result) override {
     return errors::Unimplemented("NewAppendableFile unimplemented");
   }
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
     return errors::Unimplemented(
         "NewReadOnlyMemoryRegionFromFile unimplemented");
   }
 
-  absl::Status FileExists(absl::string_view fname,
-                          TransactionToken* token) override {
+  absl::Status FileExists(absl::string_view fname) override {
     return errors::Unimplemented("FileExists unimplemented");
   }
 
-  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+  absl::Status GetChildren(const std::string& dir,
                            std::vector<std::string>* result) override {
     return errors::Unimplemented("GetChildren unimplemented");
   }
 
   absl::Status GetMatchingPaths(const std::string& pattern,
-                                TransactionToken* token,
                                 std::vector<std::string>* results) override {
     return internal::GetMatchingPaths(this, Env::Default(), pattern, results);
   }
 
-  absl::Status DeleteFile(const std::string& fname,
-                          TransactionToken* token) override {
+  absl::Status DeleteFile(const std::string& fname) override {
     return errors::Unimplemented("DeleteFile unimplemented");
   }
 
-  absl::Status CreateDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status CreateDir(const std::string& dirname) override {
     return errors::Unimplemented("CreateDir unimplemented");
   }
 
-  absl::Status DeleteDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status DeleteDir(const std::string& dirname) override {
     return errors::Unimplemented("DeleteDir unimplemented");
   }
 
-  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+  absl::Status GetFileSize(const std::string& fname,
                            uint64_t* file_size) override {
     return errors::Unimplemented("GetFileSize unimplemented");
   }
 
-  absl::Status RenameFile(const std::string& src, const std::string& target,
-                          TransactionToken* token) override {
+  absl::Status RenameFile(const std::string& src,
+                          const std::string& target) override {
     return errors::Unimplemented("RenameFile unimplemented");
   }
 
-  absl::Status Stat(const std::string& fname, TransactionToken* token,
-                    FileStatistics* stat) override {
+  absl::Status Stat(const std::string& fname, FileStatistics* stat) override {
     return errors::Unimplemented("Stat unimplemented");
   }
 };
diff --git a/tsl/platform/retrying_file_system.h b/tsl/platform/retrying_file_system.h
index 392486f31..ad465bd47 100644
--- a/tsl/platform/retrying_file_system.h
+++ b/tsl/platform/retrying_file_system.h
@@ -39,112 +39,90 @@ class RetryingFileSystem : public FileSystem {
       : base_file_system_(std::move(base_file_system)),
         retry_config_(retry_config) {}
 
-  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
-
   absl::Status NewRandomAccessFile(
-      const std::string& filename, TransactionToken* token,
+      const std::string& filename,
       std::unique_ptr<RandomAccessFile>* result) override;
 
   absl::Status NewWritableFile(const std::string& filename,
-                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override;
 
   absl::Status NewAppendableFile(
-      const std::string& filename, TransactionToken* token,
+      const std::string& filename,
       std::unique_ptr<WritableFile>* result) override;
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const std::string& filename, TransactionToken* token,
+      const std::string& filename,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override;
 
-  absl::Status FileExists(absl::string_view fname,
-                          TransactionToken* token) override {
+  absl::Status FileExists(absl::string_view fname) override {
     return RetryingUtils::CallWithRetries(
-        [this, &fname, token]() {
-          return base_file_system_->FileExists(fname, token);
-        },
+        [this, &fname]() { return base_file_system_->FileExists(fname); },
         retry_config_);
   }
 
-  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+  absl::Status GetChildren(const std::string& dir,
                            std::vector<std::string>* result) override {
     return RetryingUtils::CallWithRetries(
-        [this, &dir, result, token]() {
-          return base_file_system_->GetChildren(dir, token, result);
+        [this, &dir, result]() {
+          return base_file_system_->GetChildren(dir, result);
         },
         retry_config_);
   }
 
   absl::Status GetMatchingPaths(const std::string& pattern,
-                                TransactionToken* token,
                                 std::vector<std::string>* result) override {
     return RetryingUtils::CallWithRetries(
-        [this, &pattern, result, token]() {
-          return base_file_system_->GetMatchingPaths(pattern, token, result);
+        [this, &pattern, result]() {
+          return base_file_system_->GetMatchingPaths(pattern, result);
         },
         retry_config_);
   }
 
-  absl::Status Stat(const std::string& fname, TransactionToken* token,
-                    FileStatistics* stat) override {
+  absl::Status Stat(const std::string& fname, FileStatistics* stat) override {
     return RetryingUtils::CallWithRetries(
-        [this, &fname, stat, token]() {
-          return base_file_system_->Stat(fname, token, stat);
-        },
+        [this, &fname, stat]() { return base_file_system_->Stat(fname, stat); },
         retry_config_);
   }
 
-  absl::Status DeleteFile(const std::string& fname,
-                          TransactionToken* token) override {
+  absl::Status DeleteFile(const std::string& fname) override {
     return RetryingUtils::DeleteWithRetries(
-        [this, &fname, token]() {
-          return base_file_system_->DeleteFile(fname, token);
-        },
+        [this, &fname]() { return base_file_system_->DeleteFile(fname); },
         retry_config_);
   }
 
-  absl::Status CreateDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status CreateDir(const std::string& dirname) override {
     return RetryingUtils::CallWithRetries(
-        [this, &dirname, token]() {
-          return base_file_system_->CreateDir(dirname, token);
-        },
+        [this, &dirname]() { return base_file_system_->CreateDir(dirname); },
         retry_config_);
   }
 
-  absl::Status DeleteDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status DeleteDir(const std::string& dirname) override {
     return RetryingUtils::DeleteWithRetries(
-        [this, &dirname, token]() {
-          return base_file_system_->DeleteDir(dirname, token);
-        },
+        [this, &dirname]() { return base_file_system_->DeleteDir(dirname); },
         retry_config_);
   }
 
-  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+  absl::Status GetFileSize(const std::string& fname,
                            uint64_t* file_size) override {
     return RetryingUtils::CallWithRetries(
-        [this, &fname, file_size, token]() {
-          return base_file_system_->GetFileSize(fname, token, file_size);
+        [this, &fname, file_size]() {
+          return base_file_system_->GetFileSize(fname, file_size);
         },
         retry_config_);
   }
 
-  absl::Status RenameFile(const std::string& src, const std::string& target,
-                          TransactionToken* token) override {
+  absl::Status RenameFile(const std::string& src,
+                          const std::string& target) override {
     return RetryingUtils::CallWithRetries(
-        [this, &src, &target, token]() {
-          return base_file_system_->RenameFile(src, target, token);
+        [this, &src, &target]() {
+          return base_file_system_->RenameFile(src, target);
         },
         retry_config_);
   }
 
-  absl::Status IsDirectory(const std::string& dirname,
-                           TransactionToken* token) override {
+  absl::Status IsDirectory(const std::string& dirname) override {
     return RetryingUtils::CallWithRetries(
-        [this, &dirname, token]() {
-          return base_file_system_->IsDirectory(dirname, token);
-        },
+        [this, &dirname]() { return base_file_system_->IsDirectory(dirname); },
         retry_config_);
   }
 
@@ -155,20 +133,17 @@ class RetryingFileSystem : public FileSystem {
   }
 
   absl::Status DeleteRecursively(const std::string& dirname,
-                                 TransactionToken* token,
                                  int64_t* undeleted_files,
                                  int64_t* undeleted_dirs) override {
     return RetryingUtils::DeleteWithRetries(
-        [this, &dirname, token, undeleted_files, undeleted_dirs]() {
-          return base_file_system_->DeleteRecursively(
-              dirname, token, undeleted_files, undeleted_dirs);
+        [this, &dirname, undeleted_files, undeleted_dirs]() {
+          return base_file_system_->DeleteRecursively(dirname, undeleted_files,
+                                                      undeleted_dirs);
         },
         retry_config_);
   }
 
-  void FlushCaches(TransactionToken* token) override {
-    base_file_system_->FlushCaches(token);
-  }
+  void FlushCaches() override { base_file_system_->FlushCaches(); }
 
   Underlying* underlying() const { return base_file_system_.get(); }
 
@@ -251,13 +226,11 @@ class RetryingWritableFile : public WritableFile {
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewRandomAccessFile(
-    const std::string& filename, TransactionToken* token,
-    std::unique_ptr<RandomAccessFile>* result) {
+    const std::string& filename, std::unique_ptr<RandomAccessFile>* result) {
   std::unique_ptr<RandomAccessFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
-      [this, &filename, &base_file, token]() {
-        return base_file_system_->NewRandomAccessFile(filename, token,
-                                                      &base_file);
+      [this, &filename, &base_file]() {
+        return base_file_system_->NewRandomAccessFile(filename, &base_file);
       },
       retry_config_));
   *result = std::make_unique<retrying_internals::RetryingRandomAccessFile>(
@@ -267,12 +240,11 @@ absl::Status RetryingFileSystem<Underlying>::NewRandomAccessFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewWritableFile(
-    const std::string& filename, TransactionToken* token,
-    std::unique_ptr<WritableFile>* result) {
+    const std::string& filename, std::unique_ptr<WritableFile>* result) {
   std::unique_ptr<WritableFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
-      [this, &filename, &base_file, token]() {
-        return base_file_system_->NewWritableFile(filename, token, &base_file);
+      [this, &filename, &base_file]() {
+        return base_file_system_->NewWritableFile(filename, &base_file);
       },
       retry_config_));
   *result = std::make_unique<retrying_internals::RetryingWritableFile>(
@@ -282,13 +254,11 @@ absl::Status RetryingFileSystem<Underlying>::NewWritableFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewAppendableFile(
-    const std::string& filename, TransactionToken* token,
-    std::unique_ptr<WritableFile>* result) {
+    const std::string& filename, std::unique_ptr<WritableFile>* result) {
   std::unique_ptr<WritableFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
-      [this, &filename, &base_file, token]() {
-        return base_file_system_->NewAppendableFile(filename, token,
-                                                    &base_file);
+      [this, &filename, &base_file]() {
+        return base_file_system_->NewAppendableFile(filename, &base_file);
       },
       retry_config_));
   *result = std::make_unique<retrying_internals::RetryingWritableFile>(
@@ -298,12 +268,12 @@ absl::Status RetryingFileSystem<Underlying>::NewAppendableFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewReadOnlyMemoryRegionFromFile(
-    const std::string& filename, TransactionToken* token,
+    const std::string& filename,
     std::unique_ptr<ReadOnlyMemoryRegion>* result) {
   return RetryingUtils::CallWithRetries(
-      [this, &filename, result, token]() {
-        return base_file_system_->NewReadOnlyMemoryRegionFromFile(
-            filename, token, result);
+      [this, &filename, result]() {
+        return base_file_system_->NewReadOnlyMemoryRegionFromFile(filename,
+                                                                  result);
       },
       retry_config_);
 }
diff --git a/tsl/platform/retrying_file_system_test.cc b/tsl/platform/retrying_file_system_test.cc
index 5f43f2988..d3a938754 100644
--- a/tsl/platform/retrying_file_system_test.cc
+++ b/tsl/platform/retrying_file_system_test.cc
@@ -99,93 +99,83 @@ class MockFileSystem : public FileSystem {
   explicit MockFileSystem(const ExpectedCalls& calls, bool* flushed = nullptr)
       : calls_(calls), flushed_(flushed) {}
 
-  TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
-
   absl::Status NewRandomAccessFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<RandomAccessFile>* result) override {
     *result = std::move(random_access_file_to_return);
     return calls_.ConsumeNextCall("NewRandomAccessFile");
   }
 
   absl::Status NewWritableFile(const std::string& fname,
-                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override {
     *result = std::move(writable_file_to_return);
     return calls_.ConsumeNextCall("NewWritableFile");
   }
 
   absl::Status NewAppendableFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<WritableFile>* result) override {
     *result = std::move(writable_file_to_return);
     return calls_.ConsumeNextCall("NewAppendableFile");
   }
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const std::string& fname, TransactionToken* token,
+      const std::string& fname,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
     return calls_.ConsumeNextCall("NewReadOnlyMemoryRegionFromFile");
   }
 
-  absl::Status FileExists(absl::string_view fname,
-                          TransactionToken* token) override {
+  absl::Status FileExists(absl::string_view fname) override {
     return calls_.ConsumeNextCall("FileExists");
   }
 
-  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+  absl::Status GetChildren(const std::string& dir,
                            std::vector<std::string>* result) override {
     return calls_.ConsumeNextCall("GetChildren");
   }
 
-  absl::Status GetMatchingPaths(const std::string& dir, TransactionToken* token,
+  absl::Status GetMatchingPaths(const std::string& dir,
                                 std::vector<std::string>* result) override {
     return calls_.ConsumeNextCall("GetMatchingPaths");
   }
 
-  absl::Status Stat(const std::string& fname, TransactionToken* token,
-                    FileStatistics* stat) override {
+  absl::Status Stat(const std::string& fname, FileStatistics* stat) override {
     return calls_.ConsumeNextCall("Stat");
   }
 
-  absl::Status DeleteFile(const std::string& fname,
-                          TransactionToken* token) override {
+  absl::Status DeleteFile(const std::string& fname) override {
     return calls_.ConsumeNextCall("DeleteFile");
   }
 
-  absl::Status CreateDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status CreateDir(const std::string& dirname) override {
     return calls_.ConsumeNextCall("CreateDir");
   }
 
-  absl::Status DeleteDir(const std::string& dirname,
-                         TransactionToken* token) override {
+  absl::Status DeleteDir(const std::string& dirname) override {
     return calls_.ConsumeNextCall("DeleteDir");
   }
 
-  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+  absl::Status GetFileSize(const std::string& fname,
                            uint64_t* file_size) override {
     return calls_.ConsumeNextCall("GetFileSize");
   }
 
-  absl::Status RenameFile(const std::string& src, const std::string& target,
-                          TransactionToken* token) override {
+  absl::Status RenameFile(const std::string& src,
+                          const std::string& target) override {
     return calls_.ConsumeNextCall("RenameFile");
   }
 
-  absl::Status IsDirectory(const std::string& dirname,
-                           TransactionToken* token) override {
+  absl::Status IsDirectory(const std::string& dirname) override {
     return calls_.ConsumeNextCall("IsDirectory");
   }
 
   absl::Status DeleteRecursively(const std::string& dirname,
-                                 TransactionToken* token,
                                  int64_t* undeleted_files,
                                  int64_t* undeleted_dirs) override {
     return calls_.ConsumeNextCall("DeleteRecursively");
   }
 
-  void FlushCaches(TransactionToken* token) override {
+  void FlushCaches() override {
     if (flushed_) {
       *flushed_ = true;
     }
@@ -218,8 +208,7 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_ImmediateSuccess) {
 
   // Retrieve the wrapped random access file.
   std::unique_ptr<RandomAccessFile> random_access_file;
-  TF_EXPECT_OK(
-      fs.NewRandomAccessFile("filename.txt", nullptr, &random_access_file));
+  TF_EXPECT_OK(fs.NewRandomAccessFile("filename.txt", &random_access_file));
 
   // Use it and check the results.
   absl::string_view result;
@@ -251,8 +240,7 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_SuccessWith3rdTry) {
 
   // Retrieve the wrapped random access file.
   std::unique_ptr<RandomAccessFile> random_access_file;
-  TF_EXPECT_OK(
-      fs.NewRandomAccessFile("filename.txt", nullptr, &random_access_file));
+  TF_EXPECT_OK(fs.NewRandomAccessFile("filename.txt", &random_access_file));
 
   // Use it and check the results.
   absl::string_view result;
@@ -278,8 +266,7 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_AllRetriesFailed) {
 
   // Retrieve the wrapped random access file.
   std::unique_ptr<RandomAccessFile> random_access_file;
-  TF_EXPECT_OK(
-      fs.NewRandomAccessFile("filename.txt", nullptr, &random_access_file));
+  TF_EXPECT_OK(fs.NewRandomAccessFile("filename.txt", &random_access_file));
 
   // Use it and check the results.
   absl::string_view result;
@@ -310,8 +297,7 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_NoRetriesForSomeErrors) {
 
   // Retrieve the wrapped random access file.
   std::unique_ptr<RandomAccessFile> random_access_file;
-  TF_EXPECT_OK(
-      fs.NewRandomAccessFile("filename.txt", nullptr, &random_access_file));
+  TF_EXPECT_OK(fs.NewRandomAccessFile("filename.txt", &random_access_file));
 
   // Use it and check the results.
   absl::string_view result;
@@ -341,7 +327,7 @@ TEST(RetryingFileSystemTest, NewWritableFile_ImmediateSuccess) {
 
   // Retrieve the wrapped writable file.
   std::unique_ptr<WritableFile> writable_file;
-  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", nullptr, &writable_file));
+  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", &writable_file));
 
   absl::string_view result;
   TF_EXPECT_OK(writable_file->Name(&result));
@@ -372,7 +358,7 @@ TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry) {
 
   // Retrieve the wrapped writable file.
   std::unique_ptr<WritableFile> writable_file;
-  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", nullptr, &writable_file));
+  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", &writable_file));
 
   // Use it and check the results.
   TF_EXPECT_OK(writable_file->Sync());
@@ -399,7 +385,7 @@ TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry_ViaDestructor) {
 
   // Retrieve the wrapped writable file.
   std::unique_ptr<WritableFile> writable_file;
-  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", nullptr, &writable_file));
+  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", &writable_file));
 
   writable_file.reset();  // Trigger Close() via destructor.
 }
@@ -425,7 +411,7 @@ TEST(RetryingFileSystemTest, NewAppendableFile_SuccessWith3rdTry) {
 
   // Retrieve the wrapped appendable file.
   std::unique_ptr<WritableFile> writable_file;
-  TF_EXPECT_OK(fs.NewAppendableFile("filename.txt", nullptr, &writable_file));
+  TF_EXPECT_OK(fs.NewAppendableFile("filename.txt", &writable_file));
 
   // Use it and check the results.
   TF_EXPECT_OK(writable_file->Sync());
@@ -449,7 +435,7 @@ TEST(RetryingFileSystemTest, NewWritableFile_AllRetriesFailed) {
 
   // Retrieve the wrapped writable file.
   std::unique_ptr<WritableFile> writable_file;
-  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", nullptr, &writable_file));
+  TF_EXPECT_OK(fs.NewWritableFile("filename.txt", &writable_file));
 
   // Use it and check the results.
   const auto& status = writable_file->Sync();
@@ -469,8 +455,7 @@ TEST(RetryingFileSystemTest,
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   std::unique_ptr<ReadOnlyMemoryRegion> result;
-  TF_EXPECT_OK(
-      fs.NewReadOnlyMemoryRegionFromFile("filename.txt", nullptr, &result));
+  TF_EXPECT_OK(fs.NewReadOnlyMemoryRegionFromFile("filename.txt", &result));
 }
 
 TEST(RetryingFileSystemTest, NewReadOnlyMemoryRegionFromFile_AllRetriesFailed) {
@@ -483,7 +468,7 @@ TEST(RetryingFileSystemTest, NewReadOnlyMemoryRegionFromFile_AllRetriesFailed) {
 
   std::unique_ptr<ReadOnlyMemoryRegion> result;
   const auto& status =
-      fs.NewReadOnlyMemoryRegionFromFile("filename.txt", nullptr, &result);
+      fs.NewReadOnlyMemoryRegionFromFile("filename.txt", &result);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -499,7 +484,7 @@ TEST(RetryingFileSystemTest, GetChildren_SuccessWith2ndTry) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   std::vector<std::string> result;
-  TF_EXPECT_OK(fs.GetChildren("gs://path", nullptr, &result));
+  TF_EXPECT_OK(fs.GetChildren("gs://path", &result));
 }
 
 TEST(RetryingFileSystemTest, GetChildren_AllRetriesFailed) {
@@ -510,7 +495,7 @@ TEST(RetryingFileSystemTest, GetChildren_AllRetriesFailed) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   std::vector<std::string> result;
-  const auto& status = fs.GetChildren("gs://path", nullptr, &result);
+  const auto& status = fs.GetChildren("gs://path", &result);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -526,7 +511,7 @@ TEST(RetryingFileSystemTest, GetMatchingPaths_SuccessWith2ndTry) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   std::vector<std::string> result;
-  TF_EXPECT_OK(fs.GetMatchingPaths("gs://path/dir", nullptr, &result));
+  TF_EXPECT_OK(fs.GetMatchingPaths("gs://path/dir", &result));
 }
 
 TEST(RetryingFileSystemTest, GetMatchingPaths_AllRetriesFailed) {
@@ -538,7 +523,7 @@ TEST(RetryingFileSystemTest, GetMatchingPaths_AllRetriesFailed) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   std::vector<std::string> result;
-  const auto& status = fs.GetMatchingPaths("gs://path/dir", nullptr, &result);
+  const auto& status = fs.GetMatchingPaths("gs://path/dir", &result);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -552,7 +537,7 @@ TEST(RetryingFileSystemTest, DeleteFile_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.DeleteFile("gs://path/file.txt", nullptr));
+  TF_EXPECT_OK(fs.DeleteFile("gs://path/file.txt"));
 }
 
 TEST(RetryingFileSystemTest, DeleteFile_AllRetriesFailed) {
@@ -562,7 +547,7 @@ TEST(RetryingFileSystemTest, DeleteFile_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.DeleteFile("gs://path/file.txt", nullptr);
+  const auto& status = fs.DeleteFile("gs://path/file.txt");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -576,7 +561,7 @@ TEST(RetryingFileSystemTest, CreateDir_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.CreateDir("gs://path/newdir", nullptr));
+  TF_EXPECT_OK(fs.CreateDir("gs://path/newdir"));
 }
 
 TEST(RetryingFileSystemTest, CreateDir_AllRetriesFailed) {
@@ -586,7 +571,7 @@ TEST(RetryingFileSystemTest, CreateDir_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.CreateDir("gs://path/newdir", nullptr);
+  const auto& status = fs.CreateDir("gs://path/newdir");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -600,7 +585,7 @@ TEST(RetryingFileSystemTest, DeleteDir_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.DeleteDir("gs://path/dir", nullptr));
+  TF_EXPECT_OK(fs.DeleteDir("gs://path/dir"));
 }
 
 TEST(RetryingFileSystemTest, DeleteDir_AllRetriesFailed) {
@@ -610,7 +595,7 @@ TEST(RetryingFileSystemTest, DeleteDir_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.DeleteDir("gs://path/dir", nullptr);
+  const auto& status = fs.DeleteDir("gs://path/dir");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -626,7 +611,7 @@ TEST(RetryingFileSystemTest, GetFileSize_SuccessWith2ndTry) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   uint64_t size;
-  TF_EXPECT_OK(fs.GetFileSize("gs://path/file.txt", nullptr, &size));
+  TF_EXPECT_OK(fs.GetFileSize("gs://path/file.txt", &size));
 }
 
 TEST(RetryingFileSystemTest, GetFileSize_AllRetriesFailed) {
@@ -637,7 +622,7 @@ TEST(RetryingFileSystemTest, GetFileSize_AllRetriesFailed) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   uint64_t size;
-  const auto& status = fs.GetFileSize("gs://path/file.txt", nullptr, &size);
+  const auto& status = fs.GetFileSize("gs://path/file.txt", &size);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -651,7 +636,7 @@ TEST(RetryingFileSystemTest, RenameFile_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.RenameFile("old_name", "new_name", nullptr));
+  TF_EXPECT_OK(fs.RenameFile("old_name", "new_name"));
 }
 
 TEST(RetryingFileSystemTest, RenameFile_AllRetriesFailed) {
@@ -661,7 +646,7 @@ TEST(RetryingFileSystemTest, RenameFile_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.RenameFile("old_name", "new_name", nullptr);
+  const auto& status = fs.RenameFile("old_name", "new_name");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -676,7 +661,7 @@ TEST(RetryingFileSystemTest, Stat_SuccessWith2ndTry) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   FileStatistics stat;
-  TF_EXPECT_OK(fs.Stat("file_name", nullptr, &stat));
+  TF_EXPECT_OK(fs.Stat("file_name", &stat));
 }
 
 TEST(RetryingFileSystemTest, Stat_AllRetriesFailed) {
@@ -687,7 +672,7 @@ TEST(RetryingFileSystemTest, Stat_AllRetriesFailed) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
   FileStatistics stat;
-  const auto& status = fs.Stat("file_name", nullptr, &stat);
+  const auto& status = fs.Stat("file_name", &stat);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -699,7 +684,7 @@ TEST(RetryingFileSystemTest, FileExists_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.FileExists("file_name", nullptr);
+  const auto& status = fs.FileExists("file_name");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -713,7 +698,7 @@ TEST(RetryingFileSystemTest, FileExists_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.FileExists("gs://path/dir", nullptr));
+  TF_EXPECT_OK(fs.FileExists("gs://path/dir"));
 }
 
 TEST(RetryingFileSystemTest, IsDirectory_SuccessWith2ndTry) {
@@ -726,7 +711,7 @@ TEST(RetryingFileSystemTest, IsDirectory_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  TF_EXPECT_OK(fs.IsDirectory("gs://path/dir", nullptr));
+  TF_EXPECT_OK(fs.IsDirectory("gs://path/dir"));
 }
 
 TEST(RetryingFileSystemTest, IsDirectory_AllRetriesFailed) {
@@ -736,7 +721,7 @@ TEST(RetryingFileSystemTest, IsDirectory_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  const auto& status = fs.IsDirectory("gs://path/dir", nullptr);
+  const auto& status = fs.IsDirectory("gs://path/dir");
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -752,8 +737,8 @@ TEST(RetryingFileSystemTest, DeleteRecursively_SuccessWith2ndTry) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
   int64_t undeleted_files, undeleted_dirs;
 
-  TF_EXPECT_OK(fs.DeleteRecursively("gs://path/dir", nullptr, &undeleted_files,
-                                    &undeleted_dirs));
+  TF_EXPECT_OK(
+      fs.DeleteRecursively("gs://path/dir", &undeleted_files, &undeleted_dirs));
 }
 
 TEST(RetryingFileSystemTest, DeleteRecursively_AllRetriesFailed) {
@@ -765,8 +750,8 @@ TEST(RetryingFileSystemTest, DeleteRecursively_AllRetriesFailed) {
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
   int64_t undeleted_files, undeleted_dirs;
 
-  const auto& status = fs.DeleteRecursively("gs://path/dir", nullptr,
-                                            &undeleted_files, &undeleted_dirs);
+  const auto& status =
+      fs.DeleteRecursively("gs://path/dir", &undeleted_files, &undeleted_dirs);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
 }
@@ -777,7 +762,7 @@ TEST(RetryingFileSystemTest, FlushCaches) {
   std::unique_ptr<MockFileSystem> base_fs(new MockFileSystem(none, &flushed));
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
-  fs.FlushCaches(nullptr);
+  fs.FlushCaches();
   EXPECT_TRUE(flushed);
 }