NetLogEventParameter to Callback refactoring 2.

Get rid of all uses of NetLogEventParameters in net/disk_cache.

R=eroman@chromium.org
BUG=126243

Review URL: https://chromiumcodereview.appspot.com/10543114

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@141697 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 186 insertions, 236 deletions

diff --git a/net/disk_cache/entry_impl.cc b/net/disk_cache/entry_impl.cc
index 4991375..b79230f 100644
--- a/net/disk_cache/entry_impl.cc
+++ b/net/disk_cache/entry_impl.cc
@@ -61,8 +61,7 @@ void SyncCallback::OnFileIOComplete(int bytes_copied) {
     if (entry_->net_log().IsLoggingAllEvents()) {
       entry_->net_log().EndEvent(
           end_event_type_,
-          make_scoped_refptr(
-              new disk_cache::ReadWriteCompleteParameters(bytes_copied)));
+          disk_cache::CreateNetLogReadWriteCompleteCallback(bytes_copied));
     }
     entry_->ReportIOTime(disk_cache::EntryImpl::kAsyncIO, start_);
     callback_.Run(bytes_copied);
@@ -314,8 +313,7 @@ int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
-        make_scoped_refptr(
-            new ReadWriteDataParameters(index, offset, buf_len, false)));
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len, callback);
@@ -323,7 +321,7 @@ int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
   if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
-        make_scoped_refptr(new ReadWriteCompleteParameters(result)));
+        CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
@@ -334,8 +332,7 @@ int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        make_scoped_refptr(
-            new ReadWriteDataParameters(index, offset, buf_len, truncate)));
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
   int result = InternalWriteData(index, offset, buf, buf_len, callback,
@@ -344,7 +341,7 @@ int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
   if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        make_scoped_refptr(new ReadWriteCompleteParameters(result)));
+        CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
@@ -458,7 +455,7 @@ bool EntryImpl::IsSameEntry(const std::string& key, uint32 hash) {
 }
 
 void EntryImpl::InternalDoom() {
-  net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM, NULL);
+  net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   DCHECK(node_.HasData());
   if (!node_.Data()->dirty) {
     node_.Data()->dirty = backend_->GetCurrentEntryId();
@@ -724,7 +721,7 @@ void EntryImpl::BeginLogging(net::NetLog* net_log, bool created) {
       net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY);
   net_log_.BeginEvent(
       net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL,
-      make_scoped_refptr(new EntryCreationParameters(GetKey(), created)));
+      CreateNetLogEntryCreationCallback(this, created));
 }
 
 const net::BoundNetLog& EntryImpl::net_log() const {
@@ -934,7 +931,7 @@ EntryImpl::~EntryImpl() {
 #if defined(NET_BUILD_STRESS_CACHE)
     SanityCheck();
 #endif
-    net_log_.AddEvent(net::NetLog::TYPE_ENTRY_CLOSE, NULL);
+    net_log_.AddEvent(net::NetLog::TYPE_ENTRY_CLOSE);
     bool ret = true;
     for (int index = 0; index < kNumStreams; index++) {
       if (user_buffers_[index].get()) {
@@ -960,7 +957,7 @@ EntryImpl::~EntryImpl() {
   }
 
   Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this));
-  net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL, NULL);
+  net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL);
   backend_->OnEntryDestroyEnd();
 }
 
diff --git a/net/disk_cache/mem_entry_impl.cc b/net/disk_cache/mem_entry_impl.cc
index 776759b..0d3b00a 100644
--- a/net/disk_cache/mem_entry_impl.cc
+++ b/net/disk_cache/mem_entry_impl.cc
@@ -4,8 +4,10 @@
 
 #include "net/disk_cache/mem_entry_impl.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
+#include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/mem_backend_impl.h"
@@ -41,6 +43,17 @@ std::string GenerateChildName(const std::string& base_name, int child_id) {
   return base::StringPrintf("Range_%s:%i", base_name.c_str(), child_id);
 }
 
+// Returns NetLog parameters for the creation of a child MemEntryImpl.  Separate
+// function needed because child entries don't suppport GetKey().
+Value* NetLogChildEntryCreationCallback(const disk_cache::MemEntryImpl* parent,
+                                        int child_id,
+                                        net::NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("key", GenerateChildName(parent->GetKey(), child_id));
+  dict->SetBoolean("created", true);
+  return dict;
+}
+
 }  // namespace
 
 namespace disk_cache {
@@ -61,22 +74,25 @@ MemEntryImpl::MemEntryImpl(MemBackendImpl* backend) {
 // ------------------------------------------------------------------------
 
 bool MemEntryImpl::CreateEntry(const std::string& key, net::NetLog* net_log) {
-  net_log_ = net::BoundNetLog::Make(net_log,
-                                    net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
-  net_log_.BeginEvent(
-      net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
-      make_scoped_refptr(new EntryCreationParameters(key, true)));
   key_ = key;
   Time current = Time::Now();
   last_modified_ = current;
   last_used_ = current;
+
+  net_log_ = net::BoundNetLog::Make(net_log,
+                                    net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
+  // Must be called after |key_| is set, so GetKey() works.
+  net_log_.BeginEvent(
+      net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
+      CreateNetLogEntryCreationCallback(this, true));
+
   Open();
   backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
   return true;
 }
 
 void MemEntryImpl::InternalDoom() {
-  net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM, NULL);
+  net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   doomed_ = true;
   if (!ref_count_) {
     if (type() == kParentEntry) {
@@ -171,8 +187,7 @@ int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
-        make_scoped_refptr(
-            new ReadWriteDataParameters(index, offset, buf_len, false)));
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len);
@@ -180,7 +195,7 @@ int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
-        make_scoped_refptr(new ReadWriteCompleteParameters(result)));
+        CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
@@ -190,8 +205,7 @@ int MemEntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        make_scoped_refptr(
-            new ReadWriteDataParameters(index, offset, buf_len, truncate)));
+        CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
   int result = InternalWriteData(index, offset, buf, buf_len, truncate);
@@ -199,7 +213,7 @@ int MemEntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        make_scoped_refptr(new ReadWriteCompleteParameters(result)));
+        CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
@@ -209,25 +223,24 @@ int MemEntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_READ,
-        make_scoped_refptr(
-            new SparseOperationParameters(offset, buf_len)));
+        CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalReadSparseData(offset, buf, buf_len);
   if (net_log_.IsLoggingAllEvents())
-    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ, NULL);
+    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ);
   return result;
 }
 
 int MemEntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
                                   const CompletionCallback& callback) {
   if (net_log_.IsLoggingAllEvents()) {
-    net_log_.BeginEvent(net::NetLog::TYPE_SPARSE_WRITE,
-        make_scoped_refptr(
-            new SparseOperationParameters(offset, buf_len)));
+    net_log_.BeginEvent(
+        net::NetLog::TYPE_SPARSE_WRITE,
+        CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalWriteSparseData(offset, buf, buf_len);
   if (net_log_.IsLoggingAllEvents())
-    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE, NULL);
+    net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE);
   return result;
 }
 
@@ -236,15 +249,13 @@ int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
-        make_scoped_refptr(
-            new SparseOperationParameters(offset, len)));
+        CreateNetLogSparseOperationCallback(offset, len));
   }
   int result = GetAvailableRange(offset, len, start);
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
-        make_scoped_refptr(
-            new GetAvailableRangeResultParameters(*start, result)));
+        CreateNetLogGetAvailableRangeResultCallback(*start, result));
   }
   return result;
 }
@@ -264,7 +275,7 @@ MemEntryImpl::~MemEntryImpl() {
   for (int i = 0; i < NUM_STREAMS; i++)
     backend_->ModifyStorageSize(data_size_[i], 0);
   backend_->ModifyStorageSize(static_cast<int32>(key_.size()), 0);
-  net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL, NULL);
+  net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL);
 }
 
 int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
@@ -364,9 +375,8 @@ int MemEntryImpl::InternalReadSparseData(int64 offset, IOBuffer* buf,
     if (net_log_.IsLoggingAllEvents()) {
       net_log_.BeginEvent(
           net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
-          make_scoped_refptr(new SparseReadWriteParameters(
-              child->net_log().source(),
-              io_buf->BytesRemaining())));
+          CreateNetLogSparseReadWriteCallback(child->net_log().source(),
+                                              io_buf->BytesRemaining()));
     }
     int ret = child->ReadData(kSparseData, child_offset, io_buf,
                               io_buf->BytesRemaining(), CompletionCallback());
@@ -422,9 +432,8 @@ int MemEntryImpl::InternalWriteSparseData(int64 offset, IOBuffer* buf,
     if (net_log_.IsLoggingAllEvents()) {
       net_log_.BeginEvent(
           net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
-          make_scoped_refptr(new SparseReadWriteParameters(
-              child->net_log().source(),
-              write_len)));
+          CreateNetLogSparseReadWriteCallback(child->net_log().source(),
+                                              write_len));
     }
 
     // Always writes to the child entry. This operation may overwrite data
@@ -555,9 +564,7 @@ bool MemEntryImpl::InitChildEntry(MemEntryImpl* parent, int child_id,
                                     net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
   net_log_.BeginEvent(
       net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
-      make_scoped_refptr(new EntryCreationParameters(
-          GenerateChildName(parent->key(), child_id_),
-          true)));
+      base::Bind(&NetLogChildEntryCreationCallback, parent, child_id_));
 
   parent_ = parent;
   child_id_ = child_id;
diff --git a/net/disk_cache/net_log_parameters.cc b/net/disk_cache/net_log_parameters.cc
index 3a309f9..dcf18d6 100644
--- a/net/disk_cache/net_log_parameters.cc
+++ b/net/disk_cache/net_log_parameters.cc
@@ -4,122 +4,125 @@
 
 #include "net/disk_cache/net_log_parameters.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"
 
-namespace disk_cache {
+namespace {
 
-EntryCreationParameters::EntryCreationParameters(
-    const std::string& key,
-    bool created)
-    : key_(key),
-      created_(created) {
+Value* NetLogEntryCreationCallback(const disk_cache::Entry* entry,
+                                   bool created,
+                                   net::NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("key", entry->GetKey());
+  dict->SetBoolean("created", created);
+  return dict;
 }
 
-Value* EntryCreationParameters::ToValue() const {
+Value* NetLogReadWriteDataCallback(int index,
+                                   int offset,
+                                   int buf_len,
+                                   bool truncate,
+                                   net::NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
-  dict->SetString("key", key_);
-  dict->SetBoolean("created", created_);
+  dict->SetInteger("index", index);
+  dict->SetInteger("offset", offset);
+  dict->SetInteger("buf_len", buf_len);
+  if (truncate)
+    dict->SetBoolean("truncate", truncate);
   return dict;
 }
 
-EntryCreationParameters::~EntryCreationParameters() {}
-
-ReadWriteDataParameters::ReadWriteDataParameters(
-    int index,
-    int offset,
-    int buf_len,
-    bool truncate)
-    : index_(index),
-      offset_(offset),
-      buf_len_(buf_len),
-      truncate_(truncate) {
+Value* NetLogReadWriteCompleteCallback(int bytes_copied,
+                                       net::NetLog::LogLevel /* log_level */) {
+  DCHECK_NE(bytes_copied, net::ERR_IO_PENDING);
+  DictionaryValue* dict = new DictionaryValue();
+  if (bytes_copied < 0) {
+    dict->SetInteger("net_error", bytes_copied);
+  } else {
+    dict->SetInteger("bytes_copied", bytes_copied);
+  }
+  return dict;
 }
 
-Value* ReadWriteDataParameters::ToValue() const {
+Value* NetLogSparseOperationCallback(int64 offset,
+                                     int buff_len,
+                                     net::NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
-  dict->SetInteger("index", index_);
-  dict->SetInteger("offset", offset_);
-  dict->SetInteger("buf_len", buf_len_);
-  if (truncate_)
-    dict->SetBoolean("truncate", truncate_);
+  // Values can only be created with at most 32-bit integers.  Using a string
+  // instead circumvents that restriction.
+  dict->SetString("offset", base::Int64ToString(offset));
+  dict->SetInteger("buff_len", buff_len);
   return dict;
 }
 
-ReadWriteDataParameters::~ReadWriteDataParameters() {}
-
-// NetLog parameters logged when non-sparse reads and writes complete.
-ReadWriteCompleteParameters::ReadWriteCompleteParameters(int bytes_copied)
-    : bytes_copied_(bytes_copied) {
+Value* NetLogSparseReadWriteCallback(const net::NetLog::Source& source,
+                                     int child_len,
+                                     net::NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  source.AddToEventParameters(dict);
+  dict->SetInteger("child_len", child_len);
+  return dict;
 }
 
-Value* ReadWriteCompleteParameters::ToValue() const {
-  DCHECK_NE(bytes_copied_, net::ERR_IO_PENDING);
+Value* NetLogGetAvailableRangeResultCallback(
+    int64 start,
+    int result,
+    net::NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
-  if (bytes_copied_ < 0) {
-    dict->SetInteger("net_error", bytes_copied_);
+  if (result > 0) {
+    dict->SetInteger("length", result);
+    dict->SetString("start",  base::Int64ToString(start));
   } else {
-    dict->SetInteger("bytes_copied", bytes_copied_);
+    dict->SetInteger("net_error", result);
   }
   return dict;
 }
 
-ReadWriteCompleteParameters::~ReadWriteCompleteParameters() {}
+}  // namespace
 
-SparseOperationParameters::SparseOperationParameters(
-    int64 offset,
-    int buff_len)
-    : offset_(offset),
-      buff_len_(buff_len) {
-}
+namespace disk_cache {
 
-Value* SparseOperationParameters::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  // Values can only be created with at most 32-bit integers.  Using a string
-  // instead circumvents that restriction.
-  dict->SetString("offset", base::Int64ToString(offset_));
-  dict->SetInteger("buff_len", buff_len_);
-  return dict;
+net::NetLog::ParametersCallback CreateNetLogEntryCreationCallback(
+    const Entry* entry,
+    bool created) {
+  DCHECK(entry);
+  return base::Bind(&NetLogEntryCreationCallback, entry, created);
 }
 
-SparseOperationParameters::~SparseOperationParameters() {}
-
-SparseReadWriteParameters::SparseReadWriteParameters(
-    const net::NetLog::Source& source,
-    int child_len)
-    : source_(source),
-      child_len_(child_len) {
+net::NetLog::ParametersCallback CreateNetLogReadWriteDataCallback(
+    int index,
+    int offset,
+    int buf_len,
+    bool truncate) {
+  return base::Bind(&NetLogReadWriteDataCallback,
+                    index, offset, buf_len, truncate);
 }
 
-Value* SparseReadWriteParameters::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->Set("source_dependency", source_.ToValue());
-  dict->SetInteger("child_len", child_len_);
-  return dict;
+net::NetLog::ParametersCallback CreateNetLogReadWriteCompleteCallback(
+    int bytes_copied) {
+  return base::Bind(&NetLogReadWriteCompleteCallback, bytes_copied);
 }
 
-SparseReadWriteParameters::~SparseReadWriteParameters() {}
-
-GetAvailableRangeResultParameters::GetAvailableRangeResultParameters(
-    int64 start,
-    int result)
-    : start_(start),
-      result_(result) {
+net::NetLog::ParametersCallback CreateNetLogSparseOperationCallback(
+    int64 offset,
+    int buff_len) {
+  return base::Bind(&NetLogSparseOperationCallback, offset, buff_len);
 }
 
-Value* GetAvailableRangeResultParameters::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  if (result_ > 0) {
-    dict->SetInteger("length", result_);
-    dict->SetString("start",  base::Int64ToString(start_));
-  } else {
-    dict->SetInteger("net_error", result_);
-  }
-  return dict;
+net::NetLog::ParametersCallback CreateNetLogSparseReadWriteCallback(
+    const net::NetLog::Source& source,
+    int child_len) {
+  return base::Bind(&NetLogSparseReadWriteCallback, source, child_len);
 }
 
-GetAvailableRangeResultParameters::~GetAvailableRangeResultParameters() {}
+net::NetLog::ParametersCallback CreateNetLogGetAvailableRangeResultCallback(
+    int64 start,
+    int result) {
+  return base::Bind(&NetLogGetAvailableRangeResultCallback, start, result);
+}
 
 }  // namespace disk_cache
diff --git a/net/disk_cache/net_log_parameters.h b/net/disk_cache/net_log_parameters.h
index 4e6b8fe..4e34a0e 100644
--- a/net/disk_cache/net_log_parameters.h
+++ b/net/disk_cache/net_log_parameters.h
@@ -10,107 +10,53 @@
 
 #include "net/base/net_log.h"
 
-// This file contains a set of NetLog::EventParameters shared by EntryImpls and
-// MemEntryImpls.
+// This file contains a set of functions to create NetLog::ParametersCallbacks
+// shared by EntryImpls and MemEntryImpls.
 namespace disk_cache {
 
-// NetLog parameters for the creation of an Entry.  Contains the Entry's name
-// and whether it was created or opened.
-class EntryCreationParameters : public net::NetLog::EventParameters {
- public:
-  EntryCreationParameters(const std::string& key, bool created);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~EntryCreationParameters();
-
- private:
-  const std::string key_;
-  const bool created_;
-
-  DISALLOW_COPY_AND_ASSIGN(EntryCreationParameters);
-};
-
-// NetLog parameters for non-sparse reading and writing to an Entry.
-class ReadWriteDataParameters : public net::NetLog::EventParameters {
- public:
-  // For reads, |truncate| must be false.
-  ReadWriteDataParameters(int index, int offset, int buf_len, bool truncate);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~ReadWriteDataParameters();
-
- private:
-  const int index_;
-  const int offset_;
-  const int buf_len_;
-  const bool truncate_;
-
-  DISALLOW_COPY_AND_ASSIGN(ReadWriteDataParameters);
-};
-
-// NetLog parameters for when a non-sparse read or write completes.
-class ReadWriteCompleteParameters : public net::NetLog::EventParameters {
- public:
-  // |bytes_copied| is either the number of bytes copied or a network error
-  // code.  |bytes_copied| must not be ERR_IO_PENDING, as it's not a valid
-  // result for an operation.
-  explicit ReadWriteCompleteParameters(int bytes_copied);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~ReadWriteCompleteParameters();
-
- private:
-  const int bytes_copied_;
-
-  DISALLOW_COPY_AND_ASSIGN(ReadWriteCompleteParameters);
-};
-
-// NetLog parameters for when a sparse operation is started.
-class SparseOperationParameters : public net::NetLog::EventParameters {
- public:
-  SparseOperationParameters(int64 offset, int buff_len);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~SparseOperationParameters();
-
- private:
-  const int64 offset_;
-  const int buff_len_;
-};
-
-// NetLog parameters for when a read or write for a sparse entry's child is
-// started.
-class SparseReadWriteParameters : public net::NetLog::EventParameters {
- public:
-  SparseReadWriteParameters(const net::NetLog::Source& source, int child_len);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~SparseReadWriteParameters();
-
- private:
-  const net::NetLog::Source source_;
-  const int child_len_;
-};
-
-// NetLog parameters for when a call to GetAvailableRange returns.
-class GetAvailableRangeResultParameters : public net::NetLog::EventParameters {
- public:
-  // |start| is ignored when |result| < 0.
-  GetAvailableRangeResultParameters(int64 start, int result);
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~GetAvailableRangeResultParameters();
-
- private:
-  const int64 start_;
-  const int result_;
-};
+class Entry;
+
+// Creates a NetLog callback that returns parameters for the creation of an
+// Entry.  Contains the Entry's key and whether it was created or opened.
+// |entry| can't be NULL, must support GetKey(), and must outlive the returned
+// callback.
+net::NetLog::ParametersCallback CreateNetLogEntryCreationCallback(
+    const Entry* entry,
+    bool created);
+
+// Creates a NetLog callback that returns parameters for start of a non-sparse
+// read or write of an Entry.  For reads, |truncate| must be false.
+net::NetLog::ParametersCallback CreateNetLogReadWriteDataCallback(
+    int index,
+    int offset,
+    int buf_len,
+    bool truncate);
+
+// Creates a NetLog callback that returns parameters for when a non-sparse
+// read or write completes.  For reads, |truncate| must be false.
+// |bytes_copied| is either the number of bytes copied or a network error
+// code.  |bytes_copied| must not be ERR_IO_PENDING, as it's not a valid
+// result for an operation.
+net::NetLog::ParametersCallback CreateNetLogReadWriteCompleteCallback(
+    int bytes_copied);
+
+// Creates a NetLog callback that returns parameters for when a sparse
+// operation is started.
+net::NetLog::ParametersCallback CreateNetLogSparseOperationCallback(
+    int64 offset,
+    int buff_len);
+
+// Creates a NetLog callback that returns parameters for when a read or write
+// for a sparse entry's child is started.
+net::NetLog::ParametersCallback CreateNetLogSparseReadWriteCallback(
+    const net::NetLog::Source& source,
+    int child_len);
+
+// Creates a NetLog callback that returns parameters for when a call to
+// GetAvailableRange returns.
+net::NetLog::ParametersCallback CreateNetLogGetAvailableRangeResultCallback(
+    int64 start,
+    int result);
 
 }  // namespace disk_cache
 
diff --git a/net/disk_cache/sparse_control.cc b/net/disk_cache/sparse_control.cc
index 4ce0f48..d19b10e 100644
--- a/net/disk_cache/sparse_control.cc
+++ b/net/disk_cache/sparse_control.cc
@@ -265,7 +265,7 @@ int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
   if (entry_->net_log().IsLoggingAllEvents()) {
     entry_->net_log().BeginEvent(
         GetSparseEventType(operation_),
-        make_scoped_refptr(new SparseOperationParameters(offset_, buf_len_)));
+        CreateNetLogSparseOperationCallback(offset_, buf_len_));
   }
   DoChildrenIO();
 
@@ -337,7 +337,7 @@ void SparseControl::DeleteChildren(EntryImpl* entry) {
   if (!buffer && !address.is_initialized())
     return;
 
-  entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN, NULL);
+  entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN);
 
   DCHECK(entry && entry->backend_);
   ChildrenDeleter* deleter = new ChildrenDeleter(entry->backend_,
@@ -674,13 +674,12 @@ void SparseControl::DoChildrenIO() {
       entry_->net_log().IsLoggingAllEvents()) {
     entry_->net_log().EndEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
-        make_scoped_refptr(
-            new GetAvailableRangeResultParameters(offset_, result_)));
+        CreateNetLogGetAvailableRangeResultCallback(offset_, result_));
   }
   if (finished_) {
     if (kGetRangeOperation != operation_ &&
         entry_->net_log().IsLoggingAllEvents()) {
-      entry_->net_log().EndEvent(GetSparseEventType(operation_), NULL);
+      entry_->net_log().EndEvent(GetSparseEventType(operation_));
     }
     if (pending_)
       DoUserCallback();  // Don't touch this object after this point.
@@ -712,9 +711,8 @@ bool SparseControl::DoChildIO() {
       if (entry_->net_log().IsLoggingAllEvents()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
-            make_scoped_refptr(new SparseReadWriteParameters(
-                child_->net_log().source(),
-                child_len_)));
+            CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
+                                                child_len_));
       }
       rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_,
                                 child_len_, callback);
@@ -723,9 +721,8 @@ bool SparseControl::DoChildIO() {
       if (entry_->net_log().IsLoggingAllEvents()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
-            make_scoped_refptr(new SparseReadWriteParameters(
-                child_->net_log().source(),
-                child_len_)));
+            CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
+                                                child_len_));
       }
       rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_,
                                  child_len_, callback, false);
@@ -830,8 +827,8 @@ void SparseControl::OnChildIOCompleted(int result) {
     // the bytes to read or write, but the user cancelled the operation.
     abort_ = false;
     if (entry_->net_log().IsLoggingAllEvents()) {
-      entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED, NULL);
-      entry_->net_log().EndEvent(GetSparseEventType(operation_), NULL);
+      entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED);
+      entry_->net_log().EndEvent(GetSparseEventType(operation_));
     }
     // We have an indirect reference to this object for every callback so if
     // there is only one callback, we may delete this object before reaching