diff options
Diffstat (limited to 'net')
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 = |