[BlobStorage] Implementing disk.

content/child/blob_storage/blob_transport_controller.cc

 // Copyright 2015 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 "content/child/blob_storage/blob_transport_controller.h"
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 72 matching lines @@
         file->WriteAtCurrentPos(memory, static_cast<int>(writing_size));
     bool write_failed = actual_written < 0;
     UMA_HISTOGRAM_BOOLEAN("Storage.Blob.RendererFileWriteFailed", write_failed);
     if (write_failed)
       return false;
     written += actual_written;
   }
   return true;
 }
 
-base::Optional<base::Time> WriteSingleRequestToDisk(
-    const BlobConsolidation* consolidation,
-    const BlobItemBytesRequest& request,
-    File* file) {
+bool WriteSingleRequestToDisk(const BlobConsolidation* consolidation,
+                              const BlobItemBytesRequest& request,
+                              File* file) {
   if (!file->IsValid())
-    return base::nullopt;
+    return false;
   int64_t seek_distance = file->Seek(
       File::FROM_BEGIN, base::checked_cast<int64_t>(request.handle_offset));
   bool seek_failed = seek_distance < 0;
   UMA_HISTOGRAM_BOOLEAN("Storage.Blob.RendererFileSeekFailed", seek_failed);
-  if (seek_failed) {
-    return base::nullopt;
-  }
+  if (seek_failed)
+    return false;
   BlobConsolidation::ReadStatus status = consolidation->VisitMemory(
       request.renderer_item_index, request.renderer_item_offset, request.size,
       base::Bind(&WriteSingleChunk, file));
   if (status != BlobConsolidation::ReadStatus::OK)
-    return base::nullopt;
-  File::Info info;
-  file->GetInfo(&info);
-  return base::make_optional(info.last_modified);
+    return false;
+  return true;
 }
 
 base::Optional<std::vector<BlobItemBytesResponse>> WriteDiskRequests(
     scoped_refptr<BlobConsolidation> consolidation,
     std::unique_ptr<std::vector<BlobItemBytesRequest>> requests,
     const std::vector<IPC::PlatformFileForTransit>& file_handles) {
   std::vector<BlobItemBytesResponse> responses;
-  std::vector<base::Time> last_modified_times;
-  last_modified_times.resize(file_handles.size());
   // We grab ownership of the file handles here. When this vector is destroyed
   // it will close the files.
   std::vector<File> files;
   files.reserve(file_handles.size());
   for (const auto& file_handle : file_handles) {
     files.emplace_back(IPC::PlatformFileForTransitToFile(file_handle));
   }
   for (const auto& request : *requests) {
-    base::Optional<base::Time> last_modified = WriteSingleRequestToDisk(
-        consolidation.get(), request, &files[request.handle_index]);
-    if (!last_modified) {
+    if (!WriteSingleRequestToDisk(consolidation.get(), request,
+                                  &files[request.handle_index])) {
       return base::nullopt;
     }
-    last_modified_times[request.handle_index] = last_modified.value();
   }
+  // The last modified time needs to be collected after we flush the file.
+  std::vector<base::Time> last_modified_times;
+  last_modified_times.resize(file_handles.size());
+  for (size_t i = 0; i < files.size(); ++i) {
+    auto& file = files[i];
+    if (!file.Flush())
+      return base::nullopt;
+    File::Info info;
+    if (!file.GetInfo(&info))
+      return base::nullopt;
+    last_modified_times[i] = info.last_modified;
+  }
+
   for (const auto& request : *requests) {
     responses.push_back(BlobItemBytesResponse(request.request_number));
     responses.back().time_file_modified =
         last_modified_times[request.handle_index];
   }
 
   return responses;
 }
 
 }  // namespace
@@ skipping 253 matching lines @@
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   if (blob_storage_.erase(uuid)) {
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
 }
 
 }  // namespace content