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

Unified Diff: storage/browser/blob/blob_async_builder_host.cc

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
Index: storage/browser/blob/blob_async_builder_host.cc
diff --git a/storage/browser/blob/blob_async_builder_host.cc b/storage/browser/blob/blob_async_builder_host.cc
index a73d9d683232ff5ca6772e8fe7227c5afe1f9d22..8f08d2a070038d6c993fe49acf02045b636d5bd8 100644
--- a/storage/browser/blob/blob_async_builder_host.cc
+++ b/storage/browser/blob/blob_async_builder_host.cc
@@ -14,16 +14,21 @@
#include "base/memory/ptr_util.h"
#include "base/memory/shared_memory.h"
#include "storage/browser/blob/blob_data_handle.h"
+#include "storage/browser/blob/blob_memory_controller.h"
#include "storage/browser/blob/blob_storage_context.h"
namespace storage {
namespace {
+using MemoryStrategy = BlobMemoryController::Strategy;
+using MemoryItemRequest =
+ BlobAsyncTransportRequestBuilder::RendererMemoryItemRequest;
bool CalculateBlobMemorySize(const std::vector<DataElement>& elements,
size_t* shortcut_bytes,
uint64_t* total_bytes) {
DCHECK(shortcut_bytes);
DCHECK(total_bytes);
+
base::CheckedNumeric<uint64_t> total_size_checked = 0;
base::CheckedNumeric<size_t> shortcut_size_checked = 0;
for (const auto& e : elements) {
@@ -35,49 +40,18 @@ bool CalculateBlobMemorySize(const std::vector<DataElement>& elements,
} else {
continue;
}
- if (!total_size_checked.IsValid() || !shortcut_size_checked.IsValid()) {
+ if (!total_size_checked.IsValid() || !shortcut_size_checked.IsValid())
return false;
- }
}
*shortcut_bytes = shortcut_size_checked.ValueOrDie();
*total_bytes = total_size_checked.ValueOrDie();
return true;
}
-
-IPCBlobCreationCancelCode ConvertReferencedBlobErrorToConstructingError(
- IPCBlobCreationCancelCode referenced_blob_error) {
- switch (referenced_blob_error) {
- // For most cases we propagate the error.
- case IPCBlobCreationCancelCode::FILE_WRITE_FAILED:
- case IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT:
- case IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN:
- case IPCBlobCreationCancelCode::OUT_OF_MEMORY:
- return referenced_blob_error;
- // Others we report that the referenced blob is broken, as we don't know
- // why (the BLOB_DEREFERENCED_WHILE_BUILDING should never happen, as we hold
- // onto the reference of the blobs we're using).
- case IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING:
- DCHECK(false) << "Referenced blob should never be dereferenced while we "
- << "are depending on it, as our system holds a handle.";
- case IPCBlobCreationCancelCode::UNKNOWN:
- return IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN;
- }
- NOTREACHED();
- return IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN;
-}
-
} // namespace
-using MemoryItemRequest =
- BlobAsyncTransportRequestBuilder::RendererMemoryItemRequest;
-
BlobAsyncBuilderHost::BlobBuildingState::BlobBuildingState(
- const std::string& uuid,
- std::set<std::string> referenced_blob_uuids,
- std::vector<std::unique_ptr<BlobDataHandle>>* referenced_blob_handles)
- : data_builder(uuid),
- referenced_blob_uuids(referenced_blob_uuids),
- referenced_blob_handles(std::move(*referenced_blob_handles)) {}
+ const std::string& uuid)
+ : data_builder(uuid) {}
BlobAsyncBuilderHost::BlobBuildingState::~BlobBuildingState() {}
@@ -85,381 +59,464 @@ BlobAsyncBuilderHost::BlobAsyncBuilderHost() : ptr_factory_(this) {}
BlobAsyncBuilderHost::~BlobAsyncBuilderHost() {}
-BlobTransportResult BlobAsyncBuilderHost::RegisterBlobUUID(
+void BlobAsyncBuilderHost::RegisterBlob(
const std::string& uuid,
const std::string& content_type,
const std::string& content_disposition,
- const std::set<std::string>& referenced_blob_uuids,
- BlobStorageContext* context) {
- if (async_blob_map_.find(uuid) != async_blob_map_.end())
- return BlobTransportResult::BAD_IPC;
- if (referenced_blob_uuids.find(uuid) != referenced_blob_uuids.end())
- return BlobTransportResult::BAD_IPC;
- context->CreatePendingBlob(uuid, content_type, content_disposition);
- std::vector<std::unique_ptr<BlobDataHandle>> handles;
- for (const std::string& referenced_uuid : referenced_blob_uuids) {
- std::unique_ptr<BlobDataHandle> handle =
- context->GetBlobDataFromUUID(referenced_uuid);
- if (!handle || handle->IsBroken()) {
- // We cancel the blob right away, and don't bother storing our state.
- context->CancelPendingBlob(
- uuid, IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN);
- return BlobTransportResult::CANCEL_REFERENCED_BLOB_BROKEN;
- }
- handles.emplace_back(std::move(handle));
- }
- async_blob_map_[uuid] = base::MakeUnique<BlobBuildingState>(
- uuid, referenced_blob_uuids, &handles);
- return BlobTransportResult::DONE;
-}
-
-BlobTransportResult BlobAsyncBuilderHost::StartBuildingBlob(
- const std::string& uuid,
const std::vector<DataElement>& elements,
- size_t memory_available,
BlobStorageContext* context,
- const RequestMemoryCallback& request_memory) {
+ const RequestMemoryCallback& request_memory,
+ const BlobStatusCallback& completion_callback) {
DCHECK(context);
- DCHECK(async_blob_map_.find(uuid) != async_blob_map_.end());
-
- // Step 1: Get the sizes.
- size_t shortcut_memory_size_bytes = 0;
- uint64_t total_memory_size_bytes = 0;
- if (!CalculateBlobMemorySize(elements, &shortcut_memory_size_bytes,
- &total_memory_size_bytes)) {
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
+ if (async_blob_map_.find(uuid) != async_blob_map_.end()) {
+ completion_callback.Run(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
+ return;
}
- // Step 2: Check if we have enough memory to store the blob.
- if (total_memory_size_bytes > memory_available) {
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::OUT_OF_MEMORY, context);
- return BlobTransportResult::CANCEL_MEMORY_FULL;
+ const BlobMemoryController& memory_controller = context->memory_controller();
+ uint64_t transport_memory_size = 0;
+ size_t shortcut_size = 0;
+ if (!CalculateBlobMemorySize(elements, &shortcut_size,
+ &transport_memory_size)) {
+ completion_callback.Run(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
+ return;
}
- // From here on, we know we can fit the blob in memory.
- BlobBuildingState* state_ptr = async_blob_map_[uuid].get();
- if (!state_ptr->request_builder.requests().empty()) {
- // Check that we're not a duplicate call.
- return BlobTransportResult::BAD_IPC;
- }
- state_ptr->request_memory_callback = request_memory;
+ MemoryStrategy memory_strategy =
+ memory_controller.DetermineStrategy(shortcut_size, transport_memory_size);
- // Step 3: Check to make sure the referenced blob information we received
- // earlier is correct:
- std::set<std::string> extracted_blob_uuids;
+ // Validate that our referenced blobs aren't us.
for (const DataElement& e : elements) {
- if (e.type() == DataElement::TYPE_BLOB) {
- extracted_blob_uuids.insert(e.blob_uuid());
- // We can't depend on ourselves.
- if (e.blob_uuid() == uuid) {
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
- }
+ if (e.type() == DataElement::TYPE_BLOB && e.blob_uuid() == uuid) {
+ completion_callback.Run(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
+ return;
}
}
- if (extracted_blob_uuids != state_ptr->referenced_blob_uuids) {
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
- }
- // Step 4: Decide if we're using the shortcut method. This will also catch
- // the case where we don't have any memory items.
- if (shortcut_memory_size_bytes == total_memory_size_bytes &&
- shortcut_memory_size_bytes <= memory_available) {
- for (const DataElement& e : elements) {
- state_ptr->data_builder.AppendIPCDataElement(e);
- }
- FinishBuildingBlob(state_ptr, context);
- return BlobTransportResult::DONE;
- }
+ std::unique_ptr<BlobBuildingState> state(new BlobBuildingState(uuid));
+ state->data_builder.set_content_type(content_type);
+ state->data_builder.set_content_disposition(content_disposition);
+ state->request_memory_callback = request_memory;
- // From here on, we know the blob's size is less than |memory_available|,
- // so we know we're < max(size_t).
- // Step 5: Decide if we're using shared memory.
- if (total_memory_size_bytes > max_ipc_memory_size_) {
- state_ptr->request_builder.InitializeForSharedMemoryRequests(
- max_shared_memory_size_, total_memory_size_bytes, elements,
- &(state_ptr->data_builder));
- } else {
- // Step 6: We can fit in IPC.
- state_ptr->request_builder.InitializeForIPCRequests(
- max_ipc_memory_size_, total_memory_size_bytes, elements,
- &(state_ptr->data_builder));
+ std::unique_ptr<BlobDataHandle> temp_handle;
+
+ switch (memory_strategy) {
+ case MemoryStrategy::TOO_LARGE:
+ temp_handle =
+ context->AddBrokenBlob(uuid, content_type, content_disposition,
+ BlobStatus::ERR_OUT_OF_MEMORY);
+ context->IncrementBlobRefCount(uuid);
+ completion_callback.Run(BlobStatus::ERR_OUT_OF_MEMORY);
+ return;
+ case MemoryStrategy::NONE_NEEDED: {
+ for (const DataElement& e : elements) {
+ DCHECK_NE(e.type(), DataElement::TYPE_BYTES_DESCRIPTION);
+ state->data_builder.AppendIPCDataElement(e);
+ }
+ temp_handle =
+ context->BuildBlob(state->data_builder,
+ BlobStorageContext::PopulatationAllowedCallback());
+ context->IncrementBlobRefCount(uuid);
+ completion_callback.Run(BlobStatus::DONE);
+ return;
+ }
+ case MemoryStrategy::IPC:
+ state->strategy = IPCBlobItemRequestStrategy::IPC;
+ state->request_builder.InitializeForIPCRequests(
+ memory_controller.limits().max_ipc_memory_size, transport_memory_size,
+ elements, &(state->data_builder));
+ break;
+ case MemoryStrategy::SHARED_MEMORY:
+ state->strategy = IPCBlobItemRequestStrategy::SHARED_MEMORY;
+ state->request_builder.InitializeForSharedMemoryRequests(
+ memory_controller.limits().max_shared_memory_size,
+ transport_memory_size, elements, &(state->data_builder));
+ break;
+ case MemoryStrategy::FILE:
+ state->strategy = IPCBlobItemRequestStrategy::FILE;
+ state->request_builder.InitializeForFileRequests(
+ memory_controller.limits().max_file_size, transport_memory_size,
+ elements, &(state->data_builder));
+ break;
}
// We initialize our requests received state now that they are populated.
- state_ptr->request_received.resize(
- state_ptr->request_builder.requests().size(), false);
- return ContinueBlobMemoryRequests(uuid, context);
+ state->request_received.resize(state->request_builder.requests().size(),
+ false);
+
+ BlobBuildingState* state_ptr = state.get();
+ async_blob_map_[uuid] = std::move(state);
+
+ state_ptr->request_memory_callback = request_memory;
+ state_ptr->completion_callback = completion_callback;
+
+ temp_handle = context->BuildBlob(
+ state_ptr->data_builder,
+ base::Bind(&BlobAsyncBuilderHost::OnCanStartBuildingBlob,
+ ptr_factory_.GetWeakPtr(), uuid, context->AsWeakPtr()));
+ context->IncrementBlobRefCount(uuid);
+
+ BlobStatus status = temp_handle->GetBlobStatus();
+ if (BlobStatusIsError(status))
+ async_blob_map_.erase(uuid);
+ if (!BlobStatusIsPending(status))
+ completion_callback.Run(temp_handle->GetBlobStatus());
+ return;
}
-BlobTransportResult BlobAsyncBuilderHost::OnMemoryResponses(
+BlobStatus BlobAsyncBuilderHost::OnMemoryResponses(
const std::string& uuid,
const std::vector<BlobItemBytesResponse>& responses,
BlobStorageContext* context) {
AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid);
if (state_it == async_blob_map_.end()) {
DVLOG(1) << "Could not find blob " << uuid;
- return BlobTransportResult::BAD_IPC;
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
if (responses.empty()) {
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
+
+ // Validate response sanity: it should refer to a legal request number, and
+ // we shouldn't have received an answer for that request yet.
BlobAsyncBuilderHost::BlobBuildingState* state = state_it->second.get();
- BlobAsyncTransportRequestBuilder& request_builder = state->request_builder;
- const auto& requests = request_builder.requests();
+ const auto& requests = state->request_builder.requests();
for (const BlobItemBytesResponse& response : responses) {
if (response.request_number >= requests.size()) {
// Bad IPC, so we delete our record and ignore.
DVLOG(1) << "Invalid request number " << response.request_number;
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
DCHECK_LT(response.request_number, state->request_received.size());
- const MemoryItemRequest& request = requests[response.request_number];
if (state->request_received[response.request_number]) {
// Bad IPC, so we delete our record.
DVLOG(1) << "Already received response for that request.";
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
- }
- state->request_received[response.request_number] = true;
- bool invalid_ipc = false;
- bool memory_error = false;
- switch (request.message.transport_strategy) {
- case IPCBlobItemRequestStrategy::IPC:
- if (response.inline_data.size() < request.message.size) {
- DVLOG(1) << "Invalid data size " << response.inline_data.size()
- << " vs requested size of " << request.message.size;
- invalid_ipc = true;
- break;
- }
- invalid_ipc = !state->data_builder.PopulateFutureData(
- request.browser_item_index, &response.inline_data[0],
- request.browser_item_offset, request.message.size);
- break;
- case IPCBlobItemRequestStrategy::SHARED_MEMORY:
- if (state->num_shared_memory_requests == 0) {
- DVLOG(1) << "Received too many responses for shared memory.";
- invalid_ipc = true;
- break;
- }
- state->num_shared_memory_requests--;
- if (!state->shared_memory_block->memory()) {
- // We just map the whole block, as we'll probably be accessing the
- // whole thing in this group of responses. Another option is to use
- // MapAt, remove the mapped boolean, and then exclude the
- // handle_offset below.
- size_t handle_size = request_builder.shared_memory_sizes()
- [state->current_shared_memory_handle_index];
- if (!state->shared_memory_block->Map(handle_size)) {
- DVLOG(1) << "Unable to map memory to size " << handle_size;
- memory_error = true;
- break;
- }
- }
-
- invalid_ipc = !state->data_builder.PopulateFutureData(
- request.browser_item_index,
- static_cast<const char*>(state->shared_memory_block->memory()) +
- request.message.handle_offset,
- request.browser_item_offset, request.message.size);
- break;
- case IPCBlobItemRequestStrategy::FILE:
- case IPCBlobItemRequestStrategy::UNKNOWN:
- DVLOG(1) << "Not implemented.";
- invalid_ipc = true;
- break;
- }
- if (invalid_ipc) {
- // Bad IPC, so we delete our record and return false.
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context);
- return BlobTransportResult::BAD_IPC;
- }
- if (memory_error) {
- DVLOG(1) << "Shared memory error.";
- CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::OUT_OF_MEMORY,
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
context);
- return BlobTransportResult::CANCEL_MEMORY_FULL;
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
- state->num_fulfilled_requests++;
+ state->request_received[response.request_number] = true;
}
- return ContinueBlobMemoryRequests(uuid, context);
+ switch (state->strategy) {
+ case IPCBlobItemRequestStrategy::IPC:
+ return OnIPCResponses(uuid, state, responses, context);
+ case IPCBlobItemRequestStrategy::SHARED_MEMORY:
+ return OnSharedMemoryResponses(uuid, state, responses, context);
+ case IPCBlobItemRequestStrategy::FILE:
+ return OnFileResponses(uuid, state, responses, context);
+ case IPCBlobItemRequestStrategy::UNKNOWN:
+ break;
+ }
+ NOTREACHED();
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
void BlobAsyncBuilderHost::CancelBuildingBlob(const std::string& uuid,
- IPCBlobCreationCancelCode code,
+ BlobStatus code,
BlobStorageContext* context) {
DCHECK(context);
+ DCHECK(BlobStatusIsError(code));
auto state_it = async_blob_map_.find(uuid);
- if (state_it == async_blob_map_.end()) {
+ if (state_it == async_blob_map_.end())
return;
- }
// We can have the blob dereferenced by the renderer, but have it still being
// 'built'. In this case, it's destructed in the context, but we still have
// it in our map. Hence we make sure the context has the entry before
// calling cancel.
- if (context->registry().HasEntry(uuid))
- context->CancelPendingBlob(uuid, code);
async_blob_map_.erase(state_it);
+ if (context->registry().HasEntry(uuid))
+ context->BreakAndFinishPendingBlob(uuid, code);
}
void BlobAsyncBuilderHost::CancelAll(BlobStorageContext* context) {
DCHECK(context);
- // If the blob still exists in the context (and is being built), then we know
- // that someone else is expecting our blob, and we need to cancel it to let
- // the dependency know it's gone.
+ // If the blob still exists in the context, then we know that someone else is
+ // expecting our blob, and we need to cancel it to let the dependency know
+ // it's gone.
std::vector<std::unique_ptr<BlobDataHandle>> referenced_pending_blobs;
for (const auto& uuid_state_pair : async_blob_map_) {
- if (context->IsBeingBuilt(uuid_state_pair.first)) {
- referenced_pending_blobs.emplace_back(
+ std::unique_ptr<BlobDataHandle> handle =
+ context->GetBlobDataFromUUID(uuid_state_pair.first);
+ if (handle) {
+ referenced_pending_blobs.push_back(
context->GetBlobDataFromUUID(uuid_state_pair.first));
}
}
// We clear the map before canceling them to prevent any strange reentry into
- // our class (see ReferencedBlobFinished) if any blobs were waiting for others
+ // our class (see OnCanStartBuildingBlob) if any blobs were waiting for others
// to construct.
async_blob_map_.clear();
for (const std::unique_ptr<BlobDataHandle>& handle :
referenced_pending_blobs) {
- context->CancelPendingBlob(
- handle->uuid(), IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT);
+ context->BreakAndFinishPendingBlob(handle->uuid(),
+ BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT);
}
}
-BlobTransportResult BlobAsyncBuilderHost::ContinueBlobMemoryRequests(
+BlobStatus BlobAsyncBuilderHost::StartRequests(
const std::string& uuid,
- BlobStorageContext* context) {
+ BlobBuildingState* state,
+ BlobStorageContext* context,
+ std::vector<BlobMemoryController::FileCreationInfo> file_infos) {
+ switch (state->strategy) {
+ case IPCBlobItemRequestStrategy::IPC:
+ DCHECK(file_infos.empty());
+ SendIPCRequests(state, context);
+ return BlobStatus::PENDING_TRANSPORT;
+ case IPCBlobItemRequestStrategy::SHARED_MEMORY:
+ DCHECK(file_infos.empty());
+ return ContinueSharedMemoryRequests(uuid, state, context);
+ case IPCBlobItemRequestStrategy::FILE:
+ DCHECK(!file_infos.empty());
+ SendFileRequests(state, context, std::move(file_infos));
+ return BlobStatus::PENDING_TRANSPORT;
+ case IPCBlobItemRequestStrategy::UNKNOWN:
+ break;
+ }
+ NOTREACHED();
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+}
+
+// Note: This can be called when we cancel a blob in the context.
+void BlobAsyncBuilderHost::OnCanStartBuildingBlob(
+ const std::string& uuid,
+ base::WeakPtr<BlobStorageContext> context,
+ BlobStatus status,
+ std::vector<BlobMemoryController::FileCreationInfo> file_infos) {
+ LOG(ERROR) << "We can fit now!";
+ if (!context) {
+ async_blob_map_.erase(uuid);
+ return;
+ }
AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid);
- DCHECK(state_it != async_blob_map_.end());
- BlobAsyncBuilderHost::BlobBuildingState* state = state_it->second.get();
+ if (state_it == async_blob_map_.end())
+ return;
- BlobAsyncTransportRequestBuilder& request_builder = state->request_builder;
- const std::vector<MemoryItemRequest>& requests = request_builder.requests();
+ BlobBuildingState* state = state_it->second.get();
+ if (BlobStatusIsPending(status)) {
+ DCHECK(status == BlobStatus::PENDING_TRANSPORT);
+ status = StartRequests(uuid, state, context.get(), std::move(file_infos));
+ if (BlobStatusIsPending(status))
+ return;
+ } else {
+ LOG(ERROR) << "Got error state!";
+ }
+ BlobStatusCallback completion_callback = state->completion_callback;
+ async_blob_map_.erase(state_it);
+ completion_callback.Run(status);
+}
+
+void BlobAsyncBuilderHost::SendIPCRequests(BlobBuildingState* state,
+ BlobStorageContext* context) {
+ const std::vector<MemoryItemRequest>& requests =
+ state->request_builder.requests();
+ std::vector<BlobItemBytesRequest> byte_requests;
+
+ DCHECK(!requests.empty());
+ for (const MemoryItemRequest& request : requests) {
+ byte_requests.push_back(request.message);
+ }
+
+ state->request_memory_callback.Run(std::move(byte_requests),
+ std::vector<base::SharedMemoryHandle>(),
+ std::vector<base::File>());
+}
+
+BlobStatus BlobAsyncBuilderHost::OnIPCResponses(
+ const std::string& uuid,
+ BlobBuildingState* state,
+ const std::vector<BlobItemBytesResponse>& responses,
+ BlobStorageContext* context) {
+ const auto& requests = state->request_builder.requests();
size_t num_requests = requests.size();
+ for (const BlobItemBytesResponse& response : responses) {
+ const MemoryItemRequest& request = requests[response.request_number];
+ if (response.inline_data.size() < request.message.size) {
+ DVLOG(1) << "Invalid data size " << response.inline_data.size()
+ << " vs requested size of " << request.message.size;
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+ }
+ bool success = state->data_builder.PopulateFutureData(
+ request.browser_item_index, response.inline_data.data(),
+ request.browser_item_offset, request.message.size);
+ if (!success) {
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+ }
+ state->num_fulfilled_requests++;
+ }
if (state->num_fulfilled_requests == num_requests) {
FinishBuildingBlob(state, context);
- return BlobTransportResult::DONE;
+ return BlobStatus::DONE;
}
+ return BlobStatus::PENDING_TRANSPORT;
+}
+
+BlobStatus BlobAsyncBuilderHost::ContinueSharedMemoryRequests(
+ const std::string& uuid,
+ BlobBuildingState* state,
+ BlobStorageContext* context) {
+ BlobAsyncTransportRequestBuilder& request_builder = state->request_builder;
+ const std::vector<MemoryItemRequest>& requests = request_builder.requests();
+ size_t num_requests = requests.size();
DCHECK_LT(state->num_fulfilled_requests, num_requests);
if (state->next_request == num_requests) {
// We are still waiting on other requests to come back.
- return BlobTransportResult::PENDING_RESPONSES;
+ return BlobStatus::PENDING_TRANSPORT;
}
- std::unique_ptr<std::vector<BlobItemBytesRequest>> byte_requests(
- new std::vector<BlobItemBytesRequest>());
- std::unique_ptr<std::vector<base::SharedMemoryHandle>> shared_memory(
- new std::vector<base::SharedMemoryHandle>());
+ std::vector<BlobItemBytesRequest> byte_requests;
+ std::vector<base::SharedMemoryHandle> shared_memory;
for (; state->next_request < num_requests; ++state->next_request) {
const MemoryItemRequest& request = requests[state->next_request];
-
- bool stop_accumulating = false;
bool using_shared_memory_handle = state->num_shared_memory_requests > 0;
- switch (request.message.transport_strategy) {
- case IPCBlobItemRequestStrategy::IPC:
- byte_requests->push_back(request.message);
- break;
- case IPCBlobItemRequestStrategy::SHARED_MEMORY:
- if (using_shared_memory_handle &&
- state->current_shared_memory_handle_index !=
- request.message.handle_index) {
- // We only want one shared memory per requesting blob.
- stop_accumulating = true;
- break;
- }
- using_shared_memory_handle = true;
- state->current_shared_memory_handle_index =
- request.message.handle_index;
- state->num_shared_memory_requests++;
-
- if (!state->shared_memory_block) {
- state->shared_memory_block.reset(new base::SharedMemory());
- size_t size =
- request_builder
- .shared_memory_sizes()[request.message.handle_index];
- if (!state->shared_memory_block->CreateAnonymous(size)) {
- DVLOG(1) << "Unable to allocate shared memory for blob transfer.";
- return BlobTransportResult::CANCEL_MEMORY_FULL;
- }
- }
- shared_memory->push_back(state->shared_memory_block->handle());
- byte_requests->push_back(request.message);
- // Since we are only using one handle at a time, transform our handle
- // index correctly back to 0.
- byte_requests->back().handle_index = 0;
- break;
- case IPCBlobItemRequestStrategy::FILE:
- case IPCBlobItemRequestStrategy::UNKNOWN:
- NOTREACHED() << "Not implemented yet.";
- break;
- }
- if (stop_accumulating) {
+ if (using_shared_memory_handle &&
+ state->current_shared_memory_handle_index !=
+ request.message.handle_index) {
+ // We only want one shared memory per requesting blob.
break;
}
+ state->current_shared_memory_handle_index = request.message.handle_index;
+ state->num_shared_memory_requests++;
+
+ if (!state->shared_memory_block) {
+ state->shared_memory_block.reset(new base::SharedMemory());
+ size_t size =
+ request_builder.shared_memory_sizes()[request.message.handle_index];
+ if (!state->shared_memory_block->CreateAnonymous(size)) {
+ DVLOG(1) << "Unable to allocate shared memory for blob transfer.";
+ return BlobStatus::ERR_OUT_OF_MEMORY;
+ }
+ }
+ shared_memory.push_back(state->shared_memory_block->handle());
+ byte_requests.push_back(request.message);
+ // Since we are only using one handle at a time, transform our handle
+ // index correctly back to 0.
+ byte_requests.back().handle_index = 0;
}
DCHECK(!requests.empty());
- state->request_memory_callback.Run(
- std::move(byte_requests), std::move(shared_memory),
- base::MakeUnique<std::vector<base::File>>());
- return BlobTransportResult::PENDING_RESPONSES;
+ state->request_memory_callback.Run(std::move(byte_requests),
+ std::move(shared_memory),
+ std::vector<base::File>());
+ return BlobStatus::PENDING_TRANSPORT;
}
-void BlobAsyncBuilderHost::ReferencedBlobFinished(
- const std::string& owning_blob_uuid,
- base::WeakPtr<BlobStorageContext> context,
- bool construction_success,
- IPCBlobCreationCancelCode reason) {
- if (!context) {
- return;
+BlobStatus BlobAsyncBuilderHost::OnSharedMemoryResponses(
+ const std::string& uuid,
+ BlobBuildingState* state,
+ const std::vector<BlobItemBytesResponse>& responses,
+ BlobStorageContext* context) {
+ BlobAsyncTransportRequestBuilder& request_builder = state->request_builder;
+ const auto& requests = request_builder.requests();
+ for (const BlobItemBytesResponse& response : responses) {
+ const MemoryItemRequest& request = requests[response.request_number];
+ if (state->num_shared_memory_requests == 0) {
+ DVLOG(1) << "Received too many responses for shared memory.";
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+ }
+ state->num_shared_memory_requests--;
+ if (!state->shared_memory_block->memory()) {
+ // We just map the whole block, as we'll probably be accessing the
+ // whole thing in this group of responses.
+ size_t handle_size =
+ request_builder
+ .shared_memory_sizes()[state->current_shared_memory_handle_index];
+ if (!state->shared_memory_block->Map(handle_size)) {
+ DVLOG(1) << "Unable to map memory to size " << handle_size;
+ CancelBuildingBlob(uuid, BlobStatus::ERR_OUT_OF_MEMORY, context);
+ return BlobStatus::ERR_OUT_OF_MEMORY;
+ }
+ }
+
+ bool success = state->data_builder.PopulateFutureData(
+ request.browser_item_index,
+ static_cast<const char*>(state->shared_memory_block->memory()) +
+ request.message.handle_offset,
+ request.browser_item_offset, request.message.size);
+
+ if (!success) {
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
+ }
+ state->num_fulfilled_requests++;
}
- auto state_it = async_blob_map_.find(owning_blob_uuid);
- if (state_it == async_blob_map_.end()) {
- return;
+ if (state->num_fulfilled_requests == requests.size()) {
+ FinishBuildingBlob(state, context);
+ return BlobStatus::DONE;
}
- if (!construction_success) {
- CancelBuildingBlob(owning_blob_uuid,
- ConvertReferencedBlobErrorToConstructingError(reason),
- context.get());
- return;
+ return ContinueSharedMemoryRequests(uuid, state, context);
+}
+
+void BlobAsyncBuilderHost::SendFileRequests(
+ BlobBuildingState* state,
+ BlobStorageContext* context,
+ std::vector<BlobMemoryController::FileCreationInfo> file_infos) {
+ LOG(ERROR) << "Files created for renderer. " << file_infos.size();
+
+ std::vector<base::File> files;
+
+ for (BlobMemoryController::FileCreationInfo& file_info : file_infos) {
+ state->files.push_back(std::move(file_info.file_reference));
+ files.push_back(std::move(file_info.file));
}
- BlobBuildingState* state = state_it->second.get();
- DCHECK_GT(state->num_referenced_blobs_building, 0u);
- if (--state->num_referenced_blobs_building == 0) {
- context->CompletePendingBlob(state->data_builder);
- async_blob_map_.erase(state->data_builder.uuid());
+
+ const std::vector<MemoryItemRequest>& requests =
+ state->request_builder.requests();
+ std::vector<BlobItemBytesRequest> byte_requests;
+
+ DCHECK(!requests.empty());
+ for (const MemoryItemRequest& request : requests) {
+ byte_requests.push_back(request.message);
}
+
+ state->request_memory_callback.Run(std::move(byte_requests),
+ std::vector<base::SharedMemoryHandle>(),
+ std::move(files));
}
-void BlobAsyncBuilderHost::FinishBuildingBlob(BlobBuildingState* state,
- BlobStorageContext* context) {
- if (!state->referenced_blob_uuids.empty()) {
- DCHECK_EQ(0u, state->num_referenced_blobs_building);
- state->num_referenced_blobs_building = 0;
- // We assume re-entry is not possible, as RunOnConstructionComplete
- // will schedule a task when the blob is being built. Thus we can't have the
- // case where |num_referenced_blobs_building| reaches 0 in the
- // ReferencedBlobFinished method before we're finished looping.
- for (const std::string& referenced_uuid : state->referenced_blob_uuids) {
- if (context->IsBeingBuilt(referenced_uuid)) {
- state->num_referenced_blobs_building++;
- context->RunOnConstructionComplete(
- referenced_uuid,
- base::Bind(&BlobAsyncBuilderHost::ReferencedBlobFinished,
- ptr_factory_.GetWeakPtr(), state->data_builder.uuid(),
- context->AsWeakPtr()));
- }
- }
- if (state->num_referenced_blobs_building > 0) {
- // We wait until referenced blobs are done.
- return;
+BlobStatus BlobAsyncBuilderHost::OnFileResponses(
+ const std::string& uuid,
+ BlobBuildingState* state,
+ const std::vector<BlobItemBytesResponse>& responses,
+ BlobStorageContext* context) {
+ BlobAsyncTransportRequestBuilder& request_builder = state->request_builder;
+ const auto& requests = request_builder.requests();
+ for (const BlobItemBytesResponse& response : responses) {
+ const MemoryItemRequest& request = requests[response.request_number];
+ const scoped_refptr<ShareableFileReference>& file_ref =
+ state->files[request.message.handle_index];
+ bool success = state->data_builder.PopulateFutureFile(
+ request.browser_item_index, file_ref, response.time_file_modified);
+ if (!success) {
+ CancelBuildingBlob(uuid, BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
+ context);
+ return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
}
+ state->num_fulfilled_requests++;
+ }
+ if (state->num_fulfilled_requests == requests.size()) {
+ FinishBuildingBlob(state, context);
+ return BlobStatus::DONE;
}
- context->CompletePendingBlob(state->data_builder);
+ return BlobStatus::PENDING_TRANSPORT;
+}
+
+void BlobAsyncBuilderHost::FinishBuildingBlob(BlobBuildingState* state,
+ BlobStorageContext* context) {
+ std::string uuid = state->data_builder.uuid();
async_blob_map_.erase(state->data_builder.uuid());
+ context->FinishedPopulatingPendingBlob(uuid);
}
} // namespace storage
« no previous file with comments | « storage/browser/blob/blob_async_builder_host.h ('k') | storage/browser/blob/blob_async_transport_request_builder.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698