Server push cancellation: add PushPromiseHelper which reflects information on the push promise.

net/quic/core/quic_client_session_base.cc

 // Copyright 2014 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/core/quic_client_session_base.h"
 
 #include "net/quic/core/quic_client_promised_info.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/spdy_utils.h"
 
@@ skipping 92 matching lines @@
   largest_promised_stream_id_ = promised_stream_id;
 
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (!stream) {
     // It's quite possible to receive headers after a stream has been reset.
     return;
   }
   stream->OnPromiseHeaderList(promised_stream_id, frame_len, header_list);
 }
 
-void QuicClientSessionBase::HandlePromised(QuicStreamId /* associated_id */,
+bool QuicClientSessionBase::HandlePromised(QuicStreamId /* associated_id */,
                                            QuicStreamId id,
                                            const SpdyHeaderBlock& headers) {
   // Due to pathalogical packet re-ordering, it is possible that
   // frames for the promised stream have already arrived, and the
   // promised stream could be active or closed.
   if (IsClosedStream(id)) {
     // There was a RST on the data stream already, perhaps
     // QUIC_REFUSED_STREAM?
     DVLOG(1) << "Promise ignored for stream " << id
              << " that is already closed";
-    return;
+    return false;
   }
 
   if (push_promise_index_->promised_by_url()->size() >= get_max_promises()) {
     DVLOG(1) << "Too many promises, rejecting promise for stream " << id;
     ResetPromised(id, QUIC_REFUSED_STREAM);
-    return;
+    return false;
   }
 
   const string url = SpdyUtils::GetUrlFromHeaderBlock(headers);
   QuicClientPromisedInfo* old_promised = GetPromisedByUrl(url);
   if (old_promised) {
     DVLOG(1) << "Promise for stream " << id << " is duplicate URL " << url
              << " of previous promise for stream " << old_promised->id();
     ResetPromised(id, QUIC_DUPLICATE_PROMISE_URL);
-    return;
+    return false;
   }
 
   if (GetPromisedById(id)) {
     // OnPromiseHeadersComplete() would have closed the connection if
     // promised id is a duplicate.
     QUIC_BUG << "Duplicate promise for id " << id;
-    return;
+    return false;
   }
 
   QuicClientPromisedInfo* promised = new QuicClientPromisedInfo(this, id, url);
   std::unique_ptr<QuicClientPromisedInfo> promised_owner(promised);
   promised->Init();
   DVLOG(1) << "stream " << id << " emplace url " << url;
   (*push_promise_index_->promised_by_url())[url] = promised;
   promised_by_id_[id] = std::move(promised_owner);
   promised->OnPromiseHeaders(headers);
+  return true;
 }
 
 QuicClientPromisedInfo* QuicClientSessionBase::GetPromisedByUrl(
     const string& url) {
   QuicPromisedByUrlMap::iterator it =
       push_promise_index_->promised_by_url()->find(url);
   if (it != push_promise_index_->promised_by_url()->end()) {
     return it->second;
   }
   return nullptr;
@@ skipping 42 matching lines @@
                                              bool locally_reset) {
   QuicSpdySession::CloseStreamInner(stream_id, locally_reset);
   headers_stream()->MaybeReleaseSequencerBuffer();
 }
 
 bool QuicClientSessionBase::ShouldReleaseHeadersStreamSequencerBuffer() {
   return num_active_requests() == 0 && promised_by_id_.empty();
 }
 
 }  // namespace net