Change WeakPtr<SpdyStream> to raw pointer in SpdyHttpStream.

net/spdy/spdy_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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
@@ skipping 18 matching lines @@
 
 namespace net {
 
 const size_t SpdyHttpStream::kRequestBodyBufferSize = 1 << 14;  // 16KB
 
 SpdyHttpStream::SpdyHttpStream(const base::WeakPtr<SpdySession>& spdy_session,
                                bool direct)
     : MultiplexedHttpStream(MultiplexedSessionHandle(spdy_session)),
       spdy_session_(spdy_session),
       is_reused_(spdy_session_->IsReused()),
+      stream_(nullptr),
       stream_closed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
       request_info_(NULL),
       response_info_(NULL),
       response_headers_complete_(false),
       user_buffer_len_(0),
       request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct),
       was_alpn_negotiated_(false),
       weak_factory_(this) {
   DCHECK(spdy_session_.get());
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
-  if (stream_.get()) {
+  if (stream_) {
     stream_->DetachDelegate();
-    DCHECK(!stream_.get());
+    DCHECK(!stream_);
   }
 }
 
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const NetLogWithSource& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_);
   if (!spdy_session_)
     return ERR_CONNECTION_CLOSED;
 
   request_info_ = request_info;
   if (request_info_->method == "GET") {
     int error = spdy_session_->GetPushStream(request_info_->url, priority,
                                              &stream_, stream_net_log);
     if (error != OK)
       return error;
 
     // |stream_| may be NULL even if OK was returned.
-    if (stream_.get()) {
+    if (stream_) {
       DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
       InitializeStreamHelper();
       return OK;
     }
   }
 
   int rv = stream_request_.StartRequest(
       SPDY_REQUEST_RESPONSE_STREAM, spdy_session_, request_info_->url,
       priority, stream_net_log,
       base::Bind(&SpdyHttpStream::OnStreamCreated,
                  weak_factory_.GetWeakPtr(), callback));
 
   if (rv == OK) {
-    stream_ = stream_request_.ReleaseStream();
+    stream_ = stream_request_.ReleaseStream().get();
     InitializeStreamHelper();
   }
 
   return rv;
 }
 
 int SpdyHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(!callback.is_null());
   if (stream_closed_)
     return closed_stream_status_;
 
-  CHECK(stream_.get());
+  CHECK(stream_);
 
   // Check if we already have the response headers. If so, return synchronously.
   if (response_headers_complete_) {
     CHECK(!stream_->IsIdle());
     return OK;
   }
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(response_callback_.is_null());
   response_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int SpdyHttpStream::ReadResponseBody(
     IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   // Invalidate HttpRequestInfo pointer. This is to allow the stream to be
   // shared across multiple transactions which might require this
   // stream to outlive the request_'s owner.
   // Only allowed when Reading of response body starts. It is safe to reset it
   // at this point since request_->upload_data_stream is also not needed
   // anymore.
   request_info_ = nullptr;
 
-  if (stream_.get())
+  if (stream_)
     CHECK(!stream_->IsIdle());
 
   CHECK(buf);
   CHECK(buf_len);
   CHECK(!callback.is_null());
 
   // If we have data buffered, complete the IO immediately.
   if (!response_body_queue_.IsEmpty()) {
     return response_body_queue_.Dequeue(buf->data(), buf_len);
   } else if (stream_closed_) {
     return closed_stream_status_;
   }
 
   CHECK(response_callback_.is_null());
   CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
   response_callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void SpdyHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
 
   Cancel();
-  DCHECK(!stream_.get());
+  DCHECK(!stream_);
 }
 
 bool SpdyHttpStream::IsResponseBodyComplete() const {
   return stream_closed_;
 }
 
 bool SpdyHttpStream::IsConnectionReused() const {
   return is_reused_;
 }
 
@@ skipping 36 matching lines @@
 }
 
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   if (stream_closed_) {
     return closed_stream_status_;
   }
 
   base::Time request_time = base::Time::Now();
-  CHECK(stream_.get());
+  CHECK(stream_);
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
   CHECK(!request_body_buf_.get());
   if (HasUploadData()) {
@@ skipping 50 matching lines @@
   if (result == ERR_IO_PENDING) {
     CHECK(request_callback_.is_null());
     request_callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
   request_callback_.Reset();
   response_callback_.Reset();
-  if (stream_.get()) {
+  if (stream_) {
     stream_->Cancel();
-    DCHECK(!stream_.get());
+    DCHECK(!stream_);
   }
 }
 
 void SpdyHttpStream::OnHeadersSent() {
   if (HasUploadData()) {
     ReadAndSendRequestBodyData();
   } else {
     MaybePostRequestCallback(OK);
   }
 }
@@ skipping 28 matching lines @@
     DoResponseCallback(OK);
   }
 }
 
 void SpdyHttpStream::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {
   DCHECK(response_headers_complete_);
 
   // Note that data may be received for a SpdyStream prior to the user calling
   // ReadResponseBody(), therefore user_buffer_ may be NULL.  This may often
   // happen for server initiated streams.
-  DCHECK(stream_.get());
+  DCHECK(stream_);
   DCHECK(!stream_->IsClosed() || stream_->type() == SPDY_PUSH_STREAM);
   if (buffer) {
     response_body_queue_.Enqueue(std::move(buffer));
 
     if (user_buffer_.get()) {
       // Handing small chunks of data to the caller creates measurable overhead.
       // We buffer data in short time-spans and send a single read notification.
       ScheduleBufferedReadCallback();
     }
   }
 }
 
 void SpdyHttpStream::OnDataSent() {
   request_body_buf_size_ = 0;
   ReadAndSendRequestBodyData();
 }
 
 // TODO(xunjieli): Maybe do something with the trailers. crbug.com/422958.
 void SpdyHttpStream::OnTrailers(const SpdyHeaderBlock& trailers) {}
 
 void SpdyHttpStream::OnClose(int status) {
   // Cancel any pending reads from the upload data stream.
   if (request_info_ && request_info_->upload_data_stream)
     request_info_->upload_data_stream->Reset();
 
-  if (stream_.get()) {
+  if (stream_) {
     stream_closed_ = true;
     closed_stream_status_ = status;
     closed_stream_id_ = stream_->stream_id();
     closed_stream_has_load_timing_info_ =
         stream_->GetLoadTimingInfo(&closed_stream_load_timing_info_);
     closed_stream_received_bytes_ = stream_->raw_received_bytes();
     closed_stream_sent_bytes_ = stream_->raw_sent_bytes();
   }
-  stream_.reset();
+  stream_ = nullptr;
 
   // Callbacks might destroy |this|.
   base::WeakPtr<SpdyHttpStream> self = weak_factory_.GetWeakPtr();
 
   if (!request_callback_.is_null()) {
     DoRequestCallback(status);
     if (!self)
       return;
   }
 
@@ skipping 14 matching lines @@
   return
       request_info_->upload_data_stream &&
       ((request_info_->upload_data_stream->size() > 0) ||
        request_info_->upload_data_stream->is_chunked());
 }
 
 void SpdyHttpStream::OnStreamCreated(
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK) {
-    stream_ = stream_request_.ReleaseStream();
+    stream_ = stream_request_.ReleaseStream().get();
     InitializeStreamHelper();
   }
   callback.Run(rv);
 }
 
 void SpdyHttpStream::ReadAndSendRequestBodyData() {
   CHECK(HasUploadData());
   CHECK_EQ(request_body_buf_size_, 0);
   if (request_info_->upload_data_stream->IsEOF()) {
     MaybePostRequestCallback(OK);
@@ skipping 78 matching lines @@
   DCHECK_GT(user_buffer_len_, 0);
   return response_body_queue_.GetTotalSize() <
       static_cast<size_t>(user_buffer_len_);
 }
 
 void SpdyHttpStream::DoBufferedReadCallback() {
   buffered_read_callback_pending_ = false;
 
   // If the transaction is cancelled or errored out, we don't need to complete
   // the read.
-  if (!stream_.get() && !stream_closed_)
+  if (!stream_ && !stream_closed_)
     return;
 
   int stream_status =
       stream_closed_ ? closed_stream_status_ : stream_->response_status();
   if (stream_status != OK)
     return;
 
   // When more_read_data_pending_ is true, it means that more data has
   // arrived since we started waiting.  Wait a little longer and continue
   // to buffer.
@@ skipping 55 matching lines @@
   details->connection_info = HttpResponseInfo::CONNECTION_INFO_HTTP2;
   return;
 }
 
 void SpdyHttpStream::SetPriority(RequestPriority priority) {
   // TODO(akalin): Plumb this through to |stream_request_| and
   // |stream_|.
 }
 
 }  // namespace net