snap_start_tests: test NPN misprediction.

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 207 matching lines @@
 
     scoped_refptr<IOBuffer> reply_buffer = new IOBuffer(8);
     rv = sock->Read(reply_buffer, 8, &callback);
     if (rv < 0) {
       ASSERT_EQ(ERR_IO_PENDING, rv);
       rv = callback.WaitForResult();
     }
     EXPECT_EQ(8, rv);
     EXPECT_TRUE(memcmp(reply_buffer->data(), "goodbye!", 8) == 0);
 
+    next_proto_status_ = sock->GetNextProto(&next_proto_);
+
     sock->Disconnect();
   }
 
   // SnapStartEventType extracts the type of Snap Start from the NetLog. See
   // the SSL_SNAP_START_* defines in sslt.h
   int SnapStartEventType() {
     const std::vector<CapturingNetLog::Entry>& entries = log_.entries();
     for (std::vector<CapturingNetLog::Entry>::const_iterator
          i = entries.begin(); i != entries.end(); i++) {
       if (i->type == NetLog::TYPE_SSL_SNAP_START) {
@@ skipping 20 matching lines @@
     }
     return false;
   }
 
   base::ProcessHandle child_;
   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) {
   // Not a Snap Start connection.
   StartSnapStartServer(NULL);
   PerformConnection();
   EXPECT_EQ(SSL_SNAP_START_NONE, SnapStartEventType());
   EXPECT_FALSE(DidMerge());
 }
 
@@ skipping 32 matching lines @@
 TEST_F(SSLClientSocketSnapStartTest, SnapStartResumeRecovery) {
   StartSnapStartServer("snap-start-recovery", NULL);
   PerformConnection();
   EXPECT_EQ(SSL_SNAP_START_NONE, SnapStartEventType());
   EXPECT_FALSE(DidMerge());
   PerformConnection();
   EXPECT_EQ(SSL_SNAP_START_RESUME_RECOVERY, SnapStartEventType());
   EXPECT_TRUE(DidMerge());
 }
 
+TEST_F(SSLClientSocketSnapStartTest, SnapStartWithNPN) {
+  ssl_config_.next_protos.assign("\003foo\003bar");
+  StartSnapStartServer("snap-start", "npn", NULL);
+  PerformConnection();
+  EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, next_proto_status_);
+  EXPECT_EQ("foo", next_proto_);
+  EXPECT_EQ(SSL_SNAP_START_NONE, SnapStartEventType());
+  EXPECT_FALSE(DidMerge());
+  SSLClientSocketNSS::ClearSessionCache();
+  PerformConnection();
+  EXPECT_EQ(SSL_SNAP_START_FULL, SnapStartEventType());
+  EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, next_proto_status_);
+  EXPECT_EQ("foo", next_proto_);
+  EXPECT_TRUE(DidMerge());
+}
+
+TEST_F(SSLClientSocketSnapStartTest, SnapStartWithNPNMispredict) {
+  // This tests that we recover in the event of a misprediction.
+  ssl_config_.next_protos.assign("\003foo\003baz");
+  StartSnapStartServer("snap-start", "npn-mispredict", NULL);
+  PerformConnection();
+  EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, next_proto_status_);
+  EXPECT_EQ("foo", next_proto_);
+  EXPECT_EQ(SSL_SNAP_START_NONE, SnapStartEventType());
+  EXPECT_FALSE(DidMerge());
+
+  SSLClientSocketNSS::ClearSessionCache();
+  PerformConnection();
+  EXPECT_EQ(SSL_SNAP_START_RECOVERY, SnapStartEventType());
+  EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, next_proto_status_);
+  EXPECT_EQ("baz", next_proto_);
+  EXPECT_TRUE(DidMerge());
+
+  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