Blob Consolidation & Registry Hookup

content/child/blob_storage/blob_consolidation_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 "content/child/blob_storage/blob_consolidation.h"
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ReadStatus = content::BlobConsolidation::ReadStatus;
+using storage::DataElement;
+
+namespace content {
+namespace {
+
+static blink::WebThreadSafeData CreateData(const std::string& str) {
+  char* data = new char[str.size()];

[michaeln, 2015/06/17 03:17:55]

Is the extra heap allocation needed? Does WebThreadSafeData(str.data(),
str.size()) not work?

It looks like |data| is leaked.

[dmurph, 2015/06/17 18:29:51]

Ah, yeah, you're right.  This was from a previous version that grabbed ownership
of the pointer.

+  memcpy(data, str.c_str(), str.size());
+  return blink::WebThreadSafeData(data, str.size());
+}
+
+TEST(BlobConsolidationTest, TestSegmentation) {
+  BlobConsolidation consolidation;
+  consolidation.AddDataItem(CreateData("12345"));
+  EXPECT_EQ(5lu, consolidation.total_memory());
+
+  const auto& items = consolidation.consolidated_items();
+  EXPECT_EQ(1lu, items.size());
+  EXPECT_EQ(5lu, items[0].length);
+  EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type);
+  EXPECT_EQ(0lu, items[0].offset);
+
+  char memory[] = {'E'};
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 1, memory));
+  EXPECT_EQ('1', memory[0]);
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 1, 1, memory));
+  EXPECT_EQ('2', memory[0]);
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 1, memory));
+  EXPECT_EQ('3', memory[0]);
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 3, 1, memory));
+  EXPECT_EQ('4', memory[0]);
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 4, 1, memory));
+  EXPECT_EQ('5', memory[0]);
+}
+
+TEST(BlobConsolidationTest, TestConsolidation) {
+  BlobConsolidation consolidation;
+  consolidation.AddDataItem(CreateData("1"));
+  consolidation.AddDataItem(CreateData("23"));
+  consolidation.AddDataItem(CreateData("4"));
+  EXPECT_EQ(4lu, consolidation.total_memory());
+
+  const auto& items = consolidation.consolidated_items();
+  EXPECT_EQ(1lu, items.size());
+  EXPECT_EQ(4lu, items[0].length);
+  EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type);
+  EXPECT_EQ(0lu, items[0].offset);
+
+  char memory[4];
+  EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS,
+            consolidation.ReadMemory(0, 0, 5, memory));
+  EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS,
+            consolidation.ReadMemory(1, 0, 4, memory));
+  EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS,
+            consolidation.ReadMemory(0, 1, 4, memory));
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 4, memory));
+
+  char expected_memory[] = {'1', '2', '3', '4'};
+  EXPECT_THAT(memory, testing::ElementsAreArray(expected_memory));
+}
+
+TEST(BlobConsolidationTest, TestAccounting) {
+  BlobConsolidation consolidation;
+  consolidation.AddDataItem(CreateData("1"));
+  consolidation.AddDataItem(CreateData("23"));
+  consolidation.AddFileItem("testPath", 1, 10, 5.0);
+  consolidation.AddDataItem(CreateData("4"));
+  EXPECT_EQ(4lu, consolidation.total_memory());
+
+  EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5));
+  EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE, consolidation.RecordMemoryRead(1, 4));
+  EXPECT_EQ(ReadStatus::ERROR_OUT_OF_BOUNDS,
+            consolidation.RecordMemoryRead(3, 4));
+  EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING,
+            consolidation.RecordMemoryRead(0, 3));
+  EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(2, 1));
+  EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(2, 1));
+}
+
+TEST(BlobConsolidationTest, TestMassiveConsolidation) {
+  BlobConsolidation consolidation;
+  static const size_t NUM_PARTS = 300;

[michaeln, 2015/06/17 03:17:55]

I think our style guide prefer we name constants like this kSomething and use
THIS_STYLE for enumerated values. Is there any value to making these static?

[dmurph, 2015/06/17 18:29:51]

no value, they're global constants, so why not?

+  static const size_t PART_SIZE = 5;
+  static const size_t TOTAL_MEMORY = NUM_PARTS * PART_SIZE;
+  static const size_t SEGMENT_SIZE = 6;  // Must be factor of TOTAL_MEMORY
+  static const size_t NUM_SEGMENTS = TOTAL_MEMORY / SEGMENT_SIZE;

[michaeln, 2015/06/17 03:17:55]

maybe move these kSegmentSize and kNumSegments down to right above where they're
used to in the loop to read

[dmurph, 2015/06/17 18:29:51]

do you mind if I keep all of the constants in one spot? I made the name a bit
more specific.

+
+  char current_value = 0;
+  for (size_t i = 0; i < NUM_PARTS; i++) {
+    char* data = new char[PART_SIZE];

[michaeln, 2015/06/17 03:17:55]

looks like |data| is leaked here too

[dmurph, 2015/06/17 18:29:51]

thanks, fixed.

+    for (size_t j = 0; j < PART_SIZE; j++) {
+      data[j] = current_value;
+      ++current_value;
+    }
+    consolidation.AddDataItem(blink::WebThreadSafeData(data, PART_SIZE));
+  }
+  EXPECT_EQ(TOTAL_MEMORY, consolidation.total_memory());
+
+  const auto& items = consolidation.consolidated_items();
+  EXPECT_EQ(1lu, items.size());
+  EXPECT_EQ(TOTAL_MEMORY, items[0].length);
+
+  char expected_value = 0;
+  char read_buffer[SEGMENT_SIZE];
+  for (size_t i = 0; i < NUM_SEGMENTS; i++) {
+    EXPECT_EQ(ReadStatus::DONE,
+              consolidation.ReadMemory(0, i * SEGMENT_SIZE, SEGMENT_SIZE,
+                                       read_buffer));
+    ReadStatus expected_status = i == NUM_SEGMENTS - 1
+                                     ? ReadStatus::DONE
+                                     : ReadStatus::BLOB_BYTES_PENDING;
+    EXPECT_EQ(expected_status, consolidation.RecordMemoryRead(0, SEGMENT_SIZE));
+    for (size_t j = 0; j < SEGMENT_SIZE; j++) {
+      EXPECT_EQ(expected_value, read_buffer[j]);
+      ++expected_value;
+    }
+  }
+}
+
+TEST(BlobConsolidationTest, TestPartialRead) {
+  BlobConsolidation consolidation;
+  consolidation.AddDataItem(CreateData("1"));
+  consolidation.AddDataItem(CreateData("23"));
+  consolidation.AddDataItem(CreateData("45"));
+  EXPECT_EQ(5lu, consolidation.total_memory());
+
+  const auto& items = consolidation.consolidated_items();
+  EXPECT_EQ(1lu, items.size());
+  EXPECT_EQ(5lu, items[0].length);
+  EXPECT_EQ(0lu, items[0].offset);
+
+  char memory_part1[] = {'X', 'X'};
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 2, memory_part1));
+  char expected_memory_part1[] = {'1', '2'};
+  EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1));
+  EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING,
+            consolidation.RecordMemoryRead(0, 2));
+
+  EXPECT_EQ(ReadStatus::ERROR, consolidation.RecordMemoryRead(0, 5));
+
+  char memory_part2[] = {'X', 'X'};
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 2, 2, memory_part2));
+  char expected_memory_part2[] = {'3', '4'};
+  EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2));
+  EXPECT_EQ(ReadStatus::BLOB_BYTES_PENDING,
+            consolidation.RecordMemoryRead(0, 2));
+
+  char memory_part3[] = {'X'};
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 4, 1, memory_part3));
+  char expected_memory_part3[] = {'5'};
+  EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3));
+  EXPECT_EQ(ReadStatus::DONE, consolidation.RecordMemoryRead(0, 1));
+}
+
+TEST(BlobConsolidationTest, TestBoundaries) {
+  BlobConsolidation consolidation;
+  consolidation.AddDataItem(CreateData("1"));
+  consolidation.AddFileItem("testPath", 1, 10, 5.0);
+  consolidation.AddDataItem(CreateData("2"));
+  consolidation.AddDataItem(CreateData("3"));
+  consolidation.AddBlobItem("testUUID", 1, 2);
+  consolidation.AddDataItem(CreateData("45"));
+  EXPECT_EQ(5lu, consolidation.total_memory());
+
+  const auto& items = consolidation.consolidated_items();
+  EXPECT_EQ(5lu, items.size());
+
+  EXPECT_EQ(1lu, items[0].length);
+  EXPECT_EQ(DataElement::TYPE_BYTES, items[0].type);
+
+  EXPECT_EQ(10lu, items[1].length);
+  EXPECT_EQ(DataElement::TYPE_FILE, items[1].type);
+
+  EXPECT_EQ(2lu, items[2].length);
+  EXPECT_EQ(DataElement::TYPE_BYTES, items[2].type);
+
+  EXPECT_EQ(2lu, items[3].length);
+  EXPECT_EQ(DataElement::TYPE_BLOB, items[3].type);
+
+  EXPECT_EQ(2lu, items[4].length);
+  EXPECT_EQ(DataElement::TYPE_BYTES, items[4].type);
+
+  char test_memory[5];
+  EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE,
+            consolidation.ReadMemory(1, 0, 1, test_memory));
+  EXPECT_EQ(ReadStatus::ERROR_WRONG_TYPE,
+            consolidation.ReadMemory(3, 0, 1, test_memory));
+
+  char memory_part1[1];
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(0, 0, 1, memory_part1));
+  char expected_memory_part1[] = {'1'};
+  EXPECT_THAT(memory_part1, testing::ElementsAreArray(expected_memory_part1));
+
+  char memory_part2[2];
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(2, 0, 2, memory_part2));
+  char expected_memory_part2[] = {'2', '3'};
+  EXPECT_THAT(memory_part2, testing::ElementsAreArray(expected_memory_part2));
+
+  char memory_part3[2];
+  EXPECT_EQ(ReadStatus::DONE, consolidation.ReadMemory(4, 0, 2, memory_part3));
+  char expected_memory_part3[] = {'4', '5'};
+  EXPECT_THAT(memory_part3, testing::ElementsAreArray(expected_memory_part3));
+}
+
+}  // namespace
+}  // namespace content