content / browser / renderer_host / pepper / quota_reservation_unittest.cc [blame]

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/renderer_host/pepper/quota_reservation.h"

#include <stdint.h>

#include <memory>

#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/run_loop.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/task_environment.h"
#include "storage/browser/file_system/quota/quota_reservation.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"
#include "url/origin.h"

using storage::QuotaReservationManager;

namespace content {

namespace {

const char kOrigin[] = "http://example.com";
const storage::FileSystemType kType = storage::kFileSystemTypeTemporary;

const base::FilePath::StringType file1_name = FILE_PATH_LITERAL("file1");
const base::FilePath::StringType file2_name = FILE_PATH_LITERAL("file2");
const base::FilePath::StringType file3_name = FILE_PATH_LITERAL("file3");
const int kFile1ID = 1;
const int kFile2ID = 2;
const int kFile3ID = 3;

class FakeBackend : public QuotaReservationManager::QuotaBackend {
 public:
  FakeBackend() {}

  FakeBackend(const FakeBackend&) = delete;
  FakeBackend& operator=(const FakeBackend&) = delete;

  ~FakeBackend() override {}

  void ReserveQuota(
      const url::Origin& origin,
      storage::FileSystemType type,
      int64_t delta,
      QuotaReservationManager::ReserveQuotaCallback callback) override {
    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(base::IgnoreResult(std::move(callback)),
                                  base::File::FILE_OK, delta));
  }

  void ReleaseReservedQuota(const url::Origin& origin,
                            storage::FileSystemType type,
                            int64_t size) override {}

  void CommitQuotaUsage(const url::Origin& origin,
                        storage::FileSystemType type,
                        int64_t delta) override {}

  void IncrementDirtyCount(const url::Origin& origin,
                           storage::FileSystemType type) override {}
  void DecrementDirtyCount(const url::Origin& origin,
                           storage::FileSystemType type) override {}
};

}  // namespace

class QuotaReservationTest : public testing::Test {
 public:
  QuotaReservationTest() {}

  QuotaReservationTest(const QuotaReservationTest&) = delete;
  QuotaReservationTest& operator=(const QuotaReservationTest&) = delete;

  ~QuotaReservationTest() override {}

  void SetUp() override {
    ASSERT_TRUE(work_dir_.CreateUniqueTempDir());

    reservation_manager_ = std::make_unique<QuotaReservationManager>(
        std::make_unique<FakeBackend>());
  }

  void TearDown() override {
    reservation_manager_.reset();
    base::RunLoop().RunUntilIdle();
  }

  base::FilePath MakeFilePath(const base::FilePath::StringType& file_name) {
    return work_dir_.GetPath().Append(file_name);
  }

  storage::FileSystemURL MakeFileSystemURL(
      const base::FilePath::StringType& file_name) {
    return storage::FileSystemURL::CreateForTest(
        blink::StorageKey::CreateFromStringForTesting(kOrigin), kType,
        MakeFilePath(file_name));
  }

  scoped_refptr<QuotaReservation> CreateQuotaReservation(
      scoped_refptr<storage::QuotaReservation> reservation,
      const GURL& origin,
      storage::FileSystemType type) {
    // Sets reservation_ as a side effect.
    return base::WrapRefCounted(
        new QuotaReservation(reservation, origin, type));
  }

  void SetFileSize(const base::FilePath::StringType& file_name, int64_t size) {
    base::File file(MakeFilePath(file_name),
                    base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
    ASSERT_TRUE(file.IsValid());
    ASSERT_TRUE(file.SetLength(size));
  }

  QuotaReservationManager* reservation_manager() {
    return reservation_manager_.get();
  }

 private:
  base::test::SingleThreadTaskEnvironment task_environment_;
  base::ScopedTempDir work_dir_;
  std::unique_ptr<storage::QuotaReservationManager> reservation_manager_;
};

void GotReservedQuota(int64_t* reserved_quota_ptr,
                      ppapi::FileGrowthMap* file_growths_ptr,
                      base::OnceClosure after_callback,
                      int64_t reserved_quota,
                      const ppapi::FileSizeMap& maximum_written_offsets) {
  *reserved_quota_ptr = reserved_quota;

  file_growths_ptr->clear();
  for (auto it = maximum_written_offsets.begin();
       it != maximum_written_offsets.end(); ++it)
    (*file_growths_ptr)[it->first] = ppapi::FileGrowth(it->second, 0);

  std::move(after_callback).Run();
}

void ReserveQuota(scoped_refptr<QuotaReservation> quota_reservation,
                  int64_t amount,
                  int64_t* reserved_quota,
                  ppapi::FileGrowthMap* file_growths) {
  base::RunLoop loop;
  quota_reservation->ReserveQuota(
      amount, *file_growths,
      base::BindOnce(&GotReservedQuota, reserved_quota, file_growths,
                     loop.QuitClosure()));
  loop.Run();
}

// Tests that:
// 1) We can reserve quota with no files open.
// 2) Open a file, grow it, close it, and reserve quota with correct sizes.
TEST_F(QuotaReservationTest, ReserveQuota) {
  GURL origin(kOrigin);
  storage::FileSystemType type = kType;

  scoped_refptr<storage::QuotaReservation> reservation(
      reservation_manager()->CreateReservation(url::Origin::Create(origin),
                                               type));
  scoped_refptr<QuotaReservation> test =
      CreateQuotaReservation(reservation, origin, type);

  // Reserve quota with no files open.
  int64_t amount = 100;
  int64_t reserved_quota;
  ppapi::FileGrowthMap file_growths;
  ReserveQuota(test, amount, &reserved_quota, &file_growths);
  EXPECT_EQ(amount, reserved_quota);
  EXPECT_EQ(0U, file_growths.size());

  // Open a file, refresh the reservation, extend the file, and close it.
  int64_t file_size = 10;
  SetFileSize(file1_name, file_size);
  int64_t open_file_size =
      test->OpenFile(kFile1ID, MakeFileSystemURL(file1_name));
  EXPECT_EQ(file_size, open_file_size);

  file_growths[kFile1ID] = ppapi::FileGrowth(file_size, 0);  // 1 file open.
  ReserveQuota(test, amount, &reserved_quota, &file_growths);
  EXPECT_EQ(amount, reserved_quota);
  EXPECT_EQ(1U, file_growths.size());
  EXPECT_EQ(file_size, file_growths[kFile1ID].max_written_offset);

  int64_t new_file_size = 30;
  SetFileSize(file1_name, new_file_size);

  EXPECT_EQ(amount, reservation->remaining_quota());
  test->CloseFile(kFile1ID, ppapi::FileGrowth(new_file_size, 0));
  EXPECT_EQ(amount - (new_file_size - file_size),
            reservation->remaining_quota());
}

// Tests that:
// 1) We can open and close multiple files.
TEST_F(QuotaReservationTest, MultipleFiles) {
  GURL origin(kOrigin);
  storage::FileSystemType type = kType;

  scoped_refptr<storage::QuotaReservation> reservation(
      reservation_manager()->CreateReservation(url::Origin::Create(origin),
                                               type));
  scoped_refptr<QuotaReservation> test =
      CreateQuotaReservation(reservation, origin, type);

  // Open some files of different sizes.
  int64_t file1_size = 10;
  SetFileSize(file1_name, file1_size);
  int64_t open_file1_size =
      test->OpenFile(kFile1ID, MakeFileSystemURL(file1_name));
  EXPECT_EQ(file1_size, open_file1_size);
  int64_t file2_size = 20;
  SetFileSize(file2_name, file2_size);
  int64_t open_file2_size =
      test->OpenFile(kFile2ID, MakeFileSystemURL(file2_name));
  EXPECT_EQ(file2_size, open_file2_size);
  int64_t file3_size = 30;
  SetFileSize(file3_name, file3_size);
  int64_t open_file3_size =
      test->OpenFile(kFile3ID, MakeFileSystemURL(file3_name));
  EXPECT_EQ(file3_size, open_file3_size);

  // Reserve quota.
  int64_t amount = 100;
  int64_t reserved_quota;
  ppapi::FileGrowthMap file_growths;
  file_growths[kFile1ID] = ppapi::FileGrowth(file1_size, 0);  // 3 files open.
  file_growths[kFile2ID] = ppapi::FileGrowth(file2_size, 0);
  file_growths[kFile3ID] = ppapi::FileGrowth(file3_size, 0);

  ReserveQuota(test, amount, &reserved_quota, &file_growths);
  EXPECT_EQ(amount, reserved_quota);
  EXPECT_EQ(3U, file_growths.size());
  EXPECT_EQ(file1_size, file_growths[kFile1ID].max_written_offset);
  EXPECT_EQ(file2_size, file_growths[kFile2ID].max_written_offset);
  EXPECT_EQ(file3_size, file_growths[kFile3ID].max_written_offset);

  test->CloseFile(kFile2ID, ppapi::FileGrowth(file2_size, 0));

  file_growths.erase(kFile2ID);
  ReserveQuota(test, amount, &reserved_quota, &file_growths);
  EXPECT_EQ(amount, reserved_quota);
  EXPECT_EQ(2U, file_growths.size());
  EXPECT_EQ(file1_size, file_growths[kFile1ID].max_written_offset);
  EXPECT_EQ(file3_size, file_growths[kFile3ID].max_written_offset);

  test->CloseFile(kFile1ID, ppapi::FileGrowth(file1_size, 0));
  test->CloseFile(kFile3ID, ppapi::FileGrowth(file3_size, 0));
}

}  // namespace content