Use BoringSSL scopers in //net.

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 <openssl/ssl.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"
-#include "net/ssl/scoped_openssl_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 // Test basic insertion and lookup operations.
 TEST(SSLClientSessionCacheTest, Basic) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  ScopedSSL_SESSION session1(SSL_SESSION_new());
-  ScopedSSL_SESSION session2(SSL_SESSION_new());
-  ScopedSSL_SESSION session3(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session3(SSL_SESSION_new());
   EXPECT_EQ(1u, session1->references);
   EXPECT_EQ(1u, session2->references);
   EXPECT_EQ(1u, session3->references);
 
   EXPECT_EQ(nullptr, cache.Lookup("key1").get());
   EXPECT_EQ(nullptr, cache.Lookup("key2").get());
   EXPECT_EQ(0u, cache.size());
 
   cache.Insert("key1", session1.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
@@ skipping 27 matching lines @@
   EXPECT_EQ(1u, session2->references);
   EXPECT_EQ(1u, session3->references);
 }
 
 // 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) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
-  ScopedSSL_SESSION session(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
   EXPECT_EQ(1u, session->references);
 
   EXPECT_EQ(nullptr, cache.Lookup("key1").get());
   EXPECT_EQ(nullptr, cache.Lookup("key2").get());
   EXPECT_EQ(0u, cache.size());
 
   cache.Insert("key1", session.get());
   EXPECT_EQ(session.get(), cache.Lookup("key1").get());
   EXPECT_EQ(nullptr, cache.Lookup("key2").get());
   EXPECT_EQ(1u, cache.size());
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(1u, session->references);
 }
 
 // Tests that the session cache's size is correctly bounded.
 TEST(SSLClientSessionCacheTest, MaxEntries) {
   SSLClientSessionCache::Config config;
   config.max_entries = 3;
   SSLClientSessionCache cache(config);
 
-  ScopedSSL_SESSION session1(SSL_SESSION_new());
-  ScopedSSL_SESSION session2(SSL_SESSION_new());
-  ScopedSSL_SESSION session3(SSL_SESSION_new());
-  ScopedSSL_SESSION session4(SSL_SESSION_new());
+  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());
 
   // 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").get());
   EXPECT_EQ(session2.get(), cache.Lookup("key2").get());
   EXPECT_EQ(session3.get(), cache.Lookup("key3").get());
   EXPECT_EQ(3u, cache.size());
 
@@ skipping 23 matching lines @@
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   config.timeout = kTimeout;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = new base::SimpleTestClock;
   cache.SetClockForTesting(base::WrapUnique(clock));
 
   // Add |kNumEntries - 1| entries.
   for (size_t i = 0; i < kNumEntries - 1; i++) {
-    ScopedSSL_SESSION session(SSL_SESSION_new());
+    bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
     cache.Insert(base::SizeTToString(i), session.get());
   }
   EXPECT_EQ(kNumEntries - 1, cache.size());
 
   // Expire all the previous entries and insert one more entry.
   clock->Advance(kTimeout * 2);
-  ScopedSSL_SESSION session(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
   cache.Insert("key", session.get());
 
   // All entries are still in the cache.
   EXPECT_EQ(kNumEntries, cache.size());
 
   // Perform one fewer lookup than needed to trigger the expiration check. This
   // shall not expire any session.
   for (size_t i = 0; i < kExpirationCheckCount - 1; i++)
     cache.Lookup("key");
 
@@ skipping 19 matching lines @@
   const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1000);
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   config.timeout = kTimeout;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = new base::SimpleTestClock;
   cache.SetClockForTesting(base::WrapUnique(clock));
 
   // Insert an entry into the session cache.
-  ScopedSSL_SESSION session(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
   cache.Insert("key", session.get());
   EXPECT_EQ(session.get(), cache.Lookup("key").get());
   EXPECT_EQ(1u, cache.size());
 
   // Expire the session.
   clock->Advance(kTimeout * 2);
 
   // The entry has not been removed yet.
   EXPECT_EQ(1u, cache.size());
 
@@ skipping 20 matching lines @@
   const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(1000);
 
   SSLClientSessionCache::Config config;
   config.expiration_check_count = kExpirationCheckCount;
   config.timeout = kTimeout;
   SSLClientSessionCache cache(config);
   base::SimpleTestClock* clock = new base::SimpleTestClock;
   cache.SetClockForTesting(base::WrapUnique(clock));
 
   // Insert an entry into the session cache.
-  ScopedSSL_SESSION session1(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
   cache.Insert("key1", session1.get());
   EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
   EXPECT_EQ(1u, cache.size());
 
   // Expire the session.
   clock->Advance(kTimeout * 2);
   // Add one more session.
-  ScopedSSL_SESSION session2(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
   cache.Insert("key2", session2.get());
   EXPECT_EQ(2u, cache.size());
 
   // Fire a notification that will flush expired sessions.
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
   base::RunLoop().RunUntilIdle();
 
   // Expired session's cache should be flushed.
   // Lookup returns nullptr, when cache entry not found.
   EXPECT_FALSE(cache.Lookup("key1"));
   EXPECT_TRUE(cache.Lookup("key2"));
   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());
 }
 
 }  // namespace net