Server push cancellation: clean up the code to make sure shared code is in sync with internal code.

net/quic/core/quic_client_promised_info_test.cc

 // Copyright 2016 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_promised_info.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_client_promised_info_peer.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/quic/quic_client_session.h"
-#include "net/tools/quic/test_tools/push_promise_delegate.h"
 
 using std::string;
 using testing::StrictMock;
 
 namespace net {
 namespace test {
 namespace {
 
 class MockQuicClientSession : public QuicClientSession {
  public:
@@ skipping 157 matching lines @@
   ASSERT_NE(promised, nullptr);
 
   // Need to send the promised response headers and initiate the
   // rendezvous for secondary validation to proceed.
   QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
       session_.GetOrCreateStream(promise_id_));
   auto headers = AsHeaderList(headers_);
   promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
                                      headers);
 
-  PushPromiseDelegate delegate(/*match=*/false);
+  TestPushPromiseDelegate delegate(/*match=*/false);
   EXPECT_CALL(*connection_,
               SendRstStream(promise_id_, QUIC_PROMISE_VARY_MISMATCH, 0));
   EXPECT_CALL(session_, CloseStream(promise_id_));
 
   promised->HandleClientRequest(client_request_, &delegate);
 }
 
 TEST_F(QuicClientPromisedInfoTest, PushPromiseVaryWaits) {
   ReceivePromise(promise_id_);
 
   QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
+  EXPECT_FALSE(promised->is_validating());
   ASSERT_NE(promised, nullptr);
 
   // Now initiate rendezvous.
-  PushPromiseDelegate delegate(/*match=*/true);
+  TestPushPromiseDelegate delegate(/*match=*/true);
   promised->HandleClientRequest(client_request_, &delegate);
+  EXPECT_TRUE(promised->is_validating());
 
   // Promise is still there, waiting for response.
   EXPECT_NE(session_.GetPromisedById(promise_id_), nullptr);
 
   // Send Response, should trigger promise validation and complete rendezvous
   QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
       session_.GetOrCreateStream(promise_id_));
   ASSERT_NE(promise_stream, nullptr);
   auto headers = AsHeaderList(headers_);
   promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
@@ skipping 12 matching lines @@
   QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
       session_.GetOrCreateStream(promise_id_));
   ASSERT_NE(promise_stream, nullptr);
 
   // Send Response, should trigger promise validation and complete rendezvous
   auto headers = AsHeaderList(headers_);
   promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
                                      headers);
 
   // Now initiate rendezvous.
-  PushPromiseDelegate delegate(/*match=*/true);
+  TestPushPromiseDelegate delegate(/*match=*/true);
   promised->HandleClientRequest(client_request_, &delegate);
 
   // Promise is gone
   EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
   // Have a push stream
   EXPECT_TRUE(delegate.rendezvous_fired());
 
   EXPECT_NE(delegate.rendezvous_stream(), nullptr);
 }
 
 TEST_F(QuicClientPromisedInfoTest, PushPromiseWaitCancels) {
   ReceivePromise(promise_id_);
 
   QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
   ASSERT_NE(promised, nullptr);
 
   // Now initiate rendezvous.
-  PushPromiseDelegate delegate(/*match=*/true);
+  TestPushPromiseDelegate delegate(/*match=*/true);
   promised->HandleClientRequest(client_request_, &delegate);
 
   // Promise is still there, waiting for response.
   EXPECT_NE(session_.GetPromisedById(promise_id_), nullptr);
 
   // Create response stream, but no data yet.
   session_.GetOrCreateStream(promise_id_);
 
   // Cancel the promised stream.
   EXPECT_CALL(session_, CloseStream(promise_id_));
@@ skipping 19 matching lines @@
   auto headers = AsHeaderList(headers_);
   promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
                                      headers);
 
   EXPECT_CALL(session_, CloseStream(promise_id_));
   EXPECT_CALL(*connection_,
               SendRstStream(promise_id_, QUIC_STREAM_PEER_GOING_AWAY, 0));
   session_.SendRstStream(promise_id_, QUIC_STREAM_PEER_GOING_AWAY, 0);
 
   // Now initiate rendezvous.
-  PushPromiseDelegate delegate(/*match=*/true);
+  TestPushPromiseDelegate delegate(/*match=*/true);
   EXPECT_EQ(promised->HandleClientRequest(client_request_, &delegate),
             QUIC_FAILURE);
 
   // Got an indication of the stream failure, client should retry
   // request.
   EXPECT_FALSE(delegate.rendezvous_fired());
   EXPECT_EQ(delegate.rendezvous_stream(), nullptr);
 
   // Promise is gone
   EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net