Rework the logging for sockets/connectjobs....

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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 96 matching lines @@
   return ProxyService::CreateFixed(proxy_config);
 }
 
 HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
   return new HttpNetworkSession(NULL,
                                 session_deps->host_resolver,
                                 session_deps->proxy_service,
                                 &session_deps->socket_factory,
                                 session_deps->ssl_config_service,
                                 session_deps->spdy_session_pool,
-                                session_deps->http_auth_handler_factory.get());
+                                session_deps->http_auth_handler_factory.get(),
+                                NULL);
 }
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   virtual void SetUp() {
     spdy::SpdyFramer::set_enable_compression_default(false);
   }
 
   virtual void TearDown() {
     spdy::SpdyFramer::set_enable_compression_default(true);
@@ skipping 102 matching lines @@
   }
 }
 
 std::string MockGetHostName() {
   return "WTC-WIN7";
 }
 
 template<typename EmulatedClientSocketPool>
 class CaptureGroupNameSocketPool : public EmulatedClientSocketPool {
  public:
-  CaptureGroupNameSocketPool(HttpNetworkSession* session)
+  explicit CaptureGroupNameSocketPool(HttpNetworkSession* session)
       : EmulatedClientSocketPool(0, 0, NULL, session->host_resolver(), NULL,
-                                 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,
                             const BoundNetLog& net_log) {
@@ skipping 5329 matching lines @@
 
     EXPECT_EQ(L"myserver:80", response->auth_challenge->host_and_port);
     EXPECT_EQ(L"", response->auth_challenge->realm);
     EXPECT_EQ(L"mock", response->auth_challenge->scheme);
     auth_handler->ResetResolveExpectation();
   }
 }
 
 class TLSDecompressionFailureSocketDataProvider : public SocketDataProvider {
  public:
-  TLSDecompressionFailureSocketDataProvider(bool fail_all)
+  explicit TLSDecompressionFailureSocketDataProvider(bool fail_all)
       : fail_all_(fail_all) {
   }
 
   virtual MockRead GetNextRead() {
     if (fail_all_)
       return MockRead(false /* async */, ERR_SSL_DECOMPRESSION_FAILURE_ALERT);
 
     return MockRead(false /* async */,
                     "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nok.\r\n");
   }
@@ skipping 145 matching lines @@
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   HttpNetworkTransaction::SetNextProtos("");
   HttpNetworkTransaction::SetUseAlternateProtocols(false);
 }
 }  // namespace net