| 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 #ifndef STORAGE_BROWSER_BLOB_BLOB_ASYNC_TRANSPORT_REQUEST_BUILDER_H_ | |
| 6 #define STORAGE_BROWSER_BLOB_BLOB_ASYNC_TRANSPORT_REQUEST_BUILDER_H_ | |
| 7 | |
| 8 #include <stddef.h> | |
| 9 #include <stdint.h> | |
| 10 | |
| 11 #include <map> | |
| 12 #include <memory> | |
| 13 #include <vector> | |
| 14 | |
| 15 #include "base/macros.h" | |
| 16 #include "storage/browser/blob/blob_data_builder.h" | |
| 17 #include "storage/browser/storage_browser_export.h" | |
| 18 #include "storage/common/blob_storage/blob_item_bytes_request.h" | |
| 19 #include "storage/common/data_element.h" | |
| 20 | |
| 21 namespace storage { | |
| 22 | |
| 23 // This class generates the requests needed to asynchronously transport the | |
| 24 // given blob items from the renderer to the browser. The main job of this class | |
| 25 // is to segment the memory being transfered to efficiently use shared memory, | |
| 26 // file, and IPC max sizes. | |
| 27 // Note: This class does not compute requests by using the 'shortcut' method, | |
| 28 // where the data is already present in the blob description, and will | |
| 29 // always give the caller requests for requesting all data from the | |
| 30 // renderer. | |
| 31 class STORAGE_EXPORT BlobAsyncTransportRequestBuilder { | |
| 32 public: | |
| 33 struct RendererMemoryItemRequest { | |
| 34 RendererMemoryItemRequest(); | |
| 35 // This is the index of the item in the builder on the browser side. | |
| 36 size_t browser_item_index; | |
| 37 // Note: For files this offset should always be 0, as the file offset in | |
| 38 // segmentation is handled by the handle_offset in the message. This | |
| 39 // offset is used for populating a chunk when the data comes back to | |
| 40 // the browser. | |
| 41 size_t browser_item_offset; | |
| 42 BlobItemBytesRequest message; | |
| 43 }; | |
| 44 | |
| 45 BlobAsyncTransportRequestBuilder(); | |
| 46 virtual ~BlobAsyncTransportRequestBuilder(); | |
| 47 | |
| 48 // Initializes the request builder for file requests. One or more files are | |
| 49 // created to hold the given data. Each file can hold data from multiple | |
| 50 // items, and the data from each item can be in multiple files. | |
| 51 // See file_handle_sizes() for the generated file sizes. | |
| 52 // max_file_size: This is the maximum size for a file to back a blob. | |
| 53 // blob_total_size: This is the total in-memory size of the blob. | |
| 54 // elements: These are the descriptions of the blob items being sent from the | |
| 55 // renderer. | |
| 56 // builder: This is the builder that is populated with the 'future' versions | |
| 57 // of the data elements. In this case, we call 'AppendFutureData' in | |
| 58 // the items that we expect to be backed by files writen by the | |
| 59 // renderer. | |
| 60 void InitializeForFileRequests(size_t max_file_size, | |
| 61 uint64_t blob_total_size, | |
| 62 const std::vector<DataElement>& elements, | |
| 63 BlobDataBuilder* builder); | |
| 64 | |
| 65 // Initializes the request builder for shared memory requests. We try to | |
| 66 // consolidate as much memory as possible in each shared memory segment we | |
| 67 // use. | |
| 68 // See shared_memory_handle_sizes() for the shared memory sizes. | |
| 69 // max_shared_memory_size: This is the maximum size for a shared memory | |
| 70 // segment used to transport the data between renderer | |
| 71 // and browser. | |
| 72 // blob_total_size: This is the total in-memory size of the blob. | |
| 73 // elements: These are the descriptions of the blob items being sent from the | |
| 74 // renderer. | |
| 75 // builder: This is the builder that is populated with the 'future' versions | |
| 76 // of the data elements. In this case, we call 'AppendFutureData' for | |
| 77 // the items we expect to be populated later. | |
| 78 void InitializeForSharedMemoryRequests( | |
| 79 size_t max_shared_memory_size, | |
| 80 uint64_t blob_total_size, | |
| 81 const std::vector<DataElement>& elements, | |
| 82 BlobDataBuilder* builder); | |
| 83 | |
| 84 // Initializes the request builder for IPC requests. We put as much memory | |
| 85 // in a single IPC request as possible. | |
| 86 // max_ipc_memory_size: This is the maximum size for an IPC message which will | |
| 87 // be used to transport memory from the renderer to the | |
| 88 // browser. | |
| 89 // blob_total_size: This is the total in-memory size of the blob. | |
| 90 // elements: These are the descriptions of the blob items being sent from the | |
| 91 // renderer. | |
| 92 // builder: This is the builder that is populated with the 'future' versions | |
| 93 // of the data elements. In this case, we call 'AppendFutureData' for | |
| 94 // the items we expect to be populated later. | |
| 95 void InitializeForIPCRequests(size_t max_ipc_memory_size, | |
| 96 uint64_t blob_total_size, | |
| 97 const std::vector<DataElement>& elements, | |
| 98 BlobDataBuilder* builder); | |
| 99 | |
| 100 // The sizes of the shared memory handles being used (by handle index). | |
| 101 const std::vector<size_t>& shared_memory_sizes() const { | |
| 102 return shared_memory_sizes_; | |
| 103 } | |
| 104 | |
| 105 // The sizes of the file handles being used (by handle index). | |
| 106 const std::vector<size_t>& file_sizes() const { return file_sizes_; } | |
| 107 | |
| 108 // The requests for memory, segmented as described above, along with their | |
| 109 // destination browser indexes and offsets. | |
| 110 const std::vector<RendererMemoryItemRequest>& requests() const { | |
| 111 return requests_; | |
| 112 } | |
| 113 | |
| 114 // The total bytes size of memory items in the blob. | |
| 115 uint64_t total_bytes_size() const { return total_bytes_size_; } | |
| 116 | |
| 117 static bool ShouldBeShortcut(const std::vector<DataElement>& items, | |
| 118 size_t memory_available); | |
| 119 | |
| 120 private: | |
| 121 static void ComputeHandleSizes(uint64_t total_memory_size, | |
| 122 size_t max_segment_size, | |
| 123 std::vector<size_t>* segment_sizes); | |
| 124 | |
| 125 std::vector<size_t> shared_memory_sizes_; | |
| 126 // The size of the files is capped by the |max_file_size| argument in | |
| 127 // InitializeForFileRequests, so we can just use size_t. | |
| 128 std::vector<size_t> file_sizes_; | |
| 129 | |
| 130 uint64_t total_bytes_size_; | |
| 131 std::vector<RendererMemoryItemRequest> requests_; | |
| 132 | |
| 133 DISALLOW_COPY_AND_ASSIGN(BlobAsyncTransportRequestBuilder); | |
| 134 }; | |
| 135 | |
| 136 } // namespace storage | |
| 137 | |
| 138 #endif // STORAGE_BROWSER_BLOB_BLOB_ASYNC_TRANSPORT_REQUEST_BUILDER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2448353002:
[BlobAsync] Moving async handling into BlobStorageContext & quota out. (Closed)
