Add 3 Quic e2e tests of server push. No behavior change.

net/tools/quic/test_tools/quic_test_client.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/tools/quic/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 163 matching lines @@
                                const string& server_hostname,
                                const QuicConfig& config,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(server_address,
                                      QuicServerId(server_hostname,
                                                   server_address.port(),
                                                   PRIVACY_MODE_DISABLED),
                                      config,
                                      supported_versions,
                                      &epoll_server_)),
-      allow_bidirectional_data_(false) {
+      allow_bidirectional_data_(false),
+      num_requests_(0),
+      num_responses_(0) {
   Initialize();
 }
 
 QuicTestClient::QuicTestClient() : allow_bidirectional_data_(false) {}
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
     stream_->set_visitor(nullptr);
   }
   client_->Disconnect();
@@ skipping 71 matching lines @@
       // T-E header.
       string encoding;
       headers->GetAllOfHeaderAsString("transfer-encoding", &encoding);
       spdy_headers.insert(std::make_pair("transfer-encoding", encoding));
     }
     if (static_cast<StringPiece>(spdy_headers[":authority"]).empty()) {
       // HTTP/2 requests should include the :authority pseudo hader.
       spdy_headers[":authority"] = client_->server_id().host();
     }
     ret = stream->SendRequest(spdy_headers, body, fin);
+    ++num_requests_;
   } else {
     stream->SendBody(body.as_string(), fin, delegate);
     ret = body.length();
   }
   if (FLAGS_enable_quic_stateless_reject_support) {
     BalsaHeaders* new_headers = nullptr;
     if (headers) {
       new_headers = new BalsaHeaders;
       new_headers->CopyFrom(*headers);
     }
@@ skipping 283 matching lines @@
   response_headers_complete_ = stream_->headers_decompressed();
   SpdyBalsaUtils::SpdyHeadersToResponseHeaders(stream_->headers(), &headers_);
   response_trailers_ = stream_->trailers();
   stream_error_ = stream_->stream_error();
   bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read();
   bytes_written_ =
       stream_->stream_bytes_written() + stream_->header_bytes_written();
   response_header_size_ = headers_.GetSizeForWriteBuffer();
   response_body_size_ = stream_->data().size();
   stream_ = nullptr;
+  ++num_responses_;
 }
 
 bool QuicTestClient::CheckVary(const SpdyHeaderBlock& client_request,
                                const SpdyHeaderBlock& promise_request,
                                const SpdyHeaderBlock& promise_response) {
   return true;
 }
 
 void QuicTestClient::OnRendezvousResult(QuicSpdyStream* stream) {
   std::unique_ptr<TestClientDataToResend> data_to_resend =
@@ skipping 81 matching lines @@
   CHECK(message);
   message->headers()->SetRequestVersion(
       HTTPMessage::VersionToString(HttpConstants::HTTP_1_1));
   message->headers()->SetRequestMethod(
       HTTPMessage::MethodToString(HttpConstants::GET));
   message->headers()->SetRequestUri(uri);
 }
 
 }  // namespace test
 }  // namespace net