| // 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. |
| |
| #include "content/child/blob_storage/blob_consolidation.h" |
| |
| #include <algorithm> |
| #include <limits> |
| #include <string> |
| |
| #include "base/bind.h" |
| #include "base/callback.h" |
| |
| using storage::DataElement; |
| using blink::WebThreadSafeData; |
| |
| namespace content { |
| namespace { |
| bool WriteMemory(void* memory_out, |
| size_t* total_read, |
| const char* memory, |
| size_t size) { |
| memcpy(static_cast<char*>(memory_out) + *total_read, memory, size); |
| *total_read += size; |
| return true; |
| } |
| } // namespace |
| |
| using ReadStatus = BlobConsolidation::ReadStatus; |
| |
| BlobConsolidation::ConsolidatedItem::ConsolidatedItem() |
| : type(DataElement::TYPE_UNKNOWN), |
| offset(0), |
| length(std::numeric_limits<uint64_t>::max()), |
| expected_modification_time(0) {} |
| |
| BlobConsolidation::ConsolidatedItem::~ConsolidatedItem() { |
| } |
| |
| BlobConsolidation::ConsolidatedItem::ConsolidatedItem(DataElement::Type type, |
| uint64_t offset, |
| uint64_t length) |
| : type(type), |
| offset(offset), |
| length(length), |
| expected_modification_time(0) { |
| } |
| |
| BlobConsolidation::ConsolidatedItem::ConsolidatedItem( |
| const ConsolidatedItem& other) = default; |
| |
| BlobConsolidation::BlobConsolidation() : total_memory_(0) { |
| } |
| |
| BlobConsolidation::~BlobConsolidation() { |
| } |
| |
| void BlobConsolidation::AddDataItem(const WebThreadSafeData& data) { |
| if (data.size() == 0) |
| return; |
| if (consolidated_items_.empty() || |
| consolidated_items_.back().type != DataElement::TYPE_BYTES) { |
| consolidated_items_.push_back( |
| ConsolidatedItem(DataElement::TYPE_BYTES, 0, 0)); |
| } |
| ConsolidatedItem& item = consolidated_items_.back(); |
| if (!item.data.empty()) { |
| item.offsets.push_back(static_cast<size_t>(item.length)); |
| } |
| item.length += data.size(); |
| total_memory_ += data.size(); |
| item.data.push_back(data); |
| } |
| |
| void BlobConsolidation::AddFileItem(const base::FilePath& path, |
| uint64_t offset, |
| uint64_t length, |
| double expected_modification_time) { |
| if (length == 0) |
| return; |
| consolidated_items_.push_back( |
| ConsolidatedItem(DataElement::TYPE_FILE, offset, length)); |
| ConsolidatedItem& item = consolidated_items_.back(); |
| item.path = path; |
| item.expected_modification_time = expected_modification_time; |
| } |
| |
| void BlobConsolidation::AddBlobItem(const std::string& uuid, |
| uint64_t offset, |
| uint64_t length) { |
| if (length == 0) |
| return; |
| consolidated_items_.push_back( |
| ConsolidatedItem(DataElement::TYPE_BLOB, offset, length)); |
| ConsolidatedItem& item = consolidated_items_.back(); |
| item.blob_uuid = uuid; |
| referenced_blobs_.insert(uuid); |
| } |
| |
| void BlobConsolidation::AddFileSystemItem(const GURL& url, |
| uint64_t offset, |
| uint64_t length, |
| double expected_modification_time) { |
| if (length == 0) |
| return; |
| consolidated_items_.push_back( |
| ConsolidatedItem(DataElement::TYPE_FILE_FILESYSTEM, offset, length)); |
| ConsolidatedItem& item = consolidated_items_.back(); |
| item.filesystem_url = url; |
| item.expected_modification_time = expected_modification_time; |
| } |
| |
| ReadStatus BlobConsolidation::VisitMemory(size_t consolidated_item_index, |
| size_t consolidated_offset, |
| size_t consolidated_size, |
| const MemoryVisitor& visitor) const { |
| if (consolidated_item_index >= consolidated_items_.size()) |
| return ReadStatus::ERROR_OUT_OF_BOUNDS; |
| |
| const ConsolidatedItem& item = consolidated_items_[consolidated_item_index]; |
| if (item.type != DataElement::TYPE_BYTES) |
| return ReadStatus::ERROR_WRONG_TYPE; |
| |
| if (consolidated_size + consolidated_offset > item.length) { |
| return ReadStatus::ERROR_OUT_OF_BOUNDS; |
| } |
| |
| // We do a binary search to find the correct data to start with in the data |
| // elements. This is slightly customized due to our unique storage and |
| // constraints. |
| size_t mid = 0; |
| size_t offset_from_mid = consolidated_offset; |
| size_t num_items = item.data.size(); |
| if (!item.offsets.empty()) { |
| size_t low = 0; |
| size_t high = num_items - 1; |
| while (true) { |
| mid = (high + low) / 2; |
| // Note: we don't include the implicit '0' for the first item in offsets. |
| size_t item_offset = (mid == 0 ? 0 : item.offsets[mid - 1]); |
| offset_from_mid = consolidated_offset - item_offset; |
| size_t next_item_offset = (mid + 1 == num_items ? 0 : item.offsets[mid]); |
| if (item_offset == consolidated_offset) { |
| // found exact match. |
| break; |
| } else if (item_offset > consolidated_offset) { |
| high = mid - 1; |
| } else if (mid + 1 == num_items || |
| next_item_offset > consolidated_offset) { |
| // We are at the last item, or the next offset is greater than the one |
| // we want, so the current item wins. |
| break; |
| } else { |
| low = mid + 1; |
| } |
| } |
| } |
| |
| DCHECK_LT(offset_from_mid, item.data[mid].size()); |
| // Read starting from 'mid' and 'offset_from_mid'. |
| for (size_t memory_read = 0; |
| mid < num_items && memory_read < consolidated_size; mid++) { |
| size_t read_size = std::min(item.data[mid].size() - offset_from_mid, |
| consolidated_size - memory_read); |
| bool continu = |
| visitor.Run(item.data[mid].data() + offset_from_mid, read_size); |
| if (!continu) |
| return ReadStatus::CANCELLED_BY_VISITOR; |
| offset_from_mid = 0; |
| memory_read += read_size; |
| } |
| return ReadStatus::OK; |
| } |
| |
| ReadStatus BlobConsolidation::ReadMemory(size_t consolidated_item_index, |
| size_t consolidated_offset, |
| size_t consolidated_size, |
| void* memory_out) const { |
| size_t total_read = 0; |
| return VisitMemory(consolidated_item_index, consolidated_offset, |
| consolidated_size, |
| base::Bind(&WriteMemory, memory_out, &total_read)); |
| } |
| |
| } // namespace content |