File.lastModifiedDate() should return the current date/time if the file date/time...
[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/DateMath.h>
34 #include <wtf/text/WTFString.h>
35
36 namespace WebCore {
37
38 static String getContentTypeFromFileName(const String& name, File::ContentTypeLookupPolicy policy)
39 {
40     String type;
41     int index = name.reverseFind('.');
42     if (index != -1) {
43         if (policy == File::WellKnownContentTypes)
44             type = MIMETypeRegistry::getWellKnownMIMETypeForExtension(name.substring(index + 1));
45         else {
46             ASSERT(policy == File::AllContentTypes);
47             type = MIMETypeRegistry::getMIMETypeForExtension(name.substring(index + 1));
48         }
49     }
50     return type;
51 }
52
53 static PassOwnPtr<BlobData> createBlobDataForFileWithType(const String& path, const String& contentType)
54 {
55     OwnPtr<BlobData> blobData = BlobData::create();
56     blobData->setContentType(contentType);
57     blobData->appendFile(path);
58     return blobData.release();
59 }
60
61 static PassOwnPtr<BlobData> createBlobDataForFile(const String& path, File::ContentTypeLookupPolicy policy)
62 {
63     return createBlobDataForFileWithType(path, getContentTypeFromFileName(path, policy));
64 }
65
66 static PassOwnPtr<BlobData> createBlobDataForFileWithName(const String& path, const String& fileSystemName, File::ContentTypeLookupPolicy policy)
67 {
68     return createBlobDataForFileWithType(path, getContentTypeFromFileName(fileSystemName, policy));
69 }
70
71 #if ENABLE(FILE_SYSTEM)
72 static PassOwnPtr<BlobData> createBlobDataForFileWithMetadata(const String& fileSystemName, const FileMetadata& metadata)
73 {
74     OwnPtr<BlobData> blobData = BlobData::create();
75     blobData->setContentType(getContentTypeFromFileName(fileSystemName, File::WellKnownContentTypes));
76     blobData->appendFile(metadata.platformPath, 0, metadata.length, metadata.modificationTime);
77     return blobData.release();
78 }
79
80 static PassOwnPtr<BlobData> createBlobDataForFileSystemURL(const KURL& fileSystemURL, const FileMetadata& metadata)
81 {
82     OwnPtr<BlobData> blobData = BlobData::create();
83     blobData->setContentType(getContentTypeFromFileName(fileSystemURL.path(), File::WellKnownContentTypes));
84     blobData->appendURL(fileSystemURL, 0, metadata.length, metadata.modificationTime);
85     return blobData.release();
86 }
87 #endif
88
89 #if ENABLE(DIRECTORY_UPLOAD)
90 PassRefPtr<File> File::createWithRelativePath(const String& path, const String& relativePath)
91 {
92     RefPtr<File> file = adoptRef(new File(path, AllContentTypes));
93     file->m_relativePath = relativePath;
94     return file.release();
95 }
96 #endif
97
98 File::File(const String& path, ContentTypeLookupPolicy policy)
99     : Blob(createBlobDataForFile(path, policy), -1)
100     , m_path(path)
101     , m_name(pathGetFileName(path))
102 #if ENABLE(FILE_SYSTEM)
103     , m_snapshotSize(-1)
104     , m_snapshotModificationTime(invalidFileTime())
105 #endif
106 {
107 }
108
109 File::File(const String& path, const KURL& url, const String& type)
110     : Blob(url, type, -1)
111     , m_path(path)
112 #if ENABLE(FILE_SYSTEM)
113     , m_snapshotSize(-1)
114     , m_snapshotModificationTime(invalidFileTime())
115 #endif
116 {
117     m_name = pathGetFileName(path);
118     // FIXME: File object serialization/deserialization does not include
119     // newer file object data members: m_name and m_relativePath.
120     // See SerializedScriptValue.cpp for js and v8.
121 }
122
123 File::File(const String& path, const String& name, ContentTypeLookupPolicy policy)
124     : Blob(createBlobDataForFileWithName(path, name, policy), -1)
125     , m_path(path)
126     , m_name(name)
127 #if ENABLE(FILE_SYSTEM)
128     , m_snapshotSize(-1)
129     , m_snapshotModificationTime(invalidFileTime())
130 #endif
131 {
132 }
133
134 #if ENABLE(FILE_SYSTEM)
135 File::File(const String& name, const FileMetadata& metadata)
136     : Blob(createBlobDataForFileWithMetadata(name, metadata), metadata.length)
137     , m_path(metadata.platformPath)
138     , m_name(name)
139     , m_snapshotSize(metadata.length)
140     , m_snapshotModificationTime(metadata.modificationTime)
141 {
142 }
143
144 File::File(const KURL& fileSystemURL, const FileMetadata& metadata)
145     : Blob(createBlobDataForFileSystemURL(fileSystemURL, metadata), metadata.length)
146     , m_fileSystemURL(fileSystemURL)
147     , m_snapshotSize(metadata.length)
148     , m_snapshotModificationTime(metadata.modificationTime)
149 {
150 }
151 #endif
152
153 double File::lastModifiedDate() const
154 {
155 #if ENABLE(FILE_SYSTEM)
156     if (hasValidSnapshotMetadata() && isValidFileTime(m_snapshotModificationTime))
157         return m_snapshotModificationTime * msPerSecond;
158 #endif
159
160     time_t modificationTime;
161     if (getFileModificationTime(m_path, modificationTime) && isValidFileTime(modificationTime))
162         return modificationTime * msPerSecond;
163
164     return currentTime() * msPerSecond;
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