[BlobStorage] Implementing disk.

storage/browser/blob/blob_memory_controller.cc

 // Copyright 2016 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 "storage/browser/blob/blob_memory_controller.h"
 
 #include <algorithm>
+#include <numeric>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/containers/small_map.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 20 matching lines @@
 namespace {
 using FileCreationInfo = BlobMemoryController::FileCreationInfo;
 using MemoryAllocation = BlobMemoryController::MemoryAllocation;
 using QuotaAllocationTask = BlobMemoryController::QuotaAllocationTask;
 
 File::Error CreateBlobDirectory(const FilePath& blob_storage_dir) {
   File::Error error = File::FILE_OK;
   base::CreateDirectoryAndGetError(blob_storage_dir, &error);
   UMA_HISTOGRAM_ENUMERATION("Storage.Blob.CreateDirectoryResult", -error,
                             -File::FILE_ERROR_MAX);
+  DLOG_IF(ERROR, error != File::FILE_OK)
+      << "Error creating blob storage directory: " << error;
   return error;
 }
 
 void DestructFile(File infos_without_references) {}
 
 // Used for new unpopulated file items. Caller must populate file reference in
 // returned FileCreationInfos.
 std::pair<std::vector<FileCreationInfo>, File::Error> CreateEmptyFiles(
     const FilePath& blob_storage_dir,
     scoped_refptr<base::TaskRunner> file_task_runner,
     std::vector<base::FilePath> file_paths) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   File::Error dir_create_status = CreateBlobDirectory(blob_storage_dir);
   if (dir_create_status != File::FILE_OK)
     return std::make_pair(std::vector<FileCreationInfo>(), dir_create_status);
 
   std::vector<FileCreationInfo> result;
   for (const base::FilePath& file_path : file_paths) {
     FileCreationInfo creation_info;
     // Try to open our file.
     File file(file_path, File::FLAG_CREATE_ALWAYS | File::FLAG_WRITE);
     creation_info.path = std::move(file_path);
     creation_info.file_deletion_runner = file_task_runner;
     creation_info.error = file.error_details();
     if (creation_info.error != File::FILE_OK) {
       return std::make_pair(std::vector<FileCreationInfo>(),
                             creation_info.error);
     }
-
-    // Grab the file info to get the "last modified" time and store the file.
-    File::Info file_info;
-    bool success = file.GetInfo(&file_info);
-    creation_info.error = success ? File::FILE_OK : File::FILE_ERROR_FAILED;
-    if (!success) {
-      return std::make_pair(std::vector<FileCreationInfo>(),
-                            creation_info.error);
-    }
     creation_info.file = std::move(file);
 
     result.push_back(std::move(creation_info));
   }
   return std::make_pair(std::move(result), File::FILE_OK);
 }
 
 // Used to evict multiple memory items out to a single file. Caller must
 // populate file reference in returned FileCreationInfo.
 FileCreationInfo CreateFileAndWriteItems(
@@ skipping 31 matching lines @@
           file.WriteAtCurrentPos(element->bytes() + (length - bytes_left),
                                  base::saturated_cast<int>(bytes_left));
       if (bytes_written < 0)
         break;
       DCHECK_LE(static_cast<size_t>(bytes_written), bytes_left);
       bytes_left -= bytes_written;
     }
     if (bytes_written < 0)
       break;
   }
+  if (!file.Flush()) {
+    creation_info.error = File::FILE_ERROR_FAILED;
+    return creation_info;
+  }
 
   File::Info info;
   bool success = file.GetInfo(&info);
   creation_info.error =
       bytes_written < 0 || !success ? File::FILE_ERROR_FAILED : File::FILE_OK;
   creation_info.last_modified = info.last_modified;
   return creation_info;
 }
 
 uint64_t GetTotalSizeAndFileSizes(
     const std::vector<scoped_refptr<ShareableBlobDataItem>>&
         unreserved_file_items,
     std::vector<uint64_t>* file_sizes_output) {
   uint64_t total_size_output = 0;
   base::SmallMap<std::map<uint64_t, uint64_t>> file_id_to_sizes;
   for (const auto& item : unreserved_file_items) {
     const DataElement& element = item->item()->data_element();
     uint64_t file_id = BlobDataBuilder::GetFutureFileID(element);
     auto it = file_id_to_sizes.find(file_id);
     if (it != file_id_to_sizes.end())
       it->second = std::max(it->second, element.offset() + element.length());
     else
       file_id_to_sizes[file_id] = element.offset() + element.length();
     total_size_output += element.length();
   }
   for (const auto& size_pair : file_id_to_sizes) {
     file_sizes_output->push_back(size_pair.second);
   }
+  DCHECK_EQ(std::accumulate(file_sizes_output->begin(),
+                            file_sizes_output->end(), 0ull),
+            total_size_output)
+      << "Illegal builder configuration, temporary files must be totally used.";
   return total_size_output;
 }
 
 }  // namespace
 
 FileCreationInfo::FileCreationInfo() {}
 FileCreationInfo::~FileCreationInfo() {
   if (file.IsValid()) {
     DCHECK(file_deletion_runner);
     file_deletion_runner->PostTask(
@@ skipping 116 matching lines @@
     base::PostTaskAndReplyWithResult(
         controller_->file_runner_.get(), FROM_HERE,
         base::Bind(&CreateEmptyFiles, controller_->blob_storage_dir_,
                    controller_->file_runner_, base::Passed(&file_paths)),
         base::Bind(&FileQuotaAllocationTask::OnCreateEmptyFiles,
                    weak_factory_.GetWeakPtr(), base::Passed(&references)));
     controller_->RecordTracingCounters();
   }
   ~FileQuotaAllocationTask() override {}
 
-  void RunDoneCallback(bool success, std::vector<FileCreationInfo> file_info) {
+  void RunDoneCallback(std::vector<FileCreationInfo> file_info, bool success) {
     // Make sure we clear the weak pointers we gave to the caller beforehand.
     weak_factory_.InvalidateWeakPtrs();
 
     // We want to destroy this object on the exit of this method if we were
     // successful.
     std::unique_ptr<FileQuotaAllocationTask> this_object;
     if (success) {
       for (auto& item : pending_items_) {
         item->set_state(ShareableBlobDataItem::QUOTA_GRANTED);
       }
       this_object = std::move(*my_list_position_);
       controller_->pending_file_quota_tasks_.erase(my_list_position_);
     }
 
-    done_callback_.Run(success, std::move(file_info));
+    done_callback_.Run(std::move(file_info), success);
   }
 
   base::WeakPtr<QuotaAllocationTask> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
   void Cancel() override {
     // This call destroys this object. We rely on ShareableFileReference's
     // final release callback for disk_usage_ accounting.
     controller_->pending_file_quota_tasks_.erase(my_list_position_);
   }
 
   void OnCreateEmptyFiles(
       std::vector<scoped_refptr<ShareableFileReference>> references,
       std::pair<std::vector<FileCreationInfo>, File::Error> files_and_error) {
     auto& files = files_and_error.first;
     if (files.empty()) {
       DCHECK_GE(controller_->disk_used_, allocation_size_);
       controller_->disk_used_ -= allocation_size_;
       // This will call our callback and delete the object correctly.
       controller_->DisableFilePaging(files_and_error.second);
       return;
     }
     DCHECK_EQ(files.size(), references.size());
     for (size_t i = 0; i < files.size(); i++) {
       files[i].file_reference = std::move(references[i]);
     }
-    RunDoneCallback(true, std::move(files));
+    RunDoneCallback(std::move(files), true);
   }
 
   // The my_list_position_ iterator is stored so that we can remove ourself
   // from the task list when we are cancelled.
   void set_my_list_position(
       PendingFileQuotaTaskList::iterator my_list_position) {
     my_list_position_ = my_list_position;
   }
 
  private:
@@ skipping 17 matching lines @@
       file_runner_(std::move(file_runner)),
       populated_memory_items_(
           base::MRUCache<uint64_t, ShareableBlobDataItem*>::NO_AUTO_EVICT),
       weak_factory_(this) {}
 
 BlobMemoryController::~BlobMemoryController() {}
 
 void BlobMemoryController::DisableFilePaging(base::File::Error reason) {
   UMA_HISTOGRAM_ENUMERATION("Storage.Blob.PagingDisabled", -reason,
                             -File::FILE_ERROR_MAX);
+  DLOG(ERROR) << "Blob storage paging disabled, reason: " << reason;
   file_paging_enabled_ = false;
   in_flight_memory_used_ = 0;
   items_paging_to_file_.clear();
   pending_evictions_ = 0;
   pending_memory_quota_total_size_ = 0;
   populated_memory_items_.Clear();
   populated_memory_items_bytes_ = 0;
   file_runner_ = nullptr;
 
   PendingMemoryQuotaTaskList old_memory_tasks;
   PendingFileQuotaTaskList old_file_tasks;
   std::swap(old_memory_tasks, pending_memory_quota_tasks_);
   std::swap(old_file_tasks, pending_file_quota_tasks_);
 
   // Don't call the callbacks until we have a consistent state.
   for (auto& memory_request : old_memory_tasks) {
     memory_request->RunDoneCallback(false);
   }
   for (auto& file_request : old_file_tasks) {
-    file_request->RunDoneCallback(false, std::vector<FileCreationInfo>());
+    file_request->RunDoneCallback(std::vector<FileCreationInfo>(), false);
   }
 }
 
 BlobMemoryController::Strategy BlobMemoryController::DetermineStrategy(
     size_t preemptive_transported_bytes,
     uint64_t total_transportation_bytes) const {
   if (total_transportation_bytes == 0)
     return Strategy::NONE_NEEDED;
   if (!CanReserveQuota(total_transportation_bytes))
     return Strategy::TOO_LARGE;
@@ skipping 326 matching lines @@
   MaybeGrantPendingMemoryRequests();
 }
 
 void BlobMemoryController::OnBlobFileDelete(uint64_t size,
                                             const FilePath& path) {
   DCHECK_LE(size, disk_used_);
   disk_used_ -= size;
 }
 
 }  // namespace storage