From cad810f21b803229eb11403f9209855525a25d57 Mon Sep 17 00:00:00 2001 From: Steve Block Date: Fri, 6 May 2011 11:45:16 +0100 Subject: Merge WebKit at r75315: Initial merge by git. Change-Id: I570314b346ce101c935ed22a626b48c2af266b84 --- Source/WebCore/fileapi/FileSystemCallbacks.cpp | 259 +++++++++++++++++++++++++ 1 file changed, 259 insertions(+) create mode 100644 Source/WebCore/fileapi/FileSystemCallbacks.cpp (limited to 'Source/WebCore/fileapi/FileSystemCallbacks.cpp') diff --git a/Source/WebCore/fileapi/FileSystemCallbacks.cpp b/Source/WebCore/fileapi/FileSystemCallbacks.cpp new file mode 100644 index 0000000..966337b --- /dev/null +++ b/Source/WebCore/fileapi/FileSystemCallbacks.cpp @@ -0,0 +1,259 @@ +/* + * 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 "config.h" +#include "FileSystemCallbacks.h" + +#if ENABLE(FILE_SYSTEM) + +#include "AsyncFileSystem.h" +#include "AsyncFileWriter.h" +#include "DOMFilePath.h" +#include "DOMFileSystemBase.h" +#include "DirectoryEntry.h" +#include "DirectoryReader.h" +#include "EntriesCallback.h" +#include "EntryArray.h" +#include "EntryCallback.h" +#include "ErrorCallback.h" +#include "FileEntry.h" +#include "FileError.h" +#include "FileMetadata.h" +#include "FileSystemCallback.h" +#include "FileWriterBase.h" +#include "FileWriterBaseCallback.h" +#include "Metadata.h" +#include "MetadataCallback.h" +#include "ScriptExecutionContext.h" +#include "VoidCallback.h" + +namespace WebCore { + +FileSystemCallbacksBase::FileSystemCallbacksBase(PassRefPtr errorCallback) + : m_errorCallback(errorCallback) +{ +} + +FileSystemCallbacksBase::~FileSystemCallbacksBase() +{ +} + +void FileSystemCallbacksBase::didSucceed() +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didOpenFileSystem(const String&, PassOwnPtr) +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didReadMetadata(const FileMetadata&) +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didReadDirectoryEntries(bool) +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didReadDirectoryEntry(const String&, bool) +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didCreateFileWriter(PassOwnPtr, long long) +{ + // Each subclass must implement an appropriate one. + ASSERT_NOT_REACHED(); +} + +void FileSystemCallbacksBase::didFail(int code) +{ + if (m_errorCallback) { + m_errorCallback->handleEvent(FileError::create(static_cast(code)).get()); + m_errorCallback.clear(); + } +} + +// EntryCallbacks ------------------------------------------------------------- + +PassOwnPtr EntryCallbacks::create(PassRefPtr successCallback, PassRefPtr errorCallback, PassRefPtr fileSystem, const String& expectedPath, bool isDirectory) +{ + return adoptPtr(new EntryCallbacks(successCallback, errorCallback, fileSystem, expectedPath, isDirectory)); +} + +EntryCallbacks::EntryCallbacks(PassRefPtr successCallback, PassRefPtr errorCallback, PassRefPtr fileSystem, const String& expectedPath, bool isDirectory) + : FileSystemCallbacksBase(errorCallback) + , m_successCallback(successCallback) + , m_fileSystem(fileSystem) + , m_expectedPath(expectedPath) + , m_isDirectory(isDirectory) +{ +} + +void EntryCallbacks::didSucceed() +{ + if (m_successCallback) { + if (m_isDirectory) + m_successCallback->handleEvent(DirectoryEntry::create(m_fileSystem, m_expectedPath).get()); + else + m_successCallback->handleEvent(FileEntry::create(m_fileSystem, m_expectedPath).get()); + } + m_successCallback.clear(); +} + +// EntriesCallbacks ----------------------------------------------------------- + +PassOwnPtr EntriesCallbacks::create(PassRefPtr successCallback, PassRefPtr errorCallback, PassRefPtr directoryReader, const String& basePath) +{ + return adoptPtr(new EntriesCallbacks(successCallback, errorCallback, directoryReader, basePath)); +} + +EntriesCallbacks::EntriesCallbacks(PassRefPtr successCallback, PassRefPtr errorCallback, PassRefPtr directoryReader, const String& basePath) + : FileSystemCallbacksBase(errorCallback) + , m_successCallback(successCallback) + , m_directoryReader(directoryReader) + , m_basePath(basePath) + , m_entries(EntryArray::create()) +{ + ASSERT(m_directoryReader); +} + +void EntriesCallbacks::didReadDirectoryEntry(const String& name, bool isDirectory) +{ + if (isDirectory) + m_entries->append(DirectoryEntry::create(m_directoryReader->filesystem(), DOMFilePath::append(m_basePath, name))); + else + m_entries->append(FileEntry::create(m_directoryReader->filesystem(), DOMFilePath::append(m_basePath, name))); +} + +void EntriesCallbacks::didReadDirectoryEntries(bool hasMore) +{ + m_directoryReader->setHasMoreEntries(hasMore); + if (m_successCallback) + m_successCallback->handleEvent(m_entries.get()); +} + +// FileSystemCallbacks -------------------------------------------------------- + +PassOwnPtr FileSystemCallbacks::create(PassRefPtr successCallback, PassRefPtr errorCallback, ScriptExecutionContext* scriptExecutionContext) +{ + return adoptPtr(new FileSystemCallbacks(successCallback, errorCallback, scriptExecutionContext)); +} + +FileSystemCallbacks::FileSystemCallbacks(PassRefPtr successCallback, PassRefPtr errorCallback, ScriptExecutionContext* context) + : FileSystemCallbacksBase(errorCallback) + , m_successCallback(successCallback) + , m_scriptExecutionContext(context) +{ +} + +void FileSystemCallbacks::didOpenFileSystem(const String& name, PassOwnPtr asyncFileSystem) +{ + if (m_successCallback) { + ASSERT(asyncFileSystem); + m_successCallback->handleEvent(DOMFileSystem::create(m_scriptExecutionContext.get(), name, asyncFileSystem.leakPtr()).get()); + m_scriptExecutionContext.clear(); + } + m_successCallback.clear(); +} + +// MetadataCallbacks ---------------------------------------------------------- + +PassOwnPtr MetadataCallbacks::create(PassRefPtr successCallback, PassRefPtr errorCallback) +{ + return adoptPtr(new MetadataCallbacks(successCallback, errorCallback)); +} + +MetadataCallbacks::MetadataCallbacks(PassRefPtr successCallback, PassRefPtr errorCallback) + : FileSystemCallbacksBase(errorCallback) + , m_successCallback(successCallback) +{ +} + +void MetadataCallbacks::didReadMetadata(const FileMetadata& metadata) +{ + if (m_successCallback) + m_successCallback->handleEvent(Metadata::create(metadata.modificationTime).get()); + m_successCallback.clear(); +} + +// FileWriterBaseCallbacks ---------------------------------------------------------- + +PassOwnPtr FileWriterBaseCallbacks::create(PassRefPtr fileWriter, PassRefPtr successCallback, PassRefPtr errorCallback) +{ + return adoptPtr(new FileWriterBaseCallbacks(fileWriter, successCallback, errorCallback)); +} + +FileWriterBaseCallbacks::FileWriterBaseCallbacks(PassRefPtr fileWriter, PassRefPtr successCallback, PassRefPtr errorCallback) + : FileSystemCallbacksBase(errorCallback) + , m_fileWriter(fileWriter) + , m_successCallback(successCallback) +{ +} + +void FileWriterBaseCallbacks::didCreateFileWriter(PassOwnPtr asyncFileWriter, long long length) +{ + m_fileWriter->initialize(asyncFileWriter, length); + if (m_successCallback) + m_successCallback->handleEvent(m_fileWriter.release().get()); + m_successCallback.clear(); +} + +// VoidCallbacks -------------------------------------------------------------- + +PassOwnPtr VoidCallbacks::create(PassRefPtr successCallback, PassRefPtr errorCallback) +{ + return adoptPtr(new VoidCallbacks(successCallback, errorCallback)); +} + +VoidCallbacks::VoidCallbacks(PassRefPtr successCallback, PassRefPtr errorCallback) + : FileSystemCallbacksBase(errorCallback) + , m_successCallback(successCallback) +{ +} + +void VoidCallbacks::didSucceed() +{ + if (m_successCallback) + m_successCallback->handleEvent(); + m_successCallback.clear(); +} + +} // namespace + +#endif // ENABLE(FILE_SYSTEM) -- cgit v1.1