Deprecate FileSystemTaskRunners

webkit/browser/fileapi/syncable/local_file_sync_context.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/browser/fileapi/syncable/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
-#include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/syncable/file_change.h"
 #include "webkit/browser/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/browser/fileapi/syncable/local_origin_change_observer.h"
 #include "webkit/browser/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/browser/fileapi/syncable/sync_file_system_backend.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_operation_runner.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using fileapi::FileSystemContext;
@@ skipping 58 matching lines @@
                  this));
 }
 
 void LocalFileSyncContext::GetFileForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback) {
   DCHECK(file_system_context);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   std::deque<FileSystemURL>* urls = new std::deque<FileSystemURL>;
-  file_system_context->task_runners()->file_task_runner()->PostTaskAndReply(
+  file_system_context->default_file_task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::GetNextURLsForSyncOnFileThread,
                  this, make_scoped_refptr(file_system_context),
                  base::Unretained(urls)),
       base::Bind(&LocalFileSyncContext::TryPrepareForLocalSync,
                  this, make_scoped_refptr(file_system_context),
                  base::Owned(urls), callback));
 }
 
 void LocalFileSyncContext::ClearChangesForURL(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const base::Closure& done_callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
-  if (!file_system_context->task_runners()->file_task_runner()->
+  if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
-    file_system_context->task_runners()->file_task_runner()->PostTask(
+    file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::ClearChangesForURL,
                    this, make_scoped_refptr(file_system_context),
                    url, done_callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
@@ skipping 163 matching lines @@
   }
 }
 
 void LocalFileSyncContext::RecordFakeLocalChange(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const FileChange& change,
     const SyncStatusCallback& callback) {
   // This is called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
-  if (!file_system_context->task_runners()->file_task_runner()->
+  if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
-    file_system_context->task_runners()->file_task_runner()->PostTask(
+    file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::RecordFakeLocalChange,
                    this, make_scoped_refptr(file_system_context),
                    url, change, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
@@ skipping 28 matching lines @@
       url_for_sync, base::Bind(&LocalFileSyncContext::DidGetFileMetadata,
                       this, callback));
 }
 
 void LocalFileSyncContext::HasPendingLocalChanges(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const HasPendingLocalChangeCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
-  if (!file_system_context->task_runners()->file_task_runner()->
+  if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
-    file_system_context->task_runners()->file_task_runner()->PostTask(
+    file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::HasPendingLocalChanges,
                    this, make_scoped_refptr(file_system_context),
                    url, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
@@ skipping 96 matching lines @@
   DCHECK(backend);
   if (!backend->change_tracker()) {
     // First registers the service name.
     RegisterSyncableFileSystem();
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     std::set<GURL>* origins_with_changes = new std::set<GURL>;
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr(
         new scoped_ptr<LocalFileChangeTracker>);
     base::PostTaskAndReplyWithResult(
-        file_system_context->task_runners()->file_task_runner(),
+        file_system_context->default_file_task_runner(),
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::InitializeChangeTrackerOnFileThread,
                    this, tracker_ptr,
                    make_scoped_refptr(file_system_context),
                    origins_with_changes),
         base::Bind(&LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread,
                    this, base::Owned(tracker_ptr),
                    source_url,
                    make_scoped_refptr(file_system_context),
                    base::Owned(origins_with_changes)));
@@ skipping 16 matching lines @@
 
 SyncStatusCode LocalFileSyncContext::InitializeChangeTrackerOnFileThread(
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes) {
   DCHECK(file_system_context);
   DCHECK(tracker_ptr);
   DCHECK(origins_with_changes);
   tracker_ptr->reset(new LocalFileChangeTracker(
           file_system_context->partition_path(),
-          file_system_context->task_runners()->file_task_runner()));
+          file_system_context->default_file_task_runner()));
   const SyncStatusCode status = (*tracker_ptr)->Initialize(file_system_context);
   if (status != SYNC_STATUS_OK)
     return status;
 
   // Get all origins that have pending changes.
   std::deque<FileSystemURL> urls;
   (*tracker_ptr)->GetNextChangedURLs(&urls, 0);
   for (std::deque<FileSystemURL>::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
     origins_with_changes->insert(iter->origin());
@@ skipping 56 matching lines @@
        iter != callback_queue.end(); ++iter) {
     ui_task_runner_->PostTask(FROM_HERE, base::Bind(*iter, status));
   }
   pending_initialize_callbacks_.erase(file_system_context);
 }
 
 void LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
     FileSystemContext* file_system_context,
     std::deque<FileSystemURL>* urls) {
   DCHECK(file_system_context);
-  DCHECK(file_system_context->task_runners()->file_task_runner()->
+  DCHECK(file_system_context->default_file_task_runner()->
              RunsTasksOnCurrentThread());
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->GetNextChangedURLs(
       urls, kMaxURLsToFetchForLocalSync);
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
@@ skipping 41 matching lines @@
   TryPrepareForLocalSync(file_system_context, remaining_urls, callback);
 }
 
 void LocalFileSyncContext::DidGetWritingStatusForSync(
     FileSystemContext* file_system_context,
     SyncStatusCode status,
     const FileSystemURL& url,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
-  if (!file_system_context->task_runners()->file_task_runner()->
+  if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_) {
       callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo());
       return;
     }
-    file_system_context->task_runners()->file_task_runner()->PostTask(
+    file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
                    this, make_scoped_refptr(file_system_context),
                    status, url, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
@@ skipping 97 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system