Make WebFileSystemCallbacks not self-destruct (Chrome-side)

content/child/fileapi/webfilesystem_impl.cc

 // 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/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.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/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/WebFileSystemCallbacks.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 {
 
+// TODO(kinuko): Remove this hack after the two-sided patch lands.
+WebFileSystemCallbacks* Wrapper(WebFileSystemCallbacksType& cb) {
+#ifdef NON_SELFDESTRUCT_WEBFILESYSTEMCALLBACKS
+  return &cb;
+#else
+  return cb;
+#endif
+}
+
 base::LazyInstance<base::ThreadLocalPointer<WebFileSystemImpl> >::Leaky
     g_webfilesystem_tls = LAZY_INSTANCE_INITIALIZER;
 
 class WaitableCallbackResults {
  public:
   static WaitableCallbackResults* MaybeCreate(
-      WebKit::WebFileSystemCallbacks* callbacks) {
-    if (callbacks->shouldBlockUntilCompletion())
+      WebFileSystemCallbacksType callbacks) {
+    if (Wrapper(callbacks)->shouldBlockUntilCompletion())
       return new WaitableCallbackResults;
     return NULL;
   }
   ~WaitableCallbackResults() {}
 
   void SetResultsAndSignal(const base::Closure& results_closure) {
     results_closure_ = results_closure;
     event_->Signal();
   }
 
@@ skipping 45 matching lines @@
                    method, params);
 }
 
 // Run WebFileSystemCallbacks's |method| with |params|.
 template <typename Method, typename Params>
 void RunCallbacks(int callbacks_id, Method method, const Params& params) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
-  WebFileSystemCallbacks* callbacks =
+  WebFileSystemCallbacksType callbacks =
       filesystem->GetAndUnregisterCallbacks(callbacks_id);
-  DCHECK(callbacks);
-  DispatchToMethod(callbacks, method, params);
+  DispatchToMethod(Wrapper(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;
     }
@@ skipping 74 matching lines @@
     int callbacks_id,
     const GURL& path,
     WebKit::WebFileWriterClient* client,
     base::MessageLoopProxy* main_thread_loop,
     const base::PlatformFileInfo& file_info) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
-  WebFileSystemCallbacks* callbacks =
+  WebFileSystemCallbacksType callbacks =
       filesystem->GetAndUnregisterCallbacks(callbacks_id);
-  DCHECK(callbacks);
 
   if (file_info.is_directory || file_info.size < 0) {
-    callbacks->didFail(WebKit::WebFileErrorInvalidState);
+    Wrapper(callbacks)->didFail(WebKit::WebFileErrorInvalidState);
     return;
   }
-  WebFileWriterImpl::Type type = callbacks->shouldBlockUntilCompletion() ?
-      WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC;
-  callbacks->didCreateFileWriter(
+  WebFileWriterImpl::Type type =
+      Wrapper(callbacks)->shouldBlockUntilCompletion() ?
+          WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC;
+  Wrapper(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) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
-  WebFileSystemCallbacks* callbacks =
+  WebFileSystemCallbacksType callbacks =
       filesystem->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);
+  Wrapper(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,
@@ skipping 23 matching lines @@
   return filesystem;
 }
 
 void WebFileSystemImpl::DeleteThreadSpecificInstance() {
   DCHECK(!WorkerTaskRunner::Instance()->CurrentWorkerId());
   if (g_webfilesystem_tls.Pointer()->Get())
     delete g_webfilesystem_tls.Pointer()->Get();
 }
 
 WebFileSystemImpl::WebFileSystemImpl(base::MessageLoopProxy* main_thread_loop)
-    : main_thread_loop_(main_thread_loop) {
+    : main_thread_loop_(main_thread_loop),
+      next_callbacks_id_(0) {
   g_webfilesystem_tls.Pointer()->Set(this);
 }
 
 WebFileSystemImpl::~WebFileSystemImpl() {
-  IDMap<WebFileSystemCallbacks>::iterator iter(&callbacks_);
-  while (!iter.IsAtEnd()) {
-    iter.GetCurrentValue()->didFail(WebKit::WebFileErrorAbort);
-    iter.Advance();
+#if !defined(NON_SELFDESTRUCT_WEBFILESYSTEMCALLBACKS)
+  for (CallbacksMap::iterator iter = callbacks_.begin();
+       iter != callbacks_.end(); ++iter) {
+    iter->second->didFail(WebKit::WebFileErrorAbort);
   }
+#endif
   g_webfilesystem_tls.Pointer()->Set(NULL);
 }
 
 void WebFileSystemImpl::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 void WebFileSystemImpl::openFileSystem(
     const WebKit::WebURL& storage_partition,
     WebKit::WebFileSystemType type,
     bool create,
-    WebKit::WebFileSystemCallbacks* callbacks) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::OpenFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<fileapi::FileSystemType>(type),
                 0 /* size (not used) */, create,
                 base::Bind(&OpenFileSystemCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::deleteFileSystem(
     const WebKit::WebURL& storage_partition,
     WebKit::WebFileSystemType type,
-    WebKit::WebFileSystemCallbacks* callbacks) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   WaitableCallbackResults* waitable_results =
       WaitableCallbackResults::MaybeCreate(callbacks);
   CallDispatcherOnMainThread(
       main_thread_loop_.get(),
       &FileSystemDispatcher::DeleteFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<fileapi::FileSystemType>(type),
                 base::Bind(&StatusCallbackAdapter,
                            CurrentWorkerId(), callbacks_id,
                            base::Unretained(waitable_results))),
       make_scoped_ptr(waitable_results));
 }
 
 void WebFileSystemImpl::move(
     const WebKit::WebURL& src_path,
     const WebKit::WebURL& dest_path,
-    WebKit::WebFileSystemCallbacks* callbacks) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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) {
+    WebFileSystemCallbacksType callbacks) {
   int callbacks_id = 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));
 }
 
-int WebFileSystemImpl::RegisterCallbacks(WebFileSystemCallbacks* callbacks) {
-  return callbacks_.Add(callbacks);
+int WebFileSystemImpl::RegisterCallbacks(WebFileSystemCallbacksType callbacks) {
+  DCHECK(CalledOnValidThread());
+  int id = next_callbacks_id_++;
+  callbacks_[id] = callbacks;
+  return id;
 }
 
-WebFileSystemCallbacks* WebFileSystemImpl::GetAndUnregisterCallbacks(
+WebFileSystemCallbacksType WebFileSystemImpl::GetAndUnregisterCallbacks(
     int callbacks_id) {
-  WebFileSystemCallbacks* callbacks = callbacks_.Lookup(callbacks_id);
-  callbacks_.Remove(callbacks_id);
+  DCHECK(CalledOnValidThread());
+  CallbacksMap::iterator found = callbacks_.find(callbacks_id);
+  DCHECK(found != callbacks_.end());
+  WebFileSystemCallbacksType callbacks = found->second;
+  callbacks_.erase(found);
   return callbacks;
 }
 
 }  // namespace content