| // Copyright 2013 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 "content/child/fileapi/webfilesystem_impl.h" |
| |
| #include "base/bind.h" |
| #include "base/id_map.h" |
| #include "base/lazy_instance.h" |
| #include "base/logging.h" |
| #include "base/message_loop/message_loop_proxy.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/threading/thread_local.h" |
| #include "content/child/child_thread.h" |
| #include "content/child/fileapi/file_system_dispatcher.h" |
| #include "content/child/fileapi/webfilesystem_callback_adapters.h" |
| #include "content/child/fileapi/webfilewriter_impl.h" |
| #include "content/common/fileapi/file_system_messages.h" |
| #include "third_party/WebKit/public/platform/WebFileInfo.h" |
| #include "third_party/WebKit/public/platform/WebString.h" |
| #include "third_party/WebKit/public/platform/WebURL.h" |
| #include "third_party/WebKit/public/web/WebFileSystemCallbacks.h" |
| #include "url/gurl.h" |
| #include "webkit/child/worker_task_runner.h" |
| #include "webkit/common/fileapi/directory_entry.h" |
| #include "webkit/common/fileapi/file_system_util.h" |
| #include "webkit/glue/webkit_glue.h" |
| |
| using WebKit::WebFileInfo; |
| using WebKit::WebFileSystemCallbacks; |
| using WebKit::WebFileSystemEntry; |
| using WebKit::WebString; |
| using WebKit::WebURL; |
| using WebKit::WebVector; |
| using webkit_glue::WorkerTaskRunner; |
| |
| namespace content { |
| |
| namespace { |
| |
| class CallbacksMap; |
| |
| base::LazyInstance<base::ThreadLocalPointer<CallbacksMap> >::Leaky |
| g_callbacks_map_tls = LAZY_INSTANCE_INITIALIZER; |
| |
| // TODO(kinuko): Integrate this into WebFileSystemImpl when blink side |
| // becomes ready to make WebFileSystemImpl thread-local. |
| class CallbacksMap : public WorkerTaskRunner::Observer { |
| public: |
| static CallbacksMap* Get() { |
| return g_callbacks_map_tls.Pointer()->Get(); |
| } |
| |
| static CallbacksMap* GetOrCreate() { |
| if (g_callbacks_map_tls.Pointer()->Get()) |
| return g_callbacks_map_tls.Pointer()->Get(); |
| CallbacksMap* map = new CallbacksMap; |
| if (WorkerTaskRunner::Instance()->CurrentWorkerId()) |
| WorkerTaskRunner::Instance()->AddStopObserver(map); |
| return map; |
| } |
| |
| virtual ~CallbacksMap() { |
| IDMap<WebFileSystemCallbacks>::iterator iter(&callbacks_); |
| while (!iter.IsAtEnd()) { |
| iter.GetCurrentValue()->didFail(WebKit::WebFileErrorAbort); |
| iter.Advance(); |
| } |
| g_callbacks_map_tls.Pointer()->Set(NULL); |
| } |
| |
| // webkit_glue::WorkerTaskRunner::Observer implementation. |
| virtual void OnWorkerRunLoopStopped() OVERRIDE { |
| delete this; |
| } |
| |
| int RegisterCallbacks(WebFileSystemCallbacks* callbacks) { |
| return callbacks_.Add(callbacks); |
| } |
| |
| WebFileSystemCallbacks* GetAndUnregisterCallbacks( |
| int callbacks_id) { |
| WebFileSystemCallbacks* callbacks = callbacks_.Lookup(callbacks_id); |
| callbacks_.Remove(callbacks_id); |
| return callbacks; |
| } |
| |
| private: |
| CallbacksMap() { |
| g_callbacks_map_tls.Pointer()->Set(this); |
| } |
| |
| IDMap<WebFileSystemCallbacks> callbacks_; |
| |
| DISALLOW_COPY_AND_ASSIGN(CallbacksMap); |
| }; |
| |
| class WaitableCallbackResults { |
| public: |
| static WaitableCallbackResults* MaybeCreate( |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| if (callbacks->shouldBlockUntilCompletion()) |
| return new WaitableCallbackResults; |
| return NULL; |
| } |
| ~WaitableCallbackResults() {} |
| |
| void SetResultsAndSignal(const base::Closure& results_closure) { |
| results_closure_ = results_closure; |
| event_->Signal(); |
| } |
| |
| void WaitAndRun() { |
| event_->Wait(); |
| DCHECK(!results_closure_.is_null()); |
| results_closure_.Run(); |
| } |
| |
| private: |
| WaitableCallbackResults() : event_(new base::WaitableEvent(true, false)) {} |
| |
| base::WaitableEvent* event_; |
| base::Closure results_closure_; |
| DISALLOW_COPY_AND_ASSIGN(WaitableCallbackResults); |
| }; |
| |
| void DidReceiveSnapshotFile(int request_id) { |
| if (ChildThread::current()) |
| ChildThread::current()->Send( |
| new FileSystemHostMsg_DidReceiveSnapshotFile(request_id)); |
| } |
| |
| int CurrentWorkerId() { |
| return WorkerTaskRunner::Instance()->CurrentWorkerId(); |
| } |
| |
| template <typename Method, typename Params> |
| void CallDispatcherOnMainThread( |
| base::MessageLoopProxy* loop, |
| Method method, const Params& params, |
| scoped_ptr<WaitableCallbackResults> waitable_results) { |
| scoped_ptr<WaitableCallbackResults> null_waitable; |
| if (!loop->RunsTasksOnCurrentThread()) { |
| loop->PostTask(FROM_HERE, |
| base::Bind(&CallDispatcherOnMainThread<Method, Params>, |
| make_scoped_refptr(loop), method, params, |
| base::Passed(&null_waitable))); |
| if (!waitable_results) |
| return; |
| waitable_results->WaitAndRun(); |
| } |
| if (!ChildThread::current() || |
| !ChildThread::current()->file_system_dispatcher()) |
| return; |
| |
| DCHECK(!waitable_results); |
| DispatchToMethod(ChildThread::current()->file_system_dispatcher(), |
| method, params); |
| } |
| |
| // Run WebFileSystemCallbacks's |method| with |params|. |
| template <typename Method, typename Params> |
| void RunCallbacks(int callbacks_id, Method method, const Params& params) { |
| if (!CallbacksMap::Get()) |
| return; |
| WebFileSystemCallbacks* callbacks = |
| CallbacksMap::Get()->GetAndUnregisterCallbacks(callbacks_id); |
| DCHECK(callbacks); |
| DispatchToMethod(callbacks, method, params); |
| } |
| |
| void DispatchResultsClosure(int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| const base::Closure& results_closure) { |
| if (thread_id != CurrentWorkerId()) { |
| if (waitable_results) { |
| waitable_results->SetResultsAndSignal(results_closure); |
| return; |
| } |
| WorkerTaskRunner::Instance()->PostTask(thread_id, results_closure); |
| return; |
| } |
| results_closure.Run(); |
| } |
| |
| template <typename Method, typename Params> |
| void CallbackFileSystemCallbacks( |
| int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| Method method, const Params& params) { |
| DispatchResultsClosure( |
| thread_id, callbacks_id, waitable_results, |
| base::Bind(&RunCallbacks<Method, Params>, callbacks_id, method, params)); |
| } |
| |
| void StatusCallbackAdapter(int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| base::PlatformFileError error) { |
| if (error == base::PLATFORM_FILE_OK) { |
| CallbackFileSystemCallbacks( |
| thread_id, callbacks_id, waitable_results, |
| &WebFileSystemCallbacks::didSucceed, MakeTuple()); |
| } else { |
| CallbackFileSystemCallbacks( |
| thread_id, callbacks_id, waitable_results, |
| &WebFileSystemCallbacks::didFail, |
| MakeTuple(fileapi::PlatformFileErrorToWebFileError(error))); |
| } |
| } |
| |
| void ReadMetadataCallbackAdapter(int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| const base::PlatformFileInfo& file_info) { |
| WebFileInfo web_file_info; |
| webkit_glue::PlatformFileInfoToWebFileInfo(file_info, &web_file_info); |
| CallbackFileSystemCallbacks( |
| thread_id, callbacks_id, waitable_results, |
| &WebFileSystemCallbacks::didReadMetadata, |
| MakeTuple(web_file_info)); |
| } |
| |
| void ReadDirectoryCallbackAdapater( |
| int thread_id, int callbacks_id, WaitableCallbackResults* waitable_results, |
| const std::vector<fileapi::DirectoryEntry>& entries, |
| bool has_more) { |
| WebVector<WebFileSystemEntry> file_system_entries(entries.size()); |
| for (size_t i = 0; i < entries.size(); i++) { |
| file_system_entries[i].name = |
| base::FilePath(entries[i].name).AsUTF16Unsafe(); |
| file_system_entries[i].isDirectory = entries[i].is_directory; |
| } |
| CallbackFileSystemCallbacks( |
| thread_id, callbacks_id, waitable_results, |
| &WebFileSystemCallbacks::didReadDirectory, |
| MakeTuple(file_system_entries, has_more)); |
| } |
| |
| void DidCreateFileWriter( |
| int callbacks_id, |
| const GURL& path, |
| WebKit::WebFileWriterClient* client, |
| base::MessageLoopProxy* main_thread_loop, |
| const base::PlatformFileInfo& file_info) { |
| if (!CallbacksMap::Get()) |
| return; |
| |
| WebFileSystemCallbacks* callbacks = |
| CallbacksMap::Get()->GetAndUnregisterCallbacks(callbacks_id); |
| DCHECK(callbacks); |
| |
| if (file_info.is_directory || file_info.size < 0) { |
| callbacks->didFail(WebKit::WebFileErrorInvalidState); |
| return; |
| } |
| WebFileWriterImpl::Type type = callbacks->shouldBlockUntilCompletion() ? |
| WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC; |
| callbacks->didCreateFileWriter( |
| new WebFileWriterImpl(path, client, type, main_thread_loop), |
| file_info.size); |
| } |
| |
| void CreateFileWriterCallbackAdapter( |
| int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| base::MessageLoopProxy* main_thread_loop, |
| const GURL& path, |
| WebKit::WebFileWriterClient* client, |
| const base::PlatformFileInfo& file_info) { |
| DispatchResultsClosure( |
| thread_id, callbacks_id, waitable_results, |
| base::Bind(&DidCreateFileWriter, callbacks_id, path, client, |
| make_scoped_refptr(main_thread_loop), file_info)); |
| } |
| |
| void DidCreateSnapshotFile( |
| int callbacks_id, |
| base::MessageLoopProxy* main_thread_loop, |
| const base::PlatformFileInfo& file_info, |
| const base::FilePath& platform_path, |
| int request_id) { |
| if (!CallbacksMap::Get()) |
| return; |
| |
| WebFileSystemCallbacks* callbacks = |
| CallbacksMap::Get()->GetAndUnregisterCallbacks(callbacks_id); |
| DCHECK(callbacks); |
| |
| WebFileInfo web_file_info; |
| webkit_glue::PlatformFileInfoToWebFileInfo(file_info, &web_file_info); |
| web_file_info.platformPath = platform_path.AsUTF16Unsafe(); |
| callbacks->didCreateSnapshotFile(web_file_info); |
| |
| // TODO(michaeln,kinuko): Use ThreadSafeSender when Blob becomes |
| // non-bridge model. |
| main_thread_loop->PostTask( |
| FROM_HERE, base::Bind(&DidReceiveSnapshotFile, request_id)); |
| } |
| |
| void CreateSnapshotFileCallbackAdapter( |
| int thread_id, int callbacks_id, |
| WaitableCallbackResults* waitable_results, |
| base::MessageLoopProxy* main_thread_loop, |
| const base::PlatformFileInfo& file_info, |
| const base::FilePath& platform_path, |
| int request_id) { |
| DispatchResultsClosure( |
| thread_id, callbacks_id, waitable_results, |
| base::Bind(&DidCreateSnapshotFile, callbacks_id, |
| make_scoped_refptr(main_thread_loop), |
| file_info, platform_path, request_id)); |
| } |
| |
| } // namespace |
| |
| WebFileSystemImpl::~WebFileSystemImpl() { |
| } |
| |
| WebFileSystemImpl::WebFileSystemImpl(base::MessageLoopProxy* main_thread_loop) |
| : main_thread_loop_(main_thread_loop) { |
| } |
| |
| void WebFileSystemImpl::move( |
| const WebKit::WebURL& src_path, |
| const WebKit::WebURL& dest_path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Move, |
| MakeTuple(GURL(src_path), GURL(dest_path), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::copy( |
| const WebKit::WebURL& src_path, |
| const WebKit::WebURL& dest_path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Copy, |
| MakeTuple(GURL(src_path), GURL(dest_path), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::remove( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Remove, |
| MakeTuple(GURL(path), false /* recursive */, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::removeRecursively( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Remove, |
| MakeTuple(GURL(path), true /* recursive */, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::readMetadata( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::ReadMetadata, |
| MakeTuple(GURL(path), |
| base::Bind(&ReadMetadataCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results)), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::createFile( |
| const WebKit::WebURL& path, |
| bool exclusive, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::CreateFile, |
| MakeTuple(GURL(path), exclusive, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::createDirectory( |
| const WebKit::WebURL& path, |
| bool exclusive, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::CreateDirectory, |
| MakeTuple(GURL(path), exclusive, false /* recursive */, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::fileExists( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Exists, |
| MakeTuple(GURL(path), false /* directory */, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::directoryExists( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::Exists, |
| MakeTuple(GURL(path), true /* directory */, |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::readDirectory( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::ReadDirectory, |
| MakeTuple(GURL(path), |
| base::Bind(&ReadDirectoryCallbackAdapater, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results)), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| WebKit::WebFileWriter* WebFileSystemImpl::createFileWriter( |
| const WebURL& path, WebKit::WebFileWriterClient* client) { |
| return new WebFileWriterImpl(GURL(path), client, |
| WebFileWriterImpl::TYPE_ASYNC, |
| main_thread_loop_.get()); |
| } |
| |
| void WebFileSystemImpl::createFileWriter( |
| const WebURL& path, |
| WebKit::WebFileWriterClient* client, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::ReadMetadata, |
| MakeTuple(GURL(path), |
| base::Bind(&CreateFileWriterCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results), |
| main_thread_loop_, GURL(path), client), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| void WebFileSystemImpl::createSnapshotFileAndReadMetadata( |
| const WebKit::WebURL& path, |
| WebKit::WebFileSystemCallbacks* callbacks) { |
| int callbacks_id = CallbacksMap::GetOrCreate()->RegisterCallbacks(callbacks); |
| WaitableCallbackResults* waitable_results = |
| WaitableCallbackResults::MaybeCreate(callbacks); |
| CallDispatcherOnMainThread( |
| main_thread_loop_.get(), |
| &FileSystemDispatcher::CreateSnapshotFile, |
| MakeTuple(GURL(path), |
| base::Bind(&CreateSnapshotFileCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results), |
| main_thread_loop_), |
| base::Bind(&StatusCallbackAdapter, |
| CurrentWorkerId(), callbacks_id, |
| base::Unretained(waitable_results))), |
| make_scoped_ptr(waitable_results)); |
| } |
| |
| } // namespace content |
