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

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.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/incident_reporting_service.h"
 
 #include <math.h>
 #include <stddef.h>
-
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/process_info.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 180 matching lines @@
 }
 
 IncidentReportingService::Receiver::~Receiver() {
 }
 
 void IncidentReportingService::Receiver::AddIncidentForProfile(
     Profile* profile,
     scoped_ptr<Incident> incident) {
   DCHECK(thread_runner_->BelongsToCurrentThread());
   DCHECK(profile);
-  AddIncidentOnMainThread(service_, profile, incident.Pass());
+  AddIncidentOnMainThread(service_, profile, std::move(incident));
 }
 
 void IncidentReportingService::Receiver::AddIncidentForProcess(
     scoped_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
-    AddIncidentOnMainThread(service_, nullptr, incident.Pass());
+    AddIncidentOnMainThread(service_, nullptr, std::move(incident));
   } else if (!thread_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IncidentReportingService::Receiver::AddIncidentOnMainThread,
                  service_, nullptr, base::Passed(&incident)))) {
     LogIncidentDataType(DISCARDED, *incident);
   }
 }
 
 void IncidentReportingService::Receiver::ClearIncidentForProcess(
     scoped_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
-    ClearIncidentOnMainThread(service_, nullptr, incident.Pass());
+    ClearIncidentOnMainThread(service_, nullptr, std::move(incident));
   } else {
     thread_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &IncidentReportingService::Receiver::ClearIncidentOnMainThread,
             service_, nullptr, base::Passed(&incident)));
   }
 }
 
 bool IncidentReportingService::HasIncidentsToUpload() const {
   for (const auto& profile_and_context : profiles_) {
     if (!profile_and_context.second->incidents.empty())
       return true;
   }
   return false;
 }
 
 // static
 void IncidentReportingService::Receiver::AddIncidentOnMainThread(
     const base::WeakPtr<IncidentReportingService>& service,
     Profile* profile,
     scoped_ptr<Incident> incident) {
   if (service)
-    service->AddIncident(profile, incident.Pass());
+    service->AddIncident(profile, std::move(incident));
   else
     LogIncidentDataType(DISCARDED, *incident);
 }
 
 // static
 void IncidentReportingService::Receiver::ClearIncidentOnMainThread(
       const base::WeakPtr<IncidentReportingService>& service,
       Profile* profile,
       scoped_ptr<Incident> incident) {
   if (service)
-    service->ClearIncident(profile, incident.Pass());
+    service->ClearIncident(profile, std::move(incident));
 }
 
 IncidentReportingService::ProfileContext::ProfileContext() : added(false) {
 }
 
 IncidentReportingService::ProfileContext::~ProfileContext() {
   for (const auto& incident : incidents) {
     if (incident)
       LogIncidentDataType(DISCARDED, *incident);
   }
 }
 
 bool IncidentReportingService::ProfileContext::HasIncidents() const {
   return !incidents.empty() || !incidents_to_clear.empty();
 }
 
 IncidentReportingService::UploadContext::UploadContext(
     scoped_ptr<ClientIncidentReport> report)
-    : report(report.Pass()) {
-}
+    : report(std::move(report)) {}
 
 IncidentReportingService::UploadContext::~UploadContext() {
 }
 
 // static
 bool IncidentReportingService::IsEnabledForProfile(Profile* profile) {
   if (profile->IsOffTheRecord())
     return false;
   if (!profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled))
     return false;
@@ skipping 201 matching lines @@
   BeginEnvironmentCollection();
   // Take another stab at finding the most recent download if a report is being
   // assembled and one hasn't been found yet (the LastDownloadFinder operates
   // only on profiles that have been added to the ProfileManager).
   BeginDownloadCollection();
 }
 
 scoped_ptr<LastDownloadFinder> IncidentReportingService::CreateDownloadFinder(
     const LastDownloadFinder::LastDownloadCallback& callback) {
   return LastDownloadFinder::Create(
-             base::Bind(&DownloadMetadataManager::GetDownloadDetails,
-                        base::Unretained(&download_metadata_manager_)),
-             callback).Pass();
+      base::Bind(&DownloadMetadataManager::GetDownloadDetails,
+                 base::Unretained(&download_metadata_manager_)),
+      callback);
 }
 
 scoped_ptr<IncidentReportUploader> IncidentReportingService::StartReportUpload(
     const IncidentReportUploader::OnResultCallback& callback,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const ClientIncidentReport& report) {
   return IncidentReportUploaderImpl::UploadReport(
-             callback, request_context_getter, report).Pass();
+      callback, request_context_getter, report);
 }
 
 bool IncidentReportingService::IsProcessingReport() const {
   return report_ != NULL;
 }
 
 IncidentReportingService::ProfileContext*
 IncidentReportingService::GetOrCreateProfileContext(Profile* profile) {
   ProfileContextCollection::iterator it =
       profiles_.insert(ProfileContextCollection::value_type(profile, NULL))
@@ skipping 75 matching lines @@
 
   // Drop the incident immediately if the profile has already been added to the
   // manager and does not have incident reporting enabled. Preference evaluation
   // is deferred until OnProfileAdded() otherwise.
   if (context->added && !IsEnabledForProfile(profile)) {
     LogIncidentDataType(DROPPED, *incident);
     return;
   }
 
   // Take ownership of the incident.
-  context->incidents.push_back(incident.Pass());
+  context->incidents.push_back(std::move(incident));
 
   // Remember when the first incident for this report arrived.
   if (first_incident_time_.is_null())
     first_incident_time_ = base::Time::Now();
   // Log the time between the previous incident and this one.
   if (!last_incident_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("SBIRS.InterIncidentTime",
                         base::TimeTicks::Now() - last_incident_time_);
   }
   last_incident_time_ = base::TimeTicks::Now();
 
   // Persist the incident data.
 
   // Start assembling a new report if this is the first incident ever or the
   // first since the last upload.
   BeginReportProcessing();
 }
 
 void IncidentReportingService::ClearIncident(Profile* profile,
                                              scoped_ptr<Incident> incident) {
   ProfileContext* context = GetOrCreateProfileContext(profile);
-  context->incidents_to_clear.push_back(incident.Pass());
+  context->incidents_to_clear.push_back(std::move(incident));
   // Begin processing to handle cleared incidents following collation.
   BeginReportProcessing();
 }
 
 void IncidentReportingService::BeginReportProcessing() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Creates a new report if needed.
   if (!report_)
     report_.reset(new ClientIncidentReport());
@@ skipping 182 matching lines @@
 void IncidentReportingService::ProcessIncidentsIfCollectionComplete() {
   DCHECK(report_);
   // Bail out if there are still outstanding collection tasks. Completion of any
   // of these will start another upload attempt.
   if (WaitingForEnvironmentCollection() || WaitingToCollateIncidents() ||
       WaitingForMostRecentDownload()) {
     return;
   }
 
   // Take ownership of the report and clear things for future reports.
-  scoped_ptr<ClientIncidentReport> report(report_.Pass());
+  scoped_ptr<ClientIncidentReport> report(std::move(report_));
   first_incident_time_ = base::Time();
   last_incident_time_ = base::TimeTicks();
 
   ClientIncidentReport_EnvironmentData_Process* process =
       report->mutable_environment()->mutable_process();
 
   process->set_metrics_consent(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled());
 
   // Find the profile that benefits from the strongest protections.
   Profile* eligible_profile = FindEligibleProfile();
   process->set_extended_consent(
       eligible_profile ? eligible_profile->GetPrefs()->GetBoolean(
                              prefs::kSafeBrowsingExtendedReportingEnabled) :
                        false);
 
   process->set_field_trial_participant(enabled_by_field_trial_);
 
   // Associate process-wide incidents with the profile that benefits from the
   // strongest safe browsing protections. If there is no such profile, drop the
   // incidents.
   ProfileContext* null_context = GetProfileContext(NULL);
   if (null_context && null_context->HasIncidents()) {
     if (eligible_profile) {
       ProfileContext* eligible_context = GetProfileContext(eligible_profile);
       // Move the incidents to the target context.
       for (auto& incident : null_context->incidents) {
-        eligible_context->incidents.push_back(incident.Pass());
+        eligible_context->incidents.push_back(std::move(incident));
       }
       null_context->incidents.clear();
       for (auto& incident : null_context->incidents_to_clear)
-        eligible_context->incidents_to_clear.push_back(incident.Pass());
+        eligible_context->incidents_to_clear.push_back(std::move(incident));
       null_context->incidents_to_clear.clear();
     } else {
       for (const auto& incident : null_context->incidents)
         LogIncidentDataType(DROPPED, *incident);
       null_context->incidents.clear();
     }
   }
 
   // Clear incidents data where needed.
   for (auto& profile_and_context : profiles_) {
@@ skipping 73 matching lines @@
                                 IncidentReportUploader::NUM_UPLOAD_RESULTS);
     }
     return;
   }
 
   UMA_HISTOGRAM_COUNTS_100("SBIRS.IncidentCount", count);
 
   // Perform final synchronous collection tasks for the report.
   DoExtensionCollection(report->mutable_extension_data());
 
-  scoped_ptr<UploadContext> context(new UploadContext(report.Pass()));
+  scoped_ptr<UploadContext> context(new UploadContext(std::move(report)));
   context->profiles_to_state.swap(profiles_to_state);
   if (!database_manager_.get()) {
     // No database manager during testing. Take ownership of the context and
     // continue processing.
     UploadContext* temp_context = context.get();
-    uploads_.push_back(context.Pass());
+    uploads_.push_back(std::move(context));
     IncidentReportingService::OnKillSwitchResult(temp_context, false);
   } else {
     if (content::BrowserThread::PostTaskAndReplyWithResult(
             content::BrowserThread::IO,
             FROM_HERE,
             base::Bind(&SafeBrowsingDatabaseManager::IsCsdWhitelistKillSwitchOn,
                        database_manager_),
             base::Bind(&IncidentReportingService::OnKillSwitchResult,
                        weak_ptr_factory_.GetWeakPtr(),
                        context.get()))) {
-      uploads_.push_back(context.Pass());
+      uploads_.push_back(std::move(context));
     }  // else should not happen. Let the context be deleted automatically.
   }
 }
 
 void IncidentReportingService::CancelAllReportUploads() {
   for (size_t i = 0; i < uploads_.size(); ++i) {
     UMA_HISTOGRAM_ENUMERATION("SBIRS.UploadResult",
                               IncidentReportUploader::UPLOAD_CANCELLED,
                               IncidentReportUploader::NUM_UPLOAD_RESULTS);
   }
   uploads_.clear();
 }
 
 void IncidentReportingService::OnKillSwitchResult(UploadContext* context,
                                                   bool is_killswitch_on) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!is_killswitch_on) {
     // Initiate the upload.
-    context->uploader =
-        StartReportUpload(
-            base::Bind(&IncidentReportingService::OnReportUploadResult,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       context),
-            url_request_context_getter_,
-            *context->report).Pass();
+    context->uploader = StartReportUpload(
+        base::Bind(&IncidentReportingService::OnReportUploadResult,
+                   weak_ptr_factory_.GetWeakPtr(), context),
+        url_request_context_getter_, *context->report);
     if (!context->uploader) {
       OnReportUploadResult(context,
                            IncidentReportUploader::UPLOAD_INVALID_REQUEST,
                            scoped_ptr<ClientIncidentResponse>());
     }
   } else {
     OnReportUploadResult(context,
                          IncidentReportUploader::UPLOAD_SUPPRESSED,
                          scoped_ptr<ClientIncidentResponse>());
   }
@@ skipping 18 matching lines @@
   UMA_HISTOGRAM_ENUMERATION(
       "SBIRS.UploadResult", result, IncidentReportUploader::NUM_UPLOAD_RESULTS);
 
   // The upload is no longer outstanding, so take ownership of the context (from
   // the collection of outstanding uploads) in this scope.
   auto it = std::find_if(uploads_.begin(), uploads_.end(),
                          [context] (const scoped_ptr<UploadContext>& value) {
                            return value.get() == context;
                          });
   DCHECK(it != uploads_.end());
-  scoped_ptr<UploadContext> upload(it->Pass());
+  scoped_ptr<UploadContext> upload(std::move(*it));
   uploads_.erase(it);
 
   if (result == IncidentReportUploader::UPLOAD_SUCCESS)
     HandleResponse(*upload);
   // else retry?
 }
 
 void IncidentReportingService::OnClientDownloadRequest(
     content::DownloadItem* download,
     const ClientDownloadRequest* request) {
@@ skipping 19 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing