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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 2788883003: Move storage test next to the file that it tests (Closed)
Patch Set: The actual move. Created 3 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 | « no previous file | content/test/BUILD.gn » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: content/browser/blob_storage/blob_storage_context_unittest.cc
diff --git a/content/browser/blob_storage/blob_storage_context_unittest.cc b/content/browser/blob_storage/blob_storage_context_unittest.cc
deleted file mode 100644
index 1c9637154ddf004e743e4f05781363c966520a99..0000000000000000000000000000000000000000
--- a/content/browser/blob_storage/blob_storage_context_unittest.cc
+++ /dev/null
@@ -1,898 +0,0 @@
-// Copyright 2014 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_context.h"
-
-#include <stdint.h>
-
-#include <limits>
-#include <memory>
-#include <string>
-
-#include "base/bind.h"
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/time/time.h"
-#include "content/browser/blob_storage/blob_dispatcher_host.h"
-#include "content/browser/blob_storage/chrome_blob_storage_context.h"
-#include "content/public/test/test_browser_context.h"
-#include "net/base/io_buffer.h"
-#include "net/base/test_completion_callback.h"
-#include "net/disk_cache/disk_cache.h"
-#include "storage/browser/blob/blob_data_builder.h"
-#include "storage/browser/blob/blob_data_handle.h"
-#include "storage/browser/blob/blob_data_item.h"
-#include "storage/browser/blob/blob_data_snapshot.h"
-#include "storage/browser/blob/blob_transport_host.h"
-#include "storage/common/blob_storage/blob_item_bytes_request.h"
-#include "storage/common/blob_storage/blob_item_bytes_response.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using RequestMemoryCallback = storage::BlobTransportHost::RequestMemoryCallback;
-using FileCreationInfo = storage::BlobMemoryController::FileCreationInfo;
-
-namespace storage {
-namespace {
-using base::TestSimpleTaskRunner;
-
-const int kTestDiskCacheStreamIndex = 0;
-
-const std::string kBlobStorageDirectory = "blob_storage";
-const size_t kTestBlobStorageIPCThresholdBytes = 20;
-const size_t kTestBlobStorageMaxSharedMemoryBytes = 50;
-
-const size_t kTestBlobStorageMaxBlobMemorySize = 400;
-const uint64_t kTestBlobStorageMaxDiskSpace = 4000;
-const uint64_t kTestBlobStorageMinFileSizeBytes = 10;
-const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
-
-// Our disk cache tests don't need a real data handle since the tests themselves
-// scope the disk cache and entries.
-class EmptyDataHandle : public storage::BlobDataBuilder::DataHandle {
- private:
- ~EmptyDataHandle() override {}
-};
-
-std::unique_ptr<disk_cache::Backend> CreateInMemoryDiskCache() {
- std::unique_ptr<disk_cache::Backend> cache;
- net::TestCompletionCallback callback;
- int rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
- net::CACHE_BACKEND_DEFAULT,
- base::FilePath(), 0,
- false, nullptr, nullptr, &cache,
- callback.callback());
- EXPECT_EQ(net::OK, callback.GetResult(rv));
-
- return cache;
-}
-
-disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache,
- const char* key,
- const std::string& data) {
- disk_cache::Entry* temp_entry = nullptr;
- net::TestCompletionCallback callback;
- int rv = cache->CreateEntry(key, &temp_entry, callback.callback());
- if (callback.GetResult(rv) != net::OK)
- return nullptr;
- disk_cache::ScopedEntryPtr entry(temp_entry);
-
- scoped_refptr<net::StringIOBuffer> iobuffer = new net::StringIOBuffer(data);
- rv = entry->WriteData(kTestDiskCacheStreamIndex, 0, iobuffer.get(),
- iobuffer->size(), callback.callback(), false);
- EXPECT_EQ(static_cast<int>(data.size()), callback.GetResult(rv));
- return entry;
-}
-
-void SaveBlobStatus(BlobStatus* status_ptr, BlobStatus status) {
- *status_ptr = status;
-}
-
-void SaveBlobStatusAndFiles(BlobStatus* status_ptr,
- std::vector<FileCreationInfo>* files_ptr,
- BlobStatus status,
- std::vector<FileCreationInfo> files) {
- EXPECT_FALSE(BlobStatusIsError(status));
- *status_ptr = status;
- for (FileCreationInfo& info : files) {
- files_ptr->push_back(std::move(info));
- }
-}
-
-void IncrementNumber(size_t* number, BlobStatus status) {
- EXPECT_EQ(BlobStatus::DONE, status);
- *number = *number + 1;
-}
-
-} // namespace
-
-class BlobStorageContextTest : public testing::Test {
- protected:
- BlobStorageContextTest() {}
- ~BlobStorageContextTest() override {}
-
- void SetUp() override {
- ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- context_ = base::MakeUnique<BlobStorageContext>();
- }
-
- void TearDown() override {
- base::RunLoop().RunUntilIdle();
- file_runner_->RunPendingTasks();
- ASSERT_TRUE(temp_dir_.Delete());
- }
-
- std::unique_ptr<BlobDataHandle> SetupBasicBlob(const std::string& id) {
- BlobDataBuilder builder(id);
- builder.AppendData("1", 1);
- builder.set_content_type("text/plain");
- return context_->AddFinishedBlob(builder);
- }
-
- void SetTestMemoryLimits() {
- BlobStorageLimits limits;
- limits.max_ipc_memory_size = kTestBlobStorageIPCThresholdBytes;
- limits.max_shared_memory_size = kTestBlobStorageMaxSharedMemoryBytes;
- limits.max_blob_in_memory_space = kTestBlobStorageMaxBlobMemorySize;
- limits.desired_max_disk_space = kTestBlobStorageMaxDiskSpace;
- limits.effective_max_disk_space = kTestBlobStorageMaxDiskSpace;
- limits.min_page_file_size = kTestBlobStorageMinFileSizeBytes;
- limits.max_file_size = kTestBlobStorageMaxFileSizeBytes;
- context_->mutable_memory_controller()->set_limits_for_testing(limits);
- }
-
- void IncrementRefCount(const std::string& uuid) {
- context_->IncrementBlobRefCount(uuid);
- }
-
- void DecrementRefCount(const std::string& uuid) {
- context_->DecrementBlobRefCount(uuid);
- }
-
- std::vector<FileCreationInfo> files_;
- base::ScopedTempDir temp_dir_;
- scoped_refptr<TestSimpleTaskRunner> file_runner_ = new TestSimpleTaskRunner();
-
- base::MessageLoop fake_io_message_loop_;
- std::unique_ptr<BlobStorageContext> context_;
-};
-
-TEST_F(BlobStorageContextTest, BuildBlobAsync) {
- const std::string kId("id");
- const size_t kSize = 10u;
- BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
-
- BlobDataBuilder builder(kId);
- builder.AppendFutureData(kSize);
- builder.set_content_type("text/plain");
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- std::unique_ptr<BlobDataHandle> handle = context_->BuildBlob(
- builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
- EXPECT_TRUE(handle->IsBeingBuilt())
- << static_cast<int>(handle->GetBlobStatus());
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, status);
-
- BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
- handle->RunOnConstructionComplete(
- base::Bind(&SaveBlobStatus, &construction_done));
-
- EXPECT_EQ(10u, context_->memory_controller().memory_usage());
-
- builder.PopulateFutureData(0, "abcdefghij", 0, 10u);
- context_->NotifyTransportComplete(kId);
-
- // Check we're done.
- EXPECT_EQ(BlobStatus::DONE, handle->GetBlobStatus());
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(BlobStatus::DONE, construction_done);
-
- EXPECT_EQ(builder, *handle->CreateSnapshot());
-
- handle.reset();
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
-}
-
-TEST_F(BlobStorageContextTest, BuildBlobAndCancel) {
- const std::string kId("id");
- const size_t kSize = 10u;
- BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
-
- BlobDataBuilder builder(kId);
- builder.AppendFutureData(kSize);
- builder.set_content_type("text/plain");
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- std::unique_ptr<BlobDataHandle> handle = context_->BuildBlob(
- builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
- EXPECT_TRUE(handle->IsBeingBuilt());
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, status);
- EXPECT_EQ(10u, context_->memory_controller().memory_usage());
-
- BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
- handle->RunOnConstructionComplete(
- base::Bind(&SaveBlobStatus, &construction_done));
-
- context_->CancelBuildingBlob(kId, BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT);
- EXPECT_TRUE(handle->IsBroken());
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
-
- // Check we're broken.
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done);
-}
-
-TEST_F(BlobStorageContextTest, CancelledReference) {
- const std::string kId1("id1");
- const std::string kId2("id2");
- const size_t kSize = 10u;
- BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
-
- // Start our first blob.
- BlobDataBuilder builder(kId1);
- builder.AppendFutureData(kSize);
- builder.set_content_type("text/plain");
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- std::unique_ptr<BlobDataHandle> handle = context_->BuildBlob(
- builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
- EXPECT_TRUE(handle->IsBeingBuilt());
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, status);
-
- BlobStatus construction_done = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
- handle->RunOnConstructionComplete(
- base::Bind(&SaveBlobStatus, &construction_done));
-
- EXPECT_EQ(10u, context_->memory_controller().memory_usage());
-
- // Create our second blob, which depends on the first.
- BlobDataBuilder builder2(kId2);
- builder2.AppendBlob(kId1);
- builder2.set_content_type("text/plain");
- std::unique_ptr<BlobDataHandle> handle2 = context_->BuildBlob(
- builder2, BlobStorageContext::TransportAllowedCallback());
- BlobStatus construction_done2 =
- BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
- handle->RunOnConstructionComplete(
- base::Bind(&SaveBlobStatus, &construction_done2));
- EXPECT_TRUE(handle2->IsBeingBuilt());
-
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
-
- // Cancel the first blob.
- context_->CancelBuildingBlob(kId1, BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT);
-
- base::RunLoop().RunUntilIdle();
- // Check we broke successfully.
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done);
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- EXPECT_TRUE(handle->IsBroken());
-
- // Check that it propagated.
- EXPECT_TRUE(handle2->IsBroken());
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, construction_done2);
- EXPECT_EQ(BlobStatus::ERR_SOURCE_DIED_IN_TRANSIT, handle->GetBlobStatus());
-}
-
-TEST_F(BlobStorageContextTest, IncorrectSlice) {
- const std::string kId1("id1");
- const std::string kId2("id2");
-
- std::unique_ptr<BlobDataHandle> handle = SetupBasicBlob(kId1);
-
- EXPECT_EQ(1lu, context_->memory_controller().memory_usage());
-
- BlobDataBuilder builder(kId2);
- builder.AppendBlob(kId1, 1, 10);
- std::unique_ptr<BlobDataHandle> handle2 = context_->BuildBlob(
- builder, BlobStorageContext::TransportAllowedCallback());
-
- EXPECT_TRUE(handle2->IsBroken());
- EXPECT_EQ(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS,
- handle2->GetBlobStatus());
-}
-
-TEST_F(BlobStorageContextTest, IncrementDecrementRef) {
- // Build up a basic blob.
- const std::string kId("id");
- std::unique_ptr<BlobDataHandle> blob_data_handle = SetupBasicBlob(kId);
-
- // Do an extra increment to keep it around after we kill the handle.
- IncrementRefCount(kId);
- IncrementRefCount(kId);
- DecrementRefCount(kId);
- blob_data_handle = context_->GetBlobDataFromUUID(kId);
- EXPECT_TRUE(blob_data_handle);
- blob_data_handle.reset();
- base::RunLoop().RunUntilIdle();
-
- EXPECT_TRUE(context_->registry().HasEntry(kId));
- DecrementRefCount(kId);
- EXPECT_FALSE(context_->registry().HasEntry(kId));
-
- // Make sure it goes away in the end.
- blob_data_handle = context_->GetBlobDataFromUUID(kId);
- EXPECT_FALSE(blob_data_handle);
-}
-
-TEST_F(BlobStorageContextTest, BlobDataHandle) {
- // Build up a basic blob.
- const std::string kId("id");
- std::unique_ptr<BlobDataHandle> blob_data_handle = SetupBasicBlob(kId);
- EXPECT_TRUE(blob_data_handle);
-
- // Get another handle
- std::unique_ptr<BlobDataHandle> another_handle =
- context_->GetBlobDataFromUUID(kId);
- EXPECT_TRUE(another_handle);
-
- // Should disappear after dropping both handles.
- blob_data_handle.reset();
- base::RunLoop().RunUntilIdle();
-
- EXPECT_TRUE(context_->registry().HasEntry(kId));
-
- another_handle.reset();
- base::RunLoop().RunUntilIdle();
-
- blob_data_handle = context_->GetBlobDataFromUUID(kId);
- EXPECT_FALSE(blob_data_handle);
-}
-
-TEST_F(BlobStorageContextTest, MemoryUsage) {
- const std::string kId1("id1");
- const std::string kId2("id2");
-
- BlobDataBuilder builder1(kId1);
- BlobDataBuilder builder2(kId2);
- builder1.AppendData("Data1Data2");
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
- builder2.AppendBlob(kId1);
-
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
-
- std::unique_ptr<BlobDataHandle> blob_data_handle =
- context_->AddFinishedBlob(&builder1);
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
- std::unique_ptr<BlobDataHandle> blob_data_handle2 =
- context_->AddFinishedBlob(&builder2);
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
-
- EXPECT_EQ(2u, context_->registry().blob_count());
-
- blob_data_handle.reset();
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(10lu, context_->memory_controller().memory_usage());
- EXPECT_EQ(1u, context_->registry().blob_count());
- blob_data_handle2.reset();
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- EXPECT_EQ(0u, context_->registry().blob_count());
-}
-
-TEST_F(BlobStorageContextTest, AddFinishedBlob) {
- const std::string kId1("id1");
- const std::string kId2("id12");
- const std::string kId3("id3");
-
- BlobDataBuilder builder1(kId1);
- BlobDataBuilder builder2(kId2);
- BlobDataBuilder canonicalized_blob_data2(kId2);
- builder1.AppendData("Data1Data2");
- builder2.AppendBlob(kId1, 5, 5);
- builder2.AppendData(" is the best");
- canonicalized_blob_data2.AppendData("Data2");
- canonicalized_blob_data2.AppendData(" is the best");
-
- BlobStorageContext context;
-
- std::unique_ptr<BlobDataHandle> blob_data_handle =
- context_->AddFinishedBlob(&builder1);
- std::unique_ptr<BlobDataHandle> blob_data_handle2 =
- context_->AddFinishedBlob(&builder2);
-
- EXPECT_EQ(10u + 12u + 5u, context_->memory_controller().memory_usage());
-
- ASSERT_TRUE(blob_data_handle);
- ASSERT_TRUE(blob_data_handle2);
- std::unique_ptr<BlobDataSnapshot> data1 = blob_data_handle->CreateSnapshot();
- std::unique_ptr<BlobDataSnapshot> data2 = blob_data_handle2->CreateSnapshot();
- EXPECT_EQ(*data1, builder1);
- EXPECT_EQ(*data2, canonicalized_blob_data2);
- blob_data_handle.reset();
- data2.reset();
-
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(12u + 5u, context_->memory_controller().memory_usage());
-
- blob_data_handle = context_->GetBlobDataFromUUID(kId1);
- EXPECT_FALSE(blob_data_handle);
- EXPECT_TRUE(blob_data_handle2);
- data2 = blob_data_handle2->CreateSnapshot();
- EXPECT_EQ(*data2, canonicalized_blob_data2);
-
- // Test shared elements stick around.
- BlobDataBuilder builder3(kId3);
- builder3.AppendBlob(kId2);
- builder3.AppendBlob(kId2);
- std::unique_ptr<BlobDataHandle> blob_data_handle3 =
- context_->AddFinishedBlob(&builder3);
- EXPECT_FALSE(blob_data_handle3->IsBeingBuilt());
- blob_data_handle2.reset();
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(12u + 5u, context_->memory_controller().memory_usage());
-
- blob_data_handle2 = context_->GetBlobDataFromUUID(kId2);
- EXPECT_FALSE(blob_data_handle2);
- EXPECT_TRUE(blob_data_handle3);
- std::unique_ptr<BlobDataSnapshot> data3 = blob_data_handle3->CreateSnapshot();
-
- BlobDataBuilder canonicalized_blob_data3(kId3);
- canonicalized_blob_data3.AppendData("Data2");
- canonicalized_blob_data3.AppendData(" is the best");
- canonicalized_blob_data3.AppendData("Data2");
- canonicalized_blob_data3.AppendData(" is the best");
- EXPECT_EQ(*data3, canonicalized_blob_data3);
-
- blob_data_handle.reset();
- blob_data_handle2.reset();
- blob_data_handle3.reset();
- base::RunLoop().RunUntilIdle();
-}
-
-TEST_F(BlobStorageContextTest, AddFinishedBlob_LargeOffset) {
- // A value which does not fit in a 4-byte data type. Used to confirm that
- // large values are supported on 32-bit Chromium builds. Regression test for:
- // crbug.com/458122.
- const uint64_t kLargeSize = std::numeric_limits<uint64_t>::max() - 1;
-
- const uint64_t kBlobLength = 5;
- const std::string kId1("id1");
- const std::string kId2("id2");
-
- BlobDataBuilder builder1(kId1);
- builder1.AppendFileSystemFile(GURL(), 0, kLargeSize, base::Time::Now());
-
- BlobDataBuilder builder2(kId2);
- builder2.AppendBlob(kId1, kLargeSize - kBlobLength, kBlobLength);
-
- std::unique_ptr<BlobDataHandle> blob_data_handle1 =
- context_->AddFinishedBlob(&builder1);
- std::unique_ptr<BlobDataHandle> blob_data_handle2 =
- context_->AddFinishedBlob(&builder2);
-
- ASSERT_TRUE(blob_data_handle1);
- ASSERT_TRUE(blob_data_handle2);
- std::unique_ptr<BlobDataSnapshot> data = blob_data_handle2->CreateSnapshot();
- ASSERT_EQ(1u, data->items().size());
- const scoped_refptr<BlobDataItem> item = data->items()[0];
- EXPECT_EQ(kLargeSize - kBlobLength, item->offset());
- EXPECT_EQ(kBlobLength, item->length());
-
- blob_data_handle1.reset();
- blob_data_handle2.reset();
- base::RunLoop().RunUntilIdle();
-}
-
-TEST_F(BlobStorageContextTest, BuildDiskCacheBlob) {
- scoped_refptr<BlobDataBuilder::DataHandle>
- data_handle = new EmptyDataHandle();
-
- {
- BlobStorageContext context;
-
- std::unique_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
- ASSERT_TRUE(cache);
-
- const std::string kTestBlobData = "Test Blob Data";
- disk_cache::ScopedEntryPtr entry =
- CreateDiskCacheEntry(cache.get(), "test entry", kTestBlobData);
-
- const std::string kId1Prime("id1.prime");
- BlobDataBuilder canonicalized_blob_data(kId1Prime);
- canonicalized_blob_data.AppendData(kTestBlobData.c_str());
-
- const std::string kId1("id1");
- BlobDataBuilder builder(kId1);
-
- builder.AppendDiskCacheEntry(
- data_handle, entry.get(), kTestDiskCacheStreamIndex);
-
- std::unique_ptr<BlobDataHandle> blob_data_handle =
- context.AddFinishedBlob(&builder);
- std::unique_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
- EXPECT_EQ(*data, builder);
- EXPECT_FALSE(data_handle->HasOneRef())
- << "Data handle was destructed while context and builder still exist.";
- }
- EXPECT_TRUE(data_handle->HasOneRef())
- << "Data handle was not destructed along with blob storage context.";
- base::RunLoop().RunUntilIdle();
-}
-
-TEST_F(BlobStorageContextTest, BuildFutureFileOnlyBlob) {
- const std::string kId1("id1");
- context_ =
- base::MakeUnique<BlobStorageContext>(temp_dir_.GetPath(), file_runner_);
- SetTestMemoryLimits();
-
- BlobDataBuilder builder(kId1);
- builder.set_content_type("text/plain");
- builder.AppendFutureFile(0, 10, 0);
-
- BlobStatus status = BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS;
- std::unique_ptr<BlobDataHandle> handle = context_->BuildBlob(
- builder, base::Bind(&SaveBlobStatusAndFiles, &status, &files_));
-
- size_t blobs_finished = 0;
- EXPECT_EQ(BlobStatus::PENDING_QUOTA, handle->GetBlobStatus());
- EXPECT_EQ(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS, status);
- handle->RunOnConstructionComplete(
- base::Bind(&IncrementNumber, &blobs_finished));
- EXPECT_EQ(0u, blobs_finished);
-
- EXPECT_TRUE(file_runner_->HasPendingTask());
- file_runner_->RunPendingTasks();
- EXPECT_EQ(0u, blobs_finished);
- EXPECT_EQ(BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS, status);
- EXPECT_EQ(BlobStatus::PENDING_QUOTA, handle->GetBlobStatus());
- base::RunLoop().RunUntilIdle();
-
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, status);
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, handle->GetBlobStatus());
- EXPECT_EQ(0u, blobs_finished);
-
- ASSERT_EQ(1u, files_.size());
-
- builder.PopulateFutureFile(0, files_[0].file_reference, base::Time::Max());
- context_->NotifyTransportComplete(kId1);
-
- EXPECT_EQ(BlobStatus::DONE, handle->GetBlobStatus());
- EXPECT_EQ(0u, blobs_finished);
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(1u, blobs_finished);
-
- builder.Clear();
- handle.reset();
- files_.clear();
- base::RunLoop().RunUntilIdle();
- // We should have file cleanup tasks.
- EXPECT_TRUE(file_runner_->HasPendingTask());
- file_runner_->RunPendingTasks();
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- EXPECT_EQ(0lu, context_->memory_controller().disk_usage());
-}
-
-TEST_F(BlobStorageContextTest, CompoundBlobs) {
- const std::string kId1("id1");
- const std::string kId2("id2");
- const std::string kId3("id3");
-
- // Setup a set of blob data for testing.
- base::Time time1, time2;
- ASSERT_TRUE(base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT", &time1));
- ASSERT_TRUE(base::Time::FromString("Mon, 14 Nov 1994, 11:30:49 GMT", &time2));
-
- BlobDataBuilder blob_data1(kId1);
- blob_data1.AppendData("Data1");
- blob_data1.AppendData("Data2");
- blob_data1.AppendFile(base::FilePath(FILE_PATH_LITERAL("File1.txt")), 10,
- 1024, time1);
-
- BlobDataBuilder blob_data2(kId2);
- blob_data2.AppendData("Data3");
- blob_data2.AppendBlob(kId1, 8, 100);
- blob_data2.AppendFile(base::FilePath(FILE_PATH_LITERAL("File2.txt")), 0, 20,
- time2);
-
- BlobDataBuilder blob_data3(kId3);
- blob_data3.AppendData("Data4");
- std::unique_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
- ASSERT_TRUE(cache);
- disk_cache::ScopedEntryPtr disk_cache_entry =
- CreateDiskCacheEntry(cache.get(), "another key", "Data5");
- blob_data3.AppendDiskCacheEntry(new EmptyDataHandle(), disk_cache_entry.get(),
- kTestDiskCacheStreamIndex);
-
- BlobDataBuilder canonicalized_blob_data2(kId2);
- canonicalized_blob_data2.AppendData("Data3");
- canonicalized_blob_data2.AppendData("a2___", 2);
- canonicalized_blob_data2.AppendFile(
- base::FilePath(FILE_PATH_LITERAL("File1.txt")), 10, 98, time1);
- canonicalized_blob_data2.AppendFile(
- base::FilePath(FILE_PATH_LITERAL("File2.txt")), 0, 20, time2);
-
- BlobStorageContext context;
- std::unique_ptr<BlobDataHandle> blob_data_handle;
-
- // Test a blob referring to only data and a file.
- blob_data_handle = context_->AddFinishedBlob(&blob_data1);
-
- ASSERT_TRUE(blob_data_handle);
- std::unique_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
- ASSERT_TRUE(blob_data_handle);
- EXPECT_EQ(*data, blob_data1);
-
- // Test a blob composed in part with another blob.
- blob_data_handle = context_->AddFinishedBlob(&blob_data2);
- data = blob_data_handle->CreateSnapshot();
- ASSERT_TRUE(blob_data_handle);
- ASSERT_TRUE(data);
- EXPECT_EQ(*data, canonicalized_blob_data2);
-
- // Test a blob referring to only data and a disk cache entry.
- blob_data_handle = context_->AddFinishedBlob(&blob_data3);
- data = blob_data_handle->CreateSnapshot();
- ASSERT_TRUE(blob_data_handle);
- EXPECT_EQ(*data, blob_data3);
-
- blob_data_handle.reset();
- base::RunLoop().RunUntilIdle();
-}
-
-TEST_F(BlobStorageContextTest, PublicBlobUrls) {
- // Build up a basic blob.
- const std::string kId("id");
- std::unique_ptr<BlobDataHandle> first_handle = SetupBasicBlob(kId);
-
- // Now register a url for that blob.
- GURL kUrl("blob:id");
- context_->RegisterPublicBlobURL(kUrl, kId);
- std::unique_ptr<BlobDataHandle> blob_data_handle =
- context_->GetBlobDataFromPublicURL(kUrl);
- ASSERT_TRUE(blob_data_handle.get());
- EXPECT_EQ(kId, blob_data_handle->uuid());
- std::unique_ptr<BlobDataSnapshot> data = blob_data_handle->CreateSnapshot();
- blob_data_handle.reset();
- first_handle.reset();
- base::RunLoop().RunUntilIdle();
-
- // The url registration should keep the blob alive even after
- // explicit references are dropped.
- blob_data_handle = context_->GetBlobDataFromPublicURL(kUrl);
- EXPECT_TRUE(blob_data_handle);
- blob_data_handle.reset();
-
- base::RunLoop().RunUntilIdle();
- // Finally get rid of the url registration and the blob.
- context_->RevokePublicBlobURL(kUrl);
- blob_data_handle = context_->GetBlobDataFromPublicURL(kUrl);
- EXPECT_FALSE(blob_data_handle.get());
- EXPECT_FALSE(context_->registry().HasEntry(kId));
-}
-
-TEST_F(BlobStorageContextTest, TestUnknownBrokenAndBuildingBlobReference) {
- const std::string kBrokenId("broken_id");
- const std::string kBuildingId("building_id");
- const std::string kReferencingId("referencing_id");
- const std::string kUnknownId("unknown_id");
-
- // Create a broken blob.
- std::unique_ptr<BlobDataHandle> broken_handle =
- context_->AddBrokenBlob(kBrokenId, "", "", BlobStatus::ERR_OUT_OF_MEMORY);
- EXPECT_TRUE(broken_handle->GetBlobStatus() == BlobStatus::ERR_OUT_OF_MEMORY);
- EXPECT_TRUE(context_->registry().HasEntry(kBrokenId));
-
- // Try to create a blob with a reference to an unknown blob.
- BlobDataBuilder builder(kReferencingId);
- builder.AppendData("data");
- builder.AppendBlob(kUnknownId);
- std::unique_ptr<BlobDataHandle> handle = context_->AddFinishedBlob(builder);
- EXPECT_TRUE(handle->IsBroken());
- EXPECT_TRUE(context_->registry().HasEntry(kReferencingId));
- handle.reset();
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(context_->registry().HasEntry(kReferencingId));
-
- // Try to create a blob with a reference to the broken blob.
- BlobDataBuilder builder2(kReferencingId);
- builder2.AppendData("data");
- builder2.AppendBlob(kBrokenId);
- handle = context_->AddFinishedBlob(builder2);
- EXPECT_TRUE(handle->IsBroken());
- EXPECT_TRUE(context_->registry().HasEntry(kReferencingId));
- handle.reset();
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(context_->registry().HasEntry(kReferencingId));
-
- // Try to create a blob with a reference to the building blob.
- BlobDataBuilder builder3(kReferencingId);
- builder3.AppendData("data");
- builder3.AppendBlob(kBuildingId);
- handle = context_->AddFinishedBlob(builder3);
- EXPECT_TRUE(handle->IsBroken());
- EXPECT_TRUE(context_->registry().HasEntry(kReferencingId));
- handle.reset();
- base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(context_->registry().HasEntry(kReferencingId));
-}
-
-namespace {
-constexpr size_t kTotalRawBlobs = 200;
-constexpr size_t kTotalSlicedBlobs = 100;
-constexpr char kTestDiskCacheData[] = "Test Blob Data";
-
-// Appends data and data types that depend on the index. This is designed to
-// exercise all types of combinations of data, future data, files, future files,
-// and disk cache entries.
-size_t AppendDataInBuilder(BlobDataBuilder* builder,
- size_t index,
- disk_cache::Entry* cache_entry) {
- size_t size = 0;
- // We can't have both future data and future files, so split those up.
- if (index % 2 != 0) {
- builder->AppendFutureData(5u);
- size += 5u;
- if (index % 3 == 1) {
- builder->AppendData("abcdefghij", 4u);
- size += 4u;
- }
- if (index % 3 == 0) {
- builder->AppendFutureData(1u);
- size += 1u;
- }
- } else if (index % 3 == 0) {
- builder->AppendFutureFile(0lu, 3lu, 0);
- size += 3u;
- }
- if (index % 5 != 0) {
- builder->AppendFile(
- base::FilePath::FromUTF8Unsafe(base::SizeTToString(index)), 0ul, 20ul,
- base::Time::Max());
- size += 20u;
- }
- if (index % 3 != 0) {
- scoped_refptr<BlobDataBuilder::DataHandle> disk_cache_data_handle =
- new EmptyDataHandle();
- builder->AppendDiskCacheEntry(disk_cache_data_handle, cache_entry,
- kTestDiskCacheStreamIndex);
- size += strlen(kTestDiskCacheData);
- }
- return size;
-}
-
-bool DoesBuilderHaveFutureData(size_t index) {
- return index < kTotalRawBlobs && (index % 2 != 0 || index % 3 == 0);
-}
-
-void PopulateDataInBuilder(BlobDataBuilder* builder,
- size_t index,
- base::TaskRunner* file_runner) {
- if (index % 2 != 0) {
- builder->PopulateFutureData(0, "abcde", 0, 5);
- if (index % 3 == 0) {
- builder->PopulateFutureData(1, "z", 0, 1);
- }
- } else if (index % 3 == 0) {
- scoped_refptr<ShareableFileReference> file_ref =
- ShareableFileReference::GetOrCreate(
- base::FilePath::FromUTF8Unsafe(
- base::SizeTToString(index + kTotalRawBlobs)),
- ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE, file_runner);
- builder->PopulateFutureFile(0, file_ref, base::Time::Max());
- }
-}
-} // namespace
-
-TEST_F(BlobStorageContextTest, BuildBlobCombinations) {
- const std::string kId("id");
-
- context_ =
- base::MakeUnique<BlobStorageContext>(temp_dir_.GetPath(), file_runner_);
-
- SetTestMemoryLimits();
- std::unique_ptr<disk_cache::Backend> cache = CreateInMemoryDiskCache();
- ASSERT_TRUE(cache);
- disk_cache::ScopedEntryPtr entry =
- CreateDiskCacheEntry(cache.get(), "test entry", kTestDiskCacheData);
-
- // This tests mixed blob content with both synchronous and asynchronous
- // construction. Blobs should also be paged to disk during execution.
- std::vector<std::unique_ptr<BlobDataBuilder>> builders;
- std::vector<size_t> sizes;
- for (size_t i = 0; i < kTotalRawBlobs; i++) {
- builders.emplace_back(new BlobDataBuilder(base::SizeTToString(i)));
- auto& builder = *builders.back();
- size_t size = AppendDataInBuilder(&builder, i, entry.get());
- EXPECT_NE(0u, size);
- sizes.push_back(size);
- }
-
- for (size_t i = 0; i < kTotalSlicedBlobs; i++) {
- builders.emplace_back(
- new BlobDataBuilder(base::SizeTToString(i + kTotalRawBlobs)));
- size_t source_size = sizes[i];
- size_t offset = source_size == 1 ? 0 : i % (source_size - 1);
- size_t size = (i % (source_size - offset)) + 1;
- builders.back()->AppendBlob(base::SizeTToString(i), offset, size);
- }
-
- size_t total_finished_blobs = 0;
- std::vector<std::unique_ptr<BlobDataHandle>> handles;
- std::vector<BlobStatus> statuses;
- std::vector<bool> populated;
- statuses.resize(kTotalRawBlobs,
- BlobStatus::ERR_INVALID_CONSTRUCTION_ARGUMENTS);
- populated.resize(kTotalRawBlobs, false);
- for (size_t i = 0; i < builders.size(); i++) {
- BlobDataBuilder& builder = *builders[i];
- builder.set_content_type("text/plain");
- bool has_pending_memory = DoesBuilderHaveFutureData(i);
- std::unique_ptr<BlobDataHandle> handle = context_->BuildBlob(
- builder,
- has_pending_memory
- ? base::Bind(&SaveBlobStatusAndFiles, &statuses[0] + i, &files_)
- : BlobStorageContext::TransportAllowedCallback());
- handle->RunOnConstructionComplete(
- base::Bind(&IncrementNumber, &total_finished_blobs));
- handles.push_back(std::move(handle));
- }
- base::RunLoop().RunUntilIdle();
-
- // We should be needing to send a page or two to disk.
- EXPECT_TRUE(file_runner_->HasPendingTask());
- do {
- file_runner_->RunPendingTasks();
- base::RunLoop().RunUntilIdle();
- // Continue populating data for items that can fit.
- for (size_t i = 0; i < kTotalRawBlobs; i++) {
- BlobDataBuilder* builder = builders[i].get();
- if (DoesBuilderHaveFutureData(i) && !populated[i] &&
- statuses[i] == BlobStatus::PENDING_TRANSPORT) {
- PopulateDataInBuilder(builder, i, file_runner_.get());
- context_->NotifyTransportComplete(base::SizeTToString(i));
- populated[i] = true;
- }
- }
- base::RunLoop().RunUntilIdle();
- } while (file_runner_->HasPendingTask());
-
- // Check all builders with future items were signalled and populated.
- for (size_t i = 0; i < populated.size(); i++) {
- if (DoesBuilderHaveFutureData(i)) {
- EXPECT_EQ(BlobStatus::PENDING_TRANSPORT, statuses[i]) << i;
- EXPECT_TRUE(populated[i]) << i;
- }
- }
- base::RunLoop().RunUntilIdle();
-
- // We should be completely built now.
- EXPECT_EQ(kTotalRawBlobs + kTotalSlicedBlobs, total_finished_blobs);
- for (std::unique_ptr<BlobDataHandle>& handle : handles) {
- EXPECT_EQ(BlobStatus::DONE, handle->GetBlobStatus());
- }
- handles.clear();
- base::RunLoop().RunUntilIdle();
- files_.clear();
- // We should have file cleanup tasks.
- EXPECT_TRUE(file_runner_->HasPendingTask());
- file_runner_->RunPendingTasks();
- base::RunLoop().RunUntilIdle();
- EXPECT_EQ(0lu, context_->memory_controller().memory_usage());
- EXPECT_EQ(0lu, context_->memory_controller().disk_usage());
-}
-
-// TODO(michaeln): tests for the deprecated url stuff
-
-} // namespace storage
« no previous file with comments | « no previous file | content/test/BUILD.gn » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698