[BlobAsync] Patch 4: Browser Classes & Logic.

content/browser/fileapi/blob_transport_strategy_unittest.cc

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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_transport_strategy.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace storage {
+namespace {
+
+class BlobTransportStrategyTest : public testing::Test {
+ public:
+  BlobTransportStrategyTest() {}
+  ~BlobTransportStrategyTest() override {}
+
+  void ClearInfos() { infos_.clear(); }
+
+  void AddMemoryInfo(size_t length) {
+    DataElement bytes;
+    bytes.SetToSharedBytes(nullptr, length);
+    infos_.push_back(bytes);
+  }
+
+  void AddBlobItem() {

[kinuko, 2015/05/25 08:32:02]

AddBlobInfo() of AddBlobItemInfo() to be consistent?

[dmurph, 2015/06/13 00:13:09]

Done.

+    DataElement blob;
+    blob.SetToBlob("fakeBlob");
+    infos_.push_back(blob);
+  }
+
+  std::vector<DataElement> infos_;

[kinuko, 2015/05/25 08:32:02]

I don't feel having this as a member variable really helpful?  Just plainly
working on std::vector<Element> in the test code would be probably more
straightforward.  For example

AddMemoryInfo(305);
strategy.Initialize(...., infos_);

Doesn't really tell readers about relationship between the 1st and 2nd lines,
while

std::vector<DataElement> infos;
AddMemoryInfo(305, &infos);
strategy.Initialize(...., infos);

could give a slightly better idea what's going on.

[dmurph, 2015/06/13 00:13:09]

Done.

+};
+
+TEST_F(BlobTransportStrategyTest, TestLargeBlockToFile) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(305);
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(1u, strategy.file_handles().size());
+  EXPECT_EQ(305ul, strategy.file_handles().at(0));
+  EXPECT_EQ(1u, strategy.requests().size());
+
+  auto& memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 305ull, 0u, 0ull),
+      memory_item_request.message);
+}
+
+TEST_F(BlobTransportStrategyTest, TestLargeBlockToFiles) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(1000);
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,

[kinuko, 2015/05/25 08:32:02]

nit: could we explicitly note about some important parameters that determine the
behavior in a comment, e.g. max_file_size == 400 and max_blob_in_memory_size ==
300 (< 1000)? (Here and below)

[dmurph, 2015/06/13 00:13:10]

Done.  Added variables names and better descriptions.

+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(3u, strategy.file_handles().size());
+  EXPECT_EQ(400ul, strategy.file_handles().at(0));
+  EXPECT_EQ(400ul, strategy.file_handles().at(1));
+  EXPECT_EQ(200ul, strategy.file_handles().at(2));
+  EXPECT_EQ(3u, strategy.requests().size());
+
+  auto memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 400ull, 0u, 0ull),
+      memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(1);
+  EXPECT_EQ(1u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(1u, 0u, 400ull, 400ull, 1u, 0ull),
+      memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(2);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(2u, 0u, 800ull, 200ull, 2u, 0ull),
+      memory_item_request.message);
+}
+
+TEST_F(BlobTransportStrategyTest, TestLargeBlocksConsolidatingInFiles) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(300);
+  AddBlobItem();
+  AddMemoryInfo(500);
+  // We should have 3 browser items, two files, 400 each.
+  // Browser items 1 and 2 refer to the first file, and browser item 3 is
+  // the second file.
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(2u, strategy.file_handles().size());
+  EXPECT_EQ(400ul, strategy.file_handles().at(0));
+  EXPECT_EQ(400ul, strategy.file_handles().at(1));
+  EXPECT_EQ(3u, strategy.requests().size());
+
+  auto memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(0u, 0u, 0ull, 300ull, 0u, 0ull),
+      memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(1);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(1u, 2u, 0ull, 100ull, 0u, 300ull),
+      memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(2);
+  EXPECT_EQ(3u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(
+      BlobItemBytesRequest::CreateFileRequest(2u, 2u, 100ull, 400ull, 1u, 0ull),
+      memory_item_request.message);
+}
+
+TEST_F(BlobTransportStrategyTest, TestSharedMemorySegmentation) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(500);
+  // For transport we should have 3 shared memories, and then storage in 3
+  // browser items.
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 300, 1000,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(3u, strategy.shared_memory_handles().size());
+  EXPECT_EQ(200u, strategy.shared_memory_handles().at(0));
+  EXPECT_EQ(200u, strategy.shared_memory_handles().at(1));
+  EXPECT_EQ(100u, strategy.shared_memory_handles().at(2));
+  EXPECT_EQ(3u, strategy.requests().size());
+
+  auto memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(0u, 0u, 0ull,
+                                                            200ull, 0u, 0ull),
+            memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(1);
+  EXPECT_EQ(1u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(1u, 0u, 200ull,
+                                                            200ull, 1u, 0ull),
+            memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(2);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(2u, 0u, 400ull,
+                                                            100ull, 2u, 0ull),
+            memory_item_request.message);
+}
+
+TEST_F(BlobTransportStrategyTest, TestSharedMemorySegmentationAndStorage) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(100);
+  AddBlobItem();
+  AddMemoryInfo(200);
+  // For transport, we should have 2 shared memories, where the first one
+  // have half 0 and half 3, and then the last one has half 3
+  //
+  // For storage, we should have 3 browser items that match the pre-transport
+  // version.
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 300, 1000,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(2u, strategy.shared_memory_handles().size());
+  EXPECT_EQ(200u, strategy.shared_memory_handles().at(0));
+  EXPECT_EQ(100u, strategy.shared_memory_handles().at(1));
+  EXPECT_EQ(3u, strategy.requests().size());
+
+  auto memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(0u, 0u, 0ull,
+                                                            100ull, 0u, 0ull),
+            memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(1);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(1u, 2u, 0ull,
+                                                            100ull, 0u, 100ull),
+            memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(2);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(100u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateSharedMemoryRequest(2u, 2u, 100ull,
+                                                            100ull, 1u, 0ull),
+            memory_item_request.message);
+}
+
+TEST_F(BlobTransportStrategyTest, TestTooLarge) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(5001);
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,
+                      5000, 100, infos_);
+
+  EXPECT_EQ(0u, strategy.file_handles().size());
+  EXPECT_EQ(0u, strategy.shared_memory_handles().size());
+  EXPECT_EQ(0u, strategy.requests().size());
+  EXPECT_EQ(BlobTransportStrategy::ERROR_TOO_LARGE, strategy.error());
+}
+
+TEST_F(BlobTransportStrategyTest, TestNoDisk) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(301);
+
+  strategy.Initialize(BlobTransportStrategy::MODE_NO_DISK, 100, 200, 400, 300,
+                      5000, 300, infos_);
+
+  EXPECT_EQ(0u, strategy.file_handles().size());
+  EXPECT_EQ(0u, strategy.shared_memory_handles().size());
+  EXPECT_EQ(0u, strategy.requests().size());
+  EXPECT_EQ(BlobTransportStrategy::ERROR_TOO_LARGE, strategy.error());
+}
+
+TEST_F(BlobTransportStrategyTest, TestNoDiskFits) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(301);
+
+  strategy.Initialize(BlobTransportStrategy::MODE_NO_DISK, 100, 200, 400, 300,
+                      5000, 301, infos_);
+
+  EXPECT_EQ(0u, strategy.file_handles().size());
+  EXPECT_EQ(2u, strategy.shared_memory_handles().size());
+  EXPECT_EQ(2u, strategy.requests().size());
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+}
+
+TEST_F(BlobTransportStrategyTest, TestIPC) {
+  BlobTransportStrategy strategy;
+
+  AddMemoryInfo(10);
+  AddBlobItem();
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(1u, strategy.requests().size());
+
+  auto memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull),
+            memory_item_request.message);
+
+  ClearInfos();
+  AddMemoryInfo(10);
+  AddBlobItem();
+  AddMemoryInfo(80);
+
+  strategy.Initialize(BlobTransportStrategy::MODE_DISK, 100, 200, 400, 300,
+                      5000, 100, infos_);
+  EXPECT_EQ(BlobTransportStrategy::ERROR_NONE, strategy.error());
+
+  EXPECT_EQ(2u, strategy.requests().size());
+
+  memory_item_request = strategy.requests().at(0);
+  EXPECT_EQ(0u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(0u, 0u, 0ull, 10ull),
+            memory_item_request.message);
+
+  memory_item_request = strategy.requests().at(1);
+  EXPECT_EQ(2u, memory_item_request.browser_item_index);
+  EXPECT_EQ(0u, memory_item_request.browser_item_offset);
+  EXPECT_EQ(BlobItemBytesRequest::CreateIPCRequest(1u, 2u, 0ull, 80ull),
+            memory_item_request.message);
+}
+
+}  // namespace
+}  // namespace storage