Index: content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc |
diff --git a/content/browser/blob_storage/blob_async_transport_strategy_unittest.cc b/content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc |
similarity index 49% |
rename from content/browser/blob_storage/blob_async_transport_strategy_unittest.cc |
rename to content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc |
index 6318439e91609f865143b939d634d5fbcf0f8156..071a06bb23f97d2f893dc0237644a95f9b7ffa01 100644 |
--- a/content/browser/blob_storage/blob_async_transport_strategy_unittest.cc |
+++ b/content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc |
@@ -2,14 +2,13 @@ |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
-#include "storage/browser/blob/blob_async_transport_strategy.h" |
- |
#include <stddef.h> |
#include <stdint.h> |
#include <string> |
#include "base/logging.h" |
+#include "storage/browser/blob/blob_async_transport_request_builder.h" |
#include "testing/gtest/include/gtest/gtest.h" |
namespace storage { |
@@ -41,51 +40,43 @@ void AddBlobItem(std::vector<DataElement>* out) { |
out->push_back(blob); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestNoMemoryItems) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, TestNoMemoryItems) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
// Here we test that we don't do any requests when there are no memory items. |
AddBlobItem(&infos); |
AddBlobItem(&infos); |
AddBlobItem(&infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_available |
- kNewUUID, infos); |
- |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
+ strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
+ 0, // blob_total_size |
+ infos, &builder); |
- EXPECT_EQ(0u, strategy.handle_sizes().size()); |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(0u, strategy.file_sizes().size()); |
EXPECT_EQ(0u, strategy.requests().size()); |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendBlob(kFakeBlobUUID); |
- builder.AppendBlob(kFakeBlobUUID); |
- builder.AppendBlob(kFakeBlobUUID); |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendBlob(kFakeBlobUUID); |
+ expected_builder.AppendBlob(kFakeBlobUUID); |
+ expected_builder.AppendBlob(kFakeBlobUUID); |
+ EXPECT_EQ(expected_builder, builder); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFile) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFile) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
- // Here we test our size > max_blob_in_memory_size (100), |
- // and we save to one file. (size < max_file_size) |
AddMemoryItem(305, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_available |
- kNewUUID, infos); |
- |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
+ strategy.InitializeForFileRequests(400, // max_file_size |
+ 305, // blob_total_size |
+ infos, &builder); |
- EXPECT_EQ(1u, strategy.handle_sizes().size()); |
- EXPECT_EQ(305ul, strategy.handle_sizes().at(0)); |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(1u, strategy.file_sizes().size()); |
+ EXPECT_EQ(305ul, strategy.file_sizes().at(0)); |
EXPECT_EQ(1u, strategy.requests().size()); |
auto& memory_item_request = strategy.requests().at(0); |
@@ -95,31 +86,27 @@ TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFile) { |
BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull), |
memory_item_request.message); |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendFile(kFuturePopulatingFilePath, 0, 305, |
- base::Time::FromDoubleT(0)); |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 305, |
+ base::Time::FromDoubleT(0)); |
+ EXPECT_EQ(expected_builder, builder); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFiles) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, TestLargeBlockToFiles) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
- // Here we test our size > max_blob_in_memory_size (300), |
- // and we save 3 files. (size > max_file_size) |
AddMemoryItem(1000, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_available |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
- |
- EXPECT_EQ(3u, strategy.handle_sizes().size()); |
- EXPECT_EQ(400ul, strategy.handle_sizes().at(0)); |
- EXPECT_EQ(400ul, strategy.handle_sizes().at(1)); |
- EXPECT_EQ(200ul, strategy.handle_sizes().at(2)); |
+ strategy.InitializeForFileRequests(400, // max_file_size |
+ 1000, // blob_total_size |
+ infos, &builder); |
+ |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(3u, strategy.file_sizes().size()); |
+ EXPECT_EQ(400ul, strategy.file_sizes().at(0)); |
+ EXPECT_EQ(400ul, strategy.file_sizes().at(1)); |
+ EXPECT_EQ(200ul, strategy.file_sizes().at(2)); |
EXPECT_EQ(3u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -143,18 +130,20 @@ TEST(BlobAsyncTransportStrategyTest, TestLargeBlockToFiles) { |
BlobItemBytesRequest::CreateFileRequest(2u, 0u, 800ull, 200ull, 2u, 0ull), |
memory_item_request.message); |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendFile(kFuturePopulatingFilePath, 0, 400, |
- base::Time::FromDoubleT(0)); |
- builder.AppendFile(kFuturePopulatingFilePath, 0, 400, |
- base::Time::FromDoubleT(0)); |
- builder.AppendFile(kFuturePopulatingFilePath, 0, 200, |
- base::Time::FromDoubleT(0)); |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 400, |
+ base::Time::FromDoubleT(0)); |
+ expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 400, |
+ base::Time::FromDoubleT(0)); |
+ expected_builder.AppendFile(kFuturePopulatingFilePath, 0, 200, |
+ base::Time::FromDoubleT(0)); |
+ EXPECT_EQ(expected_builder, builder); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestLargeBlocksConsolidatingInFiles) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, |
+ TestLargeBlocksConsolidatingInFiles) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
// We should have 3 storage items for the memory, two files, 400 each. |
@@ -167,17 +156,14 @@ TEST(BlobAsyncTransportStrategyTest, TestLargeBlocksConsolidatingInFiles) { |
AddBlobItem(&infos); |
AddMemoryItem(500, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_available |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
- |
- EXPECT_EQ(2u, strategy.handle_sizes().size()); |
- EXPECT_EQ(400ul, strategy.handle_sizes().at(0)); |
- EXPECT_EQ(400ul, strategy.handle_sizes().at(1)); |
+ strategy.InitializeForFileRequests(400, // max_file_size |
+ 800, // blob_total_size |
+ infos, &builder); |
+ |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(2u, strategy.file_sizes().size()); |
+ EXPECT_EQ(400ul, strategy.file_sizes().at(0)); |
+ EXPECT_EQ(400ul, strategy.file_sizes().at(1)); |
EXPECT_EQ(3u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -202,26 +188,23 @@ TEST(BlobAsyncTransportStrategyTest, TestLargeBlocksConsolidatingInFiles) { |
memory_item_request.message); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentation) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, TestSharedMemorySegmentation) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
// For transport we should have 3 shared memories, and then storage in 3 |
// browser items. |
- // (size > max_shared_memory_size and size < max_blob_in_memory_size |
AddMemoryItem(500, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 300, // max_file_size |
- 5000, // disk_space_left |
- 500, // memory_available |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
- |
- EXPECT_EQ(3u, strategy.handle_sizes().size()); |
- EXPECT_EQ(200u, strategy.handle_sizes().at(0)); |
- EXPECT_EQ(200u, strategy.handle_sizes().at(1)); |
- EXPECT_EQ(100u, strategy.handle_sizes().at(2)); |
+ strategy.InitializeForSharedMemoryRequests(200, // max_shared_memory_size |
+ 500, // total_blob_size |
+ infos, &builder); |
+ |
+ EXPECT_EQ(0u, strategy.file_sizes().size()); |
+ EXPECT_EQ(3u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(200u, strategy.shared_memory_sizes().at(0)); |
+ EXPECT_EQ(200u, strategy.shared_memory_sizes().at(1)); |
+ EXPECT_EQ(100u, strategy.shared_memory_sizes().at(2)); |
EXPECT_EQ(3u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -245,16 +228,17 @@ TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentation) { |
100ull, 2u, 0ull), |
memory_item_request.message); |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendFutureData(200); |
- builder.AppendFutureData(200); |
- builder.AppendFutureData(100); |
- |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendFutureData(200); |
+ expected_builder.AppendFutureData(200); |
+ expected_builder.AppendFutureData(100); |
+ EXPECT_EQ(expected_builder, builder); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentationAndStorage) { |
- BlobAsyncTransportStrategy strategy; |
+TEST(BlobAsyncTransportRequestBuilderTest, |
+ TestSharedMemorySegmentationAndStorage) { |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
std::vector<DataElement> infos; |
// For transport, we should have 2 shared memories, where the first one |
@@ -269,17 +253,14 @@ TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentationAndStorage) { |
AddBlobItem(&infos); |
AddMemoryItem(200, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 300, // max_file_size |
- 5000, // disk_space_left |
- 300, // memory_available |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
- |
- EXPECT_EQ(2u, strategy.handle_sizes().size()); |
- EXPECT_EQ(200u, strategy.handle_sizes().at(0)); |
- EXPECT_EQ(100u, strategy.handle_sizes().at(1)); |
+ strategy.InitializeForSharedMemoryRequests(200, // max_shared_memory_size |
+ 300, // total_blob_size |
+ infos, &builder); |
+ |
+ EXPECT_EQ(0u, strategy.file_sizes().size()); |
+ EXPECT_EQ(2u, strategy.shared_memory_sizes().size()); |
+ EXPECT_EQ(200u, strategy.shared_memory_sizes().at(0)); |
+ EXPECT_EQ(100u, strategy.shared_memory_sizes().at(1)); |
EXPECT_EQ(3u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -303,70 +284,28 @@ TEST(BlobAsyncTransportStrategyTest, TestSharedMemorySegmentationAndStorage) { |
100ull, 1u, 0ull), |
memory_item_request.message); |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendFutureData(100); |
- builder.AppendBlob(kFakeBlobUUID); |
- builder.AppendFutureData(200); |
- |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
-} |
- |
-TEST(BlobAsyncTransportStrategyTest, TestTooLarge) { |
- BlobAsyncTransportStrategy strategy; |
- std::vector<DataElement> infos; |
- |
- // Our item is too large for disk, so error out. |
- AddMemoryItem(5001, &infos); |
- |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_left |
- kNewUUID, infos); |
- |
- EXPECT_EQ(0u, strategy.handle_sizes().size()); |
- EXPECT_EQ(0u, strategy.handle_sizes().size()); |
- EXPECT_EQ(0u, strategy.requests().size()); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_TOO_LARGE, strategy.error()); |
-} |
- |
-TEST(BlobAsyncTransportStrategyTest, TestNoDisk) { |
- BlobAsyncTransportStrategy strategy; |
- std::vector<DataElement> infos; |
- |
- // Our item is too large for memory, and we are in no_disk mode (incognito) |
- AddMemoryItem(301, &infos); |
- |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 0, // disk_space_left |
- 300, // memory_available |
- kNewUUID, infos); |
- |
- EXPECT_EQ(0u, strategy.handle_sizes().size()); |
- EXPECT_EQ(0u, strategy.handle_sizes().size()); |
- EXPECT_EQ(0u, strategy.requests().size()); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_TOO_LARGE, strategy.error()); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendFutureData(100); |
+ expected_builder.AppendBlob(kFakeBlobUUID); |
+ expected_builder.AppendFutureData(200); |
+ EXPECT_EQ(expected_builder, builder); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestSimpleIPC) { |
+TEST(BlobAsyncTransportRequestBuilderTest, TestSimpleIPC) { |
// Test simple IPC strategy, where size < max_ipc_memory_size and we have |
// just one item. |
std::vector<DataElement> infos; |
- BlobAsyncTransportStrategy strategy; |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
AddMemoryItem(10, &infos); |
AddBlobItem(&infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_left |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
+ strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
+ 10, // total_blob_size |
+ infos, &builder); |
+ EXPECT_EQ(0u, strategy.file_sizes().size()); |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
ASSERT_EQ(1u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -376,23 +315,21 @@ TEST(BlobAsyncTransportStrategyTest, TestSimpleIPC) { |
memory_item_request.message); |
} |
-TEST(BlobAsyncTransportStrategyTest, TestMultipleIPC) { |
+TEST(BlobAsyncTransportRequestBuilderTest, TestMultipleIPC) { |
// Same as above, but with 2 items and a blob in-between. |
std::vector<DataElement> infos; |
- BlobAsyncTransportStrategy strategy; |
- infos.clear(); |
+ BlobAsyncTransportRequestBuilder strategy; |
+ BlobDataBuilder builder(kNewUUID); |
AddShortcutMemoryItem(10, &infos); // should have no behavior change |
AddBlobItem(&infos); |
AddMemoryItem(80, &infos); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_left |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_NONE, strategy.error()); |
+ strategy.InitializeForIPCRequests(100, // max_ipc_memory_size |
+ 90, // total_blob_size |
+ infos, &builder); |
+ EXPECT_EQ(0u, strategy.file_sizes().size()); |
+ EXPECT_EQ(0u, strategy.shared_memory_sizes().size()); |
ASSERT_EQ(2u, strategy.requests().size()); |
auto memory_item_request = strategy.requests().at(0); |
@@ -409,50 +346,11 @@ TEST(BlobAsyncTransportStrategyTest, TestMultipleIPC) { |
// We still populate future data, as the strategy assumes we will be |
// requesting the data. |
- BlobDataBuilder builder(kNewUUID); |
- builder.AppendFutureData(10); |
- builder.AppendBlob(kFakeBlobUUID); |
- builder.AppendFutureData(80); |
- |
- EXPECT_EQ(builder, *strategy.blob_builder()); |
-} |
- |
-TEST(BlobAsyncTransportStrategyTest, Shortcut) { |
- std::vector<DataElement> infos; |
- AddMemoryItem(100, &infos); |
- AddBlobItem(&infos); |
- EXPECT_FALSE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 200)); |
- |
- infos.clear(); |
- AddShortcutMemoryItem(100, &infos); |
- AddBlobItem(&infos); |
- EXPECT_TRUE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 200)); |
- |
- infos.clear(); |
- AddShortcutMemoryItem(100, &infos); |
- EXPECT_FALSE(BlobAsyncTransportStrategy::ShouldBeShortcut(infos, 99)); |
+ BlobDataBuilder expected_builder(kNewUUID); |
+ expected_builder.AppendFutureData(10); |
+ expected_builder.AppendBlob(kFakeBlobUUID); |
+ expected_builder.AppendFutureData(80); |
+ EXPECT_EQ(expected_builder, builder); |
} |
} // namespace |
- |
-TEST(BlobAsyncTransportStrategyTest, TestInvalidParams) { |
- std::vector<DataElement> infos; |
- // In order to test uin64_t overflow, we would need to have an array with more |
- // than size_t entries (for 32 byte stuff). So this would only happen if the |
- // IPC was malformed. We instead have to friend this test from DataElement so |
- // we can modify the length to be > size_t. |
- |
- // Test uint64_t overflow. |
- BlobAsyncTransportStrategy strategy; |
- AddMemoryItem(1, &infos); |
- AddMemoryItem(1, &infos); |
- infos.back().length_ = std::numeric_limits<uint64_t>::max(); |
- strategy.Initialize(100, // max_ipc_memory_size |
- 200, // max_shared_memory_size |
- 400, // max_file_size |
- 5000, // disk_space_left |
- 100, // memory_left |
- kNewUUID, infos); |
- EXPECT_EQ(BlobAsyncTransportStrategy::ERROR_INVALID_PARAMS, |
- strategy.error()); |
-} |
} // namespace storage |