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

chrome/browser/safe_browsing/incident_reporting/download_metadata_manager.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 "chrome/browser/safe_browsing/incident_reporting/download_metadata_manager.h"
 
 #include <limits.h>
 #include <stdint.h>
-
 #include <list>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 44 matching lines @@
 
   // Returns the ClientDownloadRequest for a download or null if there is none.
   static scoped_ptr<ClientDownloadRequest> TakeRequestForDownload(
       content::DownloadItem* item);
 
  private:
   // A unique id for associating metadata with a content::DownloadItem.
   static const void* const kKey_;
 
   explicit DownloadItemData(scoped_ptr<ClientDownloadRequest> request)
-      : request_(request.Pass()) {}
+      : request_(std::move(request)) {}
   ~DownloadItemData() override {}
 
   scoped_ptr<ClientDownloadRequest> request_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemData);
 };
 
 // Make the key's value unique by setting it to its own location.
 // static
 const void* const DownloadItemData::kKey_ = &DownloadItemData::kKey_;
 
 // static
 void DownloadItemData::SetRequestForDownload(
     content::DownloadItem* item,
     scoped_ptr<ClientDownloadRequest> request) {
-  item->SetUserData(&kKey_, new DownloadItemData(request.Pass()));
+  item->SetUserData(&kKey_, new DownloadItemData(std::move(request)));
 }
 
 // static
 scoped_ptr<ClientDownloadRequest> DownloadItemData::TakeRequestForDownload(
     content::DownloadItem* item) {
   DownloadItemData* data =
       static_cast<DownloadItemData*>(item->GetUserData(&kKey_));
   if (!data)
     return nullptr;
-  scoped_ptr<ClientDownloadRequest> request = data->request_.Pass();
+  scoped_ptr<ClientDownloadRequest> request = std::move(data->request_);
   item->RemoveUserData(&kKey_);
-  return request.Pass();
+  return request;
 }
 
 
 // Utility functions------------------------------------------------------------
 
 // Returns the path to the metadata file for |browser_context|.
 base::FilePath GetMetadataPath(content::BrowserContext* browser_context) {
   return browser_context->GetPath().Append(kDownloadMetadataBasename);
 }
 
@@ skipping 69 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("SBIRS.DownloadMetadata.DeleteSuccess", success);
 }
 
 // Runs |callback| with the DownloadDetails in |download_metadata|.
 void ReturnResults(
     const DownloadMetadataManager::GetDownloadDetailsCallback& callback,
     scoped_ptr<DownloadMetadata> download_metadata) {
   if (!download_metadata->has_download_id())
     callback.Run(scoped_ptr<ClientIncidentReport_DownloadDetails>());
   else
-    callback.Run(make_scoped_ptr(download_metadata->release_download()).Pass());
+    callback.Run(make_scoped_ptr(download_metadata->release_download()));
 }
 
 }  // namespace
 
 // Applies operations to the profile's persistent DownloadMetadata as they occur
 // on its corresponding download item. An instance can be in one of three
 // states: waiting for metatada load, waiting for metadata to load after its
 // corresponding DownloadManager has gone down, and not waiting for metadata to
 // load. The instance observes all download items beloing to its manager. While
 // it is waiting for metadata to load, it records all operations on download
@@ skipping 271 matching lines @@
   download->AddObserver(this);
 }
 
 void DownloadMetadataManager::ManagerContext::SetRequest(
     content::DownloadItem* download,
     scoped_ptr<ClientDownloadRequest> request) {
   DCHECK(request);
   // Hold on to the request for completion time if the download is in progress.
   // Otherwise, commit the request.
   if (download->GetState() == content::DownloadItem::IN_PROGRESS)
-    DownloadItemData::SetRequestForDownload(download, request.Pass());
+    DownloadItemData::SetRequestForDownload(download, std::move(request));
   else
-    CommitRequest(download, request.Pass());
+    CommitRequest(download, std::move(request));
 }
 
 void DownloadMetadataManager::ManagerContext::GetDownloadDetails(
     const GetDownloadDetailsCallback& callback) {
   if (state_ != LOAD_COMPLETE) {
     get_details_callbacks_.push_back(callback);
   } else {
     callback.Run(download_metadata_ ?
                      make_scoped_ptr(new ClientIncidentReport_DownloadDetails(
                                          download_metadata_->download())) :
                      nullptr);
   }
 }
 
 void DownloadMetadataManager::ManagerContext::OnDownloadUpdated(
     content::DownloadItem* download) {
   // Persist metadata for this download if it has just completed.
   if (download->GetState() == content::DownloadItem::COMPLETE) {
     // Ignore downloads we don't have a ClientDownloadRequest for.
     scoped_ptr<ClientDownloadRequest> request =
         DownloadItemData::TakeRequestForDownload(download);
     if (request)
-      CommitRequest(download, request.Pass());
+      CommitRequest(download, std::move(request));
   }
 }
 
 void DownloadMetadataManager::ManagerContext::OnDownloadOpened(
     content::DownloadItem* download) {
   const base::Time now = base::Time::Now();
   if (state_ != LOAD_COMPLETE)
     pending_items_[download->GetId()].last_opened_time = now;
   else if (HasMetadataFor(download))
     UpdateLastOpenedTime(now);
@@ skipping 99 matching lines @@
 
 void DownloadMetadataManager::ManagerContext::OnMetadataReady(
     scoped_ptr<DownloadMetadata> download_metadata) {
   DCHECK_NE(state_, LOAD_COMPLETE);
 
   const bool is_detached = (state_ == DETACHED_WAIT);
 
   // Note that any available data has been read.
   state_ = LOAD_COMPLETE;
   if (download_metadata->has_download_id())
-    download_metadata_ = download_metadata.Pass();
+    download_metadata_ = std::move(download_metadata);
   else
     download_metadata_.reset();
 
   // Process all operations that had been held while waiting for the metadata.
   if (download_metadata_) {
     const auto& iter = pending_items_.find(download_metadata_->download_id());
     if (iter != pending_items_.end()) {
       const ItemData& item_data = iter->second;
       if (item_data.removed)
         RemoveMetadata();
@@ skipping 14 matching lines @@
 }
 
 void DownloadMetadataManager::ManagerContext::UpdateLastOpenedTime(
     const base::Time& last_opened_time) {
   download_metadata_->mutable_download()->set_open_time_msec(
       last_opened_time.ToJavaTime());
   WriteMetadata();
 }
 
 }  // namespace safe_browsing