Avoid setting a duplicate SpdySessionKey on a Request

net/http/http_stream_factory_impl_request.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/http/http_stream_factory_impl_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
@@ skipping 36 matching lines @@
   for (std::set<Job*>::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     factory_->request_map_.erase(*it);
 
   RemoveRequestFromSpdySessionRequestMap();
 
   STLDeleteElements(&jobs_);
 }
 
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const SpdySessionKey& spdy_session_key) {
-  DCHECK(!spdy_session_key_.get());
+  CHECK(!spdy_session_key_.get());

[Ryan Hamilton, 2014/06/18 19:04:45]

Is this DCHECK -> CHECK change temporary? If not, it seems like the style guide
would argue for a DCHECK here.  (Not that I'm a big fan of the style guide's
recommendations here.)

[Johnny, 2014/06/18 19:13:20]

Not temporary. Switched to CHECK because we'd rather crash than double-enter the
request into |spdy_session_request_map_|.

   spdy_session_key_.reset(new SpdySessionKey(spdy_session_key));
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
@@ skipping 175 matching lines @@
     RequestSet& request_set =
         spdy_session_request_map[*spdy_session_key_];
     DCHECK(ContainsKey(request_set, this));
     request_set.erase(this);
     if (request_set.empty())
       spdy_session_request_map.erase(*spdy_session_key_);
     spdy_session_key_.reset();
   }
 }
 
+bool HttpStreamFactoryImpl::Request::HasSpdySessionKey() const {
+  return spdy_session_key_.get();
+}
+
 // TODO(jgraettinger): Currently, HttpStreamFactoryImpl::Job notifies a
 // Request that the session is ready, which in turn notifies it's delegate,
 // and then it notifies HttpStreamFactoryImpl so that /other/ requests may
 // be woken, but only if the spdy_session is still okay. This is tough to grok.
 // Instead, see if Job can notify HttpStreamFactoryImpl only, and have one
 // path for notifying any requests waiting for the session (including the
 // request which spawned it).
 void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
     Job* job,
     scoped_ptr<HttpStream> stream,
@@ skipping 96 matching lines @@
     }
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     OrphanJobsExcept(job);
     return;
   }
   DCHECK(jobs_.empty());
 }
 
 }  // namespace net