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

chrome/browser/safe_browsing/incident_reporting/binary_integrity_analyzer_mac_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/binary_integrity_analyzer_mac.h"
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/mac/bundle_locations.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
 #include "chrome/browser/safe_browsing/incident_reporting/mock_incident_receiver.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::StrictMock;
@@ skipping 60 matching lines @@
   std::vector<PathAndRequirement> paths_and_requirements =
       GetCriticalPathsAndRequirements();
   ASSERT_EQ(1u, paths_and_requirements.size());
   EXPECT_EQ(paths_and_requirements[0].path,
             paths_and_requirements_expected[0].path);
   EXPECT_EQ(paths_and_requirements[0].requirement,
             paths_and_requirements_expected[0].requirement);
 }
 
 TEST_F(BinaryIntegrityAnalyzerMacTest, VerifyBinaryIntegrityForTesting) {
-  scoped_ptr<MockIncidentReceiver> mock_receiver(
+  std::unique_ptr<MockIncidentReceiver> mock_receiver(
       new StrictMock<MockIncidentReceiver>());
   base::FilePath bundle = temp_dir_.path().Append(kBundleBase);
   std::string requirement(
       "certificate leaf[subject.CN]=\"untrusted@goat.local\"");
 
   // Run check on valid bundle.
-  scoped_ptr<Incident> incident_to_clear;
+  std::unique_ptr<Incident> incident_to_clear;
   EXPECT_CALL(*mock_receiver, DoClearIncidentForProcess(_))
       .WillOnce(TakeIncident(&incident_to_clear));
   VerifyBinaryIntegrityForTesting(mock_receiver.get(), bundle, requirement);
 
   ASSERT_TRUE(incident_to_clear);
   ASSERT_EQ(IncidentType::BINARY_INTEGRITY, incident_to_clear->GetType());
   ASSERT_EQ(incident_to_clear->GetKey(), "test-bundle.app");
 
   base::FilePath exe_path = temp_dir_.path().Append(kBundleURL);
   ASSERT_TRUE(CorruptFileContent(exe_path));
 
-  scoped_ptr<Incident> incident;
+  std::unique_ptr<Incident> incident;
   EXPECT_CALL(*mock_receiver, DoAddIncidentForProcess(_))
       .WillOnce(TakeIncident(&incident));
 
   VerifyBinaryIntegrityForTesting(mock_receiver.get(), bundle, requirement);
 
   // Verify that the incident report contains the expected data.
-  scoped_ptr<ClientIncidentReport_IncidentData> incident_data(
+  std::unique_ptr<ClientIncidentReport_IncidentData> incident_data(
       incident->TakePayload());
 
   ASSERT_TRUE(incident_data->has_binary_integrity());
   EXPECT_TRUE(incident_data->binary_integrity().has_file_basename());
   EXPECT_EQ("test-bundle.app",
             incident_data->binary_integrity().file_basename());
   EXPECT_TRUE(incident_data->binary_integrity().has_sec_error());
   EXPECT_EQ(-67061, incident_data->binary_integrity().sec_error());
   EXPECT_FALSE(incident_data->binary_integrity().has_signature());
   EXPECT_EQ(0,
             incident_data->binary_integrity().signature().signed_data_size());
   EXPECT_EQ(1, incident_data->binary_integrity().contained_file_size());
 
   const auto& contained_file =
       incident_data->binary_integrity().contained_file(0);
   EXPECT_EQ(contained_file.relative_path(), "Contents/MacOS/test-bundle");
   EXPECT_TRUE(contained_file.has_signature());
   EXPECT_TRUE(contained_file.has_image_headers());
 }
 
 }  // namespace safe_browsing