Convert Pass()→std::move() for Mac build.

chrome/browser/media_galleries/fileapi/itunes_file_util.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/media_galleries/fileapi/itunes_file_util.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media_galleries/fileapi/itunes_data_provider.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "content/public/browser/browser_thread.h"
 #include "storage/browser/blob/shareable_file_reference.h"
@@ skipping 47 matching lines @@
 }
 
 void ITunesFileUtil::GetFileInfoOnTaskRunnerThread(
     scoped_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   ITunesDataProvider* data_provider = GetDataProvider();
   // |data_provider| may be NULL if the file system was revoked before this
   // operation had a chance to run.
   if (!data_provider) {
-    GetFileInfoWithFreshDataProvider(context.Pass(), url, callback, false);
+    GetFileInfoWithFreshDataProvider(std::move(context), url, callback, false);
   } else {
     data_provider->RefreshData(
         base::Bind(&ITunesFileUtil::GetFileInfoWithFreshDataProvider,
                    weak_factory_.GetWeakPtr(), base::Passed(&context), url,
                    callback));
   }
 }
 
 void ITunesFileUtil::ReadDirectoryOnTaskRunnerThread(
     scoped_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   ITunesDataProvider* data_provider = GetDataProvider();
   // |data_provider| may be NULL if the file system was revoked before this
   // operation had a chance to run.
   if (!data_provider) {
-    ReadDirectoryWithFreshDataProvider(context.Pass(), url, callback, false);
+    ReadDirectoryWithFreshDataProvider(std::move(context), url, callback,
+                                       false);
   } else {
     data_provider->RefreshData(
         base::Bind(&ITunesFileUtil::ReadDirectoryWithFreshDataProvider,
                    weak_factory_.GetWeakPtr(), base::Passed(&context), url,
                    callback));
   }
 }
 
 void ITunesFileUtil::CreateSnapshotFileOnTaskRunnerThread(
     scoped_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   ITunesDataProvider* data_provider = GetDataProvider();
   // |data_provider| may be NULL if the file system was revoked before this
   // operation had a chance to run.
   if (!data_provider) {
-    CreateSnapshotFileWithFreshDataProvider(context.Pass(), url, callback,
+    CreateSnapshotFileWithFreshDataProvider(std::move(context), url, callback,
                                             false);
   } else {
     data_provider->RefreshData(
         base::Bind(&ITunesFileUtil::CreateSnapshotFileWithFreshDataProvider,
                    weak_factory_.GetWeakPtr(), base::Passed(&context), url,
                    callback));
   }
 }
 
 // Contents of the iTunes media gallery:
@@ skipping 233 matching lines @@
   if (!valid_parse) {
     if (!callback.is_null()) {
       content::BrowserThread::PostTask(
           content::BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_IO,
                      base::File::Info()));
     }
     return;
   }
-  NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread(context.Pass(), url,
+  NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread(std::move(context), url,
                                                      callback);
 }
 
 void ITunesFileUtil::ReadDirectoryWithFreshDataProvider(
     scoped_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const ReadDirectoryCallback& callback,
     bool valid_parse) {
   if (!valid_parse) {
     if (!callback.is_null()) {
       content::BrowserThread::PostTask(
           content::BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_IO, EntryList(), false));
     }
     return;
   }
-  NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread(context.Pass(), url,
+  NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread(std::move(context), url,
                                                        callback);
 }
 
 void ITunesFileUtil::CreateSnapshotFileWithFreshDataProvider(
     scoped_ptr<storage::FileSystemOperationContext> context,
     const storage::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback,
     bool valid_parse) {
   if (!valid_parse) {
     if (!callback.is_null()) {
       base::File::Info file_info;
       base::FilePath platform_path;
       scoped_refptr<storage::ShareableFileReference> file_ref;
       content::BrowserThread::PostTask(
           content::BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_IO, file_info,
                      platform_path, file_ref));
     }
     return;
   }
-  NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread(context.Pass(), url,
-                                                            callback);
+  NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread(std::move(context),
+                                                            url, callback);
 }
 
 ITunesDataProvider* ITunesFileUtil::GetDataProvider() {
   if (!imported_registry_)
     imported_registry_ = ImportedMediaGalleryRegistry::GetInstance();
   return imported_registry_->ITunesDataProvider();
 }
 
 }  // namespace itunes