Web expose FileSystemFileEntry, FileSystemDirectoryEntry and friends

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

Index: third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
deleted file mode 100644
index ea862aa218899a7e5a418ed16cbb0008c31792da..0000000000000000000000000000000000000000
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * 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.
- */
-
-#include "modules/filesystem/DOMFileSystemSync.h"
-
-#include "bindings/core/v8/ExceptionState.h"
-#include "core/fileapi/File.h"
-#include "core/fileapi/FileError.h"
-#include "modules/filesystem/DOMFilePath.h"
-#include "modules/filesystem/DirectoryEntrySync.h"
-#include "modules/filesystem/ErrorCallback.h"
-#include "modules/filesystem/FileEntrySync.h"
-#include "modules/filesystem/FileSystemCallbacks.h"
-#include "modules/filesystem/FileWriterBaseCallback.h"
-#include "modules/filesystem/FileWriterSync.h"
-#include "platform/FileMetadata.h"
-#include "public/platform/WebFileSystem.h"
-#include "public/platform/WebFileSystemCallbacks.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
-
-namespace blink {
-
-class FileWriterBase;
-
-DOMFileSystemSync* DOMFileSystemSync::create(DOMFileSystemBase* fileSystem) {
-  return new DOMFileSystemSync(fileSystem->m_context, fileSystem->name(),
-                               fileSystem->type(), fileSystem->rootURL());
-}
-
-DOMFileSystemSync::DOMFileSystemSync(ExecutionContext* context,
-                                     const String& name,
-                                     FileSystemType type,
-                                     const KURL& rootURL)
-    : DOMFileSystemBase(context, name, type, rootURL),
-      m_rootEntry(DirectoryEntrySync::create(this, DOMFilePath::root)) {}
-
-DOMFileSystemSync::~DOMFileSystemSync() {}
-
-void DOMFileSystemSync::reportError(ErrorCallbackBase* errorCallback,
-                                    FileError::ErrorCode fileError) {
-  errorCallback->invoke(fileError);
-}
-
-DirectoryEntrySync* DOMFileSystemSync::root() {
-  return m_rootEntry.get();
-}
-
-namespace {
-
-class CreateFileHelper final : public AsyncFileSystemCallbacks {
- public:
-  class CreateFileResult : public GarbageCollected<CreateFileResult> {
-   public:
-    static CreateFileResult* create() { return new CreateFileResult(); }
-
-    bool m_failed;
-    int m_code;
-    Member<File> m_file;
-
-    DEFINE_INLINE_TRACE() { visitor->trace(m_file); }
-
-   private:
-    CreateFileResult() : m_failed(false), m_code(0) {}
-  };
-
-  static std::unique_ptr<AsyncFileSystemCallbacks> create(
-      CreateFileResult* result,
-      const String& name,
-      const KURL& url,
-      FileSystemType type) {
-    return wrapUnique(static_cast<AsyncFileSystemCallbacks*>(
-        new CreateFileHelper(result, name, url, type)));
-  }
-
-  void didFail(int code) override {
-    m_result->m_failed = true;
-    m_result->m_code = code;
-  }
-
-  ~CreateFileHelper() override {}
-
-  void didCreateSnapshotFile(const FileMetadata& metadata,
-                             PassRefPtr<BlobDataHandle> snapshot) override {
-    // We can't directly use the snapshot blob data handle because the content
-    // type on it hasn't been set.  The |snapshot| param is here to provide a a
-    // chain of custody thru thread bridging that is held onto until *after*
-    // we've coined a File with a new handle that has the correct type set on
-    // it. This allows the blob storage system to track when a temp file can and
-    // can't be safely deleted.
-
-    m_result->m_file =
-        DOMFileSystemBase::createFile(metadata, m_url, m_type, m_name);
-  }
-
-  bool shouldBlockUntilCompletion() const override { return true; }
-
- private:
-  CreateFileHelper(CreateFileResult* result,
-                   const String& name,
-                   const KURL& url,
-                   FileSystemType type)
-      : m_result(result), m_name(name), m_url(url), m_type(type) {}
-
-  Persistent<CreateFileResult> m_result;
-  String m_name;
-  KURL m_url;
-  FileSystemType m_type;
-};
-
-}  // namespace
-
-File* DOMFileSystemSync::createFile(const FileEntrySync* fileEntry,
-                                    ExceptionState& exceptionState) {
-  KURL fileSystemURL = createFileSystemURL(fileEntry);
-  CreateFileHelper::CreateFileResult* result(
-      CreateFileHelper::CreateFileResult::create());
-  fileSystem()->createSnapshotFileAndReadMetadata(
-      fileSystemURL, CreateFileHelper::create(result, fileEntry->name(),
-                                              fileSystemURL, type()));
-  if (result->m_failed) {
-    exceptionState.throwDOMException(
-        result->m_code, "Could not create '" + fileEntry->name() + "'.");
-    return nullptr;
-  }
-  return result->m_file.get();
-}
-
-namespace {
-
-class ReceiveFileWriterCallback final : public FileWriterBaseCallback {
- public:
-  static ReceiveFileWriterCallback* create() {
-    return new ReceiveFileWriterCallback();
-  }
-
-  void handleEvent(FileWriterBase*) override {}
-
- private:
-  ReceiveFileWriterCallback() {}
-};
-
-class LocalErrorCallback final : public ErrorCallbackBase {
- public:
-  static LocalErrorCallback* create(FileError::ErrorCode& errorCode) {
-    return new LocalErrorCallback(errorCode);
-  }
-
-  void invoke(FileError::ErrorCode error) override {
-    DCHECK_NE(error, FileError::kOK);
-    m_errorCode = error;
-  }
-
- private:
-  explicit LocalErrorCallback(FileError::ErrorCode& errorCode)
-      : m_errorCode(errorCode) {}
-
-  FileError::ErrorCode& m_errorCode;
-};
-
-}  // namespace
-
-FileWriterSync* DOMFileSystemSync::createWriter(
-    const FileEntrySync* fileEntry,
-    ExceptionState& exceptionState) {
-  ASSERT(fileEntry);
-
-  FileWriterSync* fileWriter = FileWriterSync::create();
-  ReceiveFileWriterCallback* successCallback =
-      ReceiveFileWriterCallback::create();
-  FileError::ErrorCode errorCode = FileError::kOK;
-  LocalErrorCallback* errorCallback = LocalErrorCallback::create(errorCode);
-
-  std::unique_ptr<AsyncFileSystemCallbacks> callbacks =
-      FileWriterBaseCallbacks::create(fileWriter, successCallback,
-                                      errorCallback, m_context);
-  callbacks->setShouldBlockUntilCompletion(true);
-
-  fileSystem()->createFileWriter(createFileSystemURL(fileEntry), fileWriter,
-                                 std::move(callbacks));
-  if (errorCode != FileError::kOK) {
-    FileError::throwDOMException(exceptionState, errorCode);
-    return 0;
-  }
-  return fileWriter;
-}
-
-DEFINE_TRACE(DOMFileSystemSync) {
-  DOMFileSystemBase::trace(visitor);
-  visitor->trace(m_rootEntry);
-}
-
-}  // namespace blink