storage/browser/fileapi/quota/quota_backend_impl_unittest.cc - chromium/src - Git at Google

 // 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/fileapi/quota/quota_backend_impl.h"

 #include <stdint.h>

 #include <memory>
 #include <string>

 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "storage/browser/fileapi/file_system_features.h"
 #include "storage/browser/fileapi/file_system_usage_cache.h"
 #include "storage/browser/fileapi/obfuscated_file_util.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/leveldb_chrome.h"

 using storage::FileSystemUsageCache;
 using storage::ObfuscatedFileUtil;
 using storage::QuotaBackendImpl;
 using storage::SandboxFileSystemBackendDelegate;

 namespace content {

 namespace {

 const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));

 bool DidReserveQuota(bool accepted,
                      base::File::Error* error_out,
                      int64_t* delta_out,
                      base::File::Error error,
                      int64_t delta) {
   DCHECK(error_out);
   DCHECK(delta_out);
   *error_out = error;
   *delta_out = delta;
   return accepted;
 }

 class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
  public:
   MockQuotaManagerProxy()
       : QuotaManagerProxy(nullptr, nullptr),
         storage_modified_count_(0),
         usage_(0),
         quota_(0) {}

   // We don't mock them.
   void NotifyOriginInUse(const url::Origin& origin) override {}
   void NotifyOriginNoLongerInUse(const url::Origin& origin) override {}
   void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                             const url::Origin& origin,
                             blink::mojom::StorageType type,
                             bool enabled) override {}

   void NotifyStorageModified(storage::QuotaClient::ID client_id,
                              const url::Origin& origin,
                              blink::mojom::StorageType type,
                              int64_t delta) override {
     ++storage_modified_count_;
     usage_ += delta;
     ASSERT_LE(usage_, quota_);
   }

   void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
                         const url::Origin& origin,
                         blink::mojom::StorageType type,
                         UsageAndQuotaCallback callback) override {
     std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk, usage_, quota_);
   }

   int storage_modified_count() { return storage_modified_count_; }
   int64_t usage() { return usage_; }
   void set_usage(int64_t usage) { usage_ = usage; }
   void set_quota(int64_t quota) { quota_ = quota; }

  protected:
   ~MockQuotaManagerProxy() override = default;

  private:
   int storage_modified_count_;
   int64_t usage_;
   int64_t quota_;

   DISALLOW_COPY_AND_ASSIGN(MockQuotaManagerProxy);
 };

 }  // namespace

 class QuotaBackendImplTest : public testing::Test,
                              public ::testing::WithParamInterface<bool> {
  public:
   QuotaBackendImplTest()
       : file_system_usage_cache_(is_incognito()),
         quota_manager_proxy_(new MockQuotaManagerProxy) {
     if (is_incognito()) {
       feature_list_.InitAndEnableFeature(
           storage::features::kEnableFilesystemInIncognito);
     }
   }

   void SetUp() override {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     in_memory_env_ = leveldb_chrome::NewMemEnv("quota");
     file_util_.reset(ObfuscatedFileUtil::CreateForTesting(
         nullptr, data_dir_.GetPath(), in_memory_env_.get(), is_incognito()));
     backend_ = std::make_unique<QuotaBackendImpl>(
         file_task_runner(), file_util_.get(), &file_system_usage_cache_,
         quota_manager_proxy_.get());
   }

   void TearDown() override {
     backend_.reset();
     quota_manager_proxy_ = nullptr;
     file_util_.reset();
     base::RunLoop().RunUntilIdle();
   }

   bool is_incognito() { return GetParam(); }

  protected:
   void InitializeForOriginAndType(const url::Origin& origin,
                                   storage::FileSystemType type) {
     ASSERT_TRUE(
         file_util_->InitOriginDatabase(origin.GetURL(), true /* create */));
     ASSERT_TRUE(file_util_->origin_database_ != nullptr);

     std::string type_string =
         SandboxFileSystemBackendDelegate::GetTypeString(type);
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = file_util_->GetDirectoryForOriginAndType(
         origin.GetURL(), type_string, true /* create */, &error);
     ASSERT_EQ(base::File::FILE_OK, error);

     ASSERT_TRUE(file_system_usage_cache_.UpdateUsage(
         GetUsageCachePath(origin, type), 0));
   }

   base::SequencedTaskRunner* file_task_runner() {
     return base::ThreadTaskRunnerHandle::Get().get();
   }

   base::FilePath GetUsageCachePath(const url::Origin& origin,
                                    storage::FileSystemType type) {
     base::FilePath path;
     base::File::Error error = backend_->GetUsageCachePath(origin, type, &path);
     EXPECT_EQ(base::File::FILE_OK, error);
     EXPECT_FALSE(path.empty());
     return path;
   }

   base::test::ScopedFeatureList feature_list_;
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::ScopedTempDir data_dir_;
   std::unique_ptr<leveldb::Env> in_memory_env_;
   std::unique_ptr<ObfuscatedFileUtil> file_util_;
   FileSystemUsageCache file_system_usage_cache_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   std::unique_ptr<QuotaBackendImpl> backend_;

  private:
   DISALLOW_COPY_AND_ASSIGN(QuotaBackendImplTest);
 };

 INSTANTIATE_TEST_SUITE_P(, QuotaBackendImplTest, testing::Bool());

 TEST_P(QuotaBackendImplTest, ReserveQuota_Basic) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);

   int64_t delta = 0;

   const int64_t kDelta1 = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(
       kOrigin, type, kDelta1,
       base::BindOnce(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta1, delta);
   EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());

   const int64_t kDelta2 = -300;
   error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(
       kOrigin, type, kDelta2,
       base::BindOnce(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta2, delta);
   EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());

   EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
 }

 TEST_P(QuotaBackendImplTest, ReserveQuota_NoSpace) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(100);

   int64_t delta = 0;

   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(
       kOrigin, type, kDelta,
       base::BindOnce(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(100, delta);
   EXPECT_EQ(100, quota_manager_proxy_->usage());

   EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
 }

 TEST_P(QuotaBackendImplTest, ReserveQuota_Revert) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);

   int64_t delta = 0;

   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend_->ReserveQuota(
       kOrigin, type, kDelta,
       base::BindOnce(&DidReserveQuota, false, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta, delta);
   EXPECT_EQ(0, quota_manager_proxy_->usage());

   EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
 }

 TEST_P(QuotaBackendImplTest, ReleaseReservedQuota) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   const int64_t kInitialUsage = 2000;
   quota_manager_proxy_->set_usage(kInitialUsage);
   quota_manager_proxy_->set_quota(10000);

   const int64_t kSize = 1000;
   backend_->ReleaseReservedQuota(kOrigin, type, kSize);
   EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage());

   EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
 }

 TEST_P(QuotaBackendImplTest, CommitQuotaUsage) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
   base::FilePath path = GetUsageCachePath(kOrigin, type);

   const int64_t kDelta1 = 1000;
   backend_->CommitQuotaUsage(kOrigin, type, kDelta1);
   EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());
   int64_t usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
   EXPECT_EQ(kDelta1, usage);

   const int64_t kDelta2 = -300;
   backend_->CommitQuotaUsage(kOrigin, type, kDelta2);
   EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());
   usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
   EXPECT_EQ(kDelta1 + kDelta2, usage);

   EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
 }

 TEST_P(QuotaBackendImplTest, DirtyCount) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
   InitializeForOriginAndType(kOrigin, type);
   base::FilePath path = GetUsageCachePath(kOrigin, type);

   backend_->IncrementDirtyCount(kOrigin, type);
   uint32_t dirty = 0;
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(1u, dirty);

   backend_->DecrementDirtyCount(kOrigin, type);
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(0u, dirty);
 }

 }  // namespace content
	// 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/fileapi/quota/quota_backend_impl.h"

	#include <stdint.h>

	#include <memory>
	#include <string>

	#include "base/bind.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/macros.h"
	#include "base/run_loop.h"
	#include "base/test/scoped_feature_list.h"
	#include "base/test/scoped_task_environment.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "storage/browser/fileapi/file_system_features.h"
	#include "storage/browser/fileapi/file_system_usage_cache.h"
	#include "storage/browser/fileapi/obfuscated_file_util.h"
	#include "storage/browser/quota/quota_manager_proxy.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/leveldatabase/leveldb_chrome.h"

	using storage::FileSystemUsageCache;
	using storage::ObfuscatedFileUtil;
	using storage::QuotaBackendImpl;
	using storage::SandboxFileSystemBackendDelegate;

	namespace content {

	namespace {

	const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));

	bool DidReserveQuota(bool accepted,
	base::File::Error* error_out,
	int64_t* delta_out,
	base::File::Error error,
	int64_t delta) {
	DCHECK(error_out);
	DCHECK(delta_out);
	*error_out = error;
	*delta_out = delta;
	return accepted;
	}

	class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
	public:
	MockQuotaManagerProxy()
	: QuotaManagerProxy(nullptr, nullptr),
	storage_modified_count_(0),
	usage_(0),
	quota_(0) {}

	// We don't mock them.
	void NotifyOriginInUse(const url::Origin& origin) override {}
	void NotifyOriginNoLongerInUse(const url::Origin& origin) override {}
	void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
	const url::Origin& origin,
	blink::mojom::StorageType type,
	bool enabled) override {}

	void NotifyStorageModified(storage::QuotaClient::ID client_id,
	const url::Origin& origin,
	blink::mojom::StorageType type,
	int64_t delta) override {
	++storage_modified_count_;
	usage_ += delta;
	ASSERT_LE(usage_, quota_);
	}

	void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
	const url::Origin& origin,
	blink::mojom::StorageType type,
	UsageAndQuotaCallback callback) override {
	std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk, usage_, quota_);
	}

	int storage_modified_count() { return storage_modified_count_; }
	int64_t usage() { return usage_; }
	void set_usage(int64_t usage) { usage_ = usage; }
	void set_quota(int64_t quota) { quota_ = quota; }

	protected:
	~MockQuotaManagerProxy() override = default;

	private:
	int storage_modified_count_;
	int64_t usage_;
	int64_t quota_;

	DISALLOW_COPY_AND_ASSIGN(MockQuotaManagerProxy);
	};

	} // namespace

	class QuotaBackendImplTest : public testing::Test,
	public ::testing::WithParamInterface<bool> {
	public:
	QuotaBackendImplTest()
	: file_system_usage_cache_(is_incognito()),
	quota_manager_proxy_(new MockQuotaManagerProxy) {
	if (is_incognito()) {
	feature_list_.InitAndEnableFeature(
	storage::features::kEnableFilesystemInIncognito);
	}
	}

	void SetUp() override {
	ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
	in_memory_env_ = leveldb_chrome::NewMemEnv("quota");
	file_util_.reset(ObfuscatedFileUtil::CreateForTesting(
	nullptr, data_dir_.GetPath(), in_memory_env_.get(), is_incognito()));
	backend_ = std::make_unique<QuotaBackendImpl>(
	file_task_runner(), file_util_.get(), &file_system_usage_cache_,
	quota_manager_proxy_.get());
	}

	void TearDown() override {
	backend_.reset();
	quota_manager_proxy_ = nullptr;
	file_util_.reset();
	base::RunLoop().RunUntilIdle();
	}

	bool is_incognito() { return GetParam(); }

	protected:
	void InitializeForOriginAndType(const url::Origin& origin,
	storage::FileSystemType type) {
	ASSERT_TRUE(
	file_util_->InitOriginDatabase(origin.GetURL(), true /* create */));
	ASSERT_TRUE(file_util_->origin_database_ != nullptr);

	std::string type_string =
	SandboxFileSystemBackendDelegate::GetTypeString(type);
	base::File::Error error = base::File::FILE_ERROR_FAILED;
	base::FilePath path = file_util_->GetDirectoryForOriginAndType(
	origin.GetURL(), type_string, true /* create */, &error);
	ASSERT_EQ(base::File::FILE_OK, error);

	ASSERT_TRUE(file_system_usage_cache_.UpdateUsage(
	GetUsageCachePath(origin, type), 0));
	}

	base::SequencedTaskRunner* file_task_runner() {
	return base::ThreadTaskRunnerHandle::Get().get();
	}

	base::FilePath GetUsageCachePath(const url::Origin& origin,
	storage::FileSystemType type) {
	base::FilePath path;
	base::File::Error error = backend_->GetUsageCachePath(origin, type, &path);
	EXPECT_EQ(base::File::FILE_OK, error);
	EXPECT_FALSE(path.empty());
	return path;
	}

	base::test::ScopedFeatureList feature_list_;
	base::test::ScopedTaskEnvironment scoped_task_environment_;
	base::ScopedTempDir data_dir_;
	std::unique_ptr<leveldb::Env> in_memory_env_;
	std::unique_ptr<ObfuscatedFileUtil> file_util_;
	FileSystemUsageCache file_system_usage_cache_;
	scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
	std::unique_ptr<QuotaBackendImpl> backend_;

	private:
	DISALLOW_COPY_AND_ASSIGN(QuotaBackendImplTest);
	};

	INSTANTIATE_TEST_SUITE_P(, QuotaBackendImplTest, testing::Bool());

	TEST_P(QuotaBackendImplTest, ReserveQuota_Basic) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	quota_manager_proxy_->set_quota(10000);

	int64_t delta = 0;

	const int64_t kDelta1 = 1000;
	base::File::Error error = base::File::FILE_ERROR_FAILED;
	backend_->ReserveQuota(
	kOrigin, type, kDelta1,
	base::BindOnce(&DidReserveQuota, true, &error, &delta));
	EXPECT_EQ(base::File::FILE_OK, error);
	EXPECT_EQ(kDelta1, delta);
	EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());

	const int64_t kDelta2 = -300;
	error = base::File::FILE_ERROR_FAILED;
	backend_->ReserveQuota(
	kOrigin, type, kDelta2,
	base::BindOnce(&DidReserveQuota, true, &error, &delta));
	EXPECT_EQ(base::File::FILE_OK, error);
	EXPECT_EQ(kDelta2, delta);
	EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());

	EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
	}

	TEST_P(QuotaBackendImplTest, ReserveQuota_NoSpace) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	quota_manager_proxy_->set_quota(100);

	int64_t delta = 0;

	const int64_t kDelta = 1000;
	base::File::Error error = base::File::FILE_ERROR_FAILED;
	backend_->ReserveQuota(
	kOrigin, type, kDelta,
	base::BindOnce(&DidReserveQuota, true, &error, &delta));
	EXPECT_EQ(base::File::FILE_OK, error);
	EXPECT_EQ(100, delta);
	EXPECT_EQ(100, quota_manager_proxy_->usage());

	EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
	}

	TEST_P(QuotaBackendImplTest, ReserveQuota_Revert) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	quota_manager_proxy_->set_quota(10000);

	int64_t delta = 0;

	const int64_t kDelta = 1000;
	base::File::Error error = base::File::FILE_ERROR_FAILED;
	backend_->ReserveQuota(
	kOrigin, type, kDelta,
	base::BindOnce(&DidReserveQuota, false, &error, &delta));
	EXPECT_EQ(base::File::FILE_OK, error);
	EXPECT_EQ(kDelta, delta);
	EXPECT_EQ(0, quota_manager_proxy_->usage());

	EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
	}

	TEST_P(QuotaBackendImplTest, ReleaseReservedQuota) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	const int64_t kInitialUsage = 2000;
	quota_manager_proxy_->set_usage(kInitialUsage);
	quota_manager_proxy_->set_quota(10000);

	const int64_t kSize = 1000;
	backend_->ReleaseReservedQuota(kOrigin, type, kSize);
	EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage());

	EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
	}

	TEST_P(QuotaBackendImplTest, CommitQuotaUsage) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	quota_manager_proxy_->set_quota(10000);
	base::FilePath path = GetUsageCachePath(kOrigin, type);

	const int64_t kDelta1 = 1000;
	backend_->CommitQuotaUsage(kOrigin, type, kDelta1);
	EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());
	int64_t usage = 0;
	EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
	EXPECT_EQ(kDelta1, usage);

	const int64_t kDelta2 = -300;
	backend_->CommitQuotaUsage(kOrigin, type, kDelta2);
	EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());
	usage = 0;
	EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
	EXPECT_EQ(kDelta1 + kDelta2, usage);

	EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count());
	}

	TEST_P(QuotaBackendImplTest, DirtyCount) {
	storage::FileSystemType type = storage::kFileSystemTypeTemporary;
	InitializeForOriginAndType(kOrigin, type);
	base::FilePath path = GetUsageCachePath(kOrigin, type);

	backend_->IncrementDirtyCount(kOrigin, type);
	uint32_t dirty = 0;
	ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
	EXPECT_EQ(1u, dirty);

	backend_->DecrementDirtyCount(kOrigin, type);
	ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
	EXPECT_EQ(0u, dirty);
	}

	} // namespace content