Update NetLog to be threadsafe.

The ChromeNetLog is now owned by the browser process,
and passed to the IOThread on creation.

NetLog entries can be added from any thread.

Observers must be able to handle having log entries added
from any thread.  Observers can add/remove themselves on any
thread.

BUG=63334
TEST=None, yet

Review URL: http://codereview.chromium.org/4118004

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

25 files changed, 474 insertions, 526 deletions

diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc
index c488e06..e785990 100644
--- a/net/base/capturing_net_log.cc
+++ b/net/base/capturing_net_log.cc
@@ -18,7 +18,7 @@ CapturingNetLog::Entry::Entry(EventType type,
 CapturingNetLog::Entry::~Entry() {}
 
 CapturingNetLog::CapturingNetLog(size_t max_num_entries)
-    : next_id_(0), max_num_entries_(max_num_entries) {
+    : last_id_(-1), max_num_entries_(max_num_entries) {
 }
 
 CapturingNetLog::~CapturingNetLog() {}
@@ -28,16 +28,23 @@ void CapturingNetLog::AddEntry(EventType type,
                                const Source& source,
                                EventPhase phase,
                                EventParameters* extra_parameters) {
+  AutoLock lock(lock_);
   Entry entry(type, time, source, phase, extra_parameters);
   if (entries_.size() + 1 < max_num_entries_)
     entries_.push_back(entry);
 }
 
 uint32 CapturingNetLog::NextID() {
-  return next_id_++;
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
+}
+
+void CapturingNetLog::GetEntries(EntryList* entry_list) const {
+  AutoLock lock(lock_);
+  *entry_list = entries_;
 }
 
 void CapturingNetLog::Clear() {
+  AutoLock lock(lock_);
   entries_.clear();
 }
 
@@ -51,16 +58,13 @@ CapturingBoundNetLog::CapturingBoundNetLog(size_t max_num_entries)
 
 CapturingBoundNetLog::~CapturingBoundNetLog() {}
 
-void CapturingBoundNetLog::Clear() {
-  capturing_net_log_->Clear();
+void CapturingBoundNetLog::GetEntries(
+    CapturingNetLog::EntryList* entry_list) const {
+  capturing_net_log_->GetEntries(entry_list);
 }
 
-void CapturingBoundNetLog::AppendTo(const BoundNetLog& net_log) const {
-  for (size_t i = 0; i < entries().size(); ++i) {
-    const CapturingNetLog::Entry& entry = entries()[i];
-    net_log.AddEntryWithTime(entry.type, entry.time, entry.phase,
-                             entry.extra_parameters);
-  }
+void CapturingBoundNetLog::Clear() {
+  capturing_net_log_->Clear();
 }
 
 }  // namespace net
diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h
index ff7cf16..3b6a39e 100644
--- a/net/base/capturing_net_log.h
+++ b/net/base/capturing_net_log.h
@@ -8,7 +8,9 @@
 
 #include <vector>
 
+#include "base/atomicops.h"
 #include "base/basictypes.h"
+#include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
@@ -55,12 +57,17 @@ class CapturingNetLog : public NetLog {
   virtual LogLevel GetLogLevel() const { return LOG_ALL_BUT_BYTES; }
 
   // Returns the list of all entries in the log.
-  const EntryList& entries() const { return entries_; }
+  void GetEntries(EntryList* entry_list) const;
 
   void Clear();
 
  private:
-  uint32 next_id_;
+  // Needs to be "mutable" so can use it in GetEntries().
+  mutable Lock lock_;
+
+  // Last assigned source ID.  Incremented to get the next one.
+  base::subtle::Atomic32 last_id_;
+
   size_t max_num_entries_;
   EntryList entries_;
 
@@ -85,17 +92,11 @@ class CapturingBoundNetLog {
     return BoundNetLog(source_, capturing_net_log_.get());
   }
 
-  // Returns the list of all entries in the log.
-  const CapturingNetLog::EntryList& entries() const {
-    return capturing_net_log_->entries();
-  }
+  // Fills |entry_list| with all entries in the log.
+  void GetEntries(CapturingNetLog::EntryList* entry_list) const;
 
   void Clear();
 
-  // Sends all of captured messages to |net_log|, using the same source ID
-  // as |net_log|.
-  void AppendTo(const BoundNetLog& net_log) const;
-
  private:
   NetLog::Source source_;
   scoped_ptr<CapturingNetLog> capturing_net_log_;
diff --git a/net/base/forwarding_net_log.cc b/net/base/forwarding_net_log.cc
deleted file mode 100644
index 7cfd6a9..0000000
--- a/net/base/forwarding_net_log.cc
+++ /dev/null
@@ -1,96 +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/base/forwarding_net_log.h"
-
-#include "base/lock.h"
-#include "base/logging.h"
-#include "base/message_loop.h"
-
-namespace net {
-
-// Reference-counted wrapper, so we can use PostThread and it can safely
-// outlive the parent ForwardingNetLog.
-class ForwardingNetLog::Core
-    : public base::RefCountedThreadSafe<ForwardingNetLog::Core> {
- public:
-  Core(NetLog* impl, MessageLoop* loop) : impl_(impl), loop_(loop) {
-    DCHECK(impl);
-    DCHECK(loop);
-  }
-
-  // Called once the parent ForwardingNetLog is being destroyed. It
-  // is invalid to access |loop_| and |impl_| afterwards.
-  void Orphan() {
-    AutoLock l(lock_);
-    loop_ = NULL;
-    impl_ = NULL;
-  }
-
-  void AddEntry(EventType type,
-                const base::TimeTicks& time,
-                const Source& source,
-                EventPhase phase,
-                EventParameters* params) {
-    AutoLock l(lock_);
-    if (!loop_)
-      return;  // Was orphaned.
-
-    loop_->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(
-            this, &Core::AddEntryOnLoop, type, time, source, phase,
-            scoped_refptr<EventParameters>(params)));
-  }
-
- private:
-  void AddEntryOnLoop(EventType type,
-                      const base::TimeTicks& time,
-                      const Source& source,
-                      EventPhase phase,
-                      scoped_refptr<EventParameters> params) {
-    AutoLock l(lock_);
-    if (!loop_)
-      return;  // Was orphaned.
-
-    DCHECK_EQ(MessageLoop::current(), loop_);
-
-    impl_->AddEntry(type, time, source, phase, params);
-  }
-
-  Lock lock_;
-  NetLog* impl_;
-  MessageLoop* loop_;
-};
-
-ForwardingNetLog::ForwardingNetLog(NetLog* impl, MessageLoop* loop)
-    : core_(new Core(impl, loop)) {
-}
-
-ForwardingNetLog::~ForwardingNetLog() {
-  core_->Orphan();
-}
-
-void ForwardingNetLog::AddEntry(EventType type,
-                                const base::TimeTicks& time,
-                                const Source& source,
-                                EventPhase phase,
-                                EventParameters* params) {
-  core_->AddEntry(type, time, source, phase, params);
-}
-
-uint32 ForwardingNetLog::NextID() {
-  // Can't forward a synchronous API.
-  CHECK(false) << "Not supported";
-  return 0;
-}
-
-NetLog::LogLevel ForwardingNetLog::GetLogLevel() const {
-  // Can't forward a synchronous API.
-  CHECK(false) << "Not supported";
-  return LOG_ALL_BUT_BYTES;
-}
-
-}  // namespace net
-
diff --git a/net/base/forwarding_net_log.h b/net/base/forwarding_net_log.h
deleted file mode 100644
index 257b4c7..0000000
--- a/net/base/forwarding_net_log.h
+++ /dev/null
@@ -1,54 +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.
-
-#ifndef NET_BASE_FORWARDING_NET_LOG_H_
-#define NET_BASE_FORWARDING_NET_LOG_H_
-#pragma once
-
-#include "base/basictypes.h"
-#include "net/base/net_log.h"
-
-class MessageLoop;
-
-namespace net {
-
-// ForwardingNetLog is a wrapper that can be called on any thread, and will
-// forward any calls to NetLog::AddEntry() over to |impl| on the specified
-// message loop.
-//
-// This allows using a non-threadsafe NetLog implementation from another
-// thread.
-//
-// TODO(eroman): Explore making NetLog threadsafe and obviating the need
-//               for this class.
-class ForwardingNetLog : public NetLog {
- public:
-  // Both |impl| and |loop| must outlive the lifetime of this instance.
-  // |impl| will be operated only from |loop|.
-  ForwardingNetLog(NetLog* impl, MessageLoop* loop);
-
-  // On destruction any outstanding call to AddEntry() which didn't make
-  // it to |loop| yet will be cancelled.
-  ~ForwardingNetLog();
-
-  // NetLog methods:
-  virtual void AddEntry(EventType type,
-                        const base::TimeTicks& time,
-                        const Source& source,
-                        EventPhase phase,
-                        EventParameters* params);
-  virtual uint32 NextID();
-  virtual LogLevel GetLogLevel() const;
-
- private:
-  class Core;
-  scoped_refptr<Core> core_;
-
-  DISALLOW_COPY_AND_ASSIGN(ForwardingNetLog);
-};
-
-}  // namespace net
-
-#endif  // NET_BASE_FORWARDING_NET_LOG_H_
-
diff --git a/net/base/forwarding_net_log_unittest.cc b/net/base/forwarding_net_log_unittest.cc
deleted file mode 100644
index 3f25129..0000000
--- a/net/base/forwarding_net_log_unittest.cc
+++ /dev/null
@@ -1,84 +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/base/forwarding_net_log.h"
-
-#include "base/message_loop.h"
-#include "net/base/capturing_net_log.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-
-namespace {
-
-// Test forwarding a call to AddEntry() to another implementation, operating
-// on this same message loop.
-TEST(ForwardingNetLogTest, Basic) {
-  // Create a forwarding NetLog that sends messages to this same thread.
-  CapturingNetLog log(CapturingNetLog::kUnbounded);
-  ForwardingNetLog forwarding(&log, MessageLoop::current());
-
-  EXPECT_EQ(0u, log.entries().size());
-
-  NetLogStringParameter* params = new NetLogStringParameter("xxx", "yyy");
-
-  forwarding.AddEntry(
-      NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-      base::TimeTicks(),
-      NetLog::Source(),
-      NetLog::PHASE_NONE,
-      params);
-
-  // Should still be empty, since we posted an async task.
-  EXPECT_EQ(0u, log.entries().size());
-
-  MessageLoop::current()->RunAllPending();
-
-  // After draining the message loop, we should now have executed the task
-  // and hence emitted the log entry.
-  ASSERT_EQ(1u, log.entries().size());
-
-  // Check that the forwarded call contained received all the right inputs.
-  EXPECT_EQ(NetLog::TYPE_PAC_JAVASCRIPT_ALERT, log.entries()[0].type);
-  EXPECT_EQ(NetLog::SOURCE_NONE, log.entries()[0].source.type);
-  EXPECT_EQ(NetLog::PHASE_NONE, log.entries()[0].phase);
-  EXPECT_EQ(params, log.entries()[0].extra_parameters.get());
-
-  // Check that the parameters is still referenced. (if the reference was
-  // lost then this will be a memory error and probaby crash).
-  EXPECT_EQ("yyy", params->value());
-}
-
-// Test forwarding a call to AddEntry() to another implementation that runs
-// on the same message loop. However destroy the forwarder before the posted
-// task has a chance to run.
-TEST(ForwardingNetLogTest, Orphan) {
-  // Create a forwarding NetLog that sends messages to this same thread.
-  CapturingNetLog log(CapturingNetLog::kUnbounded);
-  {
-    ForwardingNetLog forwarding(&log, MessageLoop::current());
-    EXPECT_EQ(0u, log.entries().size());
-
-    forwarding.AddEntry(
-        NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-        base::TimeTicks(),
-        NetLog::Source(),
-        NetLog::PHASE_NONE,
-        NULL);
-
-    // Should still be empty, since we posted an async task.
-    EXPECT_EQ(0u, log.entries().size());
-  }
-
-  // At this point the ForwardingNetLog is deleted. However it had already
-  // posted a task to the message loop. Once we drain the message loop, we
-  // verify that the task didn't actually try to emit to the NetLog.
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0u, log.entries().size());
-}
-
-}  // namespace
-
-}  // namespace net
-
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index f3bdb74..4d26ab9 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -271,11 +271,14 @@ TEST_F(HostResolverImplTest, SynchronousLookup) {
   int err = host_resolver->Resolve(info, &addrlist, NULL, NULL, log.bound());
   EXPECT_EQ(OK, err);
 
-  EXPECT_EQ(2u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   const struct addrinfo* ainfo = addrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
@@ -304,18 +307,23 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) {
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
-  EXPECT_EQ(1u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(1u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(callback_called_);
   ASSERT_EQ(OK, callback_result_);
 
-  EXPECT_EQ(2u, log.entries().size());
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   const struct addrinfo* ainfo = addrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
@@ -356,31 +364,37 @@ TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
 
   resolver_proc->Signal();
 
-  EXPECT_EQ(2u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+
+  net::CapturingNetLog::EntryList net_log_entries;
+  net_log.GetEntries(&net_log_entries);
 
-  int pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), 0,
+  int pos = net::ExpectLogContainsSomewhereAfter(net_log_entries, 0,
       net::NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
       net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
       net::NetLog::PHASE_BEGIN);
   // Both Job and Request need to be cancelled.
-  pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       net::NetLog::TYPE_CANCELLED,
       net::NetLog::PHASE_NONE);
   // Don't care about order in which they end, or when the other one is
   // cancelled.
-  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+  net::ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       net::NetLog::TYPE_CANCELLED,
       net::NetLog::PHASE_NONE);
-  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+  net::ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       net::NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
       net::NetLog::PHASE_END);
-  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+  net::ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
       net::NetLog::PHASE_END);
 
@@ -943,11 +957,14 @@ TEST_F(HostResolverImplTest, Observers) {
   int rv = host_resolver->Resolve(info1, &addrlist, NULL, NULL, log.bound());
   EXPECT_EQ(OK, rv);
 
-  EXPECT_EQ(2u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   EXPECT_EQ(1U, observer.start_log.size());
   EXPECT_EQ(1U, observer.finish_log.size());
diff --git a/net/base/net_log.h b/net/base/net_log.h
index 9c670ec..5a8f197 100644
--- a/net/base/net_log.h
+++ b/net/base/net_log.h
@@ -29,12 +29,9 @@ namespace net {
 // is usually accessed through a BoundNetLog, which will always pass in a
 // specific source ID.
 //
-// Note that NetLog is NOT THREADSAFE.
-//
 // ******** The NetLog (and associated logging) is a work in progress ********
 //
 // TODO(eroman): Remove the 'const' qualitifer from the BoundNetLog methods.
-// TODO(eroman): Make the DNS jobs emit into the NetLog.
 // TODO(eroman): Start a new Source each time net::URLRequest redirects
 //               (simpler to reason about each as a separate entity).
 
diff --git a/net/http/http_auth_handler_unittest.cc b/net/http/http_auth_handler_unittest.cc
index d63b9fb..c3d0114 100644
--- a/net/http/http_auth_handler_unittest.cc
+++ b/net/http/http_auth_handler_unittest.cc
@@ -49,11 +49,12 @@ TEST(HttpAuthHandlerTest, NetLog) {
         if (async)
           test_callback.WaitForResult();
 
-        EXPECT_EQ(2u, capturing_net_log.entries().size());
-        EXPECT_TRUE(LogContainsBeginEvent(capturing_net_log.entries(),
-                                          0, event_type));
-        EXPECT_TRUE(LogContainsEndEvent(capturing_net_log.entries(),
-                                        1, event_type));
+        net::CapturingNetLog::EntryList entries;
+        capturing_net_log.GetEntries(&entries);
+
+        EXPECT_EQ(2u, entries.size());
+        EXPECT_TRUE(LogContainsBeginEvent(entries, 0, event_type));
+        EXPECT_TRUE(LogContainsEndEvent(entries, 1, event_type));
       }
     }
   }
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 6ca1da1..239f34e 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -1044,19 +1044,22 @@ TEST(HttpCache, SimpleGETNoDiskCache) {
 
   // Check that the NetLog was filled as expected.
   // (We attempted to both Open and Create entries, but both failed).
-  EXPECT_EQ(6u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ -1145,23 +1148,26 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) {
                             log.bound());
 
   // Check that the NetLog was filled as expected.
-  EXPECT_EQ(8u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 6, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 6, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 7, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 7, net::NetLog::TYPE_HTTP_CACHE_WAITING));
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
@@ -1172,23 +1178,25 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) {
   RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
 
   // Check that the NetLog was filled as expected.
-  EXPECT_EQ(8u, log.entries().size());
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
+      entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 4, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 4, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 5, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 5, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 6, net::NetLog::TYPE_HTTP_CACHE_READ_INFO));
+      entries, 6, net::NetLog::TYPE_HTTP_CACHE_READ_INFO));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 7, net::NetLog::TYPE_HTTP_CACHE_READ_INFO));
+      entries, 7, net::NetLog::TYPE_HTTP_CACHE_READ_INFO));
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
@@ -1268,23 +1276,26 @@ TEST(HttpCache, SimpleGET_LoadBypassCache) {
   RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound());
 
   // Check that the NetLog was filled as expected.
-  EXPECT_EQ(8u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 2, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
+      entries, 2, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 3, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
+      entries, 3, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 4, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
+      entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 6, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 6, net::NetLog::TYPE_HTTP_CACHE_WAITING));
   EXPECT_TRUE(net::LogContainsEndEvent(
-      log.entries(), 7, net::NetLog::TYPE_HTTP_CACHE_WAITING));
+      entries, 7, net::NetLog::TYPE_HTTP_CACHE_WAITING));
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index f765696..95a8599 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -174,15 +174,18 @@ class HttpNetworkTransactionTest : public PlatformTest {
 
     rv = ReadTransaction(trans.get(), &out.response_data);
     EXPECT_EQ(OK, rv);
+
+    net::CapturingNetLog::EntryList entries;
+    log.GetEntries(&entries);
     size_t pos = ExpectLogContainsSomewhere(
-        log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
+        entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
         NetLog::PHASE_NONE);
     ExpectLogContainsSomewhere(
-        log.entries(), pos,
+        entries, pos,
         NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS,
         NetLog::PHASE_NONE);
 
-    CapturingNetLog::Entry entry = log.entries()[pos];
+    CapturingNetLog::Entry entry = entries[pos];
     NetLogHttpRequestParameter* request_params =
         static_cast<NetLogHttpRequestParameter*>(entry.extra_parameters.get());
     EXPECT_EQ("GET / HTTP/1.1\r\n", request_params->GetLine());
@@ -1525,11 +1528,13 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthProxyNoKeepAlive) {
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
-      log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
-      log.entries(), pos,
+      entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 
@@ -1629,11 +1634,13 @@ TEST_F(HttpNetworkTransactionTest, BasicAuthProxyKeepAlive) {
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
-      log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
-      log.entries(), pos,
+      entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 
@@ -1831,11 +1838,13 @@ TEST_F(HttpNetworkTransactionTest, HttpsServerRequestsProxyAuthThroughProxy) {
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_UNEXPECTED_PROXY_AUTH, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
-      log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
-      log.entries(), pos,
+      entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 }
@@ -7724,11 +7733,13 @@ TEST_F(HttpNetworkTransactionTest, ProxyTunnelGet) {
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
-      log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
-      log.entries(), pos,
+      entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 
@@ -7786,11 +7797,13 @@ TEST_F(HttpNetworkTransactionTest, ProxyTunnelGetHangup) {
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_EMPTY_RESPONSE, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   size_t pos = ExpectLogContainsSomewhere(
-      log.entries(), 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
+      entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
-      log.entries(), pos,
+      entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 }
diff --git a/net/net.gyp b/net/net.gyp
index a5134da..bf4e2d6 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -76,8 +76,6 @@
         'base/file_stream_win.cc',
         'base/filter.cc',
         'base/filter.h',
-        'base/forwarding_net_log.cc',
-        'base/forwarding_net_log.h',
         'base/gzip_filter.cc',
         'base/gzip_filter.h',
         'base/gzip_header.cc',
@@ -839,7 +837,6 @@
         'base/file_stream_unittest.cc',
         'base/filter_unittest.cc',
         'base/filter_unittest.h',
-        'base/forwarding_net_log_unittest.cc',
         'base/gzip_filter_unittest.cc',
         'base/host_cache_unittest.cc',
         'base/host_mapping_rules_unittest.cc',
diff --git a/net/proxy/init_proxy_resolver_unittest.cc b/net/proxy/init_proxy_resolver_unittest.cc
index 0c7e8a1..f9858614 100644
--- a/net/proxy/init_proxy_resolver_unittest.cc
+++ b/net/proxy/init_proxy_resolver_unittest.cc
@@ -181,19 +181,22 @@ TEST(InitProxyResolverTest, CustomPacSucceeds) {
   EXPECT_EQ(rule.text(), resolver.script_data()->utf16());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(6u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fail downloading the custom PAC script.
@@ -215,15 +218,18 @@ TEST(InitProxyResolverTest, CustomPacFails1) {
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(4u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fail parsing the custom PAC script.
@@ -326,31 +332,34 @@ TEST(InitProxyResolverTest, AutodetectFailCustomSuccess2) {
   // Check the NetLog was filled correctly.
   // (Note that the Fetch and Set states are repeated since both WPAD and custom
   // PAC scripts are tried).
-  EXPECT_EQ(11u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(11u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 5,
+      entries, 5,
       NetLog::TYPE_INIT_PROXY_RESOLVER_FALLING_BACK_TO_NEXT_PAC_URL,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 6, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 6, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 7, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 7, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 8, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 8, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 9, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      entries, 9, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 10, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 10, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fails at WPAD (downloading), and fails at custom PAC (downloading).
@@ -438,19 +447,22 @@ TEST(InitProxyResolverTest, CustomPacFails1_WithPositiveDelay) {
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(6u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_WAIT));
+      entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_WAIT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_INIT_PROXY_RESOLVER_WAIT));
+      entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_WAIT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 3, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // This is a copy-paste of CustomPacFails1, with the exception that we give it
@@ -475,15 +487,18 @@ TEST(InitProxyResolverTest, CustomPacFails1_WithNegativeDelay) {
   EXPECT_EQ(NULL, resolver.script_data());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(4u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      entries, 2, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
+      entries, 3, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 }  // namespace
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index d696438a1..a373c1a 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -8,8 +8,8 @@
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/thread.h"
-#include "net/base/capturing_net_log.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/proxy/proxy_info.h"
 
 // TODO(eroman): Have the MultiThreadedProxyResolver clear its PAC script
@@ -253,13 +253,9 @@ class MultiThreadedProxyResolver::GetProxyForURLJob
 
   // Runs on the worker thread.
   virtual void Run(MessageLoop* origin_loop) {
-    const size_t kNetLogBound = 50u;
-    worker_log_.reset(new CapturingNetLog(kNetLogBound));
-    BoundNetLog bound_worker_log(NetLog::Source(), worker_log_.get());
-
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
-        url_, &results_buf_, NULL, NULL, bound_worker_log);
+        url_, &results_buf_, NULL, NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
@@ -272,12 +268,6 @@ class MultiThreadedProxyResolver::GetProxyForURLJob
   void QueryComplete(int result_code) {
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
-      // Merge the load log that was generated on the worker thread, into the
-      // main log.
-      CapturingBoundNetLog bound_worker_log(NetLog::Source(),
-                                            worker_log_.release());
-      bound_worker_log.AppendTo(net_log_);
-
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
@@ -288,16 +278,14 @@ class MultiThreadedProxyResolver::GetProxyForURLJob
 
   // Must only be used on the "origin" thread.
   ProxyInfo* results_;
+
+  // Can be used on either "origin" or worker thread.
   BoundNetLog net_log_;
   const GURL url_;
 
   // Usable from within DoQuery on the worker thread.
   ProxyInfo results_buf_;
 
-  // Used to pass the captured events between DoQuery [worker thread] and
-  // QueryComplete [origin thread].
-  scoped_ptr<CapturingNetLog> worker_log_;
-
   bool was_waiting_for_thread_;
 };
 
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index 7027161..6f168a7 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -260,9 +260,11 @@ TEST(MultiThreadedProxyResolverTest, SingleThread_Basic) {
   // on completion, this should have been copied into |log0|.
   // We also have 1 log entry that was emitted by the
   // MultiThreadedProxyResolver.
-  ASSERT_EQ(2u, log0.entries().size());
-  EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
-            log0.entries()[0].type);
+  net::CapturingNetLog::EntryList entries0;
+  log0.GetEntries(&entries0);
+
+  ASSERT_EQ(2u, entries0.size());
+  EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD, entries0[0].type);
 
   // Start 3 more requests (request1 to request3).
 
@@ -368,30 +370,42 @@ TEST(MultiThreadedProxyResolverTest,
   // 1 entry from the mock proxy resolver.
   EXPECT_EQ(0, callback0.WaitForResult());
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
-  ASSERT_EQ(2u, log0.entries().size());
+
+  net::CapturingNetLog::EntryList entries0;
+  log0.GetEntries(&entries0);
+
+  ASSERT_EQ(2u, entries0.size());
   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
-            log0.entries()[0].type);
+            entries0[0].type);
 
   // Check that request 1 completed as expected.
   EXPECT_EQ(1, callback1.WaitForResult());
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
-  ASSERT_EQ(4u, log1.entries().size());
+
+  net::CapturingNetLog::EntryList entries1;
+  log1.GetEntries(&entries1);
+
+  ASSERT_EQ(4u, entries1.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log1.entries(), 0,
+      entries1, 0,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
-      log1.entries(), 1,
+      entries1, 1,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
 
   // Check that request 2 completed as expected.
   EXPECT_EQ(2, callback2.WaitForResult());
   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
-  ASSERT_EQ(4u, log2.entries().size());
+
+  net::CapturingNetLog::EntryList entries2;
+  log2.GetEntries(&entries2);
+
+  ASSERT_EQ(4u, entries2.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log2.entries(), 0,
+      entries2, 0,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
-      log2.entries(), 1,
+      entries2, 1,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
 }
 
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index 6b33a34..ecb36ca 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -304,65 +304,82 @@ TEST(ProxyResolverJSBindingsTest, NetLog) {
   bindings->set_current_request_context(&context);
 
   std::string ip_address;
-
-  ASSERT_EQ(0u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+  ASSERT_EQ(0u, entries.size());
 
   // Call all the bindings. Each call should be logging something to
   // our NetLog.
 
   bindings->MyIpAddress(&ip_address);
-  EXPECT_EQ(2u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
+      entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 1, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
+      entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS));
 
   bindings->MyIpAddressEx(&ip_address);
-  EXPECT_EQ(4u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 2, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
+      entries, 2, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 3, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
+      entries, 3, NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX));
 
   bindings->DnsResolve("foo", &ip_address);
-  EXPECT_EQ(6u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 4, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
+      entries, 4, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 5, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
+      entries, 5, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE));
 
   bindings->DnsResolveEx("foo", &ip_address);
-  EXPECT_EQ(8u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 6, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
+      entries, 6, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 7, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
+      entries, 7, NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX));
 
   // Nothing has been emitted globally yet.
-  EXPECT_EQ(0u, global_log.entries().size());
+  net::CapturingNetLog::EntryList global_log_entries;
+  global_log.GetEntries(&global_log_entries);
+  EXPECT_EQ(0u, global_log_entries.size());
 
   bindings->OnError(30, string16());
-  EXPECT_EQ(9u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(9u, entries.size());
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 8, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
+      entries, 8, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
       NetLog::PHASE_NONE));
 
   // We also emit errors to the top-level log stream.
-  EXPECT_EQ(1u, global_log.entries().size());
+  global_log.GetEntries(&global_log_entries);
+  EXPECT_EQ(1u, global_log_entries.size());
   EXPECT_TRUE(LogContainsEvent(
-      global_log.entries(), 0, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
+      global_log_entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
       NetLog::PHASE_NONE));
 
   bindings->Alert(string16());
-  EXPECT_EQ(10u, log.entries().size());
+
+  log.GetEntries(&entries);
+  EXPECT_EQ(10u, entries.size());
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 9, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+      entries, 9, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
       NetLog::PHASE_NONE));
 
   // We also emit javascript alerts to the top-level log stream.
-  EXPECT_EQ(2u, global_log.entries().size());
+  global_log.GetEntries(&global_log_entries);
+  EXPECT_EQ(2u, global_log_entries.size());
   EXPECT_TRUE(LogContainsEvent(
-      global_log.entries(), 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+      global_log_entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
       NetLog::PHASE_NONE));
 }
 
diff --git a/net/proxy/proxy_resolver_v8_unittest.cc b/net/proxy/proxy_resolver_v8_unittest.cc
index 3e61cd7..eff0413 100644
--- a/net/proxy/proxy_resolver_v8_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_unittest.cc
@@ -138,8 +138,10 @@ TEST(ProxyResolverV8Test, Direct) {
   EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   // No bindings were called, so no log entries.
-  EXPECT_EQ(0u, log.entries().size());
+  EXPECT_EQ(0u, entries.size());
 }
 
 TEST(ProxyResolverV8Test, ReturnEmptyString) {
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index beeab51..669ae083 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -12,7 +12,6 @@
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/forwarding_net_log.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
@@ -157,16 +156,14 @@ class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
  public:
   // |async_host_resolver|, |io_loop| and |net_log| must remain
   // valid for the duration of our lifetime.
-  // Both |async_host_resolver| and |net_log| will only be operated on
-  // |io_loop|.
+  // |async_host_resolver| will only be operated on |io_loop|.
   ProxyResolverFactoryForV8(HostResolver* async_host_resolver,
                             MessageLoop* io_loop,
                             NetLog* net_log)
       : ProxyResolverFactory(true /*expects_pac_bytes*/),
         async_host_resolver_(async_host_resolver),
         io_loop_(io_loop),
-        forwarding_net_log_(
-            net_log ? new ForwardingNetLog(net_log, io_loop) : NULL) {
+        net_log_(net_log) {
   }
 
   virtual ProxyResolver* CreateProxyResolver() {
@@ -176,8 +173,7 @@ class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
         new SyncHostResolverBridge(async_host_resolver_, io_loop_);
 
     ProxyResolverJSBindings* js_bindings =
-        ProxyResolverJSBindings::CreateDefault(sync_host_resolver,
-                                               forwarding_net_log_.get());
+        ProxyResolverJSBindings::CreateDefault(sync_host_resolver, net_log_);
 
     // ProxyResolverV8 takes ownership of |js_bindings|.
     return new ProxyResolverV8(js_bindings);
@@ -186,10 +182,7 @@ class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
  private:
   HostResolver* const async_host_resolver_;
   MessageLoop* io_loop_;
-
-  // Thread-safe wrapper around a non-threadsafe NetLog implementation. This
-  // enables the proxy resolver to emit log messages from the PAC thread.
-  scoped_ptr<ForwardingNetLog> forwarding_net_log_;
+  NetLog* net_log_;
 };
 
 // Creates ProxyResolvers using a platform-specific implementation.
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index 1c77876..3c8ef2a 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -130,14 +130,17 @@ TEST(ProxyServiceTest, Direct) {
   EXPECT_TRUE(info.is_direct());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(3u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_PROXY_SERVICE));
+      entries, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
+      entries, 1, NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_PROXY_SERVICE));
+      entries, 2, NetLog::TYPE_PROXY_SERVICE));
 }
 
 TEST(ProxyServiceTest, PAC) {
@@ -174,15 +177,18 @@ TEST(ProxyServiceTest, PAC) {
   EXPECT_EQ("foopy:80", info.proxy_server().ToURI());
 
   // Check the NetLog was filled correctly.
-  EXPECT_EQ(5u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(5u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_PROXY_SERVICE));
+      entries, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+      entries, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+      entries, 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 4, NetLog::TYPE_PROXY_SERVICE));
+      entries, 4, NetLog::TYPE_PROXY_SERVICE));
 }
 
 // Test that the proxy resolver does not see the URL's username/password
@@ -1149,18 +1155,21 @@ TEST(ProxyServiceTest, CancelWhilePACFetching) {
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
 
+  net::CapturingNetLog::EntryList entries1;
+  log1.GetEntries(&entries1);
+
   // Check the NetLog for request 1 (which was cancelled) got filled properly.
-  EXPECT_EQ(4u, log1.entries().size());
+  EXPECT_EQ(4u, entries1.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log1.entries(), 0, NetLog::TYPE_PROXY_SERVICE));
+      entries1, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log1.entries(), 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+      entries1, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   // Note that TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC is never completed before
   // the cancellation occured.
   EXPECT_TRUE(LogContainsEvent(
-      log1.entries(), 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
+      entries1, 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log1.entries(), 3, NetLog::TYPE_PROXY_SERVICE));
+      entries1, 3, NetLog::TYPE_PROXY_SERVICE));
 }
 
 // Test that if auto-detect fails, we fall-back to the custom pac.
@@ -1679,11 +1688,14 @@ TEST(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   // In particular, PROXY_CONFIG_CHANGED should have only been emitted once
   // (for the initial setup), and NOT a second time when the IP address
   // changed.
-  EXPECT_TRUE(LogContainsEntryWithType(log.entries(), 0,
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
                                        NetLog::TYPE_PROXY_CONFIG_CHANGED));
-  ASSERT_EQ(13u, log.entries().size());
-  for (size_t i = 1; i < log.entries().size(); ++i)
-    EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, log.entries()[i].type);
+  ASSERT_EQ(13u, entries.size());
+  for (size_t i = 1; i < entries.size(); ++i)
+    EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
 }
 
 }  // namespace net
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index d145bdf..fd9e337 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -620,21 +620,24 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
   PlatformThread::Sleep(1);
   EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
 
-  EXPECT_EQ(6u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+      entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
+      entries, 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
+      entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
+      entries, 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
+      entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
+      entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
@@ -655,17 +658,20 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
   EXPECT_TRUE(handle.socket());
   handle.Reset();
 
-  EXPECT_EQ(4u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
+      entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
+      entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
+      entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 3, NetLog::TYPE_SOCKET_POOL));
+      entries, 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
@@ -692,14 +698,17 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 
-  EXPECT_EQ(3u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
+      entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
+      entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_SOCKET_POOL));
+      entries, 2, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
@@ -1503,17 +1512,20 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
   EXPECT_TRUE(handle.socket());
   handle.Reset();
 
-  EXPECT_EQ(4u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
+      entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
+      entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
+      entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 3, NetLog::TYPE_SOCKET_POOL));
+      entries, 3, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest,
@@ -1540,14 +1552,17 @@ TEST_F(ClientSocketPoolBaseTest,
   EXPECT_FALSE(handle.is_ssl_error());
   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 
-  EXPECT_EQ(3u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKET_POOL));
+      entries, 0, NetLog::TYPE_SOCKET_POOL));
   EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
+      entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_SOCKET_POOL));
+      entries, 2, NetLog::TYPE_SOCKET_POOL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
@@ -1892,8 +1907,11 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
                    log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_reused());
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEntryWithType(
-      log.entries(), 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
+      entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 // Make sure that we process all pending requests even when we're stalling
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index 2152c86..5458411 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -131,14 +131,19 @@ TEST_F(SOCKS5ClientSocketTest, CompleteHandshake) {
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContainsBeginEvent(net_log_.entries(), 0,
+
+  net::CapturingNetLog::EntryList net_log_entries;
+  net_log_.GetEntries(&net_log_entries);
+  EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                     NetLog::TYPE_SOCKS5_CONNECT));
 
   rv = callback_.WaitForResult();
 
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
-  EXPECT_TRUE(LogContainsEndEvent(net_log_.entries(), -1,
+
+  net_log_.GetEntries(&net_log_entries);
+  EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                   NetLog::TYPE_SOCKS5_CONNECT));
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
@@ -248,12 +253,18 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
                                      hostname, 80, &net_log_));
     int rv = user_sock_->Connect(&callback_);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContainsBeginEvent(net_log_.entries(), 0,
+
+    net::CapturingNetLog::EntryList net_log_entries;
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                 NetLog::TYPE_SOCKS5_CONNECT));
+
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContainsEndEvent(net_log_.entries(), -1,
+
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                 NetLog::TYPE_SOCKS5_CONNECT));
   }
 
@@ -273,12 +284,16 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
                                      hostname, 80, &net_log_));
     int rv = user_sock_->Connect(&callback_);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContainsBeginEvent(net_log_.entries(), 0,
+
+    net::CapturingNetLog::EntryList net_log_entries;
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContainsEndEvent(net_log_.entries(), -1,
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLog::TYPE_SOCKS5_CONNECT));
   }
 
@@ -299,12 +314,15 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
                                      hostname, 80, &net_log_));
     int rv = user_sock_->Connect(&callback_);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContainsBeginEvent(net_log_.entries(), 0,
+    net::CapturingNetLog::EntryList net_log_entries;
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContainsEndEvent(net_log_.entries(), -1,
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLog::TYPE_SOCKS5_CONNECT));
   }
 
@@ -327,12 +345,15 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
                                      hostname, 80, &net_log_));
     int rv = user_sock_->Connect(&callback_);
     EXPECT_EQ(ERR_IO_PENDING, rv);
-    EXPECT_TRUE(LogContainsBeginEvent(net_log_.entries(), 0,
+    net::CapturingNetLog::EntryList net_log_entries;
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0,
                                       NetLog::TYPE_SOCKS5_CONNECT));
     rv = callback_.WaitForResult();
     EXPECT_EQ(OK, rv);
     EXPECT_TRUE(user_sock_->IsConnected());
-    EXPECT_TRUE(LogContainsEndEvent(net_log_.entries(), -1,
+    net_log_.GetEntries(&net_log_entries);
+    EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1,
                                     NetLog::TYPE_SOCKS5_CONNECT));
   }
 }
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index 11a88ae..aa5338a 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -142,16 +142,20 @@ TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(
-      LogContainsBeginEvent(log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
   EXPECT_FALSE(user_sock_->IsConnected());
-  rv = callback_.WaitForResult();
 
+  rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4, user_sock_->socks_version_);
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
@@ -208,14 +212,19 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
 
     int rv = user_sock_->Connect(&callback_);
     EXPECT_EQ(ERR_IO_PENDING, rv);
+
+    net::CapturingNetLog::EntryList entries;
+    log.GetEntries(&entries);
     EXPECT_TRUE(LogContainsBeginEvent(
-        log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+        entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
     rv = callback_.WaitForResult();
     EXPECT_EQ(tests[i].fail_code, rv);
     EXPECT_FALSE(user_sock_->IsConnected());
     EXPECT_TRUE(tcp_sock_->IsConnected());
+    log.GetEntries(&entries);
     EXPECT_TRUE(LogContainsEndEvent(
-        log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+        entries, -1, NetLog::TYPE_SOCKS_CONNECT));
   }
 }
 
@@ -240,13 +249,17 @@ TEST_F(SOCKSClientSocketTest, PartialServerReads) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests scenario when the client sends the handshake request in
@@ -274,13 +287,17 @@ TEST_F(SOCKSClientSocketTest, PartialClientWrites) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tests the case when the server sends a smaller sized handshake data
@@ -302,13 +319,17 @@ TEST_F(SOCKSClientSocketTest, FailedSocketRead) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
   rv = callback_.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tries to connect to an unknown DNS and on failure should revert to SOCKS4A.
@@ -335,14 +356,18 @@ TEST_F(SOCKSClientSocketTest, SOCKS4AFailedDNS) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_);
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tries to connect to a domain that resolves to IPv6.
@@ -371,14 +396,18 @@ TEST_F(SOCKSClientSocketTest, SOCKS4AIfDomainInIPv6) {
 
   int rv = user_sock_->Connect(&callback_);
   EXPECT_EQ(ERR_IO_PENDING, rv);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
-      log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT));
+      entries, 0, NetLog::TYPE_SOCKS_CONNECT));
+
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_);
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT));
+      entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Calls Disconnect() while a host resolve is in progress. The outstanding host
diff --git a/net/socket/ssl_client_socket_snapstart_unittest.cc b/net/socket/ssl_client_socket_snapstart_unittest.cc
index 13b2636..bb12fb3 100644
--- a/net/socket/ssl_client_socket_snapstart_unittest.cc
+++ b/net/socket/ssl_client_socket_snapstart_unittest.cc
@@ -234,8 +234,9 @@ class SSLClientSocketSnapStartTest : public PlatformTest {
   // SnapStartEventType extracts the type of Snap Start from the NetLog. See
   // the SSL_SNAP_START_* defines in sslt.h
   int SnapStartEventType() {
-    const std::vector<CapturingNetLog::Entry>& entries = log_.entries();
-    for (std::vector<CapturingNetLog::Entry>::const_iterator
+    CapturingNetLog::EntryList entries;
+    log_.GetEntries(&entries);
+    for (CapturingNetLog::EntryList::const_iterator
          i = entries.begin(); i != entries.end(); i++) {
       if (i->type == NetLog::TYPE_SSL_SNAP_START) {
         scoped_ptr<Value> value(i->extra_parameters->ToValue());
@@ -253,8 +254,9 @@ class SSLClientSocketSnapStartTest : public PlatformTest {
   // it's certificate validation with the optimistic validation from the
   // SSLHostInfo.
   bool DidMerge() {
-    const std::vector<CapturingNetLog::Entry>& entries = log_.entries();
-    for (std::vector<CapturingNetLog::Entry>::const_iterator
+    CapturingNetLog::EntryList entries;
+    log_.GetEntries(&entries);
+    for (CapturingNetLog::EntryList::const_iterator
          i = entries.begin(); i != entries.end(); i++) {
       if (i->type == NetLog::TYPE_SSL_VERIFICATION_MERGED)
         return true;
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index e736d5b..a95585c 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -72,13 +72,17 @@ TEST_F(SSLClientSocketTest, Connect) {
   EXPECT_FALSE(sock->IsConnected());
 
   rv = sock->Connect(&callback);
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
-  EXPECT_TRUE(LogContainsSSLConnectEndEvent(log.entries(), -1));
+  log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
 
   sock->Disconnect();
   EXPECT_FALSE(sock->IsConnected());
@@ -109,8 +113,11 @@ TEST_F(SSLClientSocketTest, ConnectExpired) {
   EXPECT_FALSE(sock->IsConnected());
 
   rv = sock->Connect(&callback);
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
@@ -120,7 +127,8 @@ TEST_F(SSLClientSocketTest, ConnectExpired) {
   // test that the handshake has finished. This is because it may be
   // desirable to disconnect the socket before showing a user prompt, since
   // the user may take indefinitely long to respond.
-  EXPECT_TRUE(LogContainsSSLConnectEndEvent(log.entries(), -1));
+  log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
 }
 
 TEST_F(SSLClientSocketTest, ConnectMismatched) {
@@ -149,8 +157,10 @@ TEST_F(SSLClientSocketTest, ConnectMismatched) {
 
   rv = sock->Connect(&callback);
 
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
@@ -160,7 +170,8 @@ TEST_F(SSLClientSocketTest, ConnectMismatched) {
   // test that the handshake has finished. This is because it may be
   // desirable to disconnect the socket before showing a user prompt, since
   // the user may take indefinitely long to respond.
-  EXPECT_TRUE(LogContainsSSLConnectEndEvent(log.entries(), -1));
+  log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
 }
 
 // Attempt to connect to a page which requests a client certificate. It should
@@ -191,11 +202,16 @@ TEST_F(SSLClientSocketTest, FLAKY_ConnectClientAuthCertRequested) {
   EXPECT_FALSE(sock->IsConnected());
 
   rv = sock->Connect(&callback);
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
+  log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
   EXPECT_EQ(net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
   EXPECT_FALSE(sock->IsConnected());
 }
@@ -235,14 +251,18 @@ TEST_F(SSLClientSocketTest, ConnectClientAuthSendNullCert) {
   // Our test server accepts certificate-less connections.
   // TODO(davidben): Add a test which requires them and verify the error.
   rv = sock->Connect(&callback);
+
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
-  EXPECT_TRUE(LogContainsSSLConnectEndEvent(log.entries(), -1));
+  log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
 
   sock->Disconnect();
   EXPECT_FALSE(sock->IsConnected());
@@ -553,8 +573,10 @@ TEST_F(SSLClientSocketTest, MAYBE_CipherSuiteDisables) {
   EXPECT_FALSE(sock->IsConnected());
 
   rv = sock->Connect(&callback);
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      log.entries(), 5, net::NetLog::TYPE_SSL_CONNECT));
+      entries, 5, net::NetLog::TYPE_SSL_CONNECT));
 
   // NSS has special handling that maps a handshake_failure alert received
   // immediately after a client_hello to be a mismatched cipher suite error,
@@ -569,12 +591,13 @@ TEST_F(SSLClientSocketTest, MAYBE_CipherSuiteDisables) {
   // The exact ordering differs between SSLClientSocketNSS (which issues an
   // extra read) and SSLClientSocketMac (which does not). Just make sure the
   // error appears somewhere in the log.
-  net::ExpectLogContainsSomewhere(log.entries(), 0,
+  log.GetEntries(&entries);
+  net::ExpectLogContainsSomewhere(entries, 0,
                                   net::NetLog::TYPE_SSL_HANDSHAKE_ERROR,
                                   net::NetLog::PHASE_NONE);
 
   // We cannot test sock->IsConnected(), as the NSS implementation disconnects
   // the socket when it encounters an error, whereas other implementations
   // leave it connected.
-  EXPECT_TRUE(LogContainsSSLConnectEndEvent(log.entries(), -1));
+  EXPECT_TRUE(LogContainsSSLConnectEndEvent(entries, -1));
 }
diff --git a/net/socket/tcp_client_socket_unittest.cc b/net/socket/tcp_client_socket_unittest.cc
index 64d78f3..2ed9441 100644
--- a/net/socket/tcp_client_socket_unittest.cc
+++ b/net/socket/tcp_client_socket_unittest.cc
@@ -105,10 +105,13 @@ TEST_F(TCPClientSocketTest, Connect) {
   EXPECT_FALSE(sock_->IsConnected());
 
   int rv = sock_->Connect(&callback);
+
+  net::CapturingNetLog::EntryList net_log_entries;
+  net_log_.GetEntries(&net_log_entries);
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      net_log_.entries(), 0, net::NetLog::TYPE_SOCKET_ALIVE));
+      net_log_entries, 0, net::NetLog::TYPE_SOCKET_ALIVE));
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      net_log_.entries(), 1, net::NetLog::TYPE_TCP_CONNECT));
+      net_log_entries, 1, net::NetLog::TYPE_TCP_CONNECT));
   if (rv != OK) {
     ASSERT_EQ(rv, ERR_IO_PENDING);
     rv = callback.WaitForResult();
@@ -116,8 +119,9 @@ TEST_F(TCPClientSocketTest, Connect) {
   }
 
   EXPECT_TRUE(sock_->IsConnected());
+  net_log_.GetEntries(&net_log_entries);
   EXPECT_TRUE(net::LogContainsEndEvent(
-      net_log_.entries(), -1, net::NetLog::TYPE_TCP_CONNECT));
+      net_log_entries, -1, net::NetLog::TYPE_TCP_CONNECT));
 
   sock_->Disconnect();
   EXPECT_FALSE(sock_->IsConnected());
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index e3ce486..7400756 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -3343,33 +3343,36 @@ TEST_P(SpdyNetworkTransactionTest, NetLog) {
   // This test is intentionally non-specific about the exact ordering of the
   // log; instead we just check to make sure that certain events exist, and that
   // they are in the right order.
-  EXPECT_LT(0u, log.entries().size());
+  net::CapturingNetLog::EntryList entries;
+  log.GetEntries(&entries);
+
+  EXPECT_LT(0u, entries.size());
   int pos = 0;
-  pos = net::ExpectLogContainsSomewhere(log.entries(), 0,
+  pos = net::ExpectLogContainsSomewhere(entries, 0,
       net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
       net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
       net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
       net::NetLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
       net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
       net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
       net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
       net::NetLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
       net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
       net::NetLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+  pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
       net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
       net::NetLog::PHASE_END);
 
   // Check that we logged all the headers correctly
   pos = net::ExpectLogContainsSomewhere(
-      log.entries(), 0,
+      entries, 0,
       net::NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
       net::NetLog::PHASE_NONE);
-  CapturingNetLog::Entry entry = log.entries()[pos];
+  CapturingNetLog::Entry entry = entries[pos];
   NetLogSpdySynParameter* request_params =
       static_cast<NetLogSpdySynParameter*>(entry.extra_parameters.get());
   spdy::SpdyHeaderBlock* headers =