Adding DiskBasedCertCache to HttpCache (+UMA).

net/http/http_cache.cc

 // Copyright (c) 2012 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/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 15 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data_stream.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/http/disk_based_cert_cache.h"
 #include "net/http/disk_cache_based_quic_server_info.h"
 #include "net/http/http_cache_transaction.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/quic/crypto/quic_server_info.h"
 
 namespace {
 
+bool UseCertCache() {

[wtc, 2014/07/08 00:14:03]

IMPORTANT: Should we also use a command-line option to enable this code?

[Ryan Sleevi, 2014/07/08 00:34:18]

wtc: What's the use case here? I discouraged Brandon from doing so, precisely
because I cannot think of a reason.

Please also note that field trials already have a means to force the group.

[wtc, 2014/07/08 01:54:41]

A command-line option is a common way to allow us to check in code that is
incomplete and should be disabled by default. We can certainly accomplish the
same effect by not starting the field trial until this code is complete.

+  return base::FieldTrialList::FindFullName("CertCacheTrial") ==
+         "ExperimentGroup";

[wtc, 2014/07/08 18:24:21]

IMPORTANT: Users in the field trial will have new cert-cache entries (with the
key "cert:<sha1-fingerprint>") in their disk caches. Before we start the field
trial, please resolve these two issues:

1. Find out if we need to provide UI (under chrome://settings > Privacy > Clear
browsing data) to have the cert-cache entries removed. Perhaps the "Cached
images and files" checkbox will take care of this automatically?

2. We may need to version the serialization format so that we can change the
format in the future. Right now the serialization format is simply the
DER-encoded certificate bytes, with no "metadata" such as the format version.

[Ryan Sleevi, 2014/07/08 18:29:08]

Yes. We're using the DiskCache.
The metadata is the URI scheme, "cert:". We can change the URI scheme if we need
to change versions.

[wtc, 2014/07/08 19:00:11]

Suppose we change the URI scheme to "cert2:". Won't that make the entries with
the old URI scheme "cert:" unreachable? It seems better to version the
serialization format because the existing entries can be overwritten with data
in the new format.

+}
+
 // Adaptor to delete a file on a worker thread.
 void DeletePath(base::FilePath path) {
   base::DeleteFile(path, false);
 }
 
 }  // namespace
 
 namespace net {
 
 HttpCache::DefaultBackend::DefaultBackend(CacheType type,
@@ skipping 281 matching lines @@
     entry->pending_queue.clear();
     entry->readers.clear();
     entry->writer = NULL;
     DeactivateEntry(entry);
   }
 
   STLDeleteElements(&doomed_entries_);
 
   // Before deleting pending_ops_, we have to make sure that the disk cache is
   // done with said operations, or it will attempt to use deleted data.
   disk_cache_.reset();

[wtc, 2014/07/08 00:14:03]

Should we call cert_cache_.reset() before calling disk_cache_.reset()?

cert_cache_ points to disk_cache_. So if disk_cache_ is gone, cert_cache_ can't
be used.

[Ryan Sleevi, 2014/07/08 00:34:18]

Yes

 
   PendingOpsMap::iterator pending_it = pending_ops_.begin();
   for (; pending_it != pending_ops_.end(); ++pending_it) {
     // We are not notifying the transactions about the cache going away, even
     // though they are waiting for a callback that will never fire.
     PendingOp* pending_op = pending_it->second;
     delete pending_op->writer;
     bool delete_pending_op = true;
     if (building_backend_) {
       // If we don't have a backend, when its construction finishes it will
@@ skipping 807 matching lines @@
   DCHECK_EQ(WI_CREATE_BACKEND, op);
 
   // We don't need the callback anymore.
   pending_op->callback.Reset();
 
   if (backend_factory_.get()) {
     // We may end up calling OnBackendCreated multiple times if we have pending
     // work items. The first call saves the backend and releases the factory,
     // and the last call clears building_backend_.
     backend_factory_.reset();  // Reclaim memory.
-    if (result == OK)
+    if (result == OK) {
       disk_cache_ = pending_op->backend.Pass();
+      if (UseCertCache())
+        cert_cache_.reset(new DiskBasedCertCache(disk_cache_.get()));
+    }
   }
 
   if (!pending_op->pending_queue.empty()) {
     WorkItem* pending_item = pending_op->pending_queue.front();
     pending_op->pending_queue.pop_front();
     DCHECK_EQ(WI_CREATE_BACKEND, pending_item->operation());
 
     // We want to process a single callback at a time, because the cache may
     // go away from the callback.
     pending_op->writer = pending_item;
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&HttpCache::OnBackendCreated, GetWeakPtr(),
                    result, pending_op));
   } else {
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net