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 |