Changeset 72715 in webkit


Ignore:
Timestamp:
Nov 24, 2010 6:44:12 PM (13 years ago)
Author:
commit-queue@webkit.org
Message:

2010-11-24 Eric Uhrhane <​ericu@chromium.org>

Reviewed by David Levin.

Implement FileWriterSync
​https://bugs.webkit.org/show_bug.cgi?id=49939

Tests to follow in a separate CL, once the test framework in 47680 goes in.

Build file changes to add FileWriterBase and FileWriterBaseCallback.

  • CMakeLists.txt:
  • GNUmakefile.am:
  • WebCore.gypi:
  • WebCore.pro:
  • WebCore.vcproj/WebCore.vcproj:
  • WebCore.xcodeproj/project.pbxproj:

FileWriterSync doesn't turn out to need to be an ActiveDOMObject.

  • bindings/scripts/CodeGeneratorV8.pm:

Added new AsyncFileWriter::waitForOperationToComplete to enable
synchronous calls.

  • fileapi/AsyncFileWriter.h:

Added a way to get a FileSystemSync.

  • fileapi/DOMFileSystemSync.cpp:
  • fileapi/FileEntrySync.cpp:
  • fileapi/FileEntrySync.h:
  • fileapi/FileEntrySync.idl:

Added an error code for OK, rather than just having 0 everywhere.

  • fileapi/FileError.h:

Turned FileWriterCallback into FileWriterBaseCallback.

  • fileapi/FileSystemCallbacks.cpp:
  • fileapi/FileSystemCallbacks.h:

Refactored out a common base class, FileWriterBase, for FileWriter and
FileWriterSync.

  • fileapi/FileWriter.cpp:
  • fileapi/FileWriter.h:
  • fileapi/FileWriterBase.cpp: Added.
  • fileapi/FileWriterBase.h: Added.
  • fileapi/FileWriterBaseCallback.h: Added.
  • fileapi/FileWriterSync.cpp:
  • fileapi/FileWriterSync.h:

Small tweaks to deal with the base class refactoring.

  • fileapi/DOMFileSystem.cpp:
  • fileapi/DOMFileSystemSync.h:

Removed "CallWith=ScriptExecutionContext", as FileWriterSync doesn't actually need it.

  • fileapi/FileWriterSync.idl:
Location:
trunk/WebCore
Files:
23 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/CMakeLists.txt

    r72591 r72715  
    16961696        fileapi/FileSystemCallbacks.cpp
    16971697        fileapi/FileWriter.cpp
     1698        fileapi/FileWriterBase.cpp
    16981699        fileapi/FileWriterSync.cpp
    16991700        fileapi/LocalFileSystem.cpp

  • trunk/WebCore/ChangeLog

    r72713 r72715  
     12010-11-24  Eric Uhrhane  <ericu@chromium.org>
     2
     3        Reviewed by David Levin.
     4
     5        Implement FileWriterSync
     6        https://bugs.webkit.org/show_bug.cgi?id=49939
     7
     8        Tests to follow in a separate CL, once the test framework in 47680 goes in.
     9
     10        Build file changes to add FileWriterBase and FileWriterBaseCallback.
     11        * CMakeLists.txt:
     12        * GNUmakefile.am:
     13        * WebCore.gypi:
     14        * WebCore.pro:
     15        * WebCore.vcproj/WebCore.vcproj:
     16        * WebCore.xcodeproj/project.pbxproj:
     17
     18        FileWriterSync doesn't turn out to need to be an ActiveDOMObject.
     19        * bindings/scripts/CodeGeneratorV8.pm:
     20
     21        Added new AsyncFileWriter::waitForOperationToComplete to enable
     22        synchronous calls.
     23        * fileapi/AsyncFileWriter.h:
     24
     25        Added a way to get a FileSystemSync.
     26        * fileapi/DOMFileSystemSync.cpp:
     27        * fileapi/FileEntrySync.cpp:
     28        * fileapi/FileEntrySync.h:
     29        * fileapi/FileEntrySync.idl:
     30
     31        Added an error code for OK, rather than just having 0 everywhere.
     32        * fileapi/FileError.h:
     33
     34        Turned FileWriterCallback into FileWriterBaseCallback.
     35        * fileapi/FileSystemCallbacks.cpp:
     36        * fileapi/FileSystemCallbacks.h:
     37
     38        Refactored out a common base class, FileWriterBase, for FileWriter and
     39        FileWriterSync.
     40        * fileapi/FileWriter.cpp:
     41        * fileapi/FileWriter.h:
     42        * fileapi/FileWriterBase.cpp: Added.
     43        * fileapi/FileWriterBase.h: Added.
     44        * fileapi/FileWriterBaseCallback.h: Added.
     45        * fileapi/FileWriterSync.cpp:
     46        * fileapi/FileWriterSync.h:
     47
     48        Small tweaks to deal with the base class refactoring.
     49        * fileapi/DOMFileSystem.cpp:
     50        * fileapi/DOMFileSystemSync.h:
     51
     52        Removed "CallWith=ScriptExecutionContext", as FileWriterSync doesn't actually need it.
     53        * fileapi/FileWriterSync.idl:
     54
    1552010-11-24  Martin Robinson  <mrobinson@igalia.com>
    256

  • trunk/WebCore/GNUmakefile.am

    r72713 r72715  
    14671467        WebCore/fileapi/FileThread.h \
    14681468        WebCore/fileapi/FileThreadTask.h \
    1469         WebCore/fileapi/FileWriterCallback.h \
    14701469        WebCore/fileapi/FileWriter.cpp \
    14711470        WebCore/fileapi/FileWriter.h \
     1471        WebCore/fileapi/FileWriterBase.cpp \
     1472        WebCore/fileapi/FileWriterBase.h \
     1473        WebCore/fileapi/FileWriterBaseCallback.h \
     1474        WebCore/fileapi/FileWriterCallback.h \
    14721475        WebCore/fileapi/FileWriterSync.cpp \
    14731476        WebCore/fileapi/FileWriterSync.h \

  • trunk/WebCore/WebCore.gypi

    r72701 r72715  
    15361536            'fileapi/FileWriter.cpp',
    15371537            'fileapi/FileWriter.h',
     1538            'fileapi/FileWriterBase.cpp',
     1539            'fileapi/FileWriterBase.h',
     1540            'fileapi/FileWriterBaseCallback.h',
    15381541            'fileapi/FileWriterCallback.h',
    15391542            'fileapi/FileWriterSync.cpp',

  • trunk/WebCore/WebCore.pro

    r72591 r72715  
    30663066        fileapi/FileSystemCallbacks.h \
    30673067        fileapi/FileWriter.h \
     3068        fileapi/FileWriterBase.h \
     3069        fileapi/FileWriterBaseCallback.h \
    30683070        fileapi/FileWriterCallback.h \
    30693071        fileapi/FileWriterClient.h \
    … …  
    30983100        fileapi/FileSystemCallbacks.cpp \
    30993101        fileapi/FileWriter.cpp \
     3102        fileapi/FileWriterBase.cpp \
    31003103        fileapi/FileWriterSync.cpp \
    31013104        fileapi/LocalFileSystem.cpp \

  • trunk/WebCore/WebCore.vcproj/WebCore.vcproj

    r72657 r72715  
    4914849148                        </File>
    4914949149                        <File
     49150                                RelativePath="..\fileapi\FileWriterBase.cpp"
     49151                                >
     49152                        </File>
     49153                        <File
     49154                                RelativePath="..\fileapi\FileWriterBase.h"
     49155                                >
     49156                        <File
     49157                                RelativePath="..\fileapi\FileWriterBaseCallback.h"
     49158                                >
     49159                        </File>
     49160                        <File
    4915049161                                RelativePath="..\fileapi\FileWriterCallback.h"
    4915149162                                >

  • trunk/WebCore/WebCore.xcodeproj/project.pbxproj

    r72591 r72715  
    976976                46700ED1127B96CB00F5D5D6 /* FileWriterSync.h in Headers */ = {isa = PBXBuildFile; fileRef = 46700ECF127B96CB00F5D5D6 /* FileWriterSync.h */; };
    977977                4689F1AF1267BAE100E8D380 /* FileMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = 4689F1AE1267BAE100E8D380 /* FileMetadata.h */; };
     978                46BC724E129B104C0071C07E /* FileWriterBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 46BC724B129B104C0071C07E /* FileWriterBase.cpp */; };
     979                46BC724F129B104C0071C07E /* FileWriterBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 46BC724C129B104C0071C07E /* FileWriterBase.h */; };
     980                46BC7250129B104C0071C07E /* FileWriterBaseCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 46BC724D129B104C0071C07E /* FileWriterBaseCallback.h */; };
    978981                46BD16E30B279473001F0839 /* noneCursor.png in Resources */ = {isa = PBXBuildFile; fileRef = 46BD16E20B279473001F0839 /* noneCursor.png */; };
    979982                46D4F2490AF97E810035385A /* cellCursor.png in Resources */ = {isa = PBXBuildFile; fileRef = 46D4F2460AF97E810035385A /* cellCursor.png */; };
    … …  
    70807083                46700ECF127B96CB00F5D5D6 /* FileWriterSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileWriterSync.h; path = fileapi/FileWriterSync.h; sourceTree = "<group>"; };
    70817084                4689F1AE1267BAE100E8D380 /* FileMetadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileMetadata.h; path = platform/FileMetadata.h; sourceTree = "<group>"; };
     7085                46BC724B129B104C0071C07E /* FileWriterBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileWriterBase.cpp; path = fileapi/FileWriterBase.cpp; sourceTree = "<group>"; };
     7086                46BC724C129B104C0071C07E /* FileWriterBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileWriterBase.h; path = fileapi/FileWriterBase.h; sourceTree = "<group>"; };
     7087                46BC724D129B104C0071C07E /* FileWriterBaseCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileWriterBaseCallback.h; path = fileapi/FileWriterBaseCallback.h; sourceTree = "<group>"; };
    70827088                46BD16E20B279473001F0839 /* noneCursor.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = noneCursor.png; sourceTree = "<group>"; };
    70837089                46D4F2460AF97E810035385A /* cellCursor.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = cellCursor.png; sourceTree = "<group>"; };
    … …  
    1515715163                                976D6C71122B8A3D001FD1F7 /* FileWriter.cpp */,
    1515815164                                976D6C72122B8A3D001FD1F7 /* FileWriter.h */,
     15165                                46BC724B129B104C0071C07E /* FileWriterBase.cpp */,
     15166                                46BC724C129B104C0071C07E /* FileWriterBase.h */,
     15167                                46BC724D129B104C0071C07E /* FileWriterBaseCallback.h */,
    1515915168                                893C47A61238908B002B3D86 /* FileWriterCallback.h */,
    1516015169                                46700ECE127B96CB00F5D5D6 /* FileWriterSync.cpp */,
    … …  
    2137821387                                97DD4D870FDF4D6E00ECF9A4 /* XSSAuditor.h in Headers */,
    2137921388                                BCB92D4F1293550B00C8387F /* FontBaseline.h in Headers */,
     21389                                46BC724F129B104C0071C07E /* FileWriterBase.h in Headers */,
     21390                                46BC7250129B104C0071C07E /* FileWriterBaseCallback.h in Headers */,
    2138021391                                BCA257151293C010007A263D /* VerticalPositionCache.h in Headers */,
    2138121392                                BCAE1FA712939DB7004CB026 /* ScrollAnimatorMac.h in Headers */,
    … …  
    2396723978                                75415D57129AB2D2003AD669 /* JSSpeechInputResult.cpp in Sources */,
    2396823979                                75415D59129AB2D2003AD669 /* JSSpeechInputResultList.cpp in Sources */,
     23980                                46BC724E129B104C0071C07E /* FileWriterBase.cpp in Sources */,
    2396923981                        );
    2397023982                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/WebCore/bindings/scripts/CodeGeneratorV8.pm

    r72552 r72715  
    25592559    return 1 if $type eq "FileReader";
    25602560    return 1 if $type eq "FileWriter";
    2561     return 1 if $type eq "FileWriterSync";
    25622561    return 0;
    25632562}

  • trunk/WebCore/fileapi/AsyncFileWriter.h

    r68180 r72715  
    4848    virtual void truncate(long long length) = 0;
    4949    virtual void abort() = 0;
     50    virtual bool waitForOperationToComplete() // Needed for FileWriterSync only.
     51    {
     52        return false;
     53    }
    5054};
    5155

  • trunk/WebCore/fileapi/DOMFileSystem.cpp

    r69907 r72715  
    4242#include "FileSystemCallbacks.h"
    4343#include "FileWriter.h"
     44#include "FileWriterBaseCallback.h"
    4445#include "FileWriterCallback.h"
    4546#include "MetadataCallback.h"
    … …  
    7677}
    7778
     79namespace {
     80
     81class ConvertToFileWriterCallback : public FileWriterBaseCallback {
     82public:
     83    static PassRefPtr<ConvertToFileWriterCallback> create(PassRefPtr<FileWriterCallback> callback)
     84    {
     85        return adoptRef(new ConvertToFileWriterCallback(callback));
     86    }
     87
     88    bool handleEvent(FileWriterBase* fileWriterBase)
     89    {
     90        return m_callback->handleEvent(static_cast<FileWriter*>(fileWriterBase));
     91    }
     92private:
     93    ConvertToFileWriterCallback(PassRefPtr<FileWriterCallback> callback)
     94        : m_callback(callback)
     95    {
     96    }
     97    RefPtr<FileWriterCallback> m_callback;
     98};
     99
     100}
     101
    78102void DOMFileSystem::createWriter(const FileEntry* fileEntry, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
    79103{
    … …  
    83107
    84108    RefPtr<FileWriter> fileWriter = FileWriter::create(scriptExecutionContext());
    85     OwnPtr<FileWriterCallbacks> callbacks = FileWriterCallbacks::create(fileWriter, successCallback, errorCallback);
     109    RefPtr<FileWriterBaseCallback> conversionCallback = ConvertToFileWriterCallback::create(successCallback);
     110    OwnPtr<FileWriterBaseCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, conversionCallback, errorCallback);
    86111    m_asyncFileSystem->createWriter(fileWriter.get(), platformPath, callbacks.release());
    87112}

  • trunk/WebCore/fileapi/DOMFileSystemSync.cpp

    r69907 r72715  
    3636#include "DOMFilePath.h"
    3737#include "DirectoryEntrySync.h"
     38#include "ErrorCallback.h"
    3839#include "File.h"
    3940#include "FileEntrySync.h"
     41#include "FileError.h"
     42#include "FileException.h"
     43#include "FileSystemCallbacks.h"
     44#include "FileWriterBaseCallback.h"
     45#include "FileWriterSync.h"
    4046
    4147namespace WebCore {
     48
     49class FileWriterBase;
    4250
    4351PassRefPtr<DOMFileSystemSync> DOMFileSystemSync::create(DOMFileSystemBase* fileSystem)
    … …  
    6775}
    6876
     77namespace {
     78
     79class ReceiveFileWriterCallback : public FileWriterBaseCallback {
     80public:
     81    static PassRefPtr<ReceiveFileWriterCallback> create()
     82    {
     83        return adoptRef(new ReceiveFileWriterCallback());
     84    }
     85
     86    bool handleEvent(FileWriterBase* fileWriterBase)
     87    {
     88#ifndef NDEBUG
     89        m_fileWriterBase = fileWriterBase;
     90#else
     91        ASSERT_UNUSED(fileWriterBase, fileWriterBase);
     92#endif
     93        return true;
     94    }
     95
     96#ifndef NDEBUG
     97    FileWriterBase* fileWriterBase()
     98    {
     99        return m_fileWriterBase;
     100    }
     101#endif
     102
     103private:
     104    ReceiveFileWriterCallback()
     105#ifndef NDEBUG
     106        : m_fileWriterBase(0)
     107#endif
     108    {
     109    }
     110
     111#ifndef NDEBUG
     112    FileWriterBase* m_fileWriterBase;
     113#endif
     114};
     115
     116class LocalErrorCallback : public ErrorCallback {
     117public:
     118    static PassRefPtr<LocalErrorCallback> create()
     119    {
     120        return adoptRef(new LocalErrorCallback());
     121    }
     122
     123    bool handleEvent(FileError* error)
     124    {
     125        m_error = error;
     126        return true;
     127    }
     128
     129    FileError* error()
     130    {
     131        return m_error.get();
     132    }
     133
     134private:
     135    LocalErrorCallback()
     136    {
     137    }
     138    RefPtr<FileError> m_error;
     139};
     140
     141}
     142
     143PassRefPtr<FileWriterSync> DOMFileSystemSync::createWriter(const FileEntrySync* fileEntry, ExceptionCode& ec)
     144{
     145    ASSERT(fileEntry);
     146    ec = 0;
     147
     148    String platformPath = m_asyncFileSystem->virtualToPlatformPath(fileEntry->fullPath());
     149
     150    RefPtr<FileWriterSync> fileWriter = FileWriterSync::create();
     151    RefPtr<ReceiveFileWriterCallback> successCallback = ReceiveFileWriterCallback::create();
     152    RefPtr<LocalErrorCallback> errorCallback = LocalErrorCallback::create();
     153
     154    OwnPtr<FileWriterBaseCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, successCallback, errorCallback);
     155    m_asyncFileSystem->createWriter(fileWriter.get(), platformPath, callbacks.release());
     156    if (!m_asyncFileSystem->waitForOperationToComplete()) {
     157        ec = FileException::ABORT_ERR;
     158        return 0;
     159    }
     160    if (errorCallback->error()) {
     161        ASSERT(!successCallback->fileWriterBase());
     162        ec = FileException::ErrorCodeToExceptionCode(errorCallback->error()->code());
     163        return 0;
     164    }
     165    ASSERT(successCallback->fileWriterBase());
     166    ASSERT(static_cast<FileWriterSync*>(successCallback->fileWriterBase()) == fileWriter.get());
     167    return fileWriter;
     168}
     169
    69170}
    70171

  • trunk/WebCore/fileapi/DOMFileSystemSync.h

    r69907 r72715  
    4141class File;
    4242class FileEntrySync;
     43class FileWriterSync;
    4344
    4445typedef int ExceptionCode;
    … …  
    5859
    5960    PassRefPtr<File> createFile(const FileEntrySync*, ExceptionCode&);
     61    PassRefPtr<FileWriterSync> createWriter(const FileEntrySync*, ExceptionCode&);
    6062
    6163private:

  • trunk/WebCore/fileapi/FileEntrySync.cpp

    r70741 r72715  
    3535
    3636#include "File.h"
     37#include "FileWriterSync.h"
    3738
    3839namespace WebCore {
    … …  
    4849}
    4950
     51PassRefPtr<FileWriterSync> FileEntrySync::createWriter(ExceptionCode& ec)
     52{
     53    return filesystem()->createWriter(this, ec);
     54}
     55
    5056}
    5157

  • trunk/WebCore/fileapi/FileEntrySync.h

    r70741 r72715  
    4242
    4343class File;
     44class FileWriterSync;
    4445
    4546class FileEntrySync : public EntrySync {
    … …  
    5354
    5455    PassRefPtr<File> file(ExceptionCode&);
     56    PassRefPtr<FileWriterSync> createWriter(ExceptionCode&);
    5557
    5658private:

  • trunk/WebCore/fileapi/FileEntrySync.idl

    r69907 r72715  
    3737    ] FileEntrySync : EntrySync {
    3838        File file() raises (FileException);
     39        FileWriterSync createWriter() raises (FileException);
    3940    };
    4041}

  • trunk/WebCore/fileapi/FileError.h

    r70438 r72715  
    4242public:
    4343    enum ErrorCode {
     44        OK = 0,
    4445        NOT_FOUND_ERR = 1,
    4546        SECURITY_ERR = 2,

  • trunk/WebCore/fileapi/FileSystemCallbacks.cpp

    r70745 r72715  
    4848#include "FileMetadata.h"
    4949#include "FileSystemCallback.h"
    50 #include "FileWriter.h"
    51 #include "FileWriterCallback.h"
     50#include "FileWriterBase.h"
     51#include "FileWriterBaseCallback.h"
    5252#include "Metadata.h"
    5353#include "MetadataCallback.h"
    … …  
    213213}
    214214
    215 // FileWriterCallbacks ----------------------------------------------------------
    216 
    217 PassOwnPtr<FileWriterCallbacks> FileWriterCallbacks::create(PassRefPtr<FileWriter> fileWriter, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
    218 {
    219     return adoptPtr(new FileWriterCallbacks(fileWriter, successCallback, errorCallback));
    220 }
    221 
    222 FileWriterCallbacks::FileWriterCallbacks(PassRefPtr<FileWriter> fileWriter, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
     215// FileWriterBaseCallbacks ----------------------------------------------------------
     216
     217PassOwnPtr<FileWriterBaseCallbacks> FileWriterBaseCallbacks::create(PassRefPtr<FileWriterBase> fileWriter, PassRefPtr<FileWriterBaseCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
     218{
     219    return adoptPtr(new FileWriterBaseCallbacks(fileWriter, successCallback, errorCallback));
     220}
     221
     222FileWriterBaseCallbacks::FileWriterBaseCallbacks(PassRefPtr<FileWriterBase> fileWriter, PassRefPtr<FileWriterBaseCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback)
    223223    : FileSystemCallbacksBase(errorCallback)
    224224    , m_fileWriter(fileWriter)
    … …  
    227227}
    228228
    229 void FileWriterCallbacks::didCreateFileWriter(PassOwnPtr<AsyncFileWriter> asyncFileWriter, long long length)
     229void FileWriterBaseCallbacks::didCreateFileWriter(PassOwnPtr<AsyncFileWriter> asyncFileWriter, long long length)
    230230{
    231231    m_fileWriter->initialize(asyncFileWriter, length);

  • trunk/WebCore/fileapi/FileSystemCallbacks.h

    r70775 r72715  
    5050struct FileMetadata;
    5151class FileSystemCallback;
    52 class FileWriter;
    53 class FileWriterCallback;
     52class FileWriterBase;
     53class FileWriterBaseCallback;
    5454class MetadataCallback;
    5555class ScriptExecutionContext;
    … …  
    134134};
    135135
    136 class FileWriterCallbacks : public FileSystemCallbacksBase {
     136class FileWriterBaseCallbacks : public FileSystemCallbacksBase {
    137137public:
    138     static PassOwnPtr<FileWriterCallbacks> create(PassRefPtr<FileWriter>, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);
     138    static PassOwnPtr<FileWriterBaseCallbacks> create(PassRefPtr<FileWriterBase>, PassRefPtr<FileWriterBaseCallback>, PassRefPtr<ErrorCallback>);
    139139    virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length);
    140140
    141141private:
    142     FileWriterCallbacks(PassRefPtr<FileWriter>, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>);
    143     RefPtr<FileWriter> m_fileWriter;
    144     RefPtr<FileWriterCallback> m_successCallback;
     142    FileWriterBaseCallbacks(PassRefPtr<FileWriterBase>, PassRefPtr<FileWriterBaseCallback>, PassRefPtr<ErrorCallback>);
     143    RefPtr<FileWriterBase> m_fileWriter;
     144    RefPtr<FileWriterBaseCallback> m_successCallback;
    145145};
    146146

  • trunk/WebCore/fileapi/FileWriter.cpp

    r70438 r72715  
    4747    : ActiveDOMObject(context, this)
    4848    , m_readyState(INIT)
    49     , m_position(0)
    5049    , m_startedWriting(false)
    5150    , m_bytesWritten(0)
    … …  
    5554}
    5655
    57 void FileWriter::initialize(PassOwnPtr<AsyncFileWriter> writer, long long length)
    58 {
    59     ASSERT(!m_writer);
    60     ASSERT(length >= 0);
    61     m_writer = writer;
    62     m_length = length;
    63 }
    64 
    6556FileWriter::~FileWriter()
    6657{
    … …  
    8273void FileWriter::stop()
    8374{
    84     if (m_writer && m_readyState == WRITING)
    85         m_writer->abort();
     75    if (writer() && m_readyState == WRITING)
     76        writer()->abort();
    8677    m_blobBeingWritten.clear();
    8778    m_readyState = DONE;
    … …  
    9081void FileWriter::write(Blob* data, ExceptionCode& ec)
    9182{
    92     ASSERT(m_writer);
     83    ASSERT(writer());
    9384    if (m_readyState == WRITING) {
    9485        setError(FileError::INVALID_STATE_ERR, ec);
    … …  
    10596    m_bytesWritten = 0;
    10697    m_bytesToWrite = data->size();
    107     m_writer->write(m_position, data);
     98    writer()->write(position(), data);
    10899}
    109100
    110101void FileWriter::seek(long long position, ExceptionCode& ec)
    111102{
    112     ASSERT(m_writer);
     103    ASSERT(writer());
    113104    if (m_readyState == WRITING) {
    114105        setError(FileError::INVALID_STATE_ERR, ec);
    … …  
    118109    m_bytesWritten = 0;
    119110    m_bytesToWrite = 0;
    120     if (position > m_length)
    121         position = m_length;
    122     else if (position < 0)
    123         position = m_length + position;
    124     if (position < 0)
    125         position = 0;
    126     m_position = position;
     111    seekInternal(position);
    127112}
    128113
    129114void FileWriter::truncate(long long position, ExceptionCode& ec)
    130115{
    131     ASSERT(m_writer);
     116    ASSERT(writer());
    132117    if (m_readyState == WRITING || position < 0) {
    133118        setError(FileError::INVALID_STATE_ERR, ec);
    … …  
    138123    m_bytesToWrite = 0;
    139124    m_truncateLength = position;
    140     m_writer->truncate(position);
     125    writer()->truncate(position);
    141126}
    142127
    143128void FileWriter::abort(ExceptionCode& ec)
    144129{
    145     ASSERT(m_writer);
     130    ASSERT(writer());
    146131    if (m_readyState != WRITING) {
    147132        setError(FileError::INVALID_STATE_ERR, ec);
    … …  
    150135
    151136    m_error = FileError::create(FileError::ABORT_ERR);
    152     m_writer->abort();
     137    writer()->abort();
    153138}
    154139
    … …  
    163148    m_bytesWritten += bytes;
    164149    ASSERT((m_bytesWritten == m_bytesToWrite) || !complete);
    165     m_position += bytes;
    166     if (m_position > m_length)
    167         m_length = m_position;
     150    setPosition(position() + bytes);
     151    if (position() > length())
     152        setLength(position());
    168153    fireEvent(eventNames().progressEvent);
    169154    if (complete) {
    … …  
    179164    ASSERT(m_truncateLength >= 0);
    180165    fireEvent(eventNames().writestartEvent);
    181     m_length = m_truncateLength;
    182     if (m_position > m_length)
    183         m_position = m_length;
     166    setLength(m_truncateLength);
     167    if (position() > length())
     168        setPosition(length());
    184169    m_truncateLength = -1;
    185170    fireEvent(eventNames().writeEvent);

  • trunk/WebCore/fileapi/FileWriter.h

    r70438 r72715  
    3535
    3636#include "ActiveDOMObject.h"
    37 #include "AsyncFileWriterClient.h"
    3837#include "EventTarget.h"
    39 #include <wtf/OwnPtr.h>
    40 #include <wtf/PassOwnPtr.h>
     38#include "FileWriterBase.h"
    4139#include <wtf/PassRefPtr.h>
    42 #include <wtf/RefCounted.h>
    4340#include <wtf/RefPtr.h>
    4441
    4542namespace WebCore {
    4643
    47 class AsyncFileWriter;
    48 class Blob;
    49 class FileError;
    5044class ScriptExecutionContext;
    5145
    52 class FileWriter : public RefCounted<FileWriter>, public ActiveDOMObject, public EventTarget, public AsyncFileWriterClient {
     46class FileWriter : public FileWriterBase, public ActiveDOMObject, public EventTarget, public AsyncFileWriterClient {
    5347public:
    5448    static PassRefPtr<FileWriter> create(ScriptExecutionContext* context)
    … …  
    5650        return adoptRef(new FileWriter(context));
    5751    }
    58 
    59     void initialize(PassOwnPtr<AsyncFileWriter> writer, long long length);
    6052
    6153    enum ReadyState {
    … …  
    6557    };
    6658
    67     void write(Blob* data, ExceptionCode& ec);
    68     void seek(long long position, ExceptionCode& ec);
    69     void truncate(long long length, ExceptionCode& ec);
    70     void abort(ExceptionCode& ec);
    71 
     59    void write(Blob*, ExceptionCode&);
     60    void seek(long long position, ExceptionCode&);
     61    void truncate(long long length, ExceptionCode&);
     62    void abort(ExceptionCode&);
    7263    ReadyState readyState() const { return m_readyState; }
    7364    FileError* error() const { return m_error.get(); }
    74     long long position() const { return m_position; }
    75     long long length() const { return m_length; }
    7665
    7766    // AsyncFileWriterClient
    … …  
    8978    virtual ScriptExecutionContext* scriptExecutionContext() const { return ActiveDOMObject::scriptExecutionContext(); }
    9079
    91     using RefCounted<FileWriter>::ref;
    92     using RefCounted<FileWriter>::deref;
     80    using RefCounted<FileWriterBase>::ref;
     81    using RefCounted<FileWriterBase>::deref;
    9382
    9483    DEFINE_ATTRIBUTE_EVENT_LISTENER(writestart);
    … …  
    10493    virtual ~FileWriter();
    10594
    106     friend class WTF::RefCounted<FileWriter>;
    107 
    10895    // EventTarget
    10996    virtual void refEventTarget() { ref(); }
    … …  
    118105    RefPtr<FileError> m_error;
    119106    EventTargetData m_eventTargetData;
    120     OwnPtr<AsyncFileWriter> m_writer;
    121107    ReadyState m_readyState;
    122     long long m_position;
    123     long long m_length;
    124108    bool m_startedWriting;
    125109    long long m_bytesWritten;

  • trunk/WebCore/fileapi/FileWriterBase.cpp

    r72713 r72715  
    11/*
    2  * Copyright (C) 2010 Google Inc. All rights reserved.
     2 * Copyright (C) 2010 Google Inc.  All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3030
    3131#include "config.h"
    32 #include "FileEntrySync.h"
    3332
    3433#if ENABLE(FILE_SYSTEM)
    3534
    36 #include "File.h"
     35#include "FileWriterBase.h"
     36
     37#include "AsyncFileWriter.h"
     38#include "Blob.h"
     39#include "ExceptionCode.h"
     40#include "FileError.h"
     41#include "FileException.h"
     42#include "ProgressEvent.h"
    3743
    3844namespace WebCore {
    3945
    40 FileEntrySync::FileEntrySync(PassRefPtr<DOMFileSystemBase> fileSystem, const String& fullPath)
    41     : EntrySync(fileSystem, fullPath)
     46FileWriterBase::~FileWriterBase()
    4247{
    4348}
    4449
    45 PassRefPtr<File> FileEntrySync::file(ExceptionCode& ec)
     50void FileWriterBase::initialize(PassOwnPtr<AsyncFileWriter> writer, long long length)
    4651{
    47     return filesystem()->createFile(this, ec);
     52    ASSERT(!m_writer);
     53    ASSERT(length >= 0);
     54    m_writer = writer;
     55    m_length = length;
    4856}
    4957
     58FileWriterBase::FileWriterBase()
     59    : m_position(0)
     60{
    5061}
    5162
     63void FileWriterBase::seekInternal(long long position)
     64{
     65    if (position > m_length)
     66        position = m_length;
     67    else if (position < 0)
     68        position = m_length + position;
     69    if (position < 0)
     70        position = 0;
     71    m_position = position;
     72}
     73
     74} // namespace WebCore
     75
    5276#endif // ENABLE(FILE_SYSTEM)

  • trunk/WebCore/fileapi/FileWriterBase.h

    r72713 r72715  
    2929 */
    3030
    31 #ifndef FileWriterSync_h
    32 #define FileWriterSync_h
     31#ifndef FileWriterBase_h
     32#define FileWriterBase_h
    3333
    3434#if ENABLE(FILE_SYSTEM)
    3535
    36 #include "ActiveDOMObject.h"
    37 #include <wtf/PassRefPtr.h>
     36#include "AsyncFileWriterClient.h"
     37#include <wtf/OwnPtr.h>
     38#include <wtf/PassOwnPtr.h>
    3839#include <wtf/RefCounted.h>
    3940
    4041namespace WebCore {
    4142
     43class AsyncFileWriter;
    4244class Blob;
    4345
    4446typedef int ExceptionCode;
    4547
    46 // FIXME: This is an empty shell waiting for implementation.
    47 class FileWriterSync : public RefCounted<FileWriterSync>, public ActiveDOMObject {
     48class FileWriterBase : public RefCounted<FileWriterBase> {
    4849public:
    49     static PassRefPtr<FileWriterSync> create(ScriptExecutionContext* context)
     50    virtual ~FileWriterBase();
     51    void initialize(PassOwnPtr<AsyncFileWriter>, long long length);
     52
     53    long long position() const
    5054    {
    51         return adoptRef(new FileWriterSync(context));
     55        return m_position;
    5256    }
    53     virtual ~FileWriterSync();
     57    long long length() const
     58    {
     59        return m_length;
     60    }
    5461
    55     void write(Blob* data, ExceptionCode&);
    56     void seek(long long position, ExceptionCode&);
    57     void truncate(long long length, ExceptionCode&);
     62protected:
     63    FileWriterBase();
    5864
    59     long long position() const { return m_position; }
    60     long long length() const { return m_length; }
     65    AsyncFileWriter* writer()
     66    {
     67        return m_writer.get();
     68    }
    6169
    62     // ActiveDOMObject
    63     virtual bool canSuspend() const;
    64     virtual bool hasPendingActivity() const;
    65     virtual void stop();
     70    void setPosition(long long position)
     71    {
     72        m_position = position;
     73    }
    6674
    67     using RefCounted<FileWriterSync>::ref;
    68     using RefCounted<FileWriterSync>::deref;
     75    void setLength(long long length)
     76    {
     77        m_length = length;
     78    }
     79
     80    void seekInternal(long long position);
    6981
    7082private:
    71     FileWriterSync(ScriptExecutionContext*);
     83    friend class WTF::RefCounted<FileWriterBase>;
    7284
    73     friend class RefCounted<FileWriterSync>;
    74 
     85    OwnPtr<AsyncFileWriter> m_writer;
    7586    long long m_position;
    7687    long long m_length;
    … …  
    8192#endif // ENABLE(FILE_SYSTEM)
    8293
    83 #endif // FileWriter_h
     94#endif // FileWriterBase_h

  • trunk/WebCore/fileapi/FileWriterBaseCallback.h

    r72713 r72715  
    2929 */
    3030
    31 #ifndef AsyncFileWriter_h
    32 #define AsyncFileWriter_h
     31#ifndef FileWriterBaseCallback_h
     32#define FileWriterBaseCallback_h
    3333
    3434#if ENABLE(FILE_SYSTEM)
    3535
    36 #include "PlatformString.h"
    3736#include <wtf/RefCounted.h>
    3837
    3938namespace WebCore {
    4039
    41 class Blob;
     40class FileWriterBase;
    4241
    43 class AsyncFileWriter {
     42class FileWriterBaseCallback : public RefCounted<FileWriterBaseCallback> {
    4443public:
    45     virtual ~AsyncFileWriter() {}
    46 
    47     virtual void write(long long position, Blob* data) = 0;
    48     virtual void truncate(long long length) = 0;
    49     virtual void abort() = 0;
     44    virtual ~FileWriterBaseCallback() { }
     45    virtual bool handleEvent(FileWriterBase*) = 0;
    5046};
    5147
    … …  
    5450#endif // ENABLE(FILE_SYSTEM)
    5551
    56 #endif // AsyncFileWriter_h
    57 
     52#endif // FileWriterBaseCallback_h

  • trunk/WebCore/fileapi/FileWriterSync.cpp

    r71711 r72715  
    3535#include "FileWriterSync.h"
    3636
     37#include "AsyncFileWriter.h"
     38#include "Blob.h"
     39#include "FileException.h"
     40
    3741namespace WebCore {
    3842
    39 void FileWriterSync::write(Blob*, ExceptionCode&)
     43void FileWriterSync::write(Blob* data, ExceptionCode& ec)
    4044{
    41     ASSERT_NOT_REACHED(); // FIXME: Not implemented yet.
     45    ASSERT(writer());
     46    ASSERT(m_complete);
     47    ec = 0;
     48    if (!data) {
     49        ec = FileException::TYPE_MISMATCH_ERR;
     50        return;
     51    }
     52
     53    prepareForWrite();
     54    writer()->write(position(), data);
     55    writer()->waitForOperationToComplete();
     56    ASSERT(m_complete);
     57    ec = FileException::ErrorCodeToExceptionCode(m_error);
     58    if (ec)
     59        return;
     60    setPosition(position() + data->size());
     61    if (position() > length())
     62        setLength(position());
    4263}
    4364
    44 void FileWriterSync::seek(long long, ExceptionCode&)
     65void FileWriterSync::seek(long long position, ExceptionCode& ec)
    4566{
    46     ASSERT_NOT_REACHED(); // FIXME: Not implemented yet.
     67    ASSERT(writer());
     68    ASSERT(m_complete);
     69    ec = 0;
     70    seekInternal(position);
    4771}
    4872
    49 void FileWriterSync::truncate(long long, ExceptionCode&)
     73void FileWriterSync::truncate(long long offset, ExceptionCode& ec)
    5074{
    51     ASSERT_NOT_REACHED(); // FIXME: Not implemented yet.
     75    ASSERT(writer());
     76    ASSERT(m_complete);
     77    ec = 0;
     78    if (offset < 0) {
     79        ec = FileException::INVALID_STATE_ERR;
     80        return;
     81    }
     82    prepareForWrite();
     83    writer()->truncate(offset);
     84    writer()->waitForOperationToComplete();
     85    ASSERT(m_complete);
     86    ec = FileException::ErrorCodeToExceptionCode(m_error);
     87    if (ec)
     88        return;
     89    if (offset < position())
     90        setPosition(offset);
     91    setLength(offset);
    5292}
    5393
    54 bool FileWriterSync::canSuspend() const
     94void FileWriterSync::didWrite(long long bytes, bool complete)
    5595{
    56     // FIXME: It is not currently possible to suspend a FileWriterSync, so pages with FileWriter can not go into page cache.
    57     return false;
     96    ASSERT(m_error == FileError::OK);
     97    ASSERT(!m_complete);
     98#ifndef NDEBUG
     99    m_complete = complete;
     100#else
     101    ASSERT_UNUSED(complete, complete);
     102#endif
    58103}
    59104
    60 bool FileWriterSync::hasPendingActivity() const
     105void FileWriterSync::didTruncate()
    61106{
    62     return ActiveDOMObject::hasPendingActivity();
     107    ASSERT(m_error == FileError::OK);
     108    ASSERT(!m_complete);
     109#ifndef NDEBUG
     110    m_complete = true;
     111#endif
    63112}
    64113
    65 void FileWriterSync::stop()
     114void FileWriterSync::didFail(FileError::ErrorCode error)
     115{
     116    ASSERT(m_error == FileError::OK);
     117    m_error = error;
     118    ASSERT(!m_complete);
     119#ifndef NDEBUG
     120    m_complete = true;
     121#endif
     122}
     123
     124FileWriterSync::FileWriterSync()
     125    : m_error(FileError::OK)
     126#ifndef NDEBUG
     127    , m_complete(true)
     128#endif
    66129{
    67130}
    68131
    69 
    70 FileWriterSync::FileWriterSync(ScriptExecutionContext* context)
    71     : ActiveDOMObject(context, this)
    72     , m_position(0)
    73     , m_length(0)
     132void FileWriterSync::prepareForWrite()
    74133{
     134    ASSERT(m_complete);
     135    m_error = FileError::OK;
     136#ifndef NDEBUG
     137    m_complete = false;
     138#endif
    75139}
    76 
    77140
    78141FileWriterSync::~FileWriterSync()

  • trunk/WebCore/fileapi/FileWriterSync.h

    r71715 r72715  
    3535
    3636#include "ActiveDOMObject.h"
     37#include "FileError.h"
     38#include "FileWriterBase.h"
    3739#include <wtf/PassRefPtr.h>
    38 #include <wtf/RefCounted.h>
    3940
    4041namespace WebCore {
    … …  
    4445typedef int ExceptionCode;
    4546
    46 // FIXME: This is an empty shell waiting for implementation.
    47 class FileWriterSync : public RefCounted<FileWriterSync>, public ActiveDOMObject {
     47class FileWriterSync : public FileWriterBase, public AsyncFileWriterClient {
    4848public:
    49     static PassRefPtr<FileWriterSync> create(ScriptExecutionContext* context)
     49    static PassRefPtr<FileWriterSync> create()
    5050    {
    51         return adoptRef(new FileWriterSync(context));
     51        return adoptRef(new FileWriterSync());
    5252    }
    5353    virtual ~FileWriterSync();
    5454
    55     void write(Blob* data, ExceptionCode&);
     55    // FileWriterBase
     56    void write(Blob*, ExceptionCode&);
    5657    void seek(long long position, ExceptionCode&);
    5758    void truncate(long long length, ExceptionCode&);
    5859
    59     long long position() const { return m_position; }
    60     long long length() const { return m_length; }
    61 
    62     // ActiveDOMObject
    63     virtual bool canSuspend() const;
    64     virtual bool hasPendingActivity() const;
    65     virtual void stop();
    66 
    67     using RefCounted<FileWriterSync>::ref;
    68     using RefCounted<FileWriterSync>::deref;
     60    // AsyncFileWriterClient, via FileWriterBase
     61    void didWrite(long long bytes, bool complete);
     62    void didTruncate();
     63    void didFail(FileError::ErrorCode);
    6964
    7065private:
    71     FileWriterSync(ScriptExecutionContext*);
     66    FileWriterSync();
     67    void prepareForWrite();
    7268
    73     friend class RefCounted<FileWriterSync>;
    74 
    75     long long m_position;
    76     long long m_length;
     69    FileError::ErrorCode m_error;
     70#ifndef NDEBUG
     71    bool m_complete;
     72#endif
    7773};
    7874

  • trunk/WebCore/fileapi/FileWriterSync.idl

    r71711 r72715  
    3232    interface [
    3333        Conditional=FILE_SYSTEM,
    34         CallWith=ScriptExecutionContext
    3534    ] FileWriterSync {
    3635        // synchronous write/modify methods
Note: See TracChangeset for help on using the changeset viewer.