Remove passing WebString across threads

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"
@@ skipping 105 matching lines @@
   DCHECK(!waitable_results);
   DispatchToMethod(ChildThread::current()->file_system_dispatcher(),
                    method, params);
 }
 
 enum CallbacksUnregisterMode {
   UNREGISTER_CALLBACKS,
   DO_NOT_UNREGISTER_CALLBACKS,
 };
 
+// Bridging functions that convert the arguments into Blink objects
+// (e.g. WebFileInfo, WebString, WebVector<WebFileSystemEntry>)
+// and call WebFileSystemCallbacks's methods.
+// These are called by RunCallbacks after crossing threads to ensure
+// thread safety, because the Blink objects cannot be passed across
+// threads by base::Bind().
+void DidSucceed(WebFileSystemCallbacks* callbacks) {
+  callbacks->didSucceed();
+}
+
+void DidReadMetadata(const base::File::Info& file_info,
+                     WebFileSystemCallbacks* callbacks) {
+  WebFileInfo web_file_info;
+  FileInfoToWebFileInfo(file_info, &web_file_info);
+  callbacks->didReadMetadata(web_file_info);
+}
+
+void DidReadDirectory(const std::vector<fileapi::DirectoryEntry>& entries,
+                      bool has_more, WebFileSystemCallbacks* callbacks) {
+  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;
+  }
+  callbacks->didReadDirectory(file_system_entries, has_more);
+}
+
+void DidOpenFileSystem(const base::string16& name, const GURL& root,
+                       WebFileSystemCallbacks* callbacks) {
+  callbacks->didOpenFileSystem(
+      name,
+      root);

[tzik, 2014/07/16 04:22:51]

can these arguments be packed to l156?

[hiroshige, 2014/07/16 04:31:49]

Done.

+}
+
+void DidResolveURL(
+    const base::string16& name,
+    const GURL& root_url,
+    fileapi::FileSystemType mount_type,
+    const base::string16& file_path,
+    bool is_directory,
+    WebFileSystemCallbacks* callbacks) {
+  callbacks->didResolveURL(
+      name,
+      root_url,
+      static_cast<blink::WebFileSystemType>(mount_type),
+      file_path,
+      is_directory);
+}
+
+void DidFail(base::File::Error error, WebFileSystemCallbacks* callbacks) {
+  callbacks->didFail(fileapi::FileErrorToWebFileError(error));
+}
+
 // Run WebFileSystemCallbacks's |method| with |params|.
-template <typename Method, typename Params>
-void RunCallbacks(int callbacks_id, Method method, const Params& params,
-                  CallbacksUnregisterMode callbacks_unregister_mode) {
+void RunCallbacks(
+    int callbacks_id,
+    const base::Callback<void(WebFileSystemCallbacks*)>& callback,
+    CallbacksUnregisterMode callbacks_unregister_mode) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
   WebFileSystemCallbacks callbacks = filesystem->GetCallbacks(callbacks_id);
   if (callbacks_unregister_mode == UNREGISTER_CALLBACKS)
     filesystem->UnregisterCallbacks(callbacks_id);
-  DispatchToMethod(&callbacks, method, params);
+  callback.Run(&callbacks);
 }
 
 void DispatchResultsClosure(int thread_id, int callbacks_id,
                             WaitableCallbackResults* waitable_results,
                             const base::Closure& results_closure) {
   if (thread_id != CurrentWorkerId()) {
     if (waitable_results) {
       // If someone is waiting, this should result in running the closure.
       waitable_results->AddResultsAndSignal(results_closure);
       // In case no one is waiting, post a task to run the closure.
       WorkerTaskRunner::Instance()->PostTask(
           thread_id,
           base::Bind(&WaitableCallbackResults::Run,
                      make_scoped_refptr(waitable_results)));
       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,
-    CallbacksUnregisterMode callbacks_unregister_mode) {
+    const base::Callback<void(WebFileSystemCallbacks*)>& callback,
+    CallbacksUnregisterMode callbacksunregister_mode) {
   DispatchResultsClosure(
       thread_id, callbacks_id, waitable_results,
-      base::Bind(&RunCallbacks<Method, Params>, callbacks_id, method, params,
-                 callbacks_unregister_mode));
+      base::Bind(&RunCallbacks, callbacks_id, callback,
+                 callbacksunregister_mode));
 }
 
+
 //-----------------------------------------------------------------------------
 // Callback adapters. Callbacks must be called on the original calling thread,
 // so these callback adapters relay back the results to the calling thread
 // if necessary.
 
 void OpenFileSystemCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const std::string& name, const GURL& root) {
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
-      &WebFileSystemCallbacks::didOpenFileSystem,
-      MakeTuple(base::UTF8ToUTF16(name), root),
+      base::Bind(&DidOpenFileSystem, base::UTF8ToUTF16(name), root),
       UNREGISTER_CALLBACKS);
 }
 
 void ResolveURLCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     const fileapi::FileSystemInfo& info,
     const base::FilePath& file_path, bool is_directory) {
   base::FilePath normalized_path(
       fileapi::VirtualPath::GetNormalizedFilePath(file_path));
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
-      &WebFileSystemCallbacks::didResolveURL,
-      MakeTuple(base::UTF8ToUTF16(info.name), info.root_url,
-                static_cast<blink::WebFileSystemType>(info.mount_type),
-                normalized_path.AsUTF16Unsafe(), is_directory),
+      base::Bind(&DidResolveURL, base::UTF8ToUTF16(info.name), info.root_url,
+                 info.mount_type,
+                 normalized_path.AsUTF16Unsafe(), is_directory),
       UNREGISTER_CALLBACKS);
 }
 
 void StatusCallbackAdapter(int thread_id, int callbacks_id,
                            WaitableCallbackResults* waitable_results,
                            base::File::Error error) {
   if (error == base::File::FILE_OK) {
     CallbackFileSystemCallbacks(
         thread_id, callbacks_id, waitable_results,
-        &WebFileSystemCallbacks::didSucceed, MakeTuple(),
+        base::Bind(&DidSucceed),
         UNREGISTER_CALLBACKS);
   } else {
     CallbackFileSystemCallbacks(
         thread_id, callbacks_id, waitable_results,
-        &WebFileSystemCallbacks::didFail,
-        MakeTuple(fileapi::FileErrorToWebFileError(error)),
+        base::Bind(&DidFail, error),
         UNREGISTER_CALLBACKS);
   }
 }
 
 void ReadMetadataCallbackAdapter(int thread_id, int callbacks_id,
                                  WaitableCallbackResults* waitable_results,
                                  const base::File::Info& file_info) {
-  WebFileInfo web_file_info;
-  FileInfoToWebFileInfo(file_info, &web_file_info);
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
-      &WebFileSystemCallbacks::didReadMetadata,
-      MakeTuple(web_file_info),
+      base::Bind(&DidReadMetadata, file_info),
       UNREGISTER_CALLBACKS);
 }
 
 void ReadDirectoryCallbackAdapter(
     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),
+      base::Bind(&DidReadDirectory, entries, has_more),
       has_more ? DO_NOT_UNREGISTER_CALLBACKS : UNREGISTER_CALLBACKS);
 }
 
 void DidCreateFileWriter(
     int callbacks_id,
     const GURL& path,
     blink::WebFileWriterClient* client,
     base::MessageLoopProxy* main_thread_loop,
     const base::File::Info& file_info) {
   WebFileSystemImpl* filesystem =
@@ skipping 389 matching lines @@
 WaitableCallbackResults* WebFileSystemImpl::MaybeCreateWaitableResults(
     const WebFileSystemCallbacks& callbacks, int callbacks_id) {
   if (!callbacks.shouldBlockUntilCompletion())
     return NULL;
   WaitableCallbackResults* results = new WaitableCallbackResults();
   waitable_results_[callbacks_id] = results;
   return results;
 }
 
 }  // namespace content