692bde1aca0ad7c161c4d3f48ed2136a3a52adc0
[WebKit-https.git] / Source / WebCore / fileapi / File.cpp
1 /*
2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "File.h"
28
29 #include "FileMetadata.h"
30 #include "FileSystem.h"
31 #include "MIMETypeRegistry.h"
32 #include <wtf/CurrentTime.h>
33 #include <wtf/text/WTFString.h>
34
35 namespace WebCore {
36
37 static String getContentTypeFromFileName(const String& name, File::ContentTypeLookupPolicy policy)
38 {
39     String type;
40     int index = name.reverseFind('.');
41     if (index != -1) {
42         if (policy == File::WellKnownContentTypes)
43             type = MIMETypeRegistry::getWellKnownMIMETypeForExtension(name.substring(index + 1));
44         else {
45             ASSERT(policy == File::AllContentTypes);
46             type = MIMETypeRegistry::getMIMETypeForExtension(name.substring(index + 1));
47         }
48     }
49     return type;
50 }
51
52 static PassOwnPtr<BlobData> createBlobDataForFileWithType(const String& path, const String& contentType)
53 {
54     OwnPtr<BlobData> blobData = BlobData::create();
55     blobData->setContentType(contentType);
56     blobData->appendFile(path);
57     return blobData.release();
58 }
59
60 static PassOwnPtr<BlobData> createBlobDataForFile(const String& path, File::ContentTypeLookupPolicy policy)
61 {
62     return createBlobDataForFileWithType(path, getContentTypeFromFileName(path, policy));
63 }
64
65 static PassOwnPtr<BlobData> createBlobDataForFileWithName(const String& path, const String& fileSystemName, File::ContentTypeLookupPolicy policy)
66 {
67     return createBlobDataForFileWithType(path, getContentTypeFromFileName(fileSystemName, policy));
68 }
69
70 #if ENABLE(FILE_SYSTEM)
71 static PassOwnPtr<BlobData> createBlobDataForFileWithMetadata(const String& fileSystemName, const FileMetadata& metadata)
72 {
73     OwnPtr<BlobData> blobData = BlobData::create();
74     blobData->setContentType(getContentTypeFromFileName(fileSystemName, File::WellKnownContentTypes));
75     blobData->appendFile(metadata.platformPath, 0, metadata.length, metadata.modificationTime);
76     return blobData.release();
77 }
78
79 static PassOwnPtr<BlobData> createBlobDataForFileSystemURL(const KURL& fileSystemURL, const FileMetadata& metadata)
80 {
81     OwnPtr<BlobData> blobData = BlobData::create();
82     blobData->setContentType(getContentTypeFromFileName(fileSystemURL.path(), File::WellKnownContentTypes));
83     blobData->appendURL(fileSystemURL, 0, metadata.length, metadata.modificationTime);
84     return blobData.release();
85 }
86 #endif
87
88 #if ENABLE(DIRECTORY_UPLOAD)
89 PassRefPtr<File> File::createWithRelativePath(const String& path, const String& relativePath)
90 {
91     RefPtr<File> file = adoptRef(new File(path, AllContentTypes));
92     file->m_relativePath = relativePath;
93     return file.release();
94 }
95 #endif
96
97 File::File(const String& path, ContentTypeLookupPolicy policy)
98     : Blob(createBlobDataForFile(path, policy), -1)
99     , m_path(path)
100     , m_name(pathGetFileName(path))
101 #if ENABLE(FILE_SYSTEM)
102     , m_snapshotSize(-1)
103     , m_snapshotModificationTime(invalidFileTime())
104 #endif
105 {
106 }
107
108 File::File(const String& path, const KURL& url, const String& type)
109     : Blob(url, type, -1)
110     , m_path(path)
111 #if ENABLE(FILE_SYSTEM)
112     , m_snapshotSize(-1)
113     , m_snapshotModificationTime(invalidFileTime())
114 #endif
115 {
116     m_name = pathGetFileName(path);
117     // FIXME: File object serialization/deserialization does not include
118     // newer file object data members: m_name and m_relativePath.
119     // See SerializedScriptValue.cpp for js and v8.
120 }
121
122 File::File(const String& path, const String& name, ContentTypeLookupPolicy policy)
123     : Blob(createBlobDataForFileWithName(path, name, policy), -1)
124     , m_path(path)
125     , m_name(name)
126 #if ENABLE(FILE_SYSTEM)
127     , m_snapshotSize(-1)
128     , m_snapshotModificationTime(invalidFileTime())
129 #endif
130 {
131 }
132
133 #if ENABLE(FILE_SYSTEM)
134 File::File(const String& name, const FileMetadata& metadata)
135     : Blob(createBlobDataForFileWithMetadata(name, metadata), metadata.length)
136     , m_path(metadata.platformPath)
137     , m_name(name)
138     , m_snapshotSize(metadata.length)
139     , m_snapshotModificationTime(metadata.modificationTime)
140 {
141 }
142
143 File::File(const KURL& fileSystemURL, const FileMetadata& metadata)
144     : Blob(createBlobDataForFileSystemURL(fileSystemURL, metadata), metadata.length)
145     , m_fileSystemURL(fileSystemURL)
146     , m_snapshotSize(metadata.length)
147     , m_snapshotModificationTime(metadata.modificationTime)
148 {
149 }
150 #endif
151
152 double File::lastModifiedDate() const
153 {
154 #if ENABLE(FILE_SYSTEM)
155     if (hasValidSnapshotMetadata())
156         return m_snapshotModificationTime * 1000.0;
157 #endif
158
159     time_t modificationTime;
160     if (!getFileModificationTime(m_path, modificationTime))
161         return invalidFileTime();
162
163     // Needs to return epoch time in milliseconds for Date.
164     return modificationTime * 1000.0;
165 }
166
167 unsigned long long File::size() const
168 {
169 #if ENABLE(FILE_SYSTEM)
170     if (hasValidSnapshotMetadata())
171         return m_snapshotSize;
172 #endif
173
174     // FIXME: JavaScript cannot represent sizes as large as unsigned long long, we need to
175     // come up with an exception to throw if file size is not representable.
176     long long size;
177     if (!getFileSize(m_path, size))
178         return 0;
179     return static_cast<unsigned long long>(size);
180 }
181
182 void File::captureSnapshot(long long& snapshotSize, double& snapshotModificationTime) const
183 {
184 #if ENABLE(FILE_SYSTEM)
185     if (hasValidSnapshotMetadata()) {
186         snapshotSize = m_snapshotSize;
187         snapshotModificationTime = m_snapshotModificationTime;
188         return;
189     }
190 #endif
191
192     // Obtains a snapshot of the file by capturing its current size and modification time. This is used when we slice a file for the first time.
193     // If we fail to retrieve the size or modification time, probably due to that the file has been deleted, 0 size is returned.
194     FileMetadata metadata;
195     if (!getFileMetadata(m_path, metadata)) {
196         snapshotSize = 0;
197         snapshotModificationTime = invalidFileTime();
198         return;
199     }
200
201     snapshotSize = metadata.length;
202     snapshotModificationTime = metadata.modificationTime;
203 }
204
205 } // namespace WebCore