Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(719)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: content/browser/blob_storage/blob_async_transport_request_builder_unittest.cc

Issue 1234813004: [BlobAsync] Asynchronous Blob Construction Final Patch (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@blob-protocol-change
Patch Set: comments and rebase Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « content/browser/blob_storage/blob_async_builder_host_unittest.cc ('k') | content/browser/blob_storage/blob_async_transport_strategy_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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
« no previous file with comments | « content/browser/blob_storage/blob_async_builder_host_unittest.cc ('k') | content/browser/blob_storage/blob_async_transport_strategy_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698