Cache certificate verification results in memory.

net/socket/ssl_client_socket_snapstart_unittest.cc

 // Copyright (c) 2010 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 <arpa/inet.h>
 #include <netinet/tcp.h>
 #include <stdarg.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 
@@ skipping 23 matching lines @@
 #include "net/socket/tcp_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 // TestSSLHostInfo is an SSLHostInfo which stores a single state in memory and
 // pretends that certificate verification always succeeds.
 class TestSSLHostInfo : public SSLHostInfo {
  public:
-  TestSSLHostInfo()
-      : SSLHostInfo("example.com", kDefaultSSLConfig) {
+  explicit TestSSLHostInfo(CertVerifier* cert_verifier)
+      : SSLHostInfo("example.com", kDefaultSSLConfig, cert_verifier) {
     if (!saved_.empty())
       Parse(saved_);
     cert_verification_complete_ = true;
     cert_verification_error_ = OK;
   }
 
   virtual void Start() {
   }
 
   virtual int WaitForDataReady(CompletionCallback*) { return OK; }
@@ skipping 131 matching lines @@
     localhost.push_back(0);
     localhost.push_back(1);
     AddressList addr_list(localhost, 443, false);
     TCPClientSocket* transport = new TCPClientSocket(
         addr_list, &log_, NetLog::Source());
 
     transport->AdoptSocket(client_);
     scoped_ptr<SSLClientSocket> sock(
         socket_factory_->CreateSSLClientSocket(
             transport, HostPortPair("example.com", 443), ssl_config_,
-            new TestSSLHostInfo()));
+            new TestSSLHostInfo(&cert_verifier_), &cert_verifier_));
 
     TestCompletionCallback callback;
     int rv = sock->Connect(&callback);
     if (rv != OK) {
       ASSERT_EQ(ERR_IO_PENDING, rv);
       EXPECT_FALSE(sock->IsConnected());
       rv = callback.WaitForResult();
       EXPECT_EQ(OK, rv);
     }
     EXPECT_TRUE(sock->IsConnected());
@@ skipping 50 matching lines @@
     log_.GetEntries(&entries);
     for (CapturingNetLog::EntryList::const_iterator
          i = entries.begin(); i != entries.end(); i++) {
       if (i->type == NetLog::TYPE_SSL_VERIFICATION_MERGED)
         return true;
     }
     return false;
   }
 
   base::ProcessHandle child_;
+  CertVerifier cert_verifier_;
   ClientSocketFactory* const socket_factory_;
   struct sockaddr_in remote_;
   int client_;
   SSLConfig ssl_config_;
   CapturingNetLog log_;
   SSLClientSocket::NextProtoStatus next_proto_status_;
   std::string next_proto_;
 };
 
 TEST_F(SSLClientSocketSnapStartTest, Basic) {
@@ skipping 81 matching lines @@
 
   SSLClientSocketNSS::ClearSessionCache();
   PerformConnection();
   EXPECT_EQ(SSL_SNAP_START_FULL, SnapStartEventType());
   EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, next_proto_status_);
   EXPECT_EQ("baz", next_proto_);
   EXPECT_TRUE(DidMerge());
 }
 
 }  // namespace net