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