Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/certificate_reporting/error_reporter_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 "components/certificate_reporting/error_reporter.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "components/certificate_reporting/encrypted_cert_logger.pb.h"
 #include "crypto/curve25519.h"
 #include "net/url_request/certificate_report_sender.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace certificate_reporting {
 
 namespace {
 
 const char kDummyHttpReportUri[] = "http://example.test";
@@ skipping 41 matching lines @@
 
 // Test that ErrorReporter::SendExtendedReportingReport sends
 // an encrypted or plaintext extended reporting report as appropriate.
 TEST_F(ErrorReporterTest, ExtendedReportingSendReport) {
   // Data should not be encrypted when sent to an HTTPS URL.
   MockCertificateReportSender* mock_report_sender =
       new MockCertificateReportSender();
   GURL https_url(kDummyHttpsReportUri);
   ErrorReporter https_reporter(https_url, server_public_key_,
                                kServerPublicKeyTestVersion,
-                               make_scoped_ptr(mock_report_sender));
+                               base::WrapUnique(mock_report_sender));
   https_reporter.SendExtendedReportingReport(kDummyReport);
   EXPECT_EQ(mock_report_sender->latest_report_uri(), https_url);
   EXPECT_EQ(mock_report_sender->latest_report(), kDummyReport);
 
   // Data should be encrypted when sent to an HTTP URL.
   if (ErrorReporter::IsHttpUploadUrlSupported()) {
     MockCertificateReportSender* http_mock_report_sender =
         new MockCertificateReportSender();
     GURL http_url(kDummyHttpReportUri);
     ErrorReporter http_reporter(http_url, server_public_key_,
                                 kServerPublicKeyTestVersion,
-                                make_scoped_ptr(http_mock_report_sender));
+                                base::WrapUnique(http_mock_report_sender));
     http_reporter.SendExtendedReportingReport(kDummyReport);
 
     EXPECT_EQ(http_mock_report_sender->latest_report_uri(), http_url);
 
     std::string uploaded_report;
     EncryptedCertLoggerRequest encrypted_request;
     ASSERT_TRUE(encrypted_request.ParseFromString(
         http_mock_report_sender->latest_report()));
     EXPECT_EQ(kServerPublicKeyTestVersion,
               encrypted_request.server_public_key_version());
@@ skipping 162 matching lines @@
   ASSERT_TRUE(encrypted_request.ParseFromString(
       std::string(reinterpret_cast<const char*>(kSerializedEncryptedReport),
                   sizeof(kSerializedEncryptedReport))));
   ASSERT_TRUE(ErrorReporter::DecryptErrorReport(
       server_private_key_, encrypted_request, &decrypted_serialized_report));
 }
 
 }  // namespace
 
 }  // namespace certificate_reporting