[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
-SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session, bool direct)
+SpdyHttpStream::SpdyHttpStream(const base::WeakPtr<SpdySession>& spdy_session,
+                               bool direct)
     : weak_factory_(this),
       spdy_session_(spdy_session),
+      is_reused_(spdy_session_->IsReused()),
       stream_closed_(false),
       closed_stream_status_(ERR_FAILED),
       closed_stream_id_(0),
       request_info_(NULL),
       response_info_(NULL),
       response_headers_status_(RESPONSE_HEADERS_ARE_INCOMPLETE),
       user_buffer_len_(0),
       request_body_buf_size_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct) {
   DCHECK(spdy_session_.get());
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_.get()) {
     stream_->DetachDelegate();
     DCHECK(!stream_.get());
   }
 }
 
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
-  DCHECK(!stream_.get());
+  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, &stream_,
                                              stream_net_log);
     if (error != OK)
       return error;
 
     // |stream_| may be NULL even if OK was returned.
     if (stream_.get()) {
@@ skipping 87 matching lines @@
 
 bool SpdyHttpStream::IsResponseBodyComplete() const {
   return stream_closed_;
 }
 
 bool SpdyHttpStream::CanFindEndOfResponse() const {
   return true;
 }
 
 bool SpdyHttpStream::IsConnectionReused() const {
-  return spdy_session_->IsReused();
+  return is_reused_;
 }
 
 void SpdyHttpStream::SetConnectionReused() {
   // SPDY doesn't need an indicator here.
 }
 
 bool SpdyHttpStream::IsConnectionReusable() const {
   // SPDY streams aren't considered reusable.
   return false;
 }
 
 bool SpdyHttpStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
+  if (stream_closed_) {
+    if (!closed_stream_has_load_timing_info_)
+      return false;
+    *load_timing_info = closed_stream_load_timing_info_;
+    return true;
+  }
+
   // If |stream_| has yet to be created, or does not yet have an ID, fail.
   // The reused flag can only be correctly set once a stream has an ID.  Streams
   // get their IDs once the request has been successfully sent, so this does not
   // behave that differently from other stream types.
-  if (!spdy_session_.get() || (!stream_.get() && !stream_closed_))
+  if (!stream_ || stream_->stream_id() == 0)
     return false;
 
-  SpdyStreamId stream_id =
-      stream_closed_ ? closed_stream_id_ : stream_->stream_id();
-  if (stream_id == 0)
-    return false;
-
-  return spdy_session_->GetLoadTimingInfo(stream_id, load_timing_info);
+  return stream_->GetLoadTimingInfo(load_timing_info);
 }
 
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   if (stream_closed_) {
     if (stream_->type() == SPDY_PUSH_STREAM)
       return closed_stream_status_;
 
     return (closed_stream_status_ == OK) ? ERR_FAILED : closed_stream_status_;
@@ skipping 110 matching lines @@
   // Don't store the SSLInfo in the response here, HttpNetworkTransaction
   // will take care of that part.
   SSLInfo ssl_info;
   NextProto protocol_negotiated = kProtoUnknown;
   stream_->GetSSLInfo(&ssl_info,
                       &response_info_->was_npn_negotiated,
                       &protocol_negotiated);
   response_info_->npn_negotiated_protocol =
       SSLClientSocket::NextProtoToString(protocol_negotiated);
   response_info_->request_time = stream_->GetRequestTime();
-  switch (spdy_session_->GetProtocolVersion()) {
+  switch (stream_->GetProtocolVersion()) {
     case SPDY2:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY2;
       break;
     case SPDY3:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY3;
       break;
     case SPDY4:
       response_info_->connection_info = HttpResponseInfo::CONNECTION_INFO_SPDY4;
       break;
     default:
@@ skipping 30 matching lines @@
 void SpdyHttpStream::OnDataSent() {
   request_body_buf_size_ = 0;
   ReadAndSendRequestBodyData();
 }
 
 void SpdyHttpStream::OnClose(int status) {
   if (stream_.get()) {
     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_);
   }
   stream_.reset();
   bool invoked_callback = false;
   if (status == net::OK) {
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
   if (!invoked_callback && !callback_.is_null())
     DoCallback(status);
 }
@@ skipping 140 matching lines @@
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net