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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
11 #include "storage/browser/blob/blob_async_transport_request_builder.h" | 11 #include "storage/browser/blob/blob_transport_request_builder.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 | 13 |
14 namespace storage { | 14 namespace storage { |
15 namespace { | 15 namespace { |
16 | 16 |
17 const char kNewUUID[] = "newUUID"; | 17 const char kNewUUID[] = "newUUID"; |
18 const char kFakeBlobUUID[] = "fakeBlob"; | 18 const char kFakeBlobUUID[] = "fakeBlob"; |
19 | 19 |
20 void AddMemoryItem(size_t length, std::vector<DataElement>* out) { | 20 void AddMemoryItem(size_t length, std::vector<DataElement>* out) { |
21 DataElement bytes; | 21 DataElement bytes; |
(...skipping 10 matching lines...) Expand all Loading... |
32 out->push_back(bytes); | 32 out->push_back(bytes); |
33 } | 33 } |
34 | 34 |
35 void AddBlobItem(std::vector<DataElement>* out) { | 35 void AddBlobItem(std::vector<DataElement>* out) { |
36 DataElement blob; | 36 DataElement blob; |
37 blob.SetToBlob(kFakeBlobUUID); | 37 blob.SetToBlob(kFakeBlobUUID); |
38 out->push_back(blob); | 38 out->push_back(blob); |
39 } | 39 } |
40 | 40 |
41 TEST(BlobAsyncTransportRequestBuilderTest, TestNoMemoryItems) { | 41 TEST(BlobAsyncTransportRequestBuilderTest, TestNoMemoryItems) { |
42 BlobAsyncTransportRequestBuilder strategy; | 42 BlobTransportRequestBuilder strategy; |
43 BlobDataBuilder builder(kNewUUID); | 43 BlobDataBuilder builder(kNewUUID); |
44 std::vector<DataElement> infos; | 44 std::vector<DataElement> infos; |
45 | 45 |
46 // Here we test that we don't do any requests when there are no memory items. | 46 // Here we test that we don't do any requests when there are no memory items. |
47 AddBlobItem(&infos); | 47 AddBlobItem(&infos); |
48 AddBlobItem(&infos); | 48 AddBlobItem(&infos); |
49 AddBlobItem(&infos); | 49 AddBlobItem(&infos); |
50 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size | 50 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
51 0, // blob_total_size | 51 0, // blob_total_size |
52 infos, &builder); | 52 infos, &builder); |
53 | 53 |
54 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); | 54 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
55 EXPECT_EQ(0u, strategy.file_sizes().size()); | 55 EXPECT_EQ(0u, strategy.file_sizes().size()); |
56 EXPECT_EQ(0u, strategy.requests().size()); | 56 EXPECT_EQ(0u, strategy.requests().size()); |
57 | 57 |
58 BlobDataBuilder expected_builder(kNewUUID); | 58 BlobDataBuilder expected_builder(kNewUUID); |
59 expected_builder.AppendBlob(kFakeBlobUUID); | 59 expected_builder.AppendBlob(kFakeBlobUUID); |
60 expected_builder.AppendBlob(kFakeBlobUUID); | 60 expected_builder.AppendBlob(kFakeBlobUUID); |
61 expected_builder.AppendBlob(kFakeBlobUUID); | 61 expected_builder.AppendBlob(kFakeBlobUUID); |
62 EXPECT_EQ(expected_builder, builder); | 62 EXPECT_EQ(expected_builder, builder); |
63 } | 63 } |
64 | 64 |
65 TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFile) { | 65 TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFile) { |
66 BlobAsyncTransportRequestBuilder strategy; | 66 BlobTransportRequestBuilder strategy; |
67 BlobDataBuilder builder(kNewUUID); | 67 BlobDataBuilder builder(kNewUUID); |
68 std::vector<DataElement> infos; | 68 std::vector<DataElement> infos; |
69 | 69 |
70 AddMemoryItem(305, &infos); | 70 AddMemoryItem(305, &infos); |
71 strategy.InitializeForFileRequests(400, // max_file_size | 71 strategy.InitializeForFileRequests(400, // max_file_size |
72 305, // blob_total_size | 72 305, // blob_total_size |
73 infos, &builder); | 73 infos, &builder); |
74 | 74 |
75 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); | 75 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
76 EXPECT_EQ(1u, strategy.file_sizes().size()); | 76 EXPECT_EQ(1u, strategy.file_sizes().size()); |
77 EXPECT_EQ(305ul, strategy.file_sizes().at(0)); | 77 EXPECT_EQ(305ul, strategy.file_sizes().at(0)); |
78 EXPECT_EQ(1u, strategy.requests().size()); | 78 EXPECT_EQ(1u, strategy.requests().size()); |
79 | 79 |
80 auto& memory_item_request = strategy.requests().at(0); | 80 auto& memory_item_request = strategy.requests().at(0); |
81 EXPECT_EQ(0u, memory_item_request.browser_item_index); | 81 EXPECT_EQ(0u, memory_item_request.browser_item_index); |
82 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | 82 EXPECT_EQ(0u, memory_item_request.browser_item_offset); |
83 EXPECT_EQ( | 83 EXPECT_EQ( |
84 BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull), | 84 BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull), |
85 memory_item_request.message); | 85 memory_item_request.message); |
86 | 86 |
87 BlobDataBuilder expected_builder(kNewUUID); | 87 BlobDataBuilder expected_builder(kNewUUID); |
88 expected_builder.AppendFutureFile(0, 305, 0); | 88 expected_builder.AppendFutureFile(0, 305, 0); |
89 EXPECT_EQ(expected_builder, builder); | 89 EXPECT_EQ(expected_builder, builder); |
90 } | 90 } |
91 | 91 |
92 TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFiles) { | 92 TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFiles) { |
93 BlobAsyncTransportRequestBuilder strategy; | 93 BlobTransportRequestBuilder strategy; |
94 BlobDataBuilder builder(kNewUUID); | 94 BlobDataBuilder builder(kNewUUID); |
95 std::vector<DataElement> infos; | 95 std::vector<DataElement> infos; |
96 | 96 |
97 AddMemoryItem(1000, &infos); | 97 AddMemoryItem(1000, &infos); |
98 strategy.InitializeForFileRequests(400, // max_file_size | 98 strategy.InitializeForFileRequests(400, // max_file_size |
99 1000, // blob_total_size | 99 1000, // blob_total_size |
100 infos, &builder); | 100 infos, &builder); |
101 | 101 |
102 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); | 102 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
103 EXPECT_EQ(3u, strategy.file_sizes().size()); | 103 EXPECT_EQ(3u, strategy.file_sizes().size()); |
(...skipping 25 matching lines...) Expand all Loading... |
129 | 129 |
130 BlobDataBuilder expected_builder(kNewUUID); | 130 BlobDataBuilder expected_builder(kNewUUID); |
131 expected_builder.AppendFutureFile(0, 400, 0); | 131 expected_builder.AppendFutureFile(0, 400, 0); |
132 expected_builder.AppendFutureFile(0, 400, 1); | 132 expected_builder.AppendFutureFile(0, 400, 1); |
133 expected_builder.AppendFutureFile(0, 200, 2); | 133 expected_builder.AppendFutureFile(0, 200, 2); |
134 EXPECT_EQ(expected_builder, builder); | 134 EXPECT_EQ(expected_builder, builder); |
135 } | 135 } |
136 | 136 |
137 TEST(BlobAsyncTransportRequestBuilderTest, | 137 TEST(BlobAsyncTransportRequestBuilderTest, |
138 TestLargeBlocksConsolidatingInFiles) { | 138 TestLargeBlocksConsolidatingInFiles) { |
139 BlobAsyncTransportRequestBuilder strategy; | 139 BlobTransportRequestBuilder strategy; |
140 BlobDataBuilder builder(kNewUUID); | 140 BlobDataBuilder builder(kNewUUID); |
141 std::vector<DataElement> infos; | 141 std::vector<DataElement> infos; |
142 | 142 |
143 // We should have 3 storage items for the memory, two files, 400 each. | 143 // We should have 3 storage items for the memory, two files, 400 each. |
144 // We end up with storage items: | 144 // We end up with storage items: |
145 // 1: File A, 300MB | 145 // 1: File A, 300MB |
146 // 2: Blob | 146 // 2: Blob |
147 // 3: File A, 100MB (300MB offset) | 147 // 3: File A, 100MB (300MB offset) |
148 // 4: File B, 400MB | 148 // 4: File B, 400MB |
149 AddMemoryItem(300, &infos); | 149 AddMemoryItem(300, &infos); |
(...skipping 26 matching lines...) Expand all Loading... |
176 | 176 |
177 memory_item_request = strategy.requests().at(2); | 177 memory_item_request = strategy.requests().at(2); |
178 EXPECT_EQ(3u, memory_item_request.browser_item_index); | 178 EXPECT_EQ(3u, memory_item_request.browser_item_index); |
179 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | 179 EXPECT_EQ(0u, memory_item_request.browser_item_offset); |
180 EXPECT_EQ( | 180 EXPECT_EQ( |
181 BlobItemBytesRequest::CreateFileRequest(2u, 2u, 100ull, 400ull, 1u, 0ull), | 181 BlobItemBytesRequest::CreateFileRequest(2u, 2u, 100ull, 400ull, 1u, 0ull), |
182 memory_item_request.message); | 182 memory_item_request.message); |
183 } | 183 } |
184 | 184 |
185 TEST(BlobAsyncTransportRequestBuilderTest, TestSharedMemorySegmentation) { | 185 TEST(BlobAsyncTransportRequestBuilderTest, TestSharedMemorySegmentation) { |
186 BlobAsyncTransportRequestBuilder strategy; | 186 BlobTransportRequestBuilder strategy; |
187 BlobDataBuilder builder(kNewUUID); | 187 BlobDataBuilder builder(kNewUUID); |
188 std::vector<DataElement> infos; | 188 std::vector<DataElement> infos; |
189 | 189 |
190 // For transport we should have 3 shared memories, and then storage in 3 | 190 // For transport we should have 3 shared memories, and then storage in 3 |
191 // browser items. | 191 // browser items. |
192 AddMemoryItem(500, &infos); | 192 AddMemoryItem(500, &infos); |
193 strategy.InitializeForSharedMemoryRequests(200, // max_shared_memory_size | 193 strategy.InitializeForSharedMemoryRequests(200, // max_shared_memory_size |
194 500, // total_blob_size | 194 500, // total_blob_size |
195 infos, &builder); | 195 infos, &builder); |
196 | 196 |
(...skipping 27 matching lines...) Expand all Loading... |
224 | 224 |
225 BlobDataBuilder expected_builder(kNewUUID); | 225 BlobDataBuilder expected_builder(kNewUUID); |
226 expected_builder.AppendFutureData(200); | 226 expected_builder.AppendFutureData(200); |
227 expected_builder.AppendFutureData(200); | 227 expected_builder.AppendFutureData(200); |
228 expected_builder.AppendFutureData(100); | 228 expected_builder.AppendFutureData(100); |
229 EXPECT_EQ(expected_builder, builder); | 229 EXPECT_EQ(expected_builder, builder); |
230 } | 230 } |
231 | 231 |
232 TEST(BlobAsyncTransportRequestBuilderTest, | 232 TEST(BlobAsyncTransportRequestBuilderTest, |
233 TestSharedMemorySegmentationAndStorage) { | 233 TestSharedMemorySegmentationAndStorage) { |
234 BlobAsyncTransportRequestBuilder strategy; | 234 BlobTransportRequestBuilder strategy; |
235 BlobDataBuilder builder(kNewUUID); | 235 BlobDataBuilder builder(kNewUUID); |
236 std::vector<DataElement> infos; | 236 std::vector<DataElement> infos; |
237 | 237 |
238 // For transport, we should have 2 shared memories, where the first one | 238 // For transport, we should have 2 shared memories, where the first one |
239 // have half 0 and half 3, and then the last one has half 3. | 239 // have half 0 and half 3, and then the last one has half 3. |
240 // | 240 // |
241 // For storage, we should have 3 browser items that match the pre-transport | 241 // For storage, we should have 3 browser items that match the pre-transport |
242 // version: | 242 // version: |
243 // 1: Bytes 100MB | 243 // 1: Bytes 100MB |
244 // 2: Blob | 244 // 2: Blob |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
282 expected_builder.AppendFutureData(100); | 282 expected_builder.AppendFutureData(100); |
283 expected_builder.AppendBlob(kFakeBlobUUID); | 283 expected_builder.AppendBlob(kFakeBlobUUID); |
284 expected_builder.AppendFutureData(200); | 284 expected_builder.AppendFutureData(200); |
285 EXPECT_EQ(expected_builder, builder); | 285 EXPECT_EQ(expected_builder, builder); |
286 } | 286 } |
287 | 287 |
288 TEST(BlobAsyncTransportRequestBuilderTest, TestSimpleIPC) { | 288 TEST(BlobAsyncTransportRequestBuilderTest, TestSimpleIPC) { |
289 // Test simple IPC strategy, where size < max_ipc_memory_size and we have | 289 // Test simple IPC strategy, where size < max_ipc_memory_size and we have |
290 // just one item. | 290 // just one item. |
291 std::vector<DataElement> infos; | 291 std::vector<DataElement> infos; |
292 BlobAsyncTransportRequestBuilder strategy; | 292 BlobTransportRequestBuilder strategy; |
293 BlobDataBuilder builder(kNewUUID); | 293 BlobDataBuilder builder(kNewUUID); |
294 AddMemoryItem(10, &infos); | 294 AddMemoryItem(10, &infos); |
295 AddBlobItem(&infos); | 295 AddBlobItem(&infos); |
296 | 296 |
297 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size | 297 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
298 10, // total_blob_size | 298 10, // total_blob_size |
299 infos, &builder); | 299 infos, &builder); |
300 | 300 |
301 EXPECT_EQ(0u, strategy.file_sizes().size()); | 301 EXPECT_EQ(0u, strategy.file_sizes().size()); |
302 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); | 302 EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
303 ASSERT_EQ(1u, strategy.requests().size()); | 303 ASSERT_EQ(1u, strategy.requests().size()); |
304 | 304 |
305 auto memory_item_request = strategy.requests().at(0); | 305 auto memory_item_request = strategy.requests().at(0); |
306 EXPECT_EQ(0u, memory_item_request.browser_item_index); | 306 EXPECT_EQ(0u, memory_item_request.browser_item_index); |
307 EXPECT_EQ(0u, memory_item_request.browser_item_offset); | 307 EXPECT_EQ(0u, memory_item_request.browser_item_offset); |
308 EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull), | 308 EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull), |
309 memory_item_request.message); | 309 memory_item_request.message); |
310 } | 310 } |
311 | 311 |
312 TEST(BlobAsyncTransportRequestBuilderTest, TestMultipleIPC) { | 312 TEST(BlobAsyncTransportRequestBuilderTest, TestMultipleIPC) { |
313 // Same as above, but with 2 items and a blob in-between. | 313 // Same as above, but with 2 items and a blob in-between. |
314 std::vector<DataElement> infos; | 314 std::vector<DataElement> infos; |
315 BlobAsyncTransportRequestBuilder strategy; | 315 BlobTransportRequestBuilder strategy; |
316 BlobDataBuilder builder(kNewUUID); | 316 BlobDataBuilder builder(kNewUUID); |
317 AddShortcutMemoryItem(10, &infos); // should have no behavior change | 317 AddShortcutMemoryItem(10, &infos); // should have no behavior change |
318 AddBlobItem(&infos); | 318 AddBlobItem(&infos); |
319 AddMemoryItem(80, &infos); | 319 AddMemoryItem(80, &infos); |
320 | 320 |
321 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size | 321 strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
322 90, // total_blob_size | 322 90, // total_blob_size |
323 infos, &builder); | 323 infos, &builder); |
324 | 324 |
325 EXPECT_EQ(0u, strategy.file_sizes().size()); | 325 EXPECT_EQ(0u, strategy.file_sizes().size()); |
(...skipping 15 matching lines...) Expand all Loading... |
341 // We still populate future data, as the strategy assumes we will be | 341 // We still populate future data, as the strategy assumes we will be |
342 // requesting the data. | 342 // requesting the data. |
343 BlobDataBuilder expected_builder(kNewUUID); | 343 BlobDataBuilder expected_builder(kNewUUID); |
344 expected_builder.AppendFutureData(10); | 344 expected_builder.AppendFutureData(10); |
345 expected_builder.AppendBlob(kFakeBlobUUID); | 345 expected_builder.AppendBlob(kFakeBlobUUID); |
346 expected_builder.AppendFutureData(80); | 346 expected_builder.AppendFutureData(80); |
347 EXPECT_EQ(expected_builder, builder); | 347 EXPECT_EQ(expected_builder, builder); |
348 } | 348 } |
349 } // namespace | 349 } // namespace |
350 } // namespace storage | 350 } // namespace storage |
OLD | NEW |