OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "storage/browser/blob/blob_async_builder_host.h" | 5 #include "storage/browser/blob/blob_async_builder_host.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <memory> | 10 #include <memory> |
11 #include <utility> | 11 #include <utility> |
12 | 12 |
13 #include "base/bind.h" | 13 #include "base/bind.h" |
14 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
15 #include "base/memory/shared_memory.h" | 15 #include "base/memory/shared_memory.h" |
16 #include "storage/browser/blob/blob_data_handle.h" | 16 #include "storage/browser/blob/blob_data_handle.h" |
17 #include "storage/browser/blob/blob_memory_controller.h" | |
17 #include "storage/browser/blob/blob_storage_context.h" | 18 #include "storage/browser/blob/blob_storage_context.h" |
18 | 19 |
19 namespace storage { | 20 namespace storage { |
20 namespace { | 21 using MemoryStrategyResult = BlobMemoryController::MemoryStrategyResult; |
21 | |
22 bool CalculateBlobMemorySize(const std::vector<DataElement>& elements, | |
23 size_t* shortcut_bytes, | |
24 uint64_t* total_bytes) { | |
25 DCHECK(shortcut_bytes); | |
26 DCHECK(total_bytes); | |
27 base::CheckedNumeric<uint64_t> total_size_checked = 0; | |
28 base::CheckedNumeric<size_t> shortcut_size_checked = 0; | |
29 for (const auto& e : elements) { | |
30 if (e.type() == DataElement::TYPE_BYTES) { | |
31 total_size_checked += e.length(); | |
32 shortcut_size_checked += e.length(); | |
33 } else if (e.type() == DataElement::TYPE_BYTES_DESCRIPTION) { | |
34 total_size_checked += e.length(); | |
35 } else { | |
36 continue; | |
37 } | |
38 if (!total_size_checked.IsValid() || !shortcut_size_checked.IsValid()) { | |
39 return false; | |
40 } | |
41 } | |
42 *shortcut_bytes = shortcut_size_checked.ValueOrDie(); | |
43 *total_bytes = total_size_checked.ValueOrDie(); | |
44 return true; | |
45 } | |
46 | |
47 IPCBlobCreationCancelCode ConvertReferencedBlobErrorToConstructingError( | |
48 IPCBlobCreationCancelCode referenced_blob_error) { | |
49 switch (referenced_blob_error) { | |
50 // For most cases we propagate the error. | |
51 case IPCBlobCreationCancelCode::FILE_WRITE_FAILED: | |
52 case IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT: | |
53 case IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN: | |
54 case IPCBlobCreationCancelCode::OUT_OF_MEMORY: | |
55 return referenced_blob_error; | |
56 // Others we report that the referenced blob is broken, as we don't know | |
57 // why (the BLOB_DEREFERENCED_WHILE_BUILDING should never happen, as we hold | |
58 // onto the reference of the blobs we're using). | |
59 case IPCBlobCreationCancelCode::BLOB_DEREFERENCED_WHILE_BUILDING: | |
60 DCHECK(false) << "Referenced blob should never be dereferenced while we " | |
61 << "are depending on it, as our system holds a handle."; | |
62 case IPCBlobCreationCancelCode::UNKNOWN: | |
63 return IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN; | |
64 } | |
65 NOTREACHED(); | |
66 return IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN; | |
67 } | |
68 | |
69 } // namespace | |
70 | |
71 using MemoryItemRequest = | 22 using MemoryItemRequest = |
72 BlobAsyncTransportRequestBuilder::RendererMemoryItemRequest; | 23 BlobAsyncTransportRequestBuilder::RendererMemoryItemRequest; |
73 | 24 |
74 BlobAsyncBuilderHost::BlobBuildingState::BlobBuildingState( | 25 BlobAsyncBuilderHost::BlobBuildingState::BlobBuildingState( |
75 const std::string& uuid, | 26 const std::string& uuid) |
76 std::set<std::string> referenced_blob_uuids, | 27 : data_builder(uuid) {} |
77 std::vector<std::unique_ptr<BlobDataHandle>>* referenced_blob_handles) | |
78 : data_builder(uuid), | |
79 referenced_blob_uuids(referenced_blob_uuids), | |
80 referenced_blob_handles(std::move(*referenced_blob_handles)) {} | |
81 | 28 |
82 BlobAsyncBuilderHost::BlobBuildingState::~BlobBuildingState() {} | 29 BlobAsyncBuilderHost::BlobBuildingState::~BlobBuildingState() {} |
83 | 30 |
84 BlobAsyncBuilderHost::BlobAsyncBuilderHost() : ptr_factory_(this) {} | 31 BlobAsyncBuilderHost::BlobAsyncBuilderHost() : ptr_factory_(this) {} |
85 | 32 |
86 BlobAsyncBuilderHost::~BlobAsyncBuilderHost() {} | 33 BlobAsyncBuilderHost::~BlobAsyncBuilderHost() {} |
87 | 34 |
88 BlobTransportResult BlobAsyncBuilderHost::RegisterBlobUUID( | 35 BlobStatus BlobAsyncBuilderHost::RegisterBlob( |
89 const std::string& uuid, | 36 const std::string& uuid, |
90 const std::string& content_type, | 37 const std::string& content_type, |
91 const std::string& content_disposition, | 38 const std::string& content_disposition, |
92 const std::set<std::string>& referenced_blob_uuids, | |
93 BlobStorageContext* context) { | |
94 if (async_blob_map_.find(uuid) != async_blob_map_.end()) | |
95 return BlobTransportResult::BAD_IPC; | |
96 if (referenced_blob_uuids.find(uuid) != referenced_blob_uuids.end()) | |
97 return BlobTransportResult::BAD_IPC; | |
98 context->CreatePendingBlob(uuid, content_type, content_disposition); | |
99 std::vector<std::unique_ptr<BlobDataHandle>> handles; | |
100 for (const std::string& referenced_uuid : referenced_blob_uuids) { | |
101 std::unique_ptr<BlobDataHandle> handle = | |
102 context->GetBlobDataFromUUID(referenced_uuid); | |
103 if (!handle || handle->IsBroken()) { | |
104 // We cancel the blob right away, and don't bother storing our state. | |
105 context->CancelPendingBlob( | |
106 uuid, IPCBlobCreationCancelCode::REFERENCED_BLOB_BROKEN); | |
107 return BlobTransportResult::CANCEL_REFERENCED_BLOB_BROKEN; | |
108 } | |
109 handles.emplace_back(std::move(handle)); | |
110 } | |
111 async_blob_map_[uuid] = base::WrapUnique( | |
112 new BlobBuildingState(uuid, referenced_blob_uuids, &handles)); | |
113 return BlobTransportResult::DONE; | |
114 } | |
115 | |
116 BlobTransportResult BlobAsyncBuilderHost::StartBuildingBlob( | |
117 const std::string& uuid, | |
118 const std::vector<DataElement>& elements, | 39 const std::vector<DataElement>& elements, |
119 size_t memory_available, | |
120 BlobStorageContext* context, | 40 BlobStorageContext* context, |
121 const RequestMemoryCallback& request_memory) { | 41 const RequestMemoryCallback& request_memory, |
42 const BlobStatusCallback& status_callback) { | |
122 DCHECK(context); | 43 DCHECK(context); |
123 DCHECK(async_blob_map_.find(uuid) != async_blob_map_.end()); | 44 if (async_blob_map_.find(uuid) != async_blob_map_.end()) { |
124 | 45 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; |
125 // Step 1: Get the sizes. | |
126 size_t shortcut_memory_size_bytes = 0; | |
127 uint64_t total_memory_size_bytes = 0; | |
128 if (!CalculateBlobMemorySize(elements, &shortcut_memory_size_bytes, | |
129 &total_memory_size_bytes)) { | |
130 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | |
131 return BlobTransportResult::BAD_IPC; | |
132 } | 46 } |
133 | 47 |
134 // Step 2: Check if we have enough memory to store the blob. | 48 uint64_t transport_memory_size = 0; |
135 if (total_memory_size_bytes > memory_available) { | 49 MemoryStrategyResult memory_strategy; |
136 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::OUT_OF_MEMORY, context); | 50 if (!context->memory_controller_.DecideBlobTransportationMemoryStrategy( |
137 return BlobTransportResult::CANCEL_MEMORY_FULL; | 51 elements, &transport_memory_size, &memory_strategy)) { |
52 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
138 } | 53 } |
139 | 54 |
140 // From here on, we know we can fit the blob in memory. | 55 // Validate that our referenced blobs aren't us. |
141 BlobBuildingState* state_ptr = async_blob_map_[uuid].get(); | |
142 if (!state_ptr->request_builder.requests().empty()) { | |
143 // Check that we're not a duplicate call. | |
144 return BlobTransportResult::BAD_IPC; | |
145 } | |
146 state_ptr->request_memory_callback = request_memory; | |
147 | |
148 // Step 3: Check to make sure the referenced blob information we received | |
149 // earlier is correct: | |
150 std::set<std::string> extracted_blob_uuids; | |
151 for (const DataElement& e : elements) { | 56 for (const DataElement& e : elements) { |
152 if (e.type() == DataElement::TYPE_BLOB) { | 57 if (e.type() == DataElement::TYPE_BLOB) { |
153 extracted_blob_uuids.insert(e.blob_uuid()); | |
154 // We can't depend on ourselves. | |
155 if (e.blob_uuid() == uuid) { | 58 if (e.blob_uuid() == uuid) { |
156 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | 59 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; |
157 return BlobTransportResult::BAD_IPC; | |
158 } | 60 } |
159 } | 61 } |
160 } | 62 } |
161 if (extracted_blob_uuids != state_ptr->referenced_blob_uuids) { | 63 |
162 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | 64 const BlobMemoryController& memory_controller = context->memory_controller(); |
kinuko
2016/07/17 16:15:46
nit: why don't we do this at the beginning of this
dmurph
2016/07/19 02:26:27
Done.
| |
163 return BlobTransportResult::BAD_IPC; | 65 std::unique_ptr<BlobBuildingState> state(new BlobBuildingState(uuid)); |
66 state->data_builder.set_content_type(content_type); | |
67 state->data_builder.set_content_disposition(content_disposition); | |
68 state->request_memory_callback = request_memory; | |
69 | |
70 std::unique_ptr<BlobDataHandle> temp_handle; | |
71 | |
72 switch (memory_strategy) { | |
73 case MemoryStrategyResult::TOO_LARGE: | |
74 temp_handle = context->AddBrokenBlob( | |
75 uuid, content_type, content_disposition, BlobStatus::OUT_OF_MEMORY); | |
76 context->IncrementBlobRefCount(uuid); | |
77 return BlobStatus::OUT_OF_MEMORY; | |
78 case MemoryStrategyResult::NONE_NEEDED: { | |
79 for (const DataElement& e : elements) { | |
80 DCHECK_NE(e.type(), DataElement::TYPE_BYTES_DESCRIPTION); | |
81 state->data_builder.AppendIPCDataElement(e); | |
82 } | |
83 temp_handle = | |
84 context->BuildBlob(state->data_builder, BlobStatusCallback()); | |
85 context->IncrementBlobRefCount(uuid); | |
86 return BlobStatus::DONE; | |
87 } | |
88 case MemoryStrategyResult::IPC: | |
89 state->strategy = IPCBlobItemRequestStrategy::IPC; | |
90 state->request_builder.InitializeForIPCRequests( | |
91 memory_controller.max_ipc_memory_size(), transport_memory_size, | |
92 elements, &(state->data_builder)); | |
93 break; | |
94 case MemoryStrategyResult::SHARED_MEMORY: | |
95 state->strategy = IPCBlobItemRequestStrategy::SHARED_MEMORY; | |
96 state->request_builder.InitializeForSharedMemoryRequests( | |
97 memory_controller.max_shared_memory_size(), transport_memory_size, | |
98 elements, &(state->data_builder)); | |
99 break; | |
100 case MemoryStrategyResult::FILE: | |
101 state->strategy = IPCBlobItemRequestStrategy::FILE; | |
102 state->request_builder.InitializeForFileRequests( | |
103 memory_controller.max_file_size(), transport_memory_size, elements, | |
104 &(state->data_builder)); | |
105 break; | |
106 } | |
107 // We initialize our requests received state now that they are populated. | |
108 state->request_received.resize(state->request_builder.requests().size(), | |
109 false); | |
110 | |
111 BlobBuildingState* state_ptr = state.get(); | |
112 async_blob_map_[uuid] = std::move(state); | |
113 | |
114 state_ptr->request_memory_callback = request_memory; | |
115 state_ptr->status_callback = status_callback; | |
116 | |
117 // We special case the file strategy, where we know they don't have to fit in | |
118 // memory, and we create the temporary files right away. | |
119 if (memory_strategy == MemoryStrategyResult::FILE) { | |
120 LOG(ERROR) << "file!"; | |
121 const auto& file_sizes = state_ptr->request_builder.file_sizes(); | |
122 state_ptr->files.resize(file_sizes.size()); | |
123 for (size_t i = 0; i < file_sizes.size(); i++) { | |
124 context->memory_controller_.CreateTemporaryFile( | |
125 file_sizes[i], base::Bind(&BlobAsyncBuilderHost::OnFileCreated, | |
126 ptr_factory_.GetWeakPtr(), uuid, i)); | |
127 } | |
128 temp_handle = | |
129 context->BuildBlob(state_ptr->data_builder, BlobStatusCallback()); | |
130 context->IncrementBlobRefCount(uuid); | |
131 return BlobStatus::PENDING_DATA_POPULATION; | |
164 } | 132 } |
165 | 133 |
166 // Step 4: Decide if we're using the shortcut method. This will also catch | 134 temp_handle = context->BuildBlob( |
167 // the case where we don't have any memory items. | 135 state_ptr->data_builder, |
168 if (shortcut_memory_size_bytes == total_memory_size_bytes && | 136 base::Bind(&BlobAsyncBuilderHost::OnCanStartBuildingBlob, |
169 shortcut_memory_size_bytes <= memory_available) { | 137 ptr_factory_.GetWeakPtr(), uuid, context->AsWeakPtr())); |
170 for (const DataElement& e : elements) { | 138 context->IncrementBlobRefCount(uuid); |
171 state_ptr->data_builder.AppendIPCDataElement(e); | 139 |
172 } | 140 if (temp_handle->IsBroken()) { |
173 FinishBuildingBlob(state_ptr, context); | 141 async_blob_map_.erase(uuid); |
174 return BlobTransportResult::DONE; | |
175 } | 142 } |
176 | 143 return temp_handle->GetBlobStatus(); |
177 // From here on, we know the blob's size is less than |memory_available|, | |
178 // so we know we're < max(size_t). | |
179 // Step 5: Decide if we're using shared memory. | |
180 if (total_memory_size_bytes > max_ipc_memory_size_) { | |
181 state_ptr->request_builder.InitializeForSharedMemoryRequests( | |
182 max_shared_memory_size_, total_memory_size_bytes, elements, | |
183 &(state_ptr->data_builder)); | |
184 } else { | |
185 // Step 6: We can fit in IPC. | |
186 state_ptr->request_builder.InitializeForIPCRequests( | |
187 max_ipc_memory_size_, total_memory_size_bytes, elements, | |
188 &(state_ptr->data_builder)); | |
189 } | |
190 // We initialize our requests received state now that they are populated. | |
191 state_ptr->request_received.resize( | |
192 state_ptr->request_builder.requests().size(), false); | |
193 return ContinueBlobMemoryRequests(uuid, context); | |
194 } | 144 } |
195 | 145 |
196 BlobTransportResult BlobAsyncBuilderHost::OnMemoryResponses( | 146 BlobStatus BlobAsyncBuilderHost::OnMemoryResponses( |
197 const std::string& uuid, | 147 const std::string& uuid, |
198 const std::vector<BlobItemBytesResponse>& responses, | 148 const std::vector<BlobItemBytesResponse>& responses, |
199 BlobStorageContext* context) { | 149 BlobStorageContext* context) { |
200 AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid); | 150 AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid); |
201 if (state_it == async_blob_map_.end()) { | 151 if (state_it == async_blob_map_.end()) { |
202 DVLOG(1) << "Could not find blob " << uuid; | 152 DVLOG(1) << "Could not find blob " << uuid; |
203 return BlobTransportResult::BAD_IPC; | 153 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; |
204 } | 154 } |
205 if (responses.empty()) { | 155 if (responses.empty()) { |
206 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | 156 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, |
207 return BlobTransportResult::BAD_IPC; | 157 context); |
158 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
208 } | 159 } |
160 | |
161 // Validate response sanity: it should refer to a legal request number, and | |
162 // we shouldn't have received an answer for that request yet. | |
209 BlobAsyncBuilderHost::BlobBuildingState* state = state_it->second.get(); | 163 BlobAsyncBuilderHost::BlobBuildingState* state = state_it->second.get(); |
210 BlobAsyncTransportRequestBuilder& request_builder = state->request_builder; | 164 const auto& requests = state->request_builder.requests(); |
211 const auto& requests = request_builder.requests(); | |
212 for (const BlobItemBytesResponse& response : responses) { | 165 for (const BlobItemBytesResponse& response : responses) { |
213 if (response.request_number >= requests.size()) { | 166 if (response.request_number >= requests.size()) { |
214 // Bad IPC, so we delete our record and ignore. | 167 // Bad IPC, so we delete our record and ignore. |
215 DVLOG(1) << "Invalid request number " << response.request_number; | 168 DVLOG(1) << "Invalid request number " << response.request_number; |
216 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | 169 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, |
217 return BlobTransportResult::BAD_IPC; | 170 context); |
171 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
218 } | 172 } |
219 DCHECK_LT(response.request_number, state->request_received.size()); | 173 DCHECK_LT(response.request_number, state->request_received.size()); |
220 const MemoryItemRequest& request = requests[response.request_number]; | |
221 if (state->request_received[response.request_number]) { | 174 if (state->request_received[response.request_number]) { |
222 // Bad IPC, so we delete our record. | 175 // Bad IPC, so we delete our record. |
223 DVLOG(1) << "Already received response for that request."; | 176 DVLOG(1) << "Already received response for that request."; |
224 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | 177 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, |
225 return BlobTransportResult::BAD_IPC; | 178 context); |
179 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
226 } | 180 } |
227 state->request_received[response.request_number] = true; | 181 state->request_received[response.request_number] = true; |
228 bool invalid_ipc = false; | |
229 bool memory_error = false; | |
230 switch (request.message.transport_strategy) { | |
231 case IPCBlobItemRequestStrategy::IPC: | |
232 if (response.inline_data.size() < request.message.size) { | |
233 DVLOG(1) << "Invalid data size " << response.inline_data.size() | |
234 << " vs requested size of " << request.message.size; | |
235 invalid_ipc = true; | |
236 break; | |
237 } | |
238 invalid_ipc = !state->data_builder.PopulateFutureData( | |
239 request.browser_item_index, &response.inline_data[0], | |
240 request.browser_item_offset, request.message.size); | |
241 break; | |
242 case IPCBlobItemRequestStrategy::SHARED_MEMORY: | |
243 if (state->num_shared_memory_requests == 0) { | |
244 DVLOG(1) << "Received too many responses for shared memory."; | |
245 invalid_ipc = true; | |
246 break; | |
247 } | |
248 state->num_shared_memory_requests--; | |
249 if (!state->shared_memory_block->memory()) { | |
250 // We just map the whole block, as we'll probably be accessing the | |
251 // whole thing in this group of responses. Another option is to use | |
252 // MapAt, remove the mapped boolean, and then exclude the | |
253 // handle_offset below. | |
254 size_t handle_size = request_builder.shared_memory_sizes() | |
255 [state->current_shared_memory_handle_index]; | |
256 if (!state->shared_memory_block->Map(handle_size)) { | |
257 DVLOG(1) << "Unable to map memory to size " << handle_size; | |
258 memory_error = true; | |
259 break; | |
260 } | |
261 } | |
262 | |
263 invalid_ipc = !state->data_builder.PopulateFutureData( | |
264 request.browser_item_index, | |
265 static_cast<const char*>(state->shared_memory_block->memory()) + | |
266 request.message.handle_offset, | |
267 request.browser_item_offset, request.message.size); | |
268 break; | |
269 case IPCBlobItemRequestStrategy::FILE: | |
270 case IPCBlobItemRequestStrategy::UNKNOWN: | |
271 DVLOG(1) << "Not implemented."; | |
272 invalid_ipc = true; | |
273 break; | |
274 } | |
275 if (invalid_ipc) { | |
276 // Bad IPC, so we delete our record and return false. | |
277 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::UNKNOWN, context); | |
278 return BlobTransportResult::BAD_IPC; | |
279 } | |
280 if (memory_error) { | |
281 DVLOG(1) << "Shared memory error."; | |
282 CancelBuildingBlob(uuid, IPCBlobCreationCancelCode::OUT_OF_MEMORY, | |
283 context); | |
284 return BlobTransportResult::CANCEL_MEMORY_FULL; | |
285 } | |
286 state->num_fulfilled_requests++; | |
287 } | 182 } |
288 return ContinueBlobMemoryRequests(uuid, context); | 183 switch (state->strategy) { |
184 case IPCBlobItemRequestStrategy::IPC: | |
185 return OnIPCResponses(uuid, state, responses, context); | |
186 case IPCBlobItemRequestStrategy::SHARED_MEMORY: | |
187 return OnSharedMemoryResponses(uuid, state, responses, context); | |
188 case IPCBlobItemRequestStrategy::FILE: | |
189 return OnFileResponses(uuid, state, responses, context); | |
190 case IPCBlobItemRequestStrategy::UNKNOWN: | |
191 break; | |
192 } | |
193 NOTREACHED(); | |
194 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
289 } | 195 } |
290 | 196 |
291 void BlobAsyncBuilderHost::CancelBuildingBlob(const std::string& uuid, | 197 void BlobAsyncBuilderHost::CancelBuildingBlob(const std::string& uuid, |
292 IPCBlobCreationCancelCode code, | 198 BlobStatus code, |
293 BlobStorageContext* context) { | 199 BlobStorageContext* context) { |
294 DCHECK(context); | 200 DCHECK(context); |
201 DCHECK(BlobStatusIsError(code)); | |
295 auto state_it = async_blob_map_.find(uuid); | 202 auto state_it = async_blob_map_.find(uuid); |
296 if (state_it == async_blob_map_.end()) { | 203 if (state_it == async_blob_map_.end()) { |
297 return; | 204 return; |
298 } | 205 } |
299 // We can have the blob dereferenced by the renderer, but have it still being | 206 // We can have the blob dereferenced by the renderer, but have it still being |
300 // 'built'. In this case, it's destructed in the context, but we still have | 207 // 'built'. In this case, it's destructed in the context, but we still have |
301 // it in our map. Hence we make sure the context has the entry before | 208 // it in our map. Hence we make sure the context has the entry before |
302 // calling cancel. | 209 // calling cancel. |
210 async_blob_map_.erase(state_it); | |
303 if (context->registry().HasEntry(uuid)) | 211 if (context->registry().HasEntry(uuid)) |
304 context->CancelPendingBlob(uuid, code); | 212 context->BreakAndFinishPendingBlob(uuid, code); |
305 async_blob_map_.erase(state_it); | |
306 } | 213 } |
307 | 214 |
308 void BlobAsyncBuilderHost::CancelAll(BlobStorageContext* context) { | 215 void BlobAsyncBuilderHost::CancelAll(BlobStorageContext* context) { |
309 DCHECK(context); | 216 DCHECK(context); |
310 // If the blob still exists in the context (and is being built), then we know | 217 // If the blob still exists in the context, then we know that someone else is |
311 // that someone else is expecting our blob, and we need to cancel it to let | 218 // expecting our blob, and we need to cancel it to let the dependency know |
312 // the dependency know it's gone. | 219 // it's gone. |
313 std::vector<std::unique_ptr<BlobDataHandle>> referenced_pending_blobs; | 220 std::vector<std::unique_ptr<BlobDataHandle>> referenced_pending_blobs; |
314 for (const auto& uuid_state_pair : async_blob_map_) { | 221 for (const auto& uuid_state_pair : async_blob_map_) { |
315 if (context->IsBeingBuilt(uuid_state_pair.first)) { | 222 std::unique_ptr<BlobDataHandle> handle = |
316 referenced_pending_blobs.emplace_back( | 223 context->GetBlobDataFromUUID(uuid_state_pair.first); |
224 if (handle) { | |
225 referenced_pending_blobs.push_back( | |
317 context->GetBlobDataFromUUID(uuid_state_pair.first)); | 226 context->GetBlobDataFromUUID(uuid_state_pair.first)); |
318 } | 227 } |
319 } | 228 } |
320 // We clear the map before canceling them to prevent any strange reentry into | 229 // We clear the map before canceling them to prevent any strange reentry into |
321 // our class (see ReferencedBlobFinished) if any blobs were waiting for others | 230 // our class (see OnCanStartBuildingBlob) if any blobs were waiting for others |
322 // to construct. | 231 // to construct. |
323 async_blob_map_.clear(); | 232 async_blob_map_.clear(); |
324 for (const std::unique_ptr<BlobDataHandle>& handle : | 233 for (const std::unique_ptr<BlobDataHandle>& handle : |
325 referenced_pending_blobs) { | 234 referenced_pending_blobs) { |
326 context->CancelPendingBlob( | 235 context->BreakAndFinishPendingBlob(handle->uuid(), |
327 handle->uuid(), IPCBlobCreationCancelCode::SOURCE_DIED_IN_TRANSIT); | 236 BlobStatus::SOURCE_DIED_IN_TRANSIT); |
328 } | 237 } |
329 } | 238 } |
330 | 239 |
331 BlobTransportResult BlobAsyncBuilderHost::ContinueBlobMemoryRequests( | 240 BlobStatus BlobAsyncBuilderHost::StartRequests(const std::string& uuid, |
241 BlobBuildingState* state, | |
242 BlobStorageContext* context) { | |
243 switch (state->strategy) { | |
244 case IPCBlobItemRequestStrategy::IPC: | |
245 SendIPCRequests(state, context); | |
246 return BlobStatus::PENDING_DATA_POPULATION; | |
247 case IPCBlobItemRequestStrategy::SHARED_MEMORY: | |
248 return ContinueSharedMemoryRequests(uuid, state, context); | |
249 case IPCBlobItemRequestStrategy::FILE: | |
250 case IPCBlobItemRequestStrategy::UNKNOWN: | |
251 break; | |
252 } | |
253 NOTREACHED(); | |
254 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
255 } | |
256 | |
257 // Note: This can be called when we cancel a blob in the context. | |
258 void BlobAsyncBuilderHost::OnCanStartBuildingBlob( | |
332 const std::string& uuid, | 259 const std::string& uuid, |
260 base::WeakPtr<BlobStorageContext> context, | |
261 BlobStatus status) { | |
262 LOG(ERROR) << "We can fit now!"; | |
263 if (!context) { | |
264 async_blob_map_.erase(uuid); | |
265 return; | |
266 } | |
267 AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid); | |
268 if (state_it == async_blob_map_.end()) { | |
269 return; | |
270 } | |
271 BlobBuildingState* state = state_it->second.get(); | |
272 | |
273 if (status == BlobStatus::PENDING_DATA_POPULATION) { | |
274 status = StartRequests(uuid, state, context.get()); | |
275 if (status == BlobStatus::PENDING_DATA_POPULATION) { | |
276 return; | |
277 } | |
278 } else { | |
279 LOG(ERROR) << "Got error state!"; | |
280 } | |
281 BlobStatusCallback status_callback = state->status_callback; | |
282 async_blob_map_.erase(state_it); | |
283 status_callback.Run(status); | |
284 } | |
285 | |
286 void BlobAsyncBuilderHost::SendIPCRequests(BlobBuildingState* state, | |
287 BlobStorageContext* context) { | |
288 const std::vector<MemoryItemRequest>& requests = | |
289 state->request_builder.requests(); | |
290 std::unique_ptr<std::vector<BlobItemBytesRequest>> byte_requests( | |
291 new std::vector<BlobItemBytesRequest>()); | |
292 | |
293 DCHECK(!requests.empty()); | |
294 for (const MemoryItemRequest& request : requests) { | |
295 byte_requests->push_back(request.message); | |
296 } | |
297 | |
298 state->request_memory_callback.Run( | |
299 std::move(byte_requests), | |
300 base::WrapUnique(new std::vector<base::SharedMemoryHandle>()), | |
301 base::WrapUnique(new std::vector<base::File>())); | |
302 } | |
303 | |
304 BlobStatus BlobAsyncBuilderHost::OnIPCResponses( | |
305 const std::string& uuid, | |
306 BlobBuildingState* state, | |
307 const std::vector<BlobItemBytesResponse>& responses, | |
333 BlobStorageContext* context) { | 308 BlobStorageContext* context) { |
334 AsyncBlobMap::const_iterator state_it = async_blob_map_.find(uuid); | 309 const auto& requests = state->request_builder.requests(); |
335 DCHECK(state_it != async_blob_map_.end()); | 310 size_t num_requests = requests.size(); |
336 BlobAsyncBuilderHost::BlobBuildingState* state = state_it->second.get(); | 311 for (const BlobItemBytesResponse& response : responses) { |
312 const MemoryItemRequest& request = requests[response.request_number]; | |
313 if (response.inline_data.size() < request.message.size) { | |
314 DVLOG(1) << "Invalid data size " << response.inline_data.size() | |
315 << " vs requested size of " << request.message.size; | |
316 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, | |
317 context); | |
318 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
319 } | |
320 bool success = state->data_builder.PopulateFutureData( | |
321 request.browser_item_index, response.inline_data.data(), | |
322 request.browser_item_offset, request.message.size); | |
323 if (!success) { | |
324 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, | |
325 context); | |
326 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
327 } | |
328 state->num_fulfilled_requests++; | |
329 } | |
330 if (state->num_fulfilled_requests == num_requests) { | |
331 FinishBuildingBlob(state, context); | |
332 return BlobStatus::DONE; | |
333 } | |
334 return BlobStatus::PENDING_DATA_POPULATION; | |
335 } | |
337 | 336 |
337 BlobStatus BlobAsyncBuilderHost::ContinueSharedMemoryRequests( | |
338 const std::string& uuid, | |
339 BlobBuildingState* state, | |
340 BlobStorageContext* context) { | |
338 BlobAsyncTransportRequestBuilder& request_builder = state->request_builder; | 341 BlobAsyncTransportRequestBuilder& request_builder = state->request_builder; |
339 const std::vector<MemoryItemRequest>& requests = request_builder.requests(); | 342 const std::vector<MemoryItemRequest>& requests = request_builder.requests(); |
340 size_t num_requests = requests.size(); | 343 size_t num_requests = requests.size(); |
341 if (state->num_fulfilled_requests == num_requests) { | |
342 FinishBuildingBlob(state, context); | |
343 return BlobTransportResult::DONE; | |
344 } | |
345 DCHECK_LT(state->num_fulfilled_requests, num_requests); | 344 DCHECK_LT(state->num_fulfilled_requests, num_requests); |
346 if (state->next_request == num_requests) { | 345 if (state->next_request == num_requests) { |
347 // We are still waiting on other requests to come back. | 346 // We are still waiting on other requests to come back. |
348 return BlobTransportResult::PENDING_RESPONSES; | 347 return BlobStatus::PENDING_DATA_POPULATION; |
349 } | 348 } |
350 | 349 |
351 std::unique_ptr<std::vector<BlobItemBytesRequest>> byte_requests( | 350 std::unique_ptr<std::vector<BlobItemBytesRequest>> byte_requests( |
352 new std::vector<BlobItemBytesRequest>()); | 351 new std::vector<BlobItemBytesRequest>()); |
353 std::unique_ptr<std::vector<base::SharedMemoryHandle>> shared_memory( | 352 std::unique_ptr<std::vector<base::SharedMemoryHandle>> shared_memory( |
354 new std::vector<base::SharedMemoryHandle>()); | 353 new std::vector<base::SharedMemoryHandle>()); |
355 | 354 |
356 for (; state->next_request < num_requests; ++state->next_request) { | 355 for (; state->next_request < num_requests; ++state->next_request) { |
357 const MemoryItemRequest& request = requests[state->next_request]; | 356 const MemoryItemRequest& request = requests[state->next_request]; |
358 | |
359 bool stop_accumulating = false; | |
360 bool using_shared_memory_handle = state->num_shared_memory_requests > 0; | 357 bool using_shared_memory_handle = state->num_shared_memory_requests > 0; |
361 switch (request.message.transport_strategy) { | 358 if (using_shared_memory_handle && |
362 case IPCBlobItemRequestStrategy::IPC: | 359 state->current_shared_memory_handle_index != |
363 byte_requests->push_back(request.message); | 360 request.message.handle_index) { |
364 break; | 361 // We only want one shared memory per requesting blob. |
365 case IPCBlobItemRequestStrategy::SHARED_MEMORY: | |
366 if (using_shared_memory_handle && | |
367 state->current_shared_memory_handle_index != | |
368 request.message.handle_index) { | |
369 // We only want one shared memory per requesting blob. | |
370 stop_accumulating = true; | |
371 break; | |
372 } | |
373 using_shared_memory_handle = true; | |
374 state->current_shared_memory_handle_index = | |
375 request.message.handle_index; | |
376 state->num_shared_memory_requests++; | |
377 | |
378 if (!state->shared_memory_block) { | |
379 state->shared_memory_block.reset(new base::SharedMemory()); | |
380 size_t size = | |
381 request_builder | |
382 .shared_memory_sizes()[request.message.handle_index]; | |
383 if (!state->shared_memory_block->CreateAnonymous(size)) { | |
384 DVLOG(1) << "Unable to allocate shared memory for blob transfer."; | |
385 return BlobTransportResult::CANCEL_MEMORY_FULL; | |
386 } | |
387 } | |
388 shared_memory->push_back(state->shared_memory_block->handle()); | |
389 byte_requests->push_back(request.message); | |
390 // Since we are only using one handle at a time, transform our handle | |
391 // index correctly back to 0. | |
392 byte_requests->back().handle_index = 0; | |
393 break; | |
394 case IPCBlobItemRequestStrategy::FILE: | |
395 case IPCBlobItemRequestStrategy::UNKNOWN: | |
396 NOTREACHED() << "Not implemented yet."; | |
397 break; | |
398 } | |
399 if (stop_accumulating) { | |
400 break; | 362 break; |
401 } | 363 } |
364 state->current_shared_memory_handle_index = request.message.handle_index; | |
365 state->num_shared_memory_requests++; | |
366 | |
367 if (!state->shared_memory_block) { | |
368 state->shared_memory_block.reset(new base::SharedMemory()); | |
369 size_t size = | |
370 request_builder.shared_memory_sizes()[request.message.handle_index]; | |
371 if (!state->shared_memory_block->CreateAnonymous(size)) { | |
372 DVLOG(1) << "Unable to allocate shared memory for blob transfer."; | |
373 return BlobStatus::OUT_OF_MEMORY; | |
374 } | |
375 } | |
376 shared_memory->push_back(state->shared_memory_block->handle()); | |
377 byte_requests->push_back(request.message); | |
378 // Since we are only using one handle at a time, transform our handle | |
379 // index correctly back to 0. | |
380 byte_requests->back().handle_index = 0; | |
402 } | 381 } |
403 DCHECK(!requests.empty()); | 382 DCHECK(!requests.empty()); |
404 | 383 |
405 state->request_memory_callback.Run( | 384 state->request_memory_callback.Run( |
406 std::move(byte_requests), std::move(shared_memory), | 385 std::move(byte_requests), std::move(shared_memory), |
407 base::WrapUnique(new std::vector<base::File>())); | 386 base::WrapUnique(new std::vector<base::File>())); |
408 return BlobTransportResult::PENDING_RESPONSES; | 387 return BlobStatus::PENDING_DATA_POPULATION; |
409 } | 388 } |
410 | 389 |
411 void BlobAsyncBuilderHost::ReferencedBlobFinished( | 390 BlobStatus BlobAsyncBuilderHost::OnSharedMemoryResponses( |
412 const std::string& owning_blob_uuid, | 391 const std::string& uuid, |
413 base::WeakPtr<BlobStorageContext> context, | 392 BlobBuildingState* state, |
414 bool construction_success, | 393 const std::vector<BlobItemBytesResponse>& responses, |
415 IPCBlobCreationCancelCode reason) { | 394 BlobStorageContext* context) { |
416 if (!context) { | 395 BlobAsyncTransportRequestBuilder& request_builder = state->request_builder; |
417 return; | 396 const auto& requests = request_builder.requests(); |
397 for (const BlobItemBytesResponse& response : responses) { | |
398 const MemoryItemRequest& request = requests[response.request_number]; | |
399 if (state->num_shared_memory_requests == 0) { | |
400 DVLOG(1) << "Received too many responses for shared memory."; | |
401 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, | |
402 context); | |
403 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
404 } | |
405 state->num_shared_memory_requests--; | |
406 if (!state->shared_memory_block->memory()) { | |
407 // We just map the whole block, as we'll probably be accessing the | |
408 // whole thing in this group of responses. | |
409 size_t handle_size = | |
410 request_builder | |
411 .shared_memory_sizes()[state->current_shared_memory_handle_index]; | |
412 if (!state->shared_memory_block->Map(handle_size)) { | |
413 DVLOG(1) << "Unable to map memory to size " << handle_size; | |
414 CancelBuildingBlob(uuid, BlobStatus::OUT_OF_MEMORY, context); | |
415 return BlobStatus::OUT_OF_MEMORY; | |
416 } | |
417 } | |
418 | |
419 bool success = state->data_builder.PopulateFutureData( | |
420 request.browser_item_index, | |
421 static_cast<const char*>(state->shared_memory_block->memory()) + | |
422 request.message.handle_offset, | |
423 request.browser_item_offset, request.message.size); | |
424 | |
425 if (!success) { | |
426 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, | |
427 context); | |
428 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
429 } | |
430 state->num_fulfilled_requests++; | |
418 } | 431 } |
419 auto state_it = async_blob_map_.find(owning_blob_uuid); | 432 if (state->num_fulfilled_requests == requests.size()) { |
433 FinishBuildingBlob(state, context); | |
434 return BlobStatus::DONE; | |
435 } | |
436 return ContinueSharedMemoryRequests(uuid, state, context); | |
437 } | |
438 | |
439 void BlobAsyncBuilderHost::OnFileCreated( | |
440 const std::string& uuid, | |
441 size_t handle_index, | |
442 BlobMemoryController::FileCreationInfo file_info) { | |
443 LOG(ERROR) << "File created for renderer."; | |
444 auto state_it = async_blob_map_.find(uuid); | |
420 if (state_it == async_blob_map_.end()) { | 445 if (state_it == async_blob_map_.end()) { |
421 return; | 446 return; |
422 } | 447 } |
423 if (!construction_success) { | 448 BlobBuildingState* state = state_it->second.get(); |
424 CancelBuildingBlob(owning_blob_uuid, | 449 DCHECK_LT(handle_index, state->files.size()); |
425 ConvertReferencedBlobErrorToConstructingError(reason), | 450 state->files[handle_index] = std::move(file_info.file_reference); |
426 context.get()); | 451 |
427 return; | 452 const BlobAsyncTransportRequestBuilder& request_builder = |
453 state->request_builder; | |
454 const std::vector<MemoryItemRequest>& requests = request_builder.requests(); | |
455 | |
456 std::unique_ptr<std::vector<BlobItemBytesRequest>> byte_requests( | |
457 new std::vector<BlobItemBytesRequest>()); | |
458 | |
459 std::unique_ptr<std::vector<base::File>> files(new std::vector<base::File>()); | |
460 files->push_back(std::move(file_info.file)); | |
461 | |
462 for (const MemoryItemRequest& request : requests) { | |
463 if (request.message.handle_index != handle_index) { | |
464 continue; | |
465 } | |
466 byte_requests->push_back(request.message); | |
467 byte_requests->back().handle_index = 0; | |
428 } | 468 } |
429 BlobBuildingState* state = state_it->second.get(); | 469 |
430 DCHECK_GT(state->num_referenced_blobs_building, 0u); | 470 state->request_memory_callback.Run( |
431 if (--state->num_referenced_blobs_building == 0) { | 471 std::move(byte_requests), |
432 context->CompletePendingBlob(state->data_builder); | 472 base::WrapUnique(new std::vector<base::SharedMemoryHandle>()), |
433 async_blob_map_.erase(state->data_builder.uuid()); | 473 std::move(files)); |
474 } | |
475 | |
476 BlobStatus BlobAsyncBuilderHost::OnFileResponses( | |
477 const std::string& uuid, | |
478 BlobBuildingState* state, | |
479 const std::vector<BlobItemBytesResponse>& responses, | |
480 BlobStorageContext* context) { | |
481 BlobAsyncTransportRequestBuilder& request_builder = state->request_builder; | |
482 const auto& requests = request_builder.requests(); | |
483 for (const BlobItemBytesResponse& response : responses) { | |
484 const MemoryItemRequest& request = requests[response.request_number]; | |
485 const scoped_refptr<ShareableFileReference>& file_ref = | |
486 state->files[request.message.handle_index]; | |
487 bool success = state->data_builder.PopulateFutureFile( | |
488 request.browser_item_index, file_ref, response.time_file_modified); | |
489 if (!success) { | |
490 CancelBuildingBlob(uuid, BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS, | |
491 context); | |
492 return BlobStatus::INVALID_CONSTRUCTION_ARGUMENTS; | |
493 } | |
494 state->num_fulfilled_requests++; | |
434 } | 495 } |
496 if (state->num_fulfilled_requests == requests.size()) { | |
497 FinishBuildingBlob(state, context); | |
498 return BlobStatus::DONE; | |
499 } | |
500 return BlobStatus::PENDING_DATA_POPULATION; | |
435 } | 501 } |
436 | 502 |
437 void BlobAsyncBuilderHost::FinishBuildingBlob(BlobBuildingState* state, | 503 void BlobAsyncBuilderHost::FinishBuildingBlob(BlobBuildingState* state, |
438 BlobStorageContext* context) { | 504 BlobStorageContext* context) { |
439 if (!state->referenced_blob_uuids.empty()) { | 505 std::string uuid = state->data_builder.uuid(); |
440 DCHECK_EQ(0u, state->num_referenced_blobs_building); | |
441 state->num_referenced_blobs_building = 0; | |
442 // We assume re-entry is not possible, as RunOnConstructionComplete | |
443 // will schedule a task when the blob is being built. Thus we can't have the | |
444 // case where |num_referenced_blobs_building| reaches 0 in the | |
445 // ReferencedBlobFinished method before we're finished looping. | |
446 for (const std::string& referenced_uuid : state->referenced_blob_uuids) { | |
447 if (context->IsBeingBuilt(referenced_uuid)) { | |
448 state->num_referenced_blobs_building++; | |
449 context->RunOnConstructionComplete( | |
450 referenced_uuid, | |
451 base::Bind(&BlobAsyncBuilderHost::ReferencedBlobFinished, | |
452 ptr_factory_.GetWeakPtr(), state->data_builder.uuid(), | |
453 context->AsWeakPtr())); | |
454 } | |
455 } | |
456 if (state->num_referenced_blobs_building > 0) { | |
457 // We wait until referenced blobs are done. | |
458 return; | |
459 } | |
460 } | |
461 context->CompletePendingBlob(state->data_builder); | |
462 async_blob_map_.erase(state->data_builder.uuid()); | 506 async_blob_map_.erase(state->data_builder.uuid()); |
507 context->FinishedPopulatingPendingBlob(uuid); | |
463 } | 508 } |
464 | 509 |
465 } // namespace storage | 510 } // namespace storage |
OLD | NEW |