Remove HttpStreamBase.

net/http/http_stream_factory_impl_unittest.cc

 // Copyright (c) 2012 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_stream_factory_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 40 matching lines @@
   };
 
   explicit MockWebSocketHandshakeStream(StreamType type) : type_(type) {}
 
   ~MockWebSocketHandshakeStream() override {}
 
   StreamType type() const {
     return type_;
   }
 
-  // HttpStreamBase methods
+  // HttpStream methods
   int InitializeStream(const HttpRequestInfo* request_info,
                        RequestPriority priority,
                        const BoundNetLog& net_log,
                        const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
   int SendRequest(const HttpRequestHeaders& request_headers,
                   HttpResponseInfo* response,
                   const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
@@ skipping 14 matching lines @@
   bool IsConnectionReusable() const override { return false; }
   int64 GetTotalReceivedBytes() const override { return 0; }
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
     return false;
   }
   void GetSSLInfo(SSLInfo* ssl_info) override {}
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
   bool IsSpdyHttpStream() const override { return false; }
   void Drain(HttpNetworkSession* session) override {}
   void SetPriority(RequestPriority priority) override {}
+  UploadProgress GetUploadProgress() const override { return UploadProgress(); }
+  HttpStream* RenewStreamForAuth() override { return nullptr; }
 
   scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
  private:
   const StreamType type_;
 };
 
 // HttpStreamFactoryImpl subclass that can wait until a preconnect is complete.
@@ skipping 29 matching lines @@
 class StreamRequestWaiter : public HttpStreamRequest::Delegate {
  public:
   StreamRequestWaiter()
       : waiting_for_stream_(false),
         stream_done_(false) {}
 
   // HttpStreamRequest::Delegate
 
   void OnStreamReady(const SSLConfig& used_ssl_config,
                      const ProxyInfo& used_proxy_info,
-                     HttpStreamBase* stream) override {
+                     HttpStream* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->Quit();
     stream_.reset(stream);
     used_ssl_config_ = used_ssl_config;
     used_proxy_info_ = used_proxy_info;
   }
 
   void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
@@ skipping 17 matching lines @@
                         const SSLConfig& used_ssl_config,
                         const ProxyInfo& used_proxy_info,
                         HttpAuthController* auth_controller) override {}
 
   void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
                          SSLCertRequestInfo* cert_info) override {}
 
   void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
                                   const SSLConfig& used_ssl_config,
                                   const ProxyInfo& used_proxy_info,
-                                  HttpStreamBase* stream) override {}
+                                  HttpStream* stream) override {}
 
   void WaitForStream() {
     while (!stream_done_) {
       waiting_for_stream_ = true;
       base::MessageLoop::current()->Run();
       waiting_for_stream_ = false;
     }
   }
 
   const SSLConfig& used_ssl_config() const {
     return used_ssl_config_;
   }
 
   const ProxyInfo& used_proxy_info() const {
     return used_proxy_info_;
   }
 
-  HttpStreamBase* stream() {
+  HttpStream* stream() {
     return stream_.get();
   }
 
   MockWebSocketHandshakeStream* websocket_stream() {
     return static_cast<MockWebSocketHandshakeStream*>(websocket_stream_.get());
   }
 
   bool stream_done() const { return stream_done_; }
 
  private:
   bool waiting_for_stream_;
   bool stream_done_;
-  scoped_ptr<HttpStreamBase> stream_;
+  scoped_ptr<HttpStream> stream_;
   scoped_ptr<WebSocketHandshakeStreamBase> websocket_stream_;
   SSLConfig used_ssl_config_;
   ProxyInfo used_proxy_info_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
 };
 
 class WebSocketSpdyHandshakeStream : public MockWebSocketHandshakeStream {
  public:
   explicit WebSocketSpdyHandshakeStream(
@@ skipping 150 matching lines @@
 typedef CapturePreconnectsSocketPool<HttpProxyClientSocketPool>
 CapturePreconnectsHttpProxySocketPool;
 typedef CapturePreconnectsSocketPool<SOCKSClientSocketPool>
 CapturePreconnectsSOCKSSocketPool;
 typedef CapturePreconnectsSocketPool<SSLClientSocketPool>
 CapturePreconnectsSSLSocketPool;
 
 template<typename ParentPool>
 CapturePreconnectsSocketPool<ParentPool>::CapturePreconnectsSocketPool(
     HostResolver* host_resolver, CertVerifier* /* cert_verifier */)
-    : ParentPool(0, 0, NULL, host_resolver, NULL, NULL),
+    : ParentPool(0, 0, nullptr, host_resolver, nullptr, nullptr),
       last_num_streams_(-1) {}
 
 template<>
 CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool(
     HostResolver* host_resolver, CertVerifier* /* cert_verifier */)
     : HttpProxyClientSocketPool(
-          0, 0, NULL, host_resolver, NULL, NULL, NULL, NULL),
+          0, 0, nullptr, host_resolver, nullptr, nullptr, nullptr, nullptr),
       last_num_streams_(-1) {}
 
 template <>
 CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
     HostResolver* host_resolver,
     CertVerifier* cert_verifier)
     : SSLClientSocketPool(0,
                           0,
-                          NULL,  // ssl_histograms
+                          nullptr,  // ssl_histograms
                           host_resolver,
                           cert_verifier,
-                          NULL,           // channel_id_store
-                          NULL,           // transport_security_state
-                          NULL,           // cert_transparency_verifier
+                          nullptr,           // channel_id_store
+                          nullptr,           // transport_security_state
+                          nullptr,           // cert_transparency_verifier
                           std::string(),  // ssl_session_cache_shard
-                          NULL,           // deterministic_socket_factory
-                          NULL,           // transport_socket_pool
-                          NULL,
-                          NULL,
-                          NULL,   // ssl_config_service
+                          nullptr,           // deterministic_socket_factory
+                          nullptr,           // transport_socket_pool
+                          nullptr,
+                          nullptr,
+                          nullptr,   // ssl_config_service
                           false,  // enable_ssl_connect_job_waiting
-                          NULL),  // net_log
+                          nullptr),  // net_log
       last_num_streams_(-1) {
 }
 
 class HttpStreamFactoryTest : public ::testing::Test,
                               public ::testing::WithParamInterface<NextProto> {
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     HttpStreamFactoryTest,
@@ skipping 227 matching lines @@
 
   SSLConfig used_ssl_config = waiter.used_ssl_config();
   EXPECT_EQ(used_ssl_config.channel_id_enabled, ssl_config.channel_id_enabled);
 }
 
 namespace {
 // Return count of distinct groups in given socket pool.
 int GetSocketPoolGroupCount(ClientSocketPool* pool) {
   int count = 0;
   scoped_ptr<base::DictionaryValue> dict(pool->GetInfoAsValue("", "", false));
-  EXPECT_TRUE(dict != NULL);
-  base::DictionaryValue* groups = NULL;
-  if (dict->GetDictionary("groups", &groups) && (groups != NULL)) {
+  EXPECT_TRUE(dict != nullptr);
+  base::DictionaryValue* groups = nullptr;
+  if (dict->GetDictionary("groups", &groups) && (groups != nullptr)) {
     count = static_cast<int>(groups->size());
   }
   return count;
 }
 }  // namespace
 
 TEST_P(HttpStreamFactoryTest, PrivacyModeUsesDifferentSocketPoolGroup) {
   SpdySessionDependencies session_deps(
       GetParam(), ProxyService::CreateDirect());
 
@@ skipping 96 matching lines @@
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory()->RequestStream(
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  ASSERT_TRUE(NULL != waiter.stream());
-  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter.stream());
+  EXPECT_TRUE(nullptr == waiter.websocket_stream());
   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
 
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 TEST_P(HttpStreamFactoryTest, RequestHttpStreamOverSSL) {
   SpdySessionDependencies session_deps(
       GetParam(), ProxyService::CreateDirect());
 
   MockRead mock_read(ASYNC, OK);
-  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  StaticSocketDataProvider socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   // Now request a stream.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("https://www.google.com");
   request_info.load_flags = 0;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory()->RequestStream(
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  ASSERT_TRUE(NULL != waiter.stream());
-  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter.stream());
+  EXPECT_TRUE(nullptr == waiter.websocket_stream());
   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
@@ skipping 23 matching lines @@
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory()->RequestStream(
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  ASSERT_TRUE(NULL != waiter.stream());
-  EXPECT_TRUE(NULL == waiter.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter.stream());
+  EXPECT_TRUE(nullptr == waiter.websocket_stream());
   EXPECT_FALSE(waiter.stream()->IsSpdyHttpStream());
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
       HttpNetworkSession::NORMAL_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::NORMAL_SOCKET_POOL,
@@ skipping 31 matching lines @@
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter,
                                             &create_helper,
                                             BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(NULL == waiter.stream());
-  ASSERT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_TRUE(nullptr == waiter.stream());
+  ASSERT_TRUE(nullptr != waiter.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
             waiter.websocket_stream()->type());
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 TEST_P(HttpStreamFactoryTest, RequestWebSocketBasicHandshakeStreamOverSSL) {
   SpdySessionDependencies session_deps(
       GetParam(), ProxyService::CreateDirect());
 
   MockRead mock_read(ASYNC, OK);
-  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  StaticSocketDataProvider socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   // Now request a stream.
   HttpRequestInfo request_info;
   request_info.method = "GET";
   request_info.url = GURL("wss://www.google.com");
   request_info.load_flags = 0;
 
   SSLConfig ssl_config;
   StreamRequestWaiter waiter;
   WebSocketStreamCreateHelper create_helper;
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter,
                                             &create_helper,
                                             BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(NULL == waiter.stream());
-  ASSERT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_TRUE(nullptr == waiter.stream());
+  ASSERT_TRUE(nullptr != waiter.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
             waiter.websocket_stream()->type());
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
@@ skipping 23 matching lines @@
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter,
                                             &create_helper,
                                             BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(NULL == waiter.stream());
-  ASSERT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_TRUE(nullptr == waiter.stream());
+  ASSERT_TRUE(nullptr != waiter.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
             waiter.websocket_stream()->type());
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
       HttpNetworkSession::NORMAL_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::NORMAL_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(1, GetSocketPoolGroupCount(session->GetSocketPoolForHTTPProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSocketPoolForSSLWithProxy(
       HttpNetworkSession::WEBSOCKET_SOCKET_POOL,
       HostPortPair("myproxy", 8888))));
   EXPECT_FALSE(waiter.used_proxy_info().is_direct());
 }
 
 TEST_P(HttpStreamFactoryTest, RequestSpdyHttpStream) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(ASYNC, OK);
-  DeterministicSocketData socket_data(&mock_read, 1, NULL, 0);
+  DeterministicSocketData socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.deterministic_socket_factory->AddSocketDataProvider(
       &socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   ssl_socket_data.SetNextProto(GetParam());
   session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
       &ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 443);
@@ skipping 12 matching lines @@
   scoped_ptr<HttpStreamRequest> request(
       session->http_stream_factory()->RequestStream(
           request_info,
           DEFAULT_PRIORITY,
           ssl_config,
           ssl_config,
           &waiter,
           BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(NULL == waiter.websocket_stream());
-  ASSERT_TRUE(NULL != waiter.stream());
+  EXPECT_TRUE(nullptr == waiter.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter.stream());
   EXPECT_TRUE(waiter.stream()->IsSpdyHttpStream());
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 // TODO(ricea): This test can be removed once the new WebSocket stack supports
 // SPDY. Currently, even if we connect to a SPDY-supporting server, we need to
 // use plain SSL.
 TEST_P(HttpStreamFactoryTest, RequestWebSocketSpdyHandshakeStreamButGetSSL) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
-  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  StaticSocketDataProvider socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 80);
   scoped_refptr<HttpNetworkSession>
       session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
@@ skipping 10 matching lines @@
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter1,
                                             &create_helper,
                                             BoundNetLog()));
   waiter1.WaitForStream();
   EXPECT_TRUE(waiter1.stream_done());
-  ASSERT_TRUE(NULL != waiter1.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter1.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeBasic,
             waiter1.websocket_stream()->type());
-  EXPECT_TRUE(NULL == waiter1.stream());
+  EXPECT_TRUE(nullptr == waiter1.stream());
 
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter1.used_proxy_info().is_direct());
 }
 
 // TODO(ricea): Re-enable once WebSocket-over-SPDY is implemented.
 TEST_P(HttpStreamFactoryTest, DISABLED_RequestWebSocketSpdyHandshakeStream) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
 
   MockRead mock_read(SYNCHRONOUS, ERR_IO_PENDING);
-  StaticSocketDataProvider socket_data(&mock_read, 1, NULL, 0);
+  StaticSocketDataProvider socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   ssl_socket_data.SetNextProto(GetParam());
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl_socket_data);
 
   HostPortPair host_port_pair("www.google.com", 80);
   scoped_refptr<HttpNetworkSession>
       session(SpdySessionDependencies::SpdyCreateSession(&session_deps));
@@ skipping 11 matching lines @@
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter1,
                                             &create_helper,
                                             BoundNetLog()));
   waiter1.WaitForStream();
   EXPECT_TRUE(waiter1.stream_done());
-  ASSERT_TRUE(NULL != waiter1.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter1.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
             waiter1.websocket_stream()->type());
-  EXPECT_TRUE(NULL == waiter1.stream());
+  EXPECT_TRUE(nullptr == waiter1.stream());
 
   StreamRequestWaiter waiter2;
   scoped_ptr<HttpStreamRequest> request2(
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter2,
                                             &create_helper,
                                             BoundNetLog()));
   waiter2.WaitForStream();
   EXPECT_TRUE(waiter2.stream_done());
-  ASSERT_TRUE(NULL != waiter2.websocket_stream());
+  ASSERT_TRUE(nullptr != waiter2.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
             waiter2.websocket_stream()->type());
-  EXPECT_TRUE(NULL == waiter2.stream());
+  EXPECT_TRUE(nullptr == waiter2.stream());
   EXPECT_NE(waiter2.websocket_stream(), waiter1.websocket_stream());
   EXPECT_EQ(static_cast<WebSocketSpdyHandshakeStream*>(
                 waiter2.websocket_stream())->spdy_session(),
             static_cast<WebSocketSpdyHandshakeStream*>(
                 waiter1.websocket_stream())->spdy_session());
 
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter1.used_proxy_info().is_direct());
 }
 
 // TODO(ricea): Re-enable once WebSocket over SPDY is implemented.
 TEST_P(HttpStreamFactoryTest, DISABLED_OrphanedWebSocketStream) {
   SpdySessionDependencies session_deps(GetParam(),
                                        ProxyService::CreateDirect());
   session_deps.use_alternate_protocols = true;
 
   MockRead mock_read(ASYNC, OK);
-  DeterministicSocketData socket_data(&mock_read, 1, NULL, 0);
+  DeterministicSocketData socket_data(&mock_read, 1, nullptr, 0);
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.deterministic_socket_factory->AddSocketDataProvider(
       &socket_data);
 
   MockRead mock_read2(ASYNC, OK);
-  DeterministicSocketData socket_data2(&mock_read2, 1, NULL, 0);
+  DeterministicSocketData socket_data2(&mock_read2, 1, nullptr, 0);
   socket_data2.set_connect_data(MockConnect(ASYNC, ERR_IO_PENDING));
   session_deps.deterministic_socket_factory->AddSocketDataProvider(
       &socket_data2);
 
   SSLSocketDataProvider ssl_socket_data(ASYNC, OK);
   ssl_socket_data.SetNextProto(GetParam());
   session_deps.deterministic_socket_factory->AddSSLSocketDataProvider(
       &ssl_socket_data);
 
   scoped_refptr<HttpNetworkSession>
@@ skipping 19 matching lines @@
       session->http_stream_factory_for_websocket()
           ->RequestWebSocketHandshakeStream(request_info,
                                             DEFAULT_PRIORITY,
                                             ssl_config,
                                             ssl_config,
                                             &waiter,
                                             &create_helper,
                                             BoundNetLog()));
   waiter.WaitForStream();
   EXPECT_TRUE(waiter.stream_done());
-  EXPECT_TRUE(NULL == waiter.stream());
-  ASSERT_TRUE(NULL != waiter.websocket_stream());
+  EXPECT_TRUE(nullptr == waiter.stream());
+  ASSERT_TRUE(nullptr != waiter.websocket_stream());
   EXPECT_EQ(MockWebSocketHandshakeStream::kStreamTypeSpdy,
             waiter.websocket_stream()->type());
 
   // Make sure that there was an alternative connection
   // which consumes extra connections.
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(2, GetSocketPoolGroupCount(
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net