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

net/quic/chromium/quic_chromium_client_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/quic/chromium/quic_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 13 matching lines @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source_type.h"
 #include "net/quic/chromium/crypto/proof_verifier_chromium.h"
 #include "net/quic/chromium/quic_chromium_connection_helper.h"
 #include "net/quic/chromium/quic_chromium_packet_writer.h"
 #include "net/quic/chromium/quic_stream_factory.h"
 #include "net/quic/core/crypto/quic_server_info.h"
 #include "net/quic/core/quic_client_promised_info.h"
 #include "net/quic/core/quic_crypto_client_stream_factory.h"
 #include "net/quic/core/spdy_utils.h"
+#include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_info.h"
 #include "net/ssl/token_binding.h"
 #include "net/udp/datagram_client_socket.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 
 namespace net {
 
@@ skipping 111 matching lines @@
 };
 
 class HpackDecoderDebugVisitor : public QuicHeadersStream::HpackDebugVisitor {
   void OnUseEntry(QuicTime::Delta elapsed) override {
     UMA_HISTOGRAM_TIMES(
         "Net.QuicHpackDecoder.IndexedEntryAge",
         base::TimeDelta::FromMicroseconds(elapsed.ToMicroseconds()));
   }
 };
 
+class QuicServerPushHelper : public ServerPushDelegate::ServerPushHelper {
+ public:
+  explicit QuicServerPushHelper(
+      base::WeakPtr<QuicChromiumClientSession> session,
+      const GURL& url)
+      : session_(session), request_url_(url) {}
+
+  void Cancel() override {
+    if (session_) {
+      session_->CancelPush(request_url_);
+    }
+  }
+
+  const GURL& GetURL() override { return request_url_; }
+
+ private:
+  base::WeakPtr<QuicChromiumClientSession> session_;
+  const GURL request_url_;
+};
+
 }  // namespace
 
 QuicChromiumClientSession::StreamRequest::StreamRequest() : stream_(nullptr) {}
 
 QuicChromiumClientSession::StreamRequest::~StreamRequest() {
   CancelRequest();
 }
 
 int QuicChromiumClientSession::StreamRequest::StartRequest(
     const base::WeakPtr<QuicChromiumClientSession>& session,
@@ skipping 60 matching lines @@
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::QUIC_SESSION)),
       logger_(new QuicConnectionLogger(this,
                                        connection_description,
                                        std::move(socket_performance_watcher),
                                        net_log_)),
       going_away_(false),
       port_migration_detected_(false),
       token_binding_signatures_(kTokenBindingSignatureMapSize),
+      push_delegate_(nullptr),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
       bytes_pushed_count_(0),
       bytes_pushed_and_unclaimed_count_(0),
       migration_pending_(false),
       weak_factory_(this) {
   sockets_.push_back(std::move(socket));
   packet_readers_.push_back(base::MakeUnique<QuicChromiumPacketReader>(
       sockets_.back().get(), clock, this, yield_after_packets,
       yield_after_duration, net_log_));
@@ skipping 1156 matching lines @@
 bool QuicChromiumClientSession::HasNonMigratableStreams() const {
   for (const auto& stream : dynamic_streams()) {
     if (!static_cast<QuicChromiumClientStream*>(stream.second.get())
              ->can_migrate()) {
       return true;
     }
   }
   return false;
 }
 
-void QuicChromiumClientSession::HandlePromised(QuicStreamId id,
+bool QuicChromiumClientSession::HandlePromised(QuicStreamId id,
                                                QuicStreamId promised_id,
                                                const SpdyHeaderBlock& headers) {
-  QuicClientSessionBase::HandlePromised(id, promised_id, headers);
+  bool result = QuicClientSessionBase::HandlePromised(id, promised_id, headers);
+  if (result) {
+    // The push promise is accepted, notify the push_delegate that a push
+    // promise has been received.
+    GURL pushed_url = GetUrlFromHeaderBlock(headers);
+    if (push_delegate_) {
+      push_delegate_->OnPush(base::MakeUnique<QuicServerPushHelper>(
+          weak_factory_.GetWeakPtr(), pushed_url));
+    }
+  }
   net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PUSH_PROMISE_RECEIVED,
                     base::Bind(&NetLogQuicPushPromiseReceivedCallback, &headers,
                                id, promised_id));
+  return result;
 }
 
 void QuicChromiumClientSession::DeletePromised(
     QuicClientPromisedInfo* promised) {
   if (IsOpenStream(promised->id()))
     streams_pushed_and_claimed_count_++;
   QuicClientSessionBase::DeletePromised(promised);
 }
 
 void QuicChromiumClientSession::OnPushStreamTimedOut(QuicStreamId stream_id) {
   QuicSpdyStream* stream = GetPromisedStream(stream_id);
   if (stream != nullptr)
     bytes_pushed_and_unclaimed_count_ += stream->stream_bytes_read();
 }
 
 void QuicChromiumClientSession::CancelPush(const GURL& url) {
   QuicClientPromisedInfo* promised_info =
       QuicClientSessionBase::GetPromisedByUrl(url.spec());
-  if (!promised_info) {
-    // Push stream has already been claimed.
+  if (!promised_info || promised_info->is_validating()) {
+    // Push stream has already been claimed or is pending matched to a request.
     return;
   }
 
   QuicStreamId stream_id = promised_info->id();
 
   // Collect data on the cancelled push stream.
   QuicSpdyStream* stream = GetPromisedStream(stream_id);
   if (stream != nullptr)
     bytes_pushed_and_unclaimed_count_ += stream->stream_bytes_read();
 
   // Send the reset and remove the promised info from the promise index.
   QuicClientSessionBase::ResetPromised(stream_id, QUIC_STREAM_CANCELLED);
   DeletePromised(promised_info);
 }
 
 const LoadTimingInfo::ConnectTiming&
 QuicChromiumClientSession::GetConnectTiming() {
   connect_timing_.ssl_start = connect_timing_.connect_start;
   connect_timing_.ssl_end = connect_timing_.connect_end;
   return connect_timing_;
 }
 
 QuicVersion QuicChromiumClientSession::GetQuicVersion() const {
   return connection()->version();
 }
 
 }  // namespace net