Convert file/filesystem services to new Mojo types

Bug: 955171
Change-Id: I66e911a8444621a4342ecfd77787704a63529672
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1632895Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Commit-Queue: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#664405}

components/services/filesystem/directory_impl.cc

@@ -18,7 +18,7 @@
 #include "components/services/filesystem/file_impl.h"
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/filesystem/util.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 
 namespace filesystem {
 
@@ -58,7 +58,7 @@ void DirectoryImpl::Read(ReadCallback callback) {
 
 // TODO(vtl): Move the implementation to a thread pool.
 void DirectoryImpl::OpenFile(const std::string& raw_path,
-                             mojom::FileRequest file,
+                             mojo::PendingReceiver<mojom::File> receiver,
                              uint32_t open_flags,
                              OpenFileCallback callback) {
   base::FilePath path;
@@ -82,11 +82,11 @@ void DirectoryImpl::OpenFile(const std::string& raw_path,
     return;
   }
 
-  if (file.is_pending()) {
-    mojo::MakeStrongBinding(
+  if (receiver) {
+    mojo::MakeSelfOwnedReceiver(
         std::make_unique<FileImpl>(path, std::move(base_file), temp_dir_,
                                    lock_table_),
-        std::move(file));
+        std::move(receiver));
   }
   std::move(callback).Run(base::File::Error::FILE_OK);
 }
@@ -114,10 +114,11 @@ void DirectoryImpl::OpenFileHandles(
   std::move(callback).Run(std::move(results));
 }
 
-void DirectoryImpl::OpenDirectory(const std::string& raw_path,
-                                  mojom::DirectoryRequest directory,
-                                  uint32_t open_flags,
-                                  OpenDirectoryCallback callback) {
+void DirectoryImpl::OpenDirectory(
+    const std::string& raw_path,
+    mojo::PendingReceiver<mojom::Directory> receiver,
+    uint32_t open_flags,
+    OpenDirectoryCallback callback) {
   base::FilePath path;
   base::File::Error error = ValidatePath(raw_path, directory_path_, &path);
   if (error != base::File::Error::FILE_OK) {
@@ -146,10 +147,10 @@ void DirectoryImpl::OpenDirectory(const std::string& raw_path,
     }
   }
 
-  if (directory.is_pending()) {
-    mojo::MakeStrongBinding(
+  if (receiver) {
+    mojo::MakeSelfOwnedReceiver(
         std::make_unique<DirectoryImpl>(path, temp_dir_, lock_table_),
-        std::move(directory));
+        std::move(receiver));
   }
 
   std::move(callback).Run(base::File::Error::FILE_OK);
@@ -297,12 +298,10 @@ void DirectoryImpl::StatFile(const std::string& raw_path,
                           MakeFileInformation(info));
 }
 
-void DirectoryImpl::Clone(mojom::DirectoryRequest directory) {
-  if (directory.is_pending()) {
-    mojo::MakeStrongBinding(std::make_unique<DirectoryImpl>(
-                                directory_path_, temp_dir_, lock_table_),
-                            std::move(directory));
-  }
+void DirectoryImpl::Clone(mojo::PendingReceiver<mojom::Directory> receiver) {
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<DirectoryImpl>(directory_path_, temp_dir_, lock_table_),
+      std::move(receiver));
 }
 
 void DirectoryImpl::ReadEntireFile(const std::string& raw_path,

components/services/filesystem/directory_impl.h

@@ -14,7 +14,6 @@
 #include "base/macros.h"
 #include "components/services/filesystem/public/interfaces/directory.mojom.h"
 #include "components/services/filesystem/shared_temp_dir.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
 
 namespace filesystem {
 
@@ -32,7 +31,7 @@ class DirectoryImpl : public mojom::Directory {
   // |Directory| implementation:
   void Read(ReadCallback callback) override;
   void OpenFile(const std::string& path,
-                mojom::FileRequest file,
+                mojo::PendingReceiver<mojom::File> receiver,
                 uint32_t open_flags,
                 OpenFileCallback callback) override;
   void OpenFileHandle(const std::string& path,
@@ -41,7 +40,7 @@ class DirectoryImpl : public mojom::Directory {
   void OpenFileHandles(std::vector<mojom::FileOpenDetailsPtr> details,
                        OpenFileHandlesCallback callback) override;
   void OpenDirectory(const std::string& path,
-                     mojom::DirectoryRequest directory,
+                     mojo::PendingReceiver<mojom::Directory> receiver,
                      uint32_t open_flags,
                      OpenDirectoryCallback callback) override;
   void Rename(const std::string& path,
@@ -58,7 +57,7 @@ class DirectoryImpl : public mojom::Directory {
                   IsWritableCallback callback) override;
   void Flush(FlushCallback callback) override;
   void StatFile(const std::string& path, StatFileCallback callback) override;
-  void Clone(mojom::DirectoryRequest directory) override;
+  void Clone(mojo::PendingReceiver<mojom::Directory> receiver) override;
   void ReadEntireFile(const std::string& path,
                       ReadEntireFileCallback callback) override;
   void WriteFile(const std::string& path,

components/services/filesystem/directory_impl_unittest.cc

@@ -11,6 +11,8 @@
 #include "base/stl_util.h"
 #include "components/services/filesystem/files_test_base.h"
 #include "components/services/filesystem/public/interfaces/directory.mojom.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace filesystem {
 namespace {
@@ -20,7 +22,7 @@ using DirectoryImplTest = FilesTestBase;
 constexpr char kData[] = "one two three";
 
 TEST_F(DirectoryImplTest, Read) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
@@ -34,15 +36,16 @@ TEST_F(DirectoryImplTest, Read) {
       {"my_file3", mojom::kFlagAppend | mojom::kFlagCreate}};
   for (size_t i = 0; i < base::size(files_to_create); i++) {
     error = base::File::Error::FILE_ERROR_FAILED;
-    bool handled = directory->OpenFile(files_to_create[i].name, nullptr,
-                                       files_to_create[i].open_flags, &error);
+    bool handled =
+        directory->OpenFile(files_to_create[i].name, mojo::NullReceiver(),
+                            files_to_create[i].open_flags, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(base::File::Error::FILE_OK, error);
   }
   // Make a directory.
   error = base::File::Error::FILE_ERROR_FAILED;
   bool handled = directory->OpenDirectory(
-      "my_dir", nullptr,
+      "my_dir", mojo::NullReceiver(),
       mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -76,20 +79,21 @@ TEST_F(DirectoryImplTest, Read) {
 // TODO(vtl): Properly test OpenFile() and OpenDirectory() (including flags).
 
 TEST_F(DirectoryImplTest, BasicRenameDelete) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
   // Create my_file.
   error = base::File::Error::FILE_ERROR_FAILED;
-  bool handled = directory->OpenFile(
-      "my_file", nullptr, mojom::kFlagWrite | mojom::kFlagCreate, &error);
+  bool handled =
+      directory->OpenFile("my_file", mojo::NullReceiver(),
+                          mojom::kFlagWrite | mojom::kFlagCreate, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_OK, error);
 
   // Opening my_file should succeed.
   error = base::File::Error::FILE_ERROR_FAILED;
-  handled = directory->OpenFile("my_file", nullptr,
+  handled = directory->OpenFile("my_file", mojo::NullReceiver(),
                                 mojom::kFlagRead | mojom::kFlagOpen, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -102,14 +106,14 @@ TEST_F(DirectoryImplTest, BasicRenameDelete) {
   // Opening my_file should fail.
 
   error = base::File::Error::FILE_ERROR_FAILED;
-  handled = directory->OpenFile("my_file", nullptr,
+  handled = directory->OpenFile("my_file", mojo::NullReceiver(),
                                 mojom::kFlagRead | mojom::kFlagOpen, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_ERROR_NOT_FOUND, error);
 
   // Opening my_new_file should succeed.
   error = base::File::Error::FILE_ERROR_FAILED;
-  handled = directory->OpenFile("my_new_file", nullptr,
+  handled = directory->OpenFile("my_new_file", mojo::NullReceiver(),
                                 mojom::kFlagRead | mojom::kFlagOpen, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -121,23 +125,23 @@ TEST_F(DirectoryImplTest, BasicRenameDelete) {
 
   // Opening my_new_file should fail.
   error = base::File::Error::FILE_ERROR_FAILED;
-  handled = directory->OpenFile("my_new_file", nullptr,
+  handled = directory->OpenFile("my_new_file", mojo::NullReceiver(),
                                 mojom::kFlagRead | mojom::kFlagOpen, &error);
   ASSERT_TRUE(handled);
   EXPECT_EQ(base::File::Error::FILE_ERROR_NOT_FOUND, error);
 }
 
 TEST_F(DirectoryImplTest, CantOpenDirectoriesAsFiles) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
   {
     // Create a directory called 'my_file'
-    mojom::DirectoryPtr my_file_directory;
+    mojo::Remote<mojom::Directory> my_file_directory;
     error = base::File::Error::FILE_ERROR_FAILED;
     bool handled = directory->OpenDirectory(
-        "my_file", MakeRequest(&my_file_directory),
+        "my_file", my_file_directory.BindNewPipeAndPassReceiver(),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -145,10 +149,10 @@ TEST_F(DirectoryImplTest, CantOpenDirectoriesAsFiles) {
 
   {
     // Attempt to open that directory as a file. This must fail!
-    mojom::FilePtr file;
+    mojo::Remote<mojom::File> file;
     error = base::File::Error::FILE_ERROR_FAILED;
     bool handled =
-        directory->OpenFile("my_file", MakeRequest(&file),
+        directory->OpenFile("my_file", file.BindNewPipeAndPassReceiver(),
                             mojom::kFlagRead | mojom::kFlagOpen, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(base::File::Error::FILE_ERROR_NOT_A_FILE, error);
@@ -156,16 +160,16 @@ TEST_F(DirectoryImplTest, CantOpenDirectoriesAsFiles) {
 }
 
 TEST_F(DirectoryImplTest, Clone) {
-  mojom::DirectoryPtr clone_one;
-  mojom::DirectoryPtr clone_two;
+  mojo::Remote<mojom::Directory> clone_one;
+  mojo::Remote<mojom::Directory> clone_two;
   base::File::Error error;
 
   {
-    mojom::DirectoryPtr directory;
+    mojo::Remote<mojom::Directory> directory;
     GetTemporaryRoot(&directory);
 
-    directory->Clone(MakeRequest(&clone_one));
-    directory->Clone(MakeRequest(&clone_two));
+    directory->Clone(clone_one.BindNewPipeAndPassReceiver());
+    directory->Clone(clone_two.BindNewPipeAndPassReceiver());
 
     // Original temporary directory goes out of scope here; shouldn't be
     // deleted since it has clones.
@@ -189,7 +193,7 @@ TEST_F(DirectoryImplTest, Clone) {
 }
 
 TEST_F(DirectoryImplTest, WriteFileReadFile) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
@@ -211,7 +215,7 @@ TEST_F(DirectoryImplTest, WriteFileReadFile) {
 }
 
 TEST_F(DirectoryImplTest, ReadEmptyFileIsNotFoundError) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
@@ -225,16 +229,16 @@ TEST_F(DirectoryImplTest, ReadEmptyFileIsNotFoundError) {
 }
 
 TEST_F(DirectoryImplTest, CantReadEntireFileOnADirectory) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
   // Create a directory
   {
-    mojom::DirectoryPtr my_file_directory;
+    mojo::Remote<mojom::Directory> my_file_directory;
     error = base::File::Error::FILE_ERROR_FAILED;
     bool handled = directory->OpenDirectory(
-        "my_dir", MakeRequest(&my_file_directory),
+        "my_dir", my_file_directory.BindNewPipeAndPassReceiver(),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -250,16 +254,16 @@ TEST_F(DirectoryImplTest, CantReadEntireFileOnADirectory) {
 }
 
 TEST_F(DirectoryImplTest, CantWriteFileOnADirectory) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 
   // Create a directory
   {
-    mojom::DirectoryPtr my_file_directory;
+    mojo::Remote<mojom::Directory> my_file_directory;
     error = base::File::Error::FILE_ERROR_FAILED;
     bool handled = directory->OpenDirectory(
-        "my_dir", MakeRequest(&my_file_directory),
+        "my_dir", my_file_directory.BindNewPipeAndPassReceiver(),
         mojom::kFlagRead | mojom::kFlagWrite | mojom::kFlagCreate, &error);
     ASSERT_TRUE(handled);
     EXPECT_EQ(base::File::Error::FILE_OK, error);
@@ -274,7 +278,7 @@ TEST_F(DirectoryImplTest, CantWriteFileOnADirectory) {
 }
 
 TEST_F(DirectoryImplTest, Flush) {
-  mojom::DirectoryPtr directory;
+  mojo::Remote<mojom::Directory> directory;
   GetTemporaryRoot(&directory);
   base::File::Error error;
 

components/services/filesystem/file_impl.cc

@@ -19,7 +19,7 @@
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/filesystem/shared_temp_dir.h"
 #include "components/services/filesystem/util.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 
 static_assert(sizeof(off_t) <= sizeof(int64_t), "off_t too big");
 static_assert(sizeof(size_t) >= sizeof(uint32_t), "size_t too small");
@@ -292,7 +292,8 @@ void FileImpl::Touch(mojom::TimespecOrNowPtr atime,
   std::move(callback).Run(base::File::Error::FILE_OK);
 }
 
-void FileImpl::Dup(mojom::FileRequest file, DupCallback callback) {
+void FileImpl::Dup(mojo::PendingReceiver<mojom::File> receiver,
+                   DupCallback callback) {
   if (!file_.IsValid()) {
     std::move(callback).Run(GetError(file_));
     return;
@@ -304,11 +305,11 @@ void FileImpl::Dup(mojom::FileRequest file, DupCallback callback) {
     return;
   }
 
-  if (file.is_pending()) {
-    mojo::MakeStrongBinding(
+  if (receiver) {
+    mojo::MakeSelfOwnedReceiver(
         std::make_unique<FileImpl>(path_, std::move(new_file), temp_dir_,
                                    lock_table_),
-        std::move(file));
+        std::move(receiver));
   }
   std::move(callback).Run(base::File::Error::FILE_OK);
 }

components/services/filesystem/file_impl.h

@@ -12,7 +12,6 @@
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "components/services/filesystem/public/interfaces/directory.mojom.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
 
 namespace base {
 class FilePath;
@@ -66,7 +65,8 @@ class FileImpl : public mojom::File {
   void Touch(mojom::TimespecOrNowPtr atime,
              mojom::TimespecOrNowPtr mtime,
              TouchCallback callback) override;
-  void Dup(mojom::FileRequest file, DupCallback callback) override;
+  void Dup(mojo::PendingReceiver<mojom::File> receiver,
+           DupCallback callback) override;
   void Flush(FlushCallback callback) override;
   void Lock(LockCallback callback) override;
   void Unlock(UnlockCallback callback) override;

components/services/filesystem/file_system_app.cc

@@ -10,7 +10,6 @@
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 #if defined(OS_WIN)
@@ -36,28 +35,23 @@ const char kUserDataDir[] = "user-data-dir";
 
 }  // namespace
 
-FileSystemApp::FileSystemApp(service_manager::mojom::ServiceRequest request)
-    : service_binding_(this, std::move(request)), lock_table_(new LockTable) {
-  registry_.AddInterface<mojom::FileSystem>(
-      base::Bind(&FileSystemApp::Create, base::Unretained(this)));
-}
+FileSystemApp::FileSystemApp(
+    mojo::PendingReceiver<service_manager::mojom::Service> receiver)
+    : service_binding_(this, std::move(receiver)),
+      lock_table_(base::MakeRefCounted<LockTable>()) {}
 
 FileSystemApp::~FileSystemApp() = default;
 
-void FileSystemApp::OnBindInterface(
-    const service_manager::BindSourceInfo& source_info,
+void FileSystemApp::OnConnect(
+    const service_manager::ConnectSourceInfo& source_info,
     const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle interface_pipe) {
-  registry_.BindInterface(interface_name, std::move(interface_pipe),
-                          source_info);
-}
-
-void FileSystemApp::Create(mojom::FileSystemRequest request,
-                           const service_manager::BindSourceInfo& source_info) {
-  mojo::MakeStrongBinding(
-      std::make_unique<FileSystemImpl>(source_info.identity, GetUserDataDir(),
-                                       lock_table_),
-      std::move(request));
+    mojo::ScopedMessagePipeHandle receiver_pipe) {
+  if (interface_name == mojom::FileSystem::Name_) {
+    file_systems_.Add(
+        std::make_unique<FileSystemImpl>(source_info.identity, GetUserDataDir(),
+                                         lock_table_),
+        mojo::PendingReceiver<mojom::FileSystem>(std::move(receiver_pipe)));
+  }
 }
 
 // static

components/services/filesystem/file_system_app.h

@@ -10,7 +10,8 @@
 #include "components/services/filesystem/file_system_impl.h"
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/filesystem/public/interfaces/file_system.mojom.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/unique_receiver_set.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_binding.h"
 
@@ -18,7 +19,8 @@ namespace filesystem {
 
 class FileSystemApp : public service_manager::Service {
  public:
-  explicit FileSystemApp(service_manager::mojom::ServiceRequest request);
+  explicit FileSystemApp(
+      mojo::PendingReceiver<service_manager::mojom::Service> receiver);
   ~FileSystemApp() override;
 
  private:
@@ -26,19 +28,13 @@ class FileSystemApp : public service_manager::Service {
   static base::FilePath GetUserDataDir();
 
   // |service_manager::Service| override:
-  void OnBindInterface(const service_manager::BindSourceInfo& source_info,
-                       const std::string& interface_name,
-                       mojo::ScopedMessagePipeHandle interface_pipe) override;
-
-  void Create(mojom::FileSystemRequest request,
-              const service_manager::BindSourceInfo& source_info);
+  void OnConnect(const service_manager::ConnectSourceInfo& source_info,
+                 const std::string& interface_name,
+                 mojo::ScopedMessagePipeHandle receiver_pipe) override;
 
   service_manager::ServiceBinding service_binding_;
-  service_manager::BinderRegistryWithArgs<
-      const service_manager::BindSourceInfo&>
-      registry_;
-
   scoped_refptr<LockTable> lock_table_;
+  mojo::UniqueReceiverSet<mojom::FileSystem> file_systems_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemApp);
 };

components/services/filesystem/file_system_impl.cc

@@ -17,7 +17,7 @@
 #include "build/build_config.h"
 #include "components/services/filesystem/directory_impl.h"
 #include "components/services/filesystem/lock_table.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "url/gurl.h"
 
@@ -30,10 +30,11 @@ FileSystemImpl::FileSystemImpl(const service_manager::Identity& remote_identity,
       lock_table_(std::move(lock_table)),
       persistent_dir_(persistent_dir) {}
 
-FileSystemImpl::~FileSystemImpl() {}
+FileSystemImpl::~FileSystemImpl() = default;
 
-void FileSystemImpl::OpenTempDirectory(mojom::DirectoryRequest directory,
-                                       OpenTempDirectoryCallback callback) {
+void FileSystemImpl::OpenTempDirectory(
+    mojo::PendingReceiver<mojom::Directory> receiver,
+    OpenTempDirectoryCallback callback) {
   // Set only if the |DirectoryImpl| will own a temporary directory.
   std::unique_ptr<base::ScopedTempDir> temp_dir(new base::ScopedTempDir);
   CHECK(temp_dir->CreateUniqueTempDir());
@@ -41,14 +42,15 @@ void FileSystemImpl::OpenTempDirectory(mojom::DirectoryRequest directory,
   base::FilePath path = temp_dir->GetPath();
   scoped_refptr<SharedTempDir> shared_temp_dir =
       new SharedTempDir(std::move(temp_dir));
-  mojo::MakeStrongBinding(std::make_unique<DirectoryImpl>(
-                              path, std::move(shared_temp_dir), lock_table_),
-                          std::move(directory));
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<DirectoryImpl>(path, std::move(shared_temp_dir),
+                                      lock_table_),
+      std::move(receiver));
   std::move(callback).Run(base::File::Error::FILE_OK);
 }
 
 void FileSystemImpl::OpenPersistentFileSystem(
-    mojo::InterfaceRequest<mojom::Directory> directory,
+    mojo::PendingReceiver<mojom::Directory> receiver,
     OpenPersistentFileSystemCallback callback) {
   std::unique_ptr<base::ScopedTempDir> temp_dir;
   base::FilePath path = persistent_dir_;
@@ -58,9 +60,10 @@ void FileSystemImpl::OpenPersistentFileSystem(
   scoped_refptr<SharedTempDir> shared_temp_dir =
       new SharedTempDir(std::move(temp_dir));
 
-  mojo::MakeStrongBinding(std::make_unique<DirectoryImpl>(
-                              path, std::move(shared_temp_dir), lock_table_),
-                          std::move(directory));
+  mojo::MakeSelfOwnedReceiver(
+      std::make_unique<DirectoryImpl>(path, std::move(shared_temp_dir),
+                                      lock_table_),
+      std::move(receiver));
   std::move(callback).Run(base::File::Error::FILE_OK);
 }
 

components/services/filesystem/file_system_impl.h

@@ -27,17 +27,17 @@ class LockTable;
 class FileSystemImpl : public mojom::FileSystem {
  public:
   // |persistent_dir| is the directory served to callers of
-  // |OpenPersistentFileSystem().
+  // |OpenPersistentFileSystem()|.
   FileSystemImpl(const service_manager::Identity& remote_identity,
                  base::FilePath persistent_dir,
                  scoped_refptr<LockTable> lock_table);
   ~FileSystemImpl() override;
 
-  // |Files| implementation:
-  void OpenTempDirectory(mojom::DirectoryRequest directory,
+  // mojom::FileSystem:
+  void OpenTempDirectory(mojo::PendingReceiver<mojom::Directory> receiver,
                          OpenTempDirectoryCallback callback) override;
   void OpenPersistentFileSystem(
-      mojom::DirectoryRequest directory,
+      mojo::PendingReceiver<mojom::Directory> receiver,
       OpenPersistentFileSystemCallback callback) override;
 
  private:

components/services/filesystem/files_test_base.cc

@@ -26,15 +26,17 @@ FilesTestBase::FilesTestBase()
       test_service_(
           test_service_manager_.RegisterTestInstance(kTestServiceName)) {}
 
-FilesTestBase::~FilesTestBase() {}
+FilesTestBase::~FilesTestBase() = default;
 
 void FilesTestBase::SetUp() {
-  connector()->BindInterface("filesystem", &files_);
+  connector()->Connect("filesystem", files_.BindNewPipeAndPassReceiver());
 }
 
-void FilesTestBase::GetTemporaryRoot(mojom::DirectoryPtr* directory) {
+void FilesTestBase::GetTemporaryRoot(
+    mojo::Remote<mojom::Directory>* directory) {
   base::File::Error error = base::File::Error::FILE_ERROR_FAILED;
-  bool handled = files()->OpenTempDirectory(MakeRequest(directory), &error);
+  bool handled = files()->OpenTempDirectory(
+      directory->BindNewPipeAndPassReceiver(), &error);
   ASSERT_TRUE(handled);
   ASSERT_EQ(base::File::Error::FILE_OK, error);
 }

components/services/filesystem/files_test_base.h

@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "base/test/scoped_task_environment.h"
 #include "components/services/filesystem/public/interfaces/file_system.mojom.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/service_manager/public/cpp/test/test_service.h"
 #include "services/service_manager/public/cpp/test/test_service_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -27,18 +27,18 @@ class FilesTestBase : public testing::Test {
   void SetUp() override;
 
  protected:
-  // Note: This has an out parameter rather than returning the |DirectoryPtr|,
+  // Note: This has an out parameter rather than returning the Directory remote,
   // since |ASSERT_...()| doesn't work with return values.
-  void GetTemporaryRoot(mojom::DirectoryPtr* directory);
+  void GetTemporaryRoot(mojo::Remote<mojom::Directory>* directory);
 
   service_manager::Connector* connector() { return test_service_.connector(); }
-  mojom::FileSystemPtr& files() { return files_; }
+  mojo::Remote<mojom::FileSystem>& files() { return files_; }
 
  private:
   base::test::ScopedTaskEnvironment task_environment_;
   service_manager::TestServiceManager test_service_manager_;
   service_manager::TestService test_service_;
-  mojom::FileSystemPtr files_;
+  mojo::Remote<mojom::FileSystem> files_;
 
   DISALLOW_COPY_AND_ASSIGN(FilesTestBase);
 };

components/services/filesystem/public/interfaces/directory.mojom

@@ -42,7 +42,7 @@ interface Directory {
   // optional, mainly for consistency with |OpenDirectory()| (but may be useful,
   // together with |kOpenFlagCreate|, for "touching" a file).
   [Sync]
-  OpenFile(string path, File&? file, uint32 open_flags)
+  OpenFile(string path, pending_receiver<File>? file, uint32 open_flags)
       => (mojo_base.mojom.FileError error);
 
   // Opens the file specified by |path| with the given |open_flags|. Returns a
@@ -61,7 +61,7 @@ interface Directory {
   // this may be used as a simple "mkdir()" with |kOpenFlagCreate|.
   [Sync]
   OpenDirectory(string path,
-                Directory&? directory,
+                pending_receiver<Directory>? directory,
                 uint32 open_flags) => (mojo_base.mojom.FileError error);
 
   // Renames/moves the file/directory given by |path| to |new_path|.
@@ -102,7 +102,7 @@ interface Directory {
       => (mojo_base.mojom.FileError error, FileInformation? file_information);
 
   // Creates a copy of this directory.
-  Clone(Directory& directory);
+  Clone(pending_receiver<Directory> directory);
 
   // Reads the contents of an entire file.
   [Sync]

components/services/filesystem/public/interfaces/file.mojom

@@ -71,7 +71,7 @@ interface File {
   // I.e., the access mode, etc. (as specified to |Directory::OpenFile()| by the
   // |open_flags| argument) as well as file position.
   [Sync]
-  Dup(File& file) => (mojo_base.mojom.FileError error);
+  Dup(pending_receiver<File> file) => (mojo_base.mojom.FileError error);
 
   // Syncs data to disk.
   [Sync]

components/services/filesystem/public/interfaces/file_system.mojom

@@ -11,11 +11,11 @@ interface FileSystem {
   // Opens a temporary filesystem. Will return a different directory each time
   // it is called.
   [Sync]
-  OpenTempDirectory(Directory& directory)
+  OpenTempDirectory(pending_receiver<Directory> directory)
       => (mojo_base.mojom.FileError error);
 
   // Returns a directory which will persist to disk.
   [Sync]
-  OpenPersistentFileSystem(Directory& directory)
+  OpenPersistentFileSystem(pending_receiver<Directory> directory)
       => (mojo_base.mojom.FileError error);
 };

components/services/leveldb/leveldb_mojo_proxy.cc

@@ -258,7 +258,7 @@ void LevelDBMojoProxy::CreateDirImpl(OpaqueDir* dir,
                                      base::File::Error* out_error) {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   bool completed = dir->directory->OpenDirectory(
-      name, nullptr,
+      name, mojo::NullReceiver(),
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite |
           filesystem::mojom::kFlagCreate,
       out_error);

components/services/unzip/unzipper_impl.cc

@@ -47,7 +47,7 @@ bool CreateDirectory(filesystem::mojom::DirectoryPtr* output_dir,
                      const base::FilePath& path) {
   base::File::Error err = base::File::Error::FILE_OK;
   return (*output_dir)
-             ->OpenDirectory(PathToMojoString(path), nullptr,
+             ->OpenDirectory(PathToMojoString(path), mojo::NullReceiver(),
                              filesystem::mojom::kFlagOpenAlways, &err) &&
          err == base::File::Error::FILE_OK;
 }

content/browser/dom_storage/local_storage_context_mojo_unittest.cc

@@ -1036,8 +1036,7 @@ TEST_F(LocalStorageContextMojoTestWithService, CorruptionOnDisk) {
 
 TEST_F(LocalStorageContextMojoTestWithService, RecreateOnCommitFailure) {
   FakeLevelDBService mock_leveldb_service;
-  file_service()->GetBinderRegistryForTesting()->AddInterface(
-      leveldb::mojom::LevelDBService::Name_,
+  file_service()->GetBinderMapForTesting().Add(
       base::BindRepeating(&test::FakeLevelDBService::Bind,
                           base::Unretained(&mock_leveldb_service)));
 
@@ -1185,8 +1184,7 @@ TEST_F(LocalStorageContextMojoTestWithService, RecreateOnCommitFailure) {
 TEST_F(LocalStorageContextMojoTestWithService,
        DontRecreateOnRepeatedCommitFailure) {
   FakeLevelDBService mock_leveldb_service;
-  file_service()->GetBinderRegistryForTesting()->AddInterface(
-      leveldb::mojom::LevelDBService::Name_,
+  file_service()->GetBinderMapForTesting().Add(
       base::BindRepeating(&test::FakeLevelDBService::Bind,
                           base::Unretained(&mock_leveldb_service)));
 

content/browser/dom_storage/session_storage_context_mojo_unittest.cc

@@ -632,8 +632,7 @@ TEST_F(SessionStorageContextMojoTest, RecreateOnCommitFailure) {
   url::Origin origin3 = url::Origin::Create(GURL("http://example.com"));
 
   test::FakeLevelDBService fake_leveldb_service;
-  file_service()->GetBinderRegistryForTesting()->AddInterface(
-      leveldb::mojom::LevelDBService::Name_,
+  file_service()->GetBinderMapForTesting().Add(
       base::BindRepeating(&test::FakeLevelDBService::Bind,
                           base::Unretained(&fake_leveldb_service)));
 
@@ -768,8 +767,7 @@ TEST_F(SessionStorageContextMojoTest, DontRecreateOnRepeatedCommitFailure) {
   url::Origin origin1 = url::Origin::Create(GURL("http://foobar.com"));
 
   test::FakeLevelDBService fake_leveldb_service;
-  file_service()->GetBinderRegistryForTesting()->AddInterface(
-      leveldb::mojom::LevelDBService::Name_,
+  file_service()->GetBinderMapForTesting().Add(
       base::BindRepeating(&test::FakeLevelDBService::Bind,
                           base::Unretained(&fake_leveldb_service)));
 

content/browser/dom_storage/test/fake_leveldb_service.cc

@@ -72,11 +72,9 @@ void FakeLevelDBService::Destroy(filesystem::mojom::DirectoryPtr,
 }
 
 void FakeLevelDBService::Bind(
-    const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle interface_pipe,
-    const service_manager::BindSourceInfo& source_info) {
-  bindings_.AddBinding(
-      this, leveldb::mojom::LevelDBServiceRequest(std::move(interface_pipe)));
+    const service_manager::Identity& remote_identity,
+    mojo::PendingReceiver<leveldb::mojom::LevelDBService> receiver) {
+  bindings_.AddBinding(this, std::move(receiver));
 }
 
 void FakeLevelDBService::FlushBindingsForTesting() {

content/browser/dom_storage/test/fake_leveldb_service.h

@@ -82,9 +82,8 @@ class FakeLevelDBService : public leveldb::mojom::LevelDBService {
     on_open_callback_ = std::move(on_open_callback);
   }
 
-  void Bind(const std::string& interface_name,
-            mojo::ScopedMessagePipeHandle interface_pipe,
-            const service_manager::BindSourceInfo& source_info);
+  void Bind(const service_manager::Identity& remote_identity,
+            mojo::PendingReceiver<leveldb::mojom::LevelDBService> receiver);
 
   void FlushBindingsForTesting();
 

mojo/public/cpp/bindings/BUILD.gn

@@ -176,6 +176,7 @@ component("bindings") {
     "receiver.h",
     "receiver_set.h",
     "remote.h",
+    "self_owned_receiver.h",
     "sequence_local_sync_event_watcher.h",
     "shared_associated_remote.h",
     "shared_remote.h",

mojo/public/cpp/bindings/self_owned_receiver.h

+// Copyright 2019 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.
+
+#ifndef MOJO_PUBLIC_CPP_BINDINGS_SELF_OWNED_RECEIVER_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_SELF_OWNED_RECEIVER_H_
+
+#include <memory>
+#include <utility>
+
+#include "base/memory/scoped_refptr.h"
+#include "base/sequenced_task_runner.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/system/core.h"
+
+namespace mojo {
+
+template <typename Interface>
+using SelfOwnedReceiverRef = StrongBindingPtr<Interface>;
+
+template <typename Interface, typename Impl>
+SelfOwnedReceiverRef<Interface> MakeSelfOwnedReceiver(
+    std::unique_ptr<Impl> impl,
+    PendingReceiver<Interface> receiver,
+    scoped_refptr<base::SequencedTaskRunner> task_runner = nullptr) {
+  return StrongBinding<Interface>::Create(std::move(impl), std::move(receiver),
+                                          std::move(task_runner));
+}
+
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_SELF_OWNED_RECEIVER_H_

mojo/public/cpp/bindings/strong_binding.h

@@ -19,7 +19,7 @@
 #include "mojo/public/cpp/bindings/filter_chain.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
-#include "mojo/public/cpp/bindings/message_header_validator.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {

services/file/BUILD.gn

@@ -20,7 +20,7 @@ source_set("lib") {
     "//components/services/filesystem/public/interfaces",
     "//components/services/leveldb:lib",
     "//components/services/leveldb/public/interfaces",
-    "//mojo/public/cpp/system",
+    "//mojo/public/cpp/bindings",
     "//services/file/public/mojom",
     "//services/service_manager/public/cpp",
     "//services/service_manager/public/mojom",

services/file/file_service.cc

@@ -4,12 +4,15 @@
 
 #include "services/file/file_service.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/post_task.h"
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/leveldb/leveldb_service_impl.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/unique_receiver_set.h"
 #include "services/file/file_system.h"
 #include "services/file/user_id_map.h"
 
@@ -22,21 +25,23 @@ class FileService::FileSystemObjects
   FileSystemObjects(base::FilePath user_dir) : user_dir_(user_dir) {}
 
   // Destroyed on the |file_service_runner_|.
-  ~FileSystemObjects() {}
+  ~FileSystemObjects() = default;
 
   // Called on the |file_service_runner_|.
-  void OnFileSystemRequest(const service_manager::Identity& remote_identity,
-                           mojom::FileSystemRequest request) {
+  void BindFileSystemReceiver(
+      const service_manager::Identity& remote_identity,
+      mojo::PendingReceiver<mojom::FileSystem> receiver) {
     if (!lock_table_)
       lock_table_ = new filesystem::LockTable;
-    mojo::MakeStrongBinding(
+    file_system_receivers_.Add(
         std::make_unique<FileSystem>(user_dir_, lock_table_),
-        std::move(request));
+        std::move(receiver));
   }
 
  private:
   scoped_refptr<filesystem::LockTable> lock_table_;
   base::FilePath user_dir_;
+  mojo::UniqueReceiverSet<mojom::FileSystem> file_system_receivers_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemObjects);
 };
@@ -50,15 +55,17 @@ class FileService::LevelDBServiceObjects
       : file_task_runner_(std::move(file_task_runner)) {}
 
   // Destroyed on the |leveldb_service_runner_|.
-  ~LevelDBServiceObjects() {}
+  ~LevelDBServiceObjects() = default;
 
   // Called on the |leveldb_service_runner_|.
-  void OnLevelDBServiceRequest(const service_manager::Identity& remote_identity,
-                               leveldb::mojom::LevelDBServiceRequest request) {
-    if (!leveldb_service_)
-      leveldb_service_.reset(
-          new leveldb::LevelDBServiceImpl(file_task_runner_));
-    leveldb_bindings_.AddBinding(leveldb_service_.get(), std::move(request));
+  void BindLevelDBServiceReceiver(
+      const service_manager::Identity& remote_identity,
+      mojo::PendingReceiver<leveldb::mojom::LevelDBService> receiver) {
+    if (!leveldb_service_) {
+      leveldb_service_ =
+          std::make_unique<leveldb::LevelDBServiceImpl>(file_task_runner_);
+    }
+    leveldb_receivers_.Add(leveldb_service_.get(), std::move(receiver));
   }
 
  private:
@@ -66,21 +73,22 @@ class FileService::LevelDBServiceObjects
 
   // Variables that are only accessible on the |leveldb_service_runner_| thread.
   std::unique_ptr<leveldb::mojom::LevelDBService> leveldb_service_;
-  mojo::BindingSet<leveldb::mojom::LevelDBService> leveldb_bindings_;
+  mojo::ReceiverSet<leveldb::mojom::LevelDBService> leveldb_receivers_;
 
   DISALLOW_COPY_AND_ASSIGN(LevelDBServiceObjects);
 };
 
-FileService::FileService(service_manager::mojom::ServiceRequest request)
-    : service_binding_(this, std::move(request)),
+FileService::FileService(
+    mojo::PendingReceiver<service_manager::mojom::Service> receiver)
+    : service_binding_(this, std::move(receiver)),
       file_service_runner_(base::CreateSequencedTaskRunnerWithTraits(
           {base::MayBlock(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
       leveldb_service_runner_(base::CreateSequencedTaskRunnerWithTraits(
           {base::MayBlock(), base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {
-  registry_.AddInterface<leveldb::mojom::LevelDBService>(base::BindRepeating(
-      &FileService::BindLevelDBServiceRequest, base::Unretained(this)));
-  registry_.AddInterface<mojom::FileSystem>(base::BindRepeating(
-      &FileService::BindFileSystemRequest, base::Unretained(this)));
+  binders_.Add<leveldb::mojom::LevelDBService>(base::BindRepeating(
+      &FileService::BindLevelDBServiceReceiver, base::Unretained(this)));
+  binders_.Add<mojom::FileSystem>(base::BindRepeating(
+      &FileService::BindFileSystemReceiver, base::Unretained(this)));
 }
 
 FileService::~FileService() {
@@ -89,40 +97,36 @@ FileService::~FileService() {
 }
 
 void FileService::OnStart() {
-  file_system_objects_.reset(
-      new FileService::FileSystemObjects(GetUserDirForInstanceGroup(
-          service_binding_.identity().instance_group())));
-  leveldb_objects_.reset(
-      new FileService::LevelDBServiceObjects(file_service_runner_));
+  file_system_objects_ = std::make_unique<FileService::FileSystemObjects>(
+      GetUserDirForInstanceGroup(service_binding_.identity().instance_group()));
+  leveldb_objects_ = std::make_unique<FileService::LevelDBServiceObjects>(
+      file_service_runner_);
 }
 
-void FileService::OnBindInterface(
-    const service_manager::BindSourceInfo& source_info,
-    const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle interface_pipe) {
-  registry_.BindInterface(interface_name, std::move(interface_pipe),
-                          source_info);
+void FileService::OnConnect(const service_manager::ConnectSourceInfo& source,
+                            const std::string& interface_name,
+                            mojo::ScopedMessagePipeHandle receiver_pipe) {
+  binders_.TryBind(source.identity, interface_name, &receiver_pipe);
 }
 
-void FileService::BindFileSystemRequest(
-    mojom::FileSystemRequest request,
-    const service_manager::BindSourceInfo& source_info) {
+void FileService::BindFileSystemReceiver(
+    const service_manager::Identity& remote_identity,
+    mojo::PendingReceiver<mojom::FileSystem> receiver) {
   file_service_runner_->PostTask(
       FROM_HERE,
-      base::BindOnce(&FileService::FileSystemObjects::OnFileSystemRequest,
-                     file_system_objects_->AsWeakPtr(), source_info.identity,
-                     std::move(request)));
+      base::BindOnce(&FileService::FileSystemObjects::BindFileSystemReceiver,
+                     file_system_objects_->AsWeakPtr(), remote_identity,
+                     std::move(receiver)));
 }
 
-void FileService::BindLevelDBServiceRequest(
-    leveldb::mojom::LevelDBServiceRequest request,
-    const service_manager::BindSourceInfo& source_info) {
+void FileService::BindLevelDBServiceReceiver(
+    const service_manager::Identity& remote_identity,
+    mojo::PendingReceiver<leveldb::mojom::LevelDBService> receiver) {
   leveldb_service_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &FileService::LevelDBServiceObjects::OnLevelDBServiceRequest,
-          leveldb_objects_->AsWeakPtr(), source_info.identity,
-          std::move(request)));
+          &FileService::LevelDBServiceObjects::BindLevelDBServiceReceiver,
+          leveldb_objects_->AsWeakPtr(), remote_identity, std::move(receiver)));
 }
 
 }  // namespace user_service

services/file/file_service.h

@@ -10,9 +10,10 @@
 #include "base/sequenced_task_runner.h"
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/leveldb/public/interfaces/leveldb.mojom.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "services/file/public/mojom/file_system.mojom.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
+#include "services/service_manager/public/cpp/binder_map.h"
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/cpp/service_binding.h"
 #include "services/service_manager/public/mojom/service.mojom.h"
@@ -21,31 +22,28 @@ namespace file {
 
 class FileService : public service_manager::Service {
  public:
-  explicit FileService(service_manager::mojom::ServiceRequest request);
+  explicit FileService(
+      mojo::PendingReceiver<service_manager::mojom::Service> receiver);
   ~FileService() override;
 
-  service_manager::BinderRegistryWithArgs<
-      const service_manager::BindSourceInfo&>*
-  GetBinderRegistryForTesting() {
-    return &registry_;
+  service_manager::BinderMapWithContext<const service_manager::Identity&>&
+  GetBinderMapForTesting() {
+    return binders_;
   }
 
  private:
   // service_manager::Service:
   void OnStart() override;
-  void OnBindInterface(const service_manager::BindSourceInfo& source_info,
-                       const std::string& interface_name,
-                       mojo::ScopedMessagePipeHandle interface_pipe) override;
+  void OnConnect(const service_manager::ConnectSourceInfo& source,
+                 const std::string& interface_name,
+                 mojo::ScopedMessagePipeHandle receiver_pipe) override;
 
-  void BindFileSystemRequest(
-      mojom::FileSystemRequest request,
-      const service_manager::BindSourceInfo& source_info);
-
-  void BindLevelDBServiceRequest(
-      leveldb::mojom::LevelDBServiceRequest request,
-      const service_manager::BindSourceInfo& source_info);
-
-  void OnLevelDBServiceError();
+  void BindFileSystemReceiver(
+      const service_manager::Identity& remote_identity,
+      mojo::PendingReceiver<mojom::FileSystem> receiver);
+  void BindLevelDBServiceReceiver(
+      const service_manager::Identity& remote_identity,
+      mojo::PendingReceiver<leveldb::mojom::LevelDBService> receiver);
 
   service_manager::ServiceBinding service_binding_;
 
@@ -60,9 +58,8 @@ class FileService : public service_manager::Service {
   class LevelDBServiceObjects;
   std::unique_ptr<LevelDBServiceObjects> leveldb_objects_;
 
-  service_manager::BinderRegistryWithArgs<
-      const service_manager::BindSourceInfo&>
-      registry_;
+  service_manager::BinderMapWithContext<const service_manager::Identity&>
+      binders_;
 
   DISALLOW_COPY_AND_ASSIGN(FileService);
 };

services/file/file_system.cc

@@ -16,7 +16,7 @@
 #include "components/services/filesystem/directory_impl.h"
 #include "components/services/filesystem/lock_table.h"
 #include "components/services/filesystem/public/interfaces/types.mojom.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 
 namespace file {
 
@@ -26,20 +26,22 @@ FileSystem::FileSystem(const base::FilePath& base_user_dir,
   base::CreateDirectory(path_);
 }
 
-FileSystem::~FileSystem() {}
+FileSystem::~FileSystem() = default;
 
-void FileSystem::GetDirectory(filesystem::mojom::DirectoryRequest request,
-                              GetDirectoryCallback callback) {
-  mojo::MakeStrongBinding(
+void FileSystem::GetDirectory(
+    mojo::PendingReceiver<filesystem::mojom::Directory> receiver,
+    GetDirectoryCallback callback) {
+  mojo::MakeSelfOwnedReceiver(
       std::make_unique<filesystem::DirectoryImpl>(
           path_, scoped_refptr<filesystem::SharedTempDir>(), lock_table_),
-      std::move(request));
+      std::move(receiver));
   std::move(callback).Run();
 }
 
-void FileSystem::GetSubDirectory(const std::string& sub_directory_path,
-                                 filesystem::mojom::DirectoryRequest request,
-                                 GetSubDirectoryCallback callback) {
+void FileSystem::GetSubDirectory(
+    const std::string& sub_directory_path,
+    mojo::PendingReceiver<filesystem::mojom::Directory> receiver,
+    GetSubDirectoryCallback callback) {
   // Ensure that we've made |subdirectory| recursively under our user dir.
   base::FilePath subdir = path_.Append(
 #if defined(OS_WIN)
@@ -53,10 +55,10 @@ void FileSystem::GetSubDirectory(const std::string& sub_directory_path,
     return;
   }
 
-  mojo::MakeStrongBinding(
+  mojo::MakeSelfOwnedReceiver(
       std::make_unique<filesystem::DirectoryImpl>(
           subdir, scoped_refptr<filesystem::SharedTempDir>(), lock_table_),
-      std::move(request));
+      std::move(receiver));
   std::move(callback).Run(base::File::Error::FILE_OK);
 }
 

services/file/file_system.h

@@ -23,11 +23,13 @@ class FileSystem : public mojom::FileSystem {
   ~FileSystem() override;
 
   // Overridden from mojom::FileSystem:
-  void GetDirectory(filesystem::mojom::DirectoryRequest request,
-                    GetDirectoryCallback callback) override;
-  void GetSubDirectory(const std::string& sub_directory_path,
-                       filesystem::mojom::DirectoryRequest request,
-                       GetSubDirectoryCallback callback) override;
+  void GetDirectory(
+      mojo::PendingReceiver<filesystem::mojom::Directory> receiver,
+      GetDirectoryCallback callback) override;
+  void GetSubDirectory(
+      const std::string& sub_directory_path,
+      mojo::PendingReceiver<filesystem::mojom::Directory> receiver,
+      GetSubDirectoryCallback callback) override;
 
  private:
   scoped_refptr<filesystem::LockTable> lock_table_;

services/file/public/mojom/file_system.mojom

@@ -10,10 +10,11 @@ import "mojo/public/mojom/base/file_error.mojom";
 // Provide access to various directories within the requesting user's directory.
 interface FileSystem {
   // Returns the user's directory.
-  GetDirectory(filesystem.mojom.Directory& dir) => ();
+  GetDirectory(pending_receiver<filesystem.mojom.Directory> dir) => ();
 
   // Returns a subdirectory under the user's dir. Returns a filesystem error
   // when we fail to create the subdirectory.
-  GetSubDirectory(string dir_path, filesystem.mojom.Directory& dir)
+  GetSubDirectory(string dir_path,
+                  pending_receiver<filesystem.mojom.Directory> dir)
       => (mojo_base.mojom.FileError err);
 };