OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "storage/browser/blob/blob_slice.h" | |
6 | |
7 #include <algorithm> | |
8 | |
9 #include "storage/browser/blob/blob_data_item.h" | |
10 #include "storage/browser/blob/blob_storage_context.h" | |
11 #include "storage/browser/blob/shareable_blob_data_item.h" | |
12 | |
13 namespace storage { | |
14 | |
15 BlobSlice::BlobSlice(const InternalBlobData& source, | |
16 uint64_t slice_offset, | |
17 uint64_t slice_size) { | |
18 const auto& source_items = source.items(); | |
19 const auto& offsets = source.offsets(); | |
20 DCHECK_LE(slice_offset + slice_size, source.total_size()); | |
21 size_t item_index = | |
22 std::upper_bound(offsets.begin(), offsets.end(), slice_offset) - | |
23 offsets.begin(); | |
24 uint64_t item_offset = | |
25 item_index == 0 ? slice_offset : slice_offset - offsets[item_index - 1]; | |
26 size_t num_items = source_items.size(); | |
27 | |
28 LOG(ERROR) << "doing a slice at " << slice_offset << " with size " | |
29 << slice_size; | |
30 size_t first_item_index = item_index; | |
31 copying_memory_size = 0; | |
32 | |
33 bool first_item = true; | |
michaeln
2016/07/14 01:44:43
probably don't need this local, could item_index =
dmurph
2016/07/15 20:18:15
Done.
| |
34 bool last_item_memory_sliced = false; | |
35 // Read starting from 'mid' and 'offset_from_mid'. | |
michaeln
2016/07/14 01:44:43
comment is stale
dmurph
2016/07/15 20:18:15
Done.
| |
36 for (uint64_t total_sliced = 0; | |
37 item_index < num_items && total_sliced < slice_size; item_index++) { | |
38 const scoped_refptr<BlobDataItem>& item = source_items[item_index]->item(); | |
michaeln
2016/07/14 01:44:43
might call this source_item for clarity
dmurph
2016/07/15 20:18:15
Done.
| |
39 uint64_t length = item->length(); | |
michaeln
2016/07/14 01:44:43
probably dont need this local
(the value is not us
dmurph
2016/07/15 20:18:15
Replaced callsites, I like the local.
| |
40 DCHECK_NE(length, std::numeric_limits<uint64_t>::max()); | |
41 DCHECK_NE(length, 0ull); | |
42 | |
43 last_item_memory_sliced = false; | |
44 | |
45 if (item_offset == 0 && slice_size - total_sliced >= item->length()) { | |
46 // We can share the entire item. | |
47 LOG(ERROR) << "we can share"; | |
48 dest_items.push_back(source_items[item_index]); | |
49 total_sliced += length; | |
50 first_item = false; | |
51 continue; | |
52 } | |
53 | |
54 uint64_t read_size = | |
55 std::min(item->length() - item_offset, slice_size - total_sliced); | |
56 total_sliced += read_size; | |
michaeln
2016/07/14 01:44:43
might help readability to move the read_size compu
dmurph
2016/07/15 20:18:15
Done.
| |
57 | |
58 scoped_refptr<BlobDataItem> data_item; | |
59 switch (item->type()) { | |
60 case DataElement::TYPE_BYTES_DESCRIPTION: | |
61 case DataElement::TYPE_BYTES: { | |
62 if (first_item) { | |
63 has_sliced_first_memory_item = true; | |
64 first_item_slice_offset = item_offset; | |
65 first_source_item = source_items[first_item_index]; | |
66 } | |
michaeln
2016/07/14 01:44:43
i think the handling of the last partial item mayb
dmurph
2016/07/15 20:18:15
Ah, much better.
| |
67 LOG(ERROR) << "we're sliceing a bytes item!"; | |
68 last_item_memory_sliced = true; | |
69 copying_memory_size += read_size; | |
70 // Since we don't have quota yet for memory, we create temporary items | |
71 // for this data. When our blob is finished constructing, all dependent | |
72 // blobs are done, and we have enough memory quota, we'll copy the data | |
73 // over. | |
74 std::unique_ptr<DataElement> element(new DataElement()); | |
75 element->SetToBytesDescription(base::checked_cast<size_t>(read_size)); | |
76 data_item = new BlobDataItem(std::move(element), nullptr); | |
77 } break; | |
78 case DataElement::TYPE_FILE: { | |
79 std::unique_ptr<DataElement> element(new DataElement()); | |
80 element->SetToFilePathRange(item->path(), item->offset() + item_offset, | |
81 read_size, | |
82 item->expected_modification_time()); | |
83 data_item = new BlobDataItem(std::move(element), item->data_handle_); | |
84 } break; | |
85 case DataElement::TYPE_FILE_FILESYSTEM: { | |
86 std::unique_ptr<DataElement> element(new DataElement()); | |
87 element->SetToFileSystemUrlRange( | |
88 item->filesystem_url(), item->offset() + item_offset, read_size, | |
89 item->expected_modification_time()); | |
90 data_item = new BlobDataItem(std::move(element), nullptr); | |
91 } break; | |
92 case DataElement::TYPE_DISK_CACHE_ENTRY: { | |
93 std::unique_ptr<DataElement> element(new DataElement()); | |
94 element->SetToDiskCacheEntryRange(item->offset() + item_offset, | |
95 read_size); | |
96 data_item = new BlobDataItem(std::move(element), item->data_handle_, | |
97 item->disk_cache_entry(), | |
98 item->disk_cache_stream_index(), | |
99 item->disk_cache_side_stream_index()); | |
100 } break; | |
101 case DataElement::TYPE_BLOB: | |
102 case DataElement::TYPE_UNKNOWN: | |
103 CHECK(false) << "Illegal blob item type: " << item->type(); | |
104 } | |
105 dest_items.push_back(new ShareableBlobDataItem(std::move(data_item))); | |
106 first_item = false; | |
107 item_offset = 0; | |
108 } | |
109 if (last_item_memory_sliced && | |
110 !(has_sliced_first_memory_item && dest_items.size() == 1)) { | |
111 has_sliced_last_memory_item = true; | |
112 last_source_item = source_items[item_index - 1]; | |
113 } | |
114 } | |
115 | |
116 BlobSlice::~BlobSlice() {} | |
117 | |
118 } // namespace storage | |
OLD | NEW |