Cleanup: Remove the implicit constructor for BoundNetLog that allowed passing...

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 "base/string_util.h"
 #include "net/base/completion_callback.h"
@@ skipping 713 matching lines @@
     MockRead(true, 0, 0)  // EOF
   };
 
   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(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_F(SpdyNetworkTransactionTest, Post) {
   static const char upload[] = { "hello world" };
 
   // Setup the request
@@ skipping 14 matching lines @@
     MockRead(true, reinterpret_cast<const char*>(kPostSynReply),
              arraysize(kPostSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kPostBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
-  TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that a simple POST works.
 TEST_F(SpdyNetworkTransactionTest, EmptyPost) {
 static const unsigned char kEmptyPostSyn[] = {
   0x80, 0x01, 0x00, 0x01,                                      // header
   0x01, 0x00, 0x00, 0x4a,                                      // flags, len
@@ skipping 27 matching lines @@
              arraysize(kPostSynReply)),
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kPostBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(1, reads, arraysize(reads),
                             writes, arraysize(writes)));
 
-  TransactionHelperResult out = TransactionHelper(request, data, NULL);
+  TransactionHelperResult out = TransactionHelper(request, data, BoundNetLog());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Test that the transaction doesn't crash when we don't have a reply.
 TEST_F(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
   MockRead reads[] = {
     MockRead(true, reinterpret_cast<const char*>(kPostBodyFrame),
              arraysize(kPostBodyFrame)),
     MockRead(true, 0, 0)  // EOF
   };
 
   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), NULL, 0));
-  TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
 }
 
 TEST_F(SpdyNetworkTransactionTest, CancelledTransaction) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSyn),
               arraysize(kGetSyn)),
     MockRead(true, 0, 0)  // EOF
   };
 
@@ skipping 18 matching lines @@
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
   session_deps.socket_factory.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   trans.reset();  // Cancel the transaction.
 
   // Flush the MessageLoop while the SessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 }
 
 // Verify that various SynReply headers parse correctly through the
 // HTTP layer.
@@ skipping 89 matching lines @@
       MockRead(true, 0, 0)  // EOF
     };
 
     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(), NULL);
+    TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                    BoundNetLog());
     EXPECT_EQ(OK, out.rv);
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
     EXPECT_EQ("hello!", out.response_data);
 
     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
     EXPECT_TRUE(headers.get() != NULL);
     void* iter = NULL;
     std::string name, value, lines;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
@@ skipping 132 matching lines @@
 
     for (int ct = 0; ct < header_count; ct++) {
       const char* header_key = test_cases[i].extra_headers[0][ct * 2];
       const char* header_value = test_cases[i].extra_headers[0][ct * 2 + 1];
       request.extra_headers.SetHeader(header_key, header_value);
     }
 
     scoped_refptr<DelayedSocketData> data(
         new DelayedSocketData(1, reads, arraysize(reads),
                               writes, arraysize(writes)));
-    TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+    TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                    BoundNetLog());
     EXPECT_EQ(OK, out.rv) << i;
     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line) << i;
     EXPECT_EQ("hello!", out.response_data) << i;
 
     // Test the response information.
     EXPECT_TRUE(out.response_info.response_time >
                 out.response_info.request_time) << i;
     base::TimeDelta test_delay = out.response_info.response_time -
                                  out.response_info.request_time;
     base::TimeDelta min_expected_delay;
@@ skipping 76 matching lines @@
       MockRead(true, 0, 0)  // EOF
     };
 
     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(), NULL);
+    TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                    BoundNetLog());
     EXPECT_EQ(ERR_INVALID_RESPONSE, out.rv);
   }
 }
 
 // Verify that we don't crash on some corrupt frames.
 TEST_F(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
   static const unsigned char kSynReplyMassiveLength[] = {
     0x80, 0x01, 0x00, 0x02,
     0x0f, 0x11, 0x11, 0x26,   // This is the length field with a big number
     0x00, 0x00, 0x00, 0x01,
@@ skipping 26 matching lines @@
       MockRead(true, 0, 0)  // EOF
     };
 
     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(), NULL);
+    TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                    BoundNetLog());
     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
   }
 }
 
 // Server push:
 // ------------
 // Client: Send the original SYN request.
 // Server: Receive the SYN request.
 // Server: Send a SYN reply, with X-Associated-Content and URL(s).
 // Server: For each URL, send a SYN_STREAM with the URL and a stream ID,
@@ skipping 50 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = url;
   request.load_flags = 0;
   TestCompletionCallback callback;
 
   // Allows the STOP_LOOP flag to work.
   data->SetCompletionCallback(&callback);
   // Sends a request.  In pass 1, this goes on the wire; in pass 2, it is
   // preempted by the push data.
-  int rv = trans.Start(&request, &callback, NULL);
+  int rv = trans.Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // In the case where we are pushing beforehand, complete the next read now.
   if ((pass == 2) && (test_type == PUSH_AFTER_REQUEST)) {
     data->CompleteRead();
   }
 
   // Process messages until either a FIN or a STOP_LOOP is encountered.
   rv = callback.WaitForResult();
   if ((pass == 2) && (test_type == PUSH_DURING_REQUEST)) {
@@ skipping 253 matching lines @@
     MockRead(true, 0, 0)  // EOF
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
-  TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(ERR_FAILED, out.rv);
   data->Reset();
 }
 
 // Test that partial writes work.
 TEST_F(SpdyNetworkTransactionTest, PartialWrite) {
   // Chop the SYN_STREAM frame into 5 chunks.
   const int kChunks = 5;
   scoped_array<MockWrite> writes(ChopFrame(
       reinterpret_cast<const char*>(kGetSyn), arraysize(kGetSyn), kChunks));
 
   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
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(kChunks, reads, arraysize(reads),
                             writes.get(), kChunks));
-  TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 TEST_F(SpdyNetworkTransactionTest, ConnectFailure) {
   MockConnect connects[]  = {
     MockConnect(true, ERR_NAME_NOT_RESOLVED),
     MockConnect(false, ERR_NAME_NOT_RESOLVED),
     MockConnect(true, ERR_INTERNET_DISCONNECTED),
@@ skipping 15 matching lines @@
       MockRead(true, 0, 0)  // EOF
     };
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
     scoped_refptr<DelayedSocketData> data(
         new DelayedSocketData(connects[index], 1, reads, arraysize(reads),
                               writes, arraysize(writes)));
-    TransactionHelperResult out = TransactionHelper(request, data.get(), NULL);
+    TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                    BoundNetLog());
     EXPECT_EQ(connects[index].result, out.rv);
   }
 }
 
 // In this test, we enable compression, but get a uncompressed SynReply from
 // the server.  Verify that teardown is all clean.
 TEST_F(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
   MockWrite writes[] = {
     MockWrite(true, reinterpret_cast<const char*>(kGetSynCompressed),
               arraysize(kGetSynCompressed)),
@@ skipping 11 matching lines @@
   // For this test, we turn on the normal compression.
   EnableCompression(true);
 
   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(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(ERR_SYN_REPLY_NOT_RECEIVED, out.rv);
   data->Reset();
 
   EnableCompression(false);
 }
 
 // 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),
@@ skipping 110 matching lines @@
   SpdySession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 85 matching lines @@
   SpdySession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 96 matching lines @@
   SpdySession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 84 matching lines @@
   SpdySession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 74 matching lines @@
   SpdySession::SetSSLMode(false);
 
   SessionDependencies session_deps;
   scoped_ptr<SpdyNetworkTransaction> trans(
       new SpdyNetworkTransaction(CreateSession(&session_deps)));
 
   session_deps.socket_factory.AddSocketDataProvider(data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback, NULL);
+  int rv = trans->Start(&request, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
   EXPECT_EQ(out.rv, OK);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.status_line = response->headers->GetStatusLine();
   out.response_info = *response;  // Make a copy so we can verify.
@@ skipping 102 matching lines @@
   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 = TransactionHelperWithSession(request,
                                                              data.get(),
-                                                             NULL,
+                                                             BoundNetLog(),
                                                              &session_deps,
                                                              session.get());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     spdy::SpdySettings saved_settings =
         session->spdy_settings().Get(host_port_pair);
@@ skipping 96 matching lines @@
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<DelayedSocketData> data(
       new DelayedSocketData(2, reads, arraysize(reads),
                             writes, arraysize(writes)));
   TransactionHelperResult out = TransactionHelperWithSession(request,
                                                              data.get(),
-                                                             NULL,
+                                                             BoundNetLog(),
                                                              &session_deps,
                                                              session.get());
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   {
     // Verify we had two persisted settings.
     spdy::SpdySettings saved_settings =
         session->spdy_settings().Get(host_port_pair);
@@ skipping 27 matching lines @@
     MockRead(true, 0, 0)  // EOF
   };
 
   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(), NULL);
+  TransactionHelperResult out = TransactionHelper(request, data.get(),
+                                                  BoundNetLog());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
 }
 
 }  // namespace net