OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "storage/browser/blob/blob_storage_context.h" | 5 #include "storage/browser/blob/blob_storage_context.h" |
6 | 6 |
7 #include <stddef.h> | |
8 #include <stdint.h> | |
9 | |
10 #include <algorithm> | 7 #include <algorithm> |
11 #include <limits> | 8 #include <limits> |
12 #include <memory> | 9 #include <memory> |
| 10 #include <set> |
13 #include <utility> | 11 #include <utility> |
14 | 12 |
15 #include "base/bind.h" | 13 #include "base/bind.h" |
16 #include "base/callback.h" | 14 #include "base/callback.h" |
17 #include "base/location.h" | 15 #include "base/location.h" |
18 #include "base/logging.h" | 16 #include "base/logging.h" |
19 #include "base/memory/ptr_util.h" | 17 #include "base/memory/ptr_util.h" |
20 #include "base/message_loop/message_loop.h" | 18 #include "base/message_loop/message_loop.h" |
21 #include "base/metrics/histogram_macros.h" | 19 #include "base/metrics/histogram_macros.h" |
| 20 #include "base/numerics/safe_conversions.h" |
| 21 #include "base/numerics/safe_math.h" |
| 22 #include "base/task_runner.h" |
22 #include "base/threading/thread_task_runner_handle.h" | 23 #include "base/threading/thread_task_runner_handle.h" |
23 #include "base/trace_event/trace_event.h" | 24 #include "base/trace_event/trace_event.h" |
24 #include "storage/browser/blob/blob_data_builder.h" | 25 #include "storage/browser/blob/blob_data_builder.h" |
25 #include "storage/browser/blob/blob_data_handle.h" | |
26 #include "storage/browser/blob/blob_data_item.h" | 26 #include "storage/browser/blob/blob_data_item.h" |
27 #include "storage/browser/blob/blob_data_snapshot.h" | 27 #include "storage/browser/blob/blob_data_snapshot.h" |
| 28 #include "storage/browser/blob/blob_transport_request_builder.h" |
28 #include "storage/browser/blob/shareable_blob_data_item.h" | 29 #include "storage/browser/blob/shareable_blob_data_item.h" |
| 30 #include "storage/common/data_element.h" |
29 #include "url/gurl.h" | 31 #include "url/gurl.h" |
30 | 32 |
31 namespace storage { | 33 namespace storage { |
32 using BlobRegistryEntry = BlobStorageRegistry::Entry; | 34 namespace { |
33 using BlobState = BlobStorageRegistry::BlobState; | 35 using ItemCopyEntry = BlobEntry::ItemCopyEntry; |
34 | 36 using QuotaAllocationTask = BlobMemoryController::QuotaAllocationTask; |
35 BlobStorageContext::BlobStorageContext() : memory_usage_(0) {} | 37 |
| 38 bool IsBytes(DataElement::Type type) { |
| 39 return type == DataElement::TYPE_BYTES || |
| 40 type == DataElement::TYPE_BYTES_DESCRIPTION; |
| 41 } |
| 42 } // namespace |
| 43 |
| 44 BlobStorageContext::BlobFlattener::BlobFlattener( |
| 45 const BlobDataBuilder& input_builder, |
| 46 BlobEntry* output_blob, |
| 47 BlobStorageRegistry* registry) { |
| 48 const std::string& uuid = input_builder.uuid_; |
| 49 std::set<std::string> dependent_blob_uuids; |
| 50 |
| 51 size_t num_files_with_unknown_size = 0; |
| 52 size_t num_building_dependent_blobs = 0; |
| 53 |
| 54 base::CheckedNumeric<uint64_t> checked_total_size = 0; |
| 55 base::CheckedNumeric<uint64_t> checked_memory_quota_needed = 0; |
| 56 |
| 57 for (scoped_refptr<BlobDataItem> input_item : input_builder.items_) { |
| 58 const DataElement& input_element = input_item->data_element(); |
| 59 DataElement::Type type = input_element.type(); |
| 60 uint64_t length = input_element.length(); |
| 61 |
| 62 if (IsBytes(type)) { |
| 63 DCHECK_NE(0 + DataElement::kUnknownSize, input_element.length()); |
| 64 checked_memory_quota_needed += length; |
| 65 checked_total_size += length; |
| 66 scoped_refptr<ShareableBlobDataItem> item = new ShareableBlobDataItem( |
| 67 std::move(input_item), ShareableBlobDataItem::QUOTA_NEEDED); |
| 68 pending_memory_items.push_back(item); |
| 69 user_items.push_back(item.get()); |
| 70 output_blob->AppendSharedBlobItem(uuid, std::move(item)); |
| 71 continue; |
| 72 } |
| 73 if (type == DataElement::TYPE_BLOB) { |
| 74 BlobEntry* ref_entry = registry->GetEntry(input_element.blob_uuid()); |
| 75 |
| 76 if (!ref_entry || input_element.blob_uuid() == uuid) { |
| 77 status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
| 78 return; |
| 79 } |
| 80 |
| 81 if (BlobStatusIsError(ref_entry->status())) { |
| 82 status = BlobStatus::ERR_REFERENCED_BLOB_BROKEN; |
| 83 return; |
| 84 } |
| 85 |
| 86 if (ref_entry->total_size() == DataElement::kUnknownSize) { |
| 87 // We can't reference a blob with unknown size. |
| 88 status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
| 89 return; |
| 90 } |
| 91 |
| 92 if (dependent_blob_uuids.find(input_element.blob_uuid()) == |
| 93 dependent_blob_uuids.end()) { |
| 94 dependent_blobs.push_back( |
| 95 std::make_pair(input_element.blob_uuid(), ref_entry)); |
| 96 dependent_blob_uuids.insert(input_element.blob_uuid()); |
| 97 if (BlobStatusIsPending(ref_entry->status())) { |
| 98 num_building_dependent_blobs++; |
| 99 } |
| 100 } |
| 101 |
| 102 length = length == DataElement::kUnknownSize ? ref_entry->total_size() |
| 103 : input_element.length(); |
| 104 checked_total_size += length; |
| 105 |
| 106 // If we're referencing the whole blob, then we don't need to slice. |
| 107 if (input_element.offset() == 0 && length == ref_entry->total_size()) { |
| 108 for (const auto& shareable_item : ref_entry->items()) { |
| 109 output_blob->AppendSharedBlobItem(uuid, shareable_item); |
| 110 } |
| 111 continue; |
| 112 } |
| 113 |
| 114 // Validate our reference has good offset & length. |
| 115 if (input_element.offset() + length > ref_entry->total_size()) { |
| 116 status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
| 117 return; |
| 118 } |
| 119 |
| 120 BlobSlice slice(*ref_entry, input_element.offset(), length); |
| 121 |
| 122 if (slice.first_source_item) { |
| 123 copies.push_back(ItemCopyEntry(slice.first_source_item, |
| 124 slice.first_item_slice_offset, |
| 125 slice.dest_items.front())); |
| 126 pending_memory_items.push_back(slice.dest_items.front()); |
| 127 } |
| 128 if (slice.last_source_item) { |
| 129 copies.push_back( |
| 130 ItemCopyEntry(slice.last_source_item, 0, slice.dest_items.back())); |
| 131 pending_memory_items.push_back(slice.dest_items.back()); |
| 132 } |
| 133 checked_memory_quota_needed += slice.copying_memory_size; |
| 134 |
| 135 for (auto& shareable_item : slice.dest_items) { |
| 136 output_blob->AppendSharedBlobItem(uuid, std::move(shareable_item)); |
| 137 } |
| 138 continue; |
| 139 } |
| 140 |
| 141 DCHECK(!BlobDataBuilder::IsFutureFileItem(input_element)) |
| 142 << "File allocation not implemented."; |
| 143 if (length == DataElement::kUnknownSize) |
| 144 num_files_with_unknown_size++; |
| 145 |
| 146 scoped_refptr<ShareableBlobDataItem> item = new ShareableBlobDataItem( |
| 147 std::move(input_item), ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA); |
| 148 |
| 149 checked_total_size += length; |
| 150 output_blob->AppendSharedBlobItem(uuid, std::move(item)); |
| 151 } |
| 152 |
| 153 if (num_files_with_unknown_size > 1 && input_builder.items_.size() > 1) { |
| 154 status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
| 155 return; |
| 156 } |
| 157 if (!checked_total_size.IsValid() || !checked_memory_quota_needed.IsValid()) { |
| 158 status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
| 159 return; |
| 160 } |
| 161 total_size = checked_total_size.ValueOrDie(); |
| 162 memory_quota_needed = checked_memory_quota_needed.ValueOrDie(); |
| 163 if (memory_quota_needed) { |
| 164 status = BlobStatus::PENDING_QUOTA; |
| 165 } else { |
| 166 status = BlobStatus::PENDING_INTERNALS; |
| 167 } |
| 168 } |
| 169 |
| 170 BlobStorageContext::BlobFlattener::~BlobFlattener() {} |
| 171 |
| 172 BlobStorageContext::BlobSlice::BlobSlice(const BlobEntry& source, |
| 173 uint64_t slice_offset, |
| 174 uint64_t slice_size) { |
| 175 const auto& source_items = source.items(); |
| 176 const auto& offsets = source.offsets(); |
| 177 DCHECK_LE(slice_offset + slice_size, source.total_size()); |
| 178 size_t item_index = |
| 179 std::upper_bound(offsets.begin(), offsets.end(), slice_offset) - |
| 180 offsets.begin(); |
| 181 uint64_t item_offset = |
| 182 item_index == 0 ? slice_offset : slice_offset - offsets[item_index - 1]; |
| 183 size_t num_items = source_items.size(); |
| 184 |
| 185 size_t first_item_index = item_index; |
| 186 copying_memory_size = 0; |
| 187 |
| 188 // Read starting from 'first_item_index' and 'item_offset'. |
| 189 for (uint64_t total_sliced = 0; |
| 190 item_index < num_items && total_sliced < slice_size; item_index++) { |
| 191 const scoped_refptr<BlobDataItem>& source_item = |
| 192 source_items[item_index]->item(); |
| 193 uint64_t source_length = source_item->length(); |
| 194 DCHECK_NE(source_length, std::numeric_limits<uint64_t>::max()); |
| 195 DCHECK_NE(source_length, 0ull); |
| 196 |
| 197 uint64_t read_size = |
| 198 std::min(source_length - item_offset, slice_size - total_sliced); |
| 199 total_sliced += read_size; |
| 200 |
| 201 if (read_size == source_length) { |
| 202 // We can share the entire item. |
| 203 dest_items.push_back(source_items[item_index]); |
| 204 continue; |
| 205 } |
| 206 |
| 207 scoped_refptr<BlobDataItem> data_item; |
| 208 ShareableBlobDataItem::State state = |
| 209 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA; |
| 210 switch (source_item->type()) { |
| 211 case DataElement::TYPE_BYTES_DESCRIPTION: |
| 212 case DataElement::TYPE_BYTES: { |
| 213 if (item_index == first_item_index) { |
| 214 first_item_slice_offset = item_offset; |
| 215 first_source_item = source_items[item_index]; |
| 216 } else { |
| 217 last_source_item = source_items[item_index]; |
| 218 } |
| 219 copying_memory_size += read_size; |
| 220 // Since we don't have quota yet for memory, we create temporary items |
| 221 // for this data. When our blob is finished constructing, all dependent |
| 222 // blobs are done, and we have enough memory quota, we'll copy the data |
| 223 // over. |
| 224 std::unique_ptr<DataElement> element(new DataElement()); |
| 225 element->SetToBytesDescription(base::checked_cast<size_t>(read_size)); |
| 226 data_item = new BlobDataItem(std::move(element)); |
| 227 state = ShareableBlobDataItem::QUOTA_NEEDED; |
| 228 break; |
| 229 } |
| 230 case DataElement::TYPE_FILE: { |
| 231 std::unique_ptr<DataElement> element(new DataElement()); |
| 232 element->SetToFilePathRange( |
| 233 source_item->path(), source_item->offset() + item_offset, read_size, |
| 234 source_item->expected_modification_time()); |
| 235 data_item = |
| 236 new BlobDataItem(std::move(element), source_item->data_handle_); |
| 237 |
| 238 DCHECK(!BlobDataBuilder::IsFutureFileItem(source_item->data_element())) |
| 239 << "File allocation unimplemented."; |
| 240 break; |
| 241 } |
| 242 case DataElement::TYPE_FILE_FILESYSTEM: { |
| 243 std::unique_ptr<DataElement> element(new DataElement()); |
| 244 element->SetToFileSystemUrlRange( |
| 245 source_item->filesystem_url(), source_item->offset() + item_offset, |
| 246 read_size, source_item->expected_modification_time()); |
| 247 data_item = new BlobDataItem(std::move(element)); |
| 248 break; |
| 249 } |
| 250 case DataElement::TYPE_DISK_CACHE_ENTRY: { |
| 251 std::unique_ptr<DataElement> element(new DataElement()); |
| 252 element->SetToDiskCacheEntryRange(source_item->offset() + item_offset, |
| 253 read_size); |
| 254 data_item = |
| 255 new BlobDataItem(std::move(element), source_item->data_handle_, |
| 256 source_item->disk_cache_entry(), |
| 257 source_item->disk_cache_stream_index(), |
| 258 source_item->disk_cache_side_stream_index()); |
| 259 break; |
| 260 } |
| 261 case DataElement::TYPE_BLOB: |
| 262 case DataElement::TYPE_UNKNOWN: |
| 263 CHECK(false) << "Illegal blob item type: " << source_item->type(); |
| 264 } |
| 265 dest_items.push_back( |
| 266 new ShareableBlobDataItem(std::move(data_item), state)); |
| 267 item_offset = 0; |
| 268 } |
| 269 } |
| 270 |
| 271 BlobStorageContext::BlobSlice::~BlobSlice() {} |
| 272 |
| 273 BlobStorageContext::BlobStorageContext() |
| 274 : memory_controller_(base::FilePath(), scoped_refptr<base::TaskRunner>()), |
| 275 ptr_factory_(this) {} |
36 | 276 |
37 BlobStorageContext::~BlobStorageContext() { | 277 BlobStorageContext::~BlobStorageContext() { |
38 } | 278 } |
39 | 279 |
40 std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID( | 280 std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID( |
41 const std::string& uuid) { | 281 const std::string& uuid) { |
42 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 282 BlobEntry* entry = registry_.GetEntry(uuid); |
43 if (!entry) { | 283 if (!entry) |
44 return nullptr; | 284 return nullptr; |
45 } | 285 return CreateHandle(uuid, entry); |
46 return base::WrapUnique( | |
47 new BlobDataHandle(uuid, entry->content_type, entry->content_disposition, | |
48 this, base::ThreadTaskRunnerHandle::Get().get())); | |
49 } | 286 } |
50 | 287 |
51 std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL( | 288 std::unique_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL( |
52 const GURL& url) { | 289 const GURL& url) { |
53 std::string uuid; | 290 std::string uuid; |
54 BlobRegistryEntry* entry = registry_.GetEntryFromURL(url, &uuid); | 291 BlobEntry* entry = registry_.GetEntryFromURL(url, &uuid); |
55 if (!entry) { | 292 if (!entry) |
56 return nullptr; | 293 return nullptr; |
57 } | 294 return CreateHandle(uuid, entry); |
58 return base::WrapUnique( | |
59 new BlobDataHandle(uuid, entry->content_type, entry->content_disposition, | |
60 this, base::ThreadTaskRunnerHandle::Get().get())); | |
61 } | 295 } |
62 | 296 |
63 std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( | 297 std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( |
64 const BlobDataBuilder& external_builder) { | 298 const BlobDataBuilder& external_builder) { |
65 TRACE_EVENT0("Blob", "Context::AddFinishedBlob"); | 299 TRACE_EVENT0("Blob", "Context::AddFinishedBlob"); |
66 CreatePendingBlob(external_builder.uuid(), external_builder.content_type_, | 300 return BuildBlob(external_builder, TransportAllowedCallback()); |
67 external_builder.content_disposition_); | |
68 CompletePendingBlob(external_builder); | |
69 std::unique_ptr<BlobDataHandle> handle = | |
70 GetBlobDataFromUUID(external_builder.uuid_); | |
71 DecrementBlobRefCount(external_builder.uuid_); | |
72 return handle; | |
73 } | 301 } |
74 | 302 |
75 std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( | 303 std::unique_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob( |
76 const BlobDataBuilder* builder) { | 304 const BlobDataBuilder* builder) { |
77 DCHECK(builder); | 305 DCHECK(builder); |
78 return AddFinishedBlob(*builder); | 306 return AddFinishedBlob(*builder); |
79 } | 307 } |
80 | 308 |
| 309 std::unique_ptr<BlobDataHandle> BlobStorageContext::AddBrokenBlob( |
| 310 const std::string& uuid, |
| 311 const std::string& content_type, |
| 312 const std::string& content_disposition, |
| 313 BlobStatus reason) { |
| 314 DCHECK(!registry_.HasEntry(uuid)); |
| 315 DCHECK(BlobStatusIsError(reason)); |
| 316 BlobEntry* entry = |
| 317 registry_.CreateEntry(uuid, content_type, content_disposition); |
| 318 entry->status_ = reason; |
| 319 FinishBuilding(entry); |
| 320 return CreateHandle(uuid, entry); |
| 321 } |
| 322 |
81 bool BlobStorageContext::RegisterPublicBlobURL(const GURL& blob_url, | 323 bool BlobStorageContext::RegisterPublicBlobURL(const GURL& blob_url, |
82 const std::string& uuid) { | 324 const std::string& uuid) { |
83 if (!registry_.CreateUrlMapping(blob_url, uuid)) { | 325 if (!registry_.CreateUrlMapping(blob_url, uuid)) |
84 return false; | 326 return false; |
85 } | |
86 IncrementBlobRefCount(uuid); | 327 IncrementBlobRefCount(uuid); |
87 return true; | 328 return true; |
88 } | 329 } |
89 | 330 |
90 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) { | 331 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) { |
91 std::string uuid; | 332 std::string uuid; |
92 if (!registry_.DeleteURLMapping(blob_url, &uuid)) { | 333 if (!registry_.DeleteURLMapping(blob_url, &uuid)) |
93 return; | 334 return; |
94 } | |
95 DecrementBlobRefCount(uuid); | 335 DecrementBlobRefCount(uuid); |
96 } | 336 } |
97 | 337 |
98 void BlobStorageContext::CreatePendingBlob( | 338 std::unique_ptr<BlobDataHandle> BlobStorageContext::BuildBlob( |
99 const std::string& uuid, | 339 const BlobDataBuilder& content, |
100 const std::string& content_type, | 340 const TransportAllowedCallback& can_populate_memory) { |
101 const std::string& content_disposition) { | 341 DCHECK(!registry_.HasEntry(content.uuid_)); |
102 DCHECK(!registry_.GetEntry(uuid) && !uuid.empty()); | 342 |
103 registry_.CreateEntry(uuid, content_type, content_disposition); | 343 BlobEntry* entry = registry_.CreateEntry(content.uuid_, content.content_type_, |
| 344 content.content_disposition_); |
| 345 |
| 346 // This flattens all blob references in the transportion content out and |
| 347 // stores the complete item representation in the internal data. |
| 348 BlobFlattener flattener(content, entry, ®istry_); |
| 349 |
| 350 // If we contain invalid references we're invalid input. |
| 351 if (flattener.status == BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS) { |
| 352 CancelBuildingBlob(content.uuid_, |
| 353 BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS); |
| 354 return CreateHandle(content.uuid_, entry); |
| 355 } |
| 356 |
| 357 // If we contain broken references (or we reference ourself) we want to fail. |
| 358 if (flattener.status == BlobStatus::ERR_REFERENCED_BLOB_BROKEN) { |
| 359 CancelBuildingBlob(content.uuid_, BlobStatus::ERR_REFERENCED_BLOB_BROKEN); |
| 360 return CreateHandle(content.uuid_, entry); |
| 361 } |
| 362 |
| 363 if (!memory_controller_.CanReserveQuota(flattener.memory_quota_needed)) { |
| 364 CancelBuildingBlob(content.uuid_, BlobStatus::ERR_OUT_OF_MEMORY); |
| 365 return CreateHandle(content.uuid_, entry); |
| 366 } |
| 367 |
| 368 entry->status_ = flattener.status; |
| 369 entry->size_ = flattener.total_size; |
| 370 std::unique_ptr<BlobDataHandle> handle = CreateHandle(content.uuid_, entry); |
| 371 |
| 372 size_t num_building_dependent_blobs = 0; |
| 373 std::vector<std::unique_ptr<BlobDataHandle>> dependent_blobs; |
| 374 // We hold a handle to all blobs we're using. This is important, as our memory |
| 375 // accounting can be delayed until OnEnoughSizeForBlobData is called, and we |
| 376 // only free memory on canceling when we've done this accounting. If a |
| 377 // dependent blob is dereferenced, then we're the last blob holding onto that |
| 378 // data item, and we need to account for that. So we prevent that case by |
| 379 // holding onto all blobs. |
| 380 for (const std::pair<std::string, BlobEntry*>& pending_blob : |
| 381 flattener.dependent_blobs) { |
| 382 dependent_blobs.push_back( |
| 383 CreateHandle(pending_blob.first, pending_blob.second)); |
| 384 if (BlobStatusIsPending(pending_blob.second->status())) { |
| 385 pending_blob.second->building_state_->build_completion_callbacks |
| 386 .push_back(base::Bind(&BlobStorageContext::OnDependentBlobFinished, |
| 387 ptr_factory_.GetWeakPtr(), content.uuid_)); |
| 388 num_building_dependent_blobs++; |
| 389 } |
| 390 } |
| 391 |
| 392 DCHECK(flattener.status != BlobStatus::PENDING_TRANSPORT || |
| 393 !can_populate_memory) |
| 394 << "There is no pending content for the user to populate, so the " |
| 395 "callback should be null."; |
| 396 DCHECK(flattener.status != BlobStatus::PENDING_TRANSPORT || |
| 397 can_populate_memory) |
| 398 << "If we have pending content then there needs to be a callback " |
| 399 "present."; |
| 400 |
| 401 entry->building_state_.reset(new BlobEntry::BuildingState( |
| 402 !flattener.user_items.empty(), can_populate_memory, |
| 403 num_building_dependent_blobs, flattener.memory_quota_needed > 0)); |
| 404 |
| 405 BlobEntry::BuildingState* building_state = entry->building_state_.get(); |
| 406 std::swap(building_state->copies, flattener.copies); |
| 407 std::swap(building_state->dependent_blobs, dependent_blobs); |
| 408 std::swap(building_state->user_items, flattener.user_items); |
| 409 |
| 410 if (flattener.memory_quota_needed > 0) { |
| 411 // We can finish our blob before returning from this method. |
| 412 base::WeakPtr<QuotaAllocationTask> pending_request = |
| 413 memory_controller_.ReserveMemoryQuota( |
| 414 std::move(flattener.pending_memory_items), |
| 415 base::Bind(&BlobStorageContext::OnEnoughSizeForMemory, |
| 416 ptr_factory_.GetWeakPtr(), content.uuid_)); |
| 417 if (entry->building_state_) |
| 418 entry->building_state_->memory_quota_request = std::move(pending_request); |
| 419 } |
| 420 |
| 421 if (entry->CanFinishBuilding()) |
| 422 FinishBuilding(entry); |
| 423 |
| 424 return handle; |
104 } | 425 } |
105 | 426 |
106 void BlobStorageContext::CompletePendingBlob( | 427 void BlobStorageContext::CancelBuildingBlob(const std::string& uuid, |
107 const BlobDataBuilder& external_builder) { | 428 BlobStatus reason) { |
108 BlobRegistryEntry* entry = registry_.GetEntry(external_builder.uuid()); | 429 BlobEntry* entry = registry_.GetEntry(uuid); |
109 DCHECK(entry); | 430 DCHECK(entry); |
110 DCHECK(!entry->data.get()) << "Blob already constructed: " | 431 DCHECK(BlobStatusIsError(reason)); |
111 << external_builder.uuid(); | 432 TransportAllowedCallback user_data_population_callback; |
112 // We want to handle storing our broken blob as well. | 433 if (entry->building_state_ && |
113 switch (entry->state) { | 434 entry->building_state_->transport_allowed_callback) { |
114 case BlobState::PENDING: { | 435 user_data_population_callback = |
115 entry->data_builder.reset(new InternalBlobData::Builder()); | 436 entry->building_state_->transport_allowed_callback; |
116 InternalBlobData::Builder* internal_data_builder = | 437 entry->building_state_->transport_allowed_callback.Reset(); |
117 entry->data_builder.get(); | |
118 | |
119 bool broken = false; | |
120 for (const auto& blob_item : external_builder.items_) { | |
121 IPCBlobCreationCancelCode error_code; | |
122 if (!AppendAllocatedBlobItem(external_builder.uuid_, blob_item, | |
123 internal_data_builder, &error_code)) { | |
124 broken = true; | |
125 memory_usage_ -= entry->data_builder->GetNonsharedMemoryUsage(); | |
126 entry->state = BlobState::BROKEN; | |
127 entry->broken_reason = error_code; | |
128 entry->data_builder.reset(new InternalBlobData::Builder()); | |
129 break; | |
130 } | |
131 } | |
132 entry->data = entry->data_builder->Build(); | |
133 entry->data_builder.reset(); | |
134 entry->state = broken ? BlobState::BROKEN : BlobState::COMPLETE; | |
135 break; | |
136 } | |
137 case BlobState::BROKEN: { | |
138 InternalBlobData::Builder builder; | |
139 entry->data = builder.Build(); | |
140 break; | |
141 } | |
142 case BlobState::COMPLETE: | |
143 DCHECK(false) << "Blob already constructed: " << external_builder.uuid(); | |
144 return; | |
145 } | 438 } |
146 | 439 ClearAndFreeMemory(uuid, entry); |
147 UMA_HISTOGRAM_COUNTS("Storage.Blob.ItemCount", entry->data->items().size()); | 440 entry->status_ = reason; |
148 UMA_HISTOGRAM_BOOLEAN("Storage.Blob.Broken", | 441 if (user_data_population_callback) { |
149 entry->state == BlobState::BROKEN); | 442 user_data_population_callback.Run( |
150 if (entry->state == BlobState::BROKEN) { | 443 reason, std::vector<BlobMemoryController::FileCreationInfo>()); |
151 UMA_HISTOGRAM_ENUMERATION( | |
152 "Storage.Blob.BrokenReason", static_cast<int>(entry->broken_reason), | |
153 (static_cast<int>(IPCBlobCreationCancelCode::LAST) + 1)); | |
154 } | 444 } |
155 size_t total_memory = 0, nonshared_memory = 0; | 445 entry->items_.clear(); |
156 entry->data->GetMemoryUsage(&total_memory, &nonshared_memory); | 446 entry->offsets_.clear(); |
157 UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalSize", total_memory / 1024); | 447 entry->size_ = 0; |
158 UMA_HISTOGRAM_COUNTS("Storage.Blob.TotalUnsharedSize", | 448 FinishBuilding(entry); |
159 nonshared_memory / 1024); | |
160 TRACE_COUNTER1("Blob", "MemoryStoreUsageBytes", memory_usage_); | |
161 | |
162 auto runner = base::ThreadTaskRunnerHandle::Get(); | |
163 for (const auto& callback : entry->build_completion_callbacks) { | |
164 runner->PostTask(FROM_HERE, | |
165 base::Bind(callback, entry->state == BlobState::COMPLETE, | |
166 entry->broken_reason)); | |
167 } | |
168 entry->build_completion_callbacks.clear(); | |
169 } | 449 } |
170 | 450 |
171 void BlobStorageContext::CancelPendingBlob(const std::string& uuid, | 451 void BlobStorageContext::NotifyTransportComplete(const std::string& uuid) { |
172 IPCBlobCreationCancelCode reason) { | 452 BlobEntry* entry = registry_.GetEntry(uuid); |
173 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 453 CHECK(entry) << "There is no blob entry with uuid " << uuid; |
174 DCHECK(entry && entry->state == BlobState::PENDING); | 454 DCHECK(BlobStatusIsPending(entry->status())); |
175 entry->state = BlobState::BROKEN; | 455 NotifyTransportComplete(entry); |
176 entry->broken_reason = reason; | |
177 CompletePendingBlob(BlobDataBuilder(uuid)); | |
178 } | 456 } |
179 | 457 |
180 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) { | 458 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) { |
181 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 459 BlobEntry* entry = registry_.GetEntry(uuid); |
182 DCHECK(entry); | 460 DCHECK(entry); |
183 ++(entry->refcount); | 461 ++(entry->refcount_); |
184 } | 462 } |
185 | 463 |
186 void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) { | 464 void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) { |
187 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 465 BlobEntry* entry = registry_.GetEntry(uuid); |
188 DCHECK(entry); | 466 DCHECK(entry); |
189 DCHECK_GT(entry->refcount, 0u); | 467 DCHECK_GT(entry->refcount_, 0u); |
190 if (--(entry->refcount) == 0) { | 468 if (--(entry->refcount_) == 0) { |
191 size_t memory_freeing = 0; | 469 ClearAndFreeMemory(uuid, entry); |
192 if (entry->state == BlobState::COMPLETE) { | |
193 memory_freeing = entry->data->GetUnsharedMemoryUsage(); | |
194 entry->data->RemoveBlobFromShareableItems(uuid); | |
195 } | |
196 DCHECK_LE(memory_freeing, memory_usage_); | |
197 memory_usage_ -= memory_freeing; | |
198 registry_.DeleteEntry(uuid); | 470 registry_.DeleteEntry(uuid); |
199 } | 471 } |
200 } | 472 } |
201 | 473 |
202 std::unique_ptr<BlobDataSnapshot> BlobStorageContext::CreateSnapshot( | 474 std::unique_ptr<BlobDataSnapshot> BlobStorageContext::CreateSnapshot( |
203 const std::string& uuid) { | 475 const std::string& uuid) { |
204 std::unique_ptr<BlobDataSnapshot> result; | 476 std::unique_ptr<BlobDataSnapshot> result; |
205 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 477 BlobEntry* entry = registry_.GetEntry(uuid); |
206 if (entry->state != BlobState::COMPLETE) { | 478 if (entry->status() != BlobStatus::DONE) |
207 return result; | 479 return result; |
208 } | |
209 | 480 |
210 const InternalBlobData& data = *entry->data; | |
211 std::unique_ptr<BlobDataSnapshot> snapshot(new BlobDataSnapshot( | 481 std::unique_ptr<BlobDataSnapshot> snapshot(new BlobDataSnapshot( |
212 uuid, entry->content_type, entry->content_disposition)); | 482 uuid, entry->content_type(), entry->content_disposition())); |
213 snapshot->items_.reserve(data.items().size()); | 483 snapshot->items_.reserve(entry->items().size()); |
214 for (const auto& shareable_item : data.items()) { | 484 for (const auto& shareable_item : entry->items()) { |
215 snapshot->items_.push_back(shareable_item->item()); | 485 snapshot->items_.push_back(shareable_item->item()); |
216 } | 486 } |
| 487 memory_controller_.NotifyMemoryItemsUsed(entry->items()); |
217 return snapshot; | 488 return snapshot; |
218 } | 489 } |
219 | 490 |
220 bool BlobStorageContext::IsBroken(const std::string& uuid) const { | 491 BlobStatus BlobStorageContext::GetBlobStatus(const std::string& uuid) const { |
221 const BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 492 const BlobEntry* entry = registry_.GetEntry(uuid); |
222 if (!entry) { | 493 if (!entry) |
223 return true; | 494 return BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS; |
224 } | 495 return entry->status(); |
225 return entry->state == BlobState::BROKEN; | |
226 } | |
227 | |
228 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) const { | |
229 const BlobRegistryEntry* entry = registry_.GetEntry(uuid); | |
230 if (!entry) { | |
231 return false; | |
232 } | |
233 return entry->state == BlobState::PENDING; | |
234 } | 496 } |
235 | 497 |
236 void BlobStorageContext::RunOnConstructionComplete( | 498 void BlobStorageContext::RunOnConstructionComplete( |
237 const std::string& uuid, | 499 const std::string& uuid, |
238 const BlobConstructedCallback& done) { | 500 const BlobStatusCallback& done) { |
239 BlobRegistryEntry* entry = registry_.GetEntry(uuid); | 501 BlobEntry* entry = registry_.GetEntry(uuid); |
240 DCHECK(entry); | 502 DCHECK(entry); |
241 switch (entry->state) { | 503 if (BlobStatusIsPending(entry->status())) { |
242 case BlobState::COMPLETE: | 504 entry->building_state_->build_completion_callbacks.push_back(done); |
243 done.Run(true, IPCBlobCreationCancelCode::UNKNOWN); | 505 return; |
244 return; | |
245 case BlobState::BROKEN: | |
246 done.Run(false, entry->broken_reason); | |
247 return; | |
248 case BlobState::PENDING: | |
249 entry->build_completion_callbacks.push_back(done); | |
250 return; | |
251 } | 506 } |
252 NOTREACHED(); | 507 done.Run(entry->status()); |
253 } | 508 } |
254 | 509 |
255 bool BlobStorageContext::AppendAllocatedBlobItem( | 510 std::unique_ptr<BlobDataHandle> BlobStorageContext::CreateHandle( |
256 const std::string& target_blob_uuid, | 511 const std::string& uuid, |
257 scoped_refptr<BlobDataItem> blob_item, | 512 BlobEntry* entry) { |
258 InternalBlobData::Builder* target_blob_builder, | 513 return base::WrapUnique(new BlobDataHandle( |
259 IPCBlobCreationCancelCode* error_code) { | 514 uuid, entry->content_type_, entry->content_disposition_, entry->size_, |
260 DCHECK(error_code); | 515 this, base::ThreadTaskRunnerHandle::Get().get())); |
261 *error_code = IPCBlobCreationCancelCode::UNKNOWN; | |
262 bool error = false; | |
263 | |
264 // The blob data is stored in the canonical way which only contains a | |
265 // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items | |
266 // are expanded into the primitive constituent types and reused if possible. | |
267 // 1) The Data item is denoted by the raw data and length. | |
268 // 2) The File item is denoted by the file path, the range and the expected | |
269 // modification time. | |
270 // 3) The FileSystem File item is denoted by the FileSystem URL, the range | |
271 // and the expected modification time. | |
272 // 4) The Blob item is denoted by the source blob and an offset and size. | |
273 // Internal items that are fully used by the new blob (not cut by the | |
274 // offset or size) are shared between the blobs. Otherwise, the relevant | |
275 // portion of the item is copied. | |
276 | |
277 DCHECK(blob_item->data_element_ptr()); | |
278 const DataElement& data_element = blob_item->data_element(); | |
279 uint64_t length = data_element.length(); | |
280 uint64_t offset = data_element.offset(); | |
281 UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeBeforeAppend", | |
282 memory_usage_ / 1024); | |
283 switch (data_element.type()) { | |
284 case DataElement::TYPE_BYTES: | |
285 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Bytes", length / 1024); | |
286 DCHECK(!offset); | |
287 if (memory_usage_ + length > kBlobStorageMaxMemoryUsage) { | |
288 error = true; | |
289 *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY; | |
290 break; | |
291 } | |
292 memory_usage_ += length; | |
293 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
294 target_blob_uuid, blob_item, | |
295 ShareableBlobDataItem::POPULATED_WITH_QUOTA)); | |
296 break; | |
297 case DataElement::TYPE_FILE: { | |
298 bool full_file = (length == std::numeric_limits<uint64_t>::max()); | |
299 UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.File.Unknown", full_file); | |
300 if (!full_file) { | |
301 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.File", | |
302 (length - offset) / 1024); | |
303 } | |
304 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
305 target_blob_uuid, blob_item, | |
306 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
307 break; | |
308 } | |
309 case DataElement::TYPE_FILE_FILESYSTEM: { | |
310 bool full_file = (length == std::numeric_limits<uint64_t>::max()); | |
311 UMA_HISTOGRAM_BOOLEAN("Storage.BlobItemSize.FileSystem.Unknown", | |
312 full_file); | |
313 if (!full_file) { | |
314 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.FileSystem", | |
315 (length - offset) / 1024); | |
316 } | |
317 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
318 target_blob_uuid, blob_item, | |
319 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
320 break; | |
321 } | |
322 case DataElement::TYPE_BLOB: { | |
323 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.Blob", | |
324 (length - offset) / 1024); | |
325 // We grab the handle to ensure it stays around while we copy it. | |
326 std::unique_ptr<BlobDataHandle> src = | |
327 GetBlobDataFromUUID(data_element.blob_uuid()); | |
328 if (!src || src->IsBroken() || src->IsBeingBuilt()) { | |
329 error = true; | |
330 *error_code = IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN; | |
331 break; | |
332 } | |
333 BlobRegistryEntry* other_entry = | |
334 registry_.GetEntry(data_element.blob_uuid()); | |
335 DCHECK(other_entry->data); | |
336 if (!AppendBlob(target_blob_uuid, *other_entry->data, offset, length, | |
337 target_blob_builder)) { | |
338 error = true; | |
339 *error_code = IPCBlobCreationCancelCode::OUT_OF_MEMORY; | |
340 } | |
341 break; | |
342 } | |
343 case DataElement::TYPE_DISK_CACHE_ENTRY: { | |
344 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.CacheEntry", | |
345 (length - offset) / 1024); | |
346 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
347 target_blob_uuid, blob_item, | |
348 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
349 break; | |
350 } | |
351 case DataElement::TYPE_BYTES_DESCRIPTION: | |
352 case DataElement::TYPE_UNKNOWN: | |
353 NOTREACHED(); | |
354 break; | |
355 } | |
356 UMA_HISTOGRAM_COUNTS("Storage.Blob.StorageSizeAfterAppend", | |
357 memory_usage_ / 1024); | |
358 return !error; | |
359 } | 516 } |
360 | 517 |
361 bool BlobStorageContext::AppendBlob( | 518 void BlobStorageContext::NotifyTransportComplete(BlobEntry* entry) { |
362 const std::string& target_blob_uuid, | 519 DCHECK(entry); |
363 const InternalBlobData& blob, | 520 SetItemStateToPopulated(&entry->building_state_->user_items); |
364 uint64_t offset, | 521 entry->status_ = BlobStatus::PENDING_INTERNALS; |
365 uint64_t length, | 522 if (entry->CanFinishBuilding()) |
366 InternalBlobData::Builder* target_blob_builder) { | 523 FinishBuilding(entry); |
367 DCHECK_GT(length, 0ull); | 524 } |
368 | 525 |
369 const std::vector<scoped_refptr<ShareableBlobDataItem>>& items = blob.items(); | 526 void BlobStorageContext::FinishBuilding(BlobEntry* entry) { |
370 auto iter = items.begin(); | 527 DCHECK(entry); |
371 if (offset) { | 528 |
372 for (; iter != items.end(); ++iter) { | 529 if (BlobStatusIsPending(entry->status_)) { |
373 const BlobDataItem& item = *(iter->get()->item()); | 530 for (const ItemCopyEntry& copy : entry->building_state_->copies) { |
374 if (offset >= item.length()) | 531 // Our source item can be a file if it was a slice of an unpopulated file, |
375 offset -= item.length(); | 532 // or a slice of data that was then paged to disk. |
376 else | 533 size_t dest_size = static_cast<size_t>(copy.dest_item->item()->length()); |
377 break; | 534 DataElement::Type dest_type = copy.dest_item->item()->type(); |
| 535 switch (copy.source_item->item()->type()) { |
| 536 case DataElement::TYPE_BYTES: { |
| 537 DCHECK_EQ(dest_type, DataElement::TYPE_BYTES_DESCRIPTION); |
| 538 const char* src_data = |
| 539 copy.source_item->item()->bytes() + copy.source_item_offset; |
| 540 copy.dest_item->item()->item_->SetToBytes(src_data, dest_size); |
| 541 } break; |
| 542 case DataElement::TYPE_FILE: |
| 543 case DataElement::TYPE_UNKNOWN: |
| 544 case DataElement::TYPE_BLOB: |
| 545 case DataElement::TYPE_BYTES_DESCRIPTION: |
| 546 case DataElement::TYPE_FILE_FILESYSTEM: |
| 547 case DataElement::TYPE_DISK_CACHE_ENTRY: |
| 548 NOTREACHED(); |
| 549 break; |
| 550 } |
| 551 copy.dest_item->set_state(ShareableBlobDataItem::POPULATED_WITH_QUOTA); |
| 552 } |
| 553 entry->status_ = BlobStatus::DONE; |
| 554 } |
| 555 |
| 556 std::vector<BlobStatusCallback> callbacks; |
| 557 if (entry->building_state_.get()) { |
| 558 std::swap(callbacks, entry->building_state_->build_completion_callbacks); |
| 559 entry->building_state_.reset(); |
| 560 } |
| 561 |
| 562 memory_controller_.NotifyMemoryItemsUsed(entry->items()); |
| 563 |
| 564 auto runner = base::ThreadTaskRunnerHandle::Get(); |
| 565 for (const auto& callback : callbacks) |
| 566 runner->PostTask(FROM_HERE, base::Bind(callback, entry->status())); |
| 567 |
| 568 for (const auto& shareable_item : entry->items()) { |
| 569 DCHECK_NE(DataElement::TYPE_BYTES_DESCRIPTION, |
| 570 shareable_item->item()->type()); |
| 571 DCHECK(shareable_item->IsPopulated()) << shareable_item->state(); |
| 572 } |
| 573 } |
| 574 |
| 575 void BlobStorageContext::RequestTransport( |
| 576 BlobEntry* entry, |
| 577 std::vector<BlobMemoryController::FileCreationInfo> files) { |
| 578 BlobEntry::BuildingState* building_state = entry->building_state_.get(); |
| 579 if (building_state->transport_allowed_callback) { |
| 580 TransportAllowedCallback user_data_population_callback = |
| 581 building_state->transport_allowed_callback; |
| 582 building_state->transport_allowed_callback.Reset(); |
| 583 user_data_population_callback.Run(BlobStatus::PENDING_TRANSPORT, |
| 584 std::move(files)); |
| 585 return; |
| 586 } |
| 587 DCHECK(files.empty()); |
| 588 NotifyTransportComplete(entry); |
| 589 } |
| 590 |
| 591 void BlobStorageContext::OnEnoughSizeForMemory(const std::string& uuid, |
| 592 bool success) { |
| 593 if (!success) { |
| 594 CancelBuildingBlob(uuid, BlobStatus::ERR_OUT_OF_MEMORY); |
| 595 return; |
| 596 } |
| 597 BlobEntry* entry = registry_.GetEntry(uuid); |
| 598 if (!entry || !entry->building_state_.get()) |
| 599 return; |
| 600 BlobEntry::BuildingState& building_state = *entry->building_state_; |
| 601 DCHECK(!building_state.memory_quota_request); |
| 602 |
| 603 if (building_state.transport_items_present) { |
| 604 entry->status_ = BlobStatus::PENDING_TRANSPORT; |
| 605 RequestTransport(entry, |
| 606 std::vector<BlobMemoryController::FileCreationInfo>()); |
| 607 } else { |
| 608 entry->status_ = BlobStatus::PENDING_INTERNALS; |
| 609 } |
| 610 |
| 611 if (entry->CanFinishBuilding()) |
| 612 FinishBuilding(entry); |
| 613 } |
| 614 |
| 615 void BlobStorageContext::OnDependentBlobFinished( |
| 616 const std::string& owning_blob_uuid, |
| 617 BlobStatus status) { |
| 618 BlobEntry* entry = registry_.GetEntry(owning_blob_uuid); |
| 619 if (!entry || !entry->building_state_) |
| 620 return; |
| 621 |
| 622 if (BlobStatusIsError(status)) { |
| 623 DCHECK_NE(BlobStatus::ERR_BLOB_DEREFERENCED_WHILE_BUILDING, status) |
| 624 << "Referenced blob should never be dereferenced while we " |
| 625 << "are depending on it, as our system holds a handle."; |
| 626 CancelBuildingBlob(owning_blob_uuid, |
| 627 BlobStatus::ERR_REFERENCED_BLOB_BROKEN); |
| 628 return; |
| 629 } |
| 630 DCHECK_GT(entry->building_state_->num_building_dependent_blobs, 0u); |
| 631 --entry->building_state_->num_building_dependent_blobs; |
| 632 |
| 633 if (entry->CanFinishBuilding()) |
| 634 FinishBuilding(entry); |
| 635 } |
| 636 |
| 637 void BlobStorageContext::ClearAndFreeMemory(const std::string& uuid, |
| 638 BlobEntry* entry) { |
| 639 if (entry->building_state_) { |
| 640 BlobEntry::BuildingState* building_state = entry->building_state_.get(); |
| 641 if (building_state->memory_quota_request) { |
| 642 building_state->memory_quota_request->Cancel(); |
378 } | 643 } |
379 } | 644 } |
| 645 entry->RemoveBlobFromShareableItems(uuid); |
| 646 entry->items_.clear(); |
| 647 entry->offsets_.clear(); |
| 648 } |
380 | 649 |
381 for (; iter != items.end() && length > 0; ++iter) { | 650 void BlobStorageContext::SetItemStateToPopulated( |
382 scoped_refptr<ShareableBlobDataItem> shareable_item = iter->get(); | 651 std::vector<ShareableBlobDataItem*>* items) { |
383 const BlobDataItem& item = *(shareable_item->item()); | 652 for (ShareableBlobDataItem* shareable_item : *items) { |
384 uint64_t item_length = item.length(); | 653 DCHECK(shareable_item->state() == ShareableBlobDataItem::QUOTA_GRANTED); |
385 DCHECK_GT(item_length, offset); | 654 shareable_item->set_state(ShareableBlobDataItem::POPULATED_WITH_QUOTA); |
386 uint64_t current_length = item_length - offset; | |
387 uint64_t new_length = current_length > length ? length : current_length; | |
388 | |
389 bool reusing_blob_item = offset == 0 && new_length == item.length(); | |
390 UMA_HISTOGRAM_BOOLEAN("Storage.Blob.ReusedItem", reusing_blob_item); | |
391 if (reusing_blob_item) { | |
392 shareable_item->referencing_blobs_mutable()->insert(target_blob_uuid); | |
393 target_blob_builder->AppendSharedBlobItem(shareable_item); | |
394 length -= new_length; | |
395 continue; | |
396 } | |
397 | |
398 // We need to do copying of the items when we have a different offset or | |
399 // length | |
400 switch (item.type()) { | |
401 case DataElement::TYPE_BYTES: { | |
402 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.Bytes", | |
403 new_length / 1024); | |
404 if (memory_usage_ + new_length > kBlobStorageMaxMemoryUsage) { | |
405 return false; | |
406 } | |
407 DCHECK(!item.offset()); | |
408 std::unique_ptr<DataElement> element(new DataElement()); | |
409 element->SetToBytes(item.bytes() + offset, | |
410 static_cast<int64_t>(new_length)); | |
411 memory_usage_ += new_length; | |
412 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
413 target_blob_uuid, new BlobDataItem(std::move(element)), | |
414 ShareableBlobDataItem::POPULATED_WITH_QUOTA)); | |
415 } break; | |
416 case DataElement::TYPE_FILE: { | |
417 DCHECK_NE(item.length(), std::numeric_limits<uint64_t>::max()) | |
418 << "We cannot use a section of a file with an unknown length"; | |
419 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.File", | |
420 new_length / 1024); | |
421 std::unique_ptr<DataElement> element(new DataElement()); | |
422 element->SetToFilePathRange(item.path(), item.offset() + offset, | |
423 new_length, | |
424 item.expected_modification_time()); | |
425 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
426 target_blob_uuid, | |
427 new BlobDataItem(std::move(element), item.data_handle_), | |
428 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
429 } break; | |
430 case DataElement::TYPE_FILE_FILESYSTEM: { | |
431 UMA_HISTOGRAM_COUNTS("Storage.BlobItemSize.BlobSlice.FileSystem", | |
432 new_length / 1024); | |
433 std::unique_ptr<DataElement> element(new DataElement()); | |
434 element->SetToFileSystemUrlRange(item.filesystem_url(), | |
435 item.offset() + offset, new_length, | |
436 item.expected_modification_time()); | |
437 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
438 target_blob_uuid, new BlobDataItem(std::move(element)), | |
439 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
440 } break; | |
441 case DataElement::TYPE_DISK_CACHE_ENTRY: { | |
442 std::unique_ptr<DataElement> element(new DataElement()); | |
443 element->SetToDiskCacheEntryRange(item.offset() + offset, | |
444 new_length); | |
445 target_blob_builder->AppendSharedBlobItem(new ShareableBlobDataItem( | |
446 target_blob_uuid, | |
447 new BlobDataItem(std::move(element), item.data_handle_, | |
448 item.disk_cache_entry(), | |
449 item.disk_cache_stream_index(), | |
450 item.disk_cache_side_stream_index()), | |
451 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | |
452 } break; | |
453 case DataElement::TYPE_BYTES_DESCRIPTION: | |
454 case DataElement::TYPE_BLOB: | |
455 case DataElement::TYPE_UNKNOWN: | |
456 CHECK(false) << "Illegal blob item type: " << item.type(); | |
457 } | |
458 length -= new_length; | |
459 offset = 0; | |
460 } | 655 } |
461 return true; | |
462 } | 656 } |
463 | 657 |
464 } // namespace storage | 658 } // namespace storage |
OLD | NEW |