Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(186)

Unified Diff: storage/browser/blob/internal_blob_data.h

Issue 2055053003: [BlobAsync] Disk support for blob storage (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « storage/browser/blob/blob_transport_result.h ('k') | storage/browser/blob/internal_blob_data.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: storage/browser/blob/internal_blob_data.h
diff --git a/storage/browser/blob/internal_blob_data.h b/storage/browser/blob/internal_blob_data.h
index 65db2f3cdc322fe85a8c01e275d2c988601b95e9..0b0a01c84ef2107541921a97471ffda256df9540 100644
--- a/storage/browser/blob/internal_blob_data.h
+++ b/storage/browser/blob/internal_blob_data.h
@@ -11,70 +11,161 @@
#include <string>
#include <vector>
+#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
-#include "storage/browser/blob/shareable_blob_data_item.h"
+#include "base/memory/weak_ptr.h"
+#include "base/optional.h"
+#include "storage/browser/blob/blob_memory_controller.h"
+#include "storage/browser/storage_browser_export.h"
namespace storage {
+class BlobDataHandle;
+class ShareableBlobDataItem;
class ViewBlobInternalsJob;
-// This class represents a blob in the BlobStorageContext. It is constructed
-// using the internal Builder class.
-class InternalBlobData {
+// This class represents a blob. We export this only for unit tests.
+class STORAGE_EXPORT InternalBlobData {
public:
+ using PopulatationAllowedCallback =
+ base::Callback<void(BlobStatus,
+ std::vector<BlobMemoryController::FileCreationInfo>)>;
+
+ // This records a copy from a referenced blob. When we finish building our
+ // blob we perform all of these copies.
+ struct STORAGE_EXPORT ItemCopyEntry {
+ ItemCopyEntry(scoped_refptr<ShareableBlobDataItem> source_item,
+ size_t source_item_offset,
+ scoped_refptr<ShareableBlobDataItem> dest_item);
+ ~ItemCopyEntry();
+ ItemCopyEntry(const ItemCopyEntry&);
+
+ scoped_refptr<ShareableBlobDataItem> source_item;
+ size_t source_item_offset = 0;
+ scoped_refptr<ShareableBlobDataItem> dest_item;
+ };
+
+ enum class TransportState {
+ PENDING_FILE_QUOTA,
+ PENDING_MEMORY_QUOTA,
+ PENDING_TRANSPORT,
+ DONE
+ };
+
+ // This keeps track of our building state for our blob. While building, four
+ // things can be happening mostly simultaneously:
+ // 1. Waiting for blobs we reference to complete,
+ // 2. Waiting for quota to be reserved for memory needed, and
+ // 3. Waiting for quota to be reserved (and files created) for files,
+ // 4. Waiting for user population of data after quota.
+ struct STORAGE_EXPORT BuildingState {
+ // |user_data_population_callback| is !null when user data needs population.
+ BuildingState(TransportState transport_state,
+ PopulatationAllowedCallback user_data_population_callback,
+ size_t num_building_dependent_blobs,
+ bool memory_quota_needed,
+ bool file_quota_needed);
+ ~BuildingState();
+
+ bool CanFinishBuilding() const {
+ return (!memory_quota_needed || memory_quota_granted) &&
+ (!file_quota_needed || file_quota_granted) &&
+ (num_building_dependent_blobs == 0) &&
+ (transport_state == TransportState::DONE);
+ }
+
+ TransportState transport_state;
+ // We can have user data that's either populated or unpopulated. If we need
+ // population, this is populated.
+ PopulatationAllowedCallback user_data_population_callback;
+ std::vector<ShareableBlobDataItem*> user_items;
+
+ const bool dependent_building_blobs_present;
+ // Stores all blobs that we're depending on for building. This keeps the
+ // blobs alive while we build our blob.
+ std::vector<std::unique_ptr<BlobDataHandle>> dependent_blobs;
+ size_t num_building_dependent_blobs;
+
+ const bool memory_quota_needed;
+ base::WeakPtr<BlobMemoryController::QuotaAllocationTask>
+ memory_quota_request;
+ bool memory_quota_granted = false;
+
+ const bool file_quota_needed;
+ base::WeakPtr<BlobMemoryController::QuotaAllocationTask> file_quota_request;
+ bool file_quota_granted = false;
+
+ // These are copies from a referenced blob item to our blob items. Some of
+ // these entries may have changed from bytes to files if they were paged.
+ std::vector<ItemCopyEntry> copies;
+
+ // When our blob finishes building these callbacks are called.
+ std::vector<BlobStatusCallback> build_completion_callbacks;
+ };
+
+ InternalBlobData(const std::string& content_type,
+ const std::string& content_disposition);
~InternalBlobData();
- protected:
- friend class BlobStorageContext;
- friend class BlobStorageRegistry;
- friend class ViewBlobInternalsJob;
+ // Appends the given shared blob data item to this object. We add |my_uuid|
+ // to the shareable item's uuid set.
+ void AppendSharedBlobItem(const std::string& my_uuid,
+ scoped_refptr<ShareableBlobDataItem> item);
// Removes the given blob uuid from the internal ShareableBlobDataItems.
// This is called when this blob is being destroyed.
void RemoveBlobFromShareableItems(const std::string& blob_uuid);
- const std::vector<scoped_refptr<ShareableBlobDataItem>>& items() const;
-
// Gets the memory used by this blob that is not shared by other blobs. This
// also doesn't count duplicate items.
size_t GetUnsharedMemoryUsage() const;
- // Gets the memory used by this blob. Total memory includes memory of items
- // possibly shared with other blobs, or items that appear multiple times in
- // this blob. Unshared memory is memory used by this blob that is not shared
- // by other blobs.
- void GetMemoryUsage(size_t* total_memory, size_t* unshared_memory);
+ // Returns if we're a pending blob that can finish building.
+ bool CanFinishBuilding() const {
+ return BlobStatusIsPending(status_) && building_state_->CanFinishBuilding();
+ }
- private:
- friend class Builder;
- InternalBlobData();
+ BlobStatus status() const { return status_; }
- std::string content_type_;
- std::string content_disposition_;
- std::vector<scoped_refptr<ShareableBlobDataItem>> items_;
+ size_t refcount() const { return refcount_; }
- class Builder {
- public:
- Builder();
- ~Builder();
+ const std::string& content_type() const { return content_type_; }
- void AppendSharedBlobItem(scoped_refptr<ShareableBlobDataItem> item);
+ const std::string& content_disposition() const {
+ return content_disposition_;
+ }
- // Gets the memory used by this builder that is not shared with other blobs.
- size_t GetNonsharedMemoryUsage() const;
+ // Total size of this blob in bytes.
+ uint64_t total_size() const { return size_; };
- // Removes the given blob uuid from the internal ShareableBlobDataItems.
- // This is called on destruction of the blob if we're still building it.
- void RemoveBlobFromShareableItems(const std::string& blob_uuid);
+ // We record the cumulative offsets of each blob item (except for the first,
+ // which would always be 0) to enable binary searching for an item at a
+ // specific byte offset.
+ const std::vector<uint64_t>& offsets() const { return offsets_; }
- // The builder is invalid after calling this method.
- std::unique_ptr<::storage::InternalBlobData> Build();
+ const std::vector<scoped_refptr<ShareableBlobDataItem>>& items() const;
+
+ private:
+ friend class BlobStorageContext;
- private:
- std::unique_ptr<::storage::InternalBlobData> data_;
+ BlobStatus status_ = BlobStatus::PENDING_QUOTA;
+ size_t refcount_ = 0;
- DISALLOW_COPY_AND_ASSIGN(Builder);
- };
+ // Metadata.
+ std::string content_type_;
+ std::string content_disposition_;
+
+ std::vector<scoped_refptr<ShareableBlobDataItem>> items_;
+
+ // Size in bytes. IFF we're a single file then this can be uint64_max.
+ uint64_t size_ = 0;
+
+ // Only populated if len(items_) > 1. Used for binary search.
+ // Since the offset of the first item is always 0, we exclude this.
+ std::vector<uint64_t> offsets_;
+
+ // Only populated if our status is PENDING_*.
+ std::unique_ptr<BuildingState> building_state_;
DISALLOW_COPY_AND_ASSIGN(InternalBlobData);
};
« no previous file with comments | « storage/browser/blob/blob_transport_result.h ('k') | storage/browser/blob/internal_blob_data.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698