Disable SpdyCredentialBuilder tests with OpenSSL.

net/spdy/spdy_credential_builder_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/spdy/spdy_credential_builder.h"
 
 #include "base/threading/sequenced_worker_pool.h"
 #include "crypto/ec_signature_creator.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/asn1_util.h"
@@ skipping 57 matching lines @@
     return SpdyCredentialBuilder::GetCredentialSecret(
         MockClientSocket::kTlsUnique);
   }
 
   SpdyTestStateHelper helper_;  // Provides deterministic EC signatures.
   std::string cert_;
   std::string key_;
   SpdyCredential credential_;
 };
 
-TEST_F(SpdyCredentialBuilderTest, GetCredentialSecret) {
+// http://crbug.com/142833, http://crbug.com/140991. The following tests fail
+// with OpenSSL due to the unimplemented ec_private_key_openssl.cc.
+#if defined(USE_OPENSSL)
+#define MAYBE_GetCredentialSecret DISABLED_GetCredentialSecret
+#else
+#define MAYBE_GetCredentialSecret GetCredentialSecret
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_GetCredentialSecret) {
   std::string secret_str(kSecretPrefix, arraysize(kSecretPrefix));
   secret_str.append(MockClientSocket::kTlsUnique);
 
   EXPECT_EQ(secret_str, GetCredentialSecret());
 }
 
-TEST_F(SpdyCredentialBuilderTest, SucceedsWithECDSACert) {
+#if defined(USE_OPENSSL)
+#define MAYBE_SucceedsWithECDSACert DISABLED_SucceedsWithECDSACert
+#else
+#define MAYBE_SucceedsWithECDSACert SucceedsWithECDSACert
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_SucceedsWithECDSACert) {
   EXPECT_EQ(OK, BuildWithType(CLIENT_CERT_ECDSA_SIGN));
 }
 
-TEST_F(SpdyCredentialBuilderTest, FailsWithRSACert) {
+#if defined(USE_OPENSSL)
+#define MAYBE_FailsWithRSACert DISABLED_FailsWithRSACert
+#else
+#define MAYBE_FailsWithRSACert FailsWithRSACert
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_FailsWithRSACert) {
   EXPECT_EQ(ERR_BAD_SSL_CLIENT_AUTH_CERT,
             BuildWithType(CLIENT_CERT_RSA_SIGN));
 }
 
-TEST_F(SpdyCredentialBuilderTest, SetsSlotCorrectly) {
+#if defined(USE_OPENSSL)
+#define MAYBE_SetsSlotCorrectly DISABLED_SetsSlotCorrectly
+#else
+#define MAYBE_SetsSlotCorrectly SetsSlotCorrectly
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_SetsSlotCorrectly) {
   ASSERT_EQ(OK, Build());
   EXPECT_EQ(kSlot, credential_.slot);
 }
 
-TEST_F(SpdyCredentialBuilderTest, SetsCertCorrectly) {
+#if defined(USE_OPENSSL)
+#define MAYBE_SetsCertCorrectly DISABLED_SetsCertCorrectly
+#else
+#define MAYBE_SetsCertCorrectly SetsCertCorrectly
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_SetsCertCorrectly) {
   ASSERT_EQ(OK, Build());
   base::StringPiece spki;
   ASSERT_TRUE(asn1::ExtractSPKIFromDERCert(cert_, &spki));
   base::StringPiece spk;
   ASSERT_TRUE(asn1::ExtractSubjectPublicKeyFromSPKI(spki, &spk));
   EXPECT_EQ(1u, credential_.certs.size());
   EXPECT_EQ(0, (int)spk[0]);
   EXPECT_EQ(4, (int)spk[1]);
   EXPECT_EQ(spk.substr(2, spk.length()).as_string(), credential_.certs[0]);
 }
 
-TEST_F(SpdyCredentialBuilderTest, SetsProofCorrectly) {
+#if defined(USE_OPENSSL)
+#define MAYBE_SetsProofCorrectly DISABLED_SetsProofCorrectly
+#else
+#define MAYBE_SetsProofCorrectly SetsProofCorrectly
+#endif
+
+TEST_F(SpdyCredentialBuilderTest, MAYBE_SetsProofCorrectly) {
   ASSERT_EQ(OK, Build());
   base::StringPiece spki;
   ASSERT_TRUE(asn1::ExtractSPKIFromDERCert(cert_, &spki));
   std::vector<uint8> spki_data(spki.data(),
                                spki.data() + spki.size());
   std::vector<uint8> key_data(key_.data(),
                               key_.data() + key_.length());
   std::vector<uint8> proof_data;
   scoped_ptr<crypto::ECPrivateKey> private_key(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
           ServerBoundCertService::kEPKIPassword, key_data, spki_data));
   scoped_ptr<crypto::ECSignatureCreator> creator(
       crypto::ECSignatureCreator::Create(private_key.get()));
   std::string secret = GetCredentialSecret();
   creator->Sign(reinterpret_cast<const unsigned char *>(secret.data()),
                 secret.length(), &proof_data);
 
   std::string proof(proof_data.begin(), proof_data.end());
   EXPECT_EQ(proof, credential_.proof);
 }
 
 }  // namespace net