Enable mojo localstorage to actually store on disk.

components/leveldb/leveldb_mojo_proxy.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/leveldb/leveldb_mojo_proxy.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 
 namespace leveldb {
 
 struct LevelDBMojoProxy::OpaqueLock {
   filesystem::mojom::FilePtr lock_file;
 };
 
 struct LevelDBMojoProxy::OpaqueDir {
   explicit OpaqueDir(
       mojo::InterfacePtrInfo<filesystem::mojom::Directory> directory_info) {
@@ skipping 154 matching lines @@
     OpaqueDir* dir) {
   // Only delete the directories on the thread that owns them.
   delete dir;
   outstanding_opaque_dirs_--;
 }
 
 void LevelDBMojoProxy::OpenFileHandleImpl(OpaqueDir* dir,
                                           std::string name,
                                           uint32_t open_flags,
                                           base::File* output_file) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   base::File file;
   filesystem::mojom::FileError error = filesystem::mojom::FileError::FAILED;
   bool completed =
       dir->directory->OpenFileHandle(name, open_flags, &error, &file);
   DCHECK(completed);
 
   if (error != filesystem::mojom::FileError::OK) {
     *output_file = base::File(static_cast<base::File::Error>(error));
   } else {
     *output_file = std::move(file);
   }
 }
 
 void LevelDBMojoProxy::SyncDirectoryImpl(
     OpaqueDir* dir,
     std::string name,
     filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   filesystem::mojom::DirectoryPtr target;
   bool completed = dir->directory->OpenDirectory(
       name, MakeRequest(&target),
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite, out_error);
   DCHECK(completed);
 
   if (*out_error != filesystem::mojom::FileError::OK)
     return;
 
   completed = target->Flush(out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::FileExistsImpl(OpaqueDir* dir,
                                       std::string name,
                                       bool* exists) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   filesystem::mojom::FileError error = filesystem::mojom::FileError::FAILED;
   bool completed = dir->directory->Exists(name, &error, exists);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::GetChildrenImpl(
     OpaqueDir* dir,
     std::string name,
     std::vector<std::string>* out_contents,
     filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   filesystem::mojom::DirectoryPtr target;
   filesystem::mojom::DirectoryRequest proxy(&target);
   bool completed = dir->directory->OpenDirectory(
       name, std::move(proxy),
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite, out_error);
   DCHECK(completed);
 
   if (*out_error != filesystem::mojom::FileError::OK)
     return;
 
   base::Optional<std::vector<filesystem::mojom::DirectoryEntryPtr>>
       directory_contents;
   completed = target->Read(out_error, &directory_contents);
   DCHECK(completed);
 
   if (directory_contents.has_value()) {
     for (size_t i = 0; i < directory_contents->size(); ++i)
       out_contents->push_back(directory_contents.value()[i]->name);
   }
 }
 
 void LevelDBMojoProxy::DeleteImpl(OpaqueDir* dir,
                                   std::string name,
                                   uint32_t delete_flags,
                                   filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   bool completed = dir->directory->Delete(name, delete_flags, out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::CreateDirImpl(OpaqueDir* dir,
                                      std::string name,
                                      filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   bool completed = dir->directory->OpenDirectory(
       name, nullptr,
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite |
           filesystem::mojom::kFlagCreate,
       out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::GetFileSizeImpl(
     OpaqueDir* dir,
     const std::string& path,
     uint64_t* file_size,
     filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   filesystem::mojom::FileInformationPtr info;
   bool completed = dir->directory->StatFile(path, out_error, &info);
   DCHECK(completed);
   if (info)
     *file_size = info->size;
 }
 
 void LevelDBMojoProxy::RenameFileImpl(OpaqueDir* dir,
                                       const std::string& old_path,
                                       const std::string& new_path,
                                       filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   bool completed = dir->directory->Rename(old_path, new_path, out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::LockFileImpl(OpaqueDir* dir,
                                     const std::string& path,
                                     filesystem::mojom::FileError* out_error,
                                     OpaqueLock** out_lock) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   // Since a lock is associated with a file descriptor, we need to open and
   // have a persistent file on the other side of the connection.
   filesystem::mojom::FilePtr target;
   filesystem::mojom::FileRequest proxy(&target);
   bool completed = dir->directory->OpenFile(path, std::move(proxy),
                                             filesystem::mojom::kFlagOpenAlways |
                                                 filesystem::mojom::kFlagRead |
                                                 filesystem::mojom::kFlagWrite,
                                             out_error);
   DCHECK(completed);
 
   if (*out_error != filesystem::mojom::FileError::OK)
     return;
 
   completed = target->Lock(out_error);
   DCHECK(completed);
 
   if (*out_error == filesystem::mojom::FileError::OK) {
     OpaqueLock* l = new OpaqueLock;
     l->lock_file = std::move(target);
     *out_lock = l;
   }
 }
 
 void LevelDBMojoProxy::UnlockFileImpl(std::unique_ptr<OpaqueLock> lock,
                                       filesystem::mojom::FileError* out_error) {
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync;
   lock->lock_file->Unlock(out_error);
 }
 
 }  // namespace leveldb