[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 64 matching lines @@
   }
 }
 
 bool WriteSingleChunk(base::File* file, const char* memory, size_t size) {
   size_t written = 0;
   while (written < size) {
     size_t writing_size = base::saturated_cast<int>(size - written);
     int actual_written =
         file->WriteAtCurrentPos(memory, static_cast<int>(writing_size));
     bool write_failed = actual_written < 0;
+    LOG_IF(ERROR, write_failed) << "Write failed";
     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;
+    LOG(ERROR) << "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));
   }
+  // First we write everything, then we flush, then we grab the last modified
+  // times.
   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();
   }
+  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;
+    LOG(ERROR) << "got post-flush modified time "
+               << info.last_modified.ToInternalValue();
+    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 226 matching lines @@
 
 BlobTransportController::~BlobTransportController() {}
 
 void BlobTransportController::OnFileWriteComplete(
     IPC::Sender* sender,
     const std::string& uuid,
     const base::Optional<std::vector<storage::BlobItemBytesResponse>>& result) {
   if (blob_storage_.find(uuid) == blob_storage_.end())
     return;
   if (!result) {
+    LOG(ERROR) << "Error writing files";
     sender->Send(new BlobStorageMsg_SendBlobStatus(
         uuid, BlobStatus::ERR_FILE_WRITE_FAILED));
     ReleaseBlobConsolidation(uuid);
     return;
   }
   sender->Send(new BlobStorageMsg_MemoryItemResponse(uuid, result.value()));
 }
 
 void BlobTransportController::StoreBlobDataForRequests(
     const std::string& uuid,
     scoped_refptr<BlobConsolidation> consolidation,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner) {
   if (!main_thread_runner_.get()) {
     main_thread_runner_ = std::move(main_runner);
   }
   blob_storage_[uuid] = std::move(consolidation);
 }
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   if (blob_storage_.erase(uuid)) {
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
 }
 
 }  // namespace content