Reduce number of unnamed-type-template-args violations.

net/base/cert_database_nss_unittest.cc

 // Copyright (c) 2011 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 <cert.h>
 #include <pk11pub.h>
 
 #include <algorithm>
 
 #include "base/file_path.h"
@@ skipping 265 matching lines @@
   EXPECT_TRUE(cert_db_.ImportCACerts(certs, CertDatabase::TRUSTED_SSL,
                                      &failed));
 
   EXPECT_EQ(0U, failed.size());
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
   scoped_refptr<X509Certificate> cert(cert_list[0]);
   EXPECT_EQ("Test CA", cert->subject().common_name);
 
-  EXPECT_EQ(CertDatabase::TRUSTED_SSL,
+  EXPECT_EQ(static_cast<unsigned int>(CertDatabase::TRUSTED_SSL),
             cert_db_.GetCertTrust(cert.get(), CA_CERT));

[wtc, 2011/08/26 21:20:53]

Are these static_casts to unsigned int necessary because
CertDatabase::GetCertTrust returns unsigned int?  If so,
I'll look into changing CertDatabase::GetCertTrust to return
int.

[Peter Kasting, 2011/08/26 21:32:51]

MSVC seems to choose whether an enum's underlying type is signed or not based on
whether the enum is named.  Since this is technically implementation-dependent,
this is legal, if weird, but other compilers aren't guaranteed to agree.  So
your changing the signature may not result in us needing to remove the cast. 
Therefore, I'd just let it go.

 
   psm::nsNSSCertTrust trust(cert->os_cert_handle()->trust);
   EXPECT_TRUE(trust.HasTrustedCA(PR_TRUE, PR_FALSE, PR_FALSE));
   EXPECT_FALSE(trust.HasTrustedCA(PR_FALSE, PR_TRUE, PR_FALSE));
   EXPECT_FALSE(trust.HasTrustedCA(PR_FALSE, PR_FALSE, PR_TRUE));
   EXPECT_FALSE(trust.HasTrustedCA(PR_TRUE, PR_TRUE, PR_TRUE));
   EXPECT_TRUE(trust.HasCA(PR_TRUE, PR_TRUE, PR_TRUE));
 }
 
 TEST_F(CertDatabaseNSSTest, ImportCACert_EmailTrust) {
@@ skipping 10 matching lines @@
   EXPECT_TRUE(cert_db_.ImportCACerts(certs, CertDatabase::TRUSTED_EMAIL,
                                      &failed));
 
   EXPECT_EQ(0U, failed.size());
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
   scoped_refptr<X509Certificate> cert(cert_list[0]);
   EXPECT_EQ("Test CA", cert->subject().common_name);
 
-  EXPECT_EQ(CertDatabase::TRUSTED_EMAIL,
+  EXPECT_EQ(static_cast<unsigned int>(CertDatabase::TRUSTED_EMAIL),
             cert_db_.GetCertTrust(cert.get(), CA_CERT));
 
   psm::nsNSSCertTrust trust(cert->os_cert_handle()->trust);
   EXPECT_FALSE(trust.HasTrustedCA(PR_TRUE, PR_FALSE, PR_FALSE));
   EXPECT_TRUE(trust.HasTrustedCA(PR_FALSE, PR_TRUE, PR_FALSE));
   EXPECT_FALSE(trust.HasTrustedCA(PR_FALSE, PR_FALSE, PR_TRUE));
   EXPECT_TRUE(trust.HasCA(PR_TRUE, PR_TRUE, PR_TRUE));
 }
 
 TEST_F(CertDatabaseNSSTest, ImportCACert_ObjSignTrust) {
@@ skipping 10 matching lines @@
   EXPECT_TRUE(cert_db_.ImportCACerts(certs, CertDatabase::TRUSTED_OBJ_SIGN,
                                      &failed));
 
   EXPECT_EQ(0U, failed.size());
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
   scoped_refptr<X509Certificate> cert(cert_list[0]);
   EXPECT_EQ("Test CA", cert->subject().common_name);
 
-  EXPECT_EQ(CertDatabase::TRUSTED_OBJ_SIGN,
+  EXPECT_EQ(static_cast<unsigned int>(CertDatabase::TRUSTED_OBJ_SIGN),
             cert_db_.GetCertTrust(cert.get(), CA_CERT));
 
   psm::nsNSSCertTrust trust(cert->os_cert_handle()->trust);
   EXPECT_FALSE(trust.HasTrustedCA(PR_TRUE, PR_FALSE, PR_FALSE));
   EXPECT_FALSE(trust.HasTrustedCA(PR_FALSE, PR_TRUE, PR_FALSE));
   EXPECT_TRUE(trust.HasTrustedCA(PR_FALSE, PR_FALSE, PR_TRUE));
   EXPECT_TRUE(trust.HasCA(PR_TRUE, PR_TRUE, PR_TRUE));
 }
 
 TEST_F(CertDatabaseNSSTest, ImportCA_NotCACert) {
@@ skipping 166 matching lines @@
 
   EXPECT_EQ(0U, failed.size());
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(2U, cert_list.size());
   scoped_refptr<X509Certificate> goog_cert(cert_list[0]);
   scoped_refptr<X509Certificate> thawte_cert(cert_list[1]);
   EXPECT_EQ("www.google.com", goog_cert->subject().common_name);
   EXPECT_EQ("Thawte SGC CA", thawte_cert->subject().common_name);
 
-  EXPECT_EQ(CertDatabase::UNTRUSTED,
+  EXPECT_EQ(static_cast<unsigned int>(CertDatabase::UNTRUSTED),
             cert_db_.GetCertTrust(goog_cert.get(), SERVER_CERT));
   psm::nsNSSCertTrust goog_trust(goog_cert->os_cert_handle()->trust);
   EXPECT_TRUE(goog_trust.HasPeer(PR_TRUE, PR_TRUE, PR_TRUE));
 
   int flags = 0;
   CertVerifyResult verify_result;
   int error = goog_cert->Verify("www.google.com", flags, &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0, verify_result.cert_status);
 }
 
 TEST_F(CertDatabaseNSSTest, ImportServerCert_SelfSigned) {
   CertificateList certs;
   ASSERT_TRUE(ReadCertIntoList("punycodetest.der", &certs));
 
   CertDatabase::ImportCertFailureList failed;
   EXPECT_TRUE(cert_db_.ImportServerCert(certs, &failed));
 
   EXPECT_EQ(0U, failed.size());
 
   CertificateList cert_list = ListCertsInSlot(slot_->os_module_handle());
   ASSERT_EQ(1U, cert_list.size());
   scoped_refptr<X509Certificate> puny_cert(cert_list[0]);
 
-  EXPECT_EQ(CertDatabase::UNTRUSTED,
+  EXPECT_EQ(static_cast<unsigned int>(CertDatabase::UNTRUSTED),
             cert_db_.GetCertTrust(puny_cert.get(), SERVER_CERT));
   psm::nsNSSCertTrust puny_trust(puny_cert->os_cert_handle()->trust);
   EXPECT_TRUE(puny_trust.HasPeer(PR_TRUE, PR_TRUE, PR_TRUE));
 
   int flags = 0;
   CertVerifyResult verify_result;
   int error = puny_cert->Verify("xn--wgv71a119e.com", flags, &verify_result);
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, error);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, verify_result.cert_status);
 
   // TODO(mattm): this should be SERVER_CERT, not CA_CERT, but that does not
   // work due to NSS bug: https://bugzilla.mozilla.org/show_bug.cgi?id=531160
   EXPECT_TRUE(cert_db_.SetCertTrust(
       puny_cert.get(), CA_CERT,
       CertDatabase::TRUSTED_SSL | CertDatabase::TRUSTED_EMAIL));
 
   verify_result.Reset();
   error = puny_cert->Verify("xn--wgv71a119e.com", flags, &verify_result);
   EXPECT_EQ(OK, error);
   EXPECT_EQ(0, verify_result.cert_status);
 }
 
 }  // namespace net