[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() {
+    DataElement blob;
+    blob.SetToBlob("fakeBlob");
+    infos_.push_back(blob);
+  }
+
+  std::vector<DataElement> infos_;
+};
+
+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,
+                      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