First pass at adding http/backend cache to NetLog

net/disk_cache/in_flight_backend_io.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/disk_cache/in_flight_backend_io.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/histogram_macros.h"
 
 namespace disk_cache {
 
 BackendIO::BackendIO(InFlightIO* controller, BackendImpl* backend,
                      net::CompletionCallback* callback)
     : BackgroundIO(controller), backend_(backend), callback_(callback),
       operation_(OP_NONE),
@@ skipping 81 matching lines @@
 }
 
 void BackendIO::EndEnumeration(void* iterator) {
   operation_ = OP_END_ENUMERATION;
   iter_ = iterator;
 }
 
 void BackendIO::CloseEntryImpl(EntryImpl* entry) {
   operation_ = OP_CLOSE_ENTRY;
   entry_ = entry;
+  if (entry->net_log().IsLoggingAllEvents())
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_CLOSE, NULL);
 }
 
 void BackendIO::DoomEntryImpl(EntryImpl* entry) {
   operation_ = OP_DOOM_ENTRY;
   entry_ = entry;
+  if (entry->net_log().IsLoggingAllEvents())
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_DOOM, NULL);
 }
 
 void BackendIO::FlushQueue() {
   operation_ = OP_FLUSH_QUEUE;
 }
 
 void BackendIO::RunTask(Task* task) {
   operation_ = OP_RUN_TASK;
   task_ = task;
 }
 
 void BackendIO::ReadData(EntryImpl* entry, int index, int offset,
                          net::IOBuffer* buf, int buf_len) {
   operation_ = OP_READ;
   entry_ = entry;
   index_ = index;
   offset_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
+
+  if (entry->net_log().IsLoggingAllEvents()) {
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_READ_DATA,

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

I'd actually remove all logging from this file.

This results in three logs for the same event: Read started at the http cache
level, read received at the backend and read received at the backend entry...
each with the closing event.

I don't think this is *that* interesting :)

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

All DISK_CACHE_QUEUE events removed.  Wasn't sure if they were worth tracking
for easy latency checking or not.

+                              NULL);
+  }
 }
 
 void BackendIO::WriteData(EntryImpl* entry, int index, int offset,
                           net::IOBuffer* buf, int buf_len, bool truncate) {
   operation_ = OP_WRITE;
   entry_ = entry;
   index_ = index;
   offset_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
   truncate_ = truncate;
+
+  if (entry->net_log().IsLoggingAllEvents()) {
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_WRITE_DATA,
+                              NULL);
+  }
 }
 
 void BackendIO::ReadSparseData(EntryImpl* entry, int64 offset,
                                net::IOBuffer* buf, int buf_len) {
   operation_ = OP_READ_SPARSE;
   entry_ = entry;
   offset64_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
+
+  if (entry->net_log().IsLoggingAllEvents()) {
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_READ_SPARSE,

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

Read/Write sparse should probably be logged directly from the entry.

+                              NULL);
+  }
 }
 
 void BackendIO::WriteSparseData(EntryImpl* entry, int64 offset,
                                 net::IOBuffer* buf, int buf_len) {
   operation_ = OP_WRITE_SPARSE;
   entry_ = entry;
   offset64_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
+
+  if (entry->net_log().IsLoggingAllEvents()) {
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_WRITE_SPARSE,
+                              NULL);
+  }
 }
 
 void BackendIO::GetAvailableRange(EntryImpl* entry, int64 offset, int len,
                                   int64* start) {
   operation_ = OP_GET_RANGE;
   entry_ = entry;
   offset64_ = offset;
   buf_len_ = len;
   start_ = start;
+
+  if (entry->net_log().IsLoggingAllEvents()) {
+    entry->net_log().AddEvent(net::NetLog::TYPE_DISK_CACHE_QUEUE_GET_RANGE,
+                              NULL);
+  }
 }
 
 void BackendIO::CancelSparseIO(EntryImpl* entry) {
   operation_ = OP_CANCEL_IO;
   entry_ = entry;
 }
 
 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
   operation_ = OP_IS_READY;
   entry_ = entry;
@@ skipping 346 matching lines @@
   DCHECK(!pending_ops_.empty());
   scoped_refptr<BackendIO> next_op = pending_ops_.front();
   if (operation != next_op)
     return false;
 
   pending_ops_.pop_front();
   return true;
 }
 
 }  // namespace