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