Changeset 68101 in webkit


Ignore:
Timestamp:
Sep 22, 2010 5:07:46 PM (14 years ago)
Author:
commit-queue@webkit.org
Message:

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

Reviewed by Dumitru Daniliuc.

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-22 Eric Uhrhane <ericu@chromium.org>

Reviewed by Dumitru Daniliuc.

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 construction-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:
Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/ChangeLog

    r68096 r68101  
     12010-09-22  Eric Uhrhane  <ericu@chromium.org>
     2
     3        Reviewed by Dumitru Daniliuc.
     4
     5        Add Chromium implementation for FileWriter
     6        https://bugs.webkit.org/show_bug.cgi?id=44361
     7
     8        No new tests; the implementation's not yet far enough along for that.
     9
     10        This makes a chain of contruction-and-linking-up for various sorts of
     11        FileWriter interfaces to call through to Chromium, and for various
     12        sorts of FileWriterClients to call back, with object ownership always
     13        pointing towards the Chromium API.  That is, the DOM object owns an
     14        AsyncFileWriter, which owns its implementation object, and the reverse
     15        (client) direction is raw pointers.
     16
     17        File metadata is looked up before the FileWriter is returned, so that
     18        we know the file exists and can cache its length.
     19
     20        The WebCore part of this is simple and generic enough to handle
     21        Chromium, so it should be easy for me to put in a WebCore-only
     22        implementation next.
     23       
     24        * fileapi/AsyncFileWriter.h:
     25        * fileapi/DOMFileSystem.cpp:
     26        (WebCore::DOMFileSystem::createWriter):
     27        * fileapi/DOMFileSystem.h:
     28        * fileapi/FileSystemCallbacks.cpp:
     29        (WebCore::FileSystemCallbacksBase::didCreateFileWriter):
     30        (WebCore::FileWriterCallbacks::FileWriterCallbacks):
     31        (WebCore::FileWriterCallbacks::didCreateFileWriter):
     32        * fileapi/FileSystemCallbacks.h:
     33        * platform/AsyncFileSystem.h:
     34        * platform/AsyncFileSystemCallbacks.h:
     35
    1362010-09-22  Alexey Proskuryakov  <ap@apple.com>
    237
  • trunk/WebCore/fileapi/AsyncFileWriter.h

    r67614 r68101  
    4646    virtual ~AsyncFileWriter() {}
    4747
    48     virtual void setFileWriterClient(FileWriterClient* client) = 0;
    49 
    5048    virtual void write(long long position, Blob* data) = 0;
    5149    virtual void truncate(long long length) = 0;
  • trunk/WebCore/fileapi/DOMFileSystem.cpp

    r67147 r68101  
    4141#include "EntryCallback.h"
    4242#include "ErrorCallback.h"
     43#include "FileEntry.h"
    4344#include "FileError.h"
    4445#include "FileSystemCallbacks.h"
     46#include "FileWriter.h"
     47#include "FileWriterCallback.h"
    4548#include "MetadataCallback.h"
    4649#include "ScriptExecutionContext.h"
     
    200203}
    201204
     205void DOMFileSystem::createWriter(const FileEntry* file, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
     206{
     207    ASSERT(file);
     208
     209    String platformPath = m_asyncFileSystem->virtualToPlatformPath(file->fullPath());
     210
     211    RefPtr<FileWriter> fileWriter = FileWriter::create(scriptExecutionContext());
     212    OwnPtr<FileWriterCallbacks> callbacks = adoptPtr(new FileWriterCallbacks(fileWriter, successCallback, errorCallback));
     213    m_asyncFileSystem->createWriter(fileWriter.get(), platformPath, callbacks.release());
     214}
     215
    202216void DOMFileSystem::readDirectory(const String& path, PassRefPtr<EntriesCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
    203217{
  • trunk/WebCore/fileapi/DOMFileSystem.h

    r66586 r68101  
    4949class EntriesCallback;
    5050class ErrorCallback;
     51class FileEntry;
     52class FileWriterCallback;
    5153class MetadataCallback;
    5254class VoidCallback;
     
    7880    void getDirectory(const Entry* base, const String& path, PassRefPtr<Flags>, PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>);
    7981    void readDirectory(const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>);
     82    void createWriter(const FileEntry* file, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);
    8083
    8184    // Schedule a callback. This should not cross threads (should be called on the same context thread).
  • trunk/WebCore/fileapi/FileSystemCallbacks.cpp

    r67220 r68101  
    3535
    3636#include "AsyncFileSystem.h"
     37#include "AsyncFileWriter.h"
    3738#include "DOMFilePath.h"
    3839#include "DOMFileSystem.h"
     
    4647#include "FileError.h"
    4748#include "FileSystemCallback.h"
     49#include "FileWriter.h"
     50#include "FileWriterCallback.h"
    4851#include "Metadata.h"
    4952#include "MetadataCallback.h"
     
    8790
    8891void FileSystemCallbacksBase::didReadDirectoryEntry(const String&, bool)
     92{
     93    // Each subclass must implement an appropriate one.
     94    ASSERT_NOT_REACHED();
     95}
     96
     97void FileSystemCallbacksBase::didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long)
    8998{
    9099    // Each subclass must implement an appropriate one.
     
    188197}
    189198
     199// FileWriterCallbacks ----------------------------------------------------------
     200
     201FileWriterCallbacks::FileWriterCallbacks(PassRefPtr<FileWriter> fileWriter, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
     202    : FileSystemCallbacksBase(errorCallback)
     203    , m_fileWriter(fileWriter)
     204    , m_successCallback(successCallback)
     205{
     206}
     207
     208void FileWriterCallbacks::didCreateFileWriter(PassOwnPtr<AsyncFileWriter> asyncFileWriter, long long length)
     209{
     210    m_fileWriter->initialize(asyncFileWriter, length);
     211    if (m_successCallback)
     212        m_successCallback->handleEvent(m_fileWriter.release().get());
     213    m_successCallback.clear();
     214}
     215
    190216// VoidCallbacks --------------------------------------------------------------
    191217
  • trunk/WebCore/fileapi/FileSystemCallbacks.h

    r66586 r68101  
    4141namespace WebCore {
    4242
     43class AsyncFileWriter;
    4344class DOMFileSystem;
    4445class ErrorCallback;
     
    4748class EntryCallback;
    4849class FileSystemCallback;
     50class FileWriter;
     51class FileWriterCallback;
    4952class MetadataCallback;
    5053class ScriptExecutionContext;
     
    6770    virtual void didReadDirectoryEntry(const String& name, bool isDirectory);
    6871    virtual void didReadDirectoryEntries(bool hasMore);
     72
     73    // For createFileWriter.
     74    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length);
    6975
    7076    // For ErrorCallback.
     
    122128};
    123129
     130class FileWriterCallbacks : public FileSystemCallbacksBase {
     131public:
     132    FileWriterCallbacks(PassRefPtr<FileWriter>, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);
     133    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length);
     134
     135private:
     136    RefPtr<FileWriter> m_fileWriter;
     137    RefPtr<FileWriterCallback> m_successCallback;
     138};
     139
    124140class VoidCallbacks : public FileSystemCallbacksBase {
    125141public:
  • trunk/WebCore/platform/AsyncFileSystem.h

    r66407 r68101  
    4242class AsyncFileSystem;
    4343class AsyncFileSystemCallbacks;
     44class FileWriterClient;
    4445
    4546// This class provides async interface for platform-specific file system implementation.  Note that all the methods take platform paths.
     
    108109    virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;
    109110
     111    // Creates an AsyncFileWriter for a given file path.
     112    // AsyncFileSystemCallbacks::didCreateFileWriter() is called when an AsyncFileWriter is created successfully.
     113    // AsyncFileSystemCallbacks::didFail() is called otherwise.
     114    virtual void createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0;
     115
    110116    // Converts a given absolute virtual path to a platform path that starts with the platform root path of this file system.
    111117    virtual String virtualToPlatformPath(const String& path) const;
  • trunk/WebCore/platform/AsyncFileSystemCallbacks.h

    r66255 r68101  
    3939
    4040class AsyncFileSystem;
     41class AsyncFileWriter;
    4142
    4243class AsyncFileSystemCallbacks : public Noncopyable {
     
    5758    virtual void didReadDirectoryEntries(bool hasMore) = 0;
    5859
     60    // Called when an AsyncFileWrter has been created successfully.
     61    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter> writer, long long length) = 0;
     62
    5963    // Called when there was an error.
    6064    virtual void didFail(int code) = 0;
  • trunk/WebKit/chromium/ChangeLog

    r68068 r68101  
     12010-09-22  Eric Uhrhane  <ericu@chromium.org>
     2
     3        Reviewed by Dumitru Daniliuc.
     4
     5        Add Chromium implementation for FileWriter
     6        https://bugs.webkit.org/show_bug.cgi?id=44361
     7
     8        No new tests; the implementation's not yet far enough along for that.
     9
     10        This makes a chain of construction-and-linking-up for various sorts of
     11        FileWriter interfaces to call through to Chromium, and for various
     12        sorts of FileWriterClients to call back, with object ownership always
     13        pointing towards the Chromium API.  That is, the DOM object owns an
     14        AsyncFileWriter, which owns its implementation object, and the reverse
     15        (client) direction is raw pointers.
     16
     17        File metadata is looked up before the FileWriter is returned, so that
     18        we know the file exists and can cache its length.
     19
     20        The WebKit/chromium interface here is modeled after that of the
     21        FileSystem.
     22       
     23        * public/WebFileInfo.h:
     24        (WebKit::WebFileInfo::WebFileInfo):
     25        * src/AsyncFileSystemChromium.cpp:
     26        (WebCore::FileWriterHelperCallbacks::FileWriterHelperCallbacks):
     27        (WebCore::FileWriterHelperCallbacks::didSucceed):
     28        (WebCore::FileWriterHelperCallbacks::didReadMetadata):
     29        (WebCore::FileWriterHelperCallbacks::didReadDirectory):
     30        (WebCore::FileWriterHelperCallbacks::didOpenFileSystem):
     31        (WebCore::FileWriterHelperCallbacks::didCreateFileWriter):
     32        (WebCore::FileWriterHelperCallbacks::didFail):
     33        (WebCore::AsyncFileSystemChromium::createWriter):
     34        * src/AsyncFileSystemChromium.h:
     35        * src/AsyncFileWriterChromium.cpp:
     36        (WebCore::AsyncFileWriterChromium::setWebFileWriter):
     37        (WebCore::AsyncFileWriterChromium::write):
     38        (WebCore::AsyncFileWriterChromium::didFail):
     39        * src/AsyncFileWriterChromium.h:
     40        * src/WebFileSystemCallbacksImpl.h:
     41
    1422010-09-22  Kenneth Russell  <kbr@google.com>
    243
  • trunk/WebKit/chromium/public/WebFileInfo.h

    r54565 r68101  
    3939    double modificationTime;
    4040
    41     WebFileInfo() : modificationTime(0.0) { }
     41    // The length of the file in bytes.
     42    // The value -1 means that the length is not set.
     43    long long length;
     44
     45    enum Type {
     46        TypeUnknown = 0,
     47        TypeFile,
     48        TypeDirectory
     49    };
     50
     51    Type type;
     52
     53    WebFileInfo() : modificationTime(0.0), length(-1), type(TypeUnknown) { }
    4254};
    4355
  • trunk/WebKit/chromium/src/AsyncFileSystemChromium.cpp

    r66407 r68101  
    3434
    3535#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"
    3941#include "WebKit.h"
    4042#include "WebKitClient.h"
     
    100102}
    101103
     104class FileWriterHelperCallbacks : public WebKit::WebFileSystemCallbacks {
     105public:
     106    FileWriterHelperCallbacks(FileWriterClient* client, const String& path, WebKit::WebFileSystem* webFileSystem, PassOwnPtr<WebCore::AsyncFileSystemCallbacks> callbacks)
     107        : m_client(client)
     108        , m_path(path)
     109        , m_webFileSystem(webFileSystem)
     110        , m_callbacks(callbacks)
     111    {
     112    }
     113
     114    virtual void didSucceed()
     115    {
     116        ASSERT_NOT_REACHED();
     117        delete this;
     118    }
     119    virtual void didReadMetadata(const WebKit::WebFileInfo& info)
     120    {
     121        ASSERT(m_callbacks);
     122        if (info.type != WebKit::WebFileInfo::TypeFile || info.length < 0)
     123            m_callbacks->didFail(WebKit::WebFileErrorInvalidState);
     124        else {
     125            OwnPtr<AsyncFileWriterChromium> asyncFileWriterChromium = adoptPtr(new AsyncFileWriterChromium(m_client));
     126            OwnPtr<WebKit::WebFileWriter> webFileWriter = adoptPtr(m_webFileSystem->createFileWriter(m_path, asyncFileWriterChromium.get()));
     127            asyncFileWriterChromium->setWebFileWriter(webFileWriter.release());
     128            m_callbacks->didCreateFileWriter(asyncFileWriterChromium.release(), info.length);
     129        }
     130        delete this;
     131    }
     132
     133    virtual void didReadDirectory(const WebKit::WebVector<WebKit::WebFileSystemEntry>& entries, bool hasMore)
     134    {
     135        ASSERT_NOT_REACHED();
     136        delete this;
     137    }
     138    virtual void didOpenFileSystem(const WebKit::WebString& name, const WebKit::WebString& rootPath)
     139    {
     140        ASSERT_NOT_REACHED();
     141        delete this;
     142    }
     143
     144    virtual void didFail(WebKit::WebFileError error)
     145    {
     146        ASSERT(m_callbacks);
     147        m_callbacks->didFail(error);
     148        delete this;
     149    }
     150
     151private:
     152    FileWriterClient* m_client;
     153    String m_path;
     154    WebKit::WebFileSystem* m_webFileSystem;
     155    OwnPtr<WebCore::AsyncFileSystemCallbacks> m_callbacks;
     156};
     157
     158void AsyncFileSystemChromium::createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks> callbacks)
     159{
     160    m_webFileSystem->readMetadata(path, new FileWriterHelperCallbacks(client, path, m_webFileSystem, callbacks));
     161}
     162
    102163} // namespace WebCore
    103164
  • trunk/WebKit/chromium/src/AsyncFileSystemChromium.h

    r66280 r68101  
    5959    virtual void directoryExists(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    6060    virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);
     61    virtual void createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks>);
    6162
    6263private:
  • trunk/WebKit/chromium/src/AsyncFileWriterChromium.cpp

    r67614 r68101  
    3939#include "WebURL.h"
    4040
    41 using namespace WebCore;
    42 
    43 namespace WebKit {
     41namespace WebCore {
    4442
    4543AsyncFileWriterChromium::AsyncFileWriterChromium(FileWriterClient* client)
     
    4846}
    4947
    50 void AsyncFileWriterChromium::setWebFileWriter(WebFileWriter* writer)
     48AsyncFileWriterChromium::~AsyncFileWriterChromium()
    5149{
    52     ASSERT(!m_writer);
     50}
     51
     52void AsyncFileWriterChromium::setWebFileWriter(PassOwnPtr<WebKit::WebFileWriter> writer)
     53{
    5354    m_writer = writer;
    5455}
     
    5758{
    5859    ASSERT(m_writer);
    59     m_writer->write(position, WebURL(data->url()));
     60    m_writer->write(position, WebKit::WebURL(data->url()));
    6061}
    6162
     
    8384}
    8485
    85 void AsyncFileWriterChromium::didFail(WebFileError error)
     86void AsyncFileWriterChromium::didFail(WebKit::WebFileError error)
    8687{
    8788    m_client->didFail(error);
  • trunk/WebKit/chromium/src/AsyncFileWriterChromium.h

    r67740 r68101  
    3737#include "WebFileError.h"
    3838#include "WebFileWriterClient.h"
     39#include <WTF/PassOwnPtr.h>
     40
     41namespace WebKit {
     42class WebFileWriter;
     43}
    3944
    4045namespace WebCore {
     46
    4147class Blob;
    4248class FileWriterClient;
    43 }
    4449
    45 namespace WebKit {
    46 
    47 class WebFileWriter;
    48 
    49 class AsyncFileWriterChromium : public WebCore::AsyncFileWriter, public WebFileWriterClient {
     50class AsyncFileWriterChromium : public AsyncFileWriter, public WebKit::WebFileWriterClient {
    5051public:
    51     AsyncFileWriterChromium(WebCore::FileWriterClient* client);
    52 
    53     void setWebFileWriter(WebFileWriter* writer);
     52    AsyncFileWriterChromium(FileWriterClient* client);
     53    ~AsyncFileWriterChromium();
     54   
     55    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);
    5759    virtual void truncate(long long length);
    5860    virtual void abort();
     
    6163    virtual void didWrite(long long bytes, bool complete);
    6264    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;
    6870};
    6971
Note: See TracChangeset for help on using the changeset viewer.