[NOT FOR LANDING] Detailed loading traces

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 <utility>
 
+#include "base/trace_event/trace_event.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/field_trial.h"
@@ skipping 363 matching lines @@
 }
 
 disk_cache::Backend* HttpCache::GetCurrentBackend() const {
   return disk_cache_.get();
 }
 
 // static
 bool HttpCache::ParseResponseInfo(const char* data, int len,
                                   HttpResponseInfo* response_info,
                                   bool* response_truncated) {
+  TRACE_EVENT0("toplevel", "HttpCache::ParseResponseInfo");
   base::Pickle pickle(data, len);
   return response_info->InitFromPickle(pickle, response_truncated);
 }
 
 void HttpCache::WriteMetadata(const GURL& url,
                               RequestPriority priority,
                               base::Time expected_response_time,
                               IOBuffer* buf,
                               int buf_len) {
   if (!buf_len)
@@ skipping 307 matching lines @@
       }
     }
   }
   DCHECK(pending_op->pending_queue.empty());
 
   delete pending_op;
 }
 
 int HttpCache::OpenEntry(const std::string& key, ActiveEntry** entry,
                          Transaction* trans) {
+  TRACE_EVENT0("toplevel", "HttpCache::OpenEntry::A");
   ActiveEntry* active_entry = FindActiveEntry(key);
   if (active_entry) {
     *entry = active_entry;
     return OK;
   }
+  TRACE_EVENT0("toplevel", "HttpCache::OpenEntry::B");
 
   WorkItem* item = new WorkItem(WI_OPEN_ENTRY, trans, entry);
   PendingOp* pending_op = GetPendingOp(key);
   if (pending_op->writer) {
     pending_op->pending_queue.push_back(item);
     return ERR_IO_PENDING;
   }
+  TRACE_EVENT0("toplevel", "HttpCache::OpenEntry::C");
 
   DCHECK(pending_op->pending_queue.empty());
 
   pending_op->writer = item;
   pending_op->callback = base::Bind(&HttpCache::OnPendingOpComplete,
                                     GetWeakPtr(), pending_op);
+  TRACE_EVENT0("toplevel", "HttpCache::OpenEntry::D");
 
   int rv = disk_cache_->OpenEntry(key, &(pending_op->disk_entry),
                                   pending_op->callback);
+  TRACE_EVENT0("toplevel", "HttpCache::OpenEntry::E");
+
   if (rv != ERR_IO_PENDING) {
     item->ClearTransaction();
     pending_op->callback.Run(rv);
   }
 
   return rv;
 }
 
 int HttpCache::CreateEntry(const std::string& key, ActiveEntry** entry,
                            Transaction* trans) {
@@ skipping 66 matching lines @@
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return OK;
 }
 
 void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
                               bool cancel) {
+  TRACE_EVENT0("toplevel", "HttpCache::DoneWithEntry");
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
     DCHECK(trans == entry->writer);
 
     // Assume there was a failure.
     bool success = false;
@@ skipping 71 matching lines @@
     // If this is really a pending transaction, and it is not part of
     // active_entries_, we should be creating the backend or the entry.
     return LOAD_STATE_WAITING_FOR_CACHE;
   }
 
   Transaction* writer = i->second->writer;
   return writer ? writer->GetWriterLoadState() : LOAD_STATE_WAITING_FOR_CACHE;
 }
 
 void HttpCache::RemovePendingTransaction(Transaction* trans) {
+  TRACE_EVENT0("toplevel", "HttpCache::RemovePendingTransaction");
+
   ActiveEntriesMap::const_iterator i = active_entries_.find(trans->key());
   bool found = false;
   if (i != active_entries_.end())
     found = RemovePendingTransactionFromEntry(i->second, trans);
 
   if (found)
     return;
 
   if (building_backend_) {
     PendingOpsMap::const_iterator j = pending_ops_.find(std::string());
@@ skipping 224 matching lines @@
     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