Create a QuicChromiumClientStream::Handle class for allowing a stream

net/quic/chromium/quic_http_stream.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/quic/chromium/quic_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
@@ skipping 90 matching lines @@
     return true;
   }
   // Now compare the client request for matching.
   return vary_data.MatchesRequest(client_request_info,
                                   *promise_response_info.headers.get());
 }
 
 void QuicHttpStream::OnRendezvousResult(QuicSpdyStream* stream) {
   push_handle_ = nullptr;
   if (stream) {
-    stream_ = static_cast<QuicChromiumClientStream*>(stream);
-    stream_->SetDelegate(this);
+    stream_ =
+        static_cast<QuicChromiumClientStream*>(stream)->CreateHandle(this);
   }
 
   // callback_ should only be non-null in the case of asynchronous
   // rendezvous; i.e. |Try()| returned QUIC_PENDING.
   if (callback_.is_null())
     return;
 
   DCHECK_EQ(STATE_HANDLE_PROMISE_COMPLETE, next_state_);
   if (!stream) {
     // rendezvous has failed so proceed as with a non-push request.
@@ skipping 228 matching lines @@
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void QuicHttpStream::Close(bool /*not_reusable*/) {
   session_error_ = ERR_ABORTED;
   SaveResponseStatus();
   // Note: the not_reusable flag has no meaning for QUIC streams.
   if (stream_) {
-    stream_->SetDelegate(nullptr);
+    stream_->ClearDelegate();
     stream_->Reset(QUIC_STREAM_CANCELLED);
   }
   ResetStream();
 }
 
 bool QuicHttpStream::IsResponseBodyComplete() const {
   return next_state_ == STATE_OPEN && !stream_;
 }
 
 bool QuicHttpStream::IsConnectionReused() const {
   // TODO(rch): do something smarter here.
   return stream_ && stream_->id() > 1;
 }
 
 int64_t QuicHttpStream::GetTotalReceivedBytes() const {
   // TODO(sclittle): Currently, this only includes headers and response body
   // bytes. Change this to include QUIC overhead as well.
   int64_t total_received_bytes = headers_bytes_received_;
   if (stream_) {
-    DCHECK_LE(stream_->sequencer()->NumBytesConsumed(),
-              stream_->stream_bytes_read());
+    DCHECK_LE(stream_->NumBytesConsumed(), stream_->stream_bytes_read());
     // Only count the uniquely received bytes.
-    total_received_bytes += stream_->sequencer()->NumBytesConsumed();
+    total_received_bytes += stream_->NumBytesConsumed();
   } else {
     total_received_bytes += closed_stream_received_bytes_;
   }
   return total_received_bytes;
 }
 
 int64_t QuicHttpStream::GetTotalSentBytes() const {
   // TODO(sclittle): Currently, this only includes request headers and body
   // bytes. Change this to include QUIC overhead as well.
   int64_t total_sent_bytes = headers_bytes_sent_;
@@ skipping 269 matching lines @@
 }
 
 int QuicHttpStream::DoReadRequestBodyComplete(int rv) {
   // If the stream is already closed, don't continue.
   if (!stream_)
     return GetResponseStatus();
 
   // |rv| is the result of read from the request body from the last call to
   // DoSendBody().
   if (rv < 0) {
-    stream_->SetDelegate(nullptr);
+    stream_->ClearDelegate();
     stream_->Reset(QUIC_ERROR_PROCESSING_STREAM);
     ResetStream();
     return rv;
   }
 
   request_body_buf_ = new DrainableIOBuffer(raw_request_body_buf_.get(), rv);
   if (rv == 0) {  // Reached the end.
     DCHECK(request_body_stream_->IsEOF());
   }
 
@@ skipping 72 matching lines @@
 int QuicHttpStream::ReadAvailableData(IOBuffer* buf, int buf_len) {
   int rv = stream_->Read(buf, buf_len);
   // TODO(rtenneti): Temporary fix for crbug.com/585591. Added a check for null
   // |stream_| to fix crash bug. Delete |stream_| check and histogram after fix
   // is merged.
   bool null_stream = stream_ == nullptr;
   UMA_HISTOGRAM_BOOLEAN("Net.QuicReadAvailableData.NullStream", null_stream);
   if (null_stream)
     return rv;
   if (stream_->IsDoneReading()) {
-    stream_->SetDelegate(nullptr);
+    stream_->ClearDelegate();
     stream_->OnFinRead();
     SetResponseStatus(OK);
     ResetStream();
   }
   return rv;
 }
 
 void QuicHttpStream::ResetStream() {
   if (push_handle_) {
     push_handle_->Cancel();
     push_handle_ = nullptr;
   }
   if (!stream_)
     return;
-  DCHECK_LE(stream_->sequencer()->NumBytesConsumed(),
-            stream_->stream_bytes_read());
+  DCHECK_LE(stream_->NumBytesConsumed(), stream_->stream_bytes_read());
   // Only count the uniquely received bytes.
-  closed_stream_received_bytes_ = stream_->sequencer()->NumBytesConsumed();
+  closed_stream_received_bytes_ = stream_->NumBytesConsumed();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   closed_is_first_stream_ = stream_->IsFirstStream();
+  stream_->ClearDelegate();
   stream_ = nullptr;
 
   // If |request_body_stream_| is non-NULL, Reset it, to abort any in progress
   // read.
   if (request_body_stream_)
     request_body_stream_->Reset();
 }
 
 int QuicHttpStream::GetResponseStatus() {
   SaveResponseStatus();
@@ skipping 33 matching lines @@
       quic_stream_error_ != QUIC_STREAM_CONNECTION_ERROR) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
 
   DCHECK_NE(QUIC_HANDSHAKE_TIMEOUT, quic_connection_error_);
 
   return ERR_QUIC_PROTOCOL_ERROR;
 }
 
 }  // namespace net