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

net/http/http_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 <math.h>  // ceil
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 176 matching lines @@
   CaptureGroupNameSocketPool() : TCPClientSocketPool(0, 0, NULL, NULL, NULL) {}
   const std::string last_group_name_received() const {
     return last_group_name_;
   }
 
   virtual int RequestSocket(const std::string& group_name,
                             const void* socket_params,
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback,
-                            LoadLog* load_log) {
+                            const BoundNetLog& net_log) {
     last_group_name_ = group_name;
     return ERR_IO_PENDING;
   }
   virtual void CancelRequest(const std::string& group_name,
                              const ClientSocketHandle* handle) { }
   virtual void ReleaseSocket(const std::string& group_name,
                              ClientSocket* socket) {}
   virtual void CloseIdleSockets() {}
   virtual HostResolver* GetHostResolver() const {
     return NULL;
@@ skipping 4065 matching lines @@
 
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  
+
   HostPortPair http_host_port_pair;
   http_host_port_pair.host = "www.google.com";
   http_host_port_pair.port = 80;
   const HttpAlternateProtocols& alternate_protocols =
       session->alternate_protocols();
   EXPECT_FALSE(
       alternate_protocols.HasAlternateProtocolFor(http_host_port_pair));
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 79 matching lines @@
   EXPECT_EQ(HttpAlternateProtocols::BROKEN, alternate.protocol);
 }
 
 // TODO(willchan): Redo this test to use TLS/NPN=>SPDY.  Currently, the code
 // says that it does SPDY, but it just does the TLS handshake, but the NPN
 // response does not indicate SPDY, so we just do standard HTTPS over the port.
 // We should add code such that we don't fallback to HTTPS, but fallback to HTTP
 // on the original port.
 //  TEST_F(HttpNetworkTransactionTest, UseAlternateProtocol) {
 //    SessionDependencies session_deps;
-//  
+//
 //    HttpRequestInfo request;
 //    request.method = "GET";
 //    request.url = GURL("http://www.google.com/");
 //    request.load_flags = 0;
-//  
+//
 //    MockRead data_reads[] = {
 //      MockRead("HTTP/1.1 200 OK\r\n\r\n"),
 //      MockRead("hello world"),
 //      MockRead(true, OK),
 //    };
 //    StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
 //    session_deps.socket_factory.AddSocketDataProvider(&data);
-//  
+//
 //    SSLSocketDataProvider ssl(true, OK);
 //    session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
-//  
+//
 //    TestCompletionCallback callback;
-//  
+//
 //    scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
-//  
+//
 //    HostPortPair http_host_port_pair;
 //    http_host_port_pair.host = "www.google.com";
 //    http_host_port_pair.port = 80;
 //    HttpAlternateProtocols* alternate_protocols =
 //        session->mutable_alternate_protocols();
 //    alternate_protocols->SetAlternateProtocolFor(
 //        http_host_port_pair, 1234 /* port is ignored */,
 //        HttpAlternateProtocols::NPN_SPDY);
-//  
+//
 //    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
-//  
+//
 //    int rv = trans->Start(&request, &callback, NULL);
 //    EXPECT_EQ(ERR_IO_PENDING, rv);
 //    EXPECT_EQ(OK, callback.WaitForResult());
-//  
+//
 //    const HttpResponseInfo* response = trans->GetResponseInfo();
 //    ASSERT_TRUE(response != NULL);
 //    ASSERT_TRUE(response->headers != NULL);
 //    EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
-//  
+//
 //    std::string response_data;
 //    ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
 //    EXPECT_EQ("hello world", response_data);
 //  }
 
 TEST_F(HttpNetworkTransactionTest, FailNpnSpdyAndFallback) {
   SessionDependencies session_deps;
 
   HttpRequestInfo request;
   request.method = "GET";
@@ skipping 38 matching lines @@
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 }
 
 }  // namespace net