Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_ptr

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/feature_list.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.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"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 118 matching lines @@
 
 struct IncidentReportingService::ProfileContext {
   ProfileContext();
   ~ProfileContext();
 
   // Returns true if the profile has incidents to be uploaded or cleared.
   bool HasIncidents() const;
 
   // The incidents collected for this profile pending creation and/or upload.
   // Will contain null values for pruned incidents.
-  std::vector<scoped_ptr<Incident>> incidents;
+  std::vector<std::unique_ptr<Incident>> incidents;
 
   // The incidents data of which should be cleared.
-  std::vector<scoped_ptr<Incident>> incidents_to_clear;
+  std::vector<std::unique_ptr<Incident>> incidents_to_clear;
 
   // State storage for this profile; null until PROFILE_ADDED notification is
   // received.
-  scoped_ptr<StateStore> state_store;
+  std::unique_ptr<StateStore> state_store;
 
   // False until PROFILE_ADDED notification is received.
   bool added;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProfileContext);
 };
 
 class IncidentReportingService::UploadContext {
  public:
   typedef std::map<ProfileContext*, std::vector<PersistentIncidentState>>
       PersistentIncidentStateCollection;
 
-  explicit UploadContext(scoped_ptr<ClientIncidentReport> report);
+  explicit UploadContext(std::unique_ptr<ClientIncidentReport> report);
   ~UploadContext();
 
   // The report being uploaded.
-  scoped_ptr<ClientIncidentReport> report;
+  std::unique_ptr<ClientIncidentReport> report;
 
   // The uploader in use. This is NULL until the CSD killswitch is checked.
-  scoped_ptr<IncidentReportUploader> uploader;
+  std::unique_ptr<IncidentReportUploader> uploader;
 
   // A mapping of profile contexts to the data to be persisted upon successful
   // upload.
   PersistentIncidentStateCollection profiles_to_state;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UploadContext);
 };
 
 // An IncidentReceiver that is weakly-bound to the service and transparently
 // bounces process-wide incidents back to the main thread for handling.
 class IncidentReportingService::Receiver : public IncidentReceiver {
  public:
   explicit Receiver(const base::WeakPtr<IncidentReportingService>& service);
   ~Receiver() override;
 
   // IncidentReceiver methods:
   void AddIncidentForProfile(Profile* profile,
-                             scoped_ptr<Incident> incident) override;
-  void AddIncidentForProcess(scoped_ptr<Incident> incident) override;
-  void ClearIncidentForProcess(scoped_ptr<Incident> incident) override;
+                             std::unique_ptr<Incident> incident) override;
+  void AddIncidentForProcess(std::unique_ptr<Incident> incident) override;
+  void ClearIncidentForProcess(std::unique_ptr<Incident> incident) override;
 
  private:
   static void AddIncidentOnMainThread(
       const base::WeakPtr<IncidentReportingService>& service,
       Profile* profile,
-      scoped_ptr<Incident> incident);
+      std::unique_ptr<Incident> incident);
   static void ClearIncidentOnMainThread(
       const base::WeakPtr<IncidentReportingService>& service,
       Profile* profile,
-      scoped_ptr<Incident> incident);
+      std::unique_ptr<Incident> incident);
 
   base::WeakPtr<IncidentReportingService> service_;
   scoped_refptr<base::SingleThreadTaskRunner> thread_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Receiver);
 };
 
 IncidentReportingService::Receiver::Receiver(
     const base::WeakPtr<IncidentReportingService>& service)
     : service_(service),
       thread_runner_(base::ThreadTaskRunnerHandle::Get()) {
 }
 
 IncidentReportingService::Receiver::~Receiver() {
 }
 
 void IncidentReportingService::Receiver::AddIncidentForProfile(
     Profile* profile,
-    scoped_ptr<Incident> incident) {
+    std::unique_ptr<Incident> incident) {
   DCHECK(thread_runner_->BelongsToCurrentThread());
   DCHECK(profile);
   AddIncidentOnMainThread(service_, profile, std::move(incident));
 }
 
 void IncidentReportingService::Receiver::AddIncidentForProcess(
-    scoped_ptr<Incident> incident) {
+    std::unique_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
     AddIncidentOnMainThread(service_, nullptr, std::move(incident));
   } else {
     thread_runner_->PostTask(
         FROM_HERE,
         base::Bind(&IncidentReportingService::Receiver::AddIncidentOnMainThread,
                    service_, nullptr, base::Passed(&incident)));
   }
 }
 
 void IncidentReportingService::Receiver::ClearIncidentForProcess(
-    scoped_ptr<Incident> incident) {
+    std::unique_ptr<Incident> incident) {
   if (thread_runner_->BelongsToCurrentThread()) {
     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) {
+    std::unique_ptr<Incident> incident) {
   if (service)
     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) {
+    const base::WeakPtr<IncidentReportingService>& service,
+    Profile* profile,
+    std::unique_ptr<Incident> incident) {
   if (service)
     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)
+    std::unique_ptr<ClientIncidentReport> report)
     : report(std::move(report)) {}
 
 IncidentReportingService::UploadContext::~UploadContext() {
 }
 
 // static
 bool IncidentReportingService::IsEnabledForProfile(Profile* profile) {
   if (profile->IsOffTheRecord())
     return false;
   if (!profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled))
@@ skipping 62 matching lines @@
   // Cancel all internal asynchronous tasks.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   CancelEnvironmentCollection();
   CancelDownloadCollection();
   CancelAllReportUploads();
 
   STLDeleteValues(&profiles_);
 }
 
-scoped_ptr<IncidentReceiver> IncidentReportingService::GetIncidentReceiver() {
-  return make_scoped_ptr(new Receiver(receiver_weak_ptr_factory_.GetWeakPtr()));
+std::unique_ptr<IncidentReceiver>
+IncidentReportingService::GetIncidentReceiver() {
+  return base::WrapUnique(
+      new Receiver(receiver_weak_ptr_factory_.GetWeakPtr()));
 }
 
-scoped_ptr<TrackedPreferenceValidationDelegate>
+std::unique_ptr<TrackedPreferenceValidationDelegate>
 IncidentReportingService::CreatePreferenceValidationDelegate(Profile* profile) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (profile->IsOffTheRecord())
-    return scoped_ptr<TrackedPreferenceValidationDelegate>();
-  return scoped_ptr<TrackedPreferenceValidationDelegate>(
+    return std::unique_ptr<TrackedPreferenceValidationDelegate>();
+  return std::unique_ptr<TrackedPreferenceValidationDelegate>(
       new PreferenceValidationDelegate(profile, GetIncidentReceiver()));
 }
 
 void IncidentReportingService::RegisterDelayedAnalysisCallback(
     const DelayedAnalysisCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // |callback| will be run on the blocking pool. The receiver will bounce back
   // to the origin thread if needed.
   delayed_analysis_callbacks_.RegisterCallback(
@@ skipping 139 matching lines @@
   // Environment collection is deferred until at least one profile for which the
   // service is enabled is added. Re-initiate collection now in case this is the
   // first such profile.
   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(
+std::unique_ptr<LastDownloadFinder>
+IncidentReportingService::CreateDownloadFinder(
     const LastDownloadFinder::LastDownloadCallback& callback) {
   return LastDownloadFinder::Create(
       base::Bind(&DownloadMetadataManager::GetDownloadDetails,
                  base::Unretained(&download_metadata_manager_)),
       callback);
 }
 
-scoped_ptr<IncidentReportUploader> IncidentReportingService::StartReportUpload(
+std::unique_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);
 }
 
 bool IncidentReportingService::IsProcessingReport() const {
   return report_ != NULL;
 }
@@ skipping 15 matching lines @@
 }
 
 void IncidentReportingService::OnProfileDestroyed(Profile* profile) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ProfileContextCollection::iterator it = profiles_.find(profile);
   if (it == profiles_.end())
     return;
 
   // Take ownership of the context.
-  scoped_ptr<ProfileContext> context(it->second);
+  std::unique_ptr<ProfileContext> context(it->second);
   it->second = nullptr;
 
   // TODO(grt): Persist incidents for upload on future profile load.
 
   // Remove the association with this profile context from all pending uploads.
   for (const auto& upload : uploads_)
     upload->profiles_to_state.erase(context.get());
 
   // Forget about this profile. Incidents not yet sent for upload are lost.
   // No new incidents will be accepted for it.
@@ skipping 21 matching lines @@
     }
     // Otherwise, store this one as a candidate and keep looking (in case we
     // find one with Extended Reporting enabled).
     candidate = scan->first;
   }
 
   return candidate;
 }
 
 void IncidentReportingService::AddIncident(Profile* profile,
-                                           scoped_ptr<Incident> incident) {
+                                           std::unique_ptr<Incident> incident) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Ignore incidents from off-the-record profiles.
   if (profile && profile->IsOffTheRecord())
     return;
 
   ProfileContext* context = GetOrCreateProfileContext(profile);
   // If this is a process-wide incident, the context must not indicate that the
   // profile (which is NULL) has been added to the profile manager.
   DCHECK(profile || !context->added);
@@ skipping 21 matching lines @@
   }
   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) {
+void IncidentReportingService::ClearIncident(
+    Profile* profile,
+    std::unique_ptr<Incident> incident) {
   ProfileContext* context = GetOrCreateProfileContext(profile);
   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.
@@ skipping 53 matching lines @@
   if (environment_collection_pending_ || report_->has_environment() ||
       !HasIncidentsToUpload() || !FindEligibleProfile()) {
     return;
   }
 
   environment_collection_begin_ = base::TimeTicks::Now();
   ClientIncidentReport_EnvironmentData* environment_data =
       new ClientIncidentReport_EnvironmentData();
   environment_collection_pending_ =
       environment_collection_task_runner_->PostTaskAndReply(
-          FROM_HERE,
-          base::Bind(collect_environment_data_fn_, environment_data),
+          FROM_HERE, base::Bind(collect_environment_data_fn_, environment_data),
           base::Bind(&IncidentReportingService::OnEnvironmentDataCollected,
                      weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(make_scoped_ptr(environment_data))));
+                     base::Passed(base::WrapUnique(environment_data))));
 
   // Posting the task will fail if the runner has been shut down. This should
   // never happen since the blocking pool is shut down after this service.
   DCHECK(environment_collection_pending_);
 }
 
 bool IncidentReportingService::WaitingForEnvironmentCollection() {
   return environment_collection_pending_;
 }
 
 void IncidentReportingService::CancelEnvironmentCollection() {
   environment_collection_begin_ = base::TimeTicks();
   environment_collection_pending_ = false;
   if (report_)
     report_->clear_environment();
 }
 
 void IncidentReportingService::OnEnvironmentDataCollected(
-    scoped_ptr<ClientIncidentReport_EnvironmentData> environment_data) {
+    std::unique_ptr<ClientIncidentReport_EnvironmentData> environment_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(environment_collection_pending_);
   DCHECK(report_ && !report_->has_environment());
   environment_collection_pending_ = false;
 
 // CurrentProcessInfo::CreationTime() is missing on some platforms.
 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
   base::TimeDelta uptime =
       first_incident_time_ - base::CurrentProcessInfo::CreationTime();
   environment_data->mutable_process()->set_uptime_msec(uptime.InMilliseconds());
@@ skipping 53 matching lines @@
 }
 
 void IncidentReportingService::CancelDownloadCollection() {
   last_download_finder_.reset();
   last_download_begin_ = base::TimeTicks();
   if (report_)
     report_->clear_download();
 }
 
 void IncidentReportingService::OnLastDownloadFound(
-    scoped_ptr<ClientIncidentReport_DownloadDetails> last_binary_download,
-    scoped_ptr<ClientIncidentReport_NonBinaryDownloadDetails>
+    std::unique_ptr<ClientIncidentReport_DownloadDetails> last_binary_download,
+    std::unique_ptr<ClientIncidentReport_NonBinaryDownloadDetails>
         last_non_binary_download) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(report_);
 
   UMA_HISTOGRAM_TIMES("SBIRS.FindDownloadedBinaryTime",
                       base::TimeTicks::Now() - last_download_begin_);
   last_download_begin_ = base::TimeTicks();
 
   // Harvest the finder.
   last_download_finder_.reset();
@@ skipping 12 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(std::move(report_));
+  std::unique_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.
@@ skipping 108 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(std::move(report)));
+  std::unique_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(std::move(context));
     IncidentReportingService::OnKillSwitchResult(temp_context, false);
   } else {
     if (content::BrowserThread::PostTaskAndReplyWithResult(
             content::BrowserThread::IO,
@@ skipping 22 matching lines @@
   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);
     if (!context->uploader) {
       OnReportUploadResult(context,
                            IncidentReportUploader::UPLOAD_INVALID_REQUEST,
-                           scoped_ptr<ClientIncidentResponse>());
+                           std::unique_ptr<ClientIncidentResponse>());
     }
   } else {
-    OnReportUploadResult(context,
-                         IncidentReportUploader::UPLOAD_SUPPRESSED,
-                         scoped_ptr<ClientIncidentResponse>());
+    OnReportUploadResult(context, IncidentReportUploader::UPLOAD_SUPPRESSED,
+                         std::unique_ptr<ClientIncidentResponse>());
   }
 }
 
 void IncidentReportingService::HandleResponse(const UploadContext& context) {
   // Mark each incident as reported in its corresponding profile's state store.
   for (const auto& context_and_states : context.profiles_to_state) {
     StateStore::Transaction transaction(
         context_and_states.first->state_store.get());
     for (const auto& state : context_and_states.second)
       transaction.MarkAsReported(state.type, state.key, state.digest);
   }
 }
 
 void IncidentReportingService::OnReportUploadResult(
     UploadContext* context,
     IncidentReportUploader::Result result,
-    scoped_ptr<ClientIncidentResponse> response) {
+    std::unique_ptr<ClientIncidentResponse> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   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;
-                         });
+  auto it =
+      std::find_if(uploads_.begin(), uploads_.end(),
+                   [context](const std::unique_ptr<UploadContext>& value) {
+                     return value.get() == context;
+                   });
   DCHECK(it != uploads_.end());
-  scoped_ptr<UploadContext> upload(std::move(*it));
+  std::unique_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