Index: storage/browser/blob/blob_entry.h |
diff --git a/storage/browser/blob/blob_entry.h b/storage/browser/blob/blob_entry.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..3c3869e89f4d9a8b8a382c74f59dd370f590c481 |
--- /dev/null |
+++ b/storage/browser/blob/blob_entry.h |
@@ -0,0 +1,164 @@ |
+// 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. |
+ |
+#ifndef STORAGE_BROWSER_BLOB_BLOB_ENTRY_H_ |
+#define STORAGE_BROWSER_BLOB_BLOB_ENTRY_H_ |
+ |
+#include <stddef.h> |
+ |
+#include <memory> |
+#include <string> |
+#include <vector> |
+ |
+#include "base/callback_forward.h" |
+#include "base/macros.h" |
+#include "base/memory/ref_counted.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 BlobStorageRegistry. We export this only for |
+// unit tests. |
+class STORAGE_EXPORT BlobEntry { |
+ public: |
+ using TransportAllowedCallback = |
+ 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(ItemCopyEntry&& other); |
+ BlobEntry::ItemCopyEntry& operator=(BlobEntry::ItemCopyEntry&& rhs); |
+ |
+ scoped_refptr<ShareableBlobDataItem> source_item; |
+ size_t source_item_offset = 0; |
+ scoped_refptr<ShareableBlobDataItem> dest_item; |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(ItemCopyEntry); |
+ }; |
+ |
+ // This keeps track of our building state for our blob. While building, four |
+ // things can be happening mostly simultaneously: |
+ // 1. Waiting for quota to be reserved for memory needed (PENDING_QUOTA) |
+ // 2. Waiting for user population of data after quota (PENDING_TRANSPORT) |
+ // 3. Waiting for blobs we reference to complete (PENDING_INTERNALS) |
+ struct STORAGE_EXPORT BuildingState { |
+ // |transport_allowed_callback| is not null when data needs population. See |
+ // BlobStorageContext::BuildBlob for when the callback is called. |
+ BuildingState(bool transport_items_present, |
+ TransportAllowedCallback transport_allowed_callback, |
+ size_t num_building_dependent_blobs); |
+ ~BuildingState(); |
+ |
+ const bool transport_items_present; |
+ // We can have trasnport data that's either populated or unpopulated. If we |
+ // need population, this is populated. |
+ TransportAllowedCallback transport_allowed_callback; |
+ std::vector<ShareableBlobDataItem*> transport_items; |
+ |
+ // 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; |
+ |
+ base::WeakPtr<BlobMemoryController::QuotaAllocationTask> |
+ memory_quota_request; |
+ |
+ // 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; |
+ |
+ private: |
+ DISALLOW_COPY_AND_ASSIGN(BuildingState); |
+ }; |
+ |
+ BlobEntry(const std::string& content_type, |
+ const std::string& content_disposition); |
+ ~BlobEntry(); |
+ |
+ // Appends the given shared blob data item to this object. |
+ void AppendSharedBlobItem(scoped_refptr<ShareableBlobDataItem> item); |
+ |
+ // Returns if we're a pending blob that can finish building. |
+ bool CanFinishBuilding() const { |
+ return status_ == BlobStatus::PENDING_INTERNALS && |
+ building_state_->num_building_dependent_blobs == 0; |
+ } |
+ |
+ BlobStatus status() const { return status_; } |
+ |
+ size_t refcount() const { return refcount_; } |
+ |
+ const std::string& content_type() const { return content_type_; } |
+ |
+ const std::string& content_disposition() const { |
+ return content_disposition_; |
+ } |
+ |
+ // Total size of this blob in bytes. |
+ uint64_t total_size() const { return size_; }; |
+ |
+ // 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_; } |
+ |
+ const std::vector<scoped_refptr<ShareableBlobDataItem>>& items() const; |
+ |
+ protected: |
+ friend class BlobStorageContext; |
+ |
+ void IncrementRefCount() { ++refcount_; } |
+ void DecrementRefCount() { --refcount_; } |
+ |
+ void set_status(BlobStatus status) { status_ = status; } |
+ void set_size(uint64_t size) { size_ = size; } |
+ |
+ void ClearItems(); |
+ void ClearOffsets(); |
+ |
+ void set_building_state(std::unique_ptr<BuildingState> building_state) { |
+ building_state_ = std::move(building_state); |
+ } |
+ |
+ private: |
+ BlobStatus status_ = BlobStatus::PENDING_QUOTA; |
+ size_t refcount_ = 0; |
+ |
+ // 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(BlobEntry); |
+}; |
+ |
+} // namespace storage |
+#endif // STORAGE_BROWSER_BLOB_BLOB_ENTRY_H_ |