| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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 <stddef.h> | |
| 6 #include <stdint.h> | |
| 7 | |
| 8 #include <algorithm> | |
| 9 | |
| 10 #include "base/numerics/safe_math.h" | |
| 11 #include "storage/browser/blob/blob_async_transport_strategy.h" | |
| 12 #include "storage/common/blob_storage/blob_storage_constants.h" | |
| 13 | |
| 14 namespace storage { | |
| 15 namespace { | |
| 16 bool IsBytes(DataElement::Type type) { | |
| 17 return type == DataElement::TYPE_BYTES || | |
| 18 type == DataElement::TYPE_BYTES_DESCRIPTION; | |
| 19 } | |
| 20 | |
| 21 // This is the general template that each strategy below implements. See the | |
| 22 // ForEachWithSegment method for a description of how these are called. | |
| 23 // class BlobSegmentVisitor { | |
| 24 // public: | |
| 25 // typedef ___ SizeType; | |
| 26 // void VisitBytesSegment(size_t element_index, uint64_t element_offset, | |
| 27 // size_t segment_index, uint64_t segment_offset, | |
| 28 // uint64_t size); | |
| 29 // void VisitNonBytesSegment(const DataElement& element, size_t element_idx); | |
| 30 // void Done(); | |
| 31 // }; | |
| 32 | |
| 33 // This class handles the logic of how transported memory is going to be | |
| 34 // represented as storage in the browser. The main idea is that all the memory | |
| 35 // is now packed into file chunks, and the browser items will just reference | |
| 36 // the file with offsets and sizes. | |
| 37 class FileStorageStrategy { | |
| 38 public: | |
| 39 FileStorageStrategy( | |
| 40 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* | |
| 41 requests, | |
| 42 BlobDataBuilder* builder) | |
| 43 : requests(requests), builder(builder), current_item_index(0) {} | |
| 44 | |
| 45 ~FileStorageStrategy() {} | |
| 46 | |
| 47 void VisitBytesSegment(size_t element_index, | |
| 48 uint64_t element_offset, | |
| 49 size_t segment_index, | |
| 50 uint64_t segment_offset, | |
| 51 uint64_t size) { | |
| 52 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
| 53 request.browser_item_index = current_item_index; | |
| 54 request.browser_item_offset = 0; | |
| 55 request.message.request_number = requests->size(); | |
| 56 request.message.transport_strategy = IPCBlobItemRequestStrategy::FILE; | |
| 57 request.message.renderer_item_index = element_index; | |
| 58 request.message.renderer_item_offset = element_offset; | |
| 59 request.message.size = size; | |
| 60 request.message.handle_index = segment_index; | |
| 61 request.message.handle_offset = segment_offset; | |
| 62 | |
| 63 requests->push_back(request); | |
| 64 builder->AppendFutureFile(segment_offset, size); | |
| 65 current_item_index++; | |
| 66 } | |
| 67 | |
| 68 void VisitNonBytesSegment(const DataElement& element, size_t element_index) { | |
| 69 builder->AppendIPCDataElement(element); | |
| 70 current_item_index++; | |
| 71 } | |
| 72 | |
| 73 void Done() {} | |
| 74 | |
| 75 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests; | |
| 76 BlobDataBuilder* builder; | |
| 77 | |
| 78 size_t current_item_index; | |
| 79 }; | |
| 80 | |
| 81 // This class handles the logic of storing memory that is transported as | |
| 82 // consolidated shared memory. | |
| 83 class SharedMemoryStorageStrategy { | |
| 84 public: | |
| 85 SharedMemoryStorageStrategy( | |
| 86 size_t max_segment_size, | |
| 87 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* | |
| 88 requests, | |
| 89 BlobDataBuilder* builder) | |
| 90 : requests(requests), | |
| 91 max_segment_size(max_segment_size), | |
| 92 builder(builder), | |
| 93 current_item_size(0), | |
| 94 current_item_index(0) {} | |
| 95 ~SharedMemoryStorageStrategy() {} | |
| 96 | |
| 97 void VisitBytesSegment(size_t element_index, | |
| 98 uint64_t element_offset, | |
| 99 size_t segment_index, | |
| 100 uint64_t segment_offset, | |
| 101 uint64_t size) { | |
| 102 if (current_item_size + size > max_segment_size) { | |
| 103 builder->AppendFutureData(current_item_size); | |
| 104 current_item_index++; | |
| 105 current_item_size = 0; | |
| 106 } | |
| 107 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
| 108 request.browser_item_index = current_item_index; | |
| 109 request.browser_item_offset = current_item_size; | |
| 110 request.message.request_number = requests->size(); | |
| 111 request.message.transport_strategy = | |
| 112 IPCBlobItemRequestStrategy::SHARED_MEMORY; | |
| 113 request.message.renderer_item_index = element_index; | |
| 114 request.message.renderer_item_offset = element_offset; | |
| 115 request.message.size = size; | |
| 116 request.message.handle_index = segment_index; | |
| 117 request.message.handle_offset = segment_offset; | |
| 118 | |
| 119 requests->push_back(request); | |
| 120 current_item_size += size; | |
| 121 } | |
| 122 | |
| 123 void VisitNonBytesSegment(const DataElement& element, size_t element_index) { | |
| 124 if (current_item_size != 0) { | |
| 125 builder->AppendFutureData(current_item_size); | |
| 126 current_item_index++; | |
| 127 } | |
| 128 builder->AppendIPCDataElement(element); | |
| 129 current_item_index++; | |
| 130 current_item_size = 0; | |
| 131 } | |
| 132 | |
| 133 void Done() { | |
| 134 if (current_item_size != 0) { | |
| 135 builder->AppendFutureData(current_item_size); | |
| 136 } | |
| 137 } | |
| 138 | |
| 139 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests; | |
| 140 | |
| 141 size_t max_segment_size; | |
| 142 BlobDataBuilder* builder; | |
| 143 size_t current_item_size; | |
| 144 uint64_t current_item_index; | |
| 145 }; | |
| 146 | |
| 147 // This iterates of the data elements and segments the 'bytes' data into | |
| 148 // the smallest number of segments given the max_segment_size. | |
| 149 // The callback describes either: | |
| 150 // * A non-memory item | |
| 151 // * A partition of a bytes element which will be populated into a given | |
| 152 // segment and segment offset. | |
| 153 // More specifically, we split each |element| into one or more |segments| of a | |
| 154 // max_size, invokes the strategy to determine the request to make for each | |
| 155 // |segment| produced. A |segment| can also span multiple |elements|. | |
| 156 // Assumptions: All memory items are consolidated. As in, there are no two | |
| 157 // 'bytes' items next to eachother. | |
| 158 template <typename Visitor> | |
| 159 void ForEachWithSegment(const std::vector<DataElement>& elements, | |
| 160 uint64_t max_segment_size, | |
| 161 Visitor* visitor) { | |
| 162 DCHECK_GT(max_segment_size, 0ull); | |
| 163 size_t segment_index = 0; | |
| 164 uint64_t segment_offset = 0; | |
| 165 size_t elements_length = elements.size(); | |
| 166 for (size_t element_index = 0; element_index < elements_length; | |
| 167 ++element_index) { | |
| 168 const auto& element = elements.at(element_index); | |
| 169 DataElement::Type type = element.type(); | |
| 170 if (!IsBytes(type)) { | |
| 171 visitor->VisitNonBytesSegment(element, element_index); | |
| 172 continue; | |
| 173 } | |
| 174 uint64_t element_memory_left = element.length(); | |
| 175 uint64_t element_offset = 0; | |
| 176 while (element_memory_left > 0) { | |
| 177 if (segment_offset == max_segment_size) { | |
| 178 ++segment_index; | |
| 179 segment_offset = 0; | |
| 180 } | |
| 181 uint64_t memory_writing = | |
| 182 std::min(max_segment_size - segment_offset, element_memory_left); | |
| 183 visitor->VisitBytesSegment(element_index, element_offset, segment_index, | |
| 184 segment_offset, memory_writing); | |
| 185 element_memory_left -= memory_writing; | |
| 186 segment_offset += memory_writing; | |
| 187 element_offset += memory_writing; | |
| 188 } | |
| 189 } | |
| 190 visitor->Done(); | |
| 191 } | |
| 192 } // namespace | |
| 193 | |
| 194 BlobAsyncTransportStrategy::RendererMemoryItemRequest:: | |
| 195 RendererMemoryItemRequest() | |
| 196 : browser_item_index(0), browser_item_offset(0), received(false) {} | |
| 197 | |
| 198 BlobAsyncTransportStrategy::BlobAsyncTransportStrategy() | |
| 199 : error_(BlobAsyncTransportStrategy::ERROR_NONE), total_bytes_size_(0) {} | |
| 200 | |
| 201 BlobAsyncTransportStrategy::~BlobAsyncTransportStrategy() {} | |
| 202 | |
| 203 // if total_blob_size > |memory_available| (say 400MB) | |
| 204 // Request all data in files | |
| 205 // (Segment all of the existing data into | |
| 206 // file blocks, of <= |max_file_size|) | |
| 207 // else if total_blob_size > |max_ipc_memory_size| (say 150KB) | |
| 208 // Request all data in shared memory | |
| 209 // (Segment all of the existing data into | |
| 210 // shared memory blocks, of <= |max_shared_memory_size|) | |
| 211 // else | |
| 212 // Request all data to be sent over IPC | |
| 213 void BlobAsyncTransportStrategy::Initialize( | |
| 214 size_t max_ipc_memory_size, | |
| 215 size_t max_shared_memory_size, | |
| 216 size_t max_file_size, | |
| 217 uint64_t disk_space_left, | |
| 218 size_t memory_available, | |
| 219 const std::string& uuid, | |
| 220 const std::vector<DataElement>& blob_item_infos) { | |
| 221 DCHECK(handle_sizes_.empty()); | |
| 222 DCHECK(requests_.empty()); | |
| 223 DCHECK(!builder_.get()); | |
| 224 builder_.reset(new BlobDataBuilder(uuid)); | |
| 225 error_ = BlobAsyncTransportStrategy::ERROR_NONE; | |
| 226 | |
| 227 size_t memory_items = 0; | |
| 228 base::CheckedNumeric<uint64_t> total_size_checked = 0; | |
| 229 for (const auto& info : blob_item_infos) { | |
| 230 if (!IsBytes(info.type())) { | |
| 231 continue; | |
| 232 } | |
| 233 total_size_checked += info.length(); | |
| 234 ++memory_items; | |
| 235 } | |
| 236 | |
| 237 if (!total_size_checked.IsValid()) { | |
| 238 DVLOG(1) << "Impossible total size of all memory elements."; | |
| 239 error_ = BlobAsyncTransportStrategy::ERROR_INVALID_PARAMS; | |
| 240 return; | |
| 241 } | |
| 242 | |
| 243 total_bytes_size_ = total_size_checked.ValueOrDie(); | |
| 244 | |
| 245 // See if we have enough memory. | |
| 246 if (total_bytes_size_ > | |
| 247 disk_space_left + static_cast<uint64_t>(memory_available)) { | |
| 248 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
| 249 return; | |
| 250 } | |
| 251 | |
| 252 // If we're more than the available memory, then we're going straight to disk. | |
| 253 if (total_bytes_size_ > memory_available) { | |
| 254 if (total_bytes_size_ > disk_space_left) { | |
| 255 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
| 256 return; | |
| 257 } | |
| 258 ComputeHandleSizes(total_bytes_size_, max_file_size, &handle_sizes_); | |
| 259 FileStorageStrategy strategy(&requests_, builder_.get()); | |
| 260 ForEachWithSegment(blob_item_infos, static_cast<uint64_t>(max_file_size), | |
| 261 &strategy); | |
| 262 return; | |
| 263 } | |
| 264 | |
| 265 if (total_bytes_size_ > max_ipc_memory_size) { | |
| 266 // Note: The size must be <= std::numeric_limits<size_t>::max(). Otherwise | |
| 267 // we are guarenteed to be caught by the if statement above, | |
| 268 // |total_bytes_size_ > memory_available|. | |
| 269 ComputeHandleSizes(total_bytes_size_, max_shared_memory_size, | |
| 270 &handle_sizes_); | |
| 271 SharedMemoryStorageStrategy strategy(max_shared_memory_size, &requests_, | |
| 272 builder_.get()); | |
| 273 ForEachWithSegment(blob_item_infos, | |
| 274 static_cast<uint64_t>(max_shared_memory_size), | |
| 275 &strategy); | |
| 276 return; | |
| 277 } | |
| 278 | |
| 279 // Since they can all fit in IPC memory, we don't need to segment anything, | |
| 280 // and just request them straight in IPC. | |
| 281 size_t items_length = blob_item_infos.size(); | |
| 282 for (size_t i = 0; i < items_length; i++) { | |
| 283 const auto& info = blob_item_infos.at(i); | |
| 284 if (!IsBytes(info.type())) { | |
| 285 builder_->AppendIPCDataElement(info); | |
| 286 continue; | |
| 287 } | |
| 288 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
| 289 request.browser_item_index = i; | |
| 290 request.browser_item_offset = 0; | |
| 291 request.message.request_number = requests_.size(); | |
| 292 request.message.transport_strategy = IPCBlobItemRequestStrategy::IPC; | |
| 293 request.message.renderer_item_index = i; | |
| 294 request.message.renderer_item_offset = 0; | |
| 295 request.message.size = info.length(); | |
| 296 requests_.push_back(request); | |
| 297 builder_->AppendFutureData(info.length()); | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 /* static */ | |
| 302 bool BlobAsyncTransportStrategy::ShouldBeShortcut( | |
| 303 const std::vector<DataElement>& elements, | |
| 304 size_t memory_available) { | |
| 305 base::CheckedNumeric<size_t> shortcut_bytes = 0; | |
| 306 for (const auto& element : elements) { | |
| 307 DataElement::Type type = element.type(); | |
| 308 if (type == DataElement::TYPE_BYTES_DESCRIPTION) { | |
| 309 return false; | |
| 310 } | |
| 311 if (type == DataElement::TYPE_BYTES) { | |
| 312 shortcut_bytes += element.length(); | |
| 313 if (!shortcut_bytes.IsValid()) { | |
| 314 return false; | |
| 315 } | |
| 316 } | |
| 317 } | |
| 318 return shortcut_bytes.ValueOrDie() <= memory_available; | |
| 319 } | |
| 320 | |
| 321 /* static */ | |
| 322 void BlobAsyncTransportStrategy::ComputeHandleSizes( | |
| 323 uint64_t total_memory_size, | |
| 324 size_t max_segment_size, | |
| 325 std::vector<size_t>* segment_sizes) { | |
| 326 size_t total_max_segments = | |
| 327 static_cast<size_t>(total_memory_size / max_segment_size); | |
| 328 bool has_extra_segment = (total_memory_size % max_segment_size) > 0; | |
| 329 segment_sizes->reserve(total_max_segments + (has_extra_segment ? 1 : 0)); | |
| 330 segment_sizes->insert(segment_sizes->begin(), total_max_segments, | |
| 331 max_segment_size); | |
| 332 if (has_extra_segment) { | |
| 333 segment_sizes->push_back(total_memory_size % max_segment_size); | |
| 334 } | |
| 335 } | |
| 336 | |
| 337 } // namespace storage | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1234813004:
[BlobAsync] Asynchronous Blob Construction Final Patch (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@blob-protocol-change