Convert Pass()→std::move() in sync/

sync/internal_api/attachments/attachment_service_impl.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_service_impl.h"
-
 #include <iterator>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "sync/api/attachments/attachment.h"
+#include "sync/internal_api/public/attachments/attachment_service_impl.h"

[Nicolas Zea, 2015/12/18 23:46:54]

Keep up top

 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 
 namespace syncer {
 
 // GetOrDownloadAttachments starts multiple parallel DownloadAttachment calls.
 // GetOrDownloadState tracks completion of these calls and posts callback for
 // consumer once all attachments are either retrieved or reported unavailable.
 class AttachmentServiceImpl::GetOrDownloadState
     : public base::RefCounted<GetOrDownloadState>,
@@ skipping 85 matching lines @@
   }
 }
 
 AttachmentServiceImpl::AttachmentServiceImpl(
     scoped_ptr<AttachmentStoreForSync> attachment_store,
     scoped_ptr<AttachmentUploader> attachment_uploader,
     scoped_ptr<AttachmentDownloader> attachment_downloader,
     Delegate* delegate,
     const base::TimeDelta& initial_backoff_delay,
     const base::TimeDelta& max_backoff_delay)
-    : attachment_store_(attachment_store.Pass()),
-      attachment_uploader_(attachment_uploader.Pass()),
-      attachment_downloader_(attachment_downloader.Pass()),
+    : attachment_store_(std::move(attachment_store)),
+      attachment_uploader_(std::move(attachment_uploader)),
+      attachment_downloader_(std::move(attachment_downloader)),
       delegate_(delegate),
       weak_ptr_factory_(this) {
   DCHECK(CalledOnValidThread());
   DCHECK(attachment_store_.get());
 
   // TODO(maniscalco): Observe network connectivity change events.  When the
   // network becomes disconnected, consider suspending queue dispatch.  When
   // connectivity is restored, consider clearing any dispatch backoff (bug
   // 411981).
   upload_task_queue_.reset(new TaskQueue<AttachmentId>(
@@ skipping 14 matching lines @@
 scoped_ptr<syncer::AttachmentService> AttachmentServiceImpl::CreateForTest() {
   scoped_ptr<syncer::AttachmentStore> attachment_store =
       AttachmentStore::CreateInMemoryStore();
   scoped_ptr<AttachmentUploader> attachment_uploader(
       new FakeAttachmentUploader);
   scoped_ptr<AttachmentDownloader> attachment_downloader(
       new FakeAttachmentDownloader());
   scoped_ptr<syncer::AttachmentService> attachment_service(
       new syncer::AttachmentServiceImpl(
           attachment_store->CreateAttachmentStoreForSync(),
-          attachment_uploader.Pass(), attachment_downloader.Pass(), NULL,
-          base::TimeDelta(), base::TimeDelta()));
-  return attachment_service.Pass();
+          std::move(attachment_uploader), std::move(attachment_downloader),
+          NULL, base::TimeDelta(), base::TimeDelta()));
+  return attachment_service;
 }
 
 void AttachmentServiceImpl::GetOrDownloadAttachments(
     const AttachmentIdList& attachment_ids,
     const GetOrDownloadCallback& callback) {
   DCHECK(CalledOnValidThread());
   scoped_refptr<GetOrDownloadState> state(
       new GetOrDownloadState(attachment_ids, callback));
   // SetModelTypeReference() makes attachments visible for model type.
   // Needed when attachment doesn't have model type reference, but still
@@ skipping 150 matching lines @@
   AttachmentMap::const_iterator end = attachments->end();
   for (; iter != end; ++iter) {
     attachment_uploader_->UploadAttachment(
         iter->second,
         base::Bind(&AttachmentServiceImpl::UploadDone,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void AttachmentServiceImpl::SetTimerForTest(scoped_ptr<base::Timer> timer) {
-  upload_task_queue_->SetTimerForTest(timer.Pass());
+  upload_task_queue_->SetTimerForTest(std::move(timer));
 }
 
 }  // namespace syncer