v8binding: Uses filesystem's V8FileWriterCallback instead of FileWriterCallback.

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

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

third_party/WebKit/Source/modules/filesystem/BUILD.gn

@@ -54,7 +54,6 @@ blink_modules_sources("filesystem") {
     "FileWriter.h",
     "FileWriterBase.cpp",
     "FileWriterBase.h",
-    "FileWriterBaseCallback.h",
     "FileWriterCallback.h",
     "FileWriterSync.cpp",
     "FileWriterSync.h",

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

@@ -38,8 +38,6 @@
 #include "modules/filesystem/FileEntry.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
 #include "modules/filesystem/FileWriter.h"
-#include "modules/filesystem/FileWriterBaseCallback.h"
-#include "modules/filesystem/FileWriterCallback.h"
 #include "modules/filesystem/MetadataCallback.h"
 #include "platform/FileMetadata.h"
 #include "platform/WebTaskRunner.h"
@@ -145,34 +143,10 @@ void DOMFileSystem::ReportError(ExecutionContext* execution_context,
                              WrapPersistent(error_callback), file_error));
 }
 
-namespace {
-
-class ConvertToFileWriterCallback : public FileWriterBaseCallback {
- public:
-  static ConvertToFileWriterCallback* Create(FileWriterCallback* callback) {
-    return new ConvertToFileWriterCallback(callback);
-  }
-
-  void Trace(blink::Visitor* visitor) override {
-    visitor->Trace(callback_);
-    FileWriterBaseCallback::Trace(visitor);
-  }
-
-  void handleEvent(FileWriterBase* file_writer_base) override {
-    callback_->handleEvent(static_cast<FileWriter*>(file_writer_base));
-  }
-
- private:
-  explicit ConvertToFileWriterCallback(FileWriterCallback* callback)
-      : callback_(callback) {}
-  Member<FileWriterCallback> callback_;
-};
-
-}  // namespace
-
-void DOMFileSystem::CreateWriter(const FileEntry* file_entry,
-                                 FileWriterCallback* success_callback,
-                                 ErrorCallbackBase* error_callback) {
+void DOMFileSystem::CreateWriter(
+    const FileEntry* file_entry,
+    FileWriterCallbacks::OnDidCreateFileWriterCallback* success_callback,
+    ErrorCallbackBase* error_callback) {
   DCHECK(file_entry);
 
   if (!FileSystem()) {
@@ -181,11 +155,9 @@ void DOMFileSystem::CreateWriter(const FileEntry* file_entry,
   }
 
   FileWriter* file_writer = FileWriter::Create(GetExecutionContext());
-  FileWriterBaseCallback* conversion_callback =
-      ConvertToFileWriterCallback::Create(success_callback);
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks =
-      FileWriterBaseCallbacks::Create(file_writer, conversion_callback,
-                                      error_callback, context_);
+      FileWriterCallbacks::Create(file_writer, success_callback, error_callback,
+                                  context_);
   FileSystem()->CreateFileWriter(CreateFileSystemURL(file_entry), file_writer,
                                  std::move(callbacks));
 }

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

@@ -44,7 +44,6 @@ namespace blink {
 
 class DirectoryEntry;
 class FileEntry;
-class FileWriterCallback;
 
 class MODULES_EXPORT DOMFileSystem final
     : public DOMFileSystemBase,
@@ -77,7 +76,9 @@ class MODULES_EXPORT DOMFileSystem final
   // ScriptWrappable overrides.
   bool HasPendingActivity() const final;
 
-  void CreateWriter(const FileEntry*, FileWriterCallback*, ErrorCallbackBase*);
+  void CreateWriter(const FileEntry*,
+                    FileWriterCallbacks::OnDidCreateFileWriterCallback*,
+                    ErrorCallbackBase*);
   void CreateFile(const FileEntry*,
                   SnapshotFileCallback::OnDidCreateSnapshotFileCallback*,
                   ErrorCallbackBase*);

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

@@ -40,8 +40,8 @@
 #include "modules/filesystem/DirectoryEntrySync.h"
 #include "modules/filesystem/FileEntrySync.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
-#include "modules/filesystem/FileWriterBaseCallback.h"
 #include "modules/filesystem/FileWriterSync.h"
+#include "modules/filesystem/SyncCallbackHelper.h"
 #include "platform/FileMetadata.h"
 #include "public/platform/WebFileSystem.h"
 #include "public/platform/WebFileSystemCallbacks.h"
@@ -153,63 +153,26 @@ File* DOMFileSystemSync::CreateFile(const FileEntrySync* file_entry,
   return result->file_.Get();
 }
 
-namespace {
-
-class ReceiveFileWriterCallback final : public FileWriterBaseCallback {
- public:
-  static ReceiveFileWriterCallback* Create() {
-    return new ReceiveFileWriterCallback();
-  }
-
-  void handleEvent(FileWriterBase*) override {}
-
- private:
-  ReceiveFileWriterCallback() = default;
-};
-
-class LocalErrorCallback final : public ErrorCallbackBase {
- public:
-  static LocalErrorCallback* Create(FileError::ErrorCode& error_code) {
-    return new LocalErrorCallback(error_code);
-  }
-
-  void Invoke(FileError::ErrorCode error) override {
-    DCHECK_NE(error, FileError::kOK);
-    error_code_ = error;
-  }
-
- private:
-  explicit LocalErrorCallback(FileError::ErrorCode& error_code)
-      : error_code_(error_code) {}
-
-  FileError::ErrorCode& error_code_;
-};
-
-}  // namespace
-
 FileWriterSync* DOMFileSystemSync::CreateWriter(
     const FileEntrySync* file_entry,
     ExceptionState& exception_state) {
   DCHECK(file_entry);
 
   FileWriterSync* file_writer = FileWriterSync::Create();
-  ReceiveFileWriterCallback* success_callback =
-      ReceiveFileWriterCallback::Create();
-  FileError::ErrorCode error_code = FileError::kOK;
-  LocalErrorCallback* error_callback = LocalErrorCallback::Create(error_code);
 
+  FileWriterCallbacksSyncHelper* sync_helper =
+      FileWriterCallbacksSyncHelper::Create();
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks =
-      FileWriterBaseCallbacks::Create(file_writer, success_callback,
-                                      error_callback, context_);
+      FileWriterCallbacks::Create(file_writer,
+                                  sync_helper->GetSuccessCallback(),
+                                  sync_helper->GetErrorCallback(), context_);
   callbacks->SetShouldBlockUntilCompletion(true);
 
   FileSystem()->CreateFileWriter(CreateFileSystemURL(file_entry), file_writer,
                                  std::move(callbacks));
-  if (error_code != FileError::kOK) {
-    FileError::ThrowDOMException(exception_state, error_code);
-    return nullptr;
-  }
-  return file_writer;
+
+  FileWriterBase* success = sync_helper->GetResultOrThrow(exception_state);
+  return success ? file_writer : nullptr;
 }
 
 void DOMFileSystemSync::Trace(blink::Visitor* visitor) {

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

@@ -33,17 +33,19 @@
 #include "core/fileapi/File.h"
 #include "modules/filesystem/DOMFileSystem.h"
 #include "modules/filesystem/FileSystemCallbacks.h"
-#include "modules/filesystem/FileWriterCallback.h"
 
 namespace blink {
 
 FileEntry::FileEntry(DOMFileSystemBase* file_system, const String& full_path)
     : Entry(file_system, full_path) {}
 
-void FileEntry::createWriter(FileWriterCallback* success_callback,
+void FileEntry::createWriter(V8FileWriterCallback* success_callback,
                              V8ErrorCallback* error_callback) {
-  filesystem()->CreateWriter(this, success_callback,
-                             ScriptErrorCallback::Wrap(error_callback));
+  filesystem()->CreateWriter(
+      this,
+      FileWriterCallbacks::OnDidCreateFileWriterV8Impl::Create(
+          success_callback),
+      ScriptErrorCallback::Wrap(error_callback));
 }
 
 void FileEntry::file(V8FileCallback* success_callback,

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

@@ -38,8 +38,8 @@
 namespace blink {
 
 class DOMFileSystemBase;
-class FileWriterCallback;
 class V8FileCallback;
+class V8FileWriterCallback;
 
 class MODULES_EXPORT FileEntry final : public Entry {
   DEFINE_WRAPPERTYPEINFO();
@@ -50,7 +50,7 @@ class MODULES_EXPORT FileEntry final : public Entry {
     return new FileEntry(file_system, full_path);
   }
 
-  void createWriter(FileWriterCallback*, V8ErrorCallback* = nullptr);
+  void createWriter(V8FileWriterCallback*, V8ErrorCallback* = nullptr);
   void file(V8FileCallback*, V8ErrorCallback* = nullptr);
 
   bool isFile() const override { return true; }

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

@@ -37,6 +37,7 @@
 #include "bindings/modules/v8/V8ErrorCallback.h"
 #include "bindings/modules/v8/V8FileCallback.h"
 #include "bindings/modules/v8/V8FileSystemCallback.h"
+#include "bindings/modules/v8/V8FileWriterCallback.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileError.h"
@@ -48,8 +49,7 @@
 #include "modules/filesystem/DirectoryReader.h"
 #include "modules/filesystem/Entry.h"
 #include "modules/filesystem/FileEntry.h"
-#include "modules/filesystem/FileWriterBase.h"
-#include "modules/filesystem/FileWriterBaseCallback.h"
+#include "modules/filesystem/FileWriter.h"
 #include "modules/filesystem/Metadata.h"
 #include "modules/filesystem/MetadataCallback.h"
 #include "platform/FileMetadata.h"
@@ -367,33 +367,48 @@ void MetadataCallbacks::DidReadMetadata(const FileMetadata& metadata) {
                                   Metadata::Create(metadata));
 }
 
-// FileWriterBaseCallbacks ----------------------------------------------------
+// FileWriterCallbacks ----------------------------------------------------
 
-std::unique_ptr<AsyncFileSystemCallbacks> FileWriterBaseCallbacks::Create(
+void FileWriterCallbacks::OnDidCreateFileWriterV8Impl::Trace(
+    blink::Visitor* visitor) {
+  visitor->Trace(callback_);
+  OnDidCreateFileWriterCallback::Trace(visitor);
+}
+
+void FileWriterCallbacks::OnDidCreateFileWriterV8Impl::OnSuccess(
+    FileWriterBase* file_writer) {
+  // The call sites must pass a FileWriter in |file_writer|.
+  callback_->handleEvent(static_cast<FileWriter*>(file_writer));
+}
+
+std::unique_ptr<AsyncFileSystemCallbacks> FileWriterCallbacks::Create(
     FileWriterBase* file_writer,
-    FileWriterBaseCallback* success_callback,
+    OnDidCreateFileWriterCallback* success_callback,
     ErrorCallbackBase* error_callback,
     ExecutionContext* context) {
-  return base::WrapUnique(new FileWriterBaseCallbacks(
-      file_writer, success_callback, error_callback, context));
+  return base::WrapUnique(new FileWriterCallbacks(file_writer, success_callback,
+                                                  error_callback, context));
 }
 
-FileWriterBaseCallbacks::FileWriterBaseCallbacks(
+FileWriterCallbacks::FileWriterCallbacks(
     FileWriterBase* file_writer,
-    FileWriterBaseCallback* success_callback,
+    OnDidCreateFileWriterCallback* success_callback,
     ErrorCallbackBase* error_callback,
     ExecutionContext* context)
     : FileSystemCallbacksBase(error_callback, nullptr, context),
       file_writer_(file_writer),
       success_callback_(success_callback) {}
 
-void FileWriterBaseCallbacks::DidCreateFileWriter(
+void FileWriterCallbacks::DidCreateFileWriter(
     std::unique_ptr<WebFileWriter> file_writer,
     long long length) {
   file_writer_->Initialize(std::move(file_writer), length);
-  if (success_callback_)
-    HandleEventOrScheduleCallback(success_callback_.Release(),
-                                  file_writer_.Release());
+
+  if (!success_callback_)
+    return;
+
+  InvokeOrScheduleCallback(&OnDidCreateFileWriterCallback::OnSuccess,
+                           success_callback_.Release(), file_writer_.Release());
 }
 
 // SnapshotFileCallback -------------------------------------------------------

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

@@ -51,12 +51,12 @@ class ExecutionContext;
 class File;
 class FileMetadata;
 class FileWriterBase;
-class FileWriterBaseCallback;
 class MetadataCallback;
 class V8EntryCallback;
 class V8ErrorCallback;
 class V8FileCallback;
 class V8FileSystemCallback;
+class V8FileWriterCallback;
 class VoidCallback;
 
 // Passed to DOMFileSystem implementations that may report errors. Subclasses
@@ -273,23 +273,49 @@ class MetadataCallbacks final : public FileSystemCallbacksBase {
   Persistent<MetadataCallback> success_callback_;
 };
 
-class FileWriterBaseCallbacks final : public FileSystemCallbacksBase {
+class FileWriterCallbacks final : public FileSystemCallbacksBase {
  public:
+  class OnDidCreateFileWriterCallback
+      : public GarbageCollectedFinalized<OnDidCreateFileWriterCallback> {
+   public:
+    virtual ~OnDidCreateFileWriterCallback() = default;
+    virtual void Trace(blink::Visitor*) {}
+    virtual void OnSuccess(FileWriterBase*) = 0;
+
+   protected:
+    OnDidCreateFileWriterCallback() = default;
+  };
+
+  class OnDidCreateFileWriterV8Impl : public OnDidCreateFileWriterCallback {
+   public:
+    static OnDidCreateFileWriterV8Impl* Create(V8FileWriterCallback* callback) {
+      return callback ? new OnDidCreateFileWriterV8Impl(callback) : nullptr;
+    }
+    void Trace(blink::Visitor*) override;
+    void OnSuccess(FileWriterBase*) override;
+
+   private:
+    OnDidCreateFileWriterV8Impl(V8FileWriterCallback* callback)
+        : callback_(callback) {}
+
+    Member<V8FileWriterCallback> callback_;
+  };
+
   static std::unique_ptr<AsyncFileSystemCallbacks> Create(
       FileWriterBase*,
-      FileWriterBaseCallback*,
+      OnDidCreateFileWriterCallback*,
       ErrorCallbackBase*,
       ExecutionContext*);
   void DidCreateFileWriter(std::unique_ptr<WebFileWriter>,
                            long long length) override;
 
  private:
-  FileWriterBaseCallbacks(FileWriterBase*,
-                          FileWriterBaseCallback*,
-                          ErrorCallbackBase*,
-                          ExecutionContext*);
+  FileWriterCallbacks(FileWriterBase*,
+                      OnDidCreateFileWriterCallback*,
+                      ErrorCallbackBase*,
+                      ExecutionContext*);
   Persistent<FileWriterBase> file_writer_;
-  Persistent<FileWriterBaseCallback> success_callback_;
+  Persistent<OnDidCreateFileWriterCallback> success_callback_;
 };
 
 class SnapshotFileCallback final : public FileSystemCallbacksBase {

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

-/*
- * Copyright (C) 2010 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef FileWriterBaseCallback_h
-#define FileWriterBaseCallback_h
-
-namespace blink {
-
-class FileWriterBase;
-
-class FileWriterBaseCallback
-    : public GarbageCollectedFinalized<FileWriterBaseCallback> {
- public:
-  virtual ~FileWriterBaseCallback() = default;
-  virtual void Trace(blink::Visitor* visitor) {}
-  virtual void handleEvent(FileWriterBase*) = 0;
-};
-
-}  // namespace blink
-
-#endif  // FileWriterBaseCallback_h

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

@@ -221,6 +221,10 @@ using FileSystemCallbacksSyncHelper = DOMFileSystemCallbacksSyncHelper<
     FileSystemCallbacks::OnDidOpenFileSystemCallback,
     DOMFileSystem>;
 
+using FileWriterCallbacksSyncHelper = DOMFileSystemCallbacksSyncHelper<
+    FileWriterCallbacks::OnDidCreateFileWriterCallback,
+    FileWriterBase>;
+
 }  // namespace blink
 
 #endif  // SyncCallbackHelper_h