Upgrade Blink to milliseconds-based last modified filetimes, part 3.

Source/bindings/core/v8/ScriptValueSerializer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
 #include "core/dom/DOMDataView.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebBlobInfo.h"
+#include "wtf/DateMath.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 
 // FIXME: consider crashing in debug mode on deserialization errors
 // NOTE: be sure to change wireFormatVersion as necessary!
 
 namespace blink {
 
 // This code implements the HTML5 Structured Clone algorithm:
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/urls.html#safe-passing-of-structured-data
@@ skipping 343 matching lines @@
     doWriteWebCoreString(file.name());
     doWriteWebCoreString(file.webkitRelativePath());
     doWriteWebCoreString(file.uuid());
     doWriteWebCoreString(file.type());
 
     // FIXME don't use 1 byte to encode a flag.
     if (file.hasValidSnapshotMetadata()) {
         doWriteUint32(static_cast<uint8_t>(1));
 
         long long size;
-        double lastModified;
-        file.captureSnapshot(size, lastModified);
+        double lastModifiedMS;
+        file.captureSnapshot(size, lastModifiedMS);
         doWriteUint64(static_cast<uint64_t>(size));
-        doWriteNumber(lastModified);
+        doWriteNumber(lastModifiedMS);
     } else {
         doWriteUint32(static_cast<uint8_t>(0));
     }
 
     doWriteUint32(static_cast<uint8_t>((file.userVisibility() == File::IsUserVisible) ? 1 : 0));
 }
 
 void SerializedScriptValueWriter::doWriteArrayBuffer(const DOMArrayBuffer& arrayBuffer)
 {
     uint32_t byteLength = arrayBuffer.byteLength();
@@ skipping 584 matching lines @@
     m_blobInfo->append(WebBlobInfo(uuid, type, size));
     return true;
 }
 
 bool ScriptValueSerializer::appendFileInfo(const File* file, int* index)
 {
     if (!m_blobInfo)
         return false;
 
     long long size = -1;
-    double lastModified = invalidFileTime();
-    file->captureSnapshot(size, lastModified);
+    double lastModifiedMS = invalidFileTime();
+    file->captureSnapshot(size, lastModifiedMS);
     *index = m_blobInfo->size();
+    // FIXME: transition WebBlobInfo.lastModified to be milliseconds-based also.
+    double lastModified = lastModifiedMS / msPerSecond;
     m_blobInfo->append(WebBlobInfo(file->uuid(), file->path(), file->name(), file->type(), lastModified, size));
     return true;
 }
 
 bool SerializedScriptValueReader::read(v8::Handle<v8::Value>* value, ScriptValueCompositeCreator& creator)
 {
     SerializationTag tag;
     if (!readTag(&tag))
         return false;
     return readWithTag(tag, value, creator);
@@ skipping 586 matching lines @@
     if (m_version < 3)
         return nullptr;
     ASSERT(!m_blobInfo);
     String path;
     String name;
     String relativePath;
     String uuid;
     String type;
     uint32_t hasSnapshot = 0;
     uint64_t size = 0;
-    double lastModified = 0;
+    double lastModifiedMS = 0;
     if (!readWebCoreString(&path))
         return nullptr;
     if (m_version >= 4 && !readWebCoreString(&name))
         return nullptr;
     if (m_version >= 4 && !readWebCoreString(&relativePath))
         return nullptr;
     if (!readWebCoreString(&uuid))
         return nullptr;
     if (!readWebCoreString(&type))
         return nullptr;
     if (m_version >= 4 && !doReadUint32(&hasSnapshot))
         return nullptr;
     if (hasSnapshot) {
         if (!doReadUint64(&size))
             return nullptr;
-        if (!doReadNumber(&lastModified))
+        if (!doReadNumber(&lastModifiedMS))
             return nullptr;
+        if (m_version < 8)
+            lastModifiedMS *= msPerSecond;
     }
     uint32_t isUserVisible = 1;
     if (m_version >= 7 && !doReadUint32(&isUserVisible))
         return nullptr;
     const File::UserVisibility userVisibility = (isUserVisible > 0) ? File::IsUserVisible : File::IsNotUserVisible;
-    return File::createFromSerialization(path, name, relativePath, userVisibility, hasSnapshot > 0, size, lastModified, getOrCreateBlobDataHandle(uuid, type));
+    return File::createFromSerialization(path, name, relativePath, userVisibility, hasSnapshot > 0, size, lastModifiedMS, getOrCreateBlobDataHandle(uuid, type));
 }
 
 File* SerializedScriptValueReader::readFileIndexHelper()
 {
     if (m_version < 3)
         return nullptr;
     ASSERT(m_blobInfo);
     uint32_t index;
     if (!doReadUint32(&index) || index >= m_blobInfo->size())
         return nullptr;
     const WebBlobInfo& info = (*m_blobInfo)[index];
-    return File::createFromIndexedSerialization(info.filePath(), info.fileName(), info.size(), info.lastModified(), getOrCreateBlobDataHandle(info.uuid(), info.type(), info.size()));
+    // FIXME: transition WebBlobInfo.lastModified to be milliseconds-based also.
+    double lastModifiedMS = info.lastModified() * msPerSecond;
+    return File::createFromIndexedSerialization(info.filePath(), info.fileName(), info.size(), lastModifiedMS, getOrCreateBlobDataHandle(info.uuid(), info.type(), info.size()));
 }
 
 bool SerializedScriptValueReader::doReadUint32(uint32_t* value)
 {
     return doReadUintHelper(value);
 }
 
 bool SerializedScriptValueReader::doReadUint64(uint64_t* value)
 {
     return doReadUintHelper(value);
@@ skipping 230 matching lines @@
         return false;
     uint32_t objectReference = m_openCompositeReferenceStack[m_openCompositeReferenceStack.size() - 1];
     m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() - 1);
     if (objectReference >= m_objectPool.size())
         return false;
     *object = m_objectPool[objectReference];
     return true;
 }
 
 } // namespace blink