WebCore/ChangeLog

2010-09-17  Eric Uhrhane  <ericu@chromium.org>

        Reviewed by NOBODY (OOPS!).

        Add Chromium implementation for FileWriter

        https://bugs.webkit.org/show_bug.cgi?id=44361

        No new tests; the implementation's not yet far enough along for that.

        This makes a chain of contruction-and-linking-up for various sorts of

        FileWriter interfaces to call through to Chromium, and for various

        sorts of FileWriterClients to call back, with object ownership always

        pointing towards the Chromium API.  That is, the DOM object owns an

        AsyncFileWriter, which owns its implementation object, and the reverse

        (client) direction is raw pointers.

        File metadata is looked up before the FileWriter is returned, so that

        we know the file exists and can cache its length.

        The WebCore part of this is simple and generic enough to handle

        Chromium, so it should be easy for me to put in a WebCore-only

        implementation next.

        * fileapi/AsyncFileWriter.h:

        * fileapi/DOMFileSystem.cpp:

        (WebCore::DOMFileSystem::createWriter):

        * fileapi/DOMFileSystem.h:

        * fileapi/FileSystemCallbacks.cpp:

        (WebCore::FileSystemCallbacksBase::didCreateFileWriter):

        (WebCore::FileWriterCallbacks::FileWriterCallbacks):

        (WebCore::FileWriterCallbacks::didCreateFileWriter):

        * fileapi/FileSystemCallbacks.h:

        * platform/AsyncFileSystem.h:

        * platform/AsyncFileSystemCallbacks.h:

2010-09-17  Darin Adler  <darin@apple.com>

        Build fix for platforms that compile Touch.

67769

WebCore/fileapi/AsyncFileWriter.h

@@class AsyncFileWriter {

public:

    virtual ~AsyncFileWriter() {}

48 virtual void setFileWriterClient(FileWriterClient* client) = 0;

49

    virtual void write(long long position, Blob* data) = 0;

    virtual void truncate(long long length) = 0;

    virtual void abort() = 0;

67769

WebCore/fileapi/DOMFileSystem.cpp

#include "Entry.h"

#include "EntryCallback.h"

#include "ErrorCallback.h"

43#include "FileEntry.h"

4344#include "FileError.h"

4445#include "FileSystemCallbacks.h"

46#include "FileWriter.h"

47#include "FileWriterCallback.h"

#include "MetadataCallback.h"

#include "ScriptExecutionContext.h"

#include "VoidCallback.h"

@@void DOMFileSystem::getDirectory(const E

        m_asyncFileSystem->directoryExists(platformPath, callbacks.release());

}

void DOMFileSystem::createWriter(const FileEntry* file, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)

{

    ASSERT(file);

    String platformPath = m_asyncFileSystem->virtualToPlatformPath(file->fullPath());

    RefPtr<FileWriter> fileWriter = FileWriter::create(scriptExecutionContext());

    OwnPtr<FileWriterCallbacks> callbacks = adoptPtr(new FileWriterCallbacks(fileWriter, successCallback, errorCallback));

    m_asyncFileSystem->createWriter(fileWriter.get(), platformPath, callbacks.release());

}

void DOMFileSystem::readDirectory(const String& path, PassRefPtr<EntriesCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)

{

    ASSERT(DOMFilePath::isAbsolute(path));

67769

WebCore/fileapi/DOMFileSystem.h

@@class Entry;

class EntryCallback;

class EntriesCallback;

class ErrorCallback;

51class FileEntry;

52class FileWriterCallback;

class MetadataCallback;

class VoidCallback;

@@public:

    void getFile(const Entry* base, const String& path, PassRefPtr<Flags>, PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>);

    void getDirectory(const Entry* base, const String& path, PassRefPtr<Flags>, PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>);

    void readDirectory(const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>);

82 void createWriter(const FileEntry* file, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);

    // Schedule a callback. This should not cross threads (should be called on the same context thread).

    template <typename CB, typename CBArg>

67769

WebCore/fileapi/FileSystemCallbacks.cpp

#if ENABLE(FILE_SYSTEM)

#include "AsyncFileSystem.h"

37#include "AsyncFileWriter.h"

#include "DOMFilePath.h"

#include "DOMFileSystem.h"

#include "DirectoryEntry.h"

#include "FileEntry.h"

#include "FileError.h"

#include "FileSystemCallback.h"

49#include "FileWriter.h"

50#include "FileWriterCallback.h"

#include "Metadata.h"

#include "MetadataCallback.h"

#include "ScriptExecutionContext.h"

@@void FileSystemCallbacksBase::didReadDir

    ASSERT_NOT_REACHED();

}

void FileSystemCallbacksBase::didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long)

{

    // Each subclass must implement an appropriate one.

    ASSERT_NOT_REACHED();

}

void FileSystemCallbacksBase::didFail(int code)

{

    if (m_errorCallback) {

@@void MetadataCallbacks::didReadMetadata(

    m_successCallback.clear();

}

// FileWriterCallbacks ----------------------------------------------------------

FileWriterCallbacks::FileWriterCallbacks(PassRefPtr<FileWriter> fileWriter, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)

    : FileSystemCallbacksBase(errorCallback)

    , m_fileWriter(fileWriter)

    , m_successCallback(successCallback)

{

}

void FileWriterCallbacks::didCreateFileWriter(PassOwnPtr<AsyncFileWriter> asyncFileWriter, long long length)

{

    m_fileWriter->initialize(asyncFileWriter, length);

    if (m_successCallback)

        m_successCallback->handleEvent(m_fileWriter.release().get());

    m_successCallback.clear();

}

// VoidCallbacks --------------------------------------------------------------

VoidCallbacks::VoidCallbacks(PassRefPtr<VoidCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)

67769

WebCore/fileapi/FileSystemCallbacks.h

namespace WebCore {

43class AsyncFileWriter;

class DOMFileSystem;

class ErrorCallback;

class EntriesCallback;

class EntryArray;

class EntryCallback;

class FileSystemCallback;

50class FileWriter;

51class FileWriterCallback;

class MetadataCallback;

class ScriptExecutionContext;

class VoidCallback;

@@public:

    virtual void didReadDirectoryEntry(const String& name, bool isDirectory);

    virtual void didReadDirectoryEntries(bool hasMore);

    // For createFileWriter.

    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length);

    // For ErrorCallback.

    virtual void didFail(int code);

@@private:

    RefPtr<MetadataCallback> m_successCallback;

};

class FileWriterCallbacks : public FileSystemCallbacksBase {

public:

    FileWriterCallbacks(PassRefPtr<FileWriter>, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);

    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length);

private:

    RefPtr<FileWriter> m_fileWriter;

    RefPtr<FileWriterCallback> m_successCallback;

};

class VoidCallbacks : public FileSystemCallbacksBase {

public:

    VoidCallbacks(PassRefPtr<VoidCallback>, PassRefPtr<ErrorCallback>);

67769

WebCore/platform/AsyncFileSystem.h

@@namespace WebCore {

class AsyncFileSystem;

class AsyncFileSystemCallbacks;

44class FileWriterClient;

// This class provides async interface for platform-specific file system implementation.  Note that all the methods take platform paths.

class AsyncFileSystem : public Noncopyable {

@@public:

    // AsyncFileSystemCallbacks::didFail() is when there is an error.

    virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Creates an AsyncFileWriter for a given file path.

    // AsyncFileSystemCallbacks::didCreateFileWriter() is called when an AsyncFileWriter is created successfully.

    // AsyncFileSystemCallbacks::didFail() is called otherwise.

    virtual void createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;

    // Converts a given absolute virtual path to a platform path that starts with the platform root path of this file system.

    virtual String virtualToPlatformPath(const String& path) const;

67769

WebCore/platform/AsyncFileSystemCallbacks.h

namespace WebCore {

class AsyncFileSystem;

41class AsyncFileWriter;

class AsyncFileSystemCallbacks : public Noncopyable {

public:

@@public:

    // Called after a chunk of directory entries have been read (i.e. indicates it's good time to call back to the application).  If hasMore is true there can be more chunks.

    virtual void didReadDirectoryEntries(bool hasMore) = 0;

    // Called when an AsyncFileWrter has been created successfully.

    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter> writer, long long length) = 0;

    // Called when there was an error.

    virtual void didFail(int code) = 0;

67769

WebKit/chromium/ChangeLog

2010-09-17  Eric Uhrhane  <ericu@chromium.org>

        Reviewed by NOBODY (OOPS!).

        Add Chromium implementation for FileWriter

        https://bugs.webkit.org/show_bug.cgi?id=44361

        No new tests; the implementation's not yet far enough along for that.

        This makes a chain of contruction-and-linking-up for various sorts of

        FileWriter interfaces to call through to Chromium, and for various

        sorts of FileWriterClients to call back, with object ownership always

        pointing towards the Chromium API.  That is, the DOM object owns an

        AsyncFileWriter, which owns its implementation object, and the reverse

        (client) direction is raw pointers.

        File metadata is looked up before the FileWriter is returned, so that

        we know the file exists and can cache its length.

        The WebKit/chromium interface here is modeled after that of the

        FileSystem.

        * public/WebFileInfo.h:

        (WebKit::WebFileInfo::WebFileInfo):

        * src/AsyncFileSystemChromium.cpp:

        (WebCore::FileWriterHelperCallbacks::FileWriterHelperCallbacks):

        (WebCore::FileWriterHelperCallbacks::didSucceed):

        (WebCore::FileWriterHelperCallbacks::didReadMetadata):

        (WebCore::FileWriterHelperCallbacks::didReadDirectory):

        (WebCore::FileWriterHelperCallbacks::didOpenFileSystem):

        (WebCore::FileWriterHelperCallbacks::didCreateFileWriter):

        (WebCore::FileWriterHelperCallbacks::didFail):

        (WebCore::AsyncFileSystemChromium::createWriter):

        * src/AsyncFileSystemChromium.h:

        * src/AsyncFileWriterChromium.cpp:

        (WebCore::AsyncFileWriterChromium::setWebFileWriter):

        (WebCore::AsyncFileWriterChromium::write):

        (WebCore::AsyncFileWriterChromium::didFail):

        * src/AsyncFileWriterChromium.h:

        * src/WebFileSystemCallbacksImpl.h:

2010-09-17  Darin Adler  <darin@apple.com>

        Reviewed by Sam Weinig.

67769

WebKit/chromium/public/WebFileInfo.h

@@struct WebFileInfo {

    // The value 0.0 means that the time is not set.

    double modificationTime;

41 WebFileInfo() : modificationTime(0.0) { }

    // The length of the file in bytes.

    // The value -1 means that the length is not set.

    long long length;

    enum EntryType {

        TypeUnknown = 0,

        TypeFile,

        TypeDirectory

    };

    EntryType type;

    WebFileInfo() : modificationTime(0.0), length(-1), type(TypeUnknown) { }

};

} // namespace WebKit

67769

WebKit/chromium/src/AsyncFileSystemChromium.cpp

#if ENABLE(FILE_SYSTEM)

#include "AsyncFileSystemCallbacks.h"

36 #include "FileSystem.h"

36#include "AsyncFileWriterChromium.h"

37#include "WebFileInfo.h"

3738#include "WebFileSystem.h"

3839#include "WebFileSystemCallbacksImpl.h"

40#include "WebFileWriter.h"

#include "WebKit.h"

#include "WebKitClient.h"

@@void AsyncFileSystemChromium::readDirect

    m_webFileSystem->readDirectory(path, new WebKit::WebFileSystemCallbacksImpl(callbacks));

}

class FileWriterHelperCallbacks : public WebKit::WebFileSystemCallbacks {

public:

    FileWriterHelperCallbacks(FileWriterClient* client, const String& path, WebKit::WebFileSystem* webFileSystem, PassOwnPtr<WebCore::AsyncFileSystemCallbacks> callbacks)

        : m_client(client)

        , m_path(path)

        , m_webFileSystem(webFileSystem)

        , m_callbacks(callbacks)

    {

    }

    virtual void didSucceed()

    {

        ASSERT_NOT_REACHED();

        delete this;

    }

    virtual void didReadMetadata(const WebKit::WebFileInfo& info)

    {

        ASSERT(m_callbacks);

        if (info.type != WebKit::WebFileInfo::TypeFile || info.length < 0)

            m_callbacks->didFail(error);

        else {

            OwnPtr<AsyncFileWriterChromium> asyncFileWriterChromium = adoptPtr(new AsyncFileWriterChromium(m_client));

            OwnPtr<WebKit::WebFileWriter> webFileWriter = adoptPtr(m_webFileSystem->createFileWriter(m_path, asyncFileWriterChromium.get()));

            asyncFileWriterChromium->setWebFileWriter(webFileWriter.release());

            m_callbacks->didCreateFileWriter(asyncFileWriterChromium.release(), info.length);

        }

        delete this;

    }

    virtual void didReadDirectory(const WebKit::WebVector<WebKit::WebFileSystemEntry>& entries, bool hasMore)

    {

        ASSERT_NOT_REACHED();

        delete this;

    }

    virtual void didOpenFileSystem(const WebKit::WebString& name, const WebKit::WebString& rootPath)

    {

        ASSERT_NOT_REACHED();

        delete this;

    }

    virtual void didFail(WebKit::WebFileError error)

    {

        ASSERT(m_callbacks);

        m_callbacks->didFail(error);

        delete this;

    }

private:

    FileWriterClient* m_client;

    String m_path;

    WebKit::WebFileSystem* m_webFileSystem;

    OwnPtr<WebCore::AsyncFileSystemCallbacks> m_callbacks;

};

void AsyncFileSystemChromium::createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)

{

    m_webFileSystem->readMetadata(path, new FileWriterHelperCallbacks(client, path, m_webFileSystem, callbacks));

}

} // namespace WebCore

#endif

67769

WebKit/chromium/src/AsyncFileSystemChromium.h

@@public:

    virtual void fileExists(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);

    virtual void directoryExists(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);

    virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);

61 virtual void createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);

private:

    WebKit::WebFileSystem* m_webFileSystem;

67769

WebKit/chromium/src/AsyncFileWriterChromium.cpp

#include "WebFileWriter.h"

#include "WebURL.h"

using namespace WebCore;

namespace WebKit {

41namespace WebCore {

AsyncFileWriterChromium::AsyncFileWriterChromium(FileWriterClient* client)

    : m_client(client)

{

}

50 void AsyncFileWriterChromium::setWebFileWriter(WebFileWriter* writer)

AsyncFileWriterChromium::~AsyncFileWriterChromium()

{

}

void AsyncFileWriterChromium::setWebFileWriter(PassOwnPtr<WebKit::WebFileWriter> writer)

5153{

52 ASSERT(!m_writer);

    m_writer = writer;

}

void AsyncFileWriterChromium::write(long long position, Blob* data)

{

    ASSERT(m_writer);

59 m_writer->write(position, WebURL(data->url()));

60 m_writer->write(position, WebKit::WebURL(data->url()));

}

void AsyncFileWriterChromium::truncate(long long length)

@@void AsyncFileWriterChromium::didTruncat

    m_client->didTruncate(length);

}

85 void AsyncFileWriterChromium::didFail(WebFileError error)

86void AsyncFileWriterChromium::didFail(WebKit::WebFileError error)

{

    m_client->didFail(error);

}

67769

WebKit/chromium/src/AsyncFileWriterChromium.h

#include "AsyncFileWriter.h"

#include "WebFileError.h"

#include "WebFileWriterClient.h"

39#include <WTF/PassOwnPtr.h>

3940

namespace WebCore {

class Blob;

class FileWriterClient;

41namespace WebKit {

42class WebFileWriter;

4343}

4444

45 namespace Web~~Kit~~ {

45namespace WebCore {

4646

47 class WebFileWriter;

47class Blob;

48class FileWriterClient;

4849

49 class AsyncFileWriterChromium : public ~~WebCore::~~AsyncFileWriter, public WebFileWriterClient {

50class AsyncFileWriterChromium : public AsyncFileWriter, public WebKit::WebFileWriterClient {

5051public:

    AsyncFileWriterChromium(WebCore::FileWriterClient* client);

    void setWebFileWriter(WebFileWriter* writer);

    AsyncFileWriterChromium(FileWriterClient* client);

    ~AsyncFileWriterChromium();

    void setWebFileWriter(PassOwnPtr<WebKit::WebFileWriter> writer);

5456

5557 // FileWriter

56 virtual void write(long long position, ~~WebCore::~~Blob* data);

58 virtual void write(long long position, Blob* data);

    virtual void truncate(long long length);

    virtual void abort();

    // WebFileWriterClient

    virtual void didWrite(long long bytes, bool complete);

    virtual void didTruncate(long long length);

63 virtual void didFail(WebFileError);

65 virtual void didFail(WebKit::WebFileError);

6466

6567private:

66 OwnPtr<WebFileWriter> m_writer;

67 ~~WebCore::~~FileWriterClient* m_client;

68 OwnPtr<WebKit::WebFileWriter> m_writer;

69 FileWriterClient* m_client;

};

} // namespace

67769