Remove HttpStreamBase.

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 2013 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/url_request/url_request_http_job.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 34 matching lines @@
  protected:
   ~TestURLRequestHttpJob() override {}
 };
 
 class URLRequestHttpJobTest : public ::testing::Test {
  protected:
   URLRequestHttpJobTest()
       : req_(context_.CreateRequest(GURL("http://www.example.com"),
                                     DEFAULT_PRIORITY,
                                     &delegate_,
-                                    NULL)) {
+                                    nullptr)) {
     context_.set_http_transaction_factory(&network_layer_);
   }
 
   bool TransactionAcceptsSdchEncoding() {
     base::WeakPtr<MockNetworkTransaction> transaction(
         network_layer_.last_transaction());
     EXPECT_TRUE(transaction);
     if (!transaction) return false;
 
     const HttpRequestInfo* request_info = transaction->request();
@@ skipping 113 matching lines @@
   scoped_refptr<TestURLRequestHttpJob> job(
       new TestURLRequestHttpJob(req_.get()));
   job->Start();
   EXPECT_FALSE(TransactionAcceptsSdchEncoding());
 }
 
 // This base class just serves to set up some things before the TestURLRequest
 // constructor is called.
 class URLRequestHttpJobWebSocketTestBase : public ::testing::Test {
  protected:
-  URLRequestHttpJobWebSocketTestBase() : socket_data_(NULL, 0, NULL, 0),
+  URLRequestHttpJobWebSocketTestBase() : socket_data_(nullptr, 0, nullptr, 0),
                                          context_(true) {
     // A Network Delegate is required for the WebSocketHandshakeStreamBase
     // object to be passed on to the HttpNetworkTransaction.
     context_.set_network_delegate(&network_delegate_);
 
     // Attempting to create real ClientSocketHandles is not going to work out so
     // well. Set up a fake socket factory.
     socket_factory_.AddSocketDataProvider(&socket_data_);
     context_.set_client_socket_factory(&socket_factory_);
     context_.Init();
   }
 
   StaticSocketDataProvider socket_data_;
   TestNetworkDelegate network_delegate_;
   MockClientSocketFactory socket_factory_;
   TestURLRequestContext context_;
 };
 
 class URLRequestHttpJobWebSocketTest
     : public URLRequestHttpJobWebSocketTestBase {
  protected:
   URLRequestHttpJobWebSocketTest()
       : req_(context_.CreateRequest(GURL("ws://www.example.com"),
                                     DEFAULT_PRIORITY,
                                     &delegate_,
-                                    NULL)) {
+                                    nullptr)) {
     // The TestNetworkDelegate expects a call to NotifyBeforeURLRequest before
     // anything else happens.
     GURL url("ws://localhost/");
     TestCompletionCallback dummy;
     network_delegate_.NotifyBeforeURLRequest(
         req_.get(), dummy.callback(), &url);
   }
 
   TestDelegate delegate_;
   scoped_ptr<URLRequest> req_;
@@ skipping 71 matching lines @@
   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; }
+
   // Fake implementation of WebSocketHandshakeStreamBase method(s)
   scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
  private:
   bool initialize_stream_was_called_;
 };
 
 TEST_F(URLRequestHttpJobWebSocketTest, RejectedWithoutCreateHelper) {
@@ skipping 21 matching lines @@
   req_->SetLoadFlags(LOAD_DISABLE_CACHE);
   job->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_->status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 }  // namespace
 
 }  // namespace net