Index: storage/browser/blob/blob_storage_context.cc |
diff --git a/storage/browser/blob/blob_storage_context.cc b/storage/browser/blob/blob_storage_context.cc |
index 6ce45e53f90663cdda7d7b9d1293715ec92aabeb..b87bf1c451cb613d911a30256340640d0d9583cc 100644 |
--- a/storage/browser/blob/blob_storage_context.cc |
+++ b/storage/browser/blob/blob_storage_context.cc |
@@ -4,12 +4,10 @@ |
#include "storage/browser/blob/blob_storage_context.h" |
-#include <stddef.h> |
-#include <stdint.h> |
- |
#include <algorithm> |
#include <limits> |
#include <memory> |
+#include <set> |
#include <utility> |
#include "base/bind.h" |
@@ -19,20 +17,26 @@ |
#include "base/memory/ptr_util.h" |
#include "base/message_loop/message_loop.h" |
#include "base/metrics/histogram.h" |
+#include "base/numerics/safe_conversions.h" |
+#include "base/numerics/safe_math.h" |
+#include "base/task_runner.h" |
#include "base/threading/thread_task_runner_handle.h" |
#include "base/trace_event/trace_event.h" |
#include "storage/browser/blob/blob_data_builder.h" |
-#include "storage/browser/blob/blob_data_handle.h" |
#include "storage/browser/blob/blob_data_item.h" |
#include "storage/browser/blob/blob_data_snapshot.h" |
+#include "storage/browser/blob/blob_flattener.h" |
+#include "storage/browser/blob/blob_slice.h" |
+#include "storage/browser/blob/internal_blob_data.h" |
#include "storage/browser/blob/shareable_blob_data_item.h" |
+#include "storage/common/data_element.h" |
#include "url/gurl.h" |
namespace storage { |
+using ItemCopyEntry = BlobStorageRegistry::ItemCopyEntry; |
using BlobRegistryEntry = BlobStorageRegistry::Entry; |
-using BlobState = BlobStorageRegistry::BlobState; |
-BlobStorageContext::BlobStorageContext() : memory_usage_(0) {} |
+BlobStorageContext::BlobStorageContext() {} |
BlobStorageContext::~BlobStorageContext() { |
} |
@@ -43,9 +47,7 @@ std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID( |
if (!entry) { |
return nullptr; |
} |
- return base::WrapUnique( |
- new BlobDataHandle(uuid, entry->content_type, entry->content_disposition, |
- this, base::ThreadTaskRunnerHandle::Get().get())); |
+ return CreateHandle(uuid, entry); |
} |
std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL( |
@@ -55,21 +57,13 @@ std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL( |
if (!entry) { |
return nullptr; |
} |
- return base::WrapUnique( |
- new BlobDataHandle(uuid, entry->content_type, entry->content_disposition, |
- this, base::ThreadTaskRunnerHandle::Get().get())); |
+ return CreateHandle(uuid, entry); |
} |
std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( |
const BlobDataBuilder& external_builder) { |
TRACE_EVENT0("Blob", "Context::AddFinishedBlob"); |
- CreatePendingBlob(external_builder.uuid(), external_builder.content_type_, |
- external_builder.content_disposition_); |
- CompletePendingBlob(external_builder); |
- std::unique_ptr<BlobDataHandle> handle = |
- GetBlobDataFromUUID(external_builder.uuid_); |
- DecrementBlobRefCount(external_builder.uuid_); |
- return handle; |
+ return BuildBlob(external_builder, BlobStatusCallback()); |
} |
std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( |
@@ -95,86 +89,312 @@ void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) { |
DecrementBlobRefCount(uuid); |
} |
-void BlobStorageContext::CreatePendingBlob( |
+void BlobStorageContext::EnableDisk( |
+ const base::FilePath& storage_directory, |
+ scoped_refptr<base::TaskRunner> file_runner) { |
+ memory_controller_.EnableDisk(storage_directory, std::move(file_runner)); |
+} |
+ |
+std::unique_ptr<BlobDataHandle> BlobStorageContext::AddBrokenBlob( |
kinuko
2016/07/17 16:15:47
nit: Can you try to match the method order as in .
dmurph
2016/07/19 02:26:28
Done.
|
const std::string& uuid, |
const std::string& content_type, |
- const std::string& content_disposition) { |
- DCHECK(!registry_.GetEntry(uuid) && !uuid.empty()); |
- registry_.CreateEntry(uuid, content_type, content_disposition); |
+ const std::string& content_disposition, |
+ BlobStatus reason) { |
+ DCHECK(!registry_.HasEntry(uuid)); |
+ DCHECK(BlobStatusIsError(reason)); |
+ BlobRegistryEntry* entry = |
+ registry_.CreateEntry(uuid, content_type, content_disposition); |
+ entry->status = reason; |
+ FinishBuilding(entry); |
+ return CreateHandle(uuid, entry); |
} |
-void BlobStorageContext::CompletePendingBlob( |
- const BlobDataBuilder& external_builder) { |
- BlobRegistryEntry* entry = registry_.GetEntry(external_builder.uuid()); |
+std::unique_ptr<BlobDataHandle> BlobStorageContext::BuildBlob( |
+ const BlobDataBuilder& content, |
+ const BlobStatusCallback& can_populate_memory) { |
+ DCHECK(!registry_.HasEntry(content.uuid_)); |
+ |
+ BlobRegistryEntry* entry = registry_.CreateEntry( |
+ content.uuid_, content.content_type_, content.content_disposition_); |
+ |
+ // This flattens all blob references in the transportion content out and |
+ // stores the complete item representation in the internal data. |
+ BlobFlattener flattener(content, &(entry->data), ®istry_); |
+ |
+ // If we contain invalid references we're invalid input. |
+ if (flattener.contains_invalid_references) { |
+ LOG(ERROR) << "invalid reference args"; |
+ BreakAndFinishPendingBlob(content.uuid_, |
+ BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS); |
+ return CreateHandle(content.uuid_, entry); |
+ } |
+ |
+ // If we contain broken references (or we reference ourself) we want to fail. |
+ if (flattener.contains_broken_references) { |
+ LOG(ERROR) << "references don't exist"; |
+ BreakAndFinishPendingBlob(content.uuid_, |
+ BlobStatus::REFERENCED_BLOB_BROKEN); |
+ return CreateHandle(content.uuid_, entry); |
+ } |
+ |
+ // We check to make sure that our memory calculations didn't overflow, which |
+ // would mean that the user is trying to save more memory than is in the |
+ // physical address space. |
+ if (!flattener.memory_needed.IsValid() || !flattener.total_size.IsValid() || |
+ !memory_controller_.CanFitInSystem( |
+ flattener.memory_needed.ValueOrDie())) { |
+ LOG(ERROR) << "sizes aren't valid!"; |
+ BreakAndFinishPendingBlob(content.uuid_, BlobStatus::OUT_OF_MEMORY); |
+ return CreateHandle(content.uuid_, entry); |
+ } |
+ // We know we're < max_size_t now. |
+ size_t new_memory_needed = |
+ static_cast<size_t>(flattener.memory_needed.ValueOrDie()); |
+ |
+ // We store if we're waiting for the user to finish populating data in the |
+ // |content| builder object. |
+ if (flattener.contains_pending_content) { |
+ entry->waiting_until_user_population = true; |
+ entry->ready_for_user_population_callback = can_populate_memory; |
+ } else { |
+ DCHECK(can_populate_memory.is_null()); |
+ } |
+ entry->data.size_ = flattener.total_size.ValueOrDie(); |
+ |
+ std::unique_ptr<BlobDataHandle> handle = CreateHandle(content.uuid_, entry); |
+ |
+ std::swap(entry->copies, flattener.copies); |
+ |
+ // We hold a handle to all blobs we're using. This is important, as our memory |
+ // accounting can be delayed until OnEnoughSizeForBlobData is called, and we |
+ // only free memory on canceling when we've done this accounting. If a |
+ // dependent blob is dereferenced, then we're the last blob holding onto that |
+ // data item, and we need to account for that. So we prevent that case by |
+ // holding onto all blobs. |
+ entry->dependent_blobs_building = 0; |
+ for (const std::pair<std::string, BlobRegistryEntry*>& pending_blob : |
+ flattener.dependent_blobs) { |
+ entry->dependent_blobs.push_back( |
+ CreateHandle(pending_blob.first, pending_blob.second)); |
+ if (BlobStatusIsPending(pending_blob.second->status)) { |
+ pending_blob.second->build_completion_callbacks.push_back( |
+ base::Bind(&BlobStorageContext::OnDependentBlobFinished, AsWeakPtr(), |
+ content.uuid_)); |
+ entry->dependent_blobs_building++; |
+ } |
+ } |
+ |
+ // This means we don't have any transport memory or copies from referenced |
+ // blobs. |
+ if (new_memory_needed == 0) { |
+ entry->status = BlobStatus::PENDING_DATA_POPULATION; |
+ if (CanFinishBuilding(entry)) |
+ FinishBuilding(entry); |
+ return handle; |
+ } |
+ |
+ // So we need to transport/copy memory. |
+ base::Optional<BlobMemoryController::PendingConstructionEntry> |
+ pending_construction_entry = |
+ memory_controller_.NotifyWhenMemoryCanPopulated( |
+ new_memory_needed, |
+ base::Bind(&BlobStorageContext::OnEnoughSizeForBlobData, |
+ AsWeakPtr(), content.uuid_)); |
+ |
+ if (pending_construction_entry) { |
+ // This means that we're waiting until the memory is available. |
+ entry->pending_copies_memory_entry = pending_construction_entry.value(); |
+ } else { |
+ entry->status = BlobStatus::PENDING_DATA_POPULATION; |
+ if (!entry->ready_for_user_population_callback.is_null()) |
+ entry->ready_for_user_population_callback.Run( |
+ BlobStatus::PENDING_DATA_POPULATION); |
+ } |
+ |
+ if (CanFinishBuilding(entry)) |
+ FinishBuilding(entry); |
+ |
+ return handle; |
+} |
+ |
+void BlobStorageContext::BreakAndFinishPendingBlob(const std::string& uuid, |
+ BlobStatus reason) { |
+ BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
+ DCHECK(entry); |
+ DCHECK(BlobStatusIsError(reason)); |
+ ClearAndFreeMemory(uuid, entry); |
+ entry->copies.clear(); |
+ entry->dependent_blobs.clear(); |
+ if (!entry->ready_for_user_population_callback.is_null()) { |
+ entry->ready_for_user_population_callback.Run(reason); |
+ entry->ready_for_user_population_callback.Reset(); |
+ } |
+ entry->data.items_.clear(); |
+ entry->data.offsets_.clear(); |
+ entry->data.size_ = 0; |
+ entry->waiting_until_user_population = false; |
+ entry->status = reason; |
+ FinishBuilding(entry); |
+} |
+ |
+void BlobStorageContext::FinishedPopulatingPendingBlob( |
+ const std::string& uuid) { |
+ BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
+ DCHECK_EQ(entry->status, BlobStatus::PENDING_DATA_POPULATION); |
+ entry->waiting_until_user_population = false; |
+ if (CanFinishBuilding(entry)) { |
+ FinishBuilding(entry); |
+ } |
+} |
+ |
+std::unique_ptr<BlobDataHandle> BlobStorageContext::CreateHandle( |
+ const std::string& uuid, |
+ BlobRegistryEntry* entry) { |
+ return base::WrapUnique(new BlobDataHandle( |
+ uuid, entry->content_type, entry->content_disposition, entry->data.size_, |
+ this, base::ThreadTaskRunnerHandle::Get().get())); |
+} |
+ |
+bool BlobStorageContext::CanFinishBuilding(BlobRegistryEntry* entry) { |
+ return entry->status == BlobStatus::PENDING_DATA_POPULATION && |
+ entry->dependent_blobs_building == 0 && |
+ !entry->waiting_until_user_population; |
+} |
+ |
+void BlobStorageContext::FinishBuilding(BlobRegistryEntry* entry) { |
DCHECK(entry); |
- DCHECK(!entry->data.get()) << "Blob already constructed: " |
- << external_builder.uuid(); |
- // We want to handle storing our broken blob as well. |
- switch (entry->state) { |
- case BlobState::PENDING: { |
- entry->data_builder.reset(new InternalBlobData::Builder()); |
- InternalBlobData::Builder* internal_data_builder = |
- entry->data_builder.get(); |
- |
- bool broken = false; |
- for (const auto& blob_item : external_builder.items_) { |
- IPCBlobCreationCancelCode error_code; |
- if (!AppendAllocatedBlobItem(external_builder.uuid_, blob_item, |
- internal_data_builder, &error_code)) { |
- broken = true; |
- memory_usage_ -= entry->data_builder->GetNonsharedMemoryUsage(); |
- entry->state = BlobState::BROKEN; |
- entry->broken_reason = error_code; |
- entry->data_builder.reset(new InternalBlobData::Builder()); |
+ |
+ if (entry->status == BlobStatus::PENDING_DATA_POPULATION) { |
+ for (const ItemCopyEntry& copy : entry->copies) { |
+ // Our source item can be a file if it was a slice of an unpopulated file, |
+ // or a slice of data that was then paged to disk. |
+ size_t dest_size = static_cast<size_t>(copy.dest_item->item()->length()); |
+ DataElement::Type dest_type = copy.dest_item->item()->type(); |
+ switch (copy.source_item->item()->type()) { |
+ case DataElement::TYPE_BYTES: { |
+ DCHECK_EQ(dest_type, DataElement::TYPE_BYTES_DESCRIPTION); |
+ const char* src_data = |
+ copy.source_item->item()->bytes() + copy.source_item_offset; |
+ copy.dest_item->item()->item_->SetToBytes(src_data, dest_size); |
+ } break; |
+ case DataElement::TYPE_FILE: { |
+ LOG(ERROR) << "Source item has been paged or we started as a file, " |
+ "so we're grabbing file ref"; |
+ // We've been paged to disk, so free the memory of our temporary item, |
+ // and create a new shared item with appropriate offset and length. |
+ const DataElement& source_element = |
+ copy.source_item->item()->data_element(); |
+ std::unique_ptr<DataElement> new_element(new DataElement()); |
+ new_element->SetToFilePathRange( |
+ source_element.path(), |
+ source_element.offset() + copy.source_item_offset, dest_size, |
+ source_element.expected_modification_time()); |
+ scoped_refptr<BlobDataItem> new_item(new BlobDataItem( |
+ std::move(new_element), copy.source_item->item()->data_handle())); |
+ copy.dest_item->item_.swap(new_item); |
+ // If we expected a memory item (and our source was paged to disk) we |
+ // free that memory. |
+ if (dest_type == DataElement::TYPE_BYTES_DESCRIPTION) { |
+ memory_controller_.FreeMemory(dest_size); |
+ } |
+ } break; |
+ case DataElement::TYPE_UNKNOWN: |
+ case DataElement::TYPE_BLOB: |
+ case DataElement::TYPE_BYTES_DESCRIPTION: |
+ case DataElement::TYPE_FILE_FILESYSTEM: |
+ case DataElement::TYPE_DISK_CACHE_ENTRY: |
+ NOTREACHED(); |
break; |
- } |
} |
- entry->data = entry->data_builder->Build(); |
- entry->data_builder.reset(); |
- entry->state = broken ? BlobState::BROKEN : BlobState::COMPLETE; |
- break; |
- } |
- case BlobState::BROKEN: { |
- InternalBlobData::Builder builder; |
- entry->data = builder.Build(); |
- break; |
} |
- case BlobState::COMPLETE: |
- DCHECK(false) << "Blob already constructed: " << external_builder.uuid(); |
- return; |
- } |
+ entry->copies.clear(); |
- UMA_HISTOGRAM_COUNTS("Storage.Blob.ItemCount", entry->data->items().size()); |
- UMA_HISTOGRAM_BOOLEAN("Storage.Blob.Broken", |
- entry->state == BlobState::BROKEN); |
- if (entry->state == BlobState::BROKEN) { |
- UMA_HISTOGRAM_ENUMERATION( |
- "Storage.Blob.BrokenReason", static_cast<int>(entry->broken_reason), |
- (static_cast<int>(IPCBlobCreationCancelCode::LAST) + 1)); |
+ entry->status = BlobStatus::DONE; |
} |
- size_t total_memory = 0, nonshared_memory = 0; |
- entry->data->GetMemoryUsage(&total_memory, &nonshared_memory); |
- UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalSize", total_memory / 1024); |
- UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalUnsharedSize", |
- nonshared_memory / 1024); |
- TRACE_COUNTER1("Blob", "MemoryStoreUsageBytes", memory_usage_); |
+ entry->dependent_blobs.clear(); |
auto runner = base::ThreadTaskRunnerHandle::Get(); |
for (const auto& callback : entry->build_completion_callbacks) { |
- runner->PostTask(FROM_HERE, |
- base::Bind(callback, entry->state == BlobState::COMPLETE, |
- entry->broken_reason)); |
+ runner->PostTask(FROM_HERE, base::Bind(callback, entry->status)); |
} |
entry->build_completion_callbacks.clear(); |
+ |
+ for (const auto& shareable_item : entry->data.items_) { |
+ DCHECK_NE(DataElement::TYPE_BYTES_DESCRIPTION, |
+ shareable_item->item()->type()); |
+ if (shareable_item->item()->type() != DataElement::TYPE_BYTES) |
+ continue; |
+ memory_controller_.UpdateBlobItemInRecents(shareable_item.get()); |
+ } |
} |
-void BlobStorageContext::CancelPendingBlob(const std::string& uuid, |
- IPCBlobCreationCancelCode reason) { |
+void BlobStorageContext::OnEnoughSizeForBlobData(const std::string& uuid, |
+ bool success) { |
+ if (!success) { |
+ BreakAndFinishPendingBlob(uuid, BlobStatus::OUT_OF_MEMORY); |
+ return; |
+ } |
BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
- DCHECK(entry && entry->state == BlobState::PENDING); |
- entry->state = BlobState::BROKEN; |
- entry->broken_reason = reason; |
- CompletePendingBlob(BlobDataBuilder(uuid)); |
+ if (entry == nullptr) { |
+ return; |
+ } |
+ entry->status = BlobStatus::PENDING_DATA_POPULATION; |
+ if (!entry->ready_for_user_population_callback.is_null()) { |
+ entry->ready_for_user_population_callback.Run( |
+ BlobStatus::PENDING_DATA_POPULATION); |
+ entry->ready_for_user_population_callback.Reset(); |
+ } |
+ if (CanFinishBuilding(entry)) { |
+ FinishBuilding(entry); |
+ } |
+} |
+ |
+void BlobStorageContext::OnDependentBlobFinished( |
+ const std::string& owning_blob_uuid, |
+ BlobStatus status) { |
+ BlobRegistryEntry* entry = registry_.GetEntry(owning_blob_uuid); |
+ if (!entry) { |
+ return; |
+ } |
+ if (BlobStatusIsError(status)) { |
+ DCHECK_NE(BlobStatus::BLOB_DEREFERENCED_WHILE_BUILDING, status) |
+ << "Referenced blob should never be dereferenced while we " |
+ << "are depending on it, as our system holds a handle."; |
+ BreakAndFinishPendingBlob(owning_blob_uuid, |
+ BlobStatus::REFERENCED_BLOB_BROKEN); |
+ return; |
+ } |
+ DCHECK_GT(entry->dependent_blobs_building, 0u); |
+ --entry->dependent_blobs_building; |
+ if (CanFinishBuilding(entry)) { |
+ FinishBuilding(entry); |
+ } |
+} |
+ |
+void BlobStorageContext::ClearAndFreeMemory(const std::string& uuid, |
+ BlobRegistryEntry* entry) { |
+ if (entry->status == BlobStatus::PENDING_MEMORY_QUOTA) { |
+ if (entry->pending_copies_memory_entry) { |
+ memory_controller_.RemovePendingConstructionEntry( |
+ entry->pending_copies_memory_entry.value()); |
+ } |
+ } |
+ // If this is false, that means we can't fit yet and our memory size hasn't |
+ // been recorded in the memory manager yet. We don't have to worry about |
+ // items from dependent blobs that have since been destroyed, as we hold |
+ // handles of all of them, which we clear below here. |
+ if (entry->status != BlobStatus::PENDING_MEMORY_QUOTA) { |
+ memory_controller_.FreeMemory(entry->data.GetUnsharedMemoryUsage()); |
+ } |
+ entry->data.RemoveBlobFromShareableItems(uuid); |
+ for (const auto& item_refptr : entry->data.items_) { |
+ if (item_refptr->referencing_blobs().size() == 0) { |
+ memory_controller_.RemoveBlobItemInRecents(*item_refptr); |
+ } |
+ } |
+ entry->data.items_.clear(); |
+ entry->data.offsets_.clear(); |
+ entry->dependent_blobs.clear(); |
} |
void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) { |
@@ -188,13 +408,7 @@ void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) { |
DCHECK(entry); |
DCHECK_GT(entry->refcount, 0u); |
if (--(entry->refcount) == 0) { |
- size_t memory_freeing = 0; |
- if (entry->state == BlobState::COMPLETE) { |
- memory_freeing = entry->data->GetUnsharedMemoryUsage(); |
- entry->data->RemoveBlobFromShareableItems(uuid); |
- } |
- DCHECK_LE(memory_freeing, memory_usage_); |
- memory_usage_ -= memory_freeing; |
+ ClearAndFreeMemory(uuid, entry); |
registry_.DeleteEntry(uuid); |
} |
} |
@@ -203,254 +417,40 @@ std::unique_ptr<BlobDataSnapshot> BlobStorageContext::CreateSnapshot( |
const std::string& uuid) { |
std::unique_ptr<BlobDataSnapshot> result; |
BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
- if (entry->state != BlobState::COMPLETE) { |
+ if (entry->status != BlobStatus::DONE) { |
return result; |
} |
- const InternalBlobData& data = *entry->data; |
+ const InternalBlobData& data = entry->data; |
std::unique_ptr<BlobDataSnapshot> snapshot(new BlobDataSnapshot( |
uuid, entry->content_type, entry->content_disposition)); |
snapshot->items_.reserve(data.items().size()); |
for (const auto& shareable_item : data.items()) { |
snapshot->items_.push_back(shareable_item->item()); |
+ if (shareable_item->item()->type() == DataElement::TYPE_BYTES) |
+ memory_controller_.UpdateBlobItemInRecents(shareable_item.get()); |
} |
return snapshot; |
} |
-bool BlobStorageContext::IsBroken(const std::string& uuid) const { |
+BlobStatus BlobStorageContext::GetBlobStatus(const std::string& uuid) const { |
const BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
if (!entry) { |
- return true; |
- } |
- return entry->state == BlobState::BROKEN; |
-} |
- |
-bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) const { |
- const BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
- if (!entry) { |
- return false; |
+ return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; |
} |
- return entry->state == BlobState::PENDING; |
+ return entry->status; |
} |
void BlobStorageContext::RunOnConstructionComplete( |
const std::string& uuid, |
- const BlobConstructedCallback& done) { |
+ const BlobStatusCallback& done) { |
BlobRegistryEntry* entry = registry_.GetEntry(uuid); |
DCHECK(entry); |
- switch (entry->state) { |
- case BlobState::COMPLETE: |
- done.Run(true, IPCBlobCreationCancelCode::UNKNOWN); |
- return; |
- case BlobState::BROKEN: |
- done.Run(false, entry->broken_reason); |
- return; |
- case BlobState::PENDING: |
- entry->build_completion_callbacks.push_back(done); |
- return; |
- } |
- NOTREACHED(); |
-} |
- |
-bool BlobStorageContext::AppendAllocatedBlobItem( |
- const std::string& target_blob_uuid, |
- scoped_refptr<BlobDataItem> blob_item, |
- InternalBlobData::Builder* target_blob_builder, |
- IPCBlobCreationCancelCode* error_code) { |
- DCHECK(error_code); |
- *error_code = IPCBlobCreationCancelCode::UNKNOWN; |
- bool error = false; |
- |
- // The blob data is stored in the canonical way which only contains a |
- // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items |
- // are expanded into the primitive constituent types and reused if possible. |
- // 1) The Data item is denoted by the raw data and length. |
- // 2) The File item is denoted by the file path, the range and the expected |
- // modification time. |
- // 3) The FileSystem File item is denoted by the FileSystem URL, the range |
- // and the expected modification time. |
- // 4) The Blob item is denoted by the source blob and an offset and size. |
- // Internal items that are fully used by the new blob (not cut by the |
- // offset or size) are shared between the blobs. Otherwise, the relevant |
- // portion of the item is copied. |
- |
- DCHECK(blob_item->data_element_ptr()); |
- const DataElement& data_element = blob_item->data_element(); |
- uint64_t length = data_element.length(); |
- uint64_t offset = data_element.offset(); |
- UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend", |
- memory_usage_ / 1024); |
- switch (data_element.type()) { |
- case DataElement::TYPE_BYTES: |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024); |
- DCHECK(!offset); |
- if (memory_usage_ + length > kBlobStorageMaxMemoryUsage) { |
- error = true; |
- *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY; |
- break; |
- } |
- memory_usage_ += length; |
- target_blob_builder->AppendSharedBlobItem( |
- new ShareableBlobDataItem(target_blob_uuid, blob_item)); |
- break; |
- case DataElement::TYPE_FILE: { |
- bool full_file = (length == std::numeric_limits<uint64_t>::max()); |
- UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.File.Unknown", full_file); |
- if (!full_file) { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File", |
- (length - offset) / 1024); |
- } |
- target_blob_builder->AppendSharedBlobItem( |
- new ShareableBlobDataItem(target_blob_uuid, blob_item)); |
- break; |
- } |
- case DataElement::TYPE_FILE_FILESYSTEM: { |
- bool full_file = (length == std::numeric_limits<uint64_t>::max()); |
- UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.FileSystem.Unknown", |
- full_file); |
- if (!full_file) { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem", |
- (length - offset) / 1024); |
- } |
- target_blob_builder->AppendSharedBlobItem( |
- new ShareableBlobDataItem(target_blob_uuid, blob_item)); |
- break; |
- } |
- case DataElement::TYPE_BLOB: { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob", |
- (length - offset) / 1024); |
- // We grab the handle to ensure it stays around while we copy it. |
- std::unique_ptr<BlobDataHandle> src = |
- GetBlobDataFromUUID(data_element.blob_uuid()); |
- if (!src || src->IsBroken() || src->IsBeingBuilt()) { |
- error = true; |
- *error_code = IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN; |
- break; |
- } |
- BlobRegistryEntry* other_entry = |
- registry_.GetEntry(data_element.blob_uuid()); |
- DCHECK(other_entry->data); |
- if (!AppendBlob(target_blob_uuid, *other_entry->data, offset, length, |
- target_blob_builder)) { |
- error = true; |
- *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY; |
- } |
- break; |
- } |
- case DataElement::TYPE_DISK_CACHE_ENTRY: { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.CacheEntry", |
- (length - offset) / 1024); |
- target_blob_builder->AppendSharedBlobItem( |
- new ShareableBlobDataItem(target_blob_uuid, blob_item)); |
- break; |
- } |
- case DataElement::TYPE_BYTES_DESCRIPTION: |
- case DataElement::TYPE_UNKNOWN: |
- NOTREACHED(); |
- break; |
- } |
- UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend", |
- memory_usage_ / 1024); |
- return !error; |
-} |
- |
-bool BlobStorageContext::AppendBlob( |
- const std::string& target_blob_uuid, |
- const InternalBlobData& blob, |
- uint64_t offset, |
- uint64_t length, |
- InternalBlobData::Builder* target_blob_builder) { |
- DCHECK_GT(length, 0ull); |
- |
- const std::vector<scoped_refptr<ShareableBlobDataItem>>& items = blob.items(); |
- auto iter = items.begin(); |
- if (offset) { |
- for (; iter != items.end(); ++iter) { |
- const BlobDataItem& item = *(iter->get()->item()); |
- if (offset >= item.length()) |
- offset -= item.length(); |
- else |
- break; |
- } |
- } |
- |
- for (; iter != items.end() && length > 0; ++iter) { |
- scoped_refptr<ShareableBlobDataItem> shareable_item = iter->get(); |
- const BlobDataItem& item = *(shareable_item->item()); |
- uint64_t item_length = item.length(); |
- DCHECK_GT(item_length, offset); |
- uint64_t current_length = item_length - offset; |
- uint64_t new_length = current_length > length ? length : current_length; |
- |
- bool reusing_blob_item = offset == 0 && new_length == item.length(); |
- UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ReusedItem", reusing_blob_item); |
- if (reusing_blob_item) { |
- shareable_item->referencing_blobs().insert(target_blob_uuid); |
- target_blob_builder->AppendSharedBlobItem(shareable_item); |
- length -= new_length; |
- continue; |
- } |
- |
- // We need to do copying of the items when we have a different offset or |
- // length |
- switch (item.type()) { |
- case DataElement::TYPE_BYTES: { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.Bytes", |
- new_length / 1024); |
- if (memory_usage_ + new_length > kBlobStorageMaxMemoryUsage) { |
- return false; |
- } |
- DCHECK(!item.offset()); |
- std::unique_ptr<DataElement> element(new DataElement()); |
- element->SetToBytes(item.bytes() + offset, |
- static_cast<int64_t>(new_length)); |
- memory_usage_ += new_length; |
- target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( |
- target_blob_uuid, new BlobDataItem(std::move(element)))); |
- } break; |
- case DataElement::TYPE_FILE: { |
- DCHECK_NE(item.length(), std::numeric_limits<uint64_t>::max()) |
- << "We cannot use a section of a file with an unknown length"; |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File", |
- new_length / 1024); |
- std::unique_ptr<DataElement> element(new DataElement()); |
- element->SetToFilePathRange(item.path(), item.offset() + offset, |
- new_length, |
- item.expected_modification_time()); |
- target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( |
- target_blob_uuid, |
- new BlobDataItem(std::move(element), item.data_handle_))); |
- } break; |
- case DataElement::TYPE_FILE_FILESYSTEM: { |
- UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem", |
- new_length / 1024); |
- std::unique_ptr<DataElement> element(new DataElement()); |
- element->SetToFileSystemUrlRange(item.filesystem_url(), |
- item.offset() + offset, new_length, |
- item.expected_modification_time()); |
- target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( |
- target_blob_uuid, new BlobDataItem(std::move(element)))); |
- } break; |
- case DataElement::TYPE_DISK_CACHE_ENTRY: { |
- std::unique_ptr<DataElement> element(new DataElement()); |
- element->SetToDiskCacheEntryRange(item.offset() + offset, |
- new_length); |
- target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( |
- target_blob_uuid, |
- new BlobDataItem(std::move(element), item.data_handle_, |
- item.disk_cache_entry(), |
- item.disk_cache_stream_index(), |
- item.disk_cache_side_stream_index()))); |
- } break; |
- case DataElement::TYPE_BYTES_DESCRIPTION: |
- case DataElement::TYPE_BLOB: |
- case DataElement::TYPE_UNKNOWN: |
- CHECK(false) << "Illegal blob item type: " << item.type(); |
- } |
- length -= new_length; |
- offset = 0; |
+ if (BlobStatusIsPending(entry->status)) { |
+ entry->build_completion_callbacks.push_back(done); |
+ return; |
} |
- return true; |
+ done.Run(entry->status); |
} |
} // namespace storage |