First pass at adding http/backend cache to NetLog

net/http/http_cache.cc

 // Copyright (c) 2010 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"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/callback.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/disk_cache_based_ssl_host_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"
@@ skipping 14 matching lines @@
       thread_(thread) {
 }
 
 HttpCache::DefaultBackend::~DefaultBackend() {}
 
 // static
 HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) {
   return new DefaultBackend(MEMORY_CACHE, FilePath(), max_bytes, NULL);
 }
 
-int HttpCache::DefaultBackend::CreateBackend(disk_cache::Backend** backend,
+int HttpCache::DefaultBackend::CreateBackend(NetLog* net_log,
+                                             disk_cache::Backend** backend,
                                              CompletionCallback* callback) {
   DCHECK_GE(max_bytes_, 0);
   return disk_cache::CreateCacheBackend(type_, path_, max_bytes_, true,
-                                        thread_, backend, callback);
+                                        thread_, net_log, backend, callback);
 }
 
 //-----------------------------------------------------------------------------
 
-HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e)
-    : disk_entry(e),
+HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* entry)
+    : disk_entry(entry),
       writer(NULL),
       will_process_pending_queue(false),
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
   if (disk_entry) {
     disk_entry->Close();
     disk_entry = NULL;
   }
@@ skipping 201 matching lines @@
 
 HttpCache::HttpCache(HostResolver* host_resolver,
                      DnsRRResolver* dnsrr_resolver,
                      DnsCertProvenanceChecker* dns_cert_checker_,
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      HttpAuthHandlerFactory* http_auth_handler_factory,
                      HttpNetworkDelegate* network_delegate,
                      NetLog* net_log,
                      BackendFactory* backend_factory)
-    : backend_factory_(backend_factory),
+    : net_log_(net_log),
+      backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       ssl_host_info_factory_(new SSLHostInfoFactoryAdaptor(
             ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       network_layer_(HttpNetworkLayer::CreateFactory(host_resolver,
           dnsrr_resolver, dns_cert_checker_,
           ssl_host_info_factory_.get(),
           proxy_service, ssl_config_service,
           http_auth_handler_factory, network_delegate, net_log)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 HttpCache::HttpCache(HttpNetworkSession* session,
                      BackendFactory* backend_factory)
-    : backend_factory_(backend_factory),
+    : net_log_(session->net_log()),
+      backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       network_layer_(HttpNetworkLayer::CreateFactory(session)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
-                     BackendFactory* backend_factory)
-    : backend_factory_(backend_factory),
+                     BackendFactory* backend_factory,
+                     NetLog* net_log)
+    : net_log_(net_log),
+      backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       network_layer_(network_layer),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 HttpCache::~HttpCache() {
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
   // won't run (due to our destruction), we can simply ignore the corresponding
@@ skipping 131 matching lines @@
       pending_op->pending_queue.push_back(item.release());
     return ERR_IO_PENDING;
   }
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item.release();
   BackendCallback* my_callback = new BackendCallback(this, pending_op);
   pending_op->callback = my_callback;
 
-  int rv = backend_factory_->CreateBackend(&pending_op->backend, my_callback);
+  int rv = backend_factory_->CreateBackend(net_log_, &pending_op->backend,
+                                           my_callback);
   if (rv != ERR_IO_PENDING) {
     pending_op->writer->ClearCallback();
     my_callback->Run(rv);
   }
 
   return rv;
 }
 
 int HttpCache::GetBackendForTransaction(Transaction* trans) {
   if (disk_cache_.get())
@@ skipping 248 matching lines @@
 
 void HttpCache::DestroyEntry(ActiveEntry* entry) {
   if (entry->doomed) {
     FinalizeDoomedEntry(entry);
   } else {
     DeactivateEntry(entry);
   }
 }
 
 int HttpCache::AddTransactionToEntry(ActiveEntry* entry, Transaction* trans) {
+  int result = AddTransactionToEntryInternal(entry, trans);
+  if (result == ERR_IO_PENDING) {
+    trans->net_log().BeginEvent(
+        NetLog::TYPE_ACTIVE_ENTRY_QUEUE,

[rvargas (doing something else), 2010/12/13 23:34:39]

This seems to do the same as TYPE_HTTP_CACHE_ADD_TO_ENTRY. If we want the size
of the queue, maybe we can just add it to the log at the transaction level and
remove this one.

[mmenke, 2010/12/14 17:53:43]

Removed.  If we decide we really want queue length, can add it later.

+        new NetLogIntegerParameter("queue_size", entry->pending_queue.size()));
+  }
+  return result;
+}
+
+int HttpCache::AddTransactionToEntryInternal(ActiveEntry* entry,
+                                             Transaction* trans) {
   DCHECK(entry);
   DCHECK(entry->disk_entry);
 
   // We implement a basic reader/writer lock for the disk cache entry.  If
   // there is already a writer, then everyone has to wait for the writer to
   // finish before they can access the cache entry.  There can be multiple
   // readers.
   //
   // NOTE: If the transaction can only write, then the entry should not be in
   // use (since any existing entry should have already been doomed).
@@ skipping 204 matching lines @@
     return;
   }
 
   // Promote next transaction from the pending queue.
   Transaction* next = entry->pending_queue.front();
   if ((next->mode() & Transaction::WRITE) && !entry->readers.empty())
     return;  // Have to wait.
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
-  int rv = AddTransactionToEntry(entry, next);
+  int rv = AddTransactionToEntryInternal(entry, next);
   if (rv != ERR_IO_PENDING) {
+    next->net_log().EndEvent(NetLog::TYPE_ACTIVE_ENTRY_QUEUE, NULL);
     next->io_callback()->Run(rv);
   }
 }
 
 void HttpCache::OnIOComplete(int result, PendingOp* pending_op) {
   WorkItemOperation op = pending_op->writer->operation();
 
   // Completing the creation of the backend is simpler than the other cases.
   if (op == WI_CREATE_BACKEND)
     return OnBackendCreated(result, pending_op);
@@ skipping 115 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, backend))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net