Make NetLog take in callbacks that return Values rather

than refcounted objects.  Avoids the need to create
classes and copy data.  Also no longer get time whenever
an event is logged.

BUG=126243

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

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

40 files changed, 1013 insertions, 942 deletions

diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index fb6ccf8..7c345b4f 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -49,18 +49,11 @@ ChromeNetLog::~ChromeNetLog() {
     RemoveThreadSafeObserver(net_log_logger_.get());
 }
 
-void ChromeNetLog::AddEntry(
-    EventType type,
-    const Source& source,
-    EventPhase phase,
-    const scoped_refptr<EventParameters>& params) {
-  base::TimeTicks time(base::TimeTicks::Now());
-
+void ChromeNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
   base::AutoLock lock(lock_);
 
   // Notify all of the log observers.
-  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_,
-                    OnAddEntry(type, time, source, phase, params));
+  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
 }
 
 uint32 ChromeNetLog::NextID() {
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index e297d33..adbad5e 100644
--- a/chrome/browser/net/chrome_net_log.h
+++ b/chrome/browser/net/chrome_net_log.h
@@ -42,10 +42,7 @@ class ChromeNetLog : public net::NetLog {
 
  private:
   // NetLog implementation:
-  virtual void AddEntry(EventType type,
-                        const Source& source,
-                        EventPhase phase,
-                        const scoped_refptr<EventParameters>& params) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
   // Called whenever an observer is added or removed, or has its log level
   // changed.  Must have acquired |lock_| prior to calling.
diff --git a/chrome/browser/net/chrome_net_log_unittest.cc b/chrome/browser/net/chrome_net_log_unittest.cc
index d04dfb7..4f89f7d 100644
--- a/chrome/browser/net/chrome_net_log_unittest.cc
+++ b/chrome/browser/net/chrome_net_log_unittest.cc
@@ -22,11 +22,7 @@ class CountingObserver : public net::NetLog::ThreadSafeObserver {
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE {
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
     ++count_;
   }
 
@@ -37,7 +33,7 @@ class CountingObserver : public net::NetLog::ThreadSafeObserver {
 };
 
 void AddEvent(ChromeNetLog* net_log) {
-  net_log->AddGlobalEntry(net::NetLog::TYPE_CANCELLED, NULL);
+  net_log->AddGlobalEntry(net::NetLog::TYPE_CANCELLED);
 }
 
 // A thread that waits until an event has been signalled before calling
diff --git a/chrome/browser/net/load_timing_observer.cc b/chrome/browser/net/load_timing_observer.cc
index b6760bc..d230f2b 100644
--- a/chrome/browser/net/load_timing_observer.cc
+++ b/chrome/browser/net/load_timing_observer.cc
@@ -83,22 +83,18 @@ LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
   return NULL;
 }
 
-void LoadTimingObserver::OnAddEntry(net::NetLog::EventType type,
-                                    const base::TimeTicks& time,
-                                    const net::NetLog::Source& source,
-                                    net::NetLog::EventPhase phase,
-                                    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddEntry(const net::NetLog::Entry& entry) {
   // The events that the Observer is interested in only occur on the IO thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
     return;
-  if (source.type == net::NetLog::SOURCE_URL_REQUEST)
-    OnAddURLRequestEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
-    OnAddHTTPStreamJobEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_CONNECT_JOB)
-    OnAddConnectJobEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_SOCKET)
-    OnAddSocketEntry(type, time, source, phase, params);
+  if (entry.source().type == net::NetLog::SOURCE_URL_REQUEST)
+    OnAddURLRequestEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
+    OnAddHTTPStreamJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_CONNECT_JOB)
+    OnAddConnectJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_SOCKET)
+    OnAddSocketEntry(entry);
 }
 
 // static
@@ -125,23 +121,23 @@ void LoadTimingObserver::PopulateTimingInfo(
   }
 }
 
-void LoadTimingObserver::OnAddURLRequestEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddURLRequestEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  if (type == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
+  if (entry.type() == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
     if (is_begin) {
       // Only record timing for entries with corresponding flag.
-      int load_flags =
-          static_cast<net::URLRequestStartEventParameters*>(params)->
-              load_flags();
+      int load_flags;
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      if (!net::StartEventLoadFlagsFromEventParams(event_params.get(),
+                                                   &load_flags)) {
+        NOTREACHED();
+        return;
+      }
+
       if (!(load_flags & net::LOAD_ENABLE_LOAD_TIMING))
         return;
 
@@ -153,38 +149,48 @@ void LoadTimingObserver::OnAddURLRequestEntry(
         url_request_to_record_.clear();
       }
 
-      URLRequestRecord& record = url_request_to_record_[source.id];
-      record.base_ticks = time;
+      URLRequestRecord& record = url_request_to_record_[entry.source().id];
+      base::TimeTicks now = GetCurrentTime();
+      record.base_ticks = now;
       record.timing = ResourceLoadTimingInfo();
-      record.timing.base_ticks = time;
-      record.timing.base_time = TimeTicksToTime(time);
+      record.timing.base_ticks = now;
+      record.timing.base_time = TimeTicksToTime(now);
     }
     return;
-  } else if (type == net::NetLog::TYPE_REQUEST_ALIVE) {
+  } else if (entry.type() == net::NetLog::TYPE_REQUEST_ALIVE) {
     // Cleanup records based on the TYPE_REQUEST_ALIVE entry.
     if (is_end)
-      url_request_to_record_.erase(source.id);
+      url_request_to_record_.erase(entry.source().id);
     return;
   }
 
-  URLRequestRecord* record = GetURLRequestRecord(source.id);
+  URLRequestRecord* record = GetURLRequestRecord(entry.source().id);
   if (!record)
     return;
 
   ResourceLoadTimingInfo& timing = record->timing;
 
-  switch (type) {
+  switch (entry.type()) {
     case net::NetLog::TYPE_PROXY_SERVICE:
       if (is_begin)
-        timing.proxy_start = TimeTicksToOffset(time, record);
+        timing.proxy_start = TimeTicksToOffset(GetCurrentTime(), record);
       else if (is_end)
-        timing.proxy_end = TimeTicksToOffset(time, record);
+        timing.proxy_end = TimeTicksToOffset(GetCurrentTime(), record);
       break;
     case net::NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB: {
-      uint32 http_stream_job_id = static_cast<net::NetLogSourceParameter*>(
-          params)->value().id;
+      net::NetLog::Source http_stream_job_source;
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(
+              event_params.get(),
+              &http_stream_job_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_HTTP_STREAM_JOB,
+                http_stream_job_source.type);
+
       HTTPStreamJobToRecordMap::iterator it =
-          http_stream_job_to_record_.find(http_stream_job_id);
+          http_stream_job_to_record_.find(http_stream_job_source.id);
       if (it == http_stream_job_to_record_.end())
         return;
       if (!it->second.connect_start.is_null()) {
@@ -207,15 +213,18 @@ void LoadTimingObserver::OnAddURLRequestEntry(
     }
     case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST:
       if (is_begin)
-        timing.send_start = TimeTicksToOffset(time, record);
+        timing.send_start = TimeTicksToOffset(GetCurrentTime(), record);
       else if (is_end)
-        timing.send_end = TimeTicksToOffset(time, record);
+        timing.send_end = TimeTicksToOffset(GetCurrentTime(), record);
       break;
     case net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS:
-      if (is_begin)
-        timing.receive_headers_start = TimeTicksToOffset(time, record);
-      else if (is_end)
-        timing.receive_headers_end = TimeTicksToOffset(time, record);
+      if (is_begin) {
+        timing.receive_headers_start =
+            TimeTicksToOffset(GetCurrentTime(), record);
+      } else if (is_end) {
+        timing.receive_headers_end =
+            TimeTicksToOffset(GetCurrentTime(), record);
+      }
       break;
     default:
       break;
@@ -223,17 +232,13 @@ void LoadTimingObserver::OnAddURLRequestEntry(
 }
 
 void LoadTimingObserver::OnAddHTTPStreamJobEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  if (type == net::NetLog::TYPE_HTTP_STREAM_JOB) {
+  if (entry.type() == net::NetLog::TYPE_HTTP_STREAM_JOB) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in
       // case something went wrong. Should not happen.
@@ -244,29 +249,36 @@ void LoadTimingObserver::OnAddHTTPStreamJobEntry(
       }
 
       http_stream_job_to_record_.insert(
-          std::make_pair(source.id, HTTPStreamJobRecord()));
+          std::make_pair(entry.source().id, HTTPStreamJobRecord()));
     } else if (is_end) {
-      http_stream_job_to_record_.erase(source.id);
+      http_stream_job_to_record_.erase(entry.source().id);
     }
     return;
   }
 
   HTTPStreamJobToRecordMap::iterator it =
-      http_stream_job_to_record_.find(source.id);
+      http_stream_job_to_record_.find(entry.source().id);
   if (it == http_stream_job_to_record_.end())
     return;
 
-  switch (type) {
+  switch (entry.type()) {
     case net::NetLog::TYPE_SOCKET_POOL:
       if (is_begin)
-        it->second.connect_start = time;
+        it->second.connect_start = GetCurrentTime();
       else if (is_end)
-        it->second.connect_end = time;
+        it->second.connect_end = GetCurrentTime();
       break;
     case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB: {
-      uint32 connect_job_id = static_cast<net::NetLogSourceParameter*>(
-          params)->value().id;
-      if (last_connect_job_id_ == connect_job_id &&
+      net::NetLog::Source connect_job_source;
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                    &connect_job_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_CONNECT_JOB, connect_job_source.type);
+
+      if (last_connect_job_id_ == connect_job_source.id &&
           !last_connect_job_record_.dns_start.is_null()) {
         it->second.dns_start = last_connect_job_record_.dns_start;
         it->second.dns_end = last_connect_job_record_.dns_end;
@@ -276,9 +288,17 @@ void LoadTimingObserver::OnAddHTTPStreamJobEntry(
     case net::NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET:
       it->second.socket_reused = true;
       break;
-    case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET:
-      it->second.socket_log_id = static_cast<net::NetLogSourceParameter*>(
-        params)->value().id;
+    case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET: {
+      net::NetLog::Source socket_source;
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                    &socket_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_SOCKET, socket_source.type);
+
+      it->second.socket_log_id = socket_source.id;
       if (!it->second.socket_reused) {
         SocketToRecordMap::iterator socket_it =
             socket_to_record_.find(it->second.socket_log_id);
@@ -289,24 +309,20 @@ void LoadTimingObserver::OnAddHTTPStreamJobEntry(
         }
       }
       break;
+    }
     default:
       break;
   }
 }
 
-void LoadTimingObserver::OnAddConnectJobEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddConnectJobEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_POOL_CONNECT_JOB entry.
-  if (type == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB) {
+  if (entry.type() == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in case
       // something went wrong. Should not happen.
@@ -317,41 +333,36 @@ void LoadTimingObserver::OnAddConnectJobEntry(
       }
 
       connect_job_to_record_.insert(
-          std::make_pair(source.id, ConnectJobRecord()));
+          std::make_pair(entry.source().id, ConnectJobRecord()));
     } else if (is_end) {
       ConnectJobToRecordMap::iterator it =
-          connect_job_to_record_.find(source.id);
+          connect_job_to_record_.find(entry.source().id);
       if (it != connect_job_to_record_.end()) {
         last_connect_job_id_ = it->first;
         last_connect_job_record_ = it->second;
         connect_job_to_record_.erase(it);
       }
     }
-  } else if (type == net::NetLog::TYPE_HOST_RESOLVER_IMPL) {
+  } else if (entry.type() == net::NetLog::TYPE_HOST_RESOLVER_IMPL) {
     ConnectJobToRecordMap::iterator it =
-        connect_job_to_record_.find(source.id);
+        connect_job_to_record_.find(entry.source().id);
     if (it != connect_job_to_record_.end()) {
       if (is_begin)
-        it->second.dns_start = time;
+        it->second.dns_start = GetCurrentTime();
       else if (is_end)
-        it->second.dns_end = time;
+        it->second.dns_end = GetCurrentTime();
     }
   }
 }
 
-void LoadTimingObserver::OnAddSocketEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddSocketEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_ALIVE entry.
-  if (type == net::NetLog::TYPE_SOCKET_ALIVE) {
+  if (entry.type() == net::NetLog::TYPE_SOCKET_ALIVE) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in case
       // something went wrong. Should not happen.
@@ -362,20 +373,24 @@ void LoadTimingObserver::OnAddSocketEntry(
       }
 
       socket_to_record_.insert(
-          std::make_pair(source.id, SocketRecord()));
+          std::make_pair(entry.source().id, SocketRecord()));
     } else if (is_end) {
-      socket_to_record_.erase(source.id);
+      socket_to_record_.erase(entry.source().id);
     }
     return;
   }
-  SocketToRecordMap::iterator it = socket_to_record_.find(source.id);
+  SocketToRecordMap::iterator it = socket_to_record_.find(entry.source().id);
   if (it == socket_to_record_.end())
     return;
 
-  if (type == net::NetLog::TYPE_SSL_CONNECT) {
+  if (entry.type() == net::NetLog::TYPE_SSL_CONNECT) {
     if (is_begin)
-      it->second.ssl_start = time;
+      it->second.ssl_start = GetCurrentTime();
     else if (is_end)
-      it->second.ssl_end = time;
+      it->second.ssl_end = GetCurrentTime();
   }
 }
+
+base::TimeTicks LoadTimingObserver::GetCurrentTime() const {
+  return base::TimeTicks::Now();
+}
diff --git a/chrome/browser/net/load_timing_observer.h b/chrome/browser/net/load_timing_observer.h
index 56d3f8e..7df1c20 100644
--- a/chrome/browser/net/load_timing_observer.h
+++ b/chrome/browser/net/load_timing_observer.h
@@ -70,11 +70,7 @@ class LoadTimingObserver : public net::NetLog::ThreadSafeObserver {
   URLRequestRecord* GetURLRequestRecord(uint32 source_id);
 
   // net::NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
   static void PopulateTimingInfo(net::URLRequest* request,
                                  content::ResourceResponse* response);
@@ -87,33 +83,17 @@ class LoadTimingObserver : public net::NetLog::ThreadSafeObserver {
   FRIEND_TEST_ALL_PREFIXES(LoadTimingObserverTest,
                            SocketRecord);
 
-  void OnAddURLRequestEntry(net::NetLog::EventType type,
-                            const base::TimeTicks& time,
-                            const net::NetLog::Source& source,
-                            net::NetLog::EventPhase phase,
-                            net::NetLog::EventParameters* params);
-
-  void OnAddHTTPStreamJobEntry(net::NetLog::EventType type,
-                               const base::TimeTicks& time,
-                               const net::NetLog::Source& source,
-                               net::NetLog::EventPhase phase,
-                               net::NetLog::EventParameters* params);
-
-  void OnAddConnectJobEntry(net::NetLog::EventType type,
-                            const base::TimeTicks& time,
-                            const net::NetLog::Source& source,
-                            net::NetLog::EventPhase phase,
-                            net::NetLog::EventParameters* params);
-
-  void OnAddSocketEntry(net::NetLog::EventType type,
-                        const base::TimeTicks& time,
-                        const net::NetLog::Source& source,
-                        net::NetLog::EventPhase phase,
-                        net::NetLog::EventParameters* params);
+  void OnAddURLRequestEntry(const net::NetLog::Entry& entry);
+  void OnAddHTTPStreamJobEntry(const net::NetLog::Entry& entry);
+  void OnAddConnectJobEntry(const net::NetLog::Entry& entry);
+  void OnAddSocketEntry(const net::NetLog::Entry& entry);
 
   URLRequestRecord* CreateURLRequestRecord(uint32 source_id);
   void DeleteURLRequestRecord(uint32 source_id);
 
+  // Returns current time.  Virtual for unit tests.
+  virtual base::TimeTicks GetCurrentTime() const;
+
   typedef base::hash_map<uint32, URLRequestRecord> URLRequestToRecordMap;
   typedef base::hash_map<uint32, HTTPStreamJobRecord> HTTPStreamJobToRecordMap;
   typedef base::hash_map<uint32, ConnectJobRecord> ConnectJobToRecordMap;
diff --git a/chrome/browser/net/load_timing_observer_unittest.cc b/chrome/browser/net/load_timing_observer_unittest.cc
index 5859aad..564f10a 100644
--- a/chrome/browser/net/load_timing_observer_unittest.cc
+++ b/chrome/browser/net/load_timing_observer_unittest.cc
@@ -20,385 +20,379 @@ using base::TimeDelta;
 using content::BrowserThread;
 using net::NetLog;
 
+class TestLoadTimingObserver : public LoadTimingObserver {
+ public:
+  TestLoadTimingObserver() {}
+  virtual ~TestLoadTimingObserver() {}
+
+  void IncementTime(base::TimeDelta delta) {
+    current_time_ += delta;
+  }
+
+  virtual base::TimeTicks GetCurrentTime() const OVERRIDE {
+    return current_time_;
+  }
+
+ private:
+  base::TimeTicks current_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLoadTimingObserver);
+};
+
 // Serves to identify the current thread as the IO thread.
 class LoadTimingObserverTest : public testing::Test {
  public:
   LoadTimingObserverTest() : io_thread_(BrowserThread::IO, &message_loop_) {
   }
 
+ protected:
+  TestLoadTimingObserver observer_;
+
  private:
   MessageLoop message_loop_;
   content::TestBrowserThread io_thread_;
 };
 
-base::TimeTicks current_time;
+void AddStartEntry(LoadTimingObserver& observer,
+                   const NetLog::Source& source,
+                   NetLog::EventType type) {
+  net::NetLog::Entry entry(type,
+                           source,
+                           NetLog::PHASE_BEGIN,
+                           NULL,
+                           NetLog::LOG_BASIC);
+  observer.OnAddEntry(entry);
+}
 
 void AddStartEntry(LoadTimingObserver& observer,
                    const NetLog::Source& source,
                    NetLog::EventType type,
-                   NetLog::EventParameters* params) {
-  observer.OnAddEntry(type, current_time, source, NetLog::PHASE_BEGIN, params);
+                   const NetLog::ParametersCallback& params_callback) {
+  net::NetLog::Entry entry(type,
+                           source,
+                           NetLog::PHASE_BEGIN,
+                           &params_callback,
+                           NetLog::LOG_BASIC);
+  observer.OnAddEntry(entry);
 }
 
 void AddEndEntry(LoadTimingObserver& observer,
                  const NetLog::Source& source,
-                 NetLog::EventType type,
-                 NetLog::EventParameters* params) {
-  observer.OnAddEntry(type, current_time, source, NetLog::PHASE_END, params);
+                 NetLog::EventType type) {
+  net::NetLog::Entry entry(type,
+                           source,
+                           NetLog::PHASE_END,
+                           NULL,
+                           NetLog::LOG_BASIC);
+  observer.OnAddEntry(entry);
 }
 
 void AddStartURLRequestEntries(LoadTimingObserver& observer,
                                uint32 id,
                                bool request_timing) {
-  scoped_refptr<net::URLRequestStartEventParameters> params(
-      new net::URLRequestStartEventParameters(
-          GURL(base::StringPrintf("http://req%d", id)),
-          "GET",
-          request_timing ? net::LOAD_ENABLE_LOAD_TIMING : 0,
-          net::LOW));
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, id);
-  AddStartEntry(observer, source, NetLog::TYPE_REQUEST_ALIVE, NULL);
-  AddStartEntry(observer,
-                source,
-                NetLog::TYPE_URL_REQUEST_START_JOB,
-                params.get());
+  AddStartEntry(observer, source, NetLog::TYPE_REQUEST_ALIVE);
+
+  GURL url(base::StringPrintf("http://req%d", id));
+  std::string method = "GET";
+  AddStartEntry(
+      observer,
+      source,
+      NetLog::TYPE_URL_REQUEST_START_JOB,
+      base::Bind(&net::NetLogURLRequestStartCallback,
+                 &url,
+                 &method,
+                 request_timing ? net::LOAD_ENABLE_LOAD_TIMING : 0,
+                 net::LOW));
 }
 
 void AddEndURLRequestEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, id);
-  AddEndEntry(observer, source, NetLog::TYPE_REQUEST_ALIVE, NULL);
-  AddEndEntry(observer,
-              source,
-              NetLog::TYPE_URL_REQUEST_START_JOB,
-              NULL);
+  AddEndEntry(observer, source, NetLog::TYPE_REQUEST_ALIVE);
+  AddEndEntry(observer, source, NetLog::TYPE_URL_REQUEST_START_JOB);
 }
 
 void AddStartHTTPStreamJobEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_HTTP_STREAM_JOB, id);
-  AddStartEntry(observer, source, NetLog::TYPE_HTTP_STREAM_JOB, NULL);
+  AddStartEntry(observer, source, NetLog::TYPE_HTTP_STREAM_JOB);
 }
 
 void AddEndHTTPStreamJobEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_HTTP_STREAM_JOB, id);
-  AddEndEntry(observer, source, NetLog::TYPE_HTTP_STREAM_JOB, NULL);
+  AddEndEntry(observer, source, NetLog::TYPE_HTTP_STREAM_JOB);
 }
 
 void AddStartConnectJobEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_CONNECT_JOB, id);
-  AddStartEntry(observer, source, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB, NULL);
+  AddStartEntry(observer, source, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB);
 }
 
 void AddEndConnectJobEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_CONNECT_JOB, id);
-  AddEndEntry(observer, source, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB, NULL);
+  AddEndEntry(observer, source, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB);
 }
 
 void AddStartSocketEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_SOCKET, id);
-  AddStartEntry(observer, source, NetLog::TYPE_SOCKET_ALIVE, NULL);
+  AddStartEntry(observer, source, NetLog::TYPE_SOCKET_ALIVE);
 }
 
 void AddEndSocketEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_SOCKET, id);
-  AddEndEntry(observer, source, NetLog::TYPE_SOCKET_ALIVE, NULL);
+  AddEndEntry(observer, source, NetLog::TYPE_SOCKET_ALIVE);
 }
 
 void BindURLRequestToHTTPStreamJob(LoadTimingObserver& observer,
                                    NetLog::Source url_request_source,
                                    NetLog::Source http_stream_job_source) {
-  scoped_refptr<net::NetLogSourceParameter> params(
-      new net::NetLogSourceParameter("source_dependency",
-                                     http_stream_job_source));
   AddStartEntry(observer,
                 url_request_source,
                 NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
-                params.get());
+                http_stream_job_source.ToEventParametersCallback());
 }
 
 void BindHTTPStreamJobToConnectJob(LoadTimingObserver& observer,
                                    NetLog::Source& http_stream_job_source,
                                    NetLog::Source& connect_source) {
-  scoped_refptr<net::NetLogSourceParameter> params(
-      new net::NetLogSourceParameter("source_dependency", connect_source));
   AddStartEntry(observer,
                 http_stream_job_source,
                 NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
-                params.get());
+                connect_source.ToEventParametersCallback());
 }
 
 void BindHTTPStreamJobToSocket(LoadTimingObserver& observer,
                                NetLog::Source& http_stream_job_source,
                                NetLog::Source& socket_source) {
-  scoped_refptr<net::NetLogSourceParameter> params(
-      new net::NetLogSourceParameter("source_dependency", socket_source));
   AddStartEntry(observer,
                 http_stream_job_source,
                 NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
-                params.get());
+                socket_source.ToEventParametersCallback());
 }
 
 }  // namespace
 
 // Test that net::URLRequest with no load timing flag is not processed.
 TEST_F(LoadTimingObserverTest, NoLoadTimingEnabled) {
-  LoadTimingObserver observer;
-
-  AddStartURLRequestEntries(observer, 0, false);
+  AddStartURLRequestEntries(observer_, 0, false);
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_TRUE(record == NULL);
 }
 
 // Test that URLRequestRecord is created, deleted and is not growing unbound.
 TEST_F(LoadTimingObserverTest, URLRequestRecord) {
-  LoadTimingObserver observer;
-
   // Create record.
-  AddStartURLRequestEntries(observer, 0, true);
+  AddStartURLRequestEntries(observer_, 0, true);
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_FALSE(record == NULL);
 
   // Collect record.
-  AddEndURLRequestEntries(observer, 0);
-  record = observer.GetURLRequestRecord(0);
+  AddEndURLRequestEntries(observer_, 0);
+  record = observer_.GetURLRequestRecord(0);
   ASSERT_TRUE(record == NULL);
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
-    AddStartURLRequestEntries(observer, i, true);
-  record = observer.GetURLRequestRecord(1);
+    AddStartURLRequestEntries(observer_, i, true);
+  record = observer_.GetURLRequestRecord(1);
   ASSERT_TRUE(record == NULL);
 }
 
 // Test that HTTPStreamJobRecord is created, deleted and is not growing unbound.
 TEST_F(LoadTimingObserverTest, HTTPStreamJobRecord) {
-  LoadTimingObserver observer;
-
   // Create record.
-  AddStartHTTPStreamJobEntries(observer, 0);
-  ASSERT_FALSE(observer.http_stream_job_to_record_.find(0) ==
-                   observer.http_stream_job_to_record_.end());
+  AddStartHTTPStreamJobEntries(observer_, 0);
+  ASSERT_FALSE(observer_.http_stream_job_to_record_.find(0) ==
+                   observer_.http_stream_job_to_record_.end());
 
   // Collect record.
-  AddEndHTTPStreamJobEntries(observer, 0);
-  ASSERT_TRUE(observer.http_stream_job_to_record_.find(0) ==
-                   observer.http_stream_job_to_record_.end());
+  AddEndHTTPStreamJobEntries(observer_, 0);
+  ASSERT_TRUE(observer_.http_stream_job_to_record_.find(0) ==
+                   observer_.http_stream_job_to_record_.end());
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
-    AddStartHTTPStreamJobEntries(observer, i);
-  ASSERT_TRUE(observer.http_stream_job_to_record_.find(1) ==
-                  observer.http_stream_job_to_record_.end());
+    AddStartHTTPStreamJobEntries(observer_, i);
+  ASSERT_TRUE(observer_.http_stream_job_to_record_.find(1) ==
+                  observer_.http_stream_job_to_record_.end());
 }
 
 // Test that ConnectJobRecord is created, deleted and is not growing unbound.
 TEST_F(LoadTimingObserverTest, ConnectJobRecord) {
-  LoadTimingObserver observer;
-
   // Create record.
-  AddStartConnectJobEntries(observer, 0);
-  ASSERT_FALSE(observer.connect_job_to_record_.find(0) ==
-                   observer.connect_job_to_record_.end());
+  AddStartConnectJobEntries(observer_, 0);
+  ASSERT_FALSE(observer_.connect_job_to_record_.find(0) ==
+                   observer_.connect_job_to_record_.end());
 
   // Collect record.
-  AddEndConnectJobEntries(observer, 0);
-  ASSERT_TRUE(observer.connect_job_to_record_.find(0) ==
-                   observer.connect_job_to_record_.end());
+  AddEndConnectJobEntries(observer_, 0);
+  ASSERT_TRUE(observer_.connect_job_to_record_.find(0) ==
+                   observer_.connect_job_to_record_.end());
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
-    AddStartConnectJobEntries(observer, i);
-  ASSERT_TRUE(observer.connect_job_to_record_.find(1) ==
-                  observer.connect_job_to_record_.end());
+    AddStartConnectJobEntries(observer_, i);
+  ASSERT_TRUE(observer_.connect_job_to_record_.find(1) ==
+                  observer_.connect_job_to_record_.end());
 }
 
 // Test that SocketRecord is created, deleted and is not growing unbound.
 TEST_F(LoadTimingObserverTest, SocketRecord) {
-  LoadTimingObserver observer;
-
   // Create record.
-  AddStartSocketEntries(observer, 0);
-  ASSERT_FALSE(observer.socket_to_record_.find(0) ==
-                   observer.socket_to_record_.end());
+  AddStartSocketEntries(observer_, 0);
+  ASSERT_FALSE(observer_.socket_to_record_.find(0) ==
+                   observer_.socket_to_record_.end());
 
   // Collect record.
-  AddEndSocketEntries(observer, 0);
-  ASSERT_TRUE(observer.socket_to_record_.find(0) ==
-                   observer.socket_to_record_.end());
-
+  AddEndSocketEntries(observer_, 0);
+  ASSERT_TRUE(observer_.socket_to_record_.find(0) ==
+                   observer_.socket_to_record_.end());
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
-    AddStartSocketEntries(observer, i);
-  ASSERT_TRUE(observer.socket_to_record_.find(1) ==
-                  observer.socket_to_record_.end());
+    AddStartSocketEntries(observer_, i);
+  ASSERT_TRUE(observer_.socket_to_record_.find(1) ==
+                  observer_.socket_to_record_.end());
 }
 
 // Test that basic time is set to the request.
 TEST_F(LoadTimingObserverTest, BaseTicks) {
-  LoadTimingObserver observer;
-  current_time += TimeDelta::FromSeconds(1);
-  AddStartURLRequestEntries(observer, 0, true);
+  observer_.IncementTime(TimeDelta::FromSeconds(1));
+  AddStartURLRequestEntries(observer_, 0, true);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(1000000, record->base_ticks.ToInternalValue());
 }
 
 // Test proxy time detection.
 TEST_F(LoadTimingObserverTest, ProxyTime) {
-  LoadTimingObserver observer;
-  current_time += TimeDelta::FromSeconds(1);
+  observer_.IncementTime(TimeDelta::FromSeconds(1));
 
-  AddStartURLRequestEntries(observer, 0, true);
+  AddStartURLRequestEntries(observer_, 0, true);
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
 
-  current_time += TimeDelta::FromSeconds(2);
-  AddStartEntry(observer, source, NetLog::TYPE_PROXY_SERVICE, NULL);
-  current_time += TimeDelta::FromSeconds(3);
-  AddEndEntry(observer, source, NetLog::TYPE_PROXY_SERVICE, NULL);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
+  AddStartEntry(observer_, source, NetLog::TYPE_PROXY_SERVICE);
+  observer_.IncementTime(TimeDelta::FromSeconds(3));
+  AddEndEntry(observer_, source, NetLog::TYPE_PROXY_SERVICE);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.proxy_start);
   ASSERT_EQ(5000, record->timing.proxy_end);
 }
 
 // Test connect time detection.
 TEST_F(LoadTimingObserverTest, ConnectTime) {
-  LoadTimingObserver observer;
-  current_time += TimeDelta::FromSeconds(1);
+  observer_.IncementTime(TimeDelta::FromSeconds(1));
 
-  AddStartURLRequestEntries(observer, 0, true);
+  AddStartURLRequestEntries(observer_, 0, true);
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
 
   NetLog::Source http_stream_job_source(NetLog::SOURCE_HTTP_STREAM_JOB, 1);
-  AddStartHTTPStreamJobEntries(observer, 1);
+  AddStartHTTPStreamJobEntries(observer_, 1);
 
-  current_time += TimeDelta::FromSeconds(2);
-  AddStartEntry(observer, http_stream_job_source, NetLog::TYPE_SOCKET_POOL,
-                NULL);
-  current_time += TimeDelta::FromSeconds(3);
-  AddEndEntry(observer, http_stream_job_source, NetLog::TYPE_SOCKET_POOL, NULL);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
+  AddStartEntry(observer_, http_stream_job_source, NetLog::TYPE_SOCKET_POOL);
+  observer_.IncementTime(TimeDelta::FromSeconds(3));
+  AddEndEntry(observer_, http_stream_job_source, NetLog::TYPE_SOCKET_POOL);
 
-  BindURLRequestToHTTPStreamJob(observer, source, http_stream_job_source);
+  BindURLRequestToHTTPStreamJob(observer_, source, http_stream_job_source);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.connect_start);
   ASSERT_EQ(5000, record->timing.connect_end);
 }
 
 // Test dns time detection.
 TEST_F(LoadTimingObserverTest, DnsTime) {
-  LoadTimingObserver observer;
-
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
-  AddStartURLRequestEntries(observer, 0, true);
-  current_time += TimeDelta::FromSeconds(1);
+  AddStartURLRequestEntries(observer_, 0, true);
+  observer_.IncementTime(TimeDelta::FromSeconds(1));
 
   // Add resolver entry.
-  AddStartConnectJobEntries(observer, 1);
+  AddStartConnectJobEntries(observer_, 1);
   NetLog::Source connect_source(NetLog::SOURCE_CONNECT_JOB, 1);
-  AddStartEntry(observer,
-                connect_source,
-                NetLog::TYPE_HOST_RESOLVER_IMPL,
-                NULL);
-  current_time += TimeDelta::FromSeconds(2);
-  AddEndEntry(observer, connect_source, NetLog::TYPE_HOST_RESOLVER_IMPL, NULL);
-  AddEndConnectJobEntries(observer, 1);
+  AddStartEntry(observer_, connect_source, NetLog::TYPE_HOST_RESOLVER_IMPL);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
+  AddEndEntry(observer_, connect_source, NetLog::TYPE_HOST_RESOLVER_IMPL);
+  AddEndConnectJobEntries(observer_, 1);
 
   NetLog::Source http_stream_job_source(NetLog::SOURCE_HTTP_STREAM_JOB, 2);
-  AddStartHTTPStreamJobEntries(observer, 2);
+  AddStartHTTPStreamJobEntries(observer_, 2);
 
-  BindHTTPStreamJobToConnectJob(observer, http_stream_job_source,
+  BindHTTPStreamJobToConnectJob(observer_, http_stream_job_source,
                                 connect_source);
-  BindURLRequestToHTTPStreamJob(observer, source, http_stream_job_source);
+  BindURLRequestToHTTPStreamJob(observer_, source, http_stream_job_source);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(1000, record->timing.dns_start);
   ASSERT_EQ(3000, record->timing.dns_end);
 }
 
 // Test send time detection.
 TEST_F(LoadTimingObserverTest, SendTime) {
-  LoadTimingObserver observer;
-
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
-  AddStartURLRequestEntries(observer, 0, true);
-  current_time += TimeDelta::FromSeconds(2);
+  AddStartURLRequestEntries(observer_, 0, true);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
 
   // Add send request entry.
-  AddStartEntry(observer,
-                source,
-                NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
-                NULL);
-  current_time += TimeDelta::FromSeconds(5);
-  AddEndEntry(observer,
-              source,
-              NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
-              NULL);
+  AddStartEntry(observer_, source, NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
+  observer_.IncementTime(TimeDelta::FromSeconds(5));
+  AddEndEntry(observer_, source, NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.send_start);
   ASSERT_EQ(7000, record->timing.send_end);
 }
 
 // Test receive time detection.
 TEST_F(LoadTimingObserverTest, ReceiveTime) {
-  LoadTimingObserver observer;
-
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
-  AddStartURLRequestEntries(observer, 0, true);
-  current_time += TimeDelta::FromSeconds(2);
+  AddStartURLRequestEntries(observer_, 0, true);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
 
   // Add send request entry.
-  AddStartEntry(observer,
-                source,
-                NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
-                NULL);
-  current_time += TimeDelta::FromSeconds(5);
-  AddEndEntry(observer,
-              source,
-              NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
-              NULL);
+  AddStartEntry(observer_, source, NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
+  observer_.IncementTime(TimeDelta::FromSeconds(5));
+  AddEndEntry(observer_, source, NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.receive_headers_start);
   ASSERT_EQ(7000, record->timing.receive_headers_end);
 }
 
 // Test ssl time detection.
 TEST_F(LoadTimingObserverTest, SslTime) {
-  LoadTimingObserver observer;
-
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
-  AddStartURLRequestEntries(observer, 0, true);
-  current_time += TimeDelta::FromSeconds(1);
+  AddStartURLRequestEntries(observer_, 0, true);
+  observer_.IncementTime(TimeDelta::FromSeconds(1));
 
   // Add resolver entry.
-  AddStartSocketEntries(observer, 1);
+  AddStartSocketEntries(observer_, 1);
   NetLog::Source socket_source(NetLog::SOURCE_SOCKET, 1);
-  AddStartEntry(observer, socket_source, NetLog::TYPE_SSL_CONNECT, NULL);
-  current_time += TimeDelta::FromSeconds(2);
-  AddEndEntry(observer, socket_source, NetLog::TYPE_SSL_CONNECT, NULL);
+  AddStartEntry(observer_, socket_source, NetLog::TYPE_SSL_CONNECT);
+  observer_.IncementTime(TimeDelta::FromSeconds(2));
+  AddEndEntry(observer_, socket_source, NetLog::TYPE_SSL_CONNECT);
 
   NetLog::Source http_stream_job_source(NetLog::SOURCE_HTTP_STREAM_JOB, 2);
-  AddStartHTTPStreamJobEntries(observer, 2);
+  AddStartHTTPStreamJobEntries(observer_, 2);
 
-  BindHTTPStreamJobToSocket(observer, http_stream_job_source, socket_source);
-  BindURLRequestToHTTPStreamJob(observer, source, http_stream_job_source);
+  BindHTTPStreamJobToSocket(observer_, http_stream_job_source, socket_source);
+  BindURLRequestToHTTPStreamJob(observer_, source, http_stream_job_source);
 
   LoadTimingObserver::URLRequestRecord* record =
-      observer.GetURLRequestRecord(0);
+      observer_.GetURLRequestRecord(0);
   ASSERT_EQ(1000, record->timing.ssl_start);
   ASSERT_EQ(3000, record->timing.ssl_end);
 }
diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc
index 9ef34d5..f91648d 100644
--- a/chrome/browser/net/net_log_logger.cc
+++ b/chrome/browser/net/net_log_logger.cc
@@ -37,14 +37,8 @@ void NetLogLogger::StartObserving(net::NetLog* net_log) {
   net_log->AddThreadSafeObserver(this, net::NetLog::LOG_ALL_BUT_BYTES);
 }
 
-void NetLogLogger::OnAddEntry(net::NetLog::EventType type,
-                              const base::TimeTicks& time,
-                              const net::NetLog::Source& source,
-                              net::NetLog::EventPhase phase,
-                              net::NetLog::EventParameters* params) {
-  scoped_ptr<Value> value(
-      net::NetLog::EntryToDictionaryValue(
-          type, time, source, phase, params, false));
+void NetLogLogger::OnAddEntry(const net::NetLog::Entry& entry) {
+  scoped_ptr<Value> value(entry.ToValue());
   // Don't pretty print, so each JSON value occupies a single line, with no
   // breaks (Line breaks in any text field will be escaped).  Using strings
   // instead of integer identifiers allows logs from older versions to be
diff --git a/chrome/browser/net/net_log_logger.h b/chrome/browser/net/net_log_logger.h
index fc54462..0aa69a9 100644
--- a/chrome/browser/net/net_log_logger.h
+++ b/chrome/browser/net/net_log_logger.h
@@ -34,11 +34,7 @@ class NetLogLogger : public net::NetLog::ThreadSafeObserver {
   void StartObserving(net::NetLog* net_log);
 
   // net::NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
  private:
   ScopedStdioHandle file_;
diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.cc b/chrome/browser/ui/webui/media/media_internals_proxy.cc
index 792c0ac..d57af78 100644
--- a/chrome/browser/ui/webui/media/media_internals_proxy.cc
+++ b/chrome/browser/ui/webui/media/media_internals_proxy.cc
@@ -80,14 +80,10 @@ void MediaInternalsProxy::OnUpdate(const string16& update) {
       base::Bind(&MediaInternalsProxy::UpdateUIOnUIThread, this, update));
 }
 
-void MediaInternalsProxy::OnAddEntry(net::NetLog::EventType type,
-                                     const base::TimeTicks& time,
-                                     const net::NetLog::Source& source,
-                                     net::NetLog::EventPhase phase,
-                                     net::NetLog::EventParameters* params) {
+void MediaInternalsProxy::OnAddEntry(const net::NetLog::Entry& entry) {
   bool is_event_interesting = false;
   for (size_t i = 0; i < arraysize(kNetEventTypeFilter); i++) {
-    if (type == kNetEventTypeFilter[i]) {
+    if (entry.type() == kNetEventTypeFilter[i]) {
       is_event_interesting = true;
       break;
     }
@@ -99,8 +95,7 @@ void MediaInternalsProxy::OnAddEntry(net::NetLog::EventType type,
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaInternalsProxy::AddNetEventOnUIThread, this,
-          net::NetLog::EntryToDictionaryValue(type, time, source, phase,
-                                              params, false)));
+                 entry.ToValue()));
 }
 
 MediaInternalsProxy::~MediaInternalsProxy() {}
diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.h b/chrome/browser/ui/webui/media/media_internals_proxy.h
index 3757841..1999fca 100644
--- a/chrome/browser/ui/webui/media/media_internals_proxy.h
+++ b/chrome/browser/ui/webui/media/media_internals_proxy.h
@@ -55,11 +55,7 @@ class MediaInternalsProxy
   virtual void OnUpdate(const string16& update) OVERRIDE;
 
   // net::NetLog::ThreadSafeObserver implementation. Callable from any thread:
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
diff --git a/chrome/browser/ui/webui/net_internals/net_internals_ui.cc b/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
index d03f19f..9dd1418 100644
--- a/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
+++ b/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
@@ -479,20 +479,16 @@ class NetInternalsMessageHandler::IOThreadImpl
   void OnSetLogLevel(const ListValue* list);
 
   // ChromeNetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params);
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
   // ConnectionTester::Delegate implementation:
-  virtual void OnStartConnectionTestSuite();
+  virtual void OnStartConnectionTestSuite() OVERRIDE;
   virtual void OnStartConnectionTestExperiment(
-      const ConnectionTester::Experiment& experiment);
+      const ConnectionTester::Experiment& experiment) OVERRIDE;
   virtual void OnCompletedConnectionTestExperiment(
       const ConnectionTester::Experiment& experiment,
-      int result);
-  virtual void OnCompletedConnectionTestSuite();
+      int result) OVERRIDE;
+  virtual void OnCompletedConnectionTestSuite() OVERRIDE;
 
   // Helper that calls g_browser.receive in the renderer, passing in |command|
   // and |arg|.  Takes ownership of |arg|.  If the renderer is displaying a log
@@ -1503,16 +1499,10 @@ void NetInternalsMessageHandler::IOThreadImpl::OnSetLogLevel(
 // Note that unlike other methods of IOThreadImpl, this function
 // can be called from ANY THREAD.
 void NetInternalsMessageHandler::IOThreadImpl::OnAddEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&IOThreadImpl::AddEntryToQueue, this,
-          net::NetLog::EntryToDictionaryValue(type, time, source, phase,
-                                              params, false)));
+      base::Bind(&IOThreadImpl::AddEntryToQueue, this, entry.ToValue()));
 }
 
 void NetInternalsMessageHandler::IOThreadImpl::AddEntryToQueue(Value* entry) {
diff --git a/content/browser/debugger/devtools_netlog_observer.cc b/content/browser/debugger/devtools_netlog_observer.cc
index bcd53db..31fb9d7 100644
--- a/content/browser/debugger/devtools_netlog_observer.cc
+++ b/content/browser/debugger/devtools_netlog_observer.cc
@@ -11,7 +11,6 @@
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/load_flags.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
@@ -38,37 +37,35 @@ DevToolsNetLogObserver::GetResourceInfo(uint32 id) {
   return NULL;
 }
 
-void DevToolsNetLogObserver::OnAddEntry(net::NetLog::EventType type,
-                                        const base::TimeTicks& time,
-                                        const net::NetLog::Source& source,
-                                        net::NetLog::EventPhase phase,
-                                        net::NetLog::EventParameters* params) {
+void DevToolsNetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
   // The events that the Observer is interested in only occur on the IO thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
     return;
-  if (source.type == net::NetLog::SOURCE_URL_REQUEST)
-    OnAddURLRequestEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
-    OnAddHTTPStreamJobEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_SOCKET)
-    OnAddSocketEntry(type, time, source, phase, params);
+
+  if (entry.source().type == net::NetLog::SOURCE_URL_REQUEST)
+    OnAddURLRequestEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
+    OnAddHTTPStreamJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_SOCKET)
+    OnAddSocketEntry(entry);
 }
 
 void DevToolsNetLogObserver::OnAddURLRequestEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  if (type == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
+  if (entry.type() == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
     if (is_begin) {
-      int load_flags = static_cast<
-          net::URLRequestStartEventParameters*>(params)->load_flags();
+      int load_flags;
+      scoped_ptr<Value> event_param(entry.ParametersToValue());
+      if (!net::StartEventLoadFlagsFromEventParams(event_param.get(),
+                                                   &load_flags)) {
+        return;
+      }
+
       if (!(load_flags & net::LOAD_REPORT_RAW_HEADERS))
         return;
 
@@ -78,7 +75,7 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
         request_to_info_.clear();
       }
 
-      request_to_info_[source.id] = new ResourceInfo();
+      request_to_info_[entry.source().id] = new ResourceInfo();
 
       if (request_to_encoded_data_length_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The encoded data length observer url request count "
@@ -86,28 +83,33 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
         request_to_encoded_data_length_.clear();
       }
 
-      request_to_encoded_data_length_[source.id] = 0;
+      request_to_encoded_data_length_[entry.source().id] = 0;
     }
     return;
-  } else if (type == net::NetLog::TYPE_REQUEST_ALIVE) {
+  } else if (entry.type() == net::NetLog::TYPE_REQUEST_ALIVE) {
     // Cleanup records based on the TYPE_REQUEST_ALIVE entry.
     if (is_end) {
-      request_to_info_.erase(source.id);
-      request_to_encoded_data_length_.erase(source.id);
+      request_to_info_.erase(entry.source().id);
+      request_to_encoded_data_length_.erase(entry.source().id);
     }
     return;
   }
 
-  ResourceInfo* info = GetResourceInfo(source.id);
+  ResourceInfo* info = GetResourceInfo(entry.source().id);
   if (!info)
     return;
 
-  switch (type) {
+  switch (entry.type()) {
     case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS: {
-      net::NetLogHttpRequestParameter* request_parameter =
-          static_cast<net::NetLogHttpRequestParameter*>(params);
-      const net::HttpRequestHeaders &request_headers =
-          request_parameter->GetHeaders();
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      std::string request_line;
+      net::HttpRequestHeaders request_headers;
+
+      if (!net::HttpRequestHeaders::FromNetLogParam(event_params.get(),
+                                                    &request_headers,
+                                                    &request_line)) {
+        NOTREACHED();
+      }
 
       // We need to clear headers in case the same url_request is reused for
       // several http requests (e.g. see http://crbug.com/80157).
@@ -115,19 +117,23 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
 
       for (net::HttpRequestHeaders::Iterator it(request_headers);
            it.GetNext();) {
-        info->request_headers.push_back(std::make_pair(it.name(),
-                                                       it.value()));
+        info->request_headers.push_back(std::make_pair(it.name(), it.value()));
       }
-      info->request_headers_text =
-          request_parameter->GetLine() +
-          request_parameter->GetHeaders().ToString();
+      info->request_headers_text = request_line + request_headers.ToString();
       break;
     }
     case net::NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS: {
-      const net::HttpResponseHeaders& response_headers =
-          static_cast<net::NetLogHttpResponseParameter*>(params)->GetHeaders();
-      info->http_status_code = response_headers.response_code();
-      info->http_status_text = response_headers.GetStatusText();
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+
+      scoped_refptr<net::HttpResponseHeaders> response_headers;
+
+      if (!net::HttpResponseHeaders::FromNetLogParam(event_params.get(),
+                                                     &response_headers)) {
+        NOTREACHED();
+      }
+
+      info->http_status_code = response_headers->response_code();
+      info->http_status_text = response_headers->GetStatusText();
       std::string name, value;
 
       // We need to clear headers in case the same url_request is reused for
@@ -135,17 +141,24 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
       info->response_headers.clear();
 
       for (void* it = NULL;
-           response_headers.EnumerateHeaderLines(&it, &name, &value); ) {
+           response_headers->EnumerateHeaderLines(&it, &name, &value); ) {
         info->response_headers.push_back(std::make_pair(name, value));
       }
       info->response_headers_text =
           net::HttpUtil::ConvertHeadersBackToHTTPResponse(
-              response_headers.raw_headers());
+              response_headers->raw_headers());
       break;
     }
     case net::NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB: {
-      uint32 http_stream_job_id = static_cast<net::NetLogSourceParameter*>(
-          params)->value().id;
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      net::NetLog::Source http_stream_job_source;
+      if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                    &http_stream_job_source)) {
+        NOTREACHED();
+        break;
+      }
+
+      uint32 http_stream_job_id = http_stream_job_source.id;
       HTTPStreamJobToSocketMap::iterator it =
           http_stream_job_to_socket_.find(http_stream_job_id);
       if (it == http_stream_job_to_socket_.end())
@@ -158,7 +171,7 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
         socket_to_request_.clear();
       }
 
-      socket_to_request_[socket_id] = source.id;
+      socket_to_request_[socket_id] = entry.source().id;
       http_stream_job_to_socket_.erase(http_stream_job_id);
       break;
     }
@@ -168,16 +181,17 @@ void DevToolsNetLogObserver::OnAddURLRequestEntry(
 }
 
 void DevToolsNetLogObserver::OnAddHTTPStreamJobEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (type == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET) {
-    uint32 socket_id = static_cast<net::NetLogSourceParameter*>(
-      params)->value().id;
+  if (entry.type() == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET) {
+    scoped_ptr<Value> event_params(entry.ParametersToValue());
+    net::NetLog::Source socket_source;
+    if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                  &socket_source)) {
+      NOTREACHED();
+      return;
+    }
 
     // Prevents us from passively growing the memory unbounded in
     // case something went wrong. Should not happen.
@@ -186,28 +200,25 @@ void DevToolsNetLogObserver::OnAddHTTPStreamJobEntry(
                       "has grown larger than expected, resetting";
       http_stream_job_to_socket_.clear();
     }
-    http_stream_job_to_socket_[source.id] = socket_id;
+    http_stream_job_to_socket_[entry.source().id] = socket_source.id;
   }
 }
 
 void DevToolsNetLogObserver::OnAddSocketEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  SocketToRequestMap::iterator it = socket_to_request_.find(source.id);
+  SocketToRequestMap::iterator it =
+      socket_to_request_.find(entry.source().id);
   if (it == socket_to_request_.end())
     return;
   uint32 request_id = it->second;
 
-  if (type == net::NetLog::TYPE_SOCKET_IN_USE) {
+  if (entry.type() == net::NetLog::TYPE_SOCKET_IN_USE) {
     if (is_end)
-      socket_to_request_.erase(source.id);
+      socket_to_request_.erase(entry.source().id);
     return;
   }
 
@@ -216,9 +227,9 @@ void DevToolsNetLogObserver::OnAddSocketEntry(
   if (encoded_data_length_it == request_to_encoded_data_length_.end())
     return;
 
-  if (net::NetLog::TYPE_SOCKET_BYTES_RECEIVED == type) {
+  if (net::NetLog::TYPE_SOCKET_BYTES_RECEIVED == entry.type()) {
     int byte_count = 0;
-    scoped_ptr<Value> value(params->ToValue());
+    scoped_ptr<Value> value(entry.ParametersToValue());
     if (!value->IsType(Value::TYPE_DICTIONARY))
       return;
 
diff --git a/content/browser/debugger/devtools_netlog_observer.h b/content/browser/debugger/devtools_netlog_observer.h
index eee61d3..1d6a7ef 100644
--- a/content/browser/debugger/devtools_netlog_observer.h
+++ b/content/browser/debugger/devtools_netlog_observer.h
@@ -31,29 +31,11 @@ class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver {
 
  public:
   // net::NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
 
-  void OnAddURLRequestEntry(net::NetLog::EventType type,
-                            const base::TimeTicks& time,
-                            const net::NetLog::Source& source,
-                            net::NetLog::EventPhase phase,
-                            net::NetLog::EventParameters* params);
-
-  void OnAddHTTPStreamJobEntry(net::NetLog::EventType type,
-                               const base::TimeTicks& time,
-                               const net::NetLog::Source& source,
-                               net::NetLog::EventPhase phase,
-                               net::NetLog::EventParameters* params);
-
-  void OnAddSocketEntry(net::NetLog::EventType type,
-                        const base::TimeTicks& time,
-                        const net::NetLog::Source& source,
-                        net::NetLog::EventPhase phase,
-                        net::NetLog::EventParameters* params);
+  void OnAddURLRequestEntry(const net::NetLog::Entry& entry);
+  void OnAddHTTPStreamJobEntry(const net::NetLog::Entry& entry);
+  void OnAddSocketEntry(const net::NetLog::Entry& entry);
 
   static void Attach();
   static void Detach();
diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc
index 0746d62..8c04b78 100644
--- a/net/base/capturing_net_log.cc
+++ b/net/base/capturing_net_log.cc
@@ -80,30 +80,24 @@ void CapturingNetLog::SetLogLevel(NetLog::LogLevel log_level) {
   log_level_ = log_level;
 }
 
-void CapturingNetLog::AddEntry(
-    EventType type,
-    const Source& source,
-    EventPhase phase,
-    const scoped_refptr<EventParameters>& extra_parameters) {
+void CapturingNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
   // Only BoundNetLogs without a NetLog should have an invalid source.
-  DCHECK(source.is_valid());
+  DCHECK(entry.source().is_valid());
 
   // Using Dictionaries instead of Values makes checking values a little
   // simpler.
   DictionaryValue* param_dict = NULL;
-  if (extra_parameters) {
-    Value* param_value = extra_parameters->ToValue();
-    if (param_value && !param_value->GetAsDictionary(&param_dict))
-      delete param_value;
-  }
+  Value* param_value = entry.ParametersToValue();
+  if (param_value && !param_value->GetAsDictionary(&param_dict))
+    delete param_value;
 
   // Only need to acquire the lock when accessing class variables.
   base::AutoLock lock(lock_);
   captured_entries_.push_back(
-      CapturedEntry(type,
+      CapturedEntry(entry.type(),
                     base::TimeTicks::Now(),
-                    source,
-                    phase,
+                    entry.source(),
+                    entry.phase(),
                     scoped_ptr<DictionaryValue>(param_dict)));
 }
 
diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h
index fdc1349..a0dc380 100644
--- a/net/base/capturing_net_log.h
+++ b/net/base/capturing_net_log.h
@@ -76,11 +76,7 @@ class CapturingNetLog : public NetLog {
   void SetLogLevel(NetLog::LogLevel log_level);
 
   // NetLog implementation:
-  virtual void AddEntry(
-      EventType type,
-      const Source& source,
-      EventPhase phase,
-      const scoped_refptr<EventParameters>& extra_parameters) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
   virtual uint32 NextID() OVERRIDE;
   virtual LogLevel GetLogLevel() const OVERRIDE;
   virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
diff --git a/net/base/file_stream_unittest.cc b/net/base/file_stream_unittest.cc
index d3853ca..7cda76d 100644
--- a/net/base/file_stream_unittest.cc
+++ b/net/base/file_stream_unittest.cc
@@ -38,7 +38,7 @@ IOBufferWithSize* CreateTestDataBuffer() {
 class NetLogForNotifyingFileClosure : public NetLog {
  public:
   NetLogForNotifyingFileClosure()
-      : id_(0),
+      : last_id_(0),
         on_closure_(false /* manual_reset */, false /* initially_signaled */) {
   }
 
@@ -51,17 +51,12 @@ class NetLogForNotifyingFileClosure : public NetLog {
   }
 
   // NetLog overrides:
-  virtual void AddEntry(
-      EventType type,
-      const Source& source,
-      EventPhase phase,
-      const scoped_refptr<EventParameters>& params) OVERRIDE {
-    if (type == TYPE_FILE_STREAM_CLOSE) {
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
+    if (entry.type() == TYPE_FILE_STREAM_CLOSE)
       on_closure_.Signal();
-    }
   }
 
-  virtual uint32 NextID() OVERRIDE { return id_++; }
+  virtual uint32 NextID() OVERRIDE { return ++last_id_; }
   virtual LogLevel GetLogLevel() const OVERRIDE { return LOG_ALL; }
   virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
                                      LogLevel log_level) OVERRIDE {
@@ -76,7 +71,7 @@ class NetLogForNotifyingFileClosure : public NetLog {
   }
 
  private:
-  uint32 id_;
+  uint32 last_id_;
   base::WaitableEvent on_closure_;
 };
 
diff --git a/net/base/net_log.cc b/net/base/net_log.cc
index 0f0b719..4f18e46c 100644
--- a/net/base/net_log.cc
+++ b/net/base/net_log.cc
@@ -4,6 +4,7 @@
 
 #include "net/base/net_log.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ -15,39 +16,43 @@ namespace net {
 
 namespace {
 
-// Parameters for logging data transferred events. Includes bytes transferred
-// and, if |bytes| is not NULL, the bytes themselves.
-class NetLogBytesTransferredParameter : public NetLog::EventParameters {
- public:
-  NetLogBytesTransferredParameter(int byte_count, const char* bytes);
-
-  virtual Value* ToValue() const;
-
- protected:
-  virtual ~NetLogBytesTransferredParameter() {}
+// Returns parameters for logging data transferred events. Includes number of
+// bytes transferred and, if the log level indicates bytes should be logged and
+// |byte_count| > 0, the bytes themselves.  The bytes are hex-encoded, since
+// base::StringValue only supports UTF-8.
+Value* BytesTransferredCallback(int byte_count,
+                                const char* bytes,
+                                NetLog::LogLevel log_level) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetInteger("byte_count", byte_count);
+  if (NetLog::IsLoggingBytes(log_level) && byte_count > 0)
+    dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
+  return dict;
+}
 
- private:
-  const int byte_count_;
-  std::string hex_encoded_bytes_;
-  bool has_bytes_;
-};
+Value* EventParametersCallback(
+    const scoped_refptr<NetLog::EventParameters>& params,
+    NetLog::LogLevel /* log_level */) {
+  if (!params.get())
+    return NULL;
+  return params->ToValue();
+}
 
-NetLogBytesTransferredParameter::NetLogBytesTransferredParameter(
-    int byte_count, const char* transferred_bytes)
-    : byte_count_(byte_count),
-      has_bytes_(false) {
-  if (transferred_bytes) {
-    hex_encoded_bytes_ = base::HexEncode(transferred_bytes, byte_count);
-    has_bytes_ = true;
-  }
+Value* SourceEventParametersCallback(const NetLog::Source source,
+                                     NetLog::LogLevel /* log_level */) {
+  DictionaryValue* event_params = new DictionaryValue();
+  source.AddToEventParameters(event_params);
+  return event_params;
 }
 
-Value* NetLogBytesTransferredParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetInteger("byte_count", byte_count_);
-  if (has_bytes_ && byte_count_ > 0)
-    dict->SetString("hex_encoded_bytes", hex_encoded_bytes_);
-  return dict;
+Value* SingleIntegerCallback(const char* name,
+                             int value,
+                             NetLog::LogLevel /* log_level */) {
+  if (!value)
+    return NULL;
+  DictionaryValue* event_params = new DictionaryValue();
+  event_params->SetInteger(name, value);
+  return event_params;
 }
 
 }  // namespace
@@ -59,6 +64,85 @@ Value* NetLog::Source::ToValue() const {
   return dict;
 }
 
+void NetLog::Source::AddToEventParameters(DictionaryValue* event_params) const {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetInteger("type", static_cast<int>(type));
+  dict->SetInteger("id", static_cast<int>(id));
+  event_params->Set("source_dependency", dict);
+}
+
+NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const {
+  return base::Bind(&SourceEventParametersCallback, *this);
+}
+
+// static
+bool NetLog::Source::FromEventParameters(Value* event_params, Source* source) {
+  DictionaryValue* dict;
+  DictionaryValue* source_dict;
+  int source_id;
+  int source_type;
+  if (!event_params ||
+      !event_params->GetAsDictionary(&dict) ||
+      !dict->GetDictionary("source_dependency", &source_dict) ||
+      !source_dict->GetInteger("id", &source_id) ||
+      !source_dict->GetInteger("type", &source_type)) {
+    *source = Source();
+    return false;
+  }
+
+  DCHECK_LE(0, source_id);
+  DCHECK_LT(source_type, NetLog::SOURCE_COUNT);
+  *source = Source(static_cast<SourceType>(source_type), source_id);
+  return true;
+}
+
+Value* NetLog::Entry::ToValue() const {
+  DictionaryValue* entry_dict(new DictionaryValue());
+
+  entry_dict->SetString("time", TickCountToString(base::TimeTicks::Now()));
+
+  // Set the entry source.
+  DictionaryValue* source_dict = new DictionaryValue();
+  source_dict->SetInteger("id", source_.id);
+  source_dict->SetInteger("type", static_cast<int>(source_.type));
+  entry_dict->Set("source", source_dict);
+
+  // Set the event info.
+  entry_dict->SetInteger("type", static_cast<int>(type_));
+  entry_dict->SetInteger("phase", static_cast<int>(phase_));
+
+  // Set the event-specific parameters.
+  if (parameters_callback_) {
+    Value* value = parameters_callback_->Run(log_level_);
+    if (value)
+      entry_dict->Set("params", value);
+  }
+
+  return entry_dict;
+}
+
+Value* NetLog::Entry::ParametersToValue() const {
+  if (parameters_callback_)
+    return parameters_callback_->Run(log_level_);
+  return NULL;
+}
+
+NetLog::Entry::Entry(
+    EventType type,
+    Source source,
+    EventPhase phase,
+    const ParametersCallback* parameters_callback,
+    LogLevel log_level)
+    : type_(type),
+      source_(source),
+      phase_(phase),
+      parameters_callback_(parameters_callback),
+      log_level_(log_level) {
+};
+
+NetLog::Entry::~Entry() {
+}
+
 NetLog::ThreadSafeObserver::ThreadSafeObserver() : log_level_(LOG_BASIC),
                                                    net_log_(NULL) {
 }
@@ -79,12 +163,29 @@ NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
+void NetLog::AddGlobalEntry(EventType type) {
+  AddEntry(type,
+           Source(net::NetLog::SOURCE_NONE, NextID()),
+           net::NetLog::PHASE_NONE,
+           NULL);
+}
+
+void NetLog::AddGlobalEntry(
+    EventType type,
+    const NetLog::ParametersCallback& parameters_callback) {
+  AddEntry(type,
+           Source(net::NetLog::SOURCE_NONE, NextID()),
+           net::NetLog::PHASE_NONE,
+           &parameters_callback);
+}
+
 void NetLog::AddGlobalEntry(EventType type,
                             const scoped_refptr<EventParameters>& params) {
+  ParametersCallback callback = base::Bind(&EventParametersCallback, params);
   AddEntry(type,
-           Source(net::NetLog::SOURCE_NONE, this->NextID()),
+           Source(net::NetLog::SOURCE_NONE, NextID()),
            net::NetLog::PHASE_NONE,
-           params);
+           &callback);
 }
 
 // static
@@ -150,41 +251,19 @@ const char* NetLog::EventPhaseToString(EventPhase phase) {
 }
 
 // static
-Value* NetLog::EntryToDictionaryValue(NetLog::EventType type,
-                                      const base::TimeTicks& time,
-                                      const NetLog::Source& source,
-                                      NetLog::EventPhase phase,
-                                      NetLog::EventParameters* params,
-                                      bool use_strings) {
-  DictionaryValue* entry_dict = new DictionaryValue();
-
-  entry_dict->SetString("time", TickCountToString(time));
-
-  // Set the entry source.
-  DictionaryValue* source_dict = new DictionaryValue();
-  source_dict->SetInteger("id", source.id);
-  if (!use_strings) {
-    source_dict->SetInteger("type", static_cast<int>(source.type));
-  } else {
-    source_dict->SetString("type",
-                           NetLog::SourceTypeToString(source.type));
-  }
-  entry_dict->Set("source", source_dict);
-
-  // Set the event info.
-  if (!use_strings) {
-    entry_dict->SetInteger("type", static_cast<int>(type));
-    entry_dict->SetInteger("phase", static_cast<int>(phase));
-  } else {
-    entry_dict->SetString("type", NetLog::EventTypeToString(type));
-    entry_dict->SetString("phase", NetLog::EventPhaseToString(phase));
-  }
+bool NetLog::IsLoggingBytes(LogLevel log_level) {
+  return log_level == NetLog::LOG_ALL;
+}
 
-  // Set the event-specific parameters.
-  if (params)
-    entry_dict->Set("params", params->ToValue());
+// static
+bool NetLog::IsLoggingAllEvents(LogLevel log_level) {
+  return log_level <= NetLog::LOG_ALL_BUT_BYTES;
+}
 
-  return entry_dict;
+// static
+NetLog::ParametersCallback NetLog::IntegerCallback(const char* name,
+                                                   int value) {
+  return base::Bind(&SingleIntegerCallback, name, value);
 }
 
 void NetLog::OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level) {
@@ -204,12 +283,69 @@ void NetLog::OnRemoveObserver(ThreadSafeObserver* observer) {
   observer->net_log_ = NULL;
 }
 
+void NetLog::AddEntry(EventType type,
+                      const Source& source,
+                      EventPhase phase,
+                      const NetLog::ParametersCallback* parameters_callback) {
+  Entry entry(type, source, phase, parameters_callback, GetLogLevel());
+  OnAddEntry(entry);
+}
+
+void BoundNetLog::AddEntry(NetLog::EventType type,
+                           NetLog::EventPhase phase) const {
+  if (!net_log_)
+    return;
+  net_log_->AddEntry(type, source_, phase, NULL);
+}
+
+void BoundNetLog::AddEntry(
+    NetLog::EventType type,
+    NetLog::EventPhase phase,
+    const NetLog::ParametersCallback& get_parameters) const {
+  if (!net_log_)
+    return;
+  net_log_->AddEntry(type, source_, phase, &get_parameters);
+}
+
+void BoundNetLog::AddEvent(NetLog::EventType type) const {
+  AddEntry(type, NetLog::PHASE_NONE);
+}
+
+void BoundNetLog::AddEvent(
+    NetLog::EventType type,
+    const NetLog::ParametersCallback& get_parameters) const {
+  AddEntry(type, NetLog::PHASE_NONE, get_parameters);
+}
+
+void BoundNetLog::BeginEvent(NetLog::EventType type) const {
+  AddEntry(type, NetLog::PHASE_BEGIN);
+}
+
+void BoundNetLog::BeginEvent(
+    NetLog::EventType type,
+    const NetLog::ParametersCallback& get_parameters) const {
+  AddEntry(type, NetLog::PHASE_BEGIN, get_parameters);
+}
+
+void BoundNetLog::EndEvent(NetLog::EventType type) const {
+  AddEntry(type, NetLog::PHASE_END);
+}
+
+void BoundNetLog::EndEvent(
+    NetLog::EventType type,
+    const NetLog::ParametersCallback& get_parameters) const {
+  AddEntry(type, NetLog::PHASE_END, get_parameters);
+}
+
 void BoundNetLog::AddEntry(
     NetLog::EventType type,
     NetLog::EventPhase phase,
     const scoped_refptr<NetLog::EventParameters>& params) const {
-  if (net_log_)
-    net_log_->AddEntry(type, source_, phase, params);
+  if (!net_log_)
+    return;
+  NetLog::ParametersCallback callback =
+      base::Bind(&EventParametersCallback, params);
+  net_log_->AddEntry(type, source_, phase, &callback);
 }
 
 void BoundNetLog::AddEvent(
@@ -234,33 +370,19 @@ void BoundNetLog::AddEventWithNetErrorCode(NetLog::EventType event_type,
                                            int net_error) const {
   DCHECK_GT(0, net_error);
   DCHECK_NE(ERR_IO_PENDING, net_error);
-  AddEvent(
-      event_type,
-      make_scoped_refptr(new NetLogIntegerParameter("net_error", net_error)));
+  AddEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
 }
 
 void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type,
                                            int net_error) const {
   DCHECK_NE(ERR_IO_PENDING, net_error);
-  if (net_error >= 0) {
-    EndEvent(event_type, NULL);
-  } else {
-    EndEvent(
-        event_type,
-        make_scoped_refptr(new NetLogIntegerParameter("net_error", net_error)));
-  }
+  EndEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
 }
 
 void BoundNetLog::AddByteTransferEvent(NetLog::EventType event_type,
                                        int byte_count,
                                        const char* bytes) const {
-  scoped_refptr<NetLog::EventParameters> params;
-  if (IsLoggingBytes()) {
-    params = new NetLogBytesTransferredParameter(byte_count, bytes);
-  } else {
-    params = new NetLogBytesTransferredParameter(byte_count, NULL);
-  }
-  AddEvent(event_type, params);
+  AddEvent(event_type, base::Bind(BytesTransferredCallback, byte_count, bytes));
 }
 
 NetLog::LogLevel BoundNetLog::GetLogLevel() const {
@@ -270,11 +392,11 @@ NetLog::LogLevel BoundNetLog::GetLogLevel() const {
 }
 
 bool BoundNetLog::IsLoggingBytes() const {
-  return GetLogLevel() == NetLog::LOG_ALL;
+  return NetLog::IsLoggingBytes(GetLogLevel());
 }
 
 bool BoundNetLog::IsLoggingAllEvents() const {
-  return GetLogLevel() <= NetLog::LOG_ALL_BUT_BYTES;
+  return NetLog::IsLoggingAllEvents(GetLogLevel());
 }
 
 // static
@@ -314,27 +436,4 @@ Value* NetLogSourceParameter::ToValue() const {
   return dict;
 }
 
-ScopedNetLogEvent::ScopedNetLogEvent(
-    const BoundNetLog& net_log,
-    NetLog::EventType event_type,
-    const scoped_refptr<NetLog::EventParameters>& params)
-    : net_log_(net_log),
-      event_type_(event_type) {
-  net_log_.BeginEvent(event_type, params);
-}
-
-ScopedNetLogEvent::~ScopedNetLogEvent() {
-  net_log_.EndEvent(event_type_, end_event_params_);
-}
-
-void ScopedNetLogEvent::SetEndEventParameters(
-    const scoped_refptr<NetLog::EventParameters>& end_event_params) {
-  DCHECK(!end_event_params_.get());
-  end_event_params_ = end_event_params;
-}
-
-const BoundNetLog& ScopedNetLogEvent::net_log() const {
-  return net_log_;
-}
-
 }  // namespace net
diff --git a/net/base/net_log.h b/net/base/net_log.h
index 777bdf5..d0eee53 100644
--- a/net/base/net_log.h
+++ b/net/base/net_log.h
@@ -9,11 +9,14 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "net/base/net_export.h"
 
 namespace base {
+class DictionaryValue;
 class TimeTicks;
 class Value;
 }
@@ -29,6 +32,7 @@ namespace net {
 // is usually accessed through a BoundNetLog, which will always pass in a
 // specific source ID.
 //
+// All NetLog methods must be thread-safe.
 class NET_EXPORT NetLog {
  public:
   enum EventType {
@@ -54,6 +58,26 @@ class NET_EXPORT NetLog {
     SOURCE_COUNT
   };
 
+  // Specifies the granularity of events that should be emitted to the log.
+  enum LogLevel {
+    // Log everything possible, even if it is slow and memory expensive.
+    // Includes logging of transferred bytes.
+    LOG_ALL,
+
+    // Log all events, but do not include the actual transferred bytes as
+    // parameters for bytes sent/received events.
+    LOG_ALL_BUT_BYTES,
+
+    // Only log events which are cheap, and don't consume much memory.
+    LOG_BASIC,
+  };
+
+  // A callback function that return a Value representation of the parameters
+  // associated with an event.  If called, it will be called synchonously,
+  // so it need not have owning references.  May be called more than once, or
+  // not at all.  May return NULL.
+  typedef base::Callback<base::Value*(LogLevel)> ParametersCallback;
+
   // Identifies the entity that generated this log. The |id| field should
   // uniquely identify the source, and is used by log observers to infer
   // message groupings. Can use NetLog::NextID() to create unique IDs.
@@ -64,9 +88,24 @@ class NET_EXPORT NetLog {
     Source(SourceType type, uint32 id) : type(type), id(id) {}
     bool is_valid() const { return id != kInvalidId; }
 
-    // The caller takes ownership of the returned Value*.
+    // Obsolete.  The caller takes ownership of the returned Value*.
+    // TODO(mmenke):  Remove this.
     base::Value* ToValue() const;
 
+    // Adds the source to a DictionaryValue containing event parameters,
+    // using the name "source_dependency".
+    void AddToEventParameters(base::DictionaryValue* event_params) const;
+
+    // Returns a callback that returns a dictionary with a single entry
+    // named "source_dependecy" that describes |this|.
+    ParametersCallback ToEventParametersCallback() const;
+
+    // Attempts to extract a Source from a set of event parameters.  Returns
+    // true and writes the result to |source| on success.  Returns false and
+    // makes |source| an invalid source on failure.
+    // TODO(mmenke):  Long term, we want to remove this.
+    static bool FromEventParameters(base::Value* event_params, Source* source);
+
     SourceType type;
     uint32 id;
   };
@@ -74,6 +113,8 @@ class NET_EXPORT NetLog {
   // Base class for associating additional parameters with an event. Log
   // observers need to know what specific derivations of EventParameters a
   // particular EventType uses, in order to get at the individual components.
+  // This class is obsolete.  New code should use ParametersCallbacks.
+  // TODO(mmenke):  Update users of this class and get rid of it.
   class NET_EXPORT EventParameters
       : public base::RefCountedThreadSafe<EventParameters> {
    public:
@@ -93,18 +134,40 @@ class NET_EXPORT NetLog {
     DISALLOW_COPY_AND_ASSIGN(EventParameters);
   };
 
-  // Specifies the granularity of events that should be emitted to the log.
-  enum LogLevel {
-    // Log everything possible, even if it is slow and memory expensive.
-    // Includes logging of transferred bytes.
-    LOG_ALL,
+  class NET_EXPORT Entry {
+   public:
+    Entry(EventType type,
+          Source source,
+          EventPhase phase,
+          const ParametersCallback* parameters_callback,
+          LogLevel log_level);
+    ~Entry();
+
+    EventType type() const { return type_; }
+    Source source() const { return source_; }
+    EventPhase phase() const { return phase_; }
+
+    // Serializes the specified event to a Value.  The Value also includes the
+    // current time.  Caller takes ownership of returned Value.
+    base::Value* ToValue() const;
 
-    // Log all events, but do not include the actual transferred bytes as
-    // parameters for bytes sent/received events.
-    LOG_ALL_BUT_BYTES,
+    // Returns the parameters as a Value.  Returns NULL if there are no
+    // parameters.  Caller takes ownership of returned Value.
+    base::Value* ParametersToValue() const;
 
-    // Only log events which are cheap, and don't consume much memory.
-    LOG_BASIC,
+   private:
+    const EventType type_;
+    const Source source_;
+    const EventPhase phase_;
+    const ParametersCallback* parameters_callback_;
+
+    // Log level when the event occurred.
+    const LogLevel log_level_;
+
+    // It is not safe to copy this class, since |parameters_callback_| may
+    // include pointers that become stale immediately after the event is added,
+    // even if the code were modified to keep its own copy of the callback.
+    DISALLOW_COPY_AND_ASSIGN(Entry);
   };
 
   // An observer, that must ensure its own thread safety, for events
@@ -136,21 +199,7 @@ class NET_EXPORT NetLog {
     //
     // It is illegal for an Observer to call any NetLog or
     // NetLog::Observer functions in response to a call to OnAddEntry.
-    //
-    // |type| - The type of the event.
-    // |time| - The time when the event occurred.
-    // |source| - The source that generated the event.
-    // |phase| - An optional parameter indicating whether this is the start/end
-    //           of an action.
-    // |params| - Optional (may be NULL) parameters for this event.
-    //            The specific subclass of EventParameters is defined
-    //            by the contract for events of this |type|.
-    // TODO(eroman): Take a scoped_refptr<EventParameters> instead.
-    virtual void OnAddEntry(EventType type,
-                            const base::TimeTicks& time,
-                            const Source& source,
-                            EventPhase phase,
-                            EventParameters* params) = 0;
+    virtual void OnAddEntry(const Entry& entry) = 0;
 
    protected:
     virtual ~ThreadSafeObserver();
@@ -169,10 +218,18 @@ class NET_EXPORT NetLog {
   virtual ~NetLog() {}
 
   // Emits a global event to the log stream, with its own unique source ID.
+  void AddGlobalEntry(EventType type);
+  void AddGlobalEntry(EventType type,
+                      const NetLog::ParametersCallback& parameters_callback);
+
+  // Older, obsolete version of above functions.  Use the ParametersCallback
+  // versions instead.
+  // TODO(mmenke):  Remove this.
   void AddGlobalEntry(EventType type,
                       const scoped_refptr<EventParameters>& params);
 
-  // Returns a unique ID which can be used as a source ID.
+  // Returns a unique ID which can be used as a source ID.  All returned IDs
+  // will be unique and greater than 0.
   virtual uint32 NextID() = 0;
 
   // Returns the logging level for this NetLog. This is used to avoid computing
@@ -226,22 +283,23 @@ class NET_EXPORT NetLog {
   // Returns a C-String symbolic name for |event_phase|.
   static const char* EventPhaseToString(EventPhase event_phase);
 
-  // Serializes the specified event to a DictionaryValue.
-  // If |use_strings| is true, uses strings rather than numeric ids.
-  static base::Value* EntryToDictionaryValue(NetLog::EventType type,
-                                             const base::TimeTicks& time,
-                                             const NetLog::Source& source,
-                                             NetLog::EventPhase phase,
-                                             NetLog::EventParameters* params,
-                                             bool use_strings);
+  // Returns true if |log_level| indicates the actual bytes transferred should
+  // be logged.  This is only the case when |log_level| is LOG_ALL.
+  static bool IsLoggingBytes(LogLevel log_level);
+
+  // Returns true if |log_level| indicates that all events should be logged,
+  // including frequently occuring ones that may impact performances.
+  // This is the case when |log_level| is LOG_ALL or LOG_ALL_BUT_BYTES.
+  static bool IsLoggingAllEvents(LogLevel log_level);
+
+  // Creates a ParametersCallback that encapsulates a single integer.
+  // Warning: |name| must remain valid for the life of the callback.
+  static ParametersCallback IntegerCallback(const char* name, int value);
 
  protected:
-  // This is the internal function used by AddGlobalEntry and BoundNetLogs.
-  virtual void AddEntry(
-      EventType type,
-      const Source& source,
-      EventPhase phase,
-      const scoped_refptr<NetLog::EventParameters>& params) = 0;
+  // Child classes should respond to the new entry here.  This includes
+  // creating the Entry object and alerting their observers.
+  virtual void OnAddEntry(const Entry& entry) = 0;
 
   // Subclasses must call these in the corresponding functions to set an
   // observer's |net_log_| and |log_level_| values.
@@ -253,6 +311,11 @@ class NET_EXPORT NetLog {
  private:
   friend class BoundNetLog;
 
+  void AddEntry(EventType type,
+                const Source& source,
+                EventPhase phase,
+                const NetLog::ParametersCallback* parameters_callback);
+
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };
 
@@ -262,15 +325,32 @@ class NET_EXPORT BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
 
-  // Convenience methods that call through to the NetLog, passing in the
-  // currently bound source.
+  // Add a log entry to the NetLog for the bound source.
+  void AddEntry(NetLog::EventType type, NetLog::EventPhase phase) const;
   void AddEntry(NetLog::EventType type,
                 NetLog::EventPhase phase,
-                const scoped_refptr<NetLog::EventParameters>& params) const;
+                const NetLog::ParametersCallback& get_parameters) const;
 
-  // Convenience methods that call through to the NetLog, passing in the
-  // currently bound source, current time, and a fixed "capture phase"
+  // Convenience methods that call AddEntry with a fixed "capture phase"
   // (begin, end, or none).
+  void BeginEvent(NetLog::EventType type) const;
+  void BeginEvent(NetLog::EventType type,
+                  const NetLog::ParametersCallback& get_parameters) const;
+
+  void EndEvent(NetLog::EventType type) const;
+  void EndEvent(NetLog::EventType type,
+                const NetLog::ParametersCallback& get_parameters) const;
+
+  void AddEvent(NetLog::EventType type) const;
+  void AddEvent(NetLog::EventType type,
+                const NetLog::ParametersCallback& get_parameters) const;
+
+  // Obsolete versions of the above functions.
+  // Use the ParametersCallback versions of these functions instead.
+  // TODO(mmenke):  Remove these.
+  void AddEntry(NetLog::EventType type,
+                NetLog::EventPhase phase,
+                const scoped_refptr<NetLog::EventParameters>& params) const;
   void AddEvent(NetLog::EventType event_type,
                 const scoped_refptr<NetLog::EventParameters>& params) const;
   void BeginEvent(NetLog::EventType event_type,
@@ -299,10 +379,10 @@ class NET_EXPORT BoundNetLog {
 
   NetLog::LogLevel GetLogLevel() const;
 
-  // Returns true if the log level is LOG_ALL.
+  // Shortcut for NetLog::IsLoggingBytes(this->GetLogLevel()).
   bool IsLoggingBytes() const;
 
-  // Returns true if the log level is LOG_ALL or LOG_ALL_BUT_BYTES.
+  // Shortcut for NetLog::IsLoggingAllEvents(this->GetLogLevel()).
   bool IsLoggingAllEvents() const;
 
   // Helper to create a BoundNetLog given a NetLog and a SourceType. Takes care
@@ -321,6 +401,9 @@ class NET_EXPORT BoundNetLog {
   NetLog* net_log_;
 };
 
+// All the classes below are obsolete.  New code should use ParametersCallbacks.
+// TODO(mmenke):  Update users these classes and get rid of them.
+
 // NetLogStringParameter is a subclass of EventParameters that encapsulates a
 // single std::string parameter.
 class NET_EXPORT NetLogStringParameter : public NetLog::EventParameters {
@@ -386,30 +469,6 @@ class NET_EXPORT NetLogSourceParameter : public NetLog::EventParameters {
   const NetLog::Source value_;
 };
 
-// ScopedNetLogEvent logs a begin event on creation, and the corresponding end
-// event on destruction.
-class NET_EXPORT_PRIVATE ScopedNetLogEvent {
- public:
-  ScopedNetLogEvent(const BoundNetLog& net_log,
-                    NetLog::EventType event_type,
-                    const scoped_refptr<NetLog::EventParameters>& params);
-
-  ~ScopedNetLogEvent();
-
-  // Sets the parameters that will logged on object destruction.  Can be called
-  // at most once for a given ScopedNetLogEvent object.  If not called, the end
-  // event will have no parameters.
-  void SetEndEventParameters(
-      const scoped_refptr<NetLog::EventParameters>& end_event_params);
-
-  const BoundNetLog& net_log() const;
-
- private:
-  BoundNetLog net_log_;
-  const NetLog::EventType event_type_;
-  scoped_refptr<NetLog::EventParameters> end_event_params_;
-};
-
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_
diff --git a/net/base/net_log_unittest.cc b/net/base/net_log_unittest.cc
deleted file mode 100644
index 3454df3..0000000
--- a/net/base/net_log_unittest.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// 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 "base/memory/scoped_ptr.h"
-#include "net/base/capturing_net_log.h"
-#include "net/base/net_log.h"
-#include "net/base/net_log_unittest.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-
-namespace {
-
-TEST(NetLog, ScopedNetLogEventTest) {
-  CapturingNetLog log;
-  BoundNetLog net_log(BoundNetLog::Make(&log, NetLog::SOURCE_URL_REQUEST));
-
-  scoped_ptr<ScopedNetLogEvent> net_log_event(
-      new ScopedNetLogEvent(net_log, NetLog::TYPE_REQUEST_ALIVE, NULL));
-
-  CapturingNetLog::CapturedEntryList entries;
-  log.GetEntries(&entries);
-  EXPECT_EQ(1u, entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_REQUEST_ALIVE));
-
-  net_log_event.reset();
-  log.GetEntries(&entries);
-  EXPECT_EQ(2u, entries.size());
-  EXPECT_TRUE(LogContainsEndEvent(entries, 1, NetLog::TYPE_REQUEST_ALIVE));
-}
-
-}  // namespace
-
-}  // namespace net
diff --git a/net/http/http_net_log_params.cc b/net/http/http_net_log_params.cc
deleted file mode 100644
index 989d30d..0000000
--- a/net/http/http_net_log_params.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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/http/http_net_log_params.h"
-
-#include "base/stringprintf.h"
-#include "base/values.h"
-#include "net/http/http_response_headers.h"
-
-namespace net {
-
-NetLogHttpRequestParameter::NetLogHttpRequestParameter(
-    const std::string& line,
-    const HttpRequestHeaders& headers)
-    : line_(line) {
-  headers_.CopyFrom(headers);
-}
-
-Value* NetLogHttpRequestParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  dict->SetString("line", line_);
-  ListValue* headers = new ListValue();
-  HttpRequestHeaders::Iterator iterator(headers_);
-  while (iterator.GetNext()) {
-    headers->Append(
-        new StringValue(base::StringPrintf("%s: %s",
-                                           iterator.name().c_str(),
-                                           iterator.value().c_str())));
-  }
-  dict->Set("headers", headers);
-  return dict;
-}
-
-NetLogHttpRequestParameter::~NetLogHttpRequestParameter() {}
-
-NetLogHttpResponseParameter::NetLogHttpResponseParameter(
-    const scoped_refptr<HttpResponseHeaders>& headers)
-    : headers_(headers) {}
-
-Value* NetLogHttpResponseParameter::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
-  ListValue* headers = new ListValue();
-  headers->Append(new StringValue(headers_->GetStatusLine()));
-  void* iterator = NULL;
-  std::string name;
-  std::string value;
-  while (headers_->EnumerateHeaderLines(&iterator, &name, &value)) {
-    headers->Append(
-        new StringValue(base::StringPrintf("%s: %s", name.c_str(),
-                                           value.c_str())));
-  }
-  dict->Set("headers", headers);
-  return dict;
-}
-
-NetLogHttpResponseParameter::~NetLogHttpResponseParameter() {}
-
-}  // namespace net
diff --git a/net/http/http_net_log_params.h b/net/http/http_net_log_params.h
deleted file mode 100644
index daa4770..0000000
--- a/net/http/http_net_log_params.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (c) 2011 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.
-
-#ifndef NET_HTTP_HTTP_NET_LOG_PARAMS_H_
-#define NET_HTTP_HTTP_NET_LOG_PARAMS_H_
-#pragma once
-
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/memory/ref_counted.h"
-#include "net/base/net_log.h"
-#include "net/http/http_request_headers.h"
-
-namespace base {
-class Value;
-}
-
-namespace net {
-
-class HttpResponseHeaders;
-
-class NetLogHttpRequestParameter : public NetLog::EventParameters {
- public:
-  NetLogHttpRequestParameter(const std::string& line,
-                             const HttpRequestHeaders& headers);
-
-  const HttpRequestHeaders& GetHeaders() const {
-    return headers_;
-  }
-
-  const std::string& GetLine() const {
-    return line_;
-  }
-
-  // NetLog::EventParameters
-  virtual base::Value* ToValue() const OVERRIDE;
-
- private:
-  virtual ~NetLogHttpRequestParameter();
-
-  const std::string line_;
-  HttpRequestHeaders headers_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetLogHttpRequestParameter);
-};
-
-class NetLogHttpResponseParameter : public NetLog::EventParameters {
- public:
-  explicit NetLogHttpResponseParameter(
-      const scoped_refptr<HttpResponseHeaders>& headers);
-
-  const HttpResponseHeaders& GetHeaders() const {
-    return *headers_;
-  }
-
-  // NetLog::EventParameters
-  virtual base::Value* ToValue() const OVERRIDE;
-
- private:
-  virtual ~NetLogHttpResponseParameter();
-
-  const scoped_refptr<HttpResponseHeaders> headers_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetLogHttpResponseParameter);
-};
-
-}  // namespace net
-
-#endif  // NET_HTTP_HTTP_NET_LOG_PARAMS_H_
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 9babefb..03de2a4 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -36,7 +36,6 @@
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_chunked_decoder.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
@@ -872,11 +871,9 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
         "Net.HttpResponseCode_Nxx_MainFrame", response_code/100, 10);
   }
 
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS,
-        make_scoped_refptr(new NetLogHttpResponseParameter(response_.headers)));
-  }
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS,
+      base::Bind(&HttpResponseHeaders::NetLogCallback, response_.headers));
 
   if (response_.headers->GetParsedHttpVersion() < HttpVersion(1, 0)) {
     // HTTP/0.9 doesn't support the PUT method, so lack of response headers
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index b7c3023..838c54f 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -37,7 +37,6 @@
 #include "net/http/http_auth_handler_mock.h"
 #include "net/http/http_auth_handler_ntlm.h"
 #include "net/http/http_basic_stream.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_server_properties_impl.h"
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index c9da692..84bd7d3 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -37,7 +37,6 @@
 #include "net/http/http_auth_handler_mock.h"
 #include "net/http/http_auth_handler_ntlm.h"
 #include "net/http/http_basic_stream.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_server_properties_impl.h"
diff --git a/net/http/http_proxy_client_socket.cc b/net/http/http_proxy_client_socket.cc
index d801da0..f09241a 100644
--- a/net/http/http_proxy_client_socket.cc
+++ b/net/http/http_proxy_client_socket.cc
@@ -15,7 +15,6 @@
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_basic_stream.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
@@ -406,12 +405,12 @@ int HttpProxyClientSocket::DoSendRequest() {
       auth_->AddAuthorizationHeader(&authorization_headers);
     BuildTunnelRequest(request_, authorization_headers, endpoint_,
                        &request_line_, &request_headers_);
-    if (net_log_.IsLoggingAllEvents()) {
-      net_log_.AddEvent(
-          NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
-          make_scoped_refptr(new NetLogHttpRequestParameter(
-              request_line_, request_headers_)));
-    }
+
+    net_log_.AddEvent(
+        NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+        base::Bind(&HttpRequestHeaders::NetLogCallback,
+                   base::Unretained(&request_headers_),
+                   &request_line_));
   }
 
   parser_buf_ = new GrowableIOBuffer();
@@ -442,11 +441,9 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
   if (response_.headers->GetParsedHttpVersion() < HttpVersion(1, 0))
     return ERR_TUNNEL_CONNECTION_FAILED;
 
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
-        make_scoped_refptr(new NetLogHttpResponseParameter(response_.headers)));
-  }
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
+      base::Bind(&HttpResponseHeaders::NetLogCallback, response_.headers));
 
   switch (response_.headers->response_code()) {
     case 200:  // OK
diff --git a/net/http/http_request_headers.cc b/net/http/http_request_headers.cc
index fcd2dce..3669140 100644
--- a/net/http/http_request_headers.cc
+++ b/net/http/http_request_headers.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -8,6 +8,7 @@
 #include "base/stringprintf.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
+#include "base/values.h"
 #include "net/http/http_util.h"
 
 namespace net {
@@ -182,6 +183,54 @@ std::string HttpRequestHeaders::ToString() const {
   return output;
 }
 
+Value* HttpRequestHeaders::NetLogCallback(
+    const std::string* request_line,
+    NetLog::LogLevel /* log_level */) const {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("line", *request_line);
+  ListValue* headers = new ListValue();
+  for (HeaderVector::const_iterator it = headers_.begin();
+       it != headers_.end(); ++it) {
+    headers->Append(
+        new StringValue(base::StringPrintf("%s: %s",
+                                           it->key.c_str(),
+                                           it->value.c_str())));
+  }
+  dict->Set("headers", headers);
+  return dict;
+}
+
+// static
+bool HttpRequestHeaders::FromNetLogParam(const base::Value* event_param,
+                                         HttpRequestHeaders* headers,
+                                         std::string* request_line) {
+  headers->Clear();
+  *request_line = "";
+
+  const base::DictionaryValue* dict;
+  base::ListValue* header_list;
+
+  if (!event_param ||
+      !event_param->GetAsDictionary(&dict) ||
+      !dict->GetList("headers", &header_list) ||
+      !dict->GetString("line", request_line)) {
+    return false;
+  }
+
+  for (base::ListValue::const_iterator it = header_list->begin();
+       it != header_list->end();
+       ++it) {
+    std::string header_line;
+    if (!(*it)->GetAsString(&header_line)) {
+      headers->Clear();
+      *request_line = "";
+      return false;
+    }
+    headers->AddHeaderFromString(header_line);
+  }
+  return true;
+}
+
 HttpRequestHeaders::HeaderVector::iterator
 HttpRequestHeaders::FindHeader(const base::StringPiece& key) {
   for (HeaderVector::iterator it = headers_.begin();
diff --git a/net/http/http_request_headers.h b/net/http/http_request_headers.h
index cfb2748..675e1e0 100644
--- a/net/http/http_request_headers.h
+++ b/net/http/http_request_headers.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 //
@@ -17,6 +17,7 @@
 #include "base/basictypes.h"
 #include "base/string_piece.h"
 #include "net/base/net_export.h"
+#include "net/base/net_log.h"
 
 namespace net {
 
@@ -145,6 +146,20 @@ class NET_EXPORT HttpRequestHeaders {
   // line, and adds the trailing "\r\n".
   std::string ToString() const;
 
+  // Takes in the request line and returns a Value for use with the NetLog
+  // containing both the request line and all headers fields.
+  base::Value* NetLogCallback(const std::string* request_line,
+                              NetLog::LogLevel log_level) const;
+
+  // Takes in a Value created by the above function, and attempts to extract the
+  // request line and create a copy of the original headers.  Returns true on
+  // success.  On failure, clears |headers| and |request_line|.
+  // TODO(mmenke):  Long term, we want to remove this, and migrate external
+  //                consumers to be NetworkDelegates.
+  static bool FromNetLogParam(const base::Value* event_param,
+                              HttpRequestHeaders* headers,
+                              std::string* request_line);
+
  private:
   HeaderVector::iterator FindHeader(const base::StringPiece& key);
   HeaderVector::const_iterator FindHeader(const base::StringPiece& key) const;
@@ -152,9 +167,9 @@ class NET_EXPORT HttpRequestHeaders {
   HeaderVector headers_;
 
   // Allow the copy construction and operator= to facilitate copying in
-  // HttpRequestInfo.
+  // HttpRequestHeaders.
   // TODO(willchan): Investigate to see if we can remove the need to copy
-  // HttpRequestInfo.
+  // HttpRequestHeaders.
   // DISALLOW_COPY_AND_ASSIGN(HttpRequestHeaders);
 };
 
diff --git a/net/http/http_request_headers_unittest.cc b/net/http/http_request_headers_unittest.cc
index 384ceeb..6346f50 100644
--- a/net/http/http_request_headers_unittest.cc
+++ b/net/http/http_request_headers_unittest.cc
@@ -1,9 +1,10 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_request_headers.h"
 
+#include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -163,6 +164,24 @@ TEST(HttpRequestHeaders, CopyFrom) {
   EXPECT_EQ("B: b\r\nC: c\r\n\r\n", headers.ToString());
 }
 
+TEST(HttpRequestHeaders, ToNetLogParamAndBackAgain) {
+  HttpRequestHeaders headers;
+  headers.SetHeader("B", "b");
+  headers.SetHeader("A", "a");
+  std::string request_line("GET /stuff");
+
+  scoped_ptr<base::Value> event_param(
+      headers.NetLogCallback(&request_line, NetLog::LOG_ALL_BUT_BYTES));
+  HttpRequestHeaders headers2;
+  std::string request_line2;
+
+  ASSERT_TRUE(HttpRequestHeaders::FromNetLogParam(event_param.get(),
+                                                  &headers2,
+                                                  &request_line2));
+  EXPECT_EQ(request_line, request_line2);
+  EXPECT_EQ("B: b\r\nA: a\r\n\r\n", headers2.ToString());
+}
+
 }  // namespace
 
 }  // namespace net
diff --git a/net/http/http_response_headers.cc b/net/http/http_response_headers.cc
index c03fbe9..6fe8e2f 100644
--- a/net/http/http_response_headers.cc
+++ b/net/http/http_response_headers.cc
@@ -14,10 +14,12 @@
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
+#include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "base/values.h"
 #include "net/base/escape.h"
 #include "net/http/http_util.h"
 
@@ -1306,6 +1308,55 @@ bool HttpResponseHeaders::GetContentRange(int64* first_byte_position,
   return true;
 }
 
+Value* HttpResponseHeaders::NetLogCallback(
+    NetLog::LogLevel /* log_level */) const {
+  DictionaryValue* dict = new DictionaryValue();
+  ListValue* headers = new ListValue();
+  headers->Append(new StringValue(GetStatusLine()));
+  void* iterator = NULL;
+  std::string name;
+  std::string value;
+  while (EnumerateHeaderLines(&iterator, &name, &value)) {
+    headers->Append(
+      new StringValue(base::StringPrintf("%s: %s",
+                                         name.c_str(),
+                                         value.c_str())));
+  }
+  dict->Set("headers", headers);
+  return dict;
+}
+
+// static
+bool HttpResponseHeaders::FromNetLogParam(
+    const base::Value* event_param,
+    scoped_refptr<HttpResponseHeaders>* http_response_headers) {
+  http_response_headers->release();
+
+  const base::DictionaryValue* dict;
+  base::ListValue* header_list;
+
+  if (!event_param ||
+      !event_param->GetAsDictionary(&dict) ||
+      !dict->GetList("headers", &header_list)) {
+    return false;
+  }
+
+  std::string raw_headers;
+  for (base::ListValue::const_iterator it = header_list->begin();
+       it != header_list->end();
+       ++it) {
+    std::string header_line;
+    if (!(*it)->GetAsString(&header_line))
+      return false;
+
+    raw_headers.append(header_line);
+    raw_headers.push_back('\0');
+  }
+  raw_headers.push_back('\0');
+  *http_response_headers = new HttpResponseHeaders(raw_headers);
+  return true;
+}
+
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
diff --git a/net/http/http_response_headers.h b/net/http/http_response_headers.h
index 6fbc0bb..1490872 100644
--- a/net/http/http_response_headers.h
+++ b/net/http/http_response_headers.h
@@ -13,6 +13,7 @@
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/net_export.h"
+#include "net/base/net_log.h"
 #include "net/http/http_version.h"
 
 class Pickle;
@@ -244,6 +245,18 @@ class NET_EXPORT HttpResponseHeaders
   // Returns true if the response is chunk-encoded.
   bool IsChunkEncoded() const;
 
+  // Creates a Value for use with the NetLog containing the response headers.
+  base::Value* NetLogCallback(NetLog::LogLevel log_level) const;
+
+  // Takes in a Value created by the above function, and attempts to create a
+  // copy of the original headers.  Returns true on success.  On failure,
+  // clears |http_response_headers|.
+  // TODO(mmenke):  Long term, we want to remove this, and migrate external
+  //                consumers to be NetworkDelegates.
+  static bool FromNetLogParam(
+      const base::Value* event_param,
+      scoped_refptr<HttpResponseHeaders>* http_response_headers);
+
   // Returns the HTTP response code.  This is 0 if the response code text seems
   // to exist but could not be parsed.  Otherwise, it defaults to 200 if the
   // response code is not found in the raw headers.
diff --git a/net/http/http_response_headers_unittest.cc b/net/http/http_response_headers_unittest.cc
index f7c5e6f5..d93c5bd 100644
--- a/net/http/http_response_headers_unittest.cc
+++ b/net/http/http_response_headers_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/basictypes.h"
 #include "base/pickle.h"
 #include "base/time.h"
+#include "base/values.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -1756,3 +1757,30 @@ TEST(HttpResponseHeadersTest, ReplaceStatus) {
     EXPECT_EQ(std::string(tests[i].expected_headers), resulting_headers);
   }
 }
+
+TEST(HttpResponseHeadersTest, ToNetLogParamAndBackAgain) {
+  std::string headers("HTTP/1.1 404\n"
+                      "Content-Length: 450\n"
+                      "Connection: keep-alive\n");
+  HeadersToRaw(&headers);
+  scoped_refptr<net::HttpResponseHeaders> parsed(
+      new net::HttpResponseHeaders(headers));
+
+  scoped_ptr<base::Value> event_param(
+      parsed->NetLogCallback(net::NetLog::LOG_ALL_BUT_BYTES));
+  scoped_refptr<net::HttpResponseHeaders> recreated;
+
+  ASSERT_TRUE(net::HttpResponseHeaders::FromNetLogParam(event_param.get(),
+                                                        &recreated));
+  ASSERT_TRUE(recreated.get());
+  EXPECT_EQ(parsed->GetHttpVersion(), recreated->GetHttpVersion());
+  EXPECT_EQ(parsed->response_code(), recreated->response_code());
+  EXPECT_EQ(parsed->GetContentLength(), recreated->GetContentLength());
+  EXPECT_EQ(parsed->IsKeepAlive(), recreated->IsKeepAlive());
+
+  std::string normalized_parsed;
+  parsed->GetNormalizedHeaders(&normalized_parsed);
+  std::string normalized_recreated;
+  parsed->GetNormalizedHeaders(&normalized_recreated);
+  EXPECT_EQ(normalized_parsed, normalized_recreated);
+}
diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc
index b56bd08..7fda009 100644
--- a/net/http/http_stream_parser.cc
+++ b/net/http/http_stream_parser.cc
@@ -4,6 +4,7 @@
 
 #include "net/http/http_stream_parser.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ -11,7 +12,6 @@
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ssl_cert_request_info.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
@@ -197,12 +197,12 @@ int HttpStreamParser::SendRequest(const std::string& request_line,
   DCHECK(!callback.is_null());
   DCHECK(response);
 
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
-        make_scoped_refptr(new NetLogHttpRequestParameter(
-            request_line, headers)));
-  }
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
+      base::Bind(&HttpRequestHeaders::NetLogCallback,
+                 base::Unretained(&headers),
+                 &request_line));
+
   DVLOG(1) << __FUNCTION__ << "()"
            << " request_line = \"" << request_line << "\""
            << " headers = \"" << headers.ToString() << "\"";
diff --git a/net/net.gyp b/net/net.gyp
index 541cec6..93a6f8d 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -456,8 +456,6 @@
         'http/http_content_disposition.h',
         'http/http_chunked_decoder.cc',
         'http/http_chunked_decoder.h',
-        'http/http_net_log_params.cc',
-        'http/http_net_log_params.h',
         'http/http_network_layer.cc',
         'http/http_network_layer.h',
         'http/http_network_session.cc',
@@ -1070,7 +1068,6 @@
         'base/mock_filter_context.cc',
         'base/mock_filter_context.h',
         'base/multi_threaded_cert_verifier_unittest.cc',
-        'base/net_log_unittest.cc',
         'base/net_log_unittest.h',
         'base/net_util_unittest.cc',
         'base/network_change_notifier_linux_unittest.cc',
diff --git a/net/socket/ssl_client_socket_nss.cc b/net/socket/ssl_client_socket_nss.cc
index a9c7bba..ff2f259 100644
--- a/net/socket/ssl_client_socket_nss.cc
+++ b/net/socket/ssl_client_socket_nss.cc
@@ -382,6 +382,17 @@ void DestroyCertificates(CERTCertificate** certs, size_t len) {
     CERT_DestroyCertificate(certs[i]);
 }
 
+// Helper function to make it possible to log events from within the
+// SSLClientSocketNSS::Core.  Can't use Bind with BoundNetLog::AddEntry directly
+// on Windows because it is overloaded.
+void AddLogEvent(BoundNetLog* net_log,
+                 NetLog::EventType event_type,
+                 const scoped_refptr<NetLog::EventParameters>& event_params) {
+  if (!net_log)
+    return;
+  net_log->AddEvent(event_type, event_params);
+}
+
 // Helper function to make it easier to call BoundNetLog::AddByteTransferEvent
 // from within the SSLClientSocketNSS::Core.
 // AddByteTransferEvent expects to receive a const char*, which within the
@@ -1292,7 +1303,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
 
   core->PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+      base::Bind(&AddLogEvent, core->weak_net_log_,
                  NetLog::TYPE_SSL_CLIENT_CERT_REQUESTED,
                  scoped_refptr<NetLog::EventParameters>()));
 
@@ -1339,7 +1350,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
           // number collision. See crbug.com/97355.
           core->PostOrRunCallback(
               FROM_HERE,
-              base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+              base::Bind(&AddLogEvent, core->weak_net_log_,
                          NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                          make_scoped_refptr(
                              new NetLogIntegerParameter("cert_count", 0))));
@@ -1362,7 +1373,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
             CERT_DestroyCertList(cert_chain);
             core->PostOrRunCallback(
                 FROM_HERE,
-                base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+                base::Bind(&AddLogEvent, core->weak_net_log_,
                            NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                            make_scoped_refptr(
                                new NetLogIntegerParameter("cert_count", 0))));
@@ -1385,7 +1396,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
         int cert_count = 1 + intermediates.size();
         core->PostOrRunCallback(
             FROM_HERE,
-            base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+            base::Bind(&AddLogEvent, core->weak_net_log_,
                        NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                        make_scoped_refptr(
                            new NetLogIntegerParameter("cert_count",
@@ -1398,7 +1409,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
     // Send no client certificate.
     core->PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+        base::Bind(&AddLogEvent, core->weak_net_log_,
                    NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                    make_scoped_refptr(
                        new NetLogIntegerParameter("cert_count", 0))));
@@ -1420,7 +1431,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
 
     core->PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+        base::Bind(&AddLogEvent, core->weak_net_log_,
                    NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                    make_scoped_refptr(
                        new NetLogIntegerParameter("cert_count", 0))));
@@ -1565,7 +1576,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
         }
         core->PostOrRunCallback(
             FROM_HERE,
-            base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+            base::Bind(&AddLogEvent, core->weak_net_log_,
                        NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                        make_scoped_refptr(
                            new NetLogIntegerParameter("cert_count",
@@ -1589,7 +1600,7 @@ SECStatus SSLClientSocketNSS::Core::PlatformClientAuthHandler(
     // Send no client certificate.
     core->PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+        base::Bind(&AddLogEvent, core->weak_net_log_,
                    NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                    make_scoped_refptr(
                        new NetLogIntegerParameter("cert_count", 0))));
@@ -1644,7 +1655,7 @@ SECStatus SSLClientSocketNSS::Core::ClientAuthHandler(
 
   core->PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+      base::Bind(&AddLogEvent, core->weak_net_log_,
                  NetLog::TYPE_SSL_CLIENT_CERT_REQUESTED,
                  scoped_refptr<NetLog::EventParameters>()));
 
@@ -1676,7 +1687,7 @@ SECStatus SSLClientSocketNSS::Core::ClientAuthHandler(
         // NSS will construct the certificate chain.
         core->PostOrRunCallback(
             FROM_HERE,
-            base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+            base::Bind(&AddLogEvent, core->weak_net_log_,
                        NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                        make_scoped_refptr(
                            new NetLogIntegerParameter("cert_count", -1))));
@@ -1688,7 +1699,7 @@ SECStatus SSLClientSocketNSS::Core::ClientAuthHandler(
     // Send no client certificate.
     core->PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, core->weak_net_log_,
+        base::Bind(&AddLogEvent, core->weak_net_log_,
                    NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                    make_scoped_refptr(
                        new NetLogIntegerParameter("cert_count", 0))));
@@ -1939,7 +1950,7 @@ int SSLClientSocketNSS::Core::DoReadLoop(int result) {
     int rv = ERR_UNEXPECTED;
     PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+        base::Bind(&AddLogEvent, weak_net_log_,
                    NetLog::TYPE_SSL_READ_ERROR,
                    make_scoped_refptr(new SSLErrorParams(rv, 0))));
     return rv;
@@ -1968,7 +1979,7 @@ int SSLClientSocketNSS::Core::DoWriteLoop(int result) {
     int rv = ERR_UNEXPECTED;
     PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+        base::Bind(&AddLogEvent, weak_net_log_,
                    NetLog::TYPE_SSL_READ_ERROR,
                    make_scoped_refptr(new SSLErrorParams(rv, 0))));
     return rv;
@@ -2003,7 +2014,7 @@ int SSLClientSocketNSS::Core::DoHandshake() {
       net_error = ERR_SSL_CLIENT_AUTH_CERT_NEEDED;
       PostOrRunCallback(
           FROM_HERE,
-          base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+          base::Bind(&AddLogEvent, weak_net_log_,
                      NetLog::TYPE_SSL_HANDSHAKE_ERROR,
                      make_scoped_refptr(new SSLErrorParams(net_error, 0))));
 
@@ -2023,7 +2034,7 @@ int SSLClientSocketNSS::Core::DoHandshake() {
       net_error = ERR_SSL_PROTOCOL_ERROR;
       PostOrRunCallback(
           FROM_HERE,
-          base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+          base::Bind(&AddLogEvent, weak_net_log_,
                      NetLog::TYPE_SSL_HANDSHAKE_ERROR,
                      make_scoped_refptr(
                          new SSLErrorParams(net_error, 0))));
@@ -2084,7 +2095,7 @@ int SSLClientSocketNSS::Core::DoHandshake() {
     } else {
       PostOrRunCallback(
           FROM_HERE,
-          base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+          base::Bind(&AddLogEvent, weak_net_log_,
                      NetLog::TYPE_SSL_HANDSHAKE_ERROR,
                      make_scoped_refptr(
                          new SSLErrorParams(net_error, prerr))));
@@ -2125,7 +2136,7 @@ int SSLClientSocketNSS::Core::DoGetDBCertComplete(int result) {
 
   PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+      base::Bind(&AddLogEvent, weak_net_log_,
                  NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                  make_scoped_refptr(
                      new NetLogIntegerParameter("cert_count",
@@ -2151,7 +2162,7 @@ int SSLClientSocketNSS::Core::DoPayloadRead() {
     rv = ERR_SSL_CLIENT_AUTH_CERT_NEEDED;
     PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+        base::Bind(&AddLogEvent, weak_net_log_,
                    NetLog::TYPE_SSL_READ_ERROR,
                    make_scoped_refptr(new SSLErrorParams(rv, 0))));
     return rv;
@@ -2171,7 +2182,7 @@ int SSLClientSocketNSS::Core::DoPayloadRead() {
   rv = HandleNSSError(prerr, false);
   PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+      base::Bind(&AddLogEvent, weak_net_log_,
                  NetLog::TYPE_SSL_READ_ERROR,
                  make_scoped_refptr(new SSLErrorParams(rv, prerr))));
   return rv;
@@ -2198,7 +2209,7 @@ int SSLClientSocketNSS::Core::DoPayloadWrite() {
   rv = HandleNSSError(prerr, false);
   PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+      base::Bind(&AddLogEvent, weak_net_log_,
                  NetLog::TYPE_SSL_WRITE_ERROR,
                  make_scoped_refptr(new SSLErrorParams(rv, prerr))));
   return rv;
@@ -2446,7 +2457,7 @@ SECStatus SSLClientSocketNSS::Core::DomainBoundClientAuthHandler(
   int cert_count = (rv == SECSuccess) ? 1 : 0;
   PostOrRunCallback(
       FROM_HERE,
-      base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+      base::Bind(&AddLogEvent, weak_net_log_,
                  NetLog::TYPE_SSL_CLIENT_CERT_PROVIDED,
                  make_scoped_refptr(
                      new NetLogIntegerParameter("cert_count",
@@ -2506,7 +2517,7 @@ void SSLClientSocketNSS::Core::UpdateServerCert() {
   if (nss_handshake_state_.server_cert) {
     PostOrRunCallback(
         FROM_HERE,
-        base::Bind(&BoundNetLog::AddEvent, weak_net_log_,
+        base::Bind(&AddLogEvent, weak_net_log_,
                    NetLog::TYPE_SSL_CERTIFICATES_RECEIVED,
                    make_scoped_refptr(
                        new X509CertificateNetLogParam(
diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc
index 62dcd5e..be4e1e9 100644
--- a/net/spdy/spdy_proxy_client_socket.cc
+++ b/net/spdy/spdy_proxy_client_socket.cc
@@ -16,7 +16,6 @@
 #include "net/base/net_util.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_net_log_params.h"
 #include "net/http/http_response_headers.h"
 #include "net/spdy/spdy_http_utils.h"
 
@@ -365,12 +364,12 @@ int SpdyProxyClientSocket::DoSendRequest() {
   HttpRequestHeaders request_headers;
   BuildTunnelRequest(request_, authorization_headers, endpoint_, &request_line,
                      &request_headers);
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
-        make_scoped_refptr(new NetLogHttpRequestParameter(
-            request_line, request_headers)));
-  }
+
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      base::Bind(&HttpRequestHeaders::NetLogCallback,
+                 base::Unretained(&request_headers),
+                 &request_line));
 
   request_.extra_headers.MergeFrom(request_headers);
   linked_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
@@ -410,11 +409,9 @@ int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
     return ERR_TUNNEL_CONNECTION_FAILED;
 
   next_state_ = STATE_OPEN;
-  if (net_log_.IsLoggingAllEvents()) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
-        make_scoped_refptr(new NetLogHttpResponseParameter(response_.headers)));
-  }
+  net_log_.AddEvent(
+      NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
+      base::Bind(&HttpResponseHeaders::NetLogCallback, response_.headers));
 
   if (response_.headers->response_code() == 200) {
     return OK;
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index fef10fb..efc83c9 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -445,8 +445,8 @@ void URLRequest::StartJob(URLRequestJob* job) {
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
-      make_scoped_refptr(new URLRequestStartEventParameters(
-          url(), method_, load_flags_, priority_)));
+      base::Bind(&NetLogURLRequestStartCallback,
+                 &url(), &method_, load_flags_, priority_));
 
   job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);
diff --git a/net/url_request/url_request_netlog_params.cc b/net/url_request/url_request_netlog_params.cc
index 29143ba..67d44c3 100644
--- a/net/url_request/url_request_netlog_params.cc
+++ b/net/url_request/url_request_netlog_params.cc
@@ -5,29 +5,32 @@
 #include "net/url_request/url_request_netlog_params.h"
 
 #include "base/values.h"
+#include "googleurl/src/gurl.h"
 
 namespace net {
 
-URLRequestStartEventParameters::URLRequestStartEventParameters(
-    const GURL& url,
-    const std::string& method,
-    int load_flags,
-    RequestPriority priority)
-    : url_(url),
-      method_(method),
-      load_flags_(load_flags),
-      priority_(priority) {
-}
-
-Value* URLRequestStartEventParameters::ToValue() const {
+Value* NetLogURLRequestStartCallback(const GURL* url,
+                                     const std::string* method,
+                                     int load_flags,
+                                     RequestPriority priority,
+                                     NetLog::LogLevel /* log_level */) {
   DictionaryValue* dict = new DictionaryValue();
-  dict->SetString("url", url_.possibly_invalid_spec());
-  dict->SetString("method", method_);
-  dict->SetInteger("load_flags", load_flags_);
-  dict->SetInteger("priority", static_cast<int>(priority_));
+  dict->SetString("url", url->possibly_invalid_spec());
+  dict->SetString("method", *method);
+  dict->SetInteger("load_flags", load_flags);
+  dict->SetInteger("priority", static_cast<int>(priority));
   return dict;
 }
 
-URLRequestStartEventParameters::~URLRequestStartEventParameters() {}
+bool StartEventLoadFlagsFromEventParams(const Value* event_params,
+                                        int* load_flags) {
+  const DictionaryValue* dict;
+  if (!event_params->GetAsDictionary(&dict) ||
+      !dict->GetInteger("load_flags", load_flags)) {
+    *load_flags = 0;
+    return false;
+  }
+  return true;
+}
 
 }  // namespace net
diff --git a/net/url_request/url_request_netlog_params.h b/net/url_request/url_request_netlog_params.h
index d084f24..eb84f7c 100644
--- a/net/url_request/url_request_netlog_params.h
+++ b/net/url_request/url_request_netlog_params.h
@@ -8,44 +8,32 @@
 
 #include <string>
 
-#include "base/basictypes.h"
-#include "googleurl/src/gurl.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 
-namespace net {
-
-// Holds the parameters to emit to the NetLog when starting a URLRequest.
-class NET_EXPORT URLRequestStartEventParameters
-    : public NetLog::EventParameters {
- public:
-  URLRequestStartEventParameters(const GURL& url,
-                                 const std::string& method,
-                                 int load_flags,
-                                 RequestPriority priority);
-
-  const GURL& url() const {
-    return url_;
-  }
+class GURL;
 
-  int load_flags() const {
-    return load_flags_;
-  }
+namespace base {
+class Value;
+}
 
-  virtual base::Value* ToValue() const OVERRIDE;
-
- protected:
-  virtual ~URLRequestStartEventParameters();
-
- private:
-  const GURL url_;
-  const std::string method_;
-  const int load_flags_;
-  const RequestPriority priority_;
+namespace net {
 
-  DISALLOW_COPY_AND_ASSIGN(URLRequestStartEventParameters);
-};
+// Returns a Value containing NetLog parameters for starting a URLRequest.
+NET_EXPORT base::Value* NetLogURLRequestStartCallback(
+    const GURL* url,
+    const std::string* method,
+    int load_flags,
+    RequestPriority priority,
+    NetLog::LogLevel /* log_level */);
+
+// Attempts to extract the load flags from a Value created by the above
+// function.  On success, sets |load_flags| accordingly and returns true.
+// On failure, sets |load_flags| to 0.
+NET_EXPORT bool StartEventLoadFlagsFromEventParams(
+    const base::Value* event_params,
+    int* load_flags);
 
 }  // namespace net
 
diff --git a/remoting/host/vlog_net_log.cc b/remoting/host/vlog_net_log.cc
index f273b09..05e9a35 100644
--- a/remoting/host/vlog_net_log.cc
+++ b/remoting/host/vlog_net_log.cc
@@ -19,15 +19,9 @@ VlogNetLog::VlogNetLog() : id_(0) {
 VlogNetLog::~VlogNetLog() {
 }
 
-void VlogNetLog::AddEntry(
-    EventType type,
-    const Source& source,
-    EventPhase phase,
-    const scoped_refptr<EventParameters>& params) {
+void VlogNetLog::OnAddEntry(const NetLog::Entry& entry) {
   if (VLOG_IS_ON(4)) {
-    scoped_ptr<Value> value(
-        net::NetLog::EntryToDictionaryValue(
-            type, base::TimeTicks::Now(), source, phase, params, false));
+    scoped_ptr<Value> value(entry.ToValue());
     std::string json;
     base::JSONWriter::Write(value.get(), &json);
     VLOG(4) << json;
@@ -35,6 +29,7 @@ void VlogNetLog::AddEntry(
 }
 
 uint32 VlogNetLog::NextID() {
+  // TODO(mmenke):  Make this threadsafe and start with 1 instead of 0.
   return id_++;
 }
 
diff --git a/remoting/host/vlog_net_log.h b/remoting/host/vlog_net_log.h
index eae349b..d056a3a 100644
--- a/remoting/host/vlog_net_log.h
+++ b/remoting/host/vlog_net_log.h
@@ -20,11 +20,7 @@ class VlogNetLog : public net::NetLog {
   virtual ~VlogNetLog();
 
   // NetLog overrides:
-  virtual void AddEntry(
-      EventType type,
-      const Source& source,
-      EventPhase phase,
-      const scoped_refptr<NetLog::EventParameters>& params) OVERRIDE;
+  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE;
   virtual uint32 NextID() OVERRIDE;
   virtual LogLevel GetLogLevel() const OVERRIDE;
   virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,