Changeset 68101 in webkit
- Timestamp:
- Sep 22, 2010 5:07:46 PM (14 years ago)
- Location:
- trunk
- Files:
-
- 14 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/WebCore/ChangeLog
r68096 r68101 1 2010-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 1 36 2010-09-22 Alexey Proskuryakov <ap@apple.com> 2 37 -
trunk/WebCore/fileapi/AsyncFileWriter.h
r67614 r68101 46 46 virtual ~AsyncFileWriter() {} 47 47 48 virtual void setFileWriterClient(FileWriterClient* client) = 0;49 50 48 virtual void write(long long position, Blob* data) = 0; 51 49 virtual void truncate(long long length) = 0; -
trunk/WebCore/fileapi/DOMFileSystem.cpp
r67147 r68101 41 41 #include "EntryCallback.h" 42 42 #include "ErrorCallback.h" 43 #include "FileEntry.h" 43 44 #include "FileError.h" 44 45 #include "FileSystemCallbacks.h" 46 #include "FileWriter.h" 47 #include "FileWriterCallback.h" 45 48 #include "MetadataCallback.h" 46 49 #include "ScriptExecutionContext.h" … … 200 203 } 201 204 205 void 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 202 216 void DOMFileSystem::readDirectory(const String& path, PassRefPtr<EntriesCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback) 203 217 { -
trunk/WebCore/fileapi/DOMFileSystem.h
r66586 r68101 49 49 class EntriesCallback; 50 50 class ErrorCallback; 51 class FileEntry; 52 class FileWriterCallback; 51 53 class MetadataCallback; 52 54 class VoidCallback; … … 78 80 void getDirectory(const Entry* base, const String& path, PassRefPtr<Flags>, PassRefPtr<EntryCallback>, PassRefPtr<ErrorCallback>); 79 81 void readDirectory(const String& path, PassRefPtr<EntriesCallback>, PassRefPtr<ErrorCallback>); 82 void createWriter(const FileEntry* file, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>); 80 83 81 84 // Schedule a callback. This should not cross threads (should be called on the same context thread). -
trunk/WebCore/fileapi/FileSystemCallbacks.cpp
r67220 r68101 35 35 36 36 #include "AsyncFileSystem.h" 37 #include "AsyncFileWriter.h" 37 38 #include "DOMFilePath.h" 38 39 #include "DOMFileSystem.h" … … 46 47 #include "FileError.h" 47 48 #include "FileSystemCallback.h" 49 #include "FileWriter.h" 50 #include "FileWriterCallback.h" 48 51 #include "Metadata.h" 49 52 #include "MetadataCallback.h" … … 87 90 88 91 void FileSystemCallbacksBase::didReadDirectoryEntry(const String&, bool) 92 { 93 // Each subclass must implement an appropriate one. 94 ASSERT_NOT_REACHED(); 95 } 96 97 void FileSystemCallbacksBase::didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long) 89 98 { 90 99 // Each subclass must implement an appropriate one. … … 188 197 } 189 198 199 // FileWriterCallbacks ---------------------------------------------------------- 200 201 FileWriterCallbacks::FileWriterCallbacks(PassRefPtr<FileWriter> fileWriter, PassRefPtr<FileWriterCallback> successCallback, PassRefPtr<ErrorCallback> errorCallback) 202 : FileSystemCallbacksBase(errorCallback) 203 , m_fileWriter(fileWriter) 204 , m_successCallback(successCallback) 205 { 206 } 207 208 void 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 190 216 // VoidCallbacks -------------------------------------------------------------- 191 217 -
trunk/WebCore/fileapi/FileSystemCallbacks.h
r66586 r68101 41 41 namespace WebCore { 42 42 43 class AsyncFileWriter; 43 44 class DOMFileSystem; 44 45 class ErrorCallback; … … 47 48 class EntryCallback; 48 49 class FileSystemCallback; 50 class FileWriter; 51 class FileWriterCallback; 49 52 class MetadataCallback; 50 53 class ScriptExecutionContext; … … 67 70 virtual void didReadDirectoryEntry(const String& name, bool isDirectory); 68 71 virtual void didReadDirectoryEntries(bool hasMore); 72 73 // For createFileWriter. 74 virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length); 69 75 70 76 // For ErrorCallback. … … 122 128 }; 123 129 130 class FileWriterCallbacks : public FileSystemCallbacksBase { 131 public: 132 FileWriterCallbacks(PassRefPtr<FileWriter>, PassRefPtr<FileWriterCallback>, PassRefPtr<ErrorCallback>); 133 virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter>, long long length); 134 135 private: 136 RefPtr<FileWriter> m_fileWriter; 137 RefPtr<FileWriterCallback> m_successCallback; 138 }; 139 124 140 class VoidCallbacks : public FileSystemCallbacksBase { 125 141 public: -
trunk/WebCore/platform/AsyncFileSystem.h
r66407 r68101 42 42 class AsyncFileSystem; 43 43 class AsyncFileSystemCallbacks; 44 class FileWriterClient; 44 45 45 46 // This class provides async interface for platform-specific file system implementation. Note that all the methods take platform paths. … … 108 109 virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>) = 0; 109 110 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 110 116 // Converts a given absolute virtual path to a platform path that starts with the platform root path of this file system. 111 117 virtual String virtualToPlatformPath(const String& path) const; -
trunk/WebCore/platform/AsyncFileSystemCallbacks.h
r66255 r68101 39 39 40 40 class AsyncFileSystem; 41 class AsyncFileWriter; 41 42 42 43 class AsyncFileSystemCallbacks : public Noncopyable { … … 57 58 virtual void didReadDirectoryEntries(bool hasMore) = 0; 58 59 60 // Called when an AsyncFileWrter has been created successfully. 61 virtual void didCreateFileWriter(PassOwnPtr<AsyncFileWriter> writer, long long length) = 0; 62 59 63 // Called when there was an error. 60 64 virtual void didFail(int code) = 0; -
trunk/WebKit/chromium/ChangeLog
r68068 r68101 1 2010-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 1 42 2010-09-22 Kenneth Russell <kbr@google.com> 2 43 -
trunk/WebKit/chromium/public/WebFileInfo.h
r54565 r68101 39 39 double modificationTime; 40 40 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) { } 42 54 }; 43 55 -
trunk/WebKit/chromium/src/AsyncFileSystemChromium.cpp
r66407 r68101 34 34 35 35 #include "AsyncFileSystemCallbacks.h" 36 #include "FileSystem.h" 36 #include "AsyncFileWriterChromium.h" 37 #include "WebFileInfo.h" 37 38 #include "WebFileSystem.h" 38 39 #include "WebFileSystemCallbacksImpl.h" 40 #include "WebFileWriter.h" 39 41 #include "WebKit.h" 40 42 #include "WebKitClient.h" … … 100 102 } 101 103 104 class FileWriterHelperCallbacks : public WebKit::WebFileSystemCallbacks { 105 public: 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 151 private: 152 FileWriterClient* m_client; 153 String m_path; 154 WebKit::WebFileSystem* m_webFileSystem; 155 OwnPtr<WebCore::AsyncFileSystemCallbacks> m_callbacks; 156 }; 157 158 void 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 102 163 } // namespace WebCore 103 164 -
trunk/WebKit/chromium/src/AsyncFileSystemChromium.h
r66280 r68101 59 59 virtual void directoryExists(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>); 60 60 virtual void readDirectory(const String& path, PassOwnPtr<AsyncFileSystemCallbacks>); 61 virtual void createWriter(FileWriterClient* client, const String& path, PassOwnPtr<AsyncFileSystemCallbacks>); 61 62 62 63 private: -
trunk/WebKit/chromium/src/AsyncFileWriterChromium.cpp
r67614 r68101 39 39 #include "WebURL.h" 40 40 41 using namespace WebCore; 42 43 namespace WebKit { 41 namespace WebCore { 44 42 45 43 AsyncFileWriterChromium::AsyncFileWriterChromium(FileWriterClient* client) … … 48 46 } 49 47 50 void AsyncFileWriterChromium::setWebFileWriter(WebFileWriter* writer)48 AsyncFileWriterChromium::~AsyncFileWriterChromium() 51 49 { 52 ASSERT(!m_writer); 50 } 51 52 void AsyncFileWriterChromium::setWebFileWriter(PassOwnPtr<WebKit::WebFileWriter> writer) 53 { 53 54 m_writer = writer; 54 55 } … … 57 58 { 58 59 ASSERT(m_writer); 59 m_writer->write(position, Web URL(data->url()));60 m_writer->write(position, WebKit::WebURL(data->url())); 60 61 } 61 62 … … 83 84 } 84 85 85 void AsyncFileWriterChromium::didFail(Web FileError error)86 void AsyncFileWriterChromium::didFail(WebKit::WebFileError error) 86 87 { 87 88 m_client->didFail(error); -
trunk/WebKit/chromium/src/AsyncFileWriterChromium.h
r67740 r68101 37 37 #include "WebFileError.h" 38 38 #include "WebFileWriterClient.h" 39 #include <WTF/PassOwnPtr.h> 40 41 namespace WebKit { 42 class WebFileWriter; 43 } 39 44 40 45 namespace WebCore { 46 41 47 class Blob; 42 48 class FileWriterClient; 43 }44 49 45 namespace WebKit { 46 47 class WebFileWriter; 48 49 class AsyncFileWriterChromium : public WebCore::AsyncFileWriter, public WebFileWriterClient { 50 class AsyncFileWriterChromium : public AsyncFileWriter, public WebKit::WebFileWriterClient { 50 51 public: 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); 54 56 55 57 // FileWriter 56 virtual void write(long long position, WebCore::Blob* data);58 virtual void write(long long position, Blob* data); 57 59 virtual void truncate(long long length); 58 60 virtual void abort(); … … 61 63 virtual void didWrite(long long bytes, bool complete); 62 64 virtual void didTruncate(long long length); 63 virtual void didFail(Web FileError);65 virtual void didFail(WebKit::WebFileError); 64 66 65 67 private: 66 OwnPtr<Web FileWriter> m_writer;67 WebCore::FileWriterClient* m_client;68 OwnPtr<WebKit::WebFileWriter> m_writer; 69 FileWriterClient* m_client; 68 70 }; 69 71
Note: See TracChangeset
for help on using the changeset viewer.