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