Remove implicit conversions from scoped_refptr to T* in net/cert/

net/cert/multi_log_ct_verifier_unittest.cc

 // Copyright 2013 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 "net/cert/multi_log_ct_verifier.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 30 matching lines @@
     scoped_ptr<CTLogVerifier> log(
         CTLogVerifier::Create(ct::GetTestPublicKey(), kLogDescription));
     ASSERT_TRUE(log);
 
     verifier_.reset(new MultiLogCTVerifier());
     verifier_->AddLog(log.Pass());
     std::string der_test_cert(ct::GetDerEncodedX509Cert());
     chain_ = X509Certificate::CreateFromBytes(
         der_test_cert.data(),
         der_test_cert.length());
-    ASSERT_TRUE(chain_);
+    ASSERT_TRUE(chain_.get());
 
     embedded_sct_chain_ =
         CreateCertificateChainFromFile(GetTestCertsDirectory(),
                                        "ct-test-embedded-cert.pem",
                                        X509Certificate::FORMAT_AUTO);
-    ASSERT_TRUE(embedded_sct_chain_);
+    ASSERT_TRUE(embedded_sct_chain_.get());
   }
 
   bool CheckForSingleVerifiedSCTInResult(const ct::CTVerifyResult& result) {
     return (result.verified_scts.size() == 1U) &&
         result.invalid_scts.empty() &&
         result.unknown_logs_scts.empty() &&
         result.verified_scts[0]->log_description == kLogDescription;
   }
 
   bool CheckForSCTOrigin(
@@ skipping 55 matching lines @@
     sct[15] = 't';
 
     std::string sct_list;
     ct::EncodeSCTListForTesting(sct, &sct_list);
     return sct_list;
   }
 
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain,
                                        const BoundNetLog& bound_net_log,
                                        ct::CTVerifyResult* result) {
-    return verifier_->Verify(
-               chain, std::string(), std::string(), result, bound_net_log) ==
-           OK;
+    return verifier_->Verify(chain.get(),
+                             std::string(),
+                             std::string(),
+                             result,
+                             bound_net_log) == OK;
   }
 
   bool VerifySinglePrecertificateChain(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
     CapturingNetLog net_log;
     BoundNetLog bound_net_log =
         BoundNetLog::Make(&net_log, NetLog::SOURCE_CONNECT_JOB);
 
-    return verifier_->Verify(
-               chain, std::string(), std::string(), &result, bound_net_log) ==
-           OK;
+    return verifier_->Verify(chain.get(),
+                             std::string(),
+                             std::string(),
+                             &result,
+                             bound_net_log) == OK;
   }
 
   bool CheckPrecertificateVerification(scoped_refptr<X509Certificate> chain) {
     ct::CTVerifyResult result;
     CapturingNetLog net_log;
     BoundNetLog bound_net_log =
       BoundNetLog::Make(&net_log, NetLog::SOURCE_CONNECT_JOB);
     return (VerifySinglePrecertificateChain(chain, bound_net_log, &result) &&
             CheckForSingleVerifiedSCTInResult(result) &&
             CheckForSCTOrigin(result,
@@ skipping 35 matching lines @@
 
 TEST_F(MultiLogCTVerifierTest, VerifiesEmbeddedSCT) {
   ASSERT_TRUE(CheckPrecertificateVerification(embedded_sct_chain_));
 }
 
 TEST_F(MultiLogCTVerifierTest, VerifiesEmbeddedSCTWithPreCA) {
   scoped_refptr<X509Certificate> chain(
       CreateCertificateChainFromFile(GetTestCertsDirectory(),
                                      "ct-test-embedded-with-preca-chain.pem",
                                      X509Certificate::FORMAT_AUTO));
-  ASSERT_TRUE(chain);
+  ASSERT_TRUE(chain.get());
   ASSERT_TRUE(CheckPrecertificateVerification(chain));
 }
 
 TEST_F(MultiLogCTVerifierTest, VerifiesEmbeddedSCTWithIntermediate) {
   scoped_refptr<X509Certificate> chain(CreateCertificateChainFromFile(
       GetTestCertsDirectory(),
       "ct-test-embedded-with-intermediate-chain.pem",
       X509Certificate::FORMAT_AUTO));
-  ASSERT_TRUE(chain);
+  ASSERT_TRUE(chain.get());
   ASSERT_TRUE(CheckPrecertificateVerification(chain));
 }
 
 TEST_F(MultiLogCTVerifierTest,
        VerifiesEmbeddedSCTWithIntermediateAndPreCA) {
   scoped_refptr<X509Certificate> chain(CreateCertificateChainFromFile(
       GetTestCertsDirectory(),
       "ct-test-embedded-with-intermediate-preca-chain.pem",
       X509Certificate::FORMAT_AUTO));
-  ASSERT_TRUE(chain);
+  ASSERT_TRUE(chain.get());
   ASSERT_TRUE(CheckPrecertificateVerification(chain));
 }
 
 TEST_F(MultiLogCTVerifierTest,
        VerifiesSCTOverX509Cert) {
   std::string sct(ct::GetTestSignedCertificateTimestamp());
 
   std::string sct_list;
   ASSERT_TRUE(ct::EncodeSCTListForTesting(sct, &sct_list));
 
   ct::CTVerifyResult result;
   EXPECT_EQ(OK,
-            verifier_->Verify(chain_, std::string(), sct_list, &result,
-                              BoundNetLog()));
+            verifier_->Verify(
+                chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
   ASSERT_TRUE(CheckForSingleVerifiedSCTInResult(result));
   ASSERT_TRUE(CheckForSCTOrigin(
       result, ct::SignedCertificateTimestamp::SCT_FROM_TLS_EXTENSION));
 }
 
 TEST_F(MultiLogCTVerifierTest,
        IdentifiesSCTFromUnknownLog) {
   std::string sct_list = GetSCTListWithInvalidSCT();
   ct::CTVerifyResult result;
 
   EXPECT_NE(OK,
             verifier_->Verify(
-                chain_, std::string(), sct_list, &result, BoundNetLog()));
+                chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
   EXPECT_EQ(1U, result.unknown_logs_scts.size());
   EXPECT_EQ("", result.unknown_logs_scts[0]->log_description);
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsValidSCTsInStatusHistogram) {
   int num_valid_scts = NumValidSCTsInStatusHistogram();
 
   ASSERT_TRUE(VerifySinglePrecertificateChain(embedded_sct_chain_));
 
   EXPECT_EQ(num_valid_scts + 1, NumValidSCTsInStatusHistogram());
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsInvalidSCTsInStatusHistogram) {
   std::string sct_list = GetSCTListWithInvalidSCT();
   ct::CTVerifyResult result;
   int num_valid_scts = NumValidSCTsInStatusHistogram();
   int num_invalid_scts = GetValueFromHistogram(
       "Net.CertificateTransparency.SCTStatus", ct::SCT_STATUS_LOG_UNKNOWN);
 
   EXPECT_NE(OK,
-            verifier_->Verify(chain_, std::string(), sct_list, &result,
-                              BoundNetLog()));
+            verifier_->Verify(
+                chain_.get(), std::string(), sct_list, &result, BoundNetLog()));
 
   ASSERT_EQ(num_valid_scts, NumValidSCTsInStatusHistogram());
   ASSERT_EQ(num_invalid_scts + 1,
             GetValueFromHistogram("Net.CertificateTransparency.SCTStatus",
                                   ct::SCT_STATUS_LOG_UNKNOWN));
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsSingleEmbeddedSCTInConnectionsHistogram) {
   int old_sct_count = NumConnectionsWithSingleSCT();
   ASSERT_TRUE(CheckPrecertificateVerification(embedded_sct_chain_));
   EXPECT_EQ(old_sct_count + 1, NumConnectionsWithSingleSCT());
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsSingleEmbeddedSCTInOriginsHistogram) {
   int old_embedded_count = NumEmbeddedSCTsInHistogram();
   ASSERT_TRUE(CheckPrecertificateVerification(embedded_sct_chain_));
   EXPECT_EQ(old_embedded_count + 1, NumEmbeddedSCTsInHistogram());
 }
 
 TEST_F(MultiLogCTVerifierTest, CountsZeroSCTsCorrectly) {
   int connections_without_scts = GetValueFromHistogram(kSCTCountHistogram, 0);
   EXPECT_FALSE(VerifySinglePrecertificateChain(chain_));
   ASSERT_EQ(connections_without_scts + 1,
             GetValueFromHistogram(kSCTCountHistogram, 0));
 }
 
 }  // namespace
 
 }  // namespace net