Pass net_log parameter properly for ProxyResolvingClientSocket

jingle/notifier/base/chrome_async_socket_unittest.cc

 // Copyright (c) 2011 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 "jingle/notifier/base/chrome_async_socket.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <arpa/inet.h>
 #endif
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "jingle/notifier/base/resolving_client_socket_factory.h"
-#include "net/base/capturing_net_log.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/net_errors.h"
-#include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "talk/base/sigslot.h"
 #include "talk/base/socketaddress.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace notifier {
 
 namespace {
@@ skipping 89 matching lines @@
  public:
   MockXmppClientSocketFactory(
       net::ClientSocketFactory* mock_client_socket_factory,
       const net::AddressList& address_list)
           : mock_client_socket_factory_(mock_client_socket_factory),
             address_list_(address_list) {
   }
 
   // ResolvingClientSocketFactory implementation.
   virtual net::StreamSocket* CreateTransportClientSocket(
-      const net::HostPortPair& host_and_port, net::NetLog* net_log) {
+      const net::HostPortPair& host_and_port) {
     return mock_client_socket_factory_->CreateTransportClientSocket(
-        address_list_, net_log, net::NetLog::Source());
+        address_list_, NULL, net::NetLog::Source());
   }
 
   virtual net::SSLClientSocket* CreateSSLClientSocket(
       net::ClientSocketHandle* transport_socket,
       const net::HostPortPair& host_and_port) {
     return mock_client_socket_factory_->CreateSSLClientSocket(
         transport_socket, host_and_port, ssl_config_, NULL, &cert_verifier_,
         NULL);
   }
 
  private:
   scoped_ptr<net::ClientSocketFactory> mock_client_socket_factory_;
   net::AddressList address_list_;
   net::SSLConfig ssl_config_;
   net::CertVerifier cert_verifier_;
 };
 
 class ChromeAsyncSocketTest
     : public testing::Test,
       public sigslot::has_slots<> {
  protected:
   ChromeAsyncSocketTest()
       : ssl_socket_data_provider_(true, net::OK),
-        capturing_net_log_(net::CapturingNetLog::kUnbounded),
         addr_(0xaabbccdd, 35) {}
 
   virtual ~ChromeAsyncSocketTest() {}
 
   virtual void SetUp() {
     scoped_ptr<net::MockClientSocketFactory> mock_client_socket_factory(
         new net::MockClientSocketFactory());
     mock_client_socket_factory->AddSocketDataProvider(
         &async_socket_data_provider_);
     mock_client_socket_factory->AddSSLSocketDataProvider(
         &ssl_socket_data_provider_);
 
     scoped_ptr<MockXmppClientSocketFactory> mock_xmpp_client_socket_factory(
         new MockXmppClientSocketFactory(
             mock_client_socket_factory.release(),
             SocketAddressToAddressList(addr_)));
     chrome_async_socket_.reset(
         new ChromeAsyncSocket(mock_xmpp_client_socket_factory.release(),
-                              14, 20,
-                              &capturing_net_log_)),
+                              14, 20)),
 
     chrome_async_socket_->SignalConnected.connect(
         this, &ChromeAsyncSocketTest::OnConnect);
     chrome_async_socket_->SignalSSLConnected.connect(
         this, &ChromeAsyncSocketTest::OnSSLConnect);
     chrome_async_socket_->SignalClosed.connect(
         this, &ChromeAsyncSocketTest::OnClose);
     chrome_async_socket_->SignalRead.connect(
         this, &ChromeAsyncSocketTest::OnRead);
     chrome_async_socket_->SignalError.connect(
@@ skipping 233 matching lines @@
     }
     return read;
   }
 
   // ChromeAsyncSocket expects a message loop.
   MessageLoop message_loop_;
 
   AsyncSocketDataProvider async_socket_data_provider_;
   net::SSLSocketDataProvider ssl_socket_data_provider_;
 
-  net::CapturingNetLog capturing_net_log_;
   scoped_ptr<ChromeAsyncSocket> chrome_async_socket_;
   std::deque<SignalSocketState> signal_socket_states_;
   const talk_base::SocketAddress addr_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeAsyncSocketTest);
 };
 
 TEST_F(ChromeAsyncSocketTest, InitialState) {
   ExpectClosed();
@@ skipping 627 matching lines @@
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace notifier