DiskBasedCertCache method name change + readability fixes.

net/http/http_cache_transaction.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_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 1808 matching lines @@
 
 void HttpCache::Transaction::ReadCertChain() {
   std::string key =
       GetCacheKeyForCert(response_.ssl_info.cert->os_cert_handle());
   const X509Certificate::OSCertHandles& intermediates =
       response_.ssl_info.cert->GetIntermediateCertificates();
   int dist_from_root = intermediates.size();
 
   scoped_refptr<SharedChainData> shared_chain_data(
       new SharedChainData(intermediates.size() + 1, TimeTicks::Now()));
-  cache_->cert_cache()->Get(key,
-                            base::Bind(&OnCertReadIOComplete,
-                                       dist_from_root,
-                                       true /* is leaf */,
-                                       shared_chain_data));
+  cache_->cert_cache()->GetCertificate(key,
+                                       base::Bind(&OnCertReadIOComplete,
+                                                  dist_from_root,
+                                                  true /* is leaf */,
+                                                  shared_chain_data));
 
   for (X509Certificate::OSCertHandles::const_iterator it =
            intermediates.begin();
        it != intermediates.end();
        ++it) {
     --dist_from_root;
     key = GetCacheKeyForCert(*it);
-    cache_->cert_cache()->Get(key,
-                              base::Bind(&OnCertReadIOComplete,
-                                         dist_from_root,
-                                         false /* is not leaf */,
-                                         shared_chain_data));
+    cache_->cert_cache()->GetCertificate(key,
+                                         base::Bind(&OnCertReadIOComplete,
+                                                    dist_from_root,
+                                                    false /* is not leaf */,
+                                                    shared_chain_data));
   }
   DCHECK_EQ(0, dist_from_root);
 }
 
 void HttpCache::Transaction::WriteCertChain() {
   const X509Certificate::OSCertHandles& intermediates =
       response_.ssl_info.cert->GetIntermediateCertificates();
   int dist_from_root = intermediates.size();
 
   scoped_refptr<SharedChainData> shared_chain_data(
       new SharedChainData(intermediates.size() + 1, TimeTicks::Now()));
-  cache_->cert_cache()->Set(response_.ssl_info.cert->os_cert_handle(),
-                            base::Bind(&OnCertWriteIOComplete,
-                                       dist_from_root,
-                                       true /* is leaf */,
-                                       shared_chain_data));
+  cache_->cert_cache()->SetCertificate(
+      response_.ssl_info.cert->os_cert_handle(),
+      base::Bind(&OnCertWriteIOComplete,
+                 dist_from_root,
+                 true /* is leaf */,
+                 shared_chain_data));
   for (X509Certificate::OSCertHandles::const_iterator it =
            intermediates.begin();
        it != intermediates.end();
        ++it) {
     --dist_from_root;
-    cache_->cert_cache()->Set(*it,
-                              base::Bind(&OnCertWriteIOComplete,
-                                         dist_from_root,
-                                         false /* is not leaf */,
-                                         shared_chain_data));
+    cache_->cert_cache()->SetCertificate(*it,
+                                         base::Bind(&OnCertWriteIOComplete,
+                                                    dist_from_root,
+                                                    false /* is not leaf */,
+                                                    shared_chain_data));
   }
   DCHECK_EQ(0, dist_from_root);
 }
 
 void HttpCache::Transaction::SetRequest(const BoundNetLog& net_log,
                                         const HttpRequestInfo* request) {
   net_log_ = net_log;
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
   switch (cache_->mode()) {
     case NORMAL:
       break;
     case RECORD:
       // When in record mode, we want to NEVER load from the cache.
-      // The reason for this is beacuse we save the Set-Cookie headers
+      // The reason for this is because we save the Set-Cookie headers
       // (intentionally).  If we read from the cache, we replay them
       // prematurely.
       effective_load_flags_ |= LOAD_BYPASS_CACHE;
       break;
     case PLAYBACK:
       // When in playback mode, we want to load exclusively from the cache.
       effective_load_flags_ |= LOAD_ONLY_FROM_CACHE;
       break;
     case DISABLE:
       effective_load_flags_ |= LOAD_DISABLE_CACHE;
@@ skipping 848 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net