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 <set> 6 #include <string> 7 #include <vector> 8 9 #include "base/bind.h" 10 #include "base/files/file.h" 11 #include "base/files/file_path.h" 12 #include "base/files/file_util.h" 13 #include "base/files/scoped_temp_dir.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/run_loop.h" 16 #include "content/browser/fileapi/mock_file_change_observer.h" 17 #include "content/public/test/async_file_test_helper.h" 18 #include "content/public/test/mock_special_storage_policy.h" 19 #include "content/public/test/sandbox_file_system_test_helper.h" 20 #include "content/public/test/test_file_system_context.h" 21 #include "content/test/fileapi_test_file_set.h" 22 #include "storage/browser/fileapi/external_mount_points.h" 23 #include "storage/browser/fileapi/file_system_backend.h" 24 #include "storage/browser/fileapi/file_system_context.h" 25 #include "storage/browser/fileapi/file_system_operation_context.h" 26 #include "storage/browser/fileapi/file_system_usage_cache.h" 27 #include "storage/browser/fileapi/obfuscated_file_util.h" 28 #include "storage/browser/fileapi/sandbox_directory_database.h" 29 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h" 30 #include "storage/browser/fileapi/sandbox_isolated_origin_database.h" 31 #include "storage/browser/fileapi/sandbox_origin_database.h" 32 #include "storage/browser/quota/quota_manager.h" 33 #include "storage/common/database/database_identifier.h" 34 #include "storage/common/quota/quota_types.h" 35 #include "testing/gtest/include/gtest/gtest.h" 36 37 using content::AsyncFileTestHelper; 38 using storage::FileSystemContext; 39 using storage::FileSystemOperation; 40 using storage::FileSystemOperationContext; 41 using storage::FileSystemURL; 42 using storage::ObfuscatedFileUtil; 43 using storage::SandboxDirectoryDatabase; 44 using storage::SandboxIsolatedOriginDatabase; 45 using storage::kFileSystemTypeTemporary; 46 using storage::kFileSystemTypePersistent; 47 48 namespace content { 49 50 namespace { 51 52 bool FileExists(const base::FilePath& path) { 53 return base::PathExists(path) && !base::DirectoryExists(path); 54 } 55 56 int64 GetSize(const base::FilePath& path) { 57 int64 size; 58 EXPECT_TRUE(base::GetFileSize(path, &size)); 59 return size; 60 } 61 62 // After a move, the dest exists and the source doesn't. 63 // After a copy, both source and dest exist. 64 struct CopyMoveTestCaseRecord { 65 bool is_copy_not_move; 66 const char source_path[64]; 67 const char dest_path[64]; 68 bool cause_overwrite; 69 }; 70 71 const CopyMoveTestCaseRecord kCopyMoveTestCases[] = { 72 // This is the combinatoric set of: 73 // rename vs. same-name 74 // different directory vs. same directory 75 // overwrite vs. no-overwrite 76 // copy vs. move 77 // We can never be called with source and destination paths identical, so 78 // those cases are omitted. 79 {true, "dir0/file0", "dir0/file1", false}, 80 {false, "dir0/file0", "dir0/file1", false}, 81 {true, "dir0/file0", "dir0/file1", true}, 82 {false, "dir0/file0", "dir0/file1", true}, 83 84 {true, "dir0/file0", "dir1/file0", false}, 85 {false, "dir0/file0", "dir1/file0", false}, 86 {true, "dir0/file0", "dir1/file0", true}, 87 {false, "dir0/file0", "dir1/file0", true}, 88 {true, "dir0/file0", "dir1/file1", false}, 89 {false, "dir0/file0", "dir1/file1", false}, 90 {true, "dir0/file0", "dir1/file1", true}, 91 {false, "dir0/file0", "dir1/file1", true}, 92 }; 93 94 struct OriginEnumerationTestRecord { 95 std::string origin_url; 96 bool has_temporary; 97 bool has_persistent; 98 }; 99 100 const OriginEnumerationTestRecord kOriginEnumerationTestRecords[] = { 101 {"http://example.com", false, true}, 102 {"http://example1.com", true, false}, 103 {"https://example1.com", true, true}, 104 {"file://", false, true}, 105 {"http://example.com:8000", false, true}, 106 }; 107 108 FileSystemURL FileSystemURLAppend( 109 const FileSystemURL& url, const base::FilePath::StringType& child) { 110 return FileSystemURL::CreateForTest( 111 url.origin(), url.mount_type(), url.virtual_path().Append(child)); 112 } 113 114 FileSystemURL FileSystemURLAppendUTF8( 115 const FileSystemURL& url, const std::string& child) { 116 return FileSystemURL::CreateForTest( 117 url.origin(), 118 url.mount_type(), 119 url.virtual_path().Append(base::FilePath::FromUTF8Unsafe(child))); 120 } 121 122 FileSystemURL FileSystemURLDirName(const FileSystemURL& url) { 123 return FileSystemURL::CreateForTest( 124 url.origin(), 125 url.mount_type(), 126 storage::VirtualPath::DirName(url.virtual_path())); 127 } 128 129 std::string GetTypeString(storage::FileSystemType type) { 130 return storage::SandboxFileSystemBackendDelegate::GetTypeString(type); 131 } 132 133 bool HasFileSystemType(ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator, 134 storage::FileSystemType type) { 135 return enumerator->HasTypeDirectory(GetTypeString(type)); 136 } 137 138 } // namespace 139 140 // TODO(ericu): The vast majority of this and the other FSFU subclass tests 141 // could theoretically be shared. It would basically be a FSFU interface 142 // compliance test, and only the subclass-specific bits that look into the 143 // implementation would need to be written per-subclass. 144 class ObfuscatedFileUtilTest : public testing::Test { 145 public: 146 ObfuscatedFileUtilTest() 147 : origin_(GURL("http://www.example.com")), 148 type_(storage::kFileSystemTypeTemporary), 149 weak_factory_(this), 150 sandbox_file_system_(origin_, type_), 151 quota_status_(storage::kQuotaStatusUnknown), 152 usage_(-1) {} 153 154 virtual void SetUp() { 155 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); 156 157 storage_policy_ = new MockSpecialStoragePolicy(); 158 159 quota_manager_ = 160 new storage::QuotaManager(false /* is_incognito */, 161 data_dir_.path(), 162 base::MessageLoopProxy::current().get(), 163 base::MessageLoopProxy::current().get(), 164 storage_policy_.get()); 165 166 // Every time we create a new sandbox_file_system helper, 167 // it creates another context, which creates another path manager, 168 // another sandbox_backend, and another OFU. 169 // We need to pass in the context to skip all that. 170 file_system_context_ = CreateFileSystemContextForTesting( 171 quota_manager_->proxy(), 172 data_dir_.path()); 173 174 sandbox_file_system_.SetUp(file_system_context_.get()); 175 176 change_observers_ = 177 storage::MockFileChangeObserver::CreateList(&change_observer_); 178 } 179 180 virtual void TearDown() { 181 quota_manager_ = NULL; 182 sandbox_file_system_.TearDown(); 183 } 184 185 scoped_ptr<FileSystemOperationContext> LimitedContext( 186 int64 allowed_bytes_growth) { 187 scoped_ptr<FileSystemOperationContext> context( 188 sandbox_file_system_.NewOperationContext()); 189 context->set_allowed_bytes_growth(allowed_bytes_growth); 190 return context.Pass(); 191 } 192 193 scoped_ptr<FileSystemOperationContext> UnlimitedContext() { 194 return LimitedContext(kint64max); 195 } 196 197 FileSystemOperationContext* NewContext( 198 SandboxFileSystemTestHelper* file_system) { 199 change_observer()->ResetCount(); 200 FileSystemOperationContext* context; 201 if (file_system) 202 context = file_system->NewOperationContext(); 203 else 204 context = sandbox_file_system_.NewOperationContext(); 205 // Setting allowed_bytes_growth big enough for all tests. 206 context->set_allowed_bytes_growth(1024 * 1024); 207 context->set_change_observers(change_observers()); 208 return context; 209 } 210 211 const storage::ChangeObserverList& change_observers() const { 212 return change_observers_; 213 } 214 215 storage::MockFileChangeObserver* change_observer() { 216 return &change_observer_; 217 } 218 219 // This can only be used after SetUp has run and created file_system_context_ 220 // and obfuscated_file_util_. 221 // Use this for tests which need to run in multiple origins; we need a test 222 // helper per origin. 223 SandboxFileSystemTestHelper* NewFileSystem(const GURL& origin, 224 storage::FileSystemType type) { 225 SandboxFileSystemTestHelper* file_system = 226 new SandboxFileSystemTestHelper(origin, type); 227 228 file_system->SetUp(file_system_context_.get()); 229 return file_system; 230 } 231 232 scoped_ptr<ObfuscatedFileUtil> CreateObfuscatedFileUtil( 233 storage::SpecialStoragePolicy* storage_policy) { 234 return scoped_ptr<ObfuscatedFileUtil>( 235 ObfuscatedFileUtil::CreateForTesting( 236 storage_policy, data_dir_path(), NULL, 237 base::MessageLoopProxy::current().get())); 238 } 239 240 ObfuscatedFileUtil* ofu() { 241 return static_cast<ObfuscatedFileUtil*>(sandbox_file_system_.file_util()); 242 } 243 244 const base::FilePath& test_directory() const { 245 return data_dir_.path(); 246 } 247 248 const GURL& origin() const { 249 return origin_; 250 } 251 252 storage::FileSystemType type() const { return type_; } 253 254 std::string type_string() const { 255 return GetTypeString(type_); 256 } 257 258 int64 ComputeTotalFileSize() { 259 return sandbox_file_system_.ComputeCurrentOriginUsage() - 260 sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage(); 261 } 262 263 void GetUsageFromQuotaManager() { 264 int64 quota = -1; 265 quota_status_ = 266 AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(), 267 origin(), 268 sandbox_file_system_.type(), 269 &usage_, 270 "a); 271 EXPECT_EQ(storage::kQuotaStatusOk, quota_status_); 272 } 273 274 void RevokeUsageCache() { 275 quota_manager_->ResetUsageTracker(sandbox_file_system_.storage_type()); 276 usage_cache()->Delete(sandbox_file_system_.GetUsageCachePath()); 277 } 278 279 int64 SizeByQuotaUtil() { 280 return sandbox_file_system_.GetCachedOriginUsage(); 281 } 282 283 int64 SizeInUsageFile() { 284 base::RunLoop().RunUntilIdle(); 285 int64 usage = 0; 286 return usage_cache()->GetUsage( 287 sandbox_file_system_.GetUsageCachePath(), &usage) ? usage : -1; 288 } 289 290 bool PathExists(const FileSystemURL& url) { 291 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 292 base::File::Info file_info; 293 base::FilePath platform_path; 294 base::File::Error error = ofu()->GetFileInfo( 295 context.get(), url, &file_info, &platform_path); 296 return error == base::File::FILE_OK; 297 } 298 299 bool DirectoryExists(const FileSystemURL& url) { 300 return AsyncFileTestHelper::DirectoryExists(file_system_context(), url); 301 } 302 303 int64 usage() const { return usage_; } 304 storage::FileSystemUsageCache* usage_cache() { 305 return sandbox_file_system_.usage_cache(); 306 } 307 308 FileSystemURL CreateURLFromUTF8(const std::string& path) { 309 return sandbox_file_system_.CreateURLFromUTF8(path); 310 } 311 312 int64 PathCost(const FileSystemURL& url) { 313 return ObfuscatedFileUtil::ComputeFilePathCost(url.path()); 314 } 315 316 FileSystemURL CreateURL(const base::FilePath& path) { 317 return sandbox_file_system_.CreateURL(path); 318 } 319 320 void CheckFileAndCloseHandle(const FileSystemURL& url, base::File file) { 321 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 322 base::FilePath local_path; 323 EXPECT_EQ(base::File::FILE_OK, 324 ofu()->GetLocalFilePath(context.get(), url, &local_path)); 325 326 base::File::Info file_info0; 327 base::FilePath data_path; 328 EXPECT_EQ(base::File::FILE_OK, 329 ofu()->GetFileInfo(context.get(), url, &file_info0, &data_path)); 330 EXPECT_EQ(data_path, local_path); 331 EXPECT_TRUE(FileExists(data_path)); 332 EXPECT_EQ(0, GetSize(data_path)); 333 334 const char data[] = "test data"; 335 const int length = arraysize(data) - 1; 336 337 if (!file.IsValid()) { 338 file.Initialize(data_path, 339 base::File::FLAG_OPEN | base::File::FLAG_WRITE); 340 ASSERT_TRUE(file.IsValid()); 341 EXPECT_FALSE(file.created()); 342 } 343 ASSERT_EQ(length, file.Write(0, data, length)); 344 file.Close(); 345 346 base::File::Info file_info1; 347 EXPECT_EQ(length, GetSize(data_path)); 348 context.reset(NewContext(NULL)); 349 EXPECT_EQ(base::File::FILE_OK, 350 ofu()->GetFileInfo(context.get(), url, &file_info1, &data_path)); 351 EXPECT_EQ(data_path, local_path); 352 353 EXPECT_FALSE(file_info0.is_directory); 354 EXPECT_FALSE(file_info1.is_directory); 355 EXPECT_FALSE(file_info0.is_symbolic_link); 356 EXPECT_FALSE(file_info1.is_symbolic_link); 357 EXPECT_EQ(0, file_info0.size); 358 EXPECT_EQ(length, file_info1.size); 359 EXPECT_LE(file_info0.last_modified, file_info1.last_modified); 360 361 context.reset(NewContext(NULL)); 362 EXPECT_EQ(base::File::FILE_OK, 363 ofu()->Truncate(context.get(), url, length * 2)); 364 EXPECT_EQ(length * 2, GetSize(data_path)); 365 366 context.reset(NewContext(NULL)); 367 EXPECT_EQ(base::File::FILE_OK, 368 ofu()->Truncate(context.get(), url, 0)); 369 EXPECT_EQ(0, GetSize(data_path)); 370 } 371 372 void ValidateTestDirectory( 373 const FileSystemURL& root_url, 374 const std::set<base::FilePath::StringType>& files, 375 const std::set<base::FilePath::StringType>& directories) { 376 scoped_ptr<FileSystemOperationContext> context; 377 std::set<base::FilePath::StringType>::const_iterator iter; 378 for (iter = files.begin(); iter != files.end(); ++iter) { 379 bool created = true; 380 context.reset(NewContext(NULL)); 381 ASSERT_EQ(base::File::FILE_OK, 382 ofu()->EnsureFileExists(context.get(), 383 FileSystemURLAppend(root_url, *iter), 384 &created)); 385 ASSERT_FALSE(created); 386 } 387 for (iter = directories.begin(); iter != directories.end(); ++iter) { 388 context.reset(NewContext(NULL)); 389 EXPECT_TRUE(DirectoryExists( 390 FileSystemURLAppend(root_url, *iter))); 391 } 392 } 393 394 class UsageVerifyHelper { 395 public: 396 UsageVerifyHelper(scoped_ptr<FileSystemOperationContext> context, 397 SandboxFileSystemTestHelper* file_system, 398 int64 expected_usage) 399 : context_(context.Pass()), 400 sandbox_file_system_(file_system), 401 expected_usage_(expected_usage) {} 402 403 ~UsageVerifyHelper() { 404 base::RunLoop().RunUntilIdle(); 405 Check(); 406 } 407 408 FileSystemOperationContext* context() { 409 return context_.get(); 410 } 411 412 private: 413 void Check() { 414 ASSERT_EQ(expected_usage_, 415 sandbox_file_system_->GetCachedOriginUsage()); 416 } 417 418 scoped_ptr<FileSystemOperationContext> context_; 419 SandboxFileSystemTestHelper* sandbox_file_system_; 420 int64 expected_usage_; 421 }; 422 423 scoped_ptr<UsageVerifyHelper> AllowUsageIncrease(int64 requested_growth) { 424 int64 usage = sandbox_file_system_.GetCachedOriginUsage(); 425 return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper( 426 LimitedContext(requested_growth), 427 &sandbox_file_system_, usage + requested_growth)); 428 } 429 430 scoped_ptr<UsageVerifyHelper> DisallowUsageIncrease(int64 requested_growth) { 431 int64 usage = sandbox_file_system_.GetCachedOriginUsage(); 432 return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper( 433 LimitedContext(requested_growth - 1), &sandbox_file_system_, usage)); 434 } 435 436 void FillTestDirectory( 437 const FileSystemURL& root_url, 438 std::set<base::FilePath::StringType>* files, 439 std::set<base::FilePath::StringType>* directories) { 440 scoped_ptr<FileSystemOperationContext> context; 441 std::vector<storage::DirectoryEntry> entries; 442 EXPECT_EQ(base::File::FILE_OK, 443 AsyncFileTestHelper::ReadDirectory(file_system_context(), 444 root_url, &entries)); 445 EXPECT_EQ(0UL, entries.size()); 446 447 files->clear(); 448 files->insert(FILE_PATH_LITERAL("first")); 449 files->insert(FILE_PATH_LITERAL("second")); 450 files->insert(FILE_PATH_LITERAL("third")); 451 directories->clear(); 452 directories->insert(FILE_PATH_LITERAL("fourth")); 453 directories->insert(FILE_PATH_LITERAL("fifth")); 454 directories->insert(FILE_PATH_LITERAL("sixth")); 455 std::set<base::FilePath::StringType>::iterator iter; 456 for (iter = files->begin(); iter != files->end(); ++iter) { 457 bool created = false; 458 context.reset(NewContext(NULL)); 459 ASSERT_EQ(base::File::FILE_OK, 460 ofu()->EnsureFileExists(context.get(), 461 FileSystemURLAppend(root_url, *iter), 462 &created)); 463 ASSERT_TRUE(created); 464 } 465 for (iter = directories->begin(); iter != directories->end(); ++iter) { 466 bool exclusive = true; 467 bool recursive = false; 468 context.reset(NewContext(NULL)); 469 EXPECT_EQ(base::File::FILE_OK, 470 ofu()->CreateDirectory(context.get(), 471 FileSystemURLAppend(root_url, *iter), 472 exclusive, recursive)); 473 } 474 ValidateTestDirectory(root_url, *files, *directories); 475 } 476 477 void TestReadDirectoryHelper(const FileSystemURL& root_url) { 478 std::set<base::FilePath::StringType> files; 479 std::set<base::FilePath::StringType> directories; 480 FillTestDirectory(root_url, &files, &directories); 481 482 scoped_ptr<FileSystemOperationContext> context; 483 std::vector<storage::DirectoryEntry> entries; 484 context.reset(NewContext(NULL)); 485 EXPECT_EQ(base::File::FILE_OK, 486 AsyncFileTestHelper::ReadDirectory( 487 file_system_context(), root_url, &entries)); 488 std::vector<storage::DirectoryEntry>::iterator entry_iter; 489 EXPECT_EQ(files.size() + directories.size(), entries.size()); 490 EXPECT_TRUE(change_observer()->HasNoChange()); 491 for (entry_iter = entries.begin(); entry_iter != entries.end(); 492 ++entry_iter) { 493 const storage::DirectoryEntry& entry = *entry_iter; 494 std::set<base::FilePath::StringType>::iterator iter = 495 files.find(entry.name); 496 if (iter != files.end()) { 497 EXPECT_FALSE(entry.is_directory); 498 files.erase(iter); 499 continue; 500 } 501 iter = directories.find(entry.name); 502 EXPECT_FALSE(directories.end() == iter); 503 EXPECT_TRUE(entry.is_directory); 504 directories.erase(iter); 505 } 506 } 507 508 void TestTouchHelper(const FileSystemURL& url, bool is_file) { 509 base::Time last_access_time = base::Time::Now(); 510 base::Time last_modified_time = base::Time::Now(); 511 512 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 513 EXPECT_EQ(base::File::FILE_OK, 514 ofu()->Touch(context.get(), url, last_access_time, 515 last_modified_time)); 516 // Currently we fire no change notifications for Touch. 517 EXPECT_TRUE(change_observer()->HasNoChange()); 518 base::FilePath local_path; 519 base::File::Info file_info; 520 context.reset(NewContext(NULL)); 521 EXPECT_EQ(base::File::FILE_OK, ofu()->GetFileInfo( 522 context.get(), url, &file_info, &local_path)); 523 // We compare as time_t here to lower our resolution, to avoid false 524 // negatives caused by conversion to the local filesystem's native 525 // representation and back. 526 EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT()); 527 528 context.reset(NewContext(NULL)); 529 last_modified_time += base::TimeDelta::FromHours(1); 530 last_access_time += base::TimeDelta::FromHours(14); 531 EXPECT_EQ(base::File::FILE_OK, 532 ofu()->Touch(context.get(), url, last_access_time, 533 last_modified_time)); 534 EXPECT_TRUE(change_observer()->HasNoChange()); 535 context.reset(NewContext(NULL)); 536 EXPECT_EQ(base::File::FILE_OK, 537 ofu()->GetFileInfo(context.get(), url, &file_info, &local_path)); 538 EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT()); 539 if (is_file) // Directories in OFU don't support atime. 540 EXPECT_EQ(file_info.last_accessed.ToTimeT(), last_access_time.ToTimeT()); 541 } 542 543 void TestCopyInForeignFileHelper(bool overwrite) { 544 base::ScopedTempDir source_dir; 545 ASSERT_TRUE(source_dir.CreateUniqueTempDir()); 546 base::FilePath root_file_path = source_dir.path(); 547 base::FilePath src_file_path = root_file_path.AppendASCII("file_name"); 548 FileSystemURL dest_url = CreateURLFromUTF8("new file"); 549 int64 src_file_length = 87; 550 551 base::File file(src_file_path, 552 base::File::FLAG_CREATE | base::File::FLAG_WRITE); 553 ASSERT_TRUE(file.IsValid()); 554 EXPECT_TRUE(file.created()); 555 ASSERT_TRUE(file.SetLength(src_file_length)); 556 file.Close(); 557 558 scoped_ptr<FileSystemOperationContext> context; 559 560 if (overwrite) { 561 context.reset(NewContext(NULL)); 562 bool created = false; 563 EXPECT_EQ(base::File::FILE_OK, 564 ofu()->EnsureFileExists(context.get(), dest_url, &created)); 565 EXPECT_TRUE(created); 566 567 // We must have observed one (and only one) create_file_count. 568 EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count()); 569 EXPECT_TRUE(change_observer()->HasNoChange()); 570 } 571 572 const int64 path_cost = 573 ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path()); 574 if (!overwrite) { 575 // Verify that file creation requires sufficient quota for the path. 576 context.reset(NewContext(NULL)); 577 context->set_allowed_bytes_growth(path_cost + src_file_length - 1); 578 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 579 ofu()->CopyInForeignFile(context.get(), 580 src_file_path, dest_url)); 581 } 582 583 context.reset(NewContext(NULL)); 584 context->set_allowed_bytes_growth(path_cost + src_file_length); 585 EXPECT_EQ(base::File::FILE_OK, 586 ofu()->CopyInForeignFile(context.get(), 587 src_file_path, dest_url)); 588 589 EXPECT_TRUE(PathExists(dest_url)); 590 EXPECT_FALSE(DirectoryExists(dest_url)); 591 592 context.reset(NewContext(NULL)); 593 base::File::Info file_info; 594 base::FilePath data_path; 595 EXPECT_EQ(base::File::FILE_OK, 596 ofu()->GetFileInfo(context.get(), dest_url, &file_info, 597 &data_path)); 598 EXPECT_NE(data_path, src_file_path); 599 EXPECT_TRUE(FileExists(data_path)); 600 EXPECT_EQ(src_file_length, GetSize(data_path)); 601 602 EXPECT_EQ(base::File::FILE_OK, 603 ofu()->DeleteFile(context.get(), dest_url)); 604 } 605 606 void ClearTimestamp(const FileSystemURL& url) { 607 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 608 EXPECT_EQ(base::File::FILE_OK, 609 ofu()->Touch(context.get(), url, base::Time(), base::Time())); 610 EXPECT_EQ(base::Time(), GetModifiedTime(url)); 611 } 612 613 base::Time GetModifiedTime(const FileSystemURL& url) { 614 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 615 base::FilePath data_path; 616 base::File::Info file_info; 617 context.reset(NewContext(NULL)); 618 EXPECT_EQ(base::File::FILE_OK, 619 ofu()->GetFileInfo(context.get(), url, &file_info, &data_path)); 620 EXPECT_TRUE(change_observer()->HasNoChange()); 621 return file_info.last_modified; 622 } 623 624 void TestDirectoryTimestampHelper(const FileSystemURL& base_dir, 625 bool copy, 626 bool overwrite) { 627 scoped_ptr<FileSystemOperationContext> context; 628 const FileSystemURL src_dir_url( 629 FileSystemURLAppendUTF8(base_dir, "foo_dir")); 630 const FileSystemURL dest_dir_url( 631 FileSystemURLAppendUTF8(base_dir, "bar_dir")); 632 633 const FileSystemURL src_file_url( 634 FileSystemURLAppendUTF8(src_dir_url, "hoge")); 635 const FileSystemURL dest_file_url( 636 FileSystemURLAppendUTF8(dest_dir_url, "fuga")); 637 638 context.reset(NewContext(NULL)); 639 EXPECT_EQ(base::File::FILE_OK, 640 ofu()->CreateDirectory(context.get(), src_dir_url, true, true)); 641 context.reset(NewContext(NULL)); 642 EXPECT_EQ(base::File::FILE_OK, 643 ofu()->CreateDirectory(context.get(), dest_dir_url, true, true)); 644 645 bool created = false; 646 context.reset(NewContext(NULL)); 647 EXPECT_EQ(base::File::FILE_OK, 648 ofu()->EnsureFileExists(context.get(), src_file_url, &created)); 649 if (overwrite) { 650 context.reset(NewContext(NULL)); 651 EXPECT_EQ(base::File::FILE_OK, 652 ofu()->EnsureFileExists(context.get(), 653 dest_file_url, &created)); 654 } 655 656 ClearTimestamp(src_dir_url); 657 ClearTimestamp(dest_dir_url); 658 context.reset(NewContext(NULL)); 659 EXPECT_EQ(base::File::FILE_OK, 660 ofu()->CopyOrMoveFile(context.get(), 661 src_file_url, dest_file_url, 662 FileSystemOperation::OPTION_NONE, 663 copy)); 664 if (copy) 665 EXPECT_EQ(base::Time(), GetModifiedTime(src_dir_url)); 666 else 667 EXPECT_NE(base::Time(), GetModifiedTime(src_dir_url)); 668 EXPECT_NE(base::Time(), GetModifiedTime(dest_dir_url)); 669 } 670 671 void MaybeDropDatabasesAliveCaseTestBody() { 672 scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(NULL); 673 file_util->InitOriginDatabase(GURL(), true /*create*/); 674 ASSERT_TRUE(file_util->origin_database_ != NULL); 675 676 // Callback to Drop DB is called while ObfuscatedFileUtilTest is 677 // still alive. 678 file_util->db_flush_delay_seconds_ = 0; 679 file_util->MarkUsed(); 680 base::RunLoop().RunUntilIdle(); 681 682 ASSERT_TRUE(file_util->origin_database_ == NULL); 683 } 684 685 void MaybeDropDatabasesAlreadyDeletedCaseTestBody() { 686 // Run message loop after OFU is already deleted to make sure callback 687 // doesn't cause a crash for use after free. 688 { 689 scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil(NULL); 690 file_util->InitOriginDatabase(GURL(), true /*create*/); 691 file_util->db_flush_delay_seconds_ = 0; 692 file_util->MarkUsed(); 693 } 694 695 // At this point the callback is still in the message queue but OFU is gone. 696 base::RunLoop().RunUntilIdle(); 697 } 698 699 void DestroyDirectoryDatabase_IsolatedTestBody() { 700 storage_policy_->AddIsolated(origin_); 701 scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil( 702 storage_policy_.get()); 703 const FileSystemURL url = FileSystemURL::CreateForTest( 704 origin_, kFileSystemTypePersistent, base::FilePath()); 705 706 // Create DirectoryDatabase for isolated origin. 707 SandboxDirectoryDatabase* db = 708 file_util->GetDirectoryDatabase(url, true /* create */); 709 ASSERT_TRUE(db != NULL); 710 711 // Destory it. 712 ASSERT_TRUE(file_util->DestroyDirectoryDatabase( 713 url.origin(), GetTypeString(url.type()))); 714 ASSERT_TRUE(file_util->directories_.empty()); 715 } 716 717 void GetDirectoryDatabase_IsolatedTestBody() { 718 storage_policy_->AddIsolated(origin_); 719 scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil( 720 storage_policy_.get()); 721 const FileSystemURL url = FileSystemURL::CreateForTest( 722 origin_, kFileSystemTypePersistent, base::FilePath()); 723 724 // Create DirectoryDatabase for isolated origin. 725 SandboxDirectoryDatabase* db = 726 file_util->GetDirectoryDatabase(url, true /* create */); 727 ASSERT_TRUE(db != NULL); 728 ASSERT_EQ(1U, file_util->directories_.size()); 729 730 // Remove isolated. 731 storage_policy_->RemoveIsolated(url.origin()); 732 733 // This should still get the same database. 734 SandboxDirectoryDatabase* db2 = 735 file_util->GetDirectoryDatabase(url, false /* create */); 736 ASSERT_EQ(db, db2); 737 } 738 739 void MigrationBackFromIsolatedTestBody() { 740 std::string kFakeDirectoryData("0123456789"); 741 base::FilePath old_directory_db_path; 742 743 // Initialize the directory with one origin using 744 // SandboxIsolatedOriginDatabase. 745 { 746 std::string origin_string = storage::GetIdentifierFromOrigin(origin_); 747 SandboxIsolatedOriginDatabase database_old( 748 origin_string, data_dir_path(), 749 base::FilePath( 750 SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory)); 751 base::FilePath path; 752 EXPECT_TRUE(database_old.GetPathForOrigin(origin_string, &path)); 753 EXPECT_FALSE(path.empty()); 754 755 // Populate the origin directory with some fake data. 756 old_directory_db_path = data_dir_path().Append(path); 757 ASSERT_TRUE(base::CreateDirectory(old_directory_db_path)); 758 EXPECT_EQ(static_cast<int>(kFakeDirectoryData.size()), 759 base::WriteFile(old_directory_db_path.AppendASCII("dummy"), 760 kFakeDirectoryData.data(), 761 kFakeDirectoryData.size())); 762 } 763 764 storage_policy_->AddIsolated(origin_); 765 scoped_ptr<ObfuscatedFileUtil> file_util = CreateObfuscatedFileUtil( 766 storage_policy_.get()); 767 base::File::Error error = base::File::FILE_ERROR_FAILED; 768 base::FilePath origin_directory = file_util->GetDirectoryForOrigin( 769 origin_, true /* create */, &error); 770 EXPECT_EQ(base::File::FILE_OK, error); 771 772 // The database is migrated from the old one. 773 EXPECT_TRUE(base::DirectoryExists(origin_directory)); 774 EXPECT_FALSE(base::DirectoryExists(old_directory_db_path)); 775 776 // Check we see the same contents in the new origin directory. 777 std::string origin_db_data; 778 EXPECT_TRUE(base::PathExists(origin_directory.AppendASCII("dummy"))); 779 EXPECT_TRUE(base::ReadFileToString( 780 origin_directory.AppendASCII("dummy"), &origin_db_data)); 781 EXPECT_EQ(kFakeDirectoryData, origin_db_data); 782 } 783 784 int64 ComputeCurrentUsage() { 785 return sandbox_file_system_.ComputeCurrentOriginUsage() - 786 sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage(); 787 } 788 789 FileSystemContext* file_system_context() { 790 return sandbox_file_system_.file_system_context(); 791 } 792 793 const base::FilePath& data_dir_path() const { 794 return data_dir_.path(); 795 } 796 797 protected: 798 base::ScopedTempDir data_dir_; 799 base::MessageLoopForIO message_loop_; 800 scoped_refptr<MockSpecialStoragePolicy> storage_policy_; 801 scoped_refptr<storage::QuotaManager> quota_manager_; 802 scoped_refptr<FileSystemContext> file_system_context_; 803 GURL origin_; 804 storage::FileSystemType type_; 805 base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_; 806 SandboxFileSystemTestHelper sandbox_file_system_; 807 storage::QuotaStatusCode quota_status_; 808 int64 usage_; 809 storage::MockFileChangeObserver change_observer_; 810 storage::ChangeObserverList change_observers_; 811 812 private: 813 DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest); 814 }; 815 816 TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) { 817 FileSystemURL url = CreateURLFromUTF8("fake/file"); 818 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 819 int file_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE; 820 821 base::File file = ofu()->CreateOrOpen(context.get(), url, file_flags); 822 EXPECT_FALSE(file.IsValid()); 823 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file.error_details()); 824 825 context.reset(NewContext(NULL)); 826 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 827 ofu()->DeleteFile(context.get(), url)); 828 829 url = CreateURLFromUTF8("test file"); 830 831 EXPECT_TRUE(change_observer()->HasNoChange()); 832 833 // Verify that file creation requires sufficient quota for the path. 834 context.reset(NewContext(NULL)); 835 context->set_allowed_bytes_growth( 836 ObfuscatedFileUtil::ComputeFilePathCost(url.path()) - 1); 837 file = ofu()->CreateOrOpen(context.get(), url, file_flags); 838 EXPECT_FALSE(file.IsValid()); 839 ASSERT_EQ(base::File::FILE_ERROR_NO_SPACE, file.error_details()); 840 841 context.reset(NewContext(NULL)); 842 context->set_allowed_bytes_growth( 843 ObfuscatedFileUtil::ComputeFilePathCost(url.path())); 844 file = ofu()->CreateOrOpen(context.get(), url, file_flags); 845 EXPECT_TRUE(file.IsValid()); 846 ASSERT_TRUE(file.created()); 847 EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count()); 848 849 CheckFileAndCloseHandle(url, file.Pass()); 850 851 context.reset(NewContext(NULL)); 852 base::FilePath local_path; 853 EXPECT_EQ(base::File::FILE_OK, 854 ofu()->GetLocalFilePath(context.get(), url, &local_path)); 855 EXPECT_TRUE(base::PathExists(local_path)); 856 857 // Verify that deleting a file isn't stopped by zero quota, and that it frees 858 // up quote from its path. 859 context.reset(NewContext(NULL)); 860 context->set_allowed_bytes_growth(0); 861 EXPECT_EQ(base::File::FILE_OK, ofu()->DeleteFile(context.get(), url)); 862 EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count()); 863 EXPECT_FALSE(base::PathExists(local_path)); 864 EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(url.path()), 865 context->allowed_bytes_growth()); 866 867 context.reset(NewContext(NULL)); 868 bool exclusive = true; 869 bool recursive = true; 870 FileSystemURL directory_url = CreateURLFromUTF8( 871 "series/of/directories"); 872 url = FileSystemURLAppendUTF8(directory_url, "file name"); 873 EXPECT_EQ(base::File::FILE_OK, 874 ofu()->CreateDirectory(context.get(), directory_url, exclusive, 875 recursive)); 876 // The oepration created 3 directories recursively. 877 EXPECT_EQ(3, change_observer()->get_and_reset_create_directory_count()); 878 879 context.reset(NewContext(NULL)); 880 file = ofu()->CreateOrOpen(context.get(), url, file_flags); 881 ASSERT_TRUE(file.IsValid()); 882 ASSERT_TRUE(file.created()); 883 EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count()); 884 885 CheckFileAndCloseHandle(url, file.Pass()); 886 887 context.reset(NewContext(NULL)); 888 EXPECT_EQ(base::File::FILE_OK, 889 ofu()->GetLocalFilePath(context.get(), url, &local_path)); 890 EXPECT_TRUE(base::PathExists(local_path)); 891 892 context.reset(NewContext(NULL)); 893 EXPECT_EQ(base::File::FILE_OK, ofu()->DeleteFile(context.get(), url)); 894 EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count()); 895 EXPECT_FALSE(base::PathExists(local_path)); 896 897 // Make sure we have no unexpected changes. 898 EXPECT_TRUE(change_observer()->HasNoChange()); 899 } 900 901 TEST_F(ObfuscatedFileUtilTest, TestTruncate) { 902 bool created = false; 903 FileSystemURL url = CreateURLFromUTF8("file"); 904 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 905 906 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 907 ofu()->Truncate(context.get(), url, 4)); 908 909 context.reset(NewContext(NULL)); 910 ASSERT_EQ(base::File::FILE_OK, 911 ofu()->EnsureFileExists(context.get(), url, &created)); 912 ASSERT_TRUE(created); 913 EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count()); 914 915 context.reset(NewContext(NULL)); 916 base::FilePath local_path; 917 EXPECT_EQ(base::File::FILE_OK, 918 ofu()->GetLocalFilePath(context.get(), url, &local_path)); 919 EXPECT_EQ(0, GetSize(local_path)); 920 921 context.reset(NewContext(NULL)); 922 EXPECT_EQ(base::File::FILE_OK, ofu()->Truncate(context.get(), url, 10)); 923 EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count()); 924 EXPECT_EQ(10, GetSize(local_path)); 925 926 context.reset(NewContext(NULL)); 927 EXPECT_EQ(base::File::FILE_OK, ofu()->Truncate(context.get(), url, 1)); 928 EXPECT_EQ(1, GetSize(local_path)); 929 EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count()); 930 931 EXPECT_FALSE(DirectoryExists(url)); 932 EXPECT_TRUE(PathExists(url)); 933 934 // Make sure we have no unexpected changes. 935 EXPECT_TRUE(change_observer()->HasNoChange()); 936 } 937 938 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnTruncation) { 939 bool created = false; 940 FileSystemURL url = CreateURLFromUTF8("file"); 941 942 ASSERT_EQ(base::File::FILE_OK, 943 ofu()->EnsureFileExists( 944 AllowUsageIncrease(PathCost(url))->context(), 945 url, &created)); 946 ASSERT_TRUE(created); 947 ASSERT_EQ(0, ComputeTotalFileSize()); 948 949 ASSERT_EQ(base::File::FILE_OK, 950 ofu()->Truncate(AllowUsageIncrease(1020)->context(), url, 1020)); 951 ASSERT_EQ(1020, ComputeTotalFileSize()); 952 953 ASSERT_EQ(base::File::FILE_OK, 954 ofu()->Truncate(AllowUsageIncrease(-1020)->context(), url, 0)); 955 ASSERT_EQ(0, ComputeTotalFileSize()); 956 957 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 958 ofu()->Truncate(DisallowUsageIncrease(1021)->context(), 959 url, 1021)); 960 ASSERT_EQ(0, ComputeTotalFileSize()); 961 962 EXPECT_EQ(base::File::FILE_OK, 963 ofu()->Truncate(AllowUsageIncrease(1020)->context(), url, 1020)); 964 ASSERT_EQ(1020, ComputeTotalFileSize()); 965 966 EXPECT_EQ(base::File::FILE_OK, 967 ofu()->Truncate(AllowUsageIncrease(0)->context(), url, 1020)); 968 ASSERT_EQ(1020, ComputeTotalFileSize()); 969 970 // quota exceeded 971 { 972 scoped_ptr<UsageVerifyHelper> helper = AllowUsageIncrease(-1); 973 helper->context()->set_allowed_bytes_growth( 974 helper->context()->allowed_bytes_growth() - 1); 975 EXPECT_EQ(base::File::FILE_OK, 976 ofu()->Truncate(helper->context(), url, 1019)); 977 ASSERT_EQ(1019, ComputeTotalFileSize()); 978 } 979 980 // Delete backing file to make following truncation fail. 981 base::FilePath local_path; 982 ASSERT_EQ(base::File::FILE_OK, 983 ofu()->GetLocalFilePath(UnlimitedContext().get(), url, 984 &local_path)); 985 ASSERT_FALSE(local_path.empty()); 986 ASSERT_TRUE(base::DeleteFile(local_path, false)); 987 988 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 989 ofu()->Truncate(LimitedContext(1234).get(), url, 1234)); 990 ASSERT_EQ(0, ComputeTotalFileSize()); 991 } 992 993 TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) { 994 FileSystemURL url = CreateURLFromUTF8("fake/file"); 995 bool created = false; 996 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 997 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 998 ofu()->EnsureFileExists(context.get(), url, &created)); 999 EXPECT_TRUE(change_observer()->HasNoChange()); 1000 1001 // Verify that file creation requires sufficient quota for the path. 1002 context.reset(NewContext(NULL)); 1003 url = CreateURLFromUTF8("test file"); 1004 created = false; 1005 context->set_allowed_bytes_growth( 1006 ObfuscatedFileUtil::ComputeFilePathCost(url.path()) - 1); 1007 ASSERT_EQ(base::File::FILE_ERROR_NO_SPACE, 1008 ofu()->EnsureFileExists(context.get(), url, &created)); 1009 ASSERT_FALSE(created); 1010 EXPECT_TRUE(change_observer()->HasNoChange()); 1011 1012 context.reset(NewContext(NULL)); 1013 context->set_allowed_bytes_growth( 1014 ObfuscatedFileUtil::ComputeFilePathCost(url.path())); 1015 ASSERT_EQ(base::File::FILE_OK, 1016 ofu()->EnsureFileExists(context.get(), url, &created)); 1017 ASSERT_TRUE(created); 1018 EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count()); 1019 1020 CheckFileAndCloseHandle(url, base::File()); 1021 1022 context.reset(NewContext(NULL)); 1023 ASSERT_EQ(base::File::FILE_OK, 1024 ofu()->EnsureFileExists(context.get(), url, &created)); 1025 ASSERT_FALSE(created); 1026 EXPECT_TRUE(change_observer()->HasNoChange()); 1027 1028 // Also test in a subdirectory. 1029 url = CreateURLFromUTF8("path/to/file.txt"); 1030 context.reset(NewContext(NULL)); 1031 bool exclusive = true; 1032 bool recursive = true; 1033 EXPECT_EQ(base::File::FILE_OK, 1034 ofu()->CreateDirectory(context.get(), FileSystemURLDirName(url), 1035 exclusive, recursive)); 1036 // 2 directories: path/ and path/to. 1037 EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count()); 1038 1039 context.reset(NewContext(NULL)); 1040 ASSERT_EQ(base::File::FILE_OK, 1041 ofu()->EnsureFileExists(context.get(), url, &created)); 1042 ASSERT_TRUE(created); 1043 EXPECT_FALSE(DirectoryExists(url)); 1044 EXPECT_TRUE(PathExists(url)); 1045 EXPECT_TRUE(change_observer()->HasNoChange()); 1046 } 1047 1048 TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) { 1049 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1050 1051 bool exclusive = false; 1052 bool recursive = false; 1053 FileSystemURL url = CreateURLFromUTF8("foo/bar"); 1054 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1055 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1056 1057 context.reset(NewContext(NULL)); 1058 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1059 ofu()->DeleteDirectory(context.get(), url)); 1060 1061 FileSystemURL root = CreateURLFromUTF8(std::string()); 1062 EXPECT_FALSE(DirectoryExists(url)); 1063 EXPECT_FALSE(PathExists(url)); 1064 context.reset(NewContext(NULL)); 1065 EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), root)); 1066 1067 context.reset(NewContext(NULL)); 1068 exclusive = false; 1069 recursive = true; 1070 EXPECT_EQ(base::File::FILE_OK, 1071 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1072 EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count()); 1073 1074 EXPECT_TRUE(DirectoryExists(url)); 1075 EXPECT_TRUE(PathExists(url)); 1076 1077 context.reset(NewContext(NULL)); 1078 EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(), root)); 1079 EXPECT_TRUE(DirectoryExists(FileSystemURLDirName(url))); 1080 1081 context.reset(NewContext(NULL)); 1082 EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(), 1083 FileSystemURLDirName(url))); 1084 1085 // Can't remove a non-empty directory. 1086 context.reset(NewContext(NULL)); 1087 EXPECT_EQ(base::File::FILE_ERROR_NOT_EMPTY, 1088 ofu()->DeleteDirectory(context.get(), 1089 FileSystemURLDirName(url))); 1090 EXPECT_TRUE(change_observer()->HasNoChange()); 1091 1092 base::File::Info file_info; 1093 base::FilePath local_path; 1094 EXPECT_EQ(base::File::FILE_OK, 1095 ofu()->GetFileInfo(context.get(), url, &file_info, &local_path)); 1096 EXPECT_TRUE(local_path.empty()); 1097 EXPECT_TRUE(file_info.is_directory); 1098 EXPECT_FALSE(file_info.is_symbolic_link); 1099 1100 // Same create again should succeed, since exclusive is false. 1101 context.reset(NewContext(NULL)); 1102 EXPECT_EQ(base::File::FILE_OK, 1103 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1104 EXPECT_TRUE(change_observer()->HasNoChange()); 1105 1106 exclusive = true; 1107 recursive = true; 1108 context.reset(NewContext(NULL)); 1109 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, 1110 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1111 EXPECT_TRUE(change_observer()->HasNoChange()); 1112 1113 // Verify that deleting a directory isn't stopped by zero quota, and that it 1114 // frees up quota from its path. 1115 context.reset(NewContext(NULL)); 1116 context->set_allowed_bytes_growth(0); 1117 EXPECT_EQ(base::File::FILE_OK, ofu()->DeleteDirectory(context.get(), url)); 1118 EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count()); 1119 EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(url.path()), 1120 context->allowed_bytes_growth()); 1121 1122 url = CreateURLFromUTF8("foo/bop"); 1123 1124 EXPECT_FALSE(DirectoryExists(url)); 1125 EXPECT_FALSE(PathExists(url)); 1126 1127 context.reset(NewContext(NULL)); 1128 EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url)); 1129 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1130 ofu()->GetFileInfo(context.get(), url, &file_info, &local_path)); 1131 1132 // Verify that file creation requires sufficient quota for the path. 1133 exclusive = true; 1134 recursive = false; 1135 context.reset(NewContext(NULL)); 1136 context->set_allowed_bytes_growth( 1137 ObfuscatedFileUtil::ComputeFilePathCost(url.path()) - 1); 1138 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 1139 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1140 EXPECT_TRUE(change_observer()->HasNoChange()); 1141 1142 context.reset(NewContext(NULL)); 1143 context->set_allowed_bytes_growth( 1144 ObfuscatedFileUtil::ComputeFilePathCost(url.path())); 1145 EXPECT_EQ(base::File::FILE_OK, 1146 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1147 EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count()); 1148 1149 EXPECT_TRUE(DirectoryExists(url)); 1150 EXPECT_TRUE(PathExists(url)); 1151 1152 exclusive = true; 1153 recursive = false; 1154 context.reset(NewContext(NULL)); 1155 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, 1156 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1157 EXPECT_TRUE(change_observer()->HasNoChange()); 1158 1159 exclusive = true; 1160 recursive = false; 1161 url = CreateURLFromUTF8("foo"); 1162 context.reset(NewContext(NULL)); 1163 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, 1164 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1165 EXPECT_TRUE(change_observer()->HasNoChange()); 1166 1167 url = CreateURLFromUTF8("blah"); 1168 1169 EXPECT_FALSE(DirectoryExists(url)); 1170 EXPECT_FALSE(PathExists(url)); 1171 1172 exclusive = true; 1173 recursive = false; 1174 context.reset(NewContext(NULL)); 1175 EXPECT_EQ(base::File::FILE_OK, 1176 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1177 EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count()); 1178 1179 EXPECT_TRUE(DirectoryExists(url)); 1180 EXPECT_TRUE(PathExists(url)); 1181 1182 exclusive = true; 1183 recursive = false; 1184 context.reset(NewContext(NULL)); 1185 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, 1186 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1187 EXPECT_TRUE(change_observer()->HasNoChange()); 1188 } 1189 1190 TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) { 1191 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1192 bool exclusive = true; 1193 bool recursive = true; 1194 FileSystemURL url = CreateURLFromUTF8("directory/to/use"); 1195 EXPECT_EQ(base::File::FILE_OK, 1196 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1197 TestReadDirectoryHelper(url); 1198 } 1199 1200 TEST_F(ObfuscatedFileUtilTest, TestReadRootWithSlash) { 1201 TestReadDirectoryHelper(CreateURLFromUTF8(std::string())); 1202 } 1203 1204 TEST_F(ObfuscatedFileUtilTest, TestReadRootWithEmptyString) { 1205 TestReadDirectoryHelper(CreateURLFromUTF8("/")); 1206 } 1207 1208 TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) { 1209 FileSystemURL url = CreateURLFromUTF8("file"); 1210 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1211 1212 bool created = false; 1213 ASSERT_EQ(base::File::FILE_OK, 1214 ofu()->EnsureFileExists(context.get(), url, &created)); 1215 ASSERT_TRUE(created); 1216 1217 std::vector<storage::DirectoryEntry> entries; 1218 EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, 1219 AsyncFileTestHelper::ReadDirectory(file_system_context(), url, 1220 &entries)); 1221 1222 EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url)); 1223 } 1224 1225 TEST_F(ObfuscatedFileUtilTest, TestTouch) { 1226 FileSystemURL url = CreateURLFromUTF8("file"); 1227 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1228 1229 base::Time last_access_time = base::Time::Now(); 1230 base::Time last_modified_time = base::Time::Now(); 1231 1232 // It's not there yet. 1233 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1234 ofu()->Touch(context.get(), url, last_access_time, 1235 last_modified_time)); 1236 1237 // OK, now create it. 1238 context.reset(NewContext(NULL)); 1239 bool created = false; 1240 ASSERT_EQ(base::File::FILE_OK, 1241 ofu()->EnsureFileExists(context.get(), url, &created)); 1242 ASSERT_TRUE(created); 1243 TestTouchHelper(url, true); 1244 1245 // Now test a directory: 1246 context.reset(NewContext(NULL)); 1247 bool exclusive = true; 1248 bool recursive = false; 1249 url = CreateURLFromUTF8("dir"); 1250 ASSERT_EQ(base::File::FILE_OK, 1251 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1252 TestTouchHelper(url, false); 1253 } 1254 1255 TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) { 1256 FileSystemURL url = CreateURLFromUTF8("fake/file"); 1257 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1258 1259 url = CreateURLFromUTF8("file name"); 1260 context->set_allowed_bytes_growth(5); 1261 bool created = false; 1262 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 1263 ofu()->EnsureFileExists(context.get(), url, &created)); 1264 EXPECT_FALSE(created); 1265 context->set_allowed_bytes_growth(1024); 1266 EXPECT_EQ(base::File::FILE_OK, 1267 ofu()->EnsureFileExists(context.get(), url, &created)); 1268 EXPECT_TRUE(created); 1269 int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost(url.path()); 1270 EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth()); 1271 1272 context->set_allowed_bytes_growth(1024); 1273 bool exclusive = true; 1274 bool recursive = true; 1275 url = CreateURLFromUTF8("directory/to/use"); 1276 std::vector<base::FilePath::StringType> components; 1277 url.path().GetComponents(&components); 1278 path_cost = 0; 1279 typedef std::vector<base::FilePath::StringType>::iterator iterator; 1280 for (iterator iter = components.begin(); 1281 iter != components.end(); ++iter) { 1282 path_cost += ObfuscatedFileUtil::ComputeFilePathCost( 1283 base::FilePath(*iter)); 1284 } 1285 context.reset(NewContext(NULL)); 1286 context->set_allowed_bytes_growth(1024); 1287 EXPECT_EQ(base::File::FILE_OK, 1288 ofu()->CreateDirectory(context.get(), url, exclusive, recursive)); 1289 EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth()); 1290 } 1291 1292 TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) { 1293 FileSystemURL source_url = CreateURLFromUTF8("path0.txt"); 1294 FileSystemURL dest_url = CreateURLFromUTF8("path1.txt"); 1295 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1296 1297 bool is_copy_not_move = false; 1298 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1299 ofu()->CopyOrMoveFile(context.get(), source_url, dest_url, 1300 FileSystemOperation::OPTION_NONE, 1301 is_copy_not_move)); 1302 EXPECT_TRUE(change_observer()->HasNoChange()); 1303 context.reset(NewContext(NULL)); 1304 is_copy_not_move = true; 1305 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1306 ofu()->CopyOrMoveFile(context.get(), source_url, dest_url, 1307 FileSystemOperation::OPTION_NONE, 1308 is_copy_not_move)); 1309 EXPECT_TRUE(change_observer()->HasNoChange()); 1310 source_url = CreateURLFromUTF8("dir/dir/file"); 1311 bool exclusive = true; 1312 bool recursive = true; 1313 context.reset(NewContext(NULL)); 1314 ASSERT_EQ(base::File::FILE_OK, 1315 ofu()->CreateDirectory(context.get(), 1316 FileSystemURLDirName(source_url), 1317 exclusive, recursive)); 1318 EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count()); 1319 is_copy_not_move = false; 1320 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1321 ofu()->CopyOrMoveFile(context.get(), source_url, dest_url, 1322 FileSystemOperation::OPTION_NONE, 1323 is_copy_not_move)); 1324 EXPECT_TRUE(change_observer()->HasNoChange()); 1325 context.reset(NewContext(NULL)); 1326 is_copy_not_move = true; 1327 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1328 ofu()->CopyOrMoveFile(context.get(), source_url, dest_url, 1329 FileSystemOperation::OPTION_NONE, 1330 is_copy_not_move)); 1331 EXPECT_TRUE(change_observer()->HasNoChange()); 1332 } 1333 1334 TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) { 1335 const int64 kSourceLength = 5; 1336 const int64 kDestLength = 50; 1337 1338 for (size_t i = 0; i < arraysize(kCopyMoveTestCases); ++i) { 1339 SCOPED_TRACE(testing::Message() << "kCopyMoveTestCase " << i); 1340 const CopyMoveTestCaseRecord& test_case = kCopyMoveTestCases[i]; 1341 SCOPED_TRACE(testing::Message() << "\t is_copy_not_move " << 1342 test_case.is_copy_not_move); 1343 SCOPED_TRACE(testing::Message() << "\t source_path " << 1344 test_case.source_path); 1345 SCOPED_TRACE(testing::Message() << "\t dest_path " << 1346 test_case.dest_path); 1347 SCOPED_TRACE(testing::Message() << "\t cause_overwrite " << 1348 test_case.cause_overwrite); 1349 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1350 1351 bool exclusive = false; 1352 bool recursive = true; 1353 FileSystemURL source_url = CreateURLFromUTF8(test_case.source_path); 1354 FileSystemURL dest_url = CreateURLFromUTF8(test_case.dest_path); 1355 1356 context.reset(NewContext(NULL)); 1357 ASSERT_EQ(base::File::FILE_OK, 1358 ofu()->CreateDirectory(context.get(), 1359 FileSystemURLDirName(source_url), 1360 exclusive, recursive)); 1361 context.reset(NewContext(NULL)); 1362 ASSERT_EQ(base::File::FILE_OK, 1363 ofu()->CreateDirectory(context.get(), 1364 FileSystemURLDirName(dest_url), 1365 exclusive, recursive)); 1366 1367 bool created = false; 1368 context.reset(NewContext(NULL)); 1369 ASSERT_EQ(base::File::FILE_OK, 1370 ofu()->EnsureFileExists(context.get(), source_url, &created)); 1371 ASSERT_TRUE(created); 1372 context.reset(NewContext(NULL)); 1373 ASSERT_EQ(base::File::FILE_OK, 1374 ofu()->Truncate(context.get(), source_url, kSourceLength)); 1375 1376 if (test_case.cause_overwrite) { 1377 context.reset(NewContext(NULL)); 1378 created = false; 1379 ASSERT_EQ(base::File::FILE_OK, 1380 ofu()->EnsureFileExists(context.get(), dest_url, &created)); 1381 ASSERT_TRUE(created); 1382 context.reset(NewContext(NULL)); 1383 ASSERT_EQ(base::File::FILE_OK, 1384 ofu()->Truncate(context.get(), dest_url, kDestLength)); 1385 } 1386 1387 context.reset(NewContext(NULL)); 1388 EXPECT_EQ(base::File::FILE_OK, 1389 ofu()->CopyOrMoveFile(context.get(), source_url, dest_url, 1390 FileSystemOperation::OPTION_NONE, 1391 test_case.is_copy_not_move)); 1392 1393 if (test_case.is_copy_not_move) { 1394 base::File::Info file_info; 1395 base::FilePath local_path; 1396 context.reset(NewContext(NULL)); 1397 EXPECT_EQ(base::File::FILE_OK, 1398 ofu()->GetFileInfo(context.get(), source_url, &file_info, 1399 &local_path)); 1400 EXPECT_EQ(kSourceLength, file_info.size); 1401 EXPECT_EQ(base::File::FILE_OK, 1402 ofu()->DeleteFile(context.get(), source_url)); 1403 } else { 1404 base::File::Info file_info; 1405 base::FilePath local_path; 1406 context.reset(NewContext(NULL)); 1407 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1408 ofu()->GetFileInfo(context.get(), source_url, &file_info, 1409 &local_path)); 1410 } 1411 base::File::Info file_info; 1412 base::FilePath local_path; 1413 EXPECT_EQ(base::File::FILE_OK, 1414 ofu()->GetFileInfo(context.get(), dest_url, &file_info, 1415 &local_path)); 1416 EXPECT_EQ(kSourceLength, file_info.size); 1417 1418 EXPECT_EQ(base::File::FILE_OK, 1419 ofu()->DeleteFile(context.get(), dest_url)); 1420 } 1421 } 1422 1423 TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) { 1424 FileSystemURL src_url = CreateURLFromUTF8("src path"); 1425 FileSystemURL dest_url = CreateURLFromUTF8("destination path"); 1426 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1427 bool created = false; 1428 ASSERT_EQ(base::File::FILE_OK, 1429 ofu()->EnsureFileExists(context.get(), src_url, &created)); 1430 1431 bool is_copy = true; 1432 // Copy, no overwrite. 1433 context->set_allowed_bytes_growth( 1434 ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path()) - 1); 1435 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 1436 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1437 FileSystemOperation::OPTION_NONE, is_copy)); 1438 context.reset(NewContext(NULL)); 1439 context->set_allowed_bytes_growth( 1440 ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path())); 1441 EXPECT_EQ(base::File::FILE_OK, 1442 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1443 FileSystemOperation::OPTION_NONE, is_copy)); 1444 1445 // Copy, with overwrite. 1446 context.reset(NewContext(NULL)); 1447 context->set_allowed_bytes_growth(0); 1448 EXPECT_EQ(base::File::FILE_OK, 1449 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1450 FileSystemOperation::OPTION_NONE, is_copy)); 1451 } 1452 1453 TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) { 1454 FileSystemURL src_url = CreateURLFromUTF8("src path"); 1455 FileSystemURL dest_url = CreateURLFromUTF8("destination path"); 1456 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1457 bool created = false; 1458 ASSERT_EQ(base::File::FILE_OK, 1459 ofu()->EnsureFileExists(context.get(), src_url, &created)); 1460 1461 bool is_copy = false; 1462 // Move, rename, no overwrite. 1463 context.reset(NewContext(NULL)); 1464 context->set_allowed_bytes_growth( 1465 ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path()) - 1466 ObfuscatedFileUtil::ComputeFilePathCost(src_url.path()) - 1); 1467 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, 1468 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1469 FileSystemOperation::OPTION_NONE, is_copy)); 1470 context.reset(NewContext(NULL)); 1471 context->set_allowed_bytes_growth( 1472 ObfuscatedFileUtil::ComputeFilePathCost(dest_url.path()) - 1473 ObfuscatedFileUtil::ComputeFilePathCost(src_url.path())); 1474 EXPECT_EQ(base::File::FILE_OK, 1475 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1476 FileSystemOperation::OPTION_NONE, is_copy)); 1477 1478 context.reset(NewContext(NULL)); 1479 ASSERT_EQ(base::File::FILE_OK, 1480 ofu()->EnsureFileExists(context.get(), src_url, &created)); 1481 1482 // Move, rename, with overwrite. 1483 context.reset(NewContext(NULL)); 1484 context->set_allowed_bytes_growth(0); 1485 EXPECT_EQ(base::File::FILE_OK, 1486 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1487 FileSystemOperation::OPTION_NONE, is_copy)); 1488 } 1489 1490 TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) { 1491 FileSystemURL src_url = CreateURLFromUTF8("src path"); 1492 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1493 bool created = false; 1494 ASSERT_EQ(base::File::FILE_OK, 1495 ofu()->EnsureFileExists(context.get(), src_url, &created)); 1496 1497 bool exclusive = true; 1498 bool recursive = false; 1499 FileSystemURL dir_url = CreateURLFromUTF8("directory path"); 1500 context.reset(NewContext(NULL)); 1501 ASSERT_EQ(base::File::FILE_OK, 1502 ofu()->CreateDirectory(context.get(), dir_url, exclusive, 1503 recursive)); 1504 1505 FileSystemURL dest_url = FileSystemURLAppend( 1506 dir_url, src_url.path().value()); 1507 1508 bool is_copy = false; 1509 int64 allowed_bytes_growth = -1000; // Over quota, this should still work. 1510 // Move, no rename, no overwrite. 1511 context.reset(NewContext(NULL)); 1512 context->set_allowed_bytes_growth(allowed_bytes_growth); 1513 EXPECT_EQ(base::File::FILE_OK, 1514 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1515 FileSystemOperation::OPTION_NONE, is_copy)); 1516 EXPECT_EQ(allowed_bytes_growth, context->allowed_bytes_growth()); 1517 1518 // Move, no rename, with overwrite. 1519 context.reset(NewContext(NULL)); 1520 ASSERT_EQ(base::File::FILE_OK, 1521 ofu()->EnsureFileExists(context.get(), src_url, &created)); 1522 context.reset(NewContext(NULL)); 1523 context->set_allowed_bytes_growth(allowed_bytes_growth); 1524 EXPECT_EQ(base::File::FILE_OK, 1525 ofu()->CopyOrMoveFile(context.get(), src_url, dest_url, 1526 FileSystemOperation::OPTION_NONE, is_copy)); 1527 EXPECT_EQ( 1528 allowed_bytes_growth + 1529 ObfuscatedFileUtil::ComputeFilePathCost(src_url.path()), 1530 context->allowed_bytes_growth()); 1531 } 1532 1533 TEST_F(ObfuscatedFileUtilTest, TestCopyInForeignFile) { 1534 TestCopyInForeignFileHelper(false /* overwrite */); 1535 TestCopyInForeignFileHelper(true /* overwrite */); 1536 } 1537 1538 TEST_F(ObfuscatedFileUtilTest, TestEnumerator) { 1539 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1540 FileSystemURL src_url = CreateURLFromUTF8("source dir"); 1541 bool exclusive = true; 1542 bool recursive = false; 1543 ASSERT_EQ(base::File::FILE_OK, 1544 ofu()->CreateDirectory(context.get(), src_url, exclusive, 1545 recursive)); 1546 1547 std::set<base::FilePath::StringType> files; 1548 std::set<base::FilePath::StringType> directories; 1549 FillTestDirectory(src_url, &files, &directories); 1550 1551 FileSystemURL dest_url = CreateURLFromUTF8("destination dir"); 1552 1553 EXPECT_FALSE(DirectoryExists(dest_url)); 1554 ASSERT_EQ(base::File::FILE_OK, 1555 AsyncFileTestHelper::Copy( 1556 file_system_context(), src_url, dest_url)); 1557 1558 ValidateTestDirectory(dest_url, files, directories); 1559 EXPECT_TRUE(DirectoryExists(src_url)); 1560 EXPECT_TRUE(DirectoryExists(dest_url)); 1561 recursive = true; 1562 ASSERT_EQ(base::File::FILE_OK, 1563 AsyncFileTestHelper::Remove( 1564 file_system_context(), dest_url, recursive)); 1565 EXPECT_FALSE(DirectoryExists(dest_url)); 1566 } 1567 1568 TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) { 1569 scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> 1570 enumerator(ofu()->CreateOriginEnumerator()); 1571 // The test helper starts out with a single filesystem. 1572 EXPECT_TRUE(enumerator.get()); 1573 EXPECT_EQ(origin(), enumerator->Next()); 1574 ASSERT_TRUE(type() == kFileSystemTypeTemporary); 1575 EXPECT_TRUE(HasFileSystemType(enumerator.get(), kFileSystemTypeTemporary)); 1576 EXPECT_FALSE(HasFileSystemType(enumerator.get(), kFileSystemTypePersistent)); 1577 EXPECT_EQ(GURL(), enumerator->Next()); 1578 EXPECT_FALSE(HasFileSystemType(enumerator.get(), kFileSystemTypeTemporary)); 1579 EXPECT_FALSE(HasFileSystemType(enumerator.get(), kFileSystemTypePersistent)); 1580 1581 std::set<GURL> origins_expected; 1582 origins_expected.insert(origin()); 1583 1584 for (size_t i = 0; i < arraysize(kOriginEnumerationTestRecords); ++i) { 1585 SCOPED_TRACE(testing::Message() << 1586 "Validating kOriginEnumerationTestRecords " << i); 1587 const OriginEnumerationTestRecord& record = 1588 kOriginEnumerationTestRecords[i]; 1589 GURL origin_url(record.origin_url); 1590 origins_expected.insert(origin_url); 1591 if (record.has_temporary) { 1592 scoped_ptr<SandboxFileSystemTestHelper> file_system( 1593 NewFileSystem(origin_url, kFileSystemTypeTemporary)); 1594 scoped_ptr<FileSystemOperationContext> context( 1595 NewContext(file_system.get())); 1596 bool created = false; 1597 ASSERT_EQ(base::File::FILE_OK, 1598 ofu()->EnsureFileExists( 1599 context.get(), 1600 file_system->CreateURLFromUTF8("file"), 1601 &created)); 1602 EXPECT_TRUE(created); 1603 } 1604 if (record.has_persistent) { 1605 scoped_ptr<SandboxFileSystemTestHelper> file_system( 1606 NewFileSystem(origin_url, kFileSystemTypePersistent)); 1607 scoped_ptr<FileSystemOperationContext> context( 1608 NewContext(file_system.get())); 1609 bool created = false; 1610 ASSERT_EQ(base::File::FILE_OK, 1611 ofu()->EnsureFileExists( 1612 context.get(), 1613 file_system->CreateURLFromUTF8("file"), 1614 &created)); 1615 EXPECT_TRUE(created); 1616 } 1617 } 1618 enumerator.reset(ofu()->CreateOriginEnumerator()); 1619 EXPECT_TRUE(enumerator.get()); 1620 std::set<GURL> origins_found; 1621 GURL origin_url; 1622 while (!(origin_url = enumerator->Next()).is_empty()) { 1623 origins_found.insert(origin_url); 1624 SCOPED_TRACE(testing::Message() << "Handling " << origin_url.spec()); 1625 bool found = false; 1626 for (size_t i = 0; !found && i < arraysize(kOriginEnumerationTestRecords); 1627 ++i) { 1628 const OriginEnumerationTestRecord& record = 1629 kOriginEnumerationTestRecords[i]; 1630 if (GURL(record.origin_url) != origin_url) 1631 continue; 1632 found = true; 1633 EXPECT_EQ(record.has_temporary, 1634 HasFileSystemType(enumerator.get(), kFileSystemTypeTemporary)); 1635 EXPECT_EQ(record.has_persistent, 1636 HasFileSystemType(enumerator.get(), kFileSystemTypePersistent)); 1637 } 1638 // Deal with the default filesystem created by the test helper. 1639 if (!found && origin_url == origin()) { 1640 ASSERT_TRUE(type() == kFileSystemTypeTemporary); 1641 EXPECT_TRUE(HasFileSystemType(enumerator.get(), 1642 kFileSystemTypeTemporary)); 1643 EXPECT_FALSE(HasFileSystemType(enumerator.get(), 1644 kFileSystemTypePersistent)); 1645 found = true; 1646 } 1647 EXPECT_TRUE(found); 1648 } 1649 1650 std::set<GURL> diff; 1651 std::set_symmetric_difference(origins_expected.begin(), 1652 origins_expected.end(), origins_found.begin(), origins_found.end(), 1653 inserter(diff, diff.begin())); 1654 EXPECT_TRUE(diff.empty()); 1655 } 1656 1657 TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) { 1658 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1659 1660 int64 expected_quota = 0; 1661 1662 for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) { 1663 SCOPED_TRACE(testing::Message() << "Creating kRegularTestCase " << i); 1664 const FileSystemTestCaseRecord& test_case = 1665 kRegularFileSystemTestCases[i]; 1666 base::FilePath file_path(test_case.path); 1667 expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(file_path); 1668 if (test_case.is_directory) { 1669 bool exclusive = true; 1670 bool recursive = false; 1671 ASSERT_EQ(base::File::FILE_OK, 1672 ofu()->CreateDirectory(context.get(), CreateURL(file_path), 1673 exclusive, recursive)); 1674 } else { 1675 bool created = false; 1676 ASSERT_EQ(base::File::FILE_OK, 1677 ofu()->EnsureFileExists(context.get(), CreateURL(file_path), 1678 &created)); 1679 ASSERT_TRUE(created); 1680 ASSERT_EQ(base::File::FILE_OK, 1681 ofu()->Truncate(context.get(), CreateURL(file_path), 1682 test_case.data_file_size)); 1683 expected_quota += test_case.data_file_size; 1684 } 1685 } 1686 1687 // Usually raw size in usage cache and the usage returned by QuotaUtil 1688 // should be same. 1689 EXPECT_EQ(expected_quota, SizeInUsageFile()); 1690 EXPECT_EQ(expected_quota, SizeByQuotaUtil()); 1691 1692 RevokeUsageCache(); 1693 EXPECT_EQ(-1, SizeInUsageFile()); 1694 EXPECT_EQ(expected_quota, SizeByQuotaUtil()); 1695 1696 // This should reconstruct the cache. 1697 GetUsageFromQuotaManager(); 1698 EXPECT_EQ(expected_quota, SizeInUsageFile()); 1699 EXPECT_EQ(expected_quota, SizeByQuotaUtil()); 1700 EXPECT_EQ(expected_quota, usage()); 1701 } 1702 1703 TEST_F(ObfuscatedFileUtilTest, TestInconsistency) { 1704 const FileSystemURL kPath1 = CreateURLFromUTF8("hoge"); 1705 const FileSystemURL kPath2 = CreateURLFromUTF8("fuga"); 1706 1707 scoped_ptr<FileSystemOperationContext> context; 1708 base::File::Info file_info; 1709 base::FilePath data_path; 1710 bool created = false; 1711 1712 // Create a non-empty file. 1713 context.reset(NewContext(NULL)); 1714 EXPECT_EQ(base::File::FILE_OK, 1715 ofu()->EnsureFileExists(context.get(), kPath1, &created)); 1716 EXPECT_TRUE(created); 1717 context.reset(NewContext(NULL)); 1718 EXPECT_EQ(base::File::FILE_OK, 1719 ofu()->Truncate(context.get(), kPath1, 10)); 1720 context.reset(NewContext(NULL)); 1721 EXPECT_EQ(base::File::FILE_OK, 1722 ofu()->GetFileInfo( 1723 context.get(), kPath1, &file_info, &data_path)); 1724 EXPECT_EQ(10, file_info.size); 1725 1726 // Destroy database to make inconsistency between database and filesystem. 1727 ofu()->DestroyDirectoryDatabase(origin(), type_string()); 1728 1729 // Try to get file info of broken file. 1730 EXPECT_FALSE(PathExists(kPath1)); 1731 context.reset(NewContext(NULL)); 1732 EXPECT_EQ(base::File::FILE_OK, 1733 ofu()->EnsureFileExists(context.get(), kPath1, &created)); 1734 EXPECT_TRUE(created); 1735 context.reset(NewContext(NULL)); 1736 EXPECT_EQ(base::File::FILE_OK, 1737 ofu()->GetFileInfo( 1738 context.get(), kPath1, &file_info, &data_path)); 1739 EXPECT_EQ(0, file_info.size); 1740 1741 // Make another broken file to |kPath2|. 1742 context.reset(NewContext(NULL)); 1743 EXPECT_EQ(base::File::FILE_OK, 1744 ofu()->EnsureFileExists(context.get(), kPath2, &created)); 1745 EXPECT_TRUE(created); 1746 1747 // Destroy again. 1748 ofu()->DestroyDirectoryDatabase(origin(), type_string()); 1749 1750 // Repair broken |kPath1|. 1751 context.reset(NewContext(NULL)); 1752 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1753 ofu()->Touch(context.get(), kPath1, base::Time::Now(), 1754 base::Time::Now())); 1755 EXPECT_EQ(base::File::FILE_OK, 1756 ofu()->EnsureFileExists(context.get(), kPath1, &created)); 1757 EXPECT_TRUE(created); 1758 1759 // Copy from sound |kPath1| to broken |kPath2|. 1760 context.reset(NewContext(NULL)); 1761 EXPECT_EQ(base::File::FILE_OK, 1762 ofu()->CopyOrMoveFile(context.get(), kPath1, kPath2, 1763 FileSystemOperation::OPTION_NONE, 1764 true /* copy */)); 1765 1766 ofu()->DestroyDirectoryDatabase(origin(), type_string()); 1767 context.reset(NewContext(NULL)); 1768 base::File file = 1769 ofu()->CreateOrOpen(context.get(), kPath1, 1770 base::File::FLAG_READ | base::File::FLAG_CREATE); 1771 EXPECT_TRUE(file.IsValid()); 1772 EXPECT_TRUE(file.created()); 1773 1774 EXPECT_TRUE(file.GetInfo(&file_info)); 1775 EXPECT_EQ(0, file_info.size); 1776 } 1777 1778 TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) { 1779 const FileSystemURL kPath[] = { 1780 CreateURLFromUTF8("foo"), 1781 CreateURLFromUTF8("bar"), 1782 CreateURLFromUTF8("baz") 1783 }; 1784 const FileSystemURL empty_path = CreateURL(base::FilePath()); 1785 scoped_ptr<FileSystemOperationContext> context; 1786 1787 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) { 1788 bool created = false; 1789 context.reset(NewContext(NULL)); 1790 EXPECT_EQ(base::File::FILE_OK, 1791 ofu()->EnsureFileExists(context.get(), kPath[i], &created)); 1792 EXPECT_TRUE(created); 1793 } 1794 1795 std::vector<storage::DirectoryEntry> entries; 1796 EXPECT_EQ(base::File::FILE_OK, 1797 AsyncFileTestHelper::ReadDirectory( 1798 file_system_context(), empty_path, &entries)); 1799 EXPECT_EQ(3u, entries.size()); 1800 1801 base::FilePath local_path; 1802 EXPECT_EQ(base::File::FILE_OK, 1803 ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path)); 1804 EXPECT_TRUE(base::DeleteFile(local_path, false)); 1805 1806 entries.clear(); 1807 EXPECT_EQ(base::File::FILE_OK, 1808 AsyncFileTestHelper::ReadDirectory( 1809 file_system_context(), empty_path, &entries)); 1810 EXPECT_EQ(ARRAYSIZE_UNSAFE(kPath) - 1, entries.size()); 1811 } 1812 1813 TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) { 1814 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1815 const FileSystemURL dir_url = CreateURLFromUTF8("foo_dir"); 1816 1817 // Create working directory. 1818 EXPECT_EQ(base::File::FILE_OK, 1819 ofu()->CreateDirectory(context.get(), dir_url, false, false)); 1820 1821 // EnsureFileExists, create case. 1822 FileSystemURL url(FileSystemURLAppendUTF8(dir_url, "EnsureFileExists_file")); 1823 bool created = false; 1824 ClearTimestamp(dir_url); 1825 context.reset(NewContext(NULL)); 1826 EXPECT_EQ(base::File::FILE_OK, 1827 ofu()->EnsureFileExists(context.get(), url, &created)); 1828 EXPECT_TRUE(created); 1829 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1830 1831 // non create case. 1832 created = true; 1833 ClearTimestamp(dir_url); 1834 context.reset(NewContext(NULL)); 1835 EXPECT_EQ(base::File::FILE_OK, 1836 ofu()->EnsureFileExists(context.get(), url, &created)); 1837 EXPECT_FALSE(created); 1838 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1839 1840 // fail case. 1841 url = FileSystemURLAppendUTF8(dir_url, "EnsureFileExists_dir"); 1842 context.reset(NewContext(NULL)); 1843 EXPECT_EQ(base::File::FILE_OK, 1844 ofu()->CreateDirectory(context.get(), url, false, false)); 1845 1846 ClearTimestamp(dir_url); 1847 context.reset(NewContext(NULL)); 1848 EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE, 1849 ofu()->EnsureFileExists(context.get(), url, &created)); 1850 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1851 1852 // CreateOrOpen, create case. 1853 url = FileSystemURLAppendUTF8(dir_url, "CreateOrOpen_file"); 1854 ClearTimestamp(dir_url); 1855 context.reset(NewContext(NULL)); 1856 base::File file = 1857 ofu()->CreateOrOpen(context.get(), url, 1858 base::File::FLAG_CREATE | base::File::FLAG_WRITE); 1859 1860 EXPECT_TRUE(file.IsValid()); 1861 EXPECT_TRUE(file.created()); 1862 file.Close(); 1863 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1864 1865 // open case. 1866 ClearTimestamp(dir_url); 1867 context.reset(NewContext(NULL)); 1868 file = ofu()->CreateOrOpen(context.get(), url, 1869 base::File::FLAG_OPEN | base::File::FLAG_WRITE); 1870 EXPECT_TRUE(file.IsValid()); 1871 EXPECT_FALSE(file.created()); 1872 file.Close(); 1873 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1874 1875 // fail case 1876 ClearTimestamp(dir_url); 1877 context.reset(NewContext(NULL)); 1878 file = ofu()->CreateOrOpen(context.get(), url, 1879 base::File::FLAG_CREATE | base::File::FLAG_WRITE); 1880 EXPECT_FALSE(file.IsValid()); 1881 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error_details()); 1882 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1883 1884 // CreateDirectory, create case. 1885 // Creating CreateDirectory_dir and CreateDirectory_dir/subdir. 1886 url = FileSystemURLAppendUTF8(dir_url, "CreateDirectory_dir"); 1887 FileSystemURL subdir_url(FileSystemURLAppendUTF8(url, "subdir")); 1888 ClearTimestamp(dir_url); 1889 context.reset(NewContext(NULL)); 1890 EXPECT_EQ(base::File::FILE_OK, 1891 ofu()->CreateDirectory(context.get(), subdir_url, 1892 true /* exclusive */, true /* recursive */)); 1893 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1894 1895 // create subdir case. 1896 // Creating CreateDirectory_dir/subdir2. 1897 subdir_url = FileSystemURLAppendUTF8(url, "subdir2"); 1898 ClearTimestamp(dir_url); 1899 ClearTimestamp(url); 1900 context.reset(NewContext(NULL)); 1901 EXPECT_EQ(base::File::FILE_OK, 1902 ofu()->CreateDirectory(context.get(), subdir_url, 1903 true /* exclusive */, true /* recursive */)); 1904 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1905 EXPECT_NE(base::Time(), GetModifiedTime(url)); 1906 1907 // fail case. 1908 url = FileSystemURLAppendUTF8(dir_url, "CreateDirectory_dir"); 1909 ClearTimestamp(dir_url); 1910 context.reset(NewContext(NULL)); 1911 EXPECT_EQ(base::File::FILE_ERROR_EXISTS, 1912 ofu()->CreateDirectory(context.get(), url, 1913 true /* exclusive */, true /* recursive */)); 1914 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1915 1916 // CopyInForeignFile, create case. 1917 url = FileSystemURLAppendUTF8(dir_url, "CopyInForeignFile_file"); 1918 FileSystemURL src_path = FileSystemURLAppendUTF8( 1919 dir_url, "CopyInForeignFile_src_file"); 1920 context.reset(NewContext(NULL)); 1921 EXPECT_EQ(base::File::FILE_OK, 1922 ofu()->EnsureFileExists(context.get(), src_path, &created)); 1923 EXPECT_TRUE(created); 1924 base::FilePath src_local_path; 1925 context.reset(NewContext(NULL)); 1926 EXPECT_EQ(base::File::FILE_OK, 1927 ofu()->GetLocalFilePath(context.get(), src_path, &src_local_path)); 1928 1929 ClearTimestamp(dir_url); 1930 context.reset(NewContext(NULL)); 1931 EXPECT_EQ(base::File::FILE_OK, 1932 ofu()->CopyInForeignFile(context.get(), 1933 src_local_path, 1934 url)); 1935 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1936 } 1937 1938 TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForDeletion) { 1939 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 1940 const FileSystemURL dir_url = CreateURLFromUTF8("foo_dir"); 1941 1942 // Create working directory. 1943 EXPECT_EQ(base::File::FILE_OK, 1944 ofu()->CreateDirectory(context.get(), dir_url, false, false)); 1945 1946 // DeleteFile, delete case. 1947 FileSystemURL url = FileSystemURLAppendUTF8( 1948 dir_url, "DeleteFile_file"); 1949 bool created = false; 1950 context.reset(NewContext(NULL)); 1951 EXPECT_EQ(base::File::FILE_OK, 1952 ofu()->EnsureFileExists(context.get(), url, &created)); 1953 EXPECT_TRUE(created); 1954 1955 ClearTimestamp(dir_url); 1956 context.reset(NewContext(NULL)); 1957 EXPECT_EQ(base::File::FILE_OK, 1958 ofu()->DeleteFile(context.get(), url)); 1959 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1960 1961 // fail case. 1962 ClearTimestamp(dir_url); 1963 context.reset(NewContext(NULL)); 1964 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, 1965 ofu()->DeleteFile(context.get(), url)); 1966 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1967 1968 // DeleteDirectory, fail case. 1969 url = FileSystemURLAppendUTF8(dir_url, "DeleteDirectory_dir"); 1970 FileSystemURL file_path(FileSystemURLAppendUTF8(url, "pakeratta")); 1971 context.reset(NewContext(NULL)); 1972 EXPECT_EQ(base::File::FILE_OK, 1973 ofu()->CreateDirectory(context.get(), url, true, true)); 1974 created = false; 1975 context.reset(NewContext(NULL)); 1976 EXPECT_EQ(base::File::FILE_OK, 1977 ofu()->EnsureFileExists(context.get(), file_path, &created)); 1978 EXPECT_TRUE(created); 1979 1980 ClearTimestamp(dir_url); 1981 context.reset(NewContext(NULL)); 1982 EXPECT_EQ(base::File::FILE_ERROR_NOT_EMPTY, 1983 ofu()->DeleteDirectory(context.get(), url)); 1984 EXPECT_EQ(base::Time(), GetModifiedTime(dir_url)); 1985 1986 // delete case. 1987 context.reset(NewContext(NULL)); 1988 EXPECT_EQ(base::File::FILE_OK, 1989 ofu()->DeleteFile(context.get(), file_path)); 1990 1991 ClearTimestamp(dir_url); 1992 context.reset(NewContext(NULL)); 1993 EXPECT_EQ(base::File::FILE_OK, ofu()->DeleteDirectory(context.get(), url)); 1994 EXPECT_NE(base::Time(), GetModifiedTime(dir_url)); 1995 } 1996 1997 TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCopyAndMove) { 1998 TestDirectoryTimestampHelper( 1999 CreateURLFromUTF8("copy overwrite"), true, true); 2000 TestDirectoryTimestampHelper( 2001 CreateURLFromUTF8("copy non-overwrite"), true, false); 2002 TestDirectoryTimestampHelper( 2003 CreateURLFromUTF8("move overwrite"), false, true); 2004 TestDirectoryTimestampHelper( 2005 CreateURLFromUTF8("move non-overwrite"), false, false); 2006 } 2007 2008 TEST_F(ObfuscatedFileUtilTest, TestFileEnumeratorTimestamp) { 2009 FileSystemURL dir = CreateURLFromUTF8("foo"); 2010 FileSystemURL url1 = FileSystemURLAppendUTF8(dir, "bar"); 2011 FileSystemURL url2 = FileSystemURLAppendUTF8(dir, "baz"); 2012 2013 scoped_ptr<FileSystemOperationContext> context(NewContext(NULL)); 2014 EXPECT_EQ(base::File::FILE_OK, 2015 ofu()->CreateDirectory(context.get(), dir, false, false)); 2016 2017 bool created = false; 2018 context.reset(NewContext(NULL)); 2019 EXPECT_EQ(base::File::FILE_OK, 2020 ofu()->EnsureFileExists(context.get(), url1, &created)); 2021 EXPECT_TRUE(created); 2022 2023 context.reset(NewContext(NULL)); 2024 EXPECT_EQ(base::File::FILE_OK, 2025 ofu()->CreateDirectory(context.get(), url2, false, false)); 2026 2027 base::FilePath file_path; 2028 context.reset(NewContext(NULL)); 2029 EXPECT_EQ(base::File::FILE_OK, 2030 ofu()->GetLocalFilePath(context.get(), url1, &file_path)); 2031 EXPECT_FALSE(file_path.empty()); 2032 2033 context.reset(NewContext(NULL)); 2034 EXPECT_EQ(base::File::FILE_OK, 2035 ofu()->Touch(context.get(), url1, 2036 base::Time::Now() + base::TimeDelta::FromHours(1), 2037 base::Time())); 2038 2039 context.reset(NewContext(NULL)); 2040 scoped_ptr<storage::FileSystemFileUtil::AbstractFileEnumerator> file_enum( 2041 ofu()->CreateFileEnumerator(context.get(), dir, false)); 2042 2043 int count = 0; 2044 base::FilePath file_path_each; 2045 while (!(file_path_each = file_enum->Next()).empty()) { 2046 context.reset(NewContext(NULL)); 2047 base::File::Info file_info; 2048 base::FilePath file_path; 2049 EXPECT_EQ(base::File::FILE_OK, 2050 ofu()->GetFileInfo(context.get(), 2051 FileSystemURL::CreateForTest( 2052 dir.origin(), 2053 dir.mount_type(), 2054 file_path_each), 2055 &file_info, &file_path)); 2056 EXPECT_EQ(file_info.is_directory, file_enum->IsDirectory()); 2057 EXPECT_EQ(file_info.last_modified, file_enum->LastModifiedTime()); 2058 EXPECT_EQ(file_info.size, file_enum->Size()); 2059 ++count; 2060 } 2061 EXPECT_EQ(2, count); 2062 } 2063 2064 // crbug.com/176470 2065 #if defined(OS_WIN) || defined(OS_ANDROID) 2066 #define MAYBE_TestQuotaOnCopyFile DISABLED_TestQuotaOnCopyFile 2067 #else 2068 #define MAYBE_TestQuotaOnCopyFile TestQuotaOnCopyFile 2069 #endif 2070 TEST_F(ObfuscatedFileUtilTest, MAYBE_TestQuotaOnCopyFile) { 2071 FileSystemURL from_file(CreateURLFromUTF8("fromfile")); 2072 FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile")); 2073 FileSystemURL to_file1(CreateURLFromUTF8("tofile1")); 2074 FileSystemURL to_file2(CreateURLFromUTF8("tofile2")); 2075 bool created; 2076 2077 int64 expected_total_file_size = 0; 2078 ASSERT_EQ(base::File::FILE_OK, 2079 ofu()->EnsureFileExists( 2080 AllowUsageIncrease(PathCost(from_file))->context(), 2081 from_file, &created)); 2082 ASSERT_TRUE(created); 2083 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2084 2085 ASSERT_EQ(base::File::FILE_OK, 2086 ofu()->EnsureFileExists( 2087 AllowUsageIncrease(PathCost(obstacle_file))->context(), 2088 obstacle_file, &created)); 2089 ASSERT_TRUE(created); 2090 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2091 2092 int64 from_file_size = 1020; 2093 expected_total_file_size += from_file_size; 2094 ASSERT_EQ(base::File::FILE_OK, 2095 ofu()->Truncate( 2096 AllowUsageIncrease(from_file_size)->context(), 2097 from_file, from_file_size)); 2098 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2099 2100 int64 obstacle_file_size = 1; 2101 expected_total_file_size += obstacle_file_size; 2102 ASSERT_EQ(base::File::FILE_OK, 2103 ofu()->Truncate( 2104 AllowUsageIncrease(obstacle_file_size)->context(), 2105 obstacle_file, obstacle_file_size)); 2106 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2107 2108 int64 to_file1_size = from_file_size; 2109 expected_total_file_size += to_file1_size; 2110 ASSERT_EQ(base::File::FILE_OK, 2111 ofu()->CopyOrMoveFile( 2112 AllowUsageIncrease( 2113 PathCost(to_file1) + to_file1_size)->context(), 2114 from_file, to_file1, 2115 FileSystemOperation::OPTION_NONE, 2116 true /* copy */)); 2117 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2118 2119 ASSERT_EQ(base::File::FILE_ERROR_NO_SPACE, 2120 ofu()->CopyOrMoveFile( 2121 DisallowUsageIncrease( 2122 PathCost(to_file2) + from_file_size)->context(), 2123 from_file, to_file2, FileSystemOperation::OPTION_NONE, 2124 true /* copy */)); 2125 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2126 2127 int64 old_obstacle_file_size = obstacle_file_size; 2128 obstacle_file_size = from_file_size; 2129 expected_total_file_size += obstacle_file_size - old_obstacle_file_size; 2130 ASSERT_EQ(base::File::FILE_OK, 2131 ofu()->CopyOrMoveFile( 2132 AllowUsageIncrease( 2133 obstacle_file_size - old_obstacle_file_size)->context(), 2134 from_file, obstacle_file, 2135 FileSystemOperation::OPTION_NONE, 2136 true /* copy */)); 2137 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2138 2139 int64 old_from_file_size = from_file_size; 2140 from_file_size = old_from_file_size - 1; 2141 expected_total_file_size += from_file_size - old_from_file_size; 2142 ASSERT_EQ(base::File::FILE_OK, 2143 ofu()->Truncate( 2144 AllowUsageIncrease( 2145 from_file_size - old_from_file_size)->context(), 2146 from_file, from_file_size)); 2147 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2148 2149 // quota exceeded 2150 { 2151 old_obstacle_file_size = obstacle_file_size; 2152 obstacle_file_size = from_file_size; 2153 expected_total_file_size += obstacle_file_size - old_obstacle_file_size; 2154 scoped_ptr<UsageVerifyHelper> helper = AllowUsageIncrease( 2155 obstacle_file_size - old_obstacle_file_size); 2156 helper->context()->set_allowed_bytes_growth( 2157 helper->context()->allowed_bytes_growth() - 1); 2158 ASSERT_EQ(base::File::FILE_OK, 2159 ofu()->CopyOrMoveFile( 2160 helper->context(), 2161 from_file, obstacle_file, 2162 FileSystemOperation::OPTION_NONE, 2163 true /* copy */)); 2164 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2165 } 2166 } 2167 2168 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnMoveFile) { 2169 FileSystemURL from_file(CreateURLFromUTF8("fromfile")); 2170 FileSystemURL obstacle_file(CreateURLFromUTF8("obstaclefile")); 2171 FileSystemURL to_file(CreateURLFromUTF8("tofile")); 2172 bool created; 2173 2174 int64 expected_total_file_size = 0; 2175 ASSERT_EQ(base::File::FILE_OK, 2176 ofu()->EnsureFileExists( 2177 AllowUsageIncrease(PathCost(from_file))->context(), 2178 from_file, &created)); 2179 ASSERT_TRUE(created); 2180 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2181 2182 int64 from_file_size = 1020; 2183 expected_total_file_size += from_file_size; 2184 ASSERT_EQ(base::File::FILE_OK, 2185 ofu()->Truncate( 2186 AllowUsageIncrease(from_file_size)->context(), 2187 from_file, from_file_size)); 2188 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2189 2190 int64 to_file_size ALLOW_UNUSED = from_file_size; 2191 from_file_size = 0; 2192 ASSERT_EQ(base::File::FILE_OK, 2193 ofu()->CopyOrMoveFile( 2194 AllowUsageIncrease(-PathCost(from_file) + 2195 PathCost(to_file))->context(), 2196 from_file, to_file, 2197 FileSystemOperation::OPTION_NONE, 2198 false /* move */)); 2199 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2200 2201 ASSERT_EQ(base::File::FILE_OK, 2202 ofu()->EnsureFileExists( 2203 AllowUsageIncrease(PathCost(from_file))->context(), 2204 from_file, &created)); 2205 ASSERT_TRUE(created); 2206 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2207 2208 ASSERT_EQ(base::File::FILE_OK, 2209 ofu()->EnsureFileExists( 2210 AllowUsageIncrease(PathCost(obstacle_file))->context(), 2211 obstacle_file, &created)); 2212 ASSERT_TRUE(created); 2213 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2214 2215 from_file_size = 1020; 2216 expected_total_file_size += from_file_size; 2217 ASSERT_EQ(base::File::FILE_OK, 2218 ofu()->Truncate( 2219 AllowUsageIncrease(from_file_size)->context(), 2220 from_file, from_file_size)); 2221 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2222 2223 int64 obstacle_file_size = 1; 2224 expected_total_file_size += obstacle_file_size; 2225 ASSERT_EQ(base::File::FILE_OK, 2226 ofu()->Truncate( 2227 AllowUsageIncrease(1)->context(), 2228 obstacle_file, obstacle_file_size)); 2229 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2230 2231 int64 old_obstacle_file_size = obstacle_file_size; 2232 obstacle_file_size = from_file_size; 2233 from_file_size = 0; 2234 expected_total_file_size -= old_obstacle_file_size; 2235 ASSERT_EQ(base::File::FILE_OK, 2236 ofu()->CopyOrMoveFile( 2237 AllowUsageIncrease( 2238 -old_obstacle_file_size - PathCost(from_file))->context(), 2239 from_file, obstacle_file, 2240 FileSystemOperation::OPTION_NONE, 2241 false /* move */)); 2242 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2243 2244 ASSERT_EQ(base::File::FILE_OK, 2245 ofu()->EnsureFileExists( 2246 AllowUsageIncrease(PathCost(from_file))->context(), 2247 from_file, &created)); 2248 ASSERT_TRUE(created); 2249 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2250 2251 from_file_size = 10; 2252 expected_total_file_size += from_file_size; 2253 ASSERT_EQ(base::File::FILE_OK, 2254 ofu()->Truncate( 2255 AllowUsageIncrease(from_file_size)->context(), 2256 from_file, from_file_size)); 2257 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2258 2259 // quota exceeded even after operation 2260 old_obstacle_file_size = obstacle_file_size; 2261 obstacle_file_size = from_file_size; 2262 from_file_size = 0; 2263 expected_total_file_size -= old_obstacle_file_size; 2264 scoped_ptr<FileSystemOperationContext> context = 2265 LimitedContext(-old_obstacle_file_size - PathCost(from_file) - 1); 2266 ASSERT_EQ(base::File::FILE_OK, 2267 ofu()->CopyOrMoveFile( 2268 context.get(), from_file, obstacle_file, 2269 FileSystemOperation::OPTION_NONE, 2270 false /* move */)); 2271 ASSERT_EQ(expected_total_file_size, ComputeTotalFileSize()); 2272 context.reset(); 2273 } 2274 2275 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnRemove) { 2276 FileSystemURL dir(CreateURLFromUTF8("dir")); 2277 FileSystemURL file(CreateURLFromUTF8("file")); 2278 FileSystemURL dfile1(CreateURLFromUTF8("dir/dfile1")); 2279 FileSystemURL dfile2(CreateURLFromUTF8("dir/dfile2")); 2280 bool created; 2281 2282 ASSERT_EQ(base::File::FILE_OK, 2283 ofu()->EnsureFileExists( 2284 AllowUsageIncrease(PathCost(file))->context(), 2285 file, &created)); 2286 ASSERT_TRUE(created); 2287 ASSERT_EQ(0, ComputeTotalFileSize()); 2288 2289 ASSERT_EQ(base::File::FILE_OK, 2290 ofu()->CreateDirectory( 2291 AllowUsageIncrease(PathCost(dir))->context(), 2292 dir, false, false)); 2293 ASSERT_EQ(0, ComputeTotalFileSize()); 2294 2295 ASSERT_EQ(base::File::FILE_OK, 2296 ofu()->EnsureFileExists( 2297 AllowUsageIncrease(PathCost(dfile1))->context(), 2298 dfile1, &created)); 2299 ASSERT_TRUE(created); 2300 ASSERT_EQ(0, ComputeTotalFileSize()); 2301 2302 ASSERT_EQ(base::File::FILE_OK, 2303 ofu()->EnsureFileExists( 2304 AllowUsageIncrease(PathCost(dfile2))->context(), 2305 dfile2, &created)); 2306 ASSERT_TRUE(created); 2307 ASSERT_EQ(0, ComputeTotalFileSize()); 2308 2309 ASSERT_EQ(base::File::FILE_OK, 2310 ofu()->Truncate( 2311 AllowUsageIncrease(340)->context(), 2312 file, 340)); 2313 ASSERT_EQ(340, ComputeTotalFileSize()); 2314 2315 ASSERT_EQ(base::File::FILE_OK, 2316 ofu()->Truncate( 2317 AllowUsageIncrease(1020)->context(), 2318 dfile1, 1020)); 2319 ASSERT_EQ(1360, ComputeTotalFileSize()); 2320 2321 ASSERT_EQ(base::File::FILE_OK, 2322 ofu()->Truncate( 2323 AllowUsageIncrease(120)->context(), 2324 dfile2, 120)); 2325 ASSERT_EQ(1480, ComputeTotalFileSize()); 2326 2327 ASSERT_EQ(base::File::FILE_OK, 2328 ofu()->DeleteFile( 2329 AllowUsageIncrease(-PathCost(file) - 340)->context(), 2330 file)); 2331 ASSERT_EQ(1140, ComputeTotalFileSize()); 2332 2333 ASSERT_EQ(base::File::FILE_OK, 2334 AsyncFileTestHelper::Remove( 2335 file_system_context(), dir, true /* recursive */)); 2336 ASSERT_EQ(0, ComputeTotalFileSize()); 2337 } 2338 2339 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnOpen) { 2340 FileSystemURL url(CreateURLFromUTF8("file")); 2341 2342 bool created; 2343 // Creating a file. 2344 ASSERT_EQ(base::File::FILE_OK, 2345 ofu()->EnsureFileExists( 2346 AllowUsageIncrease(PathCost(url))->context(), 2347 url, &created)); 2348 ASSERT_TRUE(created); 2349 ASSERT_EQ(0, ComputeTotalFileSize()); 2350 2351 // Opening it, which shouldn't change the usage. 2352 base::File file = 2353 ofu()->CreateOrOpen(AllowUsageIncrease(0)->context(), url, 2354 base::File::FLAG_OPEN | base::File::FLAG_WRITE); 2355 ASSERT_TRUE(file.IsValid()); 2356 ASSERT_EQ(0, ComputeTotalFileSize()); 2357 file.Close(); 2358 2359 const int length = 33; 2360 ASSERT_EQ(base::File::FILE_OK, 2361 ofu()->Truncate( 2362 AllowUsageIncrease(length)->context(), url, length)); 2363 ASSERT_EQ(length, ComputeTotalFileSize()); 2364 2365 // Opening it with CREATE_ALWAYS flag, which should truncate the file size. 2366 file = ofu()->CreateOrOpen( 2367 AllowUsageIncrease(-length)->context(), url, 2368 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE); 2369 ASSERT_TRUE(file.IsValid()); 2370 ASSERT_EQ(0, ComputeTotalFileSize()); 2371 file.Close(); 2372 2373 // Extending the file again. 2374 ASSERT_EQ(base::File::FILE_OK, 2375 ofu()->Truncate( 2376 AllowUsageIncrease(length)->context(), url, length)); 2377 ASSERT_EQ(length, ComputeTotalFileSize()); 2378 2379 // Opening it with TRUNCATED flag, which should truncate the file size. 2380 file = ofu()->CreateOrOpen( 2381 AllowUsageIncrease(-length)->context(), url, 2382 base::File::FLAG_OPEN_TRUNCATED | base::File::FLAG_WRITE); 2383 ASSERT_TRUE(file.IsValid()); 2384 ASSERT_EQ(0, ComputeTotalFileSize()); 2385 file.Close(); 2386 } 2387 2388 TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAliveCase) { 2389 MaybeDropDatabasesAliveCaseTestBody(); 2390 } 2391 2392 TEST_F(ObfuscatedFileUtilTest, MaybeDropDatabasesAlreadyDeletedCase) { 2393 MaybeDropDatabasesAlreadyDeletedCaseTestBody(); 2394 } 2395 2396 TEST_F(ObfuscatedFileUtilTest, DestroyDirectoryDatabase_Isolated) { 2397 DestroyDirectoryDatabase_IsolatedTestBody(); 2398 } 2399 2400 TEST_F(ObfuscatedFileUtilTest, GetDirectoryDatabase_Isolated) { 2401 GetDirectoryDatabase_IsolatedTestBody(); 2402 } 2403 2404 TEST_F(ObfuscatedFileUtilTest, MigrationBackFromIsolated) { 2405 MigrationBackFromIsolatedTestBody(); 2406 } 2407 2408 TEST_F(ObfuscatedFileUtilTest, OpenPathInNonDirectory) { 2409 FileSystemURL url(CreateURLFromUTF8("file")); 2410 FileSystemURL path_in_file(CreateURLFromUTF8("file/file")); 2411 bool created; 2412 2413 ASSERT_EQ(base::File::FILE_OK, 2414 ofu()->EnsureFileExists(UnlimitedContext().get(), url, &created)); 2415 ASSERT_TRUE(created); 2416 2417 int file_flags = base::File::FLAG_CREATE | base::File::FLAG_WRITE; 2418 base::File file = 2419 ofu()->CreateOrOpen(UnlimitedContext().get(), path_in_file, file_flags); 2420 ASSERT_FALSE(file.IsValid()); 2421 ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, file.error_details()); 2422 2423 ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, 2424 ofu()->CreateDirectory(UnlimitedContext().get(), 2425 path_in_file, 2426 false /* exclusive */, 2427 false /* recursive */)); 2428 } 2429 2430 TEST_F(ObfuscatedFileUtilTest, CreateDirectory_NotADirectoryInRecursive) { 2431 FileSystemURL file(CreateURLFromUTF8("file")); 2432 FileSystemURL path_in_file(CreateURLFromUTF8("file/child")); 2433 FileSystemURL path_in_file_in_file( 2434 CreateURLFromUTF8("file/child/grandchild")); 2435 bool created; 2436 2437 ASSERT_EQ(base::File::FILE_OK, 2438 ofu()->EnsureFileExists(UnlimitedContext().get(), file, &created)); 2439 ASSERT_TRUE(created); 2440 2441 ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, 2442 ofu()->CreateDirectory(UnlimitedContext().get(), 2443 path_in_file, 2444 false /* exclusive */, 2445 true /* recursive */)); 2446 ASSERT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY, 2447 ofu()->CreateDirectory(UnlimitedContext().get(), 2448 path_in_file_in_file, 2449 false /* exclusive */, 2450 true /* recursive */)); 2451 } 2452 2453 } // namespace content 2454
