Remove HttpStreamBase.

net/websockets/websocket_basic_handshake_stream.cc

 // Copyright 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/websockets/websocket_basic_handshake_stream.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 109 matching lines @@
                                const std::vector<std::string>& value,
                                HttpRequestHeaders* headers) {
   if (value.empty())
     return;
   headers->SetHeader(name, JoinString(value, ", "));
 }
 
 GetHeaderResult GetSingleHeaderValue(const HttpResponseHeaders* headers,
                                      const base::StringPiece& name,
                                      std::string* value) {
-  void* state = NULL;
+  void* state = nullptr;
   size_t num_values = 0;
   std::string temp_value;
   while (headers->EnumerateHeader(&state, name, &temp_value)) {
     if (++num_values > 1)
       return GET_HEADER_MULTIPLE;
     *value = temp_value;
   }
   return num_values > 0 ? GET_HEADER_OK : GET_HEADER_MISSING;
 }
 
@@ skipping 63 matching lines @@
     return false;
   }
   return true;
 }
 
 bool ValidateSubProtocol(
     const HttpResponseHeaders* headers,
     const std::vector<std::string>& requested_sub_protocols,
     std::string* sub_protocol,
     std::string* failure_message) {
-  void* state = NULL;
+  void* state = nullptr;
   std::string value;
   base::hash_set<std::string> requested_set(requested_sub_protocols.begin(),
                                             requested_sub_protocols.end());
   int count = 0;
   bool has_multiple_protocols = false;
   bool has_invalid_protocol = false;
 
   while (!has_invalid_protocol || !has_multiple_protocols) {
     std::string temp_value;
     if (!headers->EnumerateHeader(
@@ skipping 97 matching lines @@
   }
   params->deflate_enabled = true;
   return true;
 }
 
 bool ValidateExtensions(const HttpResponseHeaders* headers,
                         const std::vector<std::string>& requested_extensions,
                         std::string* extensions,
                         std::string* failure_message,
                         WebSocketExtensionParams* params) {
-  void* state = NULL;
+  void* state = nullptr;
   std::string value;
   std::vector<std::string> accepted_extensions;
   // TODO(ricea): If adding support for additional extensions, generalise this
   // code.
   bool seen_permessage_deflate = false;
   while (headers->EnumerateHeader(
              &state, websockets::kSecWebSocketExtensions, &value)) {
     WebSocketExtensionParser parser;
     parser.Parse(value);
     if (parser.has_error()) {
@@ skipping 30 matching lines @@
 
 WebSocketBasicHandshakeStream::WebSocketBasicHandshakeStream(
     scoped_ptr<ClientSocketHandle> connection,
     WebSocketStream::ConnectDelegate* connect_delegate,
     bool using_proxy,
     std::vector<std::string> requested_sub_protocols,
     std::vector<std::string> requested_extensions,
     std::string* failure_message)
     : state_(connection.release(), using_proxy),
       connect_delegate_(connect_delegate),
-      http_response_info_(NULL),
+      http_response_info_(nullptr),
       requested_sub_protocols_(requested_sub_protocols),
       requested_extensions_(requested_extensions),
       failure_message_(failure_message) {
   DCHECK(connect_delegate);
   DCHECK(failure_message);
 }
 
 WebSocketBasicHandshakeStream::~WebSocketBasicHandshakeStream() {}
 
 int WebSocketBasicHandshakeStream::InitializeStream(
@@ skipping 129 matching lines @@
   HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(this);
   drainer->Start(session);
   // |drainer| will delete itself.
 }
 
 void WebSocketBasicHandshakeStream::SetPriority(RequestPriority priority) {
   // TODO(ricea): See TODO comment in HttpBasicStream::SetPriority(). If it is
   // gone, then copy whatever has happened there over here.
 }
 
+UploadProgress WebSocketBasicHandshakeStream::GetUploadProgress() const {
+  return UploadProgress();
+}
+
+HttpStream* WebSocketBasicHandshakeStream::RenewStreamForAuth() {
+  // Return null because we don't support renewing the stream.
+  return nullptr;
+}
+
 scoped_ptr<WebSocketStream> WebSocketBasicHandshakeStream::Upgrade() {
   // The HttpStreamParser object has a pointer to our ClientSocketHandle. Make
   // sure it does not touch it again before it is destroyed.
   state_.DeleteParser();
   WebSocketTransportClientSocketPool::UnlockEndpoint(state_.connection());
   scoped_ptr<WebSocketStream> basic_stream(
       new WebSocketBasicStream(state_.ReleaseConnection(),
                                state_.read_buf(),
                                sub_protocol_,
                                extensions_));
@@ skipping 127 matching lines @@
   set_failure_message("Error during WebSocket handshake: " + failure_message);
   return ERR_INVALID_RESPONSE;
 }
 
 void WebSocketBasicHandshakeStream::set_failure_message(
     const std::string& failure_message) {
   *failure_message_ = failure_message;
 }
 
 }  // namespace net