First pass at adding http/backend cache to NetLog

net/disk_cache/sparse_control.cc

Index: net/disk_cache/sparse_control.cc
===================================================================
--- net/disk_cache/sparse_control.cc	(revision 68857)
+++ net/disk_cache/sparse_control.cc	(working copy)
@@ -223,6 +223,7 @@
   finished_ = false;
   abort_ = false;
 
+  entry_->net_log().BeginEvent(net::NetLog::TYPE_SPARSE_CONTROL, NULL);
   DoChildrenIO();
 
   if (!pending_) {
@@ -610,8 +611,11 @@
 void SparseControl::DoChildrenIO() {
   while (DoChildIO()) continue;
 
-  if (pending_ && finished_)
-    DoUserCallback();
+  if (finished_) {
+    entry_->net_log().EndEvent(net::NetLog::TYPE_SPARSE_CONTROL, NULL);
+    if (pending_)
+      DoUserCallback();
+  }
 }
 
 bool SparseControl::DoChildIO() {
@@ -632,14 +636,30 @@
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
+      if (entry_->net_log().IsLoggingAllEvents()) {
+        entry_->net_log().BeginEvent(
+            net::NetLog::TYPE_SPARSE_CONTROL_READ,
+            new net::NetLogSourceParameter("source_dependency",
+                                           child_->net_log().source()));
+      }
       rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_,
                                 child_len_, callback);
       break;
     case kWriteOperation:
+      if (entry_->net_log().IsLoggingAllEvents()) {
+        entry_->net_log().BeginEvent(
+            net::NetLog::TYPE_SPARSE_CONTROL_WRITE,
+            new net::NetLogSourceParameter("source_dependency",
+                                           child_->net_log().source()));
+      }
       rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_,
                                  child_len_, callback, false);
       break;
     case kGetRangeOperation:
+      if (entry_->net_log().IsLoggingAllEvents()) {
+        entry_->net_log().BeginEvent(net::NetLog::TYPE_SPARSE_CONTROL_GET_RANGE,
+                                     NULL);
+      }
       rv = DoGetAvailableRange();
       break;
     default:
@@ -712,6 +732,23 @@
 }
 
 void SparseControl::DoChildIOCompleted(int result) {
+  if (entry_->net_log().IsLoggingAllEvents()) {
+    net::NetLog::EventType event_type;
+    switch (operation_) {
+      case kReadOperation:
+        event_type = net::NetLog::TYPE_SPARSE_CONTROL_READ;
+        break;
+      case kWriteOperation:
+        event_type = net::NetLog::TYPE_SPARSE_CONTROL_WRITE;
+        break;
+      case kGetRangeOperation:
+        event_type = net::NetLog::TYPE_SPARSE_CONTROL_GET_RANGE;
+        break;
+      default:
+        NOTREACHED();
+    }
+    entry_->net_log().EndEventWithErrorCode(event_type, result);
+  }
   if (result < 0) {
     // We fail the whole operation if we encounter an error.
     result_ = result;
@@ -737,6 +774,9 @@
     // We'll return the current result of the operation, which may be less than
     // the bytes to read or write, but the user cancelled the operation.
     abort_ = false;
+    entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED, NULL);
+    entry_->net_log().EndEvent(
+        net::NetLog::TYPE_SPARSE_CONTROL, NULL);
     DoUserCallback();
     return DoAbortCallbacks();
   }