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

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service_unittest.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 <stdint.h>
+
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "build/build_config.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
@@ skipping 23 matching lines @@
   // collector, extension collector and report uploader via callbacks.
   class TestIncidentReportingService
       : public safe_browsing::IncidentReportingService {
    public:
     typedef base::Callback<void(Profile*)> PreProfileAddCallback;
 
     typedef base::Callback<
         void(safe_browsing::ClientIncidentReport_EnvironmentData*)>
         CollectEnvironmentCallback;
 
-    typedef base::Callback<scoped_ptr<safe_browsing::LastDownloadFinder>(
+    typedef base::Callback<std::unique_ptr<safe_browsing::LastDownloadFinder>(
         const safe_browsing::LastDownloadFinder::LastDownloadCallback&
-            callback)> CreateDownloadFinderCallback;
+            callback)>
+        CreateDownloadFinderCallback;
 
-    typedef base::Callback<scoped_ptr<safe_browsing::IncidentReportUploader>(
-        const safe_browsing::IncidentReportUploader::OnResultCallback&,
-        const safe_browsing::ClientIncidentReport& report)> StartUploadCallback;
+    typedef base::Callback<
+        std::unique_ptr<safe_browsing::IncidentReportUploader>(
+            const safe_browsing::IncidentReportUploader::OnResultCallback&,
+            const safe_browsing::ClientIncidentReport& report)>
+        StartUploadCallback;
 
     TestIncidentReportingService(
         const scoped_refptr<base::TaskRunner>& task_runner,
         const PreProfileAddCallback& pre_profile_add_callback,
         const CollectEnvironmentCallback& collect_environment_callback,
         const CreateDownloadFinderCallback& create_download_finder_callback,
         const StartUploadCallback& start_upload_callback)
         : IncidentReportingService(NULL,
                                    NULL,
                                    base::TimeDelta::FromMilliseconds(5),
@@ skipping 25 matching lines @@
     // operation.
     void DoExtensionCollection(
         safe_browsing::ClientIncidentReport_ExtensionData* data) override {
       ASSERT_NE(static_cast<safe_browsing::ClientIncidentReport_ExtensionData*>(
                     nullptr),
                 data);
       data->mutable_last_installed_extension()->set_id(kFakeExtensionId);
       extension_collected_ = true;
     }
 
-    scoped_ptr<safe_browsing::LastDownloadFinder> CreateDownloadFinder(
+    std::unique_ptr<safe_browsing::LastDownloadFinder> CreateDownloadFinder(
         const safe_browsing::LastDownloadFinder::LastDownloadCallback& callback)
         override {
       return create_download_finder_callback_.Run(callback);
     }
 
-    scoped_ptr<safe_browsing::IncidentReportUploader> StartReportUpload(
+    std::unique_ptr<safe_browsing::IncidentReportUploader> StartReportUpload(
         const safe_browsing::IncidentReportUploader::OnResultCallback& callback,
         const scoped_refptr<net::URLRequestContextGetter>&
             request_context_getter,
         const safe_browsing::ClientIncidentReport& report) override {
       return start_upload_callback_.Run(callback, report);
     }
 
    private:
     static TestIncidentReportingService& current() {
       return *test_instance_.Get().Get();
@@ skipping 107 matching lines @@
     on_create_download_finder_action_ = action;
   }
 
   // Creates and returns a profile (owned by the profile manager) with or
   // without safe browsing enabled. An incident will be created within
   // PreProfileAdd if requested. |incidents_sent|, if provided, will be set
   // in the profile's preference.
   TestingProfile* CreateProfile(const std::string& profile_name,
                                 SafeBrowsingDisposition safe_browsing_opt_in,
                                 OnProfileAdditionAction on_addition_action,
-                                scoped_ptr<base::Value> incidents_sent) {
+                                std::unique_ptr<base::Value> incidents_sent) {
     // Create prefs for the profile with safe browsing enabled or not.
-    scoped_ptr<syncable_prefs::TestingPrefServiceSyncable> prefs(
+    std::unique_ptr<syncable_prefs::TestingPrefServiceSyncable> prefs(
         new syncable_prefs::TestingPrefServiceSyncable);
     chrome::RegisterUserProfilePrefs(prefs->registry());
     prefs->SetBoolean(prefs::kSafeBrowsingEnabled,
                       safe_browsing_opt_in != SAFE_BROWSING_OPT_OUT);
     prefs->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
                       safe_browsing_opt_in == EXTENDED_REPORTING_OPT_IN);
     if (incidents_sent)
       prefs->Set(prefs::kSafeBrowsingIncidentsSent, *incidents_sent);
 
     // Remember whether or not to create an incident.
@@ skipping 12 matching lines @@
   // finishes.
   void DeleteProfileOnUpload(Profile* profile) {
     ASSERT_TRUE(on_start_upload_callback_.is_null());
     on_start_upload_callback_ =
         base::Bind(&IncidentReportingServiceTest::DelayedDeleteProfile,
                    base::Unretained(this),
                    profile);
   }
 
   // Returns an incident suitable for testing.
-  scoped_ptr<safe_browsing::Incident> MakeTestIncident(const char* value) {
-    scoped_ptr<safe_browsing::
-                   ClientIncidentReport_IncidentData_TrackedPreferenceIncident>
+  std::unique_ptr<safe_browsing::Incident> MakeTestIncident(const char* value) {
+    std::unique_ptr<
+        safe_browsing::
+            ClientIncidentReport_IncidentData_TrackedPreferenceIncident>
         incident(
             new safe_browsing::
                 ClientIncidentReport_IncidentData_TrackedPreferenceIncident());
     incident->set_path(kTestTrackedPrefPath);
     if (value)
       incident->set_atomic_value(value);
-    return make_scoped_ptr(new safe_browsing::TrackedPreferenceIncident(
+    return base::WrapUnique(new safe_browsing::TrackedPreferenceIncident(
         std::move(incident), false /* is_personal */));
   }
 
   // Adds a test incident to the service.
   void AddTestIncident(Profile* profile) {
-    scoped_ptr<safe_browsing::IncidentReceiver> receiver(
+    std::unique_ptr<safe_browsing::IncidentReceiver> receiver(
         instance_->GetIncidentReceiver());
     if (profile)
       receiver->AddIncidentForProfile(profile, MakeTestIncident(nullptr));
     else
       receiver->AddIncidentForProcess(MakeTestIncident(nullptr));
   }
 
   // Registers the callback to be run for delayed analysis.
   void RegisterAnalysis(OnDelayedAnalysisAction on_delayed_analysis_action) {
     on_delayed_analysis_action_ = on_delayed_analysis_action;
@@ skipping 14 matching lines @@
     return environment_collected_ && instance_->HasCollectedExtension();
   }
   bool HasCreatedDownloadFinder() const { return download_finder_created_; }
   bool DownloadFinderDestroyed() const { return download_finder_destroyed_; }
   bool UploaderDestroyed() const { return uploader_destroyed_; }
   bool DelayedAnalysisRan() const { return delayed_analysis_ran_; }
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle thread_task_runner_handle_;
   TestingProfileManager profile_manager_;
-  scoped_ptr<TestIncidentReportingService> instance_;
+  std::unique_ptr<TestIncidentReportingService> instance_;
   base::Closure on_start_upload_callback_;
   OnCreateDownloadFinderAction on_create_download_finder_action_;
   OnDelayedAnalysisAction on_delayed_analysis_action_;
   safe_browsing::IncidentReportUploader::Result upload_result_;
   bool environment_collected_;
   bool download_finder_created_;
-  scoped_ptr<safe_browsing::ClientIncidentReport> uploaded_report_;
+  std::unique_ptr<safe_browsing::ClientIncidentReport> uploaded_report_;
   bool download_finder_destroyed_;
   bool uploader_destroyed_;
   bool delayed_analysis_ran_;
-  scoped_ptr<base::FieldTrialList> field_trial_list_;
+  std::unique_ptr<base::FieldTrialList> field_trial_list_;
   scoped_refptr<base::FieldTrial> field_trial_;
 
  private:
   // A fake IncidentReportUploader that posts a task to provide a given response
   // back to the incident reporting service. It also reports back to the test
   // harness via a closure when it is deleted by the incident reporting service.
   class FakeUploader : public safe_browsing::IncidentReportUploader {
    public:
     FakeUploader(
         const base::Closure& on_deleted,
         const safe_browsing::IncidentReportUploader::OnResultCallback& callback,
         safe_browsing::IncidentReportUploader::Result result)
         : safe_browsing::IncidentReportUploader(callback),
           on_deleted_(on_deleted),
           result_(result) {
       // Post a task that will provide the response.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&FakeUploader::FinishUpload, base::Unretained(this)));
     }
     ~FakeUploader() override { on_deleted_.Run(); }
 
    private:
     void FinishUpload() {
       // Callbacks have a tendency to delete the uploader, so no touching
       // anything after this.
       callback_.Run(result_,
-                    scoped_ptr<safe_browsing::ClientIncidentResponse>());
+                    std::unique_ptr<safe_browsing::ClientIncidentResponse>());
     }
 
     base::Closure on_deleted_;
     safe_browsing::IncidentReportUploader::Result result_;
 
     DISALLOW_COPY_AND_ASSIGN(FakeUploader);
   };
 
   class FakeDownloadFinder : public safe_browsing::LastDownloadFinder {
    public:
-    static scoped_ptr<safe_browsing::LastDownloadFinder> Create(
+    static std::unique_ptr<safe_browsing::LastDownloadFinder> Create(
         const base::Closure& on_deleted,
-        scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
+        std::unique_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
             binary_download,
-        scoped_ptr<safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>
+        std::unique_ptr<
+            safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>
             non_binary_download,
         const safe_browsing::LastDownloadFinder::LastDownloadCallback&
             callback) {
       // Post a task to run the callback.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, base::Passed(&binary_download),
                                 base::Passed(&non_binary_download)));
-      return scoped_ptr<safe_browsing::LastDownloadFinder>(
+      return std::unique_ptr<safe_browsing::LastDownloadFinder>(
           new FakeDownloadFinder(on_deleted));
     }
 
     ~FakeDownloadFinder() override { on_deleted_.Run(); }
 
    private:
     explicit FakeDownloadFinder(const base::Closure& on_deleted)
         : on_deleted_(on_deleted) {}
 
     base::Closure on_deleted_;
@@ skipping 88 matching lines @@
       safe_browsing::ClientIncidentReport_EnvironmentData* data) {
     ASSERT_NE(
         static_cast<safe_browsing::ClientIncidentReport_EnvironmentData*>(NULL),
         data);
     data->mutable_os()->set_os_name(kFakeOsName);
     environment_collected_ = true;
   }
 
   // A fake CreateDownloadFinder implementation invoked by the service during
   // operation.
-  scoped_ptr<safe_browsing::LastDownloadFinder> CreateDownloadFinder(
+  std::unique_ptr<safe_browsing::LastDownloadFinder> CreateDownloadFinder(
       const safe_browsing::LastDownloadFinder::LastDownloadCallback& callback) {
     download_finder_created_ = true;
-    scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
+    std::unique_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
         binary_download;
-    scoped_ptr<safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>
+    std::unique_ptr<
+        safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails>
         non_binary_download;
     if (on_create_download_finder_action_ ==
         ON_CREATE_DOWNLOAD_FINDER_NO_PROFILES) {
-      return scoped_ptr<safe_browsing::LastDownloadFinder>();
+      return std::unique_ptr<safe_browsing::LastDownloadFinder>();
     }
     if (on_create_download_finder_action_ ==
             ON_CREATE_DOWNLOAD_FINDER_DOWNLOADS_FOUND ||
         on_create_download_finder_action_ ==
             ON_CREATE_DOWNLOAD_FINDER_BINARY_DOWNLOAD_FOUND) {
       binary_download.reset(
           new safe_browsing::ClientIncidentReport_DownloadDetails);
       binary_download->set_token(kFakeDownloadToken);
     }
     if (on_create_download_finder_action_ ==
             ON_CREATE_DOWNLOAD_FINDER_DOWNLOADS_FOUND ||
         on_create_download_finder_action_ ==
             ON_CREATE_DOWNLOAD_FINDER_NON_BINARY_DOWNLOAD_FOUND) {
       non_binary_download.reset(
           new safe_browsing::ClientIncidentReport_NonBinaryDownloadDetails);
       non_binary_download->set_host(kFakeDownloadHost);
     }
 
-    return scoped_ptr<safe_browsing::LastDownloadFinder>(
+    return std::unique_ptr<safe_browsing::LastDownloadFinder>(
         FakeDownloadFinder::Create(
             base::Bind(&IncidentReportingServiceTest::OnDownloadFinderDestroyed,
                        base::Unretained(this)),
             std::move(binary_download), std::move(non_binary_download),
             callback));
   }
 
   // A fake StartUpload implementation invoked by the service during operation.
-  scoped_ptr<safe_browsing::IncidentReportUploader> StartUpload(
+  std::unique_ptr<safe_browsing::IncidentReportUploader> StartUpload(
       const safe_browsing::IncidentReportUploader::OnResultCallback& callback,
       const safe_browsing::ClientIncidentReport& report) {
     // Remember the report that is being uploaded.
     uploaded_report_.reset(new safe_browsing::ClientIncidentReport(report));
     // Run and clear the OnStartUpload callback, if provided.
     if (!on_start_upload_callback_.is_null()) {
       on_start_upload_callback_.Run();
       on_start_upload_callback_ = base::Closure();
     }
-    return make_scoped_ptr(new FakeUploader(
+    return base::WrapUnique(new FakeUploader(
         base::Bind(&IncidentReportingServiceTest::OnUploaderDestroyed,
                    base::Unretained(this)),
         callback, upload_result_));
   }
 
   void OnDownloadFinderDestroyed() { download_finder_destroyed_ = true; }
   void OnUploaderDestroyed() { uploader_destroyed_ = true; }
 
-  void OnDelayedAnalysis(scoped_ptr<safe_browsing::IncidentReceiver> receiver) {
+  void OnDelayedAnalysis(
+      std::unique_ptr<safe_browsing::IncidentReceiver> receiver) {
     delayed_analysis_ran_ = true;
     if (on_delayed_analysis_action_ == ON_DELAYED_ANALYSIS_ADD_INCIDENT)
       receiver->AddIncidentForProcess(MakeTestIncident(nullptr));
   }
 
 #if defined(OS_WIN)
   registry_util::RegistryOverrideManager registry_override_manager_;
 #endif
 
   // A mapping of profile name to its corresponding properties.
@@ skipping 195 matching lines @@
 }
 
 // Tests that incidents are only uploaded after a profile has been opted into
 // extended reporting.
 TEST_F(IncidentReportingServiceTest, NoUploadBeforeExtendedReporting) {
   SetFieldTrialAndCreateService(false);
   // Create the profile, thereby causing the test to begin.
   Profile* profile = CreateProfile("profile1", SAFE_BROWSING_OPT_IN,
                                    ON_PROFILE_ADDITION_NO_ACTION, nullptr);
 
-  scoped_ptr<safe_browsing::IncidentReceiver> receiver(
+  std::unique_ptr<safe_browsing::IncidentReceiver> receiver(
       instance_->GetIncidentReceiver());
 
   // Add a process-wide test incident.
   receiver->AddIncidentForProcess(MakeTestIncident(nullptr));
 
   // Let all tasks run.
   task_runner_->RunUntilIdle();
 
   // Downloads and environment data should have not been collected
   // (DownloadFinder will be created, but should be a no-op since no eligible
@@ skipping 308 matching lines @@
 
 // Tests that two process-wide incidents of the same type with different
 // payloads added via the same callback lead to two uploads.
 TEST_F(IncidentReportingServiceTest, ProcessWideTwoUploads) {
   SetFieldTrialAndCreateService(false);
   // Add a profile that participates in safe browsing.
   CreateProfile("profile1", EXTENDED_REPORTING_OPT_IN,
                 ON_PROFILE_ADDITION_NO_ACTION, nullptr);
 
   // Add the test incident.
-  scoped_ptr<safe_browsing::IncidentReceiver> receiver(
+  std::unique_ptr<safe_browsing::IncidentReceiver> receiver(
       instance_->GetIncidentReceiver());
   receiver->AddIncidentForProcess(MakeTestIncident(nullptr));
 
   // Let all tasks run.
   task_runner_->RunUntilIdle();
 
   // An upload should have taken place.
   ExpectTestIncidentUploadWithBinaryDownload(1);
 
   // Add a variation on the incident to the service.
@@ skipping 256 matching lines @@
 
 // Test that a profile's prune state is properly cleaned upon load.
 TEST_F(IncidentReportingServiceTest, CleanLegacyPruneState) {
   SetFieldTrialAndCreateService(false);
   const std::string omnibox_type(base::IntToString(
       static_cast<int32_t>(safe_browsing::IncidentType::OMNIBOX_INTERACTION)));
   const std::string preference_type(base::IntToString(
       static_cast<int32_t>(safe_browsing::IncidentType::TRACKED_PREFERENCE)));
 
   // Set up a prune state dict with data to be cleared (and not).
-  scoped_ptr<base::DictionaryValue> incidents_sent(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> incidents_sent(
+      new base::DictionaryValue());
   base::DictionaryValue* type_dict = new base::DictionaryValue();
   type_dict->SetStringWithoutPathExpansion("foo", "47");
   incidents_sent->SetWithoutPathExpansion(omnibox_type, type_dict);
   type_dict = new base::DictionaryValue();
   type_dict->SetStringWithoutPathExpansion("bar", "43");
   incidents_sent->SetWithoutPathExpansion(preference_type, type_dict);
 
   // Add a profile.
   Profile* profile =
       CreateProfile("profile1", EXTENDED_REPORTING_OPT_IN,
@@ skipping 11 matching lines @@
 }
 
 // Tests that an identical incident added after an incident is pruned and
 // cleared leads to an upload.
 TEST_F(IncidentReportingServiceTest, ProcessWideUploadClearUpload) {
   SetFieldTrialAndCreateService(false);
   // Add a profile that participates in safe browsing.
   CreateProfile("profile1", EXTENDED_REPORTING_OPT_IN,
                 ON_PROFILE_ADDITION_NO_ACTION, nullptr);
 
-  scoped_ptr<safe_browsing::IncidentReceiver> receiver(
+  std::unique_ptr<safe_browsing::IncidentReceiver> receiver(
       instance_->GetIncidentReceiver());
 
   // Add the test incident.
   receiver->AddIncidentForProcess(MakeTestIncident(nullptr));
 
   // Let all tasks run.
   task_runner_->RunUntilIdle();
 
   // An upload should have taken place.
   ExpectTestIncidentUploadWithBinaryDownload(1);
@@ skipping 19 matching lines @@
   // Ensure that no report processing remains.
   ASSERT_FALSE(instance_->IsProcessingReport());
 }
 
 TEST_F(IncidentReportingServiceTest, ClearProcessIncidentOnCleanState) {
   SetFieldTrialAndCreateService(false);
   // Add a profile that participates in safe browsing.
   CreateProfile("profile1", EXTENDED_REPORTING_OPT_IN,
                 ON_PROFILE_ADDITION_NO_ACTION, nullptr);
 
-  scoped_ptr<safe_browsing::IncidentReceiver> receiver(
+  std::unique_ptr<safe_browsing::IncidentReceiver> receiver(
       instance_->GetIncidentReceiver());
 
   // Clear incident data.
   receiver->ClearIncidentForProcess(MakeTestIncident(nullptr));
 
   // Let all tasks run.
   task_runner_->RunUntilIdle();
 
   // No uploads should have taken place.
   ExpectTestIncidentUploadWithBinaryDownload(0);
 
   // Downloads and environment data should have not been collected.
   ASSERT_FALSE(HasCreatedDownloadFinder());
   ASSERT_FALSE(HasCollectedEnvironmentAndExtensionData());
 
   // Ensure that no report processing remains.
   ASSERT_FALSE(instance_->IsProcessingReport());
 }
 
 // Parallel uploads
 // Shutdown during processing
 // environment colection taking longer than incident delay timer
 // environment colection taking longer than incident delay timer, and then
 // another incident arriving