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

chrome/browser/safe_browsing/incident_reporting/extension_data_collection_unittest.cc

 // Copyright 2015 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/extension_data_collection.h"
 
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/install_signer.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
@@ skipping 111 matching lines @@
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
   }
 
   void TearDown() override {
     profile_manager_.reset();
     TestingBrowserProcess::DeleteInstance();
     testing::Test::TearDown();
   }
 
-  scoped_ptr<ExtensionTestingProfile> CreateProfile(
+  std::unique_ptr<ExtensionTestingProfile> CreateProfile(
       SafeBrowsingDisposition safe_browsing_opt_in) {
     std::string profile_name("profile");
     profile_name.append(base::IntToString(++profile_number_));
 
     // 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_IN);
     prefs->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
                       safe_browsing_opt_in == SAFE_BROWSING_OPT_IN);
     TestingProfile* profile = profile_manager_->CreateTestingProfile(
         profile_name, std::move(prefs),
         base::UTF8ToUTF16(profile_name),  // user_name
         0,                                // avatar_id
         std::string(),                    // supervised_user_id
         TestingProfile::TestingFactories());
 
-    return make_scoped_ptr(new ExtensionTestingProfile(profile));
+    return base::WrapUnique(new ExtensionTestingProfile(profile));
   }
 
   content::TestBrowserThreadBundle browser_thread_bundle_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
 
  private:
   int profile_number_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 };
 
 TEST_F(ExtensionDataCollectionTest, CollectExtensionDataNoExtensions) {
-  scoped_ptr<ExtensionTestingProfile> profile =
+  std::unique_ptr<ExtensionTestingProfile> profile =
       CreateProfile(SAFE_BROWSING_OPT_IN);
 
   ClientIncidentReport_ExtensionData data;
   CollectExtensionData(&data);
 
   ASSERT_FALSE(data.has_last_installed_extension());
 }
 
 TEST_F(ExtensionDataCollectionTest, CollectExtensionDataNoSafeBrowsing) {
-  scoped_ptr<ExtensionTestingProfile> profile =
+  std::unique_ptr<ExtensionTestingProfile> profile =
       CreateProfile(SAFE_BROWSING_OPT_OUT);
   profile->AddExtension();
 
   ClientIncidentReport_ExtensionData data;
   CollectExtensionData(&data);
 
   ASSERT_FALSE(data.has_last_installed_extension());
 }
 
 TEST_F(ExtensionDataCollectionTest, CollectExtensionDataWithExtension) {
   std::string extension_id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   std::string extension_name = "my_test_extension";
   base::Time install_time = base::Time::Now();
   std::string version = "1.4.2";
   std::string description = "Test Extension";
   std::string update_url = "https://www.chromium.org";
   int state = extensions::Extension::State::ENABLED;
 
-  scoped_ptr<ExtensionTestingProfile> profile =
+  std::unique_ptr<ExtensionTestingProfile> profile =
       CreateProfile(SAFE_BROWSING_OPT_IN);
   profile->AddExtension(extension_id, extension_name, install_time, version,
                         description, update_url, state);
 
   extensions::ExtensionIdSet valid_ids;
   extensions::ExtensionIdSet invalid_ids;
   invalid_ids.insert(extension_id);
   extensions::InstallSignature signature = {};
   signature.ids = valid_ids;
   signature.invalid_ids = invalid_ids;
@@ skipping 20 matching lines @@
       "manifest_version\":2,\"name\":\"my_test_extension\",\"update_url\":\""
       "https://www.chromium.org\",\"version\":\"1.4.2\"}";
   ASSERT_EQ(extension_info.manifest(), expected_manifest);
 }
 
 TEST_F(ExtensionDataCollectionTest, CollectsLastInstalledExtension) {
   std::string extension_id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   std::string extension_name = "extension_2";
   base::Time install_time = base::Time::Now() - base::TimeDelta::FromMinutes(3);
 
-  scoped_ptr<ExtensionTestingProfile> profile =
+  std::unique_ptr<ExtensionTestingProfile> profile =
       CreateProfile(SAFE_BROWSING_OPT_IN);
   profile->AddExtension("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "extension_1",
                         base::Time::Now() - base::TimeDelta::FromDays(2));
   profile->AddExtension(extension_id, extension_name, install_time);
   profile->AddExtension("cccccccccccccccccccccccccccccccc", "extension_3",
                         base::Time::Now() - base::TimeDelta::FromHours(4));
 
   ClientIncidentReport_ExtensionData data;
   CollectExtensionData(&data);
 
   ASSERT_TRUE(data.has_last_installed_extension());
   ClientIncidentReport_ExtensionData_ExtensionInfo extension_info =
       data.last_installed_extension();
 
   ASSERT_EQ(extension_info.id(), extension_id);
   ASSERT_EQ(extension_info.name(), extension_name);
   ASSERT_EQ(extension_info.install_time_msec(), install_time.ToJavaTime());
 }
 
 TEST_F(ExtensionDataCollectionTest, IgnoresExtensionsIfNoSafeBrowsing) {
   std::string extension_id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   std::string extension_name = "extension_2";
 
-  scoped_ptr<ExtensionTestingProfile> profile =
+  std::unique_ptr<ExtensionTestingProfile> profile =
       CreateProfile(SAFE_BROWSING_OPT_IN);
 
   profile->AddExtension(extension_id, extension_name,
                         base::Time::Now() - base::TimeDelta::FromDays(3));
 
-  scoped_ptr<ExtensionTestingProfile> profile_without_safe_browsing =
+  std::unique_ptr<ExtensionTestingProfile> profile_without_safe_browsing =
       CreateProfile(SAFE_BROWSING_OPT_OUT);
   profile_without_safe_browsing->AddExtension(
       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "extension_1",
       base::Time::Now() - base::TimeDelta::FromDays(2));
 
   ClientIncidentReport_ExtensionData data;
   CollectExtensionData(&data);
 
   ASSERT_TRUE(data.has_last_installed_extension());
   ClientIncidentReport_ExtensionData_ExtensionInfo extension_info =
       data.last_installed_extension();
 
   ASSERT_EQ(extension_info.id(), extension_id);
   ASSERT_EQ(extension_info.name(), extension_name);
 }
 
 }  // namespace safe_browsing