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 "chrome/browser/sync_file_system/local/canned_syncable_file_system.h" 6 7 #include <algorithm> 8 #include <iterator> 9 10 #include "base/bind.h" 11 #include "base/bind_helpers.h" 12 #include "base/file_util.h" 13 #include "base/files/file.h" 14 #include "base/guid.h" 15 #include "base/message_loop/message_loop_proxy.h" 16 #include "base/run_loop.h" 17 #include "base/single_thread_task_runner.h" 18 #include "base/task_runner_util.h" 19 #include "chrome/browser/sync_file_system/file_change.h" 20 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h" 21 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h" 22 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h" 23 #include "chrome/browser/sync_file_system/syncable_file_system_util.h" 24 #include "content/public/test/mock_blob_url_request_context.h" 25 #include "content/public/test/mock_special_storage_policy.h" 26 #include "content/public/test/test_file_system_options.h" 27 #include "testing/gtest/include/gtest/gtest.h" 28 #include "webkit/browser/fileapi/external_mount_points.h" 29 #include "webkit/browser/fileapi/file_system_backend.h" 30 #include "webkit/browser/fileapi/file_system_context.h" 31 #include "webkit/browser/fileapi/file_system_operation_context.h" 32 #include "webkit/browser/fileapi/file_system_operation_runner.h" 33 #include "webkit/browser/quota/quota_manager.h" 34 #include "webkit/common/blob/shareable_file_reference.h" 35 36 using base::File; 37 using fileapi::FileSystemContext; 38 using fileapi::FileSystemOperationRunner; 39 using fileapi::FileSystemURL; 40 using fileapi::FileSystemURLSet; 41 using quota::QuotaManager; 42 using content::MockBlobURLRequestContext; 43 using content::ScopedTextBlob; 44 45 namespace sync_file_system { 46 47 namespace { 48 49 void Quit() { base::MessageLoop::current()->Quit(); } 50 51 template <typename R> 52 void AssignAndQuit(base::TaskRunner* original_task_runner, 53 R* result_out, R result) { 54 DCHECK(result_out); 55 *result_out = result; 56 original_task_runner->PostTask(FROM_HERE, base::Bind(&Quit)); 57 } 58 59 template <typename R> 60 R RunOnThread( 61 base::SingleThreadTaskRunner* task_runner, 62 const tracked_objects::Location& location, 63 const base::Callback<void(const base::Callback<void(R)>& callback)>& task) { 64 R result; 65 task_runner->PostTask( 66 location, 67 base::Bind(task, base::Bind(&AssignAndQuit<R>, 68 base::MessageLoopProxy::current(), 69 &result))); 70 base::MessageLoop::current()->Run(); 71 return result; 72 } 73 74 void RunOnThread(base::SingleThreadTaskRunner* task_runner, 75 const tracked_objects::Location& location, 76 const base::Closure& task) { 77 task_runner->PostTaskAndReply( 78 location, task, 79 base::Bind(base::IgnoreResult( 80 base::Bind(&base::MessageLoopProxy::PostTask, 81 base::MessageLoopProxy::current(), 82 FROM_HERE, base::Bind(&Quit))))); 83 base::MessageLoop::current()->Run(); 84 } 85 86 void EnsureRunningOn(base::SingleThreadTaskRunner* runner) { 87 EXPECT_TRUE(runner->RunsTasksOnCurrentThread()); 88 } 89 90 void VerifySameTaskRunner( 91 base::SingleThreadTaskRunner* runner1, 92 base::SingleThreadTaskRunner* runner2) { 93 ASSERT_TRUE(runner1 != NULL); 94 ASSERT_TRUE(runner2 != NULL); 95 runner1->PostTask(FROM_HERE, 96 base::Bind(&EnsureRunningOn, make_scoped_refptr(runner2))); 97 } 98 99 void OnCreateSnapshotFileAndVerifyData( 100 const std::string& expected_data, 101 const CannedSyncableFileSystem::StatusCallback& callback, 102 base::File::Error result, 103 const base::File::Info& file_info, 104 const base::FilePath& platform_path, 105 const scoped_refptr<webkit_blob::ShareableFileReference>& /* file_ref */) { 106 if (result != base::File::FILE_OK) { 107 callback.Run(result); 108 return; 109 } 110 EXPECT_EQ(expected_data.size(), static_cast<size_t>(file_info.size)); 111 std::string data; 112 const bool read_status = base::ReadFileToString(platform_path, &data); 113 EXPECT_TRUE(read_status); 114 EXPECT_EQ(expected_data, data); 115 callback.Run(result); 116 } 117 118 void OnCreateSnapshotFile( 119 base::File::Info* file_info_out, 120 base::FilePath* platform_path_out, 121 const CannedSyncableFileSystem::StatusCallback& callback, 122 base::File::Error result, 123 const base::File::Info& file_info, 124 const base::FilePath& platform_path, 125 const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) { 126 DCHECK(!file_ref.get()); 127 DCHECK(file_info_out); 128 DCHECK(platform_path_out); 129 *file_info_out = file_info; 130 *platform_path_out = platform_path; 131 callback.Run(result); 132 } 133 134 void OnReadDirectory( 135 CannedSyncableFileSystem::FileEntryList* entries_out, 136 const CannedSyncableFileSystem::StatusCallback& callback, 137 base::File::Error error, 138 const fileapi::FileSystemOperation::FileEntryList& entries, 139 bool has_more) { 140 DCHECK(entries_out); 141 entries_out->reserve(entries_out->size() + entries.size()); 142 std::copy(entries.begin(), entries.end(), std::back_inserter(*entries_out)); 143 144 if (!has_more) 145 callback.Run(error); 146 } 147 148 class WriteHelper { 149 public: 150 WriteHelper() : bytes_written_(0) {} 151 WriteHelper(MockBlobURLRequestContext* request_context, 152 const std::string& blob_data) 153 : bytes_written_(0), 154 request_context_(request_context), 155 blob_data_(new ScopedTextBlob(*request_context, 156 base::GenerateGUID(), 157 blob_data)) { 158 } 159 160 ~WriteHelper() { 161 if (request_context_) { 162 base::MessageLoop::current()->DeleteSoon(FROM_HERE, 163 request_context_.release()); 164 } 165 } 166 167 ScopedTextBlob* scoped_text_blob() const { return blob_data_.get(); } 168 169 void DidWrite(const base::Callback<void(int64 result)>& completion_callback, 170 File::Error error, int64 bytes, bool complete) { 171 if (error == base::File::FILE_OK) { 172 bytes_written_ += bytes; 173 if (!complete) 174 return; 175 } 176 completion_callback.Run(error == base::File::FILE_OK ? 177 bytes_written_ : static_cast<int64>(error)); 178 } 179 180 private: 181 int64 bytes_written_; 182 scoped_ptr<MockBlobURLRequestContext> request_context_; 183 scoped_ptr<ScopedTextBlob> blob_data_; 184 185 DISALLOW_COPY_AND_ASSIGN(WriteHelper); 186 }; 187 188 void DidGetUsageAndQuota(const quota::StatusCallback& callback, 189 int64* usage_out, int64* quota_out, 190 quota::QuotaStatusCode status, 191 int64 usage, int64 quota) { 192 *usage_out = usage; 193 *quota_out = quota; 194 callback.Run(status); 195 } 196 197 void EnsureLastTaskRuns(base::SingleThreadTaskRunner* runner) { 198 base::RunLoop run_loop; 199 runner->PostTaskAndReply( 200 FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure()); 201 run_loop.Run(); 202 } 203 204 } // namespace 205 206 CannedSyncableFileSystem::CannedSyncableFileSystem( 207 const GURL& origin, 208 leveldb::Env* env_override, 209 base::SingleThreadTaskRunner* io_task_runner, 210 base::SingleThreadTaskRunner* file_task_runner) 211 : origin_(origin), 212 type_(fileapi::kFileSystemTypeSyncable), 213 result_(base::File::FILE_OK), 214 sync_status_(sync_file_system::SYNC_STATUS_OK), 215 env_override_(env_override), 216 io_task_runner_(io_task_runner), 217 file_task_runner_(file_task_runner), 218 is_filesystem_set_up_(false), 219 is_filesystem_opened_(false), 220 sync_status_observers_(new ObserverList) { 221 } 222 223 CannedSyncableFileSystem::~CannedSyncableFileSystem() {} 224 225 void CannedSyncableFileSystem::SetUp(QuotaMode quota_mode) { 226 ASSERT_FALSE(is_filesystem_set_up_); 227 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); 228 229 scoped_refptr<quota::SpecialStoragePolicy> storage_policy = 230 new content::MockSpecialStoragePolicy(); 231 232 if (quota_mode == QUOTA_ENABLED) { 233 quota_manager_ = new QuotaManager(false /* is_incognito */, 234 data_dir_.path(), 235 io_task_runner_.get(), 236 base::MessageLoopProxy::current().get(), 237 storage_policy.get()); 238 } 239 240 std::vector<std::string> additional_allowed_schemes; 241 additional_allowed_schemes.push_back(origin_.scheme()); 242 fileapi::FileSystemOptions options( 243 fileapi::FileSystemOptions::PROFILE_MODE_NORMAL, 244 additional_allowed_schemes, 245 env_override_); 246 247 ScopedVector<fileapi::FileSystemBackend> additional_backends; 248 additional_backends.push_back(SyncFileSystemBackend::CreateForTesting()); 249 250 file_system_context_ = new FileSystemContext( 251 io_task_runner_.get(), 252 file_task_runner_.get(), 253 fileapi::ExternalMountPoints::CreateRefCounted().get(), 254 storage_policy.get(), 255 quota_manager_ ? quota_manager_->proxy() : NULL, 256 additional_backends.Pass(), 257 std::vector<fileapi::URLRequestAutoMountHandler>(), 258 data_dir_.path(), options); 259 260 is_filesystem_set_up_ = true; 261 } 262 263 void CannedSyncableFileSystem::TearDown() { 264 quota_manager_ = NULL; 265 file_system_context_ = NULL; 266 267 // Make sure we give some more time to finish tasks on other threads. 268 EnsureLastTaskRuns(io_task_runner_.get()); 269 EnsureLastTaskRuns(file_task_runner_.get()); 270 } 271 272 FileSystemURL CannedSyncableFileSystem::URL(const std::string& path) const { 273 EXPECT_TRUE(is_filesystem_set_up_); 274 EXPECT_FALSE(root_url_.is_empty()); 275 276 GURL url(root_url_.spec() + path); 277 return file_system_context_->CrackURL(url); 278 } 279 280 File::Error CannedSyncableFileSystem::OpenFileSystem() { 281 EXPECT_TRUE(is_filesystem_set_up_); 282 283 io_task_runner_->PostTask( 284 FROM_HERE, 285 base::Bind(&CannedSyncableFileSystem::DoOpenFileSystem, 286 base::Unretained(this), 287 base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem, 288 base::Unretained(this), 289 base::MessageLoopProxy::current()))); 290 base::MessageLoop::current()->Run(); 291 292 if (backend()->sync_context()) { 293 // Register 'this' as a sync status observer. 294 RunOnThread( 295 io_task_runner_.get(), 296 FROM_HERE, 297 base::Bind(&CannedSyncableFileSystem::InitializeSyncStatusObserver, 298 base::Unretained(this))); 299 } 300 return result_; 301 } 302 303 void CannedSyncableFileSystem::AddSyncStatusObserver( 304 LocalFileSyncStatus::Observer* observer) { 305 sync_status_observers_->AddObserver(observer); 306 } 307 308 void CannedSyncableFileSystem::RemoveSyncStatusObserver( 309 LocalFileSyncStatus::Observer* observer) { 310 sync_status_observers_->RemoveObserver(observer); 311 } 312 313 SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext( 314 LocalFileSyncContext* sync_context) { 315 DCHECK(sync_context); 316 sync_status_ = sync_file_system::SYNC_STATUS_UNKNOWN; 317 VerifySameTaskRunner(io_task_runner_.get(), 318 sync_context->io_task_runner_.get()); 319 sync_context->MaybeInitializeFileSystemContext( 320 origin_, 321 file_system_context_.get(), 322 base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext, 323 base::Unretained(this))); 324 base::MessageLoop::current()->Run(); 325 return sync_status_; 326 } 327 328 File::Error CannedSyncableFileSystem::CreateDirectory( 329 const FileSystemURL& url) { 330 return RunOnThread<File::Error>( 331 io_task_runner_.get(), 332 FROM_HERE, 333 base::Bind(&CannedSyncableFileSystem::DoCreateDirectory, 334 base::Unretained(this), 335 url)); 336 } 337 338 File::Error CannedSyncableFileSystem::CreateFile(const FileSystemURL& url) { 339 return RunOnThread<File::Error>( 340 io_task_runner_.get(), 341 FROM_HERE, 342 base::Bind(&CannedSyncableFileSystem::DoCreateFile, 343 base::Unretained(this), 344 url)); 345 } 346 347 File::Error CannedSyncableFileSystem::Copy( 348 const FileSystemURL& src_url, const FileSystemURL& dest_url) { 349 return RunOnThread<File::Error>( 350 io_task_runner_.get(), 351 FROM_HERE, 352 base::Bind(&CannedSyncableFileSystem::DoCopy, 353 base::Unretained(this), 354 src_url, 355 dest_url)); 356 } 357 358 File::Error CannedSyncableFileSystem::Move( 359 const FileSystemURL& src_url, const FileSystemURL& dest_url) { 360 return RunOnThread<File::Error>( 361 io_task_runner_.get(), 362 FROM_HERE, 363 base::Bind(&CannedSyncableFileSystem::DoMove, 364 base::Unretained(this), 365 src_url, 366 dest_url)); 367 } 368 369 File::Error CannedSyncableFileSystem::TruncateFile( 370 const FileSystemURL& url, int64 size) { 371 return RunOnThread<File::Error>( 372 io_task_runner_.get(), 373 FROM_HERE, 374 base::Bind(&CannedSyncableFileSystem::DoTruncateFile, 375 base::Unretained(this), 376 url, 377 size)); 378 } 379 380 File::Error CannedSyncableFileSystem::TouchFile( 381 const FileSystemURL& url, 382 const base::Time& last_access_time, 383 const base::Time& last_modified_time) { 384 return RunOnThread<File::Error>( 385 io_task_runner_.get(), 386 FROM_HERE, 387 base::Bind(&CannedSyncableFileSystem::DoTouchFile, 388 base::Unretained(this), 389 url, 390 last_access_time, 391 last_modified_time)); 392 } 393 394 File::Error CannedSyncableFileSystem::Remove( 395 const FileSystemURL& url, bool recursive) { 396 return RunOnThread<File::Error>( 397 io_task_runner_.get(), 398 FROM_HERE, 399 base::Bind(&CannedSyncableFileSystem::DoRemove, 400 base::Unretained(this), 401 url, 402 recursive)); 403 } 404 405 File::Error CannedSyncableFileSystem::FileExists( 406 const FileSystemURL& url) { 407 return RunOnThread<File::Error>( 408 io_task_runner_.get(), 409 FROM_HERE, 410 base::Bind(&CannedSyncableFileSystem::DoFileExists, 411 base::Unretained(this), 412 url)); 413 } 414 415 File::Error CannedSyncableFileSystem::DirectoryExists( 416 const FileSystemURL& url) { 417 return RunOnThread<File::Error>( 418 io_task_runner_.get(), 419 FROM_HERE, 420 base::Bind(&CannedSyncableFileSystem::DoDirectoryExists, 421 base::Unretained(this), 422 url)); 423 } 424 425 File::Error CannedSyncableFileSystem::VerifyFile( 426 const FileSystemURL& url, 427 const std::string& expected_data) { 428 return RunOnThread<File::Error>( 429 io_task_runner_.get(), 430 FROM_HERE, 431 base::Bind(&CannedSyncableFileSystem::DoVerifyFile, 432 base::Unretained(this), 433 url, 434 expected_data)); 435 } 436 437 File::Error CannedSyncableFileSystem::GetMetadataAndPlatformPath( 438 const FileSystemURL& url, 439 base::File::Info* info, 440 base::FilePath* platform_path) { 441 return RunOnThread<File::Error>( 442 io_task_runner_.get(), 443 FROM_HERE, 444 base::Bind(&CannedSyncableFileSystem::DoGetMetadataAndPlatformPath, 445 base::Unretained(this), 446 url, 447 info, 448 platform_path)); 449 } 450 451 File::Error CannedSyncableFileSystem::ReadDirectory( 452 const fileapi::FileSystemURL& url, 453 FileEntryList* entries) { 454 return RunOnThread<File::Error>( 455 io_task_runner_.get(), 456 FROM_HERE, 457 base::Bind(&CannedSyncableFileSystem::DoReadDirectory, 458 base::Unretained(this), 459 url, 460 entries)); 461 } 462 463 int64 CannedSyncableFileSystem::Write( 464 net::URLRequestContext* url_request_context, 465 const FileSystemURL& url, 466 scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle) { 467 return RunOnThread<int64>(io_task_runner_.get(), 468 FROM_HERE, 469 base::Bind(&CannedSyncableFileSystem::DoWrite, 470 base::Unretained(this), 471 url_request_context, 472 url, 473 base::Passed(&blob_data_handle))); 474 } 475 476 int64 CannedSyncableFileSystem::WriteString( 477 const FileSystemURL& url, const std::string& data) { 478 return RunOnThread<int64>(io_task_runner_.get(), 479 FROM_HERE, 480 base::Bind(&CannedSyncableFileSystem::DoWriteString, 481 base::Unretained(this), 482 url, 483 data)); 484 } 485 486 File::Error CannedSyncableFileSystem::DeleteFileSystem() { 487 EXPECT_TRUE(is_filesystem_set_up_); 488 return RunOnThread<File::Error>( 489 io_task_runner_.get(), 490 FROM_HERE, 491 base::Bind(&FileSystemContext::DeleteFileSystem, 492 file_system_context_, 493 origin_, 494 type_)); 495 } 496 497 quota::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota( 498 int64* usage, int64* quota) { 499 return RunOnThread<quota::QuotaStatusCode>( 500 io_task_runner_.get(), 501 FROM_HERE, 502 base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota, 503 base::Unretained(this), 504 usage, 505 quota)); 506 } 507 508 void CannedSyncableFileSystem::GetChangedURLsInTracker( 509 FileSystemURLSet* urls) { 510 RunOnThread( 511 file_task_runner_.get(), 512 FROM_HERE, 513 base::Bind(&LocalFileChangeTracker::GetAllChangedURLs, 514 base::Unretained(backend()->change_tracker()), 515 urls)); 516 } 517 518 void CannedSyncableFileSystem::ClearChangeForURLInTracker( 519 const FileSystemURL& url) { 520 RunOnThread( 521 file_task_runner_.get(), 522 FROM_HERE, 523 base::Bind(&LocalFileChangeTracker::ClearChangesForURL, 524 base::Unretained(backend()->change_tracker()), 525 url)); 526 } 527 528 void CannedSyncableFileSystem::GetChangesForURLInTracker( 529 const FileSystemURL& url, 530 FileChangeList* changes) { 531 RunOnThread( 532 file_task_runner_.get(), 533 FROM_HERE, 534 base::Bind(&LocalFileChangeTracker::GetChangesForURL, 535 base::Unretained(backend()->change_tracker()), 536 url, changes)); 537 } 538 539 SyncFileSystemBackend* CannedSyncableFileSystem::backend() { 540 return SyncFileSystemBackend::GetBackend(file_system_context_); 541 } 542 543 FileSystemOperationRunner* CannedSyncableFileSystem::operation_runner() { 544 return file_system_context_->operation_runner(); 545 } 546 547 void CannedSyncableFileSystem::OnSyncEnabled(const FileSystemURL& url) { 548 sync_status_observers_->Notify(&LocalFileSyncStatus::Observer::OnSyncEnabled, 549 url); 550 } 551 552 void CannedSyncableFileSystem::OnWriteEnabled(const FileSystemURL& url) { 553 sync_status_observers_->Notify(&LocalFileSyncStatus::Observer::OnWriteEnabled, 554 url); 555 } 556 557 void CannedSyncableFileSystem::DoOpenFileSystem( 558 const OpenFileSystemCallback& callback) { 559 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 560 EXPECT_FALSE(is_filesystem_opened_); 561 file_system_context_->OpenFileSystem( 562 origin_, type_, 563 fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT, 564 callback); 565 } 566 567 void CannedSyncableFileSystem::DoCreateDirectory( 568 const FileSystemURL& url, 569 const StatusCallback& callback) { 570 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 571 EXPECT_TRUE(is_filesystem_opened_); 572 operation_runner()->CreateDirectory( 573 url, false /* exclusive */, false /* recursive */, callback); 574 } 575 576 void CannedSyncableFileSystem::DoCreateFile( 577 const FileSystemURL& url, 578 const StatusCallback& callback) { 579 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 580 EXPECT_TRUE(is_filesystem_opened_); 581 operation_runner()->CreateFile(url, false /* exclusive */, callback); 582 } 583 584 void CannedSyncableFileSystem::DoCopy( 585 const FileSystemURL& src_url, 586 const FileSystemURL& dest_url, 587 const StatusCallback& callback) { 588 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 589 EXPECT_TRUE(is_filesystem_opened_); 590 operation_runner()->Copy( 591 src_url, dest_url, 592 fileapi::FileSystemOperation::OPTION_NONE, 593 fileapi::FileSystemOperationRunner::CopyProgressCallback(), callback); 594 } 595 596 void CannedSyncableFileSystem::DoMove( 597 const FileSystemURL& src_url, 598 const FileSystemURL& dest_url, 599 const StatusCallback& callback) { 600 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 601 EXPECT_TRUE(is_filesystem_opened_); 602 operation_runner()->Move( 603 src_url, dest_url, fileapi::FileSystemOperation::OPTION_NONE, callback); 604 } 605 606 void CannedSyncableFileSystem::DoTruncateFile( 607 const FileSystemURL& url, int64 size, 608 const StatusCallback& callback) { 609 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 610 EXPECT_TRUE(is_filesystem_opened_); 611 operation_runner()->Truncate(url, size, callback); 612 } 613 614 void CannedSyncableFileSystem::DoTouchFile( 615 const FileSystemURL& url, 616 const base::Time& last_access_time, 617 const base::Time& last_modified_time, 618 const StatusCallback& callback) { 619 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 620 EXPECT_TRUE(is_filesystem_opened_); 621 operation_runner()->TouchFile(url, last_access_time, 622 last_modified_time, callback); 623 } 624 625 void CannedSyncableFileSystem::DoRemove( 626 const FileSystemURL& url, bool recursive, 627 const StatusCallback& callback) { 628 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 629 EXPECT_TRUE(is_filesystem_opened_); 630 operation_runner()->Remove(url, recursive, callback); 631 } 632 633 void CannedSyncableFileSystem::DoFileExists( 634 const FileSystemURL& url, const StatusCallback& callback) { 635 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 636 EXPECT_TRUE(is_filesystem_opened_); 637 operation_runner()->FileExists(url, callback); 638 } 639 640 void CannedSyncableFileSystem::DoDirectoryExists( 641 const FileSystemURL& url, const StatusCallback& callback) { 642 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 643 EXPECT_TRUE(is_filesystem_opened_); 644 operation_runner()->DirectoryExists(url, callback); 645 } 646 647 void CannedSyncableFileSystem::DoVerifyFile( 648 const FileSystemURL& url, 649 const std::string& expected_data, 650 const StatusCallback& callback) { 651 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 652 EXPECT_TRUE(is_filesystem_opened_); 653 operation_runner()->CreateSnapshotFile( 654 url, 655 base::Bind(&OnCreateSnapshotFileAndVerifyData, expected_data, callback)); 656 } 657 658 void CannedSyncableFileSystem::DoGetMetadataAndPlatformPath( 659 const FileSystemURL& url, 660 base::File::Info* info, 661 base::FilePath* platform_path, 662 const StatusCallback& callback) { 663 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 664 EXPECT_TRUE(is_filesystem_opened_); 665 operation_runner()->CreateSnapshotFile( 666 url, base::Bind(&OnCreateSnapshotFile, info, platform_path, callback)); 667 } 668 669 void CannedSyncableFileSystem::DoReadDirectory( 670 const FileSystemURL& url, 671 FileEntryList* entries, 672 const StatusCallback& callback) { 673 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 674 EXPECT_TRUE(is_filesystem_opened_); 675 operation_runner()->ReadDirectory( 676 url, base::Bind(&OnReadDirectory, entries, callback)); 677 } 678 679 void CannedSyncableFileSystem::DoWrite( 680 net::URLRequestContext* url_request_context, 681 const FileSystemURL& url, 682 scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle, 683 const WriteCallback& callback) { 684 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 685 EXPECT_TRUE(is_filesystem_opened_); 686 WriteHelper* helper = new WriteHelper; 687 operation_runner()->Write(url_request_context, url, 688 blob_data_handle.Pass(), 0, 689 base::Bind(&WriteHelper::DidWrite, 690 base::Owned(helper), callback)); 691 } 692 693 void CannedSyncableFileSystem::DoWriteString( 694 const FileSystemURL& url, 695 const std::string& data, 696 const WriteCallback& callback) { 697 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 698 EXPECT_TRUE(is_filesystem_opened_); 699 MockBlobURLRequestContext* url_request_context( 700 new MockBlobURLRequestContext(file_system_context_.get())); 701 WriteHelper* helper = new WriteHelper(url_request_context, data); 702 operation_runner()->Write(url_request_context, url, 703 helper->scoped_text_blob()->GetBlobDataHandle(), 0, 704 base::Bind(&WriteHelper::DidWrite, 705 base::Owned(helper), callback)); 706 } 707 708 void CannedSyncableFileSystem::DoGetUsageAndQuota( 709 int64* usage, 710 int64* quota, 711 const quota::StatusCallback& callback) { 712 EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 713 EXPECT_TRUE(is_filesystem_opened_); 714 DCHECK(quota_manager_); 715 quota_manager_->GetUsageAndQuota( 716 origin_, storage_type(), 717 base::Bind(&DidGetUsageAndQuota, callback, usage, quota)); 718 } 719 720 void CannedSyncableFileSystem::DidOpenFileSystem( 721 base::SingleThreadTaskRunner* original_task_runner, 722 const GURL& root, 723 const std::string& name, 724 File::Error result) { 725 if (io_task_runner_->RunsTasksOnCurrentThread()) { 726 EXPECT_FALSE(is_filesystem_opened_); 727 is_filesystem_opened_ = true; 728 } 729 if (!original_task_runner->RunsTasksOnCurrentThread()) { 730 DCHECK(io_task_runner_->RunsTasksOnCurrentThread()); 731 original_task_runner->PostTask( 732 FROM_HERE, 733 base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem, 734 base::Unretained(this), 735 make_scoped_refptr(original_task_runner), 736 root, name, result)); 737 return; 738 } 739 result_ = result; 740 root_url_ = root; 741 base::MessageLoop::current()->Quit(); 742 } 743 744 void CannedSyncableFileSystem::DidInitializeFileSystemContext( 745 SyncStatusCode status) { 746 sync_status_ = status; 747 base::MessageLoop::current()->Quit(); 748 } 749 750 void CannedSyncableFileSystem::InitializeSyncStatusObserver() { 751 ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread()); 752 backend()->sync_context()->sync_status()->AddObserver(this); 753 } 754 755 } // namespace sync_file_system 756
