Add a new QuicChromiumClientSession::Handle class

net/quic/chromium/quic_stream_factory.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_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 589 matching lines @@
     net_log_ = net_log;
     callback_ = callback;
   } else {
     factory_ = nullptr;
   }
   if (rv == OK)
     DCHECK(session_);
   return rv;
 }
 
-void QuicStreamRequest::SetSession(QuicChromiumClientSession* session) {
-  DCHECK(session);
-  session_ = session->GetWeakPtr();
+void QuicStreamRequest::SetSession(
+    std::unique_ptr<QuicChromiumClientSession::Handle> session) {
+  session_ = move(session);
 }
 
 void QuicStreamRequest::OnRequestComplete(int rv) {
   factory_ = nullptr;
   base::ResetAndReturn(&callback_).Run(rv);
 }
 
 base::TimeDelta QuicStreamRequest::GetTimeDelayForWaitingJob() const {
   if (!factory_)
     return base::TimeDelta();
   return factory_->GetTimeDelayForWaitingJob(server_id_);
 }
 
 std::unique_ptr<HttpStream> QuicStreamRequest::CreateStream() {
-  if (!session_)
+  if (!session_ || !session_->IsConnected())
     return nullptr;
-  return base::MakeUnique<QuicHttpStream>(session_, http_server_properties_);
+
+  return base::MakeUnique<QuicHttpStream>(std::move(session_),
+                                          http_server_properties_);
 }
 
 std::unique_ptr<BidirectionalStreamImpl>
 QuicStreamRequest::CreateBidirectionalStreamImpl() {
-  if (!session_)
+  if (!session_ || !session_->IsConnected())
     return nullptr;
-  return base::MakeUnique<BidirectionalStreamQuicImpl>(session_);
+
+  return base::MakeUnique<BidirectionalStreamQuicImpl>(std::move(session_));
 }
 
 QuicStreamFactory::QuicStreamFactory(
     NetLog* net_log,
     HostResolver* host_resolver,
     SSLConfigService* ssl_config_service,
     ClientSocketFactory* client_socket_factory,
     HttpServerProperties* http_server_properties,
     ProxyDelegate* proxy_delegate,
     CertVerifier* cert_verifier,
@@ skipping 220 matching lines @@
   }
   DCHECK(server_id.host_port_pair().Equals(HostPortPair::FromURL(url)));
   // Enforce session affinity for promised streams.
   QuicClientPromisedInfo* promised =
       push_promise_index_.GetPromised(url.spec());
   if (promised) {
     QuicChromiumClientSession* session =
         static_cast<QuicChromiumClientSession*>(promised->session());
     DCHECK(session);
     if (session->server_id().privacy_mode() == server_id.privacy_mode()) {
-      request->SetSession(session);
+      request->SetSession(session->CreateHandle());
       ++num_push_streams_created_;
       return OK;
     }
     // This should happen extremely rarely (if ever), but if somehow a
     // request comes in with a mismatched privacy mode, consider the
     // promise borked.
     promised->Cancel();
   }
 
   // Use active session for |server_id| if such exists.
   // TODO(rtenneti): crbug.com/498823 - delete active_sessions_.empty() checks.
   if (!active_sessions_.empty()) {
     SessionMap::iterator it = active_sessions_.find(server_id);
     if (it != active_sessions_.end()) {
       QuicChromiumClientSession* session = it->second;
-      request->SetSession(session);
+      request->SetSession(session->CreateHandle());
       return OK;
     }
   }
 
   // Associate with active job to |server_id| if such exists.
   auto it = active_jobs_.find(server_id);
   if (it != active_jobs_.end()) {
     const NetLogWithSource& job_net_log = it->second->net_log();
     job_net_log.AddEvent(
         NetLogEventType::QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB,
         net_log.source().ToEventParametersCallback());
     net_log.AddEvent(
         NetLogEventType::HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB,
         job_net_log.source().ToEventParametersCallback());
     job_requests_map_[server_id].insert(request);
     return ERR_IO_PENDING;
   }
 
   // Pool to active session to |destination| if possible.
   if (!active_sessions_.empty()) {
     for (const auto& key_value : active_sessions_) {
       QuicChromiumClientSession* session = key_value.second;
       if (destination.Equals(all_sessions_[session].destination()) &&
           session->CanPool(server_id.host(), server_id.privacy_mode())) {
-        request->SetSession(session);
+        request->SetSession(session->CreateHandle());
         return OK;
       }
     }
   }
 
   // TODO(rtenneti): |task_runner_| is used by the Job. Initialize task_runner_
   // in the constructor after WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::ThreadTaskRunnerHandle::Get().get();
 
@@ skipping 13 matching lines @@
   if (rv == OK) {
     // TODO(rtenneti): crbug.com/498823 - revert active_sessions_.empty()
     // related changes.
     if (active_sessions_.empty())
       return ERR_QUIC_PROTOCOL_ERROR;
     SessionMap::iterator it = active_sessions_.find(server_id);
     DCHECK(it != active_sessions_.end());
     if (it == active_sessions_.end())
       return ERR_QUIC_PROTOCOL_ERROR;
     QuicChromiumClientSession* session = it->second;
-    request->SetSession(session);
+    request->SetSession(session->CreateHandle());
   }
   return rv;
 }
 
 QuicStreamFactory::QuicSessionKey::QuicSessionKey(
     const HostPortPair& destination,
     const QuicServerId& server_id)
     : destination_(destination), server_id_(server_id) {}
 
 bool QuicStreamFactory::QuicSessionKey::operator<(
@@ skipping 44 matching lines @@
   if (rv == OK) {
     set_require_confirmation(false);
 
     if (!requests_iter->second.empty()) {
       SessionMap::iterator session_it = active_sessions_.find(server_id);
       DCHECK(session_it != active_sessions_.end());
       QuicChromiumClientSession* session = session_it->second;
       for (QuicStreamRequest* request : requests_iter->second) {
         DCHECK(request->server_id() == server_id);
         // Do not notify |request| yet.
-        request->SetSession(session);
+        request->SetSession(session->CreateHandle());
       }
     }
   }
 
   // It's okay not to erase |request| from |requests_iter->second| because the
   // entire RequestSet will be erased from |job_requests_map_|.
   for (auto* request : requests_iter->second) {
     // Even though we're invoking callbacks here, we don't need to worry
     // about |this| being deleted, because the factory is owned by the
     // profile which can not be deleted via callbacks.
@@ skipping 675 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net