[BlobStorage] Implementing disk.

storage/browser/blob/blob_storage_context.h

 // Copyright (c) 2013 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.
 
 #ifndef STORAGE_BROWSER_BLOB_BLOB_STORAGE_CONTEXT_H_
 #define STORAGE_BROWSER_BLOB_BLOB_STORAGE_CONTEXT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 18 matching lines @@
 
 namespace base {
 class FilePath;
 class Time;
 class TaskRunner;
 }
 
 namespace content {
 class BlobDispatcherHost;
 class BlobDispatcherHostTest;
+class BlobStorageBrowserTest;
 }
 
 namespace storage {
 class BlobDataBuilder;
 class BlobDataHandle;
 class BlobDataItem;
 class BlobDataSnapshot;
 class ShareableBlobDataItem;
 
 // This class handles the logistics of blob storage within the browser process.
 // We are single threaded and should only be used on the IO thread. In Chromium

[pwnall, 2016/12/01 01:12:14]

"We are single threaded" -> "The class is not threadsafe"?

[dmurph, 2016/12/01 20:40:59]

Done.

 // there is one instance per profile.
 class STORAGE_EXPORT BlobStorageContext {
  public:
   using TransportAllowedCallback = BlobEntry::TransportAllowedCallback;
 
   // Initializes the context without disk support.
   BlobStorageContext();
+  // We enable disk support if |file_runner| isn't null.

[pwnall, 2016/12/01 01:12:14]

We enable disk support -> disk support is enabled.

[dmurph, 2016/12/01 20:40:59]

Done.

+  BlobStorageContext(const base::FilePath& storage_directory,
+                     scoped_refptr<base::TaskRunner> file_runner);
   ~BlobStorageContext();
 
   std::unique_ptr<BlobDataHandle> GetBlobDataFromUUID(const std::string& uuid);
   std::unique_ptr<BlobDataHandle> GetBlobDataFromPublicURL(const GURL& url);
 
   // Always returns a handle to a blob. Use BlobStatus::GetBlobStatus() and
   // BlobStatus::RunOnConstructionComplete(callback) to determine construction
   // completion and possible errors.
   std::unique_ptr<BlobDataHandle> AddFinishedBlob(
       const BlobDataBuilder& builder);
@@ skipping 51 matching lines @@
 
   const BlobMemoryController& memory_controller() { return memory_controller_; }
 
   base::WeakPtr<BlobStorageContext> AsWeakPtr() {
     return ptr_factory_.GetWeakPtr();
   }
 
  protected:
   friend class content::BlobDispatcherHost;
   friend class content::BlobDispatcherHostTest;
+  friend class content::BlobStorageBrowserTest;
   friend class BlobTransportHost;
   friend class BlobTransportHostTest;
   friend class BlobDataHandle;
   friend class BlobDataHandle::BlobDataHandleShared;
   friend class BlobFlattenerTest;
   friend class BlobSliceTest;
   friend class BlobStorageContextTest;
 
+  enum class TransportQuotaType { MEMORY, FILE };
+
   // Transforms a BlobDataBuilder into a BlobEntry with no blob references.
   // BlobSlice is used to flatten out these references. Records the total size
   // and items for memory and file quota requests.
   // Exposed in the header file for testing.
   struct STORAGE_EXPORT BlobFlattener {
     BlobFlattener(const BlobDataBuilder& input_builder,
                   BlobEntry* output_blob,
                   BlobStorageRegistry* registry);
     ~BlobFlattener();
 
     // This can be:
     // * PENDING_QUOTA if we need memory quota, if we're populated and don't
     // need quota.
     // * PENDING_INTERNALS if we're waiting on dependent blobs or we're done.
     // * INVALID_CONSTRUCTION_ARGUMENTS if we have invalid input.
     // * REFERENCED_BLOB_BROKEN if one of the referenced blobs is broken or we
     //   reference ourself.
     BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
 
     // This is the total size of the blob, including all memory, files, etc.
     uint64_t total_size = 0;
     // Total memory size of the blob (not including files, etc).
     uint64_t total_memory_size = 0;
 
     std::vector<std::pair<std::string, BlobEntry*>> dependent_blobs;
 
-    uint64_t memory_quota_needed = 0;
-    std::vector<scoped_refptr<ShareableBlobDataItem>> pending_memory_items;
+    TransportQuotaType transport_quota_type = TransportQuotaType::MEMORY;
+    uint64_t transport_quota_needed = 0;
+    std::vector<scoped_refptr<ShareableBlobDataItem>> pending_transport_items;
+    // Hold a separate vector of pointers to declare them as populated.
+    std::vector<ShareableBlobDataItem*> transport_items;
 
-    std::vector<ShareableBlobDataItem*> transport_items;
+    // Copy quota is always memory quota.
+    uint64_t copy_quota_needed = 0;
+    std::vector<scoped_refptr<ShareableBlobDataItem>> pending_copy_items;
 
     // These record all future copies we'll need to do from referenced blobs.
     // This
     // happens when we do a partial slice from a pending data or file item.
     std::vector<BlobEntry::ItemCopyEntry> copies;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(BlobFlattener);
   };
 
@@ skipping 52 matching lines @@
   void NotifyTransportCompleteInternal(BlobEntry* entry);
 
   void CancelBuildingBlobInternal(BlobEntry* entry, BlobStatus reason);
 
   void FinishBuilding(BlobEntry* entry);
 
   void RequestTransport(
       BlobEntry* entry,
       std::vector<BlobMemoryController::FileCreationInfo> files);
 
-  void OnEnoughSizeForMemory(const std::string& uuid, bool can_fit);
+  void OnEnoughSpaceForTransportByFiles(
+      const std::string& uuid,
+      bool can_fit,
+      std::vector<BlobMemoryController::FileCreationInfo> files);
+
+  void OnEnoughSpaceForTransportByMemory(const std::string& uuid, bool can_fit);
+
+  void OnEnoughSpaceForCopies(const std::string& uuid, bool can_fit);
 
   void OnDependentBlobFinished(const std::string& owning_blob_uuid,
                                BlobStatus reason);
 
   void ClearAndFreeMemory(BlobEntry* entry);
 
   BlobStorageRegistry registry_;
   BlobMemoryController memory_controller_;
   base::WeakPtrFactory<BlobStorageContext> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobStorageContext);
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_BLOB_BLOB_STORAGE_CONTEXT_H_