[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 222 matching lines @@
 SpdyStreamRequest::SpdyStreamRequest() {
   Reset();
 }
 
 SpdyStreamRequest::~SpdyStreamRequest() {
   CancelRequest();
 }
 
 int SpdyStreamRequest::StartRequest(
     SpdyStreamType type,
-    const scoped_refptr<SpdySession>& session,
+    const base::WeakPtr<SpdySession>& session,
     const GURL& url,
     RequestPriority priority,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
   DCHECK(session.get());
   DCHECK(!session_.get());
   DCHECK(!stream_.get());
   DCHECK(callback_.is_null());
 
   type_ = type;
@@ skipping 43 matching lines @@
   DCHECK(!stream_.get());
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
   Reset();
   DCHECK_NE(rv, OK);
   callback.Run(rv);
 }
 
 void SpdyStreamRequest::Reset() {
   type_ = SPDY_BIDIRECTIONAL_STREAM;
-  session_ = NULL;
+  session_.reset();
   stream_.reset();
   url_ = GURL();
   priority_ = MINIMUM_PRIORITY;
   net_log_ = BoundNetLog();
   callback_.Reset();
 }
 
 SpdySession::ActiveStreamInfo::ActiveStreamInfo()
     : stream(NULL),
       waiting_for_syn_reply(false) {}
@@ skipping 307 matching lines @@
     if (!connection_->socket()->IsConnected()) {
       CloseSessionResult result = DoCloseSession(
           ERR_CONNECTION_CLOSED,
           "Tried to create SPDY stream for a closed socket connection.");
       DCHECK_EQ(result, SESSION_CLOSED_AND_REMOVED);
       return ERR_CONNECTION_CLOSED;
     }
   }
 
   scoped_ptr<SpdyStream> new_stream(
-      new SpdyStream(request.type(), this, request.url(), request.priority(),
+      new SpdyStream(request.type(), GetWeakPtr(), request.url(),
+                     request.priority(),
                      stream_initial_send_window_size_,
                      stream_initial_recv_window_size_,
                      request.net_log()));
   *stream = new_stream->GetWeakPtr();
   InsertCreatedStream(new_stream.Pass());
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Net.SpdyPriorityCount",
       static_cast<int>(request.priority()), 0, 10, 11);
 
@@ skipping 70 matching lines @@
 
 void SpdySession::AddPooledAlias(const SpdySessionKey& alias_key) {
   pooled_aliases_.insert(alias_key);
 }
 
 int SpdySession::GetProtocolVersion() const {
   DCHECK(buffered_spdy_framer_.get());
   return buffered_spdy_framer_->protocol_version();
 }
 
+base::WeakPtr<SpdySession> SpdySession::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
 bool SpdySession::CloseOneIdleConnection() {
   CHECK(!in_io_loop_);
   DCHECK(pool_);
   DCHECK_NE(availability_state_, STATE_CLOSED);
   if (!active_streams_.empty())
     return false;
   base::WeakPtr<SpdySession> weak_ptr = weak_factory_.GetWeakPtr();
   CloseSessionResult result =
       DoCloseSession(ERR_CONNECTION_CLOSED, "Closing one idle connection.");
   DCHECK_EQ(result, SESSION_CLOSED_AND_REMOVED);
@@ skipping 582 matching lines @@
   return connection_->socket()->Write(
       write_io_buffer.get(),
       in_flight_write_->GetRemainingSize(),
       base::Bind(&SpdySession::PumpWriteLoop,
                  weak_factory_.GetWeakPtr(), WRITE_STATE_DO_WRITE_COMPLETE));
 }
 
 int SpdySession::DoWriteComplete(int result) {
   CHECK(in_io_loop_);
   DCHECK_NE(availability_state_, STATE_CLOSED);
-
+  DCHECK_NE(result, ERR_IO_PENDING);
   DCHECK_GT(in_flight_write_->GetRemainingSize(), 0u);
 
   last_activity_time_ = time_func_();
 
   if (result < 0) {
     DCHECK_NE(result, ERR_IO_PENDING);
     in_flight_write_.reset();
     in_flight_write_frame_type_ = DATA;
     in_flight_write_frame_size_ = 0;
     in_flight_write_stream_.reset();
@@ skipping 120 matching lines @@
       NetLog::TYPE_SPDY_SESSION_CLOSE,
       base::Bind(&NetLogSpdySessionCloseCallback, err, &description));
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.SpdySession.ClosedOnError", -err);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySession.BytesRead.OtherErrors",
                               total_bytes_received_, 1, 100000000, 50);
 
   // |pool_| will be NULL when |InitializeWithSocket()| is in the
   // call stack.
   if (pool_ && availability_state_ != STATE_GOING_AWAY)
-    pool_->MakeSessionUnavailable(make_scoped_refptr(this));
+    pool_->MakeSessionUnavailable(GetWeakPtr());
 
   availability_state_ = STATE_CLOSED;
   error_on_close_ = err;
 
   StartGoingAway(0, err);
   write_queue_.Clear();
 
   DcheckClosed();
 
   if (in_io_loop_)
     return SESSION_CLOSED_BUT_NOT_REMOVED;
 
   RemoveFromPool();
   return SESSION_CLOSED_AND_REMOVED;
 }
 
 void SpdySession::RemoveFromPool() {
   DcheckClosed();
   CHECK(pool_);
 
   SpdySessionPool* pool = pool_;
   pool_ = NULL;
-  pool->RemoveUnavailableSession(make_scoped_refptr(this));
+  pool->RemoveUnavailableSession(GetWeakPtr());
 }
 
 void SpdySession::LogAbandonedStream(SpdyStream* stream, Error status) {
   DCHECK(stream);
   std::string description = base::StringPrintf(
       "ABANDONED (stream_id=%d): ", stream->stream_id()) +
       stream->url().spec();
   stream->LogStreamError(status, description);
   // We don't increment the streams abandoned counter here. If the
   // stream isn't active (i.e., it hasn't written anything to the wire
@@ skipping 518 matching lines @@
       unclaimed_pushed_streams_.lower_bound(gurl);
   if (pushed_it != unclaimed_pushed_streams_.end() &&
       pushed_it->first == gurl) {
     SendResetStreamFrame(stream_id, request_priority, RST_STREAM_PROTOCOL_ERROR,
                          "Received duplicate pushed stream with url: " +
                          gurl.spec());
     return;
   }
 
   scoped_ptr<SpdyStream> stream(
-      new SpdyStream(SPDY_PUSH_STREAM, this, gurl,
+      new SpdyStream(SPDY_PUSH_STREAM, GetWeakPtr(), gurl,
                      request_priority,
                      stream_initial_send_window_size_,
                      stream_initial_recv_window_size_,
                      net_log_));
   stream->set_stream_id(stream_id);
 
   DeleteExpiredPushedStreams();
   PushedStreamMap::iterator inserted_pushed_it =
       unclaimed_pushed_streams_.insert(
           pushed_it,
@@ skipping 176 matching lines @@
       base::Bind(&NetLogSpdyGoAwayCallback,
                  last_accepted_stream_id,
                  active_streams_.size(),
                  unclaimed_pushed_streams_.size(),
                  status));
   if (availability_state_ < STATE_GOING_AWAY) {
     availability_state_ = STATE_GOING_AWAY;
     // |pool_| will be NULL when |InitializeWithSocket()| is in the
     // call stack.
     if (pool_)
-      pool_->MakeSessionUnavailable(make_scoped_refptr(this));
+      pool_->MakeSessionUnavailable(GetWeakPtr());
   }
   StartGoingAway(last_accepted_stream_id, ERR_ABORTED);
   // This is to handle the case when we already don't have any active
   // streams (i.e., StartGoingAway() did nothing). Otherwise, we have
   // active streams and so the last one being closed will finish the
   // going away process (see DeleteStream()).
   MaybeFinishGoingAway();
 }
 
 void SpdySession::OnPing(uint32 unique_id) {
@@ skipping 654 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net