content/browser/quota/quota_reservation_manager_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "storage/browser/fileapi/quota/quota_reservation_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/files/file.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/location.h"
  13 #include "base/run_loop.h"
  14 #include "base/single_thread_task_runner.h"
  15 #include "base/thread_task_runner_handle.h"
  16 #include "storage/browser/fileapi/quota/open_file_handle.h"
  17 #include "storage/browser/fileapi/quota/quota_reservation.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using storage::kFileSystemTypeTemporary;
  21 using storage::OpenFileHandle;
  22 using storage::QuotaReservation;
  23 using storage::QuotaReservationManager;
  24
  25 namespace content {
  26
  27 namespace {
  28
  29 const char kOrigin[] = "http://example.com";
  30 const storage::FileSystemType kType = kFileSystemTypeTemporary;
  31 const int64 kInitialFileSize = 1;
  32
  33 typedef QuotaReservationManager::ReserveQuotaCallback ReserveQuotaCallback;
  34
  35 int64 GetFileSize(const base::FilePath& path) {
  36   int64 size = 0;
  37   base::GetFileSize(path, &size);
  38   return size;
  39 }
  40
  41 void SetFileSize(const base::FilePath& path, int64 size) {
  42   base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
  43   ASSERT_TRUE(file.IsValid());
  44   ASSERT_TRUE(file.SetLength(size));
  45 }
  46
  47 class FakeBackend : public QuotaReservationManager::QuotaBackend {
  48  public:
  49   FakeBackend()
  50       : on_memory_usage_(kInitialFileSize),
  51         on_disk_usage_(kInitialFileSize) {}
  52   ~FakeBackend() override {}
  53
  54   void ReserveQuota(const GURL& origin,
  55                     storage::FileSystemType type,
  56                     int64 delta,
  57                     const ReserveQuotaCallback& callback) override {
  58     EXPECT_EQ(GURL(kOrigin), origin);
  59     EXPECT_EQ(kType, type);
  60     on_memory_usage_ += delta;
  61     base::ThreadTaskRunnerHandle::Get()->PostTask(
  62         FROM_HERE,
  63         base::Bind(base::IgnoreResult(callback), base::File::FILE_OK, delta));
  64   }
  65
  66   void ReleaseReservedQuota(const GURL& origin,
  67                             storage::FileSystemType type,
  68                             int64 size) override {
  69     EXPECT_LE(0, size);
  70     EXPECT_EQ(GURL(kOrigin), origin);
  71     EXPECT_EQ(kType, type);
  72     on_memory_usage_ -= size;
  73   }
  74
  75   void CommitQuotaUsage(const GURL& origin,
  76                         storage::FileSystemType type,
  77                         int64 delta) override {
  78     EXPECT_EQ(GURL(kOrigin), origin);
  79     EXPECT_EQ(kType, type);
  80     on_disk_usage_ += delta;
  81     on_memory_usage_ += delta;
  82   }
  83
  84   void IncrementDirtyCount(const GURL& origin,
  85                            storage::FileSystemType type) override {}
  86   void DecrementDirtyCount(const GURL& origin,
  87                            storage::FileSystemType type) override {}
  88
  89   int64 on_memory_usage() { return on_memory_usage_; }
  90   int64 on_disk_usage() { return on_disk_usage_; }
  91
  92  private:
  93   int64 on_memory_usage_;
  94   int64 on_disk_usage_;
  95
  96   DISALLOW_COPY_AND_ASSIGN(FakeBackend);
  97 };
  98
  99 class FakeWriter {
 100  public:
 101   explicit FakeWriter(scoped_ptr<OpenFileHandle> handle)
 102       : handle_(handle.Pass()),
 103         path_(handle_->platform_path()),
 104         max_written_offset_(handle_->GetEstimatedFileSize()),
 105         append_mode_write_amount_(0),
 106         dirty_(false) {
 107   }
 108
 109   ~FakeWriter() {
 110     if (handle_)
 111       EXPECT_FALSE(dirty_);
 112   }
 113
 114   int64 Truncate(int64 length) {
 115     int64 consumed = 0;
 116
 117     if (max_written_offset_ < length) {
 118       consumed = length - max_written_offset_;
 119       max_written_offset_ = length;
 120     }
 121     SetFileSize(path_, length);
 122     return consumed;
 123   }
 124
 125   int64 Write(int64 max_offset) {
 126     dirty_ = true;
 127
 128     int64 consumed = 0;
 129     if (max_written_offset_ < max_offset) {
 130       consumed = max_offset - max_written_offset_;
 131       max_written_offset_ = max_offset;
 132     }
 133     if (GetFileSize(path_) < max_offset)
 134       SetFileSize(path_, max_offset);
 135     return consumed;
 136   }
 137
 138   int64 Append(int64 amount) {
 139     dirty_ = true;
 140     append_mode_write_amount_ += amount;
 141     SetFileSize(path_, GetFileSize(path_) + amount);
 142     return amount;
 143   }
 144
 145   void ReportUsage() {
 146     handle_->UpdateMaxWrittenOffset(max_written_offset_);
 147     handle_->AddAppendModeWriteAmount(append_mode_write_amount_);
 148     max_written_offset_ = handle_->GetEstimatedFileSize();
 149     append_mode_write_amount_ = 0;
 150     dirty_ = false;
 151   }
 152
 153   void ClearWithoutUsageReport() {
 154     handle_.reset();
 155   }
 156
 157  private:
 158   scoped_ptr<OpenFileHandle> handle_;
 159   base::FilePath path_;
 160   int64 max_written_offset_;
 161   int64 append_mode_write_amount_;
 162   bool dirty_;
 163 };
 164
 165 void ExpectSuccess(bool* done, base::File::Error error) {
 166   EXPECT_FALSE(*done);
 167   *done = true;
 168   EXPECT_EQ(base::File::FILE_OK, error);
 169 }
 170
 171 void RefreshReservation(QuotaReservation* reservation, int64 size) {
 172   DCHECK(reservation);
 173
 174   bool done = false;
 175   reservation->RefreshReservation(size, base::Bind(&ExpectSuccess, &done));
 176   base::RunLoop().RunUntilIdle();
 177   EXPECT_TRUE(done);
 178 }
 179
 180 }  // namespace
 181
 182 class QuotaReservationManagerTest : public testing::Test {
 183  public:
 184   QuotaReservationManagerTest() {}
 185   ~QuotaReservationManagerTest() override {}
 186
 187   void SetUp() override {
 188     ASSERT_TRUE(work_dir_.CreateUniqueTempDir());
 189     file_path_ = work_dir_.path().Append(FILE_PATH_LITERAL("hoge"));
 190     SetFileSize(file_path_, kInitialFileSize);
 191
 192     scoped_ptr<QuotaReservationManager::QuotaBackend> backend(new FakeBackend);
 193     reservation_manager_.reset(new QuotaReservationManager(backend.Pass()));
 194   }
 195
 196   void TearDown() override { reservation_manager_.reset(); }
 197
 198   FakeBackend* fake_backend() {
 199     return static_cast<FakeBackend*>(reservation_manager_->backend_.get());
 200   }
 201
 202   QuotaReservationManager* reservation_manager() {
 203     return reservation_manager_.get();
 204   }
 205
 206   const base::FilePath& file_path() const {
 207     return file_path_;
 208   }
 209
 210  private:
 211   base::MessageLoop message_loop_;
 212   base::ScopedTempDir work_dir_;
 213   base::FilePath file_path_;
 214   scoped_ptr<QuotaReservationManager> reservation_manager_;
 215
 216   DISALLOW_COPY_AND_ASSIGN(QuotaReservationManagerTest);
 217 };
 218
 219 TEST_F(QuotaReservationManagerTest, BasicTest) {
 220   scoped_refptr<QuotaReservation> reservation =
 221       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 222
 223   {
 224     RefreshReservation(reservation.get(), 10 + 20 + 3);
 225     int64 cached_reserved_quota = reservation->remaining_quota();
 226     FakeWriter writer(reservation->GetOpenFileHandle(file_path()));
 227
 228     cached_reserved_quota -= writer.Write(kInitialFileSize + 10);
 229     EXPECT_LE(0, cached_reserved_quota);
 230     cached_reserved_quota -= writer.Append(20);
 231     EXPECT_LE(0, cached_reserved_quota);
 232
 233     writer.ReportUsage();
 234   }
 235
 236   EXPECT_EQ(3, reservation->remaining_quota());
 237   EXPECT_EQ(kInitialFileSize + 10 + 20, GetFileSize(file_path()));
 238   EXPECT_EQ(kInitialFileSize + 10 + 20, fake_backend()->on_disk_usage());
 239   EXPECT_EQ(kInitialFileSize + 10 + 20 + 3, fake_backend()->on_memory_usage());
 240
 241   {
 242     RefreshReservation(reservation.get(), 5);
 243     FakeWriter writer(reservation->GetOpenFileHandle(file_path()));
 244
 245     EXPECT_EQ(0, writer.Truncate(3));
 246
 247     writer.ReportUsage();
 248   }
 249
 250   EXPECT_EQ(5, reservation->remaining_quota());
 251   EXPECT_EQ(3, GetFileSize(file_path()));
 252   EXPECT_EQ(3, fake_backend()->on_disk_usage());
 253   EXPECT_EQ(3 + 5, fake_backend()->on_memory_usage());
 254
 255   reservation = NULL;
 256
 257   EXPECT_EQ(3, fake_backend()->on_memory_usage());
 258 }
 259
 260 TEST_F(QuotaReservationManagerTest, MultipleWriter) {
 261   scoped_refptr<QuotaReservation> reservation =
 262       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 263
 264   {
 265     RefreshReservation(reservation.get(), 10 + 20 + 30 + 40 + 5);
 266     int64 cached_reserved_quota = reservation->remaining_quota();
 267     FakeWriter writer1(reservation->GetOpenFileHandle(file_path()));
 268     FakeWriter writer2(reservation->GetOpenFileHandle(file_path()));
 269     FakeWriter writer3(reservation->GetOpenFileHandle(file_path()));
 270
 271     cached_reserved_quota -= writer1.Write(kInitialFileSize + 10);
 272     EXPECT_LE(0, cached_reserved_quota);
 273     cached_reserved_quota -= writer2.Write(kInitialFileSize + 20);
 274     cached_reserved_quota -= writer3.Append(30);
 275     EXPECT_LE(0, cached_reserved_quota);
 276     cached_reserved_quota -= writer3.Append(40);
 277     EXPECT_LE(0, cached_reserved_quota);
 278
 279     writer1.ReportUsage();
 280     writer2.ReportUsage();
 281     writer3.ReportUsage();
 282   }
 283
 284   EXPECT_EQ(kInitialFileSize + 20 + 30 + 40, GetFileSize(file_path()));
 285   EXPECT_EQ(kInitialFileSize + 10 + 20 + 30 + 40 + 5,
 286             fake_backend()->on_memory_usage());
 287   EXPECT_EQ(kInitialFileSize + 20 + 30 + 40, fake_backend()->on_disk_usage());
 288
 289   reservation = NULL;
 290
 291   EXPECT_EQ(kInitialFileSize + 20 + 30 + 40, fake_backend()->on_disk_usage());
 292 }
 293
 294 TEST_F(QuotaReservationManagerTest, MultipleClient) {
 295   scoped_refptr<QuotaReservation> reservation1 =
 296       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 297   RefreshReservation(reservation1.get(), 10);
 298   int64 cached_reserved_quota1 = reservation1->remaining_quota();
 299
 300   scoped_refptr<QuotaReservation> reservation2 =
 301       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 302   RefreshReservation(reservation2.get(), 20);
 303   int64 cached_reserved_quota2 = reservation2->remaining_quota();
 304
 305   scoped_ptr<FakeWriter> writer1(
 306       new FakeWriter(reservation1->GetOpenFileHandle(file_path())));
 307
 308   scoped_ptr<FakeWriter> writer2(
 309       new FakeWriter(reservation2->GetOpenFileHandle(file_path())));
 310
 311   cached_reserved_quota1 -= writer1->Write(kInitialFileSize + 10);
 312   EXPECT_LE(0, cached_reserved_quota1);
 313
 314   cached_reserved_quota2 -= writer2->Append(20);
 315   EXPECT_LE(0, cached_reserved_quota2);
 316
 317   writer1->ReportUsage();
 318   RefreshReservation(reservation1.get(), 2);
 319   cached_reserved_quota1 = reservation1->remaining_quota();
 320
 321   writer2->ReportUsage();
 322   RefreshReservation(reservation2.get(), 3);
 323   cached_reserved_quota2 = reservation2->remaining_quota();
 324
 325   writer1.reset();
 326   writer2.reset();
 327
 328   EXPECT_EQ(kInitialFileSize + 10 + 20, GetFileSize(file_path()));
 329   EXPECT_EQ(kInitialFileSize + 10 + 20 + 2 + 3,
 330             fake_backend()->on_memory_usage());
 331   EXPECT_EQ(kInitialFileSize + 10 + 20, fake_backend()->on_disk_usage());
 332
 333   reservation1 = NULL;
 334   EXPECT_EQ(kInitialFileSize + 10 + 20 + 3, fake_backend()->on_memory_usage());
 335
 336   reservation2 = NULL;
 337   EXPECT_EQ(kInitialFileSize + 10 + 20, fake_backend()->on_memory_usage());
 338 }
 339
 340 TEST_F(QuotaReservationManagerTest, ClientCrash) {
 341   scoped_refptr<QuotaReservation> reservation1 =
 342       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 343   RefreshReservation(reservation1.get(), 15);
 344
 345   scoped_refptr<QuotaReservation> reservation2 =
 346       reservation_manager()->CreateReservation(GURL(kOrigin), kType);
 347   RefreshReservation(reservation2.get(), 20);
 348
 349   {
 350     FakeWriter writer(reservation1->GetOpenFileHandle(file_path()));
 351
 352     writer.Write(kInitialFileSize + 10);
 353
 354     reservation1->OnClientCrash();
 355     writer.ClearWithoutUsageReport();
 356   }
 357   reservation1 = NULL;
 358
 359   EXPECT_EQ(kInitialFileSize + 10, GetFileSize(file_path()));
 360   EXPECT_EQ(kInitialFileSize + 15 + 20, fake_backend()->on_memory_usage());
 361   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_disk_usage());
 362
 363   reservation2 = NULL;
 364   EXPECT_EQ(kInitialFileSize + 10, fake_backend()->on_memory_usage());
 365 }
 366
 367 }  // namespace content