[BlobAsync] Patch 1: BlobStorageRegistry

content/browser/blob_storage/blob_storage_registry_unittest.cc

Index: content/browser/blob_storage/blob_storage_registry_unittest.cc
diff --git a/content/browser/blob_storage/blob_storage_registry_unittest.cc b/content/browser/blob_storage/blob_storage_registry_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..08b18b66c9d80aed81485259ddb8bcd4665103e0
--- /dev/null
+++ b/content/browser/blob_storage/blob_storage_registry_unittest.cc
@@ -0,0 +1,92 @@
+// 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_storage_registry.h"
+
+#include "base/callback.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace storage {
+namespace {
+using BlobRegistryEntry = BlobStorageRegistry::BlobRegistryEntry;
+using BlobState = BlobStorageRegistry::BlobState;
+
+TEST(BlobStorageRegistry, UUIDRegistration) {
+  const std::string kBlob1 = "Blob1";
+  BlobStorageRegistry registry;
+
+  EXPECT_FALSE(registry.IsUUIDRegistered(kBlob1));
+  EXPECT_FALSE(registry.RemoveBlobEntry(kBlob1));
+  EXPECT_EQ(0u, registry.blob_count());
+
+  BlobRegistryEntry* entry = registry.RegisterBlobUUID(kBlob1);
+  ASSERT_NE(nullptr, entry);
+  EXPECT_EQ(BlobState::RESERVED, entry->state);
+  EXPECT_EQ(BlobState::RESERVED, registry.GetBlobState(kBlob1));
+  EXPECT_EQ(1u, entry->refcount);
+  EXPECT_EQ(0, entry->flags);
+  EXPECT_FALSE(entry->data.get() || entry->data_builder.get());
+  EXPECT_EQ(0u, entry->construction_complete_callbacks.size());
+
+  EXPECT_TRUE(registry.IsUUIDRegistered(kBlob1));
+  EXPECT_EQ(nullptr, registry.RegisterBlobUUID(kBlob1));
+  EXPECT_EQ(entry, registry.GetBlobEntry(kBlob1));
+  EXPECT_TRUE(registry.RemoveBlobEntry(kBlob1));
+  entry = registry.RegisterBlobUUID(kBlob1);
+
+  EXPECT_TRUE(registry.TestAndSetState(kBlob1, BlobState::RESERVED,
+                                       BlobState::ASYNC_TRANSPORTATION));
+  EXPECT_FALSE(registry.TestAndSetState(kBlob1, BlobState::CONSTRUCTION,
+                                        BlobState::RESERVED));
+  EXPECT_FALSE(registry.TestAndSetState(kBlob1, BlobState::UNKNOWN,
+                                        BlobState::RESERVED));
+  EXPECT_TRUE(registry.TestAndSetState(kBlob1, BlobState::ASYNC_TRANSPORTATION,
+                                       BlobState::CONSTRUCTION));
+  EXPECT_EQ(BlobState::CONSTRUCTION, registry.GetBlobState(kBlob1));
+  EXPECT_EQ(1u, registry.blob_count());
+}
+
+TEST(BlobStorageRegistry, URLRegistration) {
+  const std::string kBlob = "Blob1";
+  const std::string kBlob2 = "Blob2";
+  const GURL kURL = GURL("blob://Blob1");
+  const GURL kURL2 = GURL("blob://Blob2");
+  BlobStorageRegistry registry;
+
+  EXPECT_FALSE(registry.IsURLMapped(kURL));
+  EXPECT_EQ(nullptr, registry.GetBlobEntryFromURL(kURL, nullptr));
+  EXPECT_FALSE(registry.RemoveURLMapping(kURL, nullptr));
+  EXPECT_FALSE(registry.RegisterURLMapping(kURL, kBlob));
+  EXPECT_EQ(0u, registry.url_count());
+  BlobRegistryEntry* entry = registry.RegisterBlobUUID(kBlob);

[kinuko, 2015/08/14 10:12:18]

nit: I'd put empty line before line 63 rather than after line 63, to make it
clearer that the block l.58-62 is testing initial state before registering
anything

+
+  EXPECT_FALSE(registry.IsURLMapped(kURL));
+  EXPECT_TRUE(registry.RegisterURLMapping(kURL, kBlob));
+  EXPECT_FALSE(registry.RegisterURLMapping(kURL, kBlob2));
+
+  EXPECT_TRUE(registry.IsURLMapped(kURL));
+  EXPECT_EQ(entry, registry.GetBlobEntryFromURL(kURL, nullptr));
+  std::string uuid;
+  EXPECT_EQ(entry, registry.GetBlobEntryFromURL(kURL, &uuid));
+  EXPECT_EQ(kBlob, uuid);
+  EXPECT_EQ(1u, registry.url_count());
+
+  registry.RegisterBlobUUID(kBlob2);
+  EXPECT_TRUE(registry.RegisterURLMapping(kURL2, kBlob2));

[kinuko, 2015/08/14 10:12:18]

nit: test registry.IsURLMapped(kURL2) here for completeness

+  EXPECT_EQ(2u, registry.url_count());
+  EXPECT_TRUE(registry.RemoveURLMapping(kURL2, &uuid));
+  EXPECT_EQ(kBlob2, uuid);
+  EXPECT_FALSE(registry.IsURLMapped(kURL2));
+
+  // Both urls point to the same blob.
+  EXPECT_TRUE(registry.RegisterURLMapping(kURL2, kBlob));
+  std::string uuid2;
+  EXPECT_EQ(registry.GetBlobEntryFromURL(kURL, &uuid),
+            registry.GetBlobEntryFromURL(kURL2, &uuid2));
+  EXPECT_EQ(uuid, uuid2);
+}
+
+}  // namespace
+}  // namespace storage