[SyncFS] Interface clean up around LocalfileSyncContext::GetFileForLocalSync

chrome/browser/sync_file_system/local/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 "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 89 matching lines @@
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::ShutdownOnIOThread, 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->default_file_task_runner()->PostTaskAndReply(
+  base::PostTaskAndReplyWithResult(
+      file_system_context->default_file_task_runner(),
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::GetNextURLsForSyncOnFileThread,
-                 this, make_scoped_refptr(file_system_context),
-                 base::Unretained(urls)),
+                 this, make_scoped_refptr(file_system_context)),
       base::Bind(&LocalFileSyncContext::TryPrepareForLocalSync,
-                 this, make_scoped_refptr(file_system_context),
-                 base::Owned(urls), callback));
+                 this, make_scoped_refptr(file_system_context), 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->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
@@ skipping 626 matching lines @@
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   for (StatusCallbackQueue::iterator iter = callback_queue.begin();
        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) {
+scoped_ptr<LocalFileSyncContext::FileSystemURLQueue>
+LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
+    FileSystemContext* file_system_context) {
   DCHECK(file_system_context);
   DCHECK(file_system_context->default_file_task_runner()->
              RunsTasksOnCurrentThread());
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
+  scoped_ptr<FileSystemURLQueue> urls(new FileSystemURLQueue);
   backend->change_tracker()->GetNextChangedURLs(
-      urls, kMaxURLsToFetchForLocalSync);
+      urls.get(), kMaxURLsToFetchForLocalSync);
+  return urls.Pass();
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
-    std::deque<FileSystemURL>* urls,
-    const LocalFileSyncInfoCallback& callback) {
+    const LocalFileSyncInfoCallback& callback,
+    scoped_ptr<FileSystemURLQueue> urls) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(urls);
 
   if (shutdown_on_ui_) {
     callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(),
                  webkit_blob::ScopedFile());
     return;
   }
 
   if (urls->empty()) {
     callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC, LocalFileSyncInfo(),
                  webkit_blob::ScopedFile());
     return;
   }
 
   const FileSystemURL url = urls->front();
   urls->pop_front();
-  std::deque<FileSystemURL>* remaining = new std::deque<FileSystemURL>;
-  remaining->swap(*urls);
 
   PrepareForSync(
       file_system_context, url, SYNC_SNAPSHOT,
       base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
                  this, make_scoped_refptr(file_system_context),
-                 base::Owned(remaining), callback));
+                 base::Passed(&urls), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
-    std::deque<FileSystemURL>* remaining_urls,
+    scoped_ptr<FileSystemURLQueue> remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
     const LocalFileSyncInfo& sync_file_info,
     webkit_blob::ScopedFile snapshot) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (status != SYNC_STATUS_FILE_BUSY) {
     callback.Run(status, sync_file_info, snapshot.Pass());
     return;
   }
   // Recursively call TryPrepareForLocalSync with remaining_urls.
-  TryPrepareForLocalSync(file_system_context, remaining_urls, callback);
+  TryPrepareForLocalSync(file_system_context, callback, remaining_urls.Pass());
 }
 
 void LocalFileSyncContext::DidGetWritingStatusForSync(
     FileSystemContext* file_system_context,
     SyncStatusCode status,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
@@ skipping 165 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