third_party/WebKit/Source/core/fileapi/File.cpp - chromium/src - Git at Google

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "core/fileapi/File.h"

 #include <memory>
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fileapi/FilePropertyBag.h"
 #include "core/frame/UseCounter.h"
 #include "platform/FileMetadata.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFileUtilities.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DateMath.h"

 namespace blink {

 static String getContentTypeFromFileName(const String& name,
                                          File::ContentTypeLookupPolicy policy) {
   String type;
   int index = name.reverseFind('.');
   if (index != -1) {
     if (policy == File::WellKnownContentTypes) {
       type = MIMETypeRegistry::getWellKnownMIMETypeForExtension(
           name.substring(index + 1));
     } else {
       ASSERT(policy == File::AllContentTypes);
       type =
           MIMETypeRegistry::getMIMETypeForExtension(name.substring(index + 1));
     }
   }
   return type;
 }

 static std::unique_ptr<BlobData> createBlobDataForFileWithType(
     const String& path,
     const String& contentType) {
   std::unique_ptr<BlobData> blobData =
       BlobData::createForFileWithUnknownSize(path);
   blobData->setContentType(contentType);
   return blobData;
 }

 static std::unique_ptr<BlobData> createBlobDataForFile(
     const String& path,
     File::ContentTypeLookupPolicy policy) {
   return createBlobDataForFileWithType(
       path, getContentTypeFromFileName(path, policy));
 }

 static std::unique_ptr<BlobData> createBlobDataForFileWithName(
     const String& path,
     const String& fileSystemName,
     File::ContentTypeLookupPolicy policy) {
   return createBlobDataForFileWithType(
       path, getContentTypeFromFileName(fileSystemName, policy));
 }

 static std::unique_ptr<BlobData> createBlobDataForFileWithMetadata(
     const String& fileSystemName,
     const FileMetadata& metadata) {
   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->setContentType(
       getContentTypeFromFileName(fileSystemName, File::WellKnownContentTypes));
   blobData->appendFile(metadata.platformPath, 0, metadata.length,
                        metadata.modificationTime / msPerSecond);
   return blobData;
 }

 static std::unique_ptr<BlobData> createBlobDataForFileSystemURL(
     const KURL& fileSystemURL,
     const FileMetadata& metadata) {
   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->setContentType(getContentTypeFromFileName(
       fileSystemURL.path(), File::WellKnownContentTypes));
   blobData->appendFileSystemURL(fileSystemURL, 0, metadata.length,
                                 metadata.modificationTime / msPerSecond);
   return blobData;
 }

 // static
 File* File::create(
     ExecutionContext* context,
     const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& fileBits,
     const String& fileName,
     const FilePropertyBag& options,
     ExceptionState& exceptionState) {
   ASSERT(options.hasType());

   double lastModified;
   if (options.hasLastModified())
     lastModified = static_cast<double>(options.lastModified());
   else
     lastModified = currentTimeMS();
   ASSERT(options.hasEndings());
   bool normalizeLineEndingsToNative = options.endings() == "native";
   if (normalizeLineEndingsToNative)
     UseCounter::count(context, UseCounter::FileAPINativeLineEndings);

   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->setContentType(normalizeType(options.type()));
   populateBlobData(blobData.get(), fileBits, normalizeLineEndingsToNative);

   long long fileSize = blobData->length();
   return File::create(fileName, lastModified,
                       BlobDataHandle::create(std::move(blobData), fileSize));
 }

 File* File::createWithRelativePath(const String& path,
                                    const String& relativePath) {
   File* file = new File(path, File::AllContentTypes, File::IsUserVisible);
   file->m_relativePath = relativePath;
   return file;
 }

 File::File(const String& path,
            ContentTypeLookupPolicy policy,
            UserVisibility userVisibility)
     : Blob(BlobDataHandle::create(createBlobDataForFile(path, policy), -1)),
       m_hasBackingFile(true),
       m_userVisibility(userVisibility),
       m_path(path),
       m_name(Platform::current()->fileUtilities()->baseName(path)),
       m_snapshotSize(-1),
       m_snapshotModificationTimeMS(invalidFileTime()) {}

 File::File(const String& path,
            const String& name,
            ContentTypeLookupPolicy policy,
            UserVisibility userVisibility)
     : Blob(BlobDataHandle::create(
           createBlobDataForFileWithName(path, name, policy),
           -1)),
       m_hasBackingFile(true),
       m_userVisibility(userVisibility),
       m_path(path),
       m_name(name),
       m_snapshotSize(-1),
       m_snapshotModificationTimeMS(invalidFileTime()) {}

 File::File(const String& path,
            const String& name,
            const String& relativePath,
            UserVisibility userVisibility,
            bool hasSnapshotData,
            uint64_t size,
            double lastModified,
            PassRefPtr<BlobDataHandle> blobDataHandle)
     : Blob(std::move(blobDataHandle)),
       m_hasBackingFile(!path.isEmpty() || !relativePath.isEmpty()),
       m_userVisibility(userVisibility),
       m_path(path),
       m_name(name),
       m_snapshotSize(hasSnapshotData ? static_cast<long long>(size) : -1),
       m_snapshotModificationTimeMS(hasSnapshotData ? lastModified
                                                    : invalidFileTime()),
       m_relativePath(relativePath) {}

 File::File(const String& name,
            double modificationTimeMS,
            PassRefPtr<BlobDataHandle> blobDataHandle)
     : Blob(std::move(blobDataHandle)),
       m_hasBackingFile(false),
       m_userVisibility(File::IsNotUserVisible),
       m_name(name),
       m_snapshotSize(Blob::size()),
       m_snapshotModificationTimeMS(modificationTimeMS) {}

 File::File(const String& name,
            const FileMetadata& metadata,
            UserVisibility userVisibility)
     : Blob(BlobDataHandle::create(
           createBlobDataForFileWithMetadata(name, metadata),
           metadata.length)),
       m_hasBackingFile(true),
       m_userVisibility(userVisibility),
       m_path(metadata.platformPath),
       m_name(name),
       m_snapshotSize(metadata.length),
       m_snapshotModificationTimeMS(metadata.modificationTime) {}

 File::File(const KURL& fileSystemURL,
            const FileMetadata& metadata,
            UserVisibility userVisibility)
     : Blob(BlobDataHandle::create(
           createBlobDataForFileSystemURL(fileSystemURL, metadata),
           metadata.length)),
       m_hasBackingFile(false),
       m_userVisibility(userVisibility),
       m_name(decodeURLEscapeSequences(fileSystemURL.lastPathComponent())),
       m_fileSystemURL(fileSystemURL),
       m_snapshotSize(metadata.length),
       m_snapshotModificationTimeMS(metadata.modificationTime) {}

 File::File(const File& other)
     : Blob(other.blobDataHandle()),
       m_hasBackingFile(other.m_hasBackingFile),
       m_userVisibility(other.m_userVisibility),
       m_path(other.m_path),
       m_name(other.m_name),
       m_fileSystemURL(other.m_fileSystemURL),
       m_snapshotSize(other.m_snapshotSize),
       m_snapshotModificationTimeMS(other.m_snapshotModificationTimeMS),
       m_relativePath(other.m_relativePath) {}

 File* File::clone(const String& name) const {
   File* file = new File(*this);
   if (!name.isNull())
     file->m_name = name;
   return file;
 }

 double File::lastModifiedMS() const {
   if (hasValidSnapshotMetadata() &&
       isValidFileTime(m_snapshotModificationTimeMS))
     return m_snapshotModificationTimeMS;

   double modificationTimeMS;
   if (hasBackingFile() && getFileModificationTime(m_path, modificationTimeMS) &&
       isValidFileTime(modificationTimeMS))
     return modificationTimeMS;

   return currentTimeMS();
 }

 long long File::lastModified() const {
   double modifiedDate = lastModifiedMS();

   // The getter should return the current time when the last modification time
   // isn't known.
   if (!isValidFileTime(modifiedDate))
     modifiedDate = currentTimeMS();

   // lastModified returns a number, not a Date instance,
   // http://dev.w3.org/2006/webapi/FileAPI/#file-attrs
   return floor(modifiedDate);
 }

 double File::lastModifiedDate() const {
   double modifiedDate = lastModifiedMS();

   // The getter should return the current time when the last modification time
   // isn't known.
   if (!isValidFileTime(modifiedDate))
     modifiedDate = currentTimeMS();

   // lastModifiedDate returns a Date instance,
   // http://www.w3.org/TR/FileAPI/#dfn-lastModifiedDate
   return modifiedDate;
 }

 unsigned long long File::size() const {
   if (hasValidSnapshotMetadata())
     return m_snapshotSize;

   // FIXME: JavaScript cannot represent sizes as large as unsigned long long, we
   // need to come up with an exception to throw if file size is not
   // representable.
   long long size;
   if (!hasBackingFile() || !getFileSize(m_path, size))
     return 0;
   return static_cast<unsigned long long>(size);
 }

 Blob* File::slice(long long start,
                   long long end,
                   const String& contentType,
                   ExceptionState& exceptionState) const {
   if (isClosed()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "File has been closed.");
     return nullptr;
   }

   if (!m_hasBackingFile)
     return Blob::slice(start, end, contentType, exceptionState);

   // FIXME: This involves synchronous file operation. We need to figure out how
   // to make it asynchronous.
   long long size;
   double modificationTimeMS;
   captureSnapshot(size, modificationTimeMS);
   clampSliceOffsets(size, start, end);

   long long length = end - start;
   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->setContentType(normalizeType(contentType));
   if (!m_fileSystemURL.isEmpty()) {
     blobData->appendFileSystemURL(m_fileSystemURL, start, length,
                                   modificationTimeMS / msPerSecond);
   } else {
     ASSERT(!m_path.isEmpty());
     blobData->appendFile(m_path, start, length,
                          modificationTimeMS / msPerSecond);
   }
   return Blob::create(BlobDataHandle::create(std::move(blobData), length));
 }

 void File::captureSnapshot(long long& snapshotSize,
                            double& snapshotModificationTimeMS) const {
   if (hasValidSnapshotMetadata()) {
     snapshotSize = m_snapshotSize;
     snapshotModificationTimeMS = m_snapshotModificationTimeMS;
     return;
   }

   // 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.
   // If we fail to retrieve the size or modification time, probably due to that
   // the file has been deleted, 0 size is returned.
   FileMetadata metadata;
   if (!hasBackingFile() || !getFileMetadata(m_path, metadata)) {
     snapshotSize = 0;
     snapshotModificationTimeMS = invalidFileTime();
     return;
   }

   snapshotSize = metadata.length;
   snapshotModificationTimeMS = metadata.modificationTime;
 }

 void File::close(ScriptState* scriptState, ExceptionState& exceptionState) {
   if (isClosed()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "Blob has been closed.");
     return;
   }

   // Reset the File to its closed representation, an empty
   // Blob. The name isn't cleared, as it should still be
   // available.
   m_hasBackingFile = false;
   m_path = String();
   m_fileSystemURL = KURL();
   invalidateSnapshotMetadata();
   m_relativePath = String();
   Blob::close(scriptState, exceptionState);
 }

 void File::appendTo(BlobData& blobData) const {
   if (!m_hasBackingFile) {
     Blob::appendTo(blobData);
     return;
   }

   // FIXME: This involves synchronous file operation. We need to figure out how
   // to make it asynchronous.
   long long size;
   double modificationTimeMS;
   captureSnapshot(size, modificationTimeMS);
   if (!m_fileSystemURL.isEmpty()) {
     blobData.appendFileSystemURL(m_fileSystemURL, 0, size,
                                  modificationTimeMS / msPerSecond);
     return;
   }
   ASSERT(!m_path.isEmpty());
   blobData.appendFile(m_path, 0, size, modificationTimeMS / msPerSecond);
 }

 bool File::hasSameSource(const File& other) const {
   if (m_hasBackingFile != other.m_hasBackingFile)
     return false;

   if (m_hasBackingFile)
     return m_path == other.m_path;

   if (m_fileSystemURL.isEmpty() != other.m_fileSystemURL.isEmpty())
     return false;

   if (!m_fileSystemURL.isEmpty())
     return m_fileSystemURL == other.m_fileSystemURL;

   return uuid() == other.uuid();
 }

 }  // namespace blink
	/*
	* Copyright (C) 2008 Apple Inc. All Rights Reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "core/fileapi/File.h"

	#include <memory>
	#include "bindings/core/v8/ExceptionState.h"
	#include "bindings/core/v8/ScriptState.h"
	#include "core/dom/ExceptionCode.h"
	#include "core/fileapi/FilePropertyBag.h"
	#include "core/frame/UseCounter.h"
	#include "platform/FileMetadata.h"
	#include "platform/blob/BlobData.h"
	#include "platform/network/mime/MIMETypeRegistry.h"
	#include "public/platform/Platform.h"
	#include "public/platform/WebFileUtilities.h"
	#include "wtf/CurrentTime.h"
	#include "wtf/DateMath.h"

	namespace blink {

	static String getContentTypeFromFileName(const String& name,
	File::ContentTypeLookupPolicy policy) {
	String type;
	int index = name.reverseFind('.');
	if (index != -1) {
	if (policy == File::WellKnownContentTypes) {
	type = MIMETypeRegistry::getWellKnownMIMETypeForExtension(
	name.substring(index + 1));
	} else {
	ASSERT(policy == File::AllContentTypes);
	type =
	MIMETypeRegistry::getMIMETypeForExtension(name.substring(index + 1));
	}
	}
	return type;
	}

	static std::unique_ptr<BlobData> createBlobDataForFileWithType(
	const String& path,
	const String& contentType) {
	std::unique_ptr<BlobData> blobData =
	BlobData::createForFileWithUnknownSize(path);
	blobData->setContentType(contentType);
	return blobData;
	}

	static std::unique_ptr<BlobData> createBlobDataForFile(
	const String& path,
	File::ContentTypeLookupPolicy policy) {
	return createBlobDataForFileWithType(
	path, getContentTypeFromFileName(path, policy));
	}

	static std::unique_ptr<BlobData> createBlobDataForFileWithName(
	const String& path,
	const String& fileSystemName,
	File::ContentTypeLookupPolicy policy) {
	return createBlobDataForFileWithType(
	path, getContentTypeFromFileName(fileSystemName, policy));
	}

	static std::unique_ptr<BlobData> createBlobDataForFileWithMetadata(
	const String& fileSystemName,
	const FileMetadata& metadata) {
	std::unique_ptr<BlobData> blobData = BlobData::create();
	blobData->setContentType(
	getContentTypeFromFileName(fileSystemName, File::WellKnownContentTypes));
	blobData->appendFile(metadata.platformPath, 0, metadata.length,
	metadata.modificationTime / msPerSecond);
	return blobData;
	}

	static std::unique_ptr<BlobData> createBlobDataForFileSystemURL(
	const KURL& fileSystemURL,
	const FileMetadata& metadata) {
	std::unique_ptr<BlobData> blobData = BlobData::create();
	blobData->setContentType(getContentTypeFromFileName(
	fileSystemURL.path(), File::WellKnownContentTypes));
	blobData->appendFileSystemURL(fileSystemURL, 0, metadata.length,
	metadata.modificationTime / msPerSecond);
	return blobData;
	}

	// static
	File* File::create(
	ExecutionContext* context,
	const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& fileBits,
	const String& fileName,
	const FilePropertyBag& options,
	ExceptionState& exceptionState) {
	ASSERT(options.hasType());

	double lastModified;
	if (options.hasLastModified())
	lastModified = static_cast<double>(options.lastModified());
	else
	lastModified = currentTimeMS();
	ASSERT(options.hasEndings());
	bool normalizeLineEndingsToNative = options.endings() == "native";
	if (normalizeLineEndingsToNative)
	UseCounter::count(context, UseCounter::FileAPINativeLineEndings);

	std::unique_ptr<BlobData> blobData = BlobData::create();
	blobData->setContentType(normalizeType(options.type()));
	populateBlobData(blobData.get(), fileBits, normalizeLineEndingsToNative);

	long long fileSize = blobData->length();
	return File::create(fileName, lastModified,
	BlobDataHandle::create(std::move(blobData), fileSize));
	}

	File* File::createWithRelativePath(const String& path,
	const String& relativePath) {
	File* file = new File(path, File::AllContentTypes, File::IsUserVisible);
	file->m_relativePath = relativePath;
	return file;
	}

	File::File(const String& path,
	ContentTypeLookupPolicy policy,
	UserVisibility userVisibility)
	: Blob(BlobDataHandle::create(createBlobDataForFile(path, policy), -1)),
	m_hasBackingFile(true),
	m_userVisibility(userVisibility),
	m_path(path),
	m_name(Platform::current()->fileUtilities()->baseName(path)),
	m_snapshotSize(-1),
	m_snapshotModificationTimeMS(invalidFileTime()) {}

	File::File(const String& path,
	const String& name,
	ContentTypeLookupPolicy policy,
	UserVisibility userVisibility)
	: Blob(BlobDataHandle::create(
	createBlobDataForFileWithName(path, name, policy),
	-1)),
	m_hasBackingFile(true),
	m_userVisibility(userVisibility),
	m_path(path),
	m_name(name),
	m_snapshotSize(-1),
	m_snapshotModificationTimeMS(invalidFileTime()) {}

	File::File(const String& path,
	const String& name,
	const String& relativePath,
	UserVisibility userVisibility,
	bool hasSnapshotData,
	uint64_t size,
	double lastModified,
	PassRefPtr<BlobDataHandle> blobDataHandle)
	: Blob(std::move(blobDataHandle)),
	m_hasBackingFile(!path.isEmpty() \|\| !relativePath.isEmpty()),
	m_userVisibility(userVisibility),
	m_path(path),
	m_name(name),
	m_snapshotSize(hasSnapshotData ? static_cast<long long>(size) : -1),
	m_snapshotModificationTimeMS(hasSnapshotData ? lastModified
	: invalidFileTime()),
	m_relativePath(relativePath) {}

	File::File(const String& name,
	double modificationTimeMS,
	PassRefPtr<BlobDataHandle> blobDataHandle)
	: Blob(std::move(blobDataHandle)),
	m_hasBackingFile(false),
	m_userVisibility(File::IsNotUserVisible),
	m_name(name),
	m_snapshotSize(Blob::size()),
	m_snapshotModificationTimeMS(modificationTimeMS) {}

	File::File(const String& name,
	const FileMetadata& metadata,
	UserVisibility userVisibility)
	: Blob(BlobDataHandle::create(
	createBlobDataForFileWithMetadata(name, metadata),
	metadata.length)),
	m_hasBackingFile(true),
	m_userVisibility(userVisibility),
	m_path(metadata.platformPath),
	m_name(name),
	m_snapshotSize(metadata.length),
	m_snapshotModificationTimeMS(metadata.modificationTime) {}

	File::File(const KURL& fileSystemURL,
	const FileMetadata& metadata,
	UserVisibility userVisibility)
	: Blob(BlobDataHandle::create(
	createBlobDataForFileSystemURL(fileSystemURL, metadata),
	metadata.length)),
	m_hasBackingFile(false),
	m_userVisibility(userVisibility),
	m_name(decodeURLEscapeSequences(fileSystemURL.lastPathComponent())),
	m_fileSystemURL(fileSystemURL),
	m_snapshotSize(metadata.length),
	m_snapshotModificationTimeMS(metadata.modificationTime) {}

	File::File(const File& other)
	: Blob(other.blobDataHandle()),
	m_hasBackingFile(other.m_hasBackingFile),
	m_userVisibility(other.m_userVisibility),
	m_path(other.m_path),
	m_name(other.m_name),
	m_fileSystemURL(other.m_fileSystemURL),
	m_snapshotSize(other.m_snapshotSize),
	m_snapshotModificationTimeMS(other.m_snapshotModificationTimeMS),
	m_relativePath(other.m_relativePath) {}

	File* File::clone(const String& name) const {
	File* file = new File(*this);
	if (!name.isNull())
	file->m_name = name;
	return file;
	}

	double File::lastModifiedMS() const {
	if (hasValidSnapshotMetadata() &&
	isValidFileTime(m_snapshotModificationTimeMS))
	return m_snapshotModificationTimeMS;

	double modificationTimeMS;
	if (hasBackingFile() && getFileModificationTime(m_path, modificationTimeMS) &&
	isValidFileTime(modificationTimeMS))
	return modificationTimeMS;

	return currentTimeMS();
	}

	long long File::lastModified() const {
	double modifiedDate = lastModifiedMS();

	// The getter should return the current time when the last modification time
	// isn't known.
	if (!isValidFileTime(modifiedDate))
	modifiedDate = currentTimeMS();

	// lastModified returns a number, not a Date instance,
	// http://dev.w3.org/2006/webapi/FileAPI/#file-attrs
	return floor(modifiedDate);
	}

	double File::lastModifiedDate() const {
	double modifiedDate = lastModifiedMS();

	// The getter should return the current time when the last modification time
	// isn't known.
	if (!isValidFileTime(modifiedDate))
	modifiedDate = currentTimeMS();

	// lastModifiedDate returns a Date instance,
	// http://www.w3.org/TR/FileAPI/#dfn-lastModifiedDate
	return modifiedDate;
	}

	unsigned long long File::size() const {
	if (hasValidSnapshotMetadata())
	return m_snapshotSize;

	// FIXME: JavaScript cannot represent sizes as large as unsigned long long, we
	// need to come up with an exception to throw if file size is not
	// representable.
	long long size;
	if (!hasBackingFile() \|\| !getFileSize(m_path, size))
	return 0;
	return static_cast<unsigned long long>(size);
	}

	Blob* File::slice(long long start,
	long long end,
	const String& contentType,
	ExceptionState& exceptionState) const {
	if (isClosed()) {
	exceptionState.throwDOMException(InvalidStateError,
	"File has been closed.");
	return nullptr;
	}

	if (!m_hasBackingFile)
	return Blob::slice(start, end, contentType, exceptionState);

	// FIXME: This involves synchronous file operation. We need to figure out how
	// to make it asynchronous.
	long long size;
	double modificationTimeMS;
	captureSnapshot(size, modificationTimeMS);
	clampSliceOffsets(size, start, end);

	long long length = end - start;
	std::unique_ptr<BlobData> blobData = BlobData::create();
	blobData->setContentType(normalizeType(contentType));
	if (!m_fileSystemURL.isEmpty()) {
	blobData->appendFileSystemURL(m_fileSystemURL, start, length,
	modificationTimeMS / msPerSecond);
	} else {
	ASSERT(!m_path.isEmpty());
	blobData->appendFile(m_path, start, length,
	modificationTimeMS / msPerSecond);
	}
	return Blob::create(BlobDataHandle::create(std::move(blobData), length));
	}

	void File::captureSnapshot(long long& snapshotSize,
	double& snapshotModificationTimeMS) const {
	if (hasValidSnapshotMetadata()) {
	snapshotSize = m_snapshotSize;
	snapshotModificationTimeMS = m_snapshotModificationTimeMS;
	return;
	}

	// 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.
	// If we fail to retrieve the size or modification time, probably due to that
	// the file has been deleted, 0 size is returned.
	FileMetadata metadata;
	if (!hasBackingFile() \|\| !getFileMetadata(m_path, metadata)) {
	snapshotSize = 0;
	snapshotModificationTimeMS = invalidFileTime();
	return;
	}

	snapshotSize = metadata.length;
	snapshotModificationTimeMS = metadata.modificationTime;
	}

	void File::close(ScriptState* scriptState, ExceptionState& exceptionState) {
	if (isClosed()) {
	exceptionState.throwDOMException(InvalidStateError,
	"Blob has been closed.");
	return;
	}

	// Reset the File to its closed representation, an empty
	// Blob. The name isn't cleared, as it should still be
	// available.
	m_hasBackingFile = false;
	m_path = String();
	m_fileSystemURL = KURL();
	invalidateSnapshotMetadata();
	m_relativePath = String();
	Blob::close(scriptState, exceptionState);
	}

	void File::appendTo(BlobData& blobData) const {
	if (!m_hasBackingFile) {
	Blob::appendTo(blobData);
	return;
	}

	// FIXME: This involves synchronous file operation. We need to figure out how
	// to make it asynchronous.
	long long size;
	double modificationTimeMS;
	captureSnapshot(size, modificationTimeMS);
	if (!m_fileSystemURL.isEmpty()) {
	blobData.appendFileSystemURL(m_fileSystemURL, 0, size,
	modificationTimeMS / msPerSecond);
	return;
	}
	ASSERT(!m_path.isEmpty());
	blobData.appendFile(m_path, 0, size, modificationTimeMS / msPerSecond);
	}

	bool File::hasSameSource(const File& other) const {
	if (m_hasBackingFile != other.m_hasBackingFile)
	return false;

	if (m_hasBackingFile)
	return m_path == other.m_path;

	if (m_fileSystemURL.isEmpty() != other.m_fileSystemURL.isEmpty())
	return false;

	if (!m_fileSystemURL.isEmpty())
	return m_fileSystemURL == other.m_fileSystemURL;

	return uuid() == other.uuid();
	}

	} // namespace blink