Adding DiskBasedCertCache to HttpCache (+UMA).

net/http/disk_based_cert_cache.cc

 // Copyright (c) 2014 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/http/disk_based_cert_cache.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 
 namespace net {
 
 namespace {
 
+// TODO(brandonsalmon): remove when more data no longer needed.
+void RecordHistogram(int rv) {
+  bool already_existed = (rv < 0);
+  UMA_HISTOGRAM_BOOLEAN(
+      "DiskBasedCertCache.WritePreviouslyExisted", already_existed);

[Ryan Sleevi, 2014/06/26 19:56:02]

You will need to update histograms.xml to ad this

[brandonsalmon, 2014/06/26 22:04:42]

What do I need to do to update this? I tried and git started acting weird.

+}
+
 // Used to obtain a unique cache key for a certificate in the form of
 // "cert:<hash>".
-std::string GetCacheKeyToCert(const X509Certificate::OSCertHandle cert_handle) {
+std::string GetCacheKeyToCert(
+       const X509Certificate::OSCertHandle cert_handle) {

[Ryan Sleevi, 2014/06/26 19:56:02]

Seems like this fit before - why the change?

   SHA1HashValue fingerprint =
       X509Certificate::CalculateFingerprint(cert_handle);
 
   return "cert:" +
          base::HexEncode(fingerprint.data, arraysize(fingerprint.data));
 }
 
-}  // namespace
+} // namespace

[Ryan Sleevi, 2014/06/26 19:56:02]

This was correct the way it was before (two spaces before // )

 
 // WriteWorkers represent pending Set jobs in the DiskBasedCertCache. Each
 // certificate requested to be cached is assigned a Writeworker on a one-to-one
 // basis. The same certificate should not have multiple WriteWorkers at the same
 // time; instead, add a user callback to the existing WriteWorker.
 class DiskBasedCertCache::WriteWorker {
  public:
   // |backend| is the backend to store |certificate| in, using
   // |key| as the key for the disk_cache::Entry.
   // |cleanup_callback| is called to clean up this ReadWorker,
@@ skipping 141 matching lines @@
 int DiskBasedCertCache::WriteWorker::DoCreate() {
   state_ = STATE_CREATE_COMPLETE;
 
   return backend_->CreateEntry(key_, &entry_, io_callback_);
 }
 
 int DiskBasedCertCache::WriteWorker::DoCreateComplete(int rv) {
   // An error here usually signifies that the entry already exists.
   // If this occurs, it is necessary to instead open the previously
   // existing entry.
+  RecordHistogram(rv);

[Ryan Sleevi, 2014/06/26 19:56:02]

Sanity check: What would you expect to use this information for? How would it
influence the design?

[brandonsalmon, 2014/06/26 22:04:42]

I added this because it seemed important to gather data on how often a
certificate is overwritten on disk (it was my assumption that this would
correspond to duplicate writes in the currently used method).

   if (rv < 0) {
     state_ = STATE_OPEN;
     return OK;
   }
 
   state_ = STATE_WRITE;
   return OK;
 }
 
 int DiskBasedCertCache::WriteWorker::DoOpen() {
@@ skipping 334 matching lines @@
 
 void DiskBasedCertCache::FinishedWriteOperation(const std::string& key) {
   write_worker_map_.erase(key);
 }
 
 void DiskBasedCertCache::FinishedReadOperation(const std::string& key) {
   read_worker_map_.erase(key);
 }
 
 }  // namespace net