SSLClientSessionCache: Log number of times Lookup is called per Session.

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/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 
 namespace net {
 
@@ skipping 60 matching lines @@
   EXPECT_EQ(nullptr, cache.Lookup("key1").get());
   EXPECT_EQ(nullptr, cache.Lookup("key2").get());
   EXPECT_EQ(nullptr, cache.Lookup("key3").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/DecrementLookupCount appropriately log to
+// UMA.
+TEST(SSLClientSessionCacheTest, LookupCountUMA) {
+  const char kLookupCountHistogram[] = "Net.SSLSessionConcurrentLookupCount";
+  base::HistogramTester histograms;
+
+  SSLClientSessionCache::Config config;
+  SSLClientSessionCache cache(config);
+
+  bssl::UniquePtr<SSL_SESSION> session1(SSL_SESSION_new());
+  bssl::UniquePtr<SSL_SESSION> session2(SSL_SESSION_new());
+  cache.Insert("key1", session1.get());
+  cache.Insert("key2", session2.get());
+  histograms.ExpectTotalCount(kLookupCountHistogram, 0);
+
+  // Test that multiple lookups of the same key are grouped, but that only the
+  // number of concurrent uses is logged, not the total number of uses before
+  // the count returns to 0.
+  EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
+  EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
+  cache.DecrementLookupCount("key1", true);
+  EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
+  cache.DecrementLookupCount("key1", true);
+  cache.DecrementLookupCount("key1", true);
+  histograms.ExpectBucketCount(kLookupCountHistogram, 2, 1);
+
+  // Test that independent keys are logged separately.
+  EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
+  EXPECT_EQ(session2.get(), cache.Lookup("key2").get());
+  cache.DecrementLookupCount("key1", true);
+  cache.DecrementLookupCount("key2", true);
+  histograms.ExpectBucketCount(kLookupCountHistogram, 1, 2);
+
+  histograms.ExpectTotalCount(kLookupCountHistogram, 3);
+
+  // Check that nothing gets logged if false is passed into
+  // DecrementLookupCount.
+  EXPECT_EQ(session1.get(), cache.Lookup("key1").get());
+  cache.DecrementLookupCount("key1", false);
+  histograms.ExpectTotalCount(kLookupCountHistogram, 3);
+
+  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) {
   SSLClientSessionCache::Config config;
   SSLClientSessionCache cache(config);
 
   bssl::UniquePtr<SSL_SESSION> session(SSL_SESSION_new());
   EXPECT_EQ(1u, session->references);
 
   EXPECT_EQ(nullptr, cache.Lookup("key1").get());
@@ skipping 232 matching lines @@
   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