webkit/fileapi/file_writer_delegate_unittest.cc

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