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

net/cert/x509_certificate_unittest.cc

 // Copyright (c) 2012 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/x509_certificate.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
@@ skipping 73 matching lines @@
 };
 
 // Dec 18 00:00:00 2009 GMT
 const double kGoogleParseValidFrom = 1261094400;
 // Dec 18 23:59:59 2011 GMT
 const double kGoogleParseValidTo = 1324252799;
 
 void CheckGoogleCert(const scoped_refptr<X509Certificate>& google_cert,
                      uint8* expected_fingerprint,
                      double valid_from, double valid_to) {
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), google_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), google_cert.get());
 
   const CertPrincipal& subject = google_cert->subject();
   EXPECT_EQ("www.google.com", subject.common_name);
   EXPECT_EQ("Mountain View", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   ASSERT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Google Inc", subject.organization_names[0]);
   EXPECT_EQ(0U, subject.organization_unit_names.size());
@@ skipping 34 matching lines @@
 
   CheckGoogleCert(google_cert, google_fingerprint,
                   1238192407,   // Mar 27 22:20:07 2009 GMT
                   1269728407);  // Mar 27 22:20:07 2010 GMT
 }
 
 TEST(X509CertificateTest, WebkitCertParsing) {
   scoped_refptr<X509Certificate> webkit_cert(X509Certificate::CreateFromBytes(
       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)));
 
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), webkit_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), webkit_cert.get());
 
   const CertPrincipal& subject = webkit_cert->subject();
   EXPECT_EQ("Cupertino", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   ASSERT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Apple Inc.", subject.organization_names[0]);
   ASSERT_EQ(1U, subject.organization_unit_names.size());
   EXPECT_EQ("Mac OS Forge", subject.organization_unit_names[0]);
@@ skipping 35 matching lines @@
   EXPECT_TRUE(webkit_cert->VerifyNameMatch("foo.webkit.org", &unused));
   EXPECT_TRUE(webkit_cert->VerifyNameMatch("webkit.org", &unused));
   EXPECT_FALSE(webkit_cert->VerifyNameMatch("www.webkit.com", &unused));
   EXPECT_FALSE(webkit_cert->VerifyNameMatch("www.foo.webkit.com", &unused));
 }
 
 TEST(X509CertificateTest, ThawteCertParsing) {
   scoped_refptr<X509Certificate> thawte_cert(X509Certificate::CreateFromBytes(
       reinterpret_cast<const char*>(thawte_der), sizeof(thawte_der)));
 
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), thawte_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), thawte_cert.get());
 
   const CertPrincipal& subject = thawte_cert->subject();
   EXPECT_EQ("www.thawte.com", subject.common_name);
   EXPECT_EQ("Mountain View", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   ASSERT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Thawte Inc", subject.organization_names[0]);
   EXPECT_EQ(0U, subject.organization_unit_names.size());
@@ skipping 31 matching lines @@
 
 // Test that all desired AttributeAndValue pairs can be extracted when only
 // a single RelativeDistinguishedName is present. "Normally" there is only
 // one AVA per RDN, but some CAs place all AVAs within a single RDN.
 // This is a regression test for http://crbug.com/101009
 TEST(X509CertificateTest, MultivalueRDN) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> multivalue_rdn_cert =
       ImportCertFromFile(certs_dir, "multivalue_rdn.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), multivalue_rdn_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), multivalue_rdn_cert.get());
 
   const CertPrincipal& subject = multivalue_rdn_cert->subject();
   EXPECT_EQ("Multivalue RDN Test", subject.common_name);
   EXPECT_EQ("", subject.locality_name);
   EXPECT_EQ("", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   EXPECT_EQ(0U, subject.street_addresses.size());
   ASSERT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Chromium", subject.organization_names[0]);
   ASSERT_EQ(1U, subject.organization_unit_names.size());
   EXPECT_EQ("Chromium net_unittests", subject.organization_unit_names[0]);
   ASSERT_EQ(1U, subject.domain_components.size());
   EXPECT_EQ("Chromium", subject.domain_components[0]);
 }
 
 // Test that characters which would normally be escaped in the string form,
 // such as '=' or '"', are not escaped when parsed as individual components.
 // This is a regression test for http://crbug.com/102839
 TEST(X509CertificateTest, UnescapedSpecialCharacters) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> unescaped_cert =
       ImportCertFromFile(certs_dir, "unescaped.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), unescaped_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), unescaped_cert.get());
 
   const CertPrincipal& subject = unescaped_cert->subject();
   EXPECT_EQ("127.0.0.1", subject.common_name);
   EXPECT_EQ("Mountain View", subject.locality_name);
   EXPECT_EQ("California", subject.state_or_province_name);
   EXPECT_EQ("US", subject.country_name);
   ASSERT_EQ(1U, subject.street_addresses.size());
   EXPECT_EQ("1600 Amphitheatre Parkway", subject.street_addresses[0]);
   ASSERT_EQ(1U, subject.organization_names.size());
   EXPECT_EQ("Chromium = \"net_unittests\"", subject.organization_names[0]);
@@ skipping 29 matching lines @@
             paypal_null_cert->serial_number().size());
   EXPECT_TRUE(memcmp(paypal_null_cert->serial_number().data(),
                      paypal_null_serial, sizeof(paypal_null_serial)) == 0);
 }
 
 TEST(X509CertificateTest, CAFingerprints) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> server_cert =
       ImportCertFromFile(certs_dir, "salesforce_com_test.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), server_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), server_cert.get());
 
   scoped_refptr<X509Certificate> intermediate_cert1 =
       ImportCertFromFile(certs_dir, "verisign_intermediate_ca_2011.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), intermediate_cert1);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), intermediate_cert1.get());
 
   scoped_refptr<X509Certificate> intermediate_cert2 =
       ImportCertFromFile(certs_dir, "verisign_intermediate_ca_2016.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), intermediate_cert2);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), intermediate_cert2.get());
 
   X509Certificate::OSCertHandles intermediates;
   intermediates.push_back(intermediate_cert1->os_cert_handle());
   scoped_refptr<X509Certificate> cert_chain1 =
       X509Certificate::CreateFromHandle(server_cert->os_cert_handle(),
                                         intermediates);
 
   intermediates.clear();
   intermediates.push_back(intermediate_cert2->os_cert_handle());
   scoped_refptr<X509Certificate> cert_chain2 =
@@ skipping 99 matching lines @@
                      cert_chain2_chain_fingerprint_256, 32) == 0);
   EXPECT_TRUE(memcmp(chain_fingerprint_256_3.data,
                      cert_chain3_chain_fingerprint_256, 32) == 0);
 }
 
 TEST(X509CertificateTest, ParseSubjectAltNames) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> san_cert =
       ImportCertFromFile(certs_dir, "subjectAltName_sanity_check.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), san_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), san_cert.get());
 
   std::vector<std::string> dns_names;
   std::vector<std::string> ip_addresses;
   san_cert->GetSubjectAltName(&dns_names, &ip_addresses);
 
   // Ensure that DNS names are correctly parsed.
   ASSERT_EQ(1U, dns_names.size());
   EXPECT_EQ("test.example", dns_names[0]);
 
   // Ensure that both IPv4 and IPv6 addresses are correctly parsed.
@@ skipping 16 matching lines @@
 
   // Ensure the subjectAltName dirName has not influenced the handling of
   // the subject commonName.
   EXPECT_EQ("127.0.0.1", san_cert->subject().common_name);
 }
 
 TEST(X509CertificateTest, ExtractSPKIFromDERCert) {
   base::FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> cert =
       ImportCertFromFile(certs_dir, "nist.der");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert.get());
 
   std::string derBytes;
   EXPECT_TRUE(X509Certificate::GetDEREncoded(cert->os_cert_handle(),
                                              &derBytes));
 
   base::StringPiece spkiBytes;
   EXPECT_TRUE(asn1::ExtractSPKIFromDERCert(derBytes, &spkiBytes));
 
   uint8 hash[base::kSHA1Length];
   base::SHA1HashBytes(reinterpret_cast<const uint8*>(spkiBytes.data()),
                       spkiBytes.size(), hash);
 
   EXPECT_EQ(0, memcmp(hash, kNistSPKIHash, sizeof(hash)));
 }
 
 TEST(X509CertificateTest, ExtractCRLURLsFromDERCert) {
   base::FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> cert =
       ImportCertFromFile(certs_dir, "nist.der");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert.get());
 
   std::string derBytes;
   EXPECT_TRUE(X509Certificate::GetDEREncoded(cert->os_cert_handle(),
                                              &derBytes));
 
   std::vector<base::StringPiece> crl_urls;
   EXPECT_TRUE(asn1::ExtractCRLURLsFromDERCert(derBytes, &crl_urls));
 
   EXPECT_EQ(1u, crl_urls.size());
   if (crl_urls.size() > 0) {
@@ skipping 69 matching lines @@
   X509Certificate::FreeOSCertHandle(google_cert_handle);
   X509Certificate::FreeOSCertHandle(thawte_cert_handle);
 
   Pickle pickle;
   cert->Persist(&pickle);
 
   PickleIterator iter(pickle);
   scoped_refptr<X509Certificate> cert_from_pickle =
       X509Certificate::CreateFromPickle(
           pickle, &iter, X509Certificate::PICKLETYPE_CERTIFICATE_CHAIN_V3);
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert_from_pickle);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), cert_from_pickle.get());
   EXPECT_TRUE(X509Certificate::IsSameOSCert(
       cert->os_cert_handle(), cert_from_pickle->os_cert_handle()));
   const X509Certificate::OSCertHandles& cert_intermediates =
       cert->GetIntermediateCertificates();
   const X509Certificate::OSCertHandles& pickle_intermediates =
       cert_from_pickle->GetIntermediateCertificates();
   ASSERT_EQ(cert_intermediates.size(), pickle_intermediates.size());
   for (size_t i = 0; i < cert_intermediates.size(); ++i) {
     EXPECT_TRUE(X509Certificate::IsSameOSCert(cert_intermediates[i],
                                               pickle_intermediates[i]));
@@ skipping 142 matching lines @@
   // Cleanup
   X509Certificate::FreeOSCertHandle(google_handle);
 }
 
 TEST(X509CertificateTest, IsIssuedByEncoded) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   // Test a client certificate from MIT.
   scoped_refptr<X509Certificate> mit_davidben_cert(
       ImportCertFromFile(certs_dir, "mit.davidben.der"));
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), mit_davidben_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), mit_davidben_cert.get());
 
   std::string mit_issuer(reinterpret_cast<const char*>(MITDN),
                          sizeof(MITDN));
 
   // Test a certificate from Google, issued by Thawte
   scoped_refptr<X509Certificate> google_cert(
       ImportCertFromFile(certs_dir, "google.single.der"));
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), google_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), google_cert.get());
 
   std::string thawte_issuer(reinterpret_cast<const char*>(ThawteDN),
                             sizeof(ThawteDN));
 
   // Check that the David Ben certificate is issued by MIT, but not
   // by Thawte.
   std::vector<std::string> issuers;
   issuers.clear();
   issuers.push_back(mit_issuer);
   EXPECT_TRUE(mit_davidben_cert->IsIssuedByEncoded(issuers));
@@ skipping 81 matching lines @@
 TEST(X509CertificateTest, FreeNullHandle) {
   X509Certificate::FreeOSCertHandle(NULL);
 }
 
 #if defined(USE_NSS)
 TEST(X509CertificateTest, GetDefaultNickname) {
   base::FilePath certs_dir = GetTestCertsDirectory();
 
   scoped_refptr<X509Certificate> test_cert(
       ImportCertFromFile(certs_dir, "no_subject_common_name_cert.pem"));
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
 
   std::string nickname = test_cert->GetDefaultNickname(USER_CERT);
   EXPECT_EQ("wtc@google.com's COMODO Client Authentication and "
             "Secure Email CA ID", nickname);
 }
 #endif
 
 const struct CertificateFormatTestData {
   const char* file_name;
   X509Certificate::Format format;
@@ skipping 377 matching lines @@
                                     &actual_type);
 
   EXPECT_EQ(data.expected_bits, actual_bits);
   EXPECT_EQ(data.expected_type, actual_type);
 }
 
 INSTANTIATE_TEST_CASE_P(, X509CertificatePublicKeyInfoTest,
                         testing::ValuesIn(kPublicKeyInfoTestData));
 
 }  // namespace net