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