Roll src/third_party/boringssl/src dc8c1d962..0f28691d3

net/ssl/ssl_client_session_cache_unittest.cc

 // Copyright 2015 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/ssl/ssl_client_session_cache.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 10 matching lines @@
 
 std::unique_ptr<base::SimpleTestClock> MakeTestClock() {
   std::unique_ptr<base::SimpleTestClock> clock =
       base::MakeUnique<base::SimpleTestClock>();
   // SimpleTestClock starts at the null base::Time which converts to and from
   // time_t confusingly.
   clock->SetNow(base::Time::FromTimeT(1000000000));
   return clock;
 }
 
-bssl::UniquePtr<SSL_SESSION> MakeTestSession(base::Time now,
-                                             base::TimeDelta timeout) {
-  bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
-  SSL_SESSION_set_time(session.get(), now.ToTimeT());
-  SSL_SESSION_set_timeout(session.get(), timeout.InSeconds());
-  return session;
-}
+class SSLClientSessionCacheTest : public testing::Test {
+ public:
+  SSLClientSessionCacheTest() : ssl_ctx_(SSL_CTX_new(TLS_method())) {}
+
+ protected:
+  bssl::UniquePtr<SSL_SESSION> NewSSLSession() {
+    return bssl::UniquePtr<SSL_SESSION>(SSL_SESSION_new(ssl_ctx_.get()));
+  }
+
+  bssl::UniquePtr<SSL_SESSION> MakeTestSession(base::Time now,
+                                               base::TimeDelta timeout) {
+    bssl::UniquePtr<SSL_SESSION> session = NewSSLSession();
+    SSL_SESSION_set_time(session.get(), now.ToTimeT());
+    SSL_SESSION_set_timeout(session.get(), timeout.InSeconds());
+    return session;
+  }
+
+ private:
+  bssl::UniquePtr<SSL_CTX> ssl_ctx_;
+};
 
 }  // namespace
 
 // Test basic insertion and lookup operations.
-TEST(SSLClientSessionCacheTest, Basic) {
+TEST_F(SSLClientSessionCacheTest, Basic) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session3(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session2 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session3 = NewSSLSession();
   EXPECT_EQ(1u, session1->references);
   EXPECT_EQ(1u, session2->references);
   EXPECT_EQ(1u, session3->references);
 
   EXPECT_EQ(nullptr, cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(nullptr, cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(0u, cache.size());
 
   cache.Insert("key1", session1.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1", nullptr).get());
@@ skipping 23 matching lines @@
   EXPECT_EQ(nullptr, cache.Lookup("key3", nullptr).get());
   EXPECT_EQ(0u, cache.size());
 
   EXPECT_EQ(1u, session1->references);
   EXPECT_EQ(1u, session2->references);
   EXPECT_EQ(1u, session3->references);
 }
 
 // Test that pairs of calls to Lookup/ResetLookupCount appropriately log to
 // UMA.
-TEST(SSLClientSessionCacheTest, LookupCountUMA) {
+TEST_F(SSLClientSessionCacheTest, LookupCountUMA) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session2 = NewSSLSession();
   cache.Insert("key1", session1.get());
   cache.Insert("key2", session2.get());
 
   // Test that the count returned increments when multiple lookups of the same
   // key/session occur before the count is reset.
   int count;
   EXPECT_EQ(session1.get(), cache.Lookup("key1", &count).get());
   EXPECT_EQ(1, count);
   EXPECT_EQ(session1.get(), cache.Lookup("key1", &count).get());
   EXPECT_EQ(2, count);
@@ skipping 13 matching lines @@
   EXPECT_EQ(0, count);
 
   // Check that ResetLookupCount doesn't explode if there's a cache miss.
   cache.ResetLookupCount("not present");
 
   EXPECT_EQ(2u, cache.size());
 }
 
 // Test that a session may be inserted at two different keys. This should never
 // be necessary, but the API doesn't prohibit it.
-TEST(SSLClientSessionCacheTest, DoubleInsert) {
+TEST_F(SSLClientSessionCacheTest, DoubleInsert) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session = NewSSLSession();
   EXPECT_EQ(1u, session->references);
 
   EXPECT_EQ(nullptr, cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(nullptr, cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(0u, cache.size());
 
   cache.Insert("key1", session.get());
   EXPECT_EQ(session.get(), cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(nullptr, cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(1u, cache.size());
 
   EXPECT_EQ(2u, session->references);
 
   cache.Insert("key2", session.get());
   EXPECT_EQ(session.get(), cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(session.get(), cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(2u, cache.size());
 
   EXPECT_EQ(3u, session->references);
 
   cache.Flush();
   EXPECT_EQ(nullptr, cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(nullptr, cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(0u, cache.size());
 
   EXPECT_EQ(1u, session->references);
 }
 
 // Tests that the session cache's size is correctly bounded.
-TEST(SSLClientSessionCacheTest, MaxEntries) {
+TEST_F(SSLClientSessionCacheTest, MaxEntries) {
   SSLClientSessionCache::Config config;
   config.max_entries = 3;
   SSLClientSessionCache cache(config);
 
-  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session3(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session4(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session2 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session3 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session4 = NewSSLSession();
 
   // Insert three entries.
   cache.Insert("key1", session1.get());
   cache.Insert("key2", session2.get());
   cache.Insert("key3", session3.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(session2.get(), cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(session3.get(), cache.Lookup("key3", nullptr).get());
   EXPECT_EQ(3u, cache.size());
 
   // On insertion of a fourth, the first is removed.
   cache.Insert("key4", session4.get());
   EXPECT_EQ(nullptr, cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(session4.get(), cache.Lookup("key4", nullptr).get());
   EXPECT_EQ(session3.get(), cache.Lookup("key3", nullptr).get());
   EXPECT_EQ(session2.get(), cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(3u, cache.size());
 
   // Despite being newest, the next to be removed is session4 as it was accessed
   // least. recently.
   cache.Insert("key1", session1.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(session2.get(), cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(session3.get(), cache.Lookup("key3", nullptr).get());
   EXPECT_EQ(nullptr, cache.Lookup("key4", nullptr).get());
   EXPECT_EQ(3u, cache.size());
 }
 
 // Tests that session expiration works properly.
-TEST(SSLClientSessionCacheTest, Expiration) {
+TEST_F(SSLClientSessionCacheTest, Expiration) {
   const size_t kNumEntries = 20;
   const size_t kExpirationCheckCount = 10;
   const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1000);
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = MakeTestClock().release();
   cache.SetClockForTesting(base::WrapUnique(clock));
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(1u, cache.size());
   EXPECT_EQ(session.get(), cache.Lookup("key", nullptr).get());
   for (size_t i = 0; i < kNumEntries - 1; i++) {
     SCOPED_TRACE(i);
     EXPECT_EQ(nullptr, cache.Lookup(base::SizeTToString(i), nullptr));
   }
 }
 
 // Tests that Lookup performs an expiration check before returning a cached
 // session.
-TEST(SSLClientSessionCacheTest, LookupExpirationCheck) {
+TEST_F(SSLClientSessionCacheTest, LookupExpirationCheck) {
   // kExpirationCheckCount is set to a suitably large number so the automated
   // pruning never triggers.
   const size_t kExpirationCheckCount = 1000;
   const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1000);
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = MakeTestClock().release();
   cache.SetClockForTesting(base::WrapUnique(clock));
@@ skipping 27 matching lines @@
   EXPECT_EQ(session.get(), cache.Lookup("key", nullptr).get());
   EXPECT_EQ(1u, cache.size());
 
   // Sessions also are treated as expired if the clock rewinds.
   clock->Advance(base::TimeDelta::FromSeconds(-1));
   EXPECT_EQ(nullptr, cache.Lookup("key", nullptr).get());
   EXPECT_EQ(0u, cache.size());
 }
 
 // Test that SSL cache is flushed on low memory notifications
-TEST(SSLClientSessionCacheTest, TestFlushOnMemoryNotifications) {
+TEST_F(SSLClientSessionCacheTest, TestFlushOnMemoryNotifications) {
   // kExpirationCheckCount is set to a suitably large number so the automated
   // pruning never triggers.
   const size_t kExpirationCheckCount = 1000;
   const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1000);
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = MakeTestClock().release();
   cache.SetClockForTesting(base::WrapUnique(clock));
@@ skipping 25 matching lines @@
   EXPECT_EQ(1u, cache.size());
 
   // Fire notification that will flush everything.
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, cache.size());
 }
 
 // Basic test for dumping memory stats.
-TEST(SSLClientSessionCacheTest, TestDumpMemoryStats) {
+TEST_F(SSLClientSessionCacheTest, TestDumpMemoryStats) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
-  bssl::UniquePtr<SSL_SESSION> session3(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session2 = NewSSLSession();
+  bssl::UniquePtr<SSL_SESSION> session3 = NewSSLSession();
 
   // Insert three entries.
   cache.Insert("key1", session1.get());
   cache.Insert("key2", session2.get());
   cache.Insert("key3", session3.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1", nullptr).get());
   EXPECT_EQ(session2.get(), cache.Lookup("key2", nullptr).get());
   EXPECT_EQ(session3.get(), cache.Lookup("key3", nullptr).get());
   EXPECT_EQ(3u, cache.size());
 
   base::trace_event::MemoryDumpArgs dump_args = {
       base::trace_event::MemoryDumpLevelOfDetail::DETAILED};
   std::unique_ptr<base::trace_event::ProcessMemoryDump> process_memory_dump(
       new base::trace_event::ProcessMemoryDump(nullptr, dump_args));
   cache.DumpMemoryStats(process_memory_dump.get());
 
   const base::trace_event::MemoryAllocatorDump* dump =
       process_memory_dump->GetAllocatorDump("net/ssl_session_cache");
   ASSERT_NE(nullptr, dump);
   std::unique_ptr<base::Value> raw_attrs =
       dump->attributes_for_testing()->ToBaseValue();
   base::DictionaryValue* attrs;
   ASSERT_TRUE(raw_attrs->GetAsDictionary(&attrs));
   ASSERT_TRUE(attrs->HasKey("cert_count"));
   ASSERT_TRUE(attrs->HasKey("serialized_cert_size"));
   ASSERT_TRUE(attrs->HasKey(base::trace_event::MemoryAllocatorDump::kNameSize));
 }
 
 }  // namespace net