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; }

[tyoshino-do-not-use, 2014/11/05 02:51:44]

NULL -> nullptr in this file

[yhirano, 2014/11/05 03:55:37]

Done.

 
   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 1072 matching lines @@
   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