Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/spdy/spdy_network_transaction_unittest.cc

 // 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/spdy/spdy_network_transaction.h"
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "net/base/completion_callback.h"
-#include "net/base/load_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
+#include "net/base/net_log_unittest.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_protocol.h"
 #include "testing/platform_test.h"
@@ skipping 256 matching lines @@
     std::string response_data;
     HttpResponseInfo response_info;
   };
 
   void EnableCompression(bool enabled) {
     spdy::SpdyFramer::set_enable_compression_default(enabled);
   }
 
   TransactionHelperResult TransactionHelper(const HttpRequestInfo& request,
                                             DelayedSocketData* data,
-                                            LoadLog* log) {
+                                            const BoundNetLog& log) {
     TransactionHelperResult out;
 
     // We disable SSL for this test.
     SpdySession::SetSSLMode(false);
 
     SessionDependencies session_deps;
     scoped_ptr<SpdyNetworkTransaction> trans(
         new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
     session_deps.socket_factory.AddSocketDataProvider(data);
@@ skipping 718 matching lines @@
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
   data->Reset();
 
   EnableCompression(false);
 }
 
-// Test that the LoadLog contains good data for a simple GET request.
-TEST_F(SpdyNetworkTransactionTest, LoadLog) {
+// Test that the NetLog contains good data for a simple GET request.
+TEST_F(SpdyNetworkTransactionTest, NetLog) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
   };
 
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kGetSynReply),
              arraysize(kGetSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kGetBodyFrame),
              arraysize(kGetBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
-  scoped_refptr<net::LoadLog> log(new net::LoadLog(net::LoadLog::kUnbounded));
+  net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelper(request, data.get(),
-                                                  log);
+                                                  log.bound());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
-  // Check that the LoadLog was filled reasonably.
+  // Check that the NetLog was filled reasonably.
   // This test is intentionally non-specific about the exact ordering of
   // the log; instead we just check to make sure that certain events exist.
-  EXPECT_LT(0u, log->entries().size());
+  EXPECT_LT(0u, log.entries().size());
   int pos = 0;
   // We know the first event at position 0.
   EXPECT_TRUE(net::LogContainsBeginEvent(
-      *log, 0, net::LoadLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION));
+      log.entries(), 0, net::NetLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION));
   // For the rest of the events, allow additional events in the middle,
   // but expect these to be logged in order.
-  pos = net::ExpectLogContainsSomewhere(log, 0,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION,
-      net::LoadLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST,
-      net::LoadLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST,
-      net::LoadLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS,
-      net::LoadLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS,
-      net::LoadLog::PHASE_END);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY,
-      net::LoadLog::PHASE_BEGIN);
-  pos = net::ExpectLogContainsSomewhere(log, pos + 1,
-      net::LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY,
-      net::LoadLog::PHASE_END);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), 0,
+      net::NetLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION,
+      net::NetLog::PHASE_END);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST,
+      net::NetLog::PHASE_BEGIN);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST,
+      net::NetLog::PHASE_END);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS,
+      net::NetLog::PHASE_BEGIN);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS,
+      net::NetLog::PHASE_END);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_READ_BODY,
+      net::NetLog::PHASE_BEGIN);
+  pos = net::ExpectLogContainsSomewhere(log.entries(), pos + 1,
+      net::NetLog::TYPE_SPDY_TRANSACTION_READ_BODY,
+      net::NetLog::PHASE_END);
 }
 
 // Since we buffer the IO from the stream to the renderer, this test verifies
 // that when we read out the maximum amount of data (e.g. we received 50 bytes
 // on the network, but issued a Read for only 5 of those bytes) that the data
 // flow still works correctly.
 TEST_F(SpdyNetworkTransactionTest, BufferFull) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
@@ skipping 504 matching lines @@
     FAIL() << "Unexpected read: " << rv;
   } while (rv > 0);
 
   // Flush the MessageLoop; this will cause the buffered IO task
   // to run for the final time.
   MessageLoop::current()->RunAllPending();
 }
 
 
 }  // namespace net