v8binding: Uses filesystem's V8VoidCallback instead of VoidCallback.

This patch removes use of filesystem's VoidCallback.  The
motivation is the same as https://crrev.com/844307 .

Bug: 778580
Change-Id: I2f57919461a31a4f64af287b40e0a3a6d1f242cb
Reviewed-on: https://chromium-review.googlesource.com/888234
Commit-Queue: Yuki Shiino <yukishiino@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Hitoshi Yoshida <peria@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532414}

third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp

@@ -66,7 +66,6 @@
 #include "core/frame/LocalFrameView.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLHeadElement.h"
-#include "core/html/VoidCallback.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InspectorHistory.h"

third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp

@@ -45,7 +45,6 @@
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLFrameOwnerElement.h"
-#include "core/html/VoidCallback.h"
 #include "core/html/imports/HTMLImportLoader.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/html/parser/TextResourceDecoder.h"

third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp

@@ -34,7 +34,6 @@
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileError.h"
-#include "core/html/VoidCallback.h"
 #include "modules/filesystem/DOMFilePath.h"
 #include "modules/filesystem/DirectoryEntry.h"
 #include "modules/filesystem/DirectoryReaderBase.h"
@@ -321,10 +320,11 @@ void DOMFileSystemBase::Copy(
       std::move(callbacks));
 }
 
-void DOMFileSystemBase::Remove(const EntryBase* entry,
-                               VoidCallback* success_callback,
-                               ErrorCallbackBase* error_callback,
-                               SynchronousType synchronous_type) {
+void DOMFileSystemBase::Remove(
+    const EntryBase* entry,
+    VoidCallbacks::OnDidSucceedCallback* success_callback,
+    ErrorCallbackBase* error_callback,
+    SynchronousType synchronous_type) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return;
@@ -344,10 +344,11 @@ void DOMFileSystemBase::Remove(const EntryBase* entry,
   FileSystem()->Remove(CreateFileSystemURL(entry), std::move(callbacks));
 }
 
-void DOMFileSystemBase::RemoveRecursively(const EntryBase* entry,
-                                          VoidCallback* success_callback,
-                                          ErrorCallbackBase* error_callback,
-                                          SynchronousType synchronous_type) {
+void DOMFileSystemBase::RemoveRecursively(
+    const EntryBase* entry,
+    VoidCallbacks::OnDidSucceedCallback* success_callback,
+    ErrorCallbackBase* error_callback,
+    SynchronousType synchronous_type) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return;

third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.h

@@ -54,7 +54,6 @@ class ExecutionContext;
 class File;
 class FileMetadata;
 class SecurityOrigin;
-class VoidCallback;
 
 // A common base class for DOMFileSystem and DOMFileSystemSync.
 class MODULES_EXPORT DOMFileSystemBase : public ScriptWrappable {
@@ -129,11 +128,11 @@ class MODULES_EXPORT DOMFileSystemBase : public ScriptWrappable {
             ErrorCallbackBase*,
             SynchronousType = kAsynchronous);
   void Remove(const EntryBase*,
-              VoidCallback*,
+              VoidCallbacks::OnDidSucceedCallback*,
               ErrorCallbackBase*,
               SynchronousType = kAsynchronous);
   void RemoveRecursively(const EntryBase*,
-                         VoidCallback*,
+                         VoidCallbacks::OnDidSucceedCallback*,
                          ErrorCallbackBase*,
                          SynchronousType = kAsynchronous);
   void GetParent(const EntryBase*,

third_party/WebKit/Source/modules/filesystem/DirectoryEntry.cpp

@@ -31,7 +31,6 @@
 #include "modules/filesystem/DirectoryEntry.h"
 
 #include "core/fileapi/FileError.h"
-#include "core/html/VoidCallback.h"
 #include "modules/filesystem/DirectoryReader.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "modules/filesystem/FileSystemFlags.h"
@@ -66,10 +65,11 @@ void DirectoryEntry::getDirectory(const String& path,
       ScriptErrorCallback::Wrap(error_callback));
 }
 
-void DirectoryEntry::removeRecursively(VoidCallback* success_callback,
+void DirectoryEntry::removeRecursively(V8VoidCallback* success_callback,
                                        V8ErrorCallback* error_callback) const {
-  file_system_->RemoveRecursively(this, success_callback,
-                                  ScriptErrorCallback::Wrap(error_callback));
+  file_system_->RemoveRecursively(
+      this, VoidCallbacks::OnDidSucceedV8Impl::Create(success_callback),
+      ScriptErrorCallback::Wrap(error_callback));
 }
 
 void DirectoryEntry::Trace(blink::Visitor* visitor) {

third_party/WebKit/Source/modules/filesystem/DirectoryEntry.h

@@ -43,7 +43,7 @@ class DirectoryReader;
 class FileSystemFlags;
 class V8EntryCallback;
 class V8ErrorCallback;
-class VoidCallback;
+class V8VoidCallback;
 
 class MODULES_EXPORT DirectoryEntry final : public Entry {
   DEFINE_WRAPPERTYPEINFO();
@@ -64,7 +64,7 @@ class MODULES_EXPORT DirectoryEntry final : public Entry {
                     const FileSystemFlags&,
                     V8EntryCallback* = nullptr,
                     V8ErrorCallback* = nullptr);
-  void removeRecursively(VoidCallback* success_callback = nullptr,
+  void removeRecursively(V8VoidCallback* success_callback = nullptr,
                          V8ErrorCallback* = nullptr) const;
 
   void Trace(blink::Visitor*) override;

third_party/WebKit/Source/modules/filesystem/DirectoryEntrySync.cpp

@@ -33,6 +33,7 @@
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "modules/filesystem/DirectoryReaderSync.h"
+#include "modules/filesystem/Entry.h"
 #include "modules/filesystem/FileEntrySync.h"
 #include "modules/filesystem/FileSystemFlags.h"
 #include "modules/filesystem/SyncCallbackHelper.h"
@@ -50,11 +51,11 @@ DirectoryReaderSync* DirectoryEntrySync::createReader() {
 FileEntrySync* DirectoryEntrySync::getFile(const String& path,
                                            const FileSystemFlags& options,
                                            ExceptionState& exception_state) {
-  EntryCallbacksSyncHelper* helper = EntryCallbacksSyncHelper::Create();
-  file_system_->GetFile(this, path, options, helper->GetSuccessCallback(),
-                        helper->GetErrorCallback(),
+  EntryCallbacksSyncHelper* sync_helper = EntryCallbacksSyncHelper::Create();
+  file_system_->GetFile(this, path, options, sync_helper->GetSuccessCallback(),
+                        sync_helper->GetErrorCallback(),
                         DOMFileSystemBase::kSynchronous);
-  Entry* entry = helper->GetResultOrThrow(exception_state);
+  Entry* entry = sync_helper->GetResultOrThrow(exception_state);
   return entry ? ToFileEntrySync(EntrySync::Create(entry)) : nullptr;
 }
 
@@ -62,20 +63,20 @@ DirectoryEntrySync* DirectoryEntrySync::getDirectory(
     const String& path,
     const FileSystemFlags& options,
     ExceptionState& exception_state) {
-  EntryCallbacksSyncHelper* helper = EntryCallbacksSyncHelper::Create();
-  file_system_->GetDirectory(this, path, options, helper->GetSuccessCallback(),
-                             helper->GetErrorCallback(),
-                             DOMFileSystemBase::kSynchronous);
-  Entry* entry = helper->GetResultOrThrow(exception_state);
+  EntryCallbacksSyncHelper* sync_helper = EntryCallbacksSyncHelper::Create();
+  file_system_->GetDirectory(
+      this, path, options, sync_helper->GetSuccessCallback(),
+      sync_helper->GetErrorCallback(), DOMFileSystemBase::kSynchronous);
+  Entry* entry = sync_helper->GetResultOrThrow(exception_state);
   return entry ? ToDirectoryEntrySync(EntrySync::Create(entry)) : nullptr;
 }
 
 void DirectoryEntrySync::removeRecursively(ExceptionState& exception_state) {
-  VoidSyncCallbackHelper* helper = VoidSyncCallbackHelper::Create();
-  file_system_->RemoveRecursively(this, helper->GetSuccessCallback(),
-                                  helper->GetErrorCallback(),
+  VoidCallbacksSyncHelper* sync_helper = VoidCallbacksSyncHelper::Create();
+  file_system_->RemoveRecursively(this, nullptr,
+                                  sync_helper->GetErrorCallback(),
                                   DOMFileSystemBase::kSynchronous);
-  helper->GetResult(exception_state);
+  sync_helper->GetResultOrThrow(exception_state);
 }
 
 void DirectoryEntrySync::Trace(blink::Visitor* visitor) {

third_party/WebKit/Source/modules/filesystem/Entry.cpp

@@ -32,7 +32,6 @@
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/FileError.h"
 #include "core/frame/UseCounter.h"
-#include "core/html/VoidCallback.h"
 #include "modules/filesystem/DirectoryEntry.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "platform/bindings/ScriptState.h"
@@ -97,14 +96,15 @@ void Entry::copyTo(ScriptState* script_state,
 }
 
 void Entry::remove(ScriptState* script_state,
-                   VoidCallback* success_callback,
+                   V8VoidCallback* success_callback,
                    V8ErrorCallback* error_callback) const {
   if (file_system_->GetType() == kFileSystemTypeIsolated) {
     UseCounter::Count(ExecutionContext::From(script_state),
                       WebFeature::kEntry_Remove_Method_IsolatedFileSystem);
   }
-  file_system_->Remove(this, success_callback,
-                       ScriptErrorCallback::Wrap(error_callback));
+  file_system_->Remove(
+      this, VoidCallbacks::OnDidSucceedV8Impl::Create(success_callback),
+      ScriptErrorCallback::Wrap(error_callback));
 }
 
 void Entry::getParent(ScriptState* script_state,

third_party/WebKit/Source/modules/filesystem/Entry.h

@@ -42,7 +42,7 @@ class DirectoryEntry;
 class V8EntryCallback;
 class V8ErrorCallback;
 class V8MetadataCallback;
-class VoidCallback;
+class V8VoidCallback;
 
 class MODULES_EXPORT Entry : public EntryBase {
   DEFINE_WRAPPERTYPEINFO();
@@ -67,7 +67,7 @@ class MODULES_EXPORT Entry : public EntryBase {
               V8EntryCallback* success_callback = nullptr,
               V8ErrorCallback* = nullptr) const;
   void remove(ScriptState*,
-              VoidCallback* success_callback = nullptr,
+              V8VoidCallback* success_callback = nullptr,
               V8ErrorCallback* = nullptr) const;
   void getParent(ScriptState*,
                  V8EntryCallback* success_callback = nullptr,

third_party/WebKit/Source/modules/filesystem/EntrySync.cpp

@@ -79,11 +79,10 @@ EntrySync* EntrySync::copyTo(DirectoryEntrySync* parent,
 }
 
 void EntrySync::remove(ExceptionState& exception_state) const {
-  VoidSyncCallbackHelper* helper = VoidSyncCallbackHelper::Create();
-  file_system_->Remove(this, helper->GetSuccessCallback(),
-                       helper->GetErrorCallback(),
+  VoidCallbacksSyncHelper* sync_helper = VoidCallbacksSyncHelper::Create();
+  file_system_->Remove(this, nullptr, sync_helper->GetErrorCallback(),
                        DOMFileSystemBase::kSynchronous);
-  helper->GetResult(exception_state);
+  sync_helper->GetResultOrThrow(exception_state);
 }
 
 EntrySync* EntrySync::getParent() const {

third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp

@@ -33,6 +33,7 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
+#include "bindings/core/v8/V8VoidCallback.h"
 #include "bindings/modules/v8/V8EntryCallback.h"
 #include "bindings/modules/v8/V8ErrorCallback.h"
 #include "bindings/modules/v8/V8FileCallback.h"
@@ -42,7 +43,6 @@
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileError.h"
-#include "core/html/VoidCallback.h"
 #include "modules/filesystem/DOMFilePath.h"
 #include "modules/filesystem/DOMFileSystem.h"
 #include "modules/filesystem/DOMFileSystemBase.h"
@@ -482,8 +482,18 @@ void SnapshotFileCallback::DidCreateSnapshotFile(
 
 // VoidCallbacks --------------------------------------------------------------
 
+void VoidCallbacks::OnDidSucceedV8Impl::Trace(blink::Visitor* visitor) {
+  visitor->Trace(callback_);
+  OnDidSucceedCallback::Trace(visitor);
+}
+
+void VoidCallbacks::OnDidSucceedV8Impl::OnSuccess(
+    ExecutionContext* dummy_arg_for_sync_helper) {
+  callback_->handleEvent();
+}
+
 std::unique_ptr<AsyncFileSystemCallbacks> VoidCallbacks::Create(
-    VoidCallback* success_callback,
+    OnDidSucceedCallback* success_callback,
     ErrorCallbackBase* error_callback,
     ExecutionContext* context,
     DOMFileSystemBase* file_system) {
@@ -491,7 +501,7 @@ std::unique_ptr<AsyncFileSystemCallbacks> VoidCallbacks::Create(
                                             context, file_system));
 }
 
-VoidCallbacks::VoidCallbacks(VoidCallback* success_callback,
+VoidCallbacks::VoidCallbacks(OnDidSucceedCallback* success_callback,
                              ErrorCallbackBase* error_callback,
                              ExecutionContext* context,
                              DOMFileSystemBase* file_system)
@@ -499,8 +509,12 @@ VoidCallbacks::VoidCallbacks(VoidCallback* success_callback,
       success_callback_(success_callback) {}
 
 void VoidCallbacks::DidSucceed() {
-  if (success_callback_)
-    HandleEventOrScheduleCallback(success_callback_.Release());
+  if (!success_callback_)
+    return;
+
+  InvokeOrScheduleCallback(&OnDidSucceedCallback::OnSuccess,
+                           success_callback_.Release(),
+                           execution_context_.Get());
 }
 
 }  // namespace blink

third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h

@@ -58,7 +58,7 @@ class V8FileCallback;
 class V8FileSystemCallback;
 class V8FileWriterCallback;
 class V8MetadataCallback;
-class VoidCallback;
+class V8VoidCallback;
 
 // Passed to DOMFileSystem implementations that may report errors. Subclasses
 // may capture the error for throwing on return to script (for synchronous APIs)
@@ -398,18 +398,43 @@ class SnapshotFileCallback final : public FileSystemCallbacksBase {
 
 class VoidCallbacks final : public FileSystemCallbacksBase {
  public:
-  static std::unique_ptr<AsyncFileSystemCallbacks> Create(VoidCallback*,
+  class OnDidSucceedCallback
+      : public GarbageCollectedFinalized<OnDidSucceedCallback> {
+   public:
+    virtual ~OnDidSucceedCallback() = default;
+    virtual void Trace(blink::Visitor*) {}
+    virtual void OnSuccess(ExecutionContext* dummy_arg_for_sync_helper) = 0;
+
+   protected:
+    OnDidSucceedCallback() = default;
+  };
+
+  class OnDidSucceedV8Impl : public OnDidSucceedCallback {
+   public:
+    static OnDidSucceedV8Impl* Create(V8VoidCallback* callback) {
+      return callback ? new OnDidSucceedV8Impl(callback) : nullptr;
+    }
+    void Trace(blink::Visitor*) override;
+    void OnSuccess(ExecutionContext* dummy_arg_for_sync_helper) override;
+
+   private:
+    OnDidSucceedV8Impl(V8VoidCallback* callback) : callback_(callback) {}
+
+    Member<V8VoidCallback> callback_;
+  };
+
+  static std::unique_ptr<AsyncFileSystemCallbacks> Create(OnDidSucceedCallback*,
                                                           ErrorCallbackBase*,
                                                           ExecutionContext*,
                                                           DOMFileSystemBase*);
   void DidSucceed() override;
 
  private:
-  VoidCallbacks(VoidCallback*,
+  VoidCallbacks(OnDidSucceedCallback*,
                 ErrorCallbackBase*,
                 ExecutionContext*,
                 DOMFileSystemBase*);
-  Persistent<VoidCallback> success_callback_;
+  Persistent<OnDidSucceedCallback> success_callback_;
 };
 
 }  // namespace blink

third_party/WebKit/Source/modules/filesystem/SyncCallbackHelper.h

@@ -32,111 +32,12 @@
 #ifndef SyncCallbackHelper_h
 #define SyncCallbackHelper_h
 
-#include "bindings/core/v8/ExceptionState.h"
 #include "core/fileapi/FileError.h"
-#include "core/html/VoidCallback.h"
-#include "modules/filesystem/DirectoryEntry.h"
-#include "modules/filesystem/EntrySync.h"
-#include "modules/filesystem/FileEntry.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
-// A helper template for FileSystemSync implementation.
-template <typename SuccessCallback, typename CallbackArg, typename ResultType>
-class SyncCallbackHelper final
-    : public GarbageCollected<
-          SyncCallbackHelper<SuccessCallback, CallbackArg, ResultType>> {
- public:
-  typedef SyncCallbackHelper<SuccessCallback, CallbackArg, ResultType>
-      HelperType;
-
-  static HelperType* Create() { return new SyncCallbackHelper(); }
-
-  ResultType* GetResult(ExceptionState& exception_state) {
-    if (error_code_)
-      FileError::ThrowDOMException(exception_state, error_code_);
-
-    return result_;
-  }
-
-  SuccessCallback* GetSuccessCallback() {
-    return SuccessCallbackImpl::Create(this);
-  }
-  ErrorCallbackBase* GetErrorCallback() {
-    return ErrorCallbackImpl::Create(this);
-  }
-
-  void Trace(blink::Visitor* visitor) { visitor->Trace(result_); }
-
- private:
-  SyncCallbackHelper() : error_code_(FileError::kOK), completed_(false) {}
-
-  class SuccessCallbackImpl final : public SuccessCallback {
-   public:
-    static SuccessCallbackImpl* Create(HelperType* helper) {
-      return new SuccessCallbackImpl(helper);
-    }
-
-    virtual void handleEvent() { helper_->SetError(FileError::kOK); }
-
-    virtual void handleEvent(CallbackArg arg) { helper_->SetResult(arg); }
-
-    void Trace(blink::Visitor* visitor) {
-      visitor->Trace(helper_);
-      SuccessCallback::Trace(visitor);
-    }
-
-   private:
-    explicit SuccessCallbackImpl(HelperType* helper) : helper_(helper) {}
-    Member<HelperType> helper_;
-  };
-
-  class ErrorCallbackImpl final : public ErrorCallbackBase {
-   public:
-    static ErrorCallbackImpl* Create(HelperType* helper) {
-      return new ErrorCallbackImpl(helper);
-    }
-
-    void Invoke(FileError::ErrorCode error) override {
-      helper_->SetError(error);
-    }
-
-    void Trace(blink::Visitor* visitor) {
-      visitor->Trace(helper_);
-      ErrorCallbackBase::Trace(visitor);
-    }
-
-   private:
-    explicit ErrorCallbackImpl(HelperType* helper) : helper_(helper) {}
-    Member<HelperType> helper_;
-  };
-
-  void SetError(FileError::ErrorCode error) {
-    error_code_ = error;
-    completed_ = true;
-  }
-
-  void SetResult(CallbackArg result) {
-    result_ = ResultType::Create(result);
-    completed_ = true;
-  }
-
-  Member<ResultType> result_;
-  FileError::ErrorCode error_code_;
-  bool completed_;
-};
-
-struct EmptyType : public GarbageCollected<EmptyType> {
-  static EmptyType* Create(EmptyType*) { return nullptr; }
-
-  void Trace(blink::Visitor* visitor) {}
-};
-
-typedef SyncCallbackHelper<VoidCallback, EmptyType*, EmptyType>
-    VoidSyncCallbackHelper;
-
 // Helper class to support DOMFileSystemSync implementation.
 template <typename SuccessCallback, typename CallbackArg>
 class DOMFileSystemCallbacksSyncHelper final
@@ -226,6 +127,10 @@ using MetadataCallbacksSyncHelper = DOMFileSystemCallbacksSyncHelper<
     MetadataCallbacks::OnDidReadMetadataCallback,
     Metadata>;
 
+using VoidCallbacksSyncHelper = DOMFileSystemCallbacksSyncHelper<
+    VoidCallbacks::OnDidSucceedCallback,
+    ExecutionContext /* dummy_arg_for_sync_helper */>;
+
 }  // namespace blink
 
 #endif  // SyncCallbackHelper_h

third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.cpp

@@ -34,8 +34,9 @@
 #include "core/fileapi/FileError.h"
 #include "core/frame/UseCounter.h"
 #include "core/workers/WorkerGlobalScope.h"
-#include "modules/filesystem/DOMFileSystemBase.h"
+#include "modules/filesystem/DOMFileSystem.h"
 #include "modules/filesystem/DirectoryEntrySync.h"
+#include "modules/filesystem/Entry.h"
 #include "modules/filesystem/FileEntrySync.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "modules/filesystem/LocalFileSystem.h"