content/browser/fileapi/file_writer_delegate_unittest.cc

   1 // Copyright 2013 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 <string>
   6 #include <vector>
   7
   8 #include "base/basictypes.h"
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/run_loop.h"
  14 #include "content/public/test/test_file_system_context.h"
  15 #include "net/base/io_buffer.h"
  16 #include "net/base/request_priority.h"
  17 #include "net/url_request/url_request.h"
  18 #include "net/url_request/url_request_context.h"
  19 #include "net/url_request/url_request_job.h"
  20 #include "net/url_request/url_request_status.h"
  21 #include "testing/platform_test.h"
  22 #include "url/gurl.h"
  23 #include "webkit/browser/fileapi/async_file_test_helper.h"
  24 #include "webkit/browser/fileapi/file_system_context.h"
  25 #include "webkit/browser/fileapi/file_system_quota_util.h"
  26 #include "webkit/browser/fileapi/file_writer_delegate.h"
  27 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
  28
  29 namespace fileapi {
  30
  31 namespace {
  32
  33 const GURL kOrigin("http://example.com");
  34 const FileSystemType kFileSystemType = kFileSystemTypeTest;
  35
  36 const char kData[] = "The quick brown fox jumps over the lazy dog.\n";
  37 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1;
  38
  39 class Result {
  40  public:
  41   Result()
  42       : status_(base::PLATFORM_FILE_OK),
  43         bytes_written_(0),
  44         write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {}
  45
  46   base::PlatformFileError status() const { return status_; }
  47   int64 bytes_written() const { return bytes_written_; }
  48   FileWriterDelegate::WriteProgressStatus write_status() const {
  49     return write_status_;
  50   }
  51
  52   void DidWrite(base::PlatformFileError status, int64 bytes,
  53                 FileWriterDelegate::WriteProgressStatus write_status) {
  54     write_status_ = write_status;
  55     if (status == base::PLATFORM_FILE_OK) {
  56       bytes_written_ += bytes;
  57       if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING)
  58         base::MessageLoop::current()->Quit();
  59     } else {
  60       EXPECT_EQ(base::PLATFORM_FILE_OK, status_);
  61       status_ = status;
  62       base::MessageLoop::current()->Quit();
  63     }
  64   }
  65
  66  private:
  67   // For post-operation status.
  68   base::PlatformFileError status_;
  69   int64 bytes_written_;
  70   FileWriterDelegate::WriteProgressStatus write_status_;
  71 };
  72
  73 }  // namespace (anonymous)
  74
  75 class FileWriterDelegateTest : public PlatformTest {
  76  public:
  77   FileWriterDelegateTest() {}
  78
  79  protected:
  80   virtual void SetUp() OVERRIDE;
  81   virtual void TearDown() OVERRIDE;
  82
  83   int64 usage() {
  84     return file_system_context_->GetQuotaUtil(kFileSystemType)
  85         ->GetOriginUsageOnFileTaskRunner(
  86               file_system_context_.get(), kOrigin, kFileSystemType);
  87   }
  88
  89   int64 GetFileSizeOnDisk(const char* test_file_path) {
  90     // There might be in-flight flush/write.
  91     base::MessageLoop::current()->PostTask(
  92         FROM_HERE, base::Bind(&base::DoNothing));
  93     base::RunLoop().RunUntilIdle();
  94
  95     FileSystemURL url = GetFileSystemURL(test_file_path);
  96     base::PlatformFileInfo file_info;
  97     EXPECT_EQ(base::PLATFORM_FILE_OK,
  98               AsyncFileTestHelper::GetMetadata(
  99                   file_system_context_, url, &file_info));
 100     return file_info.size;
 101   }
 102
 103   FileSystemURL GetFileSystemURL(const char* file_name) const {
 104     return file_system_context_->CreateCrackedFileSystemURL(
 105         kOrigin, kFileSystemType, base::FilePath().FromUTF8Unsafe(file_name));
 106   }
 107
 108   FileWriterDelegate* CreateWriterDelegate(
 109       const char* test_file_path,
 110       int64 offset,
 111       int64 allowed_growth) {
 112     SandboxFileStreamWriter* writer = new SandboxFileStreamWriter(
 113         file_system_context_.get(),
 114         GetFileSystemURL(test_file_path),
 115         offset,
 116         *file_system_context_->GetUpdateObservers(kFileSystemType));
 117     writer->set_default_quota(allowed_growth);
 118     return new FileWriterDelegate(scoped_ptr<FileStreamWriter>(writer));
 119   }
 120
 121   FileWriterDelegate::DelegateWriteCallback GetWriteCallback(Result* result) {
 122     return base::Bind(&Result::DidWrite, base::Unretained(result));
 123   }
 124
 125   // Creates and sets up a FileWriterDelegate for writing the given |blob_url|,
 126   // and creates a new FileWriterDelegate for the file.
 127   void PrepareForWrite(const char* test_file_path,
 128                        const GURL& blob_url,
 129                        int64 offset,
 130                        int64 allowed_growth) {
 131     file_writer_delegate_.reset(
 132         CreateWriterDelegate(test_file_path, offset, allowed_growth));
 133     request_ = empty_context_.CreateRequest(
 134         blob_url, net::DEFAULT_PRIORITY, file_writer_delegate_.get());
 135   }
 136
 137   static net::URLRequest::ProtocolFactory Factory;
 138
 139   // This should be alive until the very end of this instance.
 140   base::MessageLoopForIO loop_;
 141
 142   scoped_refptr<FileSystemContext> file_system_context_;
 143
 144   net::URLRequestContext empty_context_;
 145   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
 146   scoped_ptr<net::URLRequest> request_;
 147
 148   base::ScopedTempDir dir_;
 149
 150   static const char* content_;
 151 };
 152
 153 const char* FileWriterDelegateTest::content_ = NULL;
 154
 155 namespace {
 156
 157 static std::string g_content;
 158
 159 class FileWriterDelegateTestJob : public net::URLRequestJob {
 160  public:
 161   FileWriterDelegateTestJob(net::URLRequest* request,
 162                             net::NetworkDelegate* network_delegate,
 163                             const std::string& content)
 164       : net::URLRequestJob(request, network_delegate),
 165         content_(content),
 166         remaining_bytes_(content.length()),
 167         cursor_(0) {
 168   }
 169
 170   virtual void Start() OVERRIDE {
 171     base::MessageLoop::current()->PostTask(
 172         FROM_HERE,
 173         base::Bind(&FileWriterDelegateTestJob::NotifyHeadersComplete, this));
 174   }
 175
 176   virtual bool ReadRawData(net::IOBuffer* buf,
 177                            int buf_size,
 178                            int *bytes_read) OVERRIDE {
 179     if (remaining_bytes_ < buf_size)
 180       buf_size = static_cast<int>(remaining_bytes_);
 181
 182     for (int i = 0; i < buf_size; ++i)
 183       buf->data()[i] = content_[cursor_++];
 184     remaining_bytes_ -= buf_size;
 185
 186     SetStatus(net::URLRequestStatus());
 187     *bytes_read = buf_size;
 188     return true;
 189   }
 190
 191   virtual int GetResponseCode() const OVERRIDE {
 192     return 200;
 193   }
 194
 195  protected:
 196   virtual ~FileWriterDelegateTestJob() {}
 197
 198  private:
 199   std::string content_;
 200   int remaining_bytes_;
 201   int cursor_;
 202 };
 203
 204 }  // namespace (anonymous)
 205
 206 // static
 207 net::URLRequestJob* FileWriterDelegateTest::Factory(
 208     net::URLRequest* request,
 209     net::NetworkDelegate* network_delegate,
 210     const std::string& scheme) {
 211   return new FileWriterDelegateTestJob(
 212       request, network_delegate, FileWriterDelegateTest::content_);
 213 }
 214
 215 void FileWriterDelegateTest::SetUp() {
 216   ASSERT_TRUE(dir_.CreateUniqueTempDir());
 217
 218   file_system_context_ = CreateFileSystemContextForTesting(
 219       NULL, dir_.path());
 220   ASSERT_EQ(base::PLATFORM_FILE_OK,
 221             AsyncFileTestHelper::CreateFile(
 222                 file_system_context_, GetFileSystemURL("test")));
 223   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory);
 224 }
 225
 226 void FileWriterDelegateTest::TearDown() {
 227   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL);
 228   file_system_context_ = NULL;
 229   base::RunLoop().RunUntilIdle();
 230 }
 231
 232 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
 233   const GURL kBlobURL("blob:nolimit");
 234   content_ = kData;
 235
 236   PrepareForWrite("test", kBlobURL, 0, kint64max);
 237
 238   Result result;
 239   ASSERT_EQ(0, usage());
 240   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 241   base::MessageLoop::current()->Run();
 242
 243   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 244   file_writer_delegate_.reset();
 245
 246   ASSERT_EQ(kDataSize, usage());
 247   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 248   EXPECT_EQ(kDataSize, result.bytes_written());
 249   EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 250 }
 251
 252 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
 253   const GURL kBlobURL("blob:just");
 254   content_ = kData;
 255   const int64 kAllowedGrowth = kDataSize;
 256   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 257
 258   Result result;
 259   ASSERT_EQ(0, usage());
 260   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 261   base::MessageLoop::current()->Run();
 262   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 263   file_writer_delegate_.reset();
 264
 265   ASSERT_EQ(kAllowedGrowth, usage());
 266   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 267
 268   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
 269   EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 270 }
 271
 272 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) {
 273   const GURL kBlobURL("blob:failure");
 274   content_ = kData;
 275   const int64 kAllowedGrowth = kDataSize - 1;
 276   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 277
 278   Result result;
 279   ASSERT_EQ(0, usage());
 280   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 281   base::MessageLoop::current()->Run();
 282   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 283   file_writer_delegate_.reset();
 284
 285   ASSERT_EQ(kAllowedGrowth, usage());
 286   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 287
 288   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
 289   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status());
 290   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 291 }
 292
 293 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
 294   const GURL kBlobURL("blob:zero");
 295   content_ = "";
 296   int64 kAllowedGrowth = 0;
 297   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 298
 299   Result result;
 300   ASSERT_EQ(0, usage());
 301   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 302   base::MessageLoop::current()->Run();
 303   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 304   file_writer_delegate_.reset();
 305
 306   ASSERT_EQ(kAllowedGrowth, usage());
 307   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 308
 309   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
 310   EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 311   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 312 }
 313
 314 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
 315   scoped_ptr<FileWriterDelegate> file_writer_delegate2;
 316   scoped_ptr<net::URLRequest> request2;
 317
 318   ASSERT_EQ(base::PLATFORM_FILE_OK,
 319             AsyncFileTestHelper::CreateFile(
 320                 file_system_context_, GetFileSystemURL("test2")));
 321
 322   const GURL kBlobURL("blob:nolimitconcurrent");
 323   const GURL kBlobURL2("blob:nolimitconcurrent2");
 324   content_ = kData;
 325
 326   PrepareForWrite("test", kBlobURL, 0, kint64max);
 327
 328   // Credate another FileWriterDelegate for concurrent write.
 329   file_writer_delegate2.reset(CreateWriterDelegate("test2", 0, kint64max));
 330   request2 = empty_context_.CreateRequest(
 331       kBlobURL2, net::DEFAULT_PRIORITY, file_writer_delegate2.get());
 332
 333   Result result, result2;
 334   ASSERT_EQ(0, usage());
 335   file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 336   file_writer_delegate2->Start(request2.Pass(), GetWriteCallback(&result2));
 337   base::MessageLoop::current()->Run();
 338   if (result.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING ||
 339       result2.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING)
 340     base::MessageLoop::current()->Run();
 341
 342   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 343   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status());
 344   file_writer_delegate_.reset();
 345   file_writer_delegate2.reset();
 346
 347   ASSERT_EQ(kDataSize * 2, usage());
 348   EXPECT_EQ(GetFileSizeOnDisk("test") + GetFileSizeOnDisk("test2"), usage());
 349
 350   EXPECT_EQ(kDataSize, result.bytes_written());
 351   EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 352   EXPECT_EQ(kDataSize, result2.bytes_written());
 353   EXPECT_EQ(base::PLATFORM_FILE_OK, result2.status());
 354 }
 355
 356 TEST_F(FileWriterDelegateTest, WritesWithQuotaAndOffset) {
 357   const GURL kBlobURL("blob:failure-with-updated-quota");
 358   content_ = kData;
 359
 360   // Writing kDataSize (=45) bytes data while allowed_growth is 100.
 361   int64 offset = 0;
 362   int64 allowed_growth = 100;
 363   ASSERT_LT(kDataSize, allowed_growth);
 364   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 365
 366   {
 367     Result result;
 368     ASSERT_EQ(0, usage());
 369     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 370     base::MessageLoop::current()->Run();
 371     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 372     file_writer_delegate_.reset();
 373
 374     ASSERT_EQ(kDataSize, usage());
 375     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 376     EXPECT_EQ(kDataSize, result.bytes_written());
 377     EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 378   }
 379
 380   // Trying to overwrite kDataSize bytes data while allowed_growth is 20.
 381   offset = 0;
 382   allowed_growth = 20;
 383   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 384
 385   {
 386     Result result;
 387     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 388     base::MessageLoop::current()->Run();
 389     EXPECT_EQ(kDataSize, usage());
 390     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 391     EXPECT_EQ(kDataSize, result.bytes_written());
 392     EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 393     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 394   }
 395
 396   // Trying to write kDataSize bytes data from offset 25 while
 397   // allowed_growth is 55.
 398   offset = 25;
 399   allowed_growth = 55;
 400   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 401
 402   {
 403     Result result;
 404     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 405     base::MessageLoop::current()->Run();
 406     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 407     file_writer_delegate_.reset();
 408
 409     EXPECT_EQ(offset + kDataSize, usage());
 410     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 411     EXPECT_EQ(kDataSize, result.bytes_written());
 412     EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 413   }
 414
 415   // Trying to overwrite 45 bytes data while allowed_growth is -20.
 416   offset = 0;
 417   allowed_growth = -20;
 418   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 419   int64 pre_write_usage = GetFileSizeOnDisk("test");
 420
 421   {
 422     Result result;
 423     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 424     base::MessageLoop::current()->Run();
 425     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 426     file_writer_delegate_.reset();
 427
 428     EXPECT_EQ(pre_write_usage, usage());
 429     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 430     EXPECT_EQ(kDataSize, result.bytes_written());
 431     EXPECT_EQ(base::PLATFORM_FILE_OK, result.status());
 432   }
 433
 434   // Trying to overwrite 45 bytes data with offset pre_write_usage - 20,
 435   // while allowed_growth is 10.
 436   const int kOverlap = 20;
 437   offset = pre_write_usage - kOverlap;
 438   allowed_growth = 10;
 439   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 440
 441   {
 442     Result result;
 443     file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result));
 444     base::MessageLoop::current()->Run();
 445     ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 446     file_writer_delegate_.reset();
 447
 448     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
 449     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 450     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
 451     EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status());
 452   }
 453 }
 454
 455 }  // namespace fileapi