Replace NULL with nullptr in WebSocket code in net/socket/

net/socket/websocket_transport_client_socket_pool_unittest.cc

 // Copyright 2014 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/socket/websocket_transport_client_socket_pool.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
             HostPortPair("www.google.com", 80),
             false,
             OnHostResolutionCallback(),
             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
         host_resolver_(new MockHostResolver),
         client_socket_factory_(&net_log_),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               host_resolver_.get(),
               &client_socket_factory_,
-              NULL) {}
+              nullptr) {}
 
   ~WebSocketTransportClientSocketPoolTest() override {
     RunUntilIdle();
     // ReleaseAllConnections() calls RunUntilIdle() after releasing each
     // connection.
     ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
     EXPECT_TRUE(WebSocketEndpointLockManager::GetInstance()->IsEmpty());
   }
 
   static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
@@ skipping 429 matching lines @@
   EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));
   RunUntilIdle();
   pool_.CancelRequest("a", request(0)->handle());
   EXPECT_THAT(request(1)->WaitForResult(), IsOk());
 }
 
 // Test the case of the IPv6 address stalling, and falling back to the IPv4
 // socket which finishes first.
 TEST_F(WebSocketTransportClientSocketPoolTest,
        IPv6FallbackSocketIPv4FinishesFirst) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   MockTransportClientSocketFactory::ClientSocketType case_types[] = {
       // This is the IPv6 socket.
       MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
       // This is the IPv4 socket.
       MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
 
   // Resolve an AddressList with an IPv6 address first and then an IPv4 address.
@@ skipping 16 matching lines @@
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_TRUE(endpoint.address().IsIPv4());
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 // Test the case of the IPv6 address being slow, thus falling back to trying to
 // connect to the IPv4 address, but having the connect to the IPv6 address
 // finish first.
 TEST_F(WebSocketTransportClientSocketPoolTest,
        IPv6FallbackSocketIPv6FinishesFirst) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   MockTransportClientSocketFactory::ClientSocketType case_types[] = {
       // This is the IPv6 socket.
       MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
       // This is the IPv4 socket.
       MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types, 2);
   client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds(
       TransportConnectJob::kIPv6FallbackTimerInMs + 50));
@@ skipping 15 matching lines @@
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_TRUE(endpoint.address().IsIPv6());
   EXPECT_EQ(2, client_socket_factory_.allocation_count());
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest,
        IPv6NoIPv4AddressesToFallbackTo) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv6 addresses.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
       handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,
                   callback.callback(), &pool, BoundNetLog());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_TRUE(endpoint.address().IsIPv6());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, IPv4HasNoFallback) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
 
   // Resolve an AddressList with only IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv =
       handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,
                   callback.callback(), &pool, BoundNetLog());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   IPEndPoint endpoint;
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_TRUE(endpoint.address().IsIPv4());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
 }
 
 // If all IPv6 addresses fail to connect synchronously, then IPv4 connections
 // proceeed immediately.
 TEST_F(WebSocketTransportClientSocketPoolTest, IPv6InstantFail) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   MockTransportClientSocketFactory::ClientSocketType case_types[] = {
       // First IPv6 socket.
       MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET,
       // Second IPv6 socket.
       MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET,
       // This is the IPv4 socket.
       MockTransportClientSocketFactory::MOCK_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types,
@@ skipping 12 matching lines @@
   ASSERT_TRUE(handle.socket());
 
   IPEndPoint endpoint;
   handle.socket()->GetPeerAddress(&endpoint);
   EXPECT_EQ("2.2.2.2", endpoint.ToStringWithoutPort());
 }
 
 // If all IPv6 addresses fail before the IPv4 fallback timeout, then the IPv4
 // connections proceed immediately.
 TEST_F(WebSocketTransportClientSocketPoolTest, IPv6RapidFail) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   MockTransportClientSocketFactory::ClientSocketType case_types[] = {
       // First IPv6 socket.
       MockTransportClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET,
       // Second IPv6 socket.
       MockTransportClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET,
       // This is the IPv4 socket.
       MockTransportClientSocketFactory::MOCK_CLIENT_SOCKET};
 
   client_socket_factory_.set_client_socket_types(case_types,
@@ skipping 20 matching lines @@
 
   IPEndPoint endpoint;
   handle.socket()->GetPeerAddress(&endpoint);
   EXPECT_EQ("2.2.2.2", endpoint.ToStringWithoutPort());
 }
 
 // If two sockets connect successfully, the one which connected first wins (this
 // can only happen if the sockets are different types, since sockets of the same
 // type do not race).
 TEST_F(WebSocketTransportClientSocketPoolTest, FirstSuccessWins) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_TRIGGERABLE_CLIENT_SOCKET);
 
   // Resolve an AddressList with an IPv6 addresses and an IPv4 address.
   host_resolver_->rules()->AddIPLiteralRule(
       "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
@@ skipping 14 matching lines @@
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   ASSERT_TRUE(handle.socket());
 
   IPEndPoint endpoint;
   handle.socket()->GetPeerAddress(&endpoint);
   EXPECT_EQ("2.2.2.2", endpoint.ToStringWithoutPort());
 }
 
 // We should not report failure until all connections have failed.
 TEST_F(WebSocketTransportClientSocketPoolTest, LastFailureWins) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_FAILING_CLIENT_SOCKET);
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(
       TransportConnectJob::kIPv6FallbackTimerInMs / 3);
   client_socket_factory_.set_delay(delay);
 
   // Resolve an AddressList with 4 IPv6 addresses and 2 IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule("*",
                                             "1:abcd::3:4:ff,2:abcd::3:4:ff,"
@@ skipping 18 matching lines @@
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
 
   EXPECT_GE(base::TimeTicks::Now() - start, delay * 5);
 }
 
 // Global timeout for all connects applies. This test is disabled by default
 // because it takes 4 minutes. Run with --gtest_also_run_disabled_tests if you
 // want to run it.
 TEST_F(WebSocketTransportClientSocketPoolTest, DISABLED_OverallTimeoutApplies) {
-  WebSocketTransportClientSocketPool pool(kMaxSockets,
-                                          kMaxSocketsPerGroup,
+  WebSocketTransportClientSocketPool pool(kMaxSockets, kMaxSocketsPerGroup,
                                           host_resolver_.get(),
-                                          &client_socket_factory_,
-                                          NULL);
+                                          &client_socket_factory_, nullptr);
   const base::TimeDelta connect_job_timeout = pool.ConnectionTimeout();
 
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_DELAYED_FAILING_CLIENT_SOCKET);
   client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(1) +
                                    connect_job_timeout / 6);
 
   // Resolve an AddressList with 6 IPv6 addresses and 6 IPv4 addresses.
   host_resolver_->rules()->AddIPLiteralRule("*",
                                             "1:abcd::3:4:ff,2:abcd::3:4:ff,"
@@ skipping 254 matching lines @@
   EXPECT_THAT(request(1)->WaitForResult(), IsOk());
   // Third socket should still be waiting for endpoint.
   ASSERT_FALSE(request(2)->handle()->is_initialized());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET,
             request(2)->handle()->GetLoadState());
 }
 
 }  // namespace
 
 }  // namespace net