chrome/browser/sync_file_system/local/canned_syncable_file_system.cc

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