Add some trace-points to HttpCache for request profiling (cache entry "open",...

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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 <string>
 
 #include "base/compiler_specific.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
+#include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/disk_cache/disk_cache.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_transaction.h"
 #include "net/http/http_util.h"
@@ skipping 595 matching lines @@
   ActiveEntry* entry = NULL;
 
   if (revoked())
     return ERR_UNEXPECTED;
 
   if (mode_ == WRITE) {
     cache_->DoomEntry(cache_key_);
   } else {
     entry = cache_->FindActiveEntry(cache_key_);
     if (!entry) {
+      LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
       entry = cache_->OpenEntry(cache_key_);
+      LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
       if (!entry) {
         if (mode_ == READ_WRITE) {
           mode_ = WRITE;
         } else if (mode_ == UPDATE) {
           // There is no cache entry to update; proceed without caching.
           mode_ = NONE;
           return BeginNetworkRequest();
         } else {
           if (cache_->mode() == PLAYBACK)
             DLOG(INFO) << "Playback Cache Miss: " << request_->url;
 
           // entry does not exist, and not permitted to create a new entry, so
           // we must fail.
           return HandleResult(ERR_CACHE_MISS);
         }
       }
     }
   }
 
   if (mode_ == WRITE) {
     DCHECK(!entry);
+    LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
     entry = cache_->CreateEntry(cache_key_);
+    LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
     if (!entry) {
       DLOG(WARNING) << "unable to create cache entry";
       mode_ = NONE;
       return BeginNetworkRequest();
     }
   }
 
+
+  LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_WAITING);
   return cache_->AddTransactionToEntry(entry, this);
 }
 
 int HttpCache::Transaction::EntryAvailable(ActiveEntry* entry) {
+  LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_WAITING);
+
   // We now have access to the cache entry.
   //
   //  o if we are the writer for the transaction, then we can start the network
   //    transaction.
   //
   //  o if we are a reader for the transaction, then we can start reading the
   //    cache entry.
   //
   //  o if we can read or write, then we should check if the cache entry needs
   //    to be validated and then issue a network request if needed or just read
@@ skipping 584 matching lines @@
     rv = DoCacheReadCompleted(rv);
   } else if (rv != ERR_IO_PENDING) {
     cache_read_callback_->Release();
   }
   return rv;
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
-  if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_, &truncated_))
-    return ERR_CACHE_READ_FAILURE;
-  return OK;
+  LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
+  bool read_ok =
+      HttpCache::ReadResponseInfo(entry_->disk_entry, &response_, &truncated_);
+  LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
+
+  return read_ok ? OK : ERR_CACHE_READ_FAILURE;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
                                           IOBuffer* data, int data_len) {
   if (!entry_)
     return;
 
   int rv = 0;
   if (!partial_.get() || !data_len) {
     rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
@@ skipping 819 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net