Change the type of blink::FileMetadata::modification_time

from |double| to |base::Optional<base::Time>|.

This CL is the first step to stop using |double| for file timestamps in Blink.

Though base::Time can be an is_null() value, we apply
base::Optional<base::Time> instead of just base::Time because:

 - In JavaScript, the null base::Time, which represents
   1601-01-01 00:00 UTC, is a valid time. We have to use
   base::Optional<base::Time> in some parts of Blink.

 - data_element.mojom applies |mojo_base.mojom.Time?| for file timestamps,
  and it is mapped to |base::Optional<base::Time>| in C++.

This CL should have no user-visible behavior changes.

Bug: 988343
Change-Id: I91f592b31cf8e61053969530fafc689eea8ff538
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1930756
Auto-Submit: Kent Tamura <tkent@chromium.org>
Reviewed-by: Joshua Bell <jsbell@chromium.org>
Commit-Queue: Kent Tamura <tkent@chromium.org>
Cr-Commit-Position: refs/heads/master@{#718489}

third_party/blink/renderer/core/fileapi/file.cc

@@ -95,11 +95,13 @@ static std::unique_ptr<BlobData> CreateBlobDataForFileWithMetadata(
   std::unique_ptr<BlobData> blob_data;
   if (metadata.length == BlobData::kToEndOfFile) {
     blob_data = BlobData::CreateForFileWithUnknownSize(
-        metadata.platform_path, metadata.modification_time / kMsPerSecond);
+        metadata.platform_path,
+        ToJsTimeOrNaN(metadata.modification_time) / kMsPerSecond);
   } else {
     blob_data = std::make_unique<BlobData>();
-    blob_data->AppendFile(metadata.platform_path, 0, metadata.length,
-                          metadata.modification_time / kMsPerSecond);
+    blob_data->AppendFile(
+        metadata.platform_path, 0, metadata.length,
+        ToJsTimeOrNaN(metadata.modification_time) / kMsPerSecond);
   }
   blob_data->SetContentType(GetContentTypeFromFileName(
       file_system_name, File::kWellKnownContentTypes));
@@ -112,11 +114,13 @@ static std::unique_ptr<BlobData> CreateBlobDataForFileSystemURL(
   std::unique_ptr<BlobData> blob_data;
   if (metadata.length == BlobData::kToEndOfFile) {
     blob_data = BlobData::CreateForFileSystemURLWithUnknownSize(
-        file_system_url, metadata.modification_time / kMsPerSecond);
+        file_system_url,
+        ToJsTimeOrNaN(metadata.modification_time) / kMsPerSecond);
   } else {
     blob_data = std::make_unique<BlobData>();
-    blob_data->AppendFileSystemURL(file_system_url, 0, metadata.length,
-                                   metadata.modification_time / kMsPerSecond);
+    blob_data->AppendFileSystemURL(
+        file_system_url, 0, metadata.length,
+        ToJsTimeOrNaN(metadata.modification_time) / kMsPerSecond);
   }
   blob_data->SetContentType(GetContentTypeFromFileName(
       file_system_url.GetPath(), File::kWellKnownContentTypes));
@@ -252,7 +256,8 @@ File::File(const String& name,
       user_visibility_(user_visibility),
       path_(metadata.platform_path),
       name_(name),
-      snapshot_modification_time_ms_(metadata.modification_time) {
+      snapshot_modification_time_ms_(
+          ToJsTimeOrNaN(metadata.modification_time)) {
   if (metadata.length >= 0)
     snapshot_size_ = metadata.length;
 }
@@ -268,7 +273,8 @@ File::File(const KURL& file_system_url,
       name_(DecodeURLEscapeSequences(file_system_url.LastPathComponent(),
                                      DecodeURLMode::kUTF8OrIsomorphic)),
       file_system_url_(file_system_url),
-      snapshot_modification_time_ms_(metadata.modification_time) {
+      snapshot_modification_time_ms_(
+          ToJsTimeOrNaN(metadata.modification_time)) {
   if (metadata.length >= 0)
     snapshot_size_ = metadata.length;
 }
@@ -296,11 +302,10 @@ double File::LastModifiedMS() const {
       IsValidFileTime(snapshot_modification_time_ms_))
     return snapshot_modification_time_ms_;
 
-  double modification_time_ms;
-  if (HasBackingFile() &&
-      GetFileModificationTime(path_, modification_time_ms) &&
-      IsValidFileTime(modification_time_ms))
-    return modification_time_ms;
+  base::Optional<base::Time> modification_time;
+  if (HasBackingFile() && GetFileModificationTime(path_, modification_time) &&
+      modification_time)
+    return modification_time->ToJsTimeIgnoringNull();
 
   return base::Time::Now().ToDoubleT() * 1000.0;
 }
@@ -392,7 +397,7 @@ void File::CaptureSnapshot(uint64_t& snapshot_size,
   }
 
   snapshot_size = static_cast<uint64_t>(metadata.length);
-  snapshot_modification_time_ms = metadata.modification_time;
+  snapshot_modification_time_ms = ToJsTimeOrNaN(metadata.modification_time);
 }
 
 void File::AppendTo(BlobData& blob_data) const {

third_party/blink/renderer/core/html/forms/file_input_type.cc

@@ -288,7 +288,8 @@ FileList* FileInputType::CreateFileList(const FileChooserFileInfoList& files,
     } else {
       const auto& fs_info = file->get_file_system();
       FileMetadata metadata;
-      metadata.modification_time = fs_info->modification_time.ToJsTime();
+      metadata.modification_time =
+          NullableTimeToOptionalTime(fs_info->modification_time);
       metadata.length = fs_info->length;
       metadata.type = FileMetadata::kTypeFile;
       file_list->Append(File::CreateForFileSystemFile(fs_info->url, metadata,

third_party/blink/renderer/modules/filesystem/metadata.cc

@@ -14,9 +14,7 @@ ScriptValue Metadata::modificationTime(ScriptState* script_state) const {
   // metadata.modificationTime returns a Date object with an invalid state.
   // Passing Time::Max() here creates such a Date object.
   base::Time time =
-      std::isfinite(platform_metadata_.modification_time)
-          ? base::Time::FromJsTime(platform_metadata_.modification_time)
-          : base::Time::Max();
+      platform_metadata_.modification_time.value_or(base::Time::Max());
   return ScriptValue(script_state->GetIsolate(), ToV8(time, script_state));
 }
 

third_party/blink/renderer/platform/file_metadata.cc

@@ -49,10 +49,8 @@ namespace blink {
 // static
 FileMetadata FileMetadata::From(const base::File::Info& file_info) {
   FileMetadata file_metadata;
-  if (file_info.last_modified.is_null())
-    file_metadata.modification_time = std::numeric_limits<double>::quiet_NaN();
-  else
-    file_metadata.modification_time = file_info.last_modified.ToJsTime();
+  file_metadata.modification_time =
+      NullableTimeToOptionalTime(file_info.last_modified);
   file_metadata.length = file_info.size;
   if (file_info.is_directory)
     file_metadata.type = FileMetadata::kTypeDirectory;
@@ -69,7 +67,8 @@ bool GetFileSize(const String& path, int64_t& result) {
   return true;
 }
 
-bool GetFileModificationTime(const String& path, double& result) {
+bool GetFileModificationTime(const String& path,
+                             base::Optional<base::Time>& result) {
   FileMetadata metadata;
   if (!GetFileMetadata(path, metadata))
     return false;
@@ -91,10 +90,8 @@ bool GetFileMetadata(const String& path, FileMetadata& metadata) {
   if (!host->GetFileInfo(WebStringToFilePath(path), &file_info) || !file_info)
     return false;
 
-  // Blink now expects NaN as uninitialized/null Date.
-  metadata.modification_time = file_info->last_modified.is_null()
-                                   ? std::numeric_limits<double>::quiet_NaN()
-                                   : file_info->last_modified.ToJsTime();
+  metadata.modification_time =
+      NullableTimeToOptionalTime(file_info->last_modified);
   metadata.length = file_info->size;
   metadata.type = file_info->is_directory ? FileMetadata::kTypeDirectory
                                           : FileMetadata::kTypeFile;

third_party/blink/renderer/platform/file_metadata.h

@@ -31,16 +31,18 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_FILE_METADATA_H_
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_FILE_METADATA_H_
 
-#include <time.h>
 #include "base/files/file.h"
+#include "base/optional.h"
+#include "base/time/time.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/weborigin/kurl.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
-#include "third_party/blink/renderer/platform/wtf/math_extras.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 
 namespace blink {
 
+// TODO(crbug.com/988343): InvalidFileTime() and IsValidFileTime() should be
+// removed. File timestamps should be represented as base::Optional<base::Time>.
 inline double InvalidFileTime() {
   return std::numeric_limits<double>::quiet_NaN();
 }
@@ -53,13 +55,12 @@ class FileMetadata {
 
  public:
   FileMetadata()
-      : modification_time(InvalidFileTime()), length(-1), type(kTypeUnknown) {}
+      : modification_time(base::nullopt), length(-1), type(kTypeUnknown) {}
 
   PLATFORM_EXPORT static FileMetadata From(const base::File::Info& file_info);
 
-  // The last modification time of the file, in milliseconds.
-  // The value NaN means that the time is not known.
-  double modification_time;
+  // The last modification time of the file.
+  base::Optional<base::Time> modification_time;
 
   // The length of the file in bytes.
   // The value -1 means that the length is not set.
@@ -72,10 +73,24 @@ class FileMetadata {
 };
 
 PLATFORM_EXPORT bool GetFileSize(const String&, int64_t& result);
-PLATFORM_EXPORT bool GetFileModificationTime(const String&, double& result);
+PLATFORM_EXPORT bool GetFileModificationTime(
+    const String&,
+    base::Optional<base::Time>& result);
 PLATFORM_EXPORT bool GetFileMetadata(const String&, FileMetadata&);
 PLATFORM_EXPORT KURL FilePathToURL(const String&);
 
+// TODO(crbug.com/988343): Temporary conversion function. This should be
+// removed.
+inline double ToJsTimeOrNaN(base::Optional<base::Time> time) {
+  return time ? time->ToJsTimeIgnoringNull() : InvalidFileTime();
+}
+
+inline base::Optional<base::Time> NullableTimeToOptionalTime(base::Time time) {
+  if (time.is_null())
+    return base::nullopt;
+  return time;
+}
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_FILE_METADATA_H_