Disable QUIC 0RTT for POST requests.

Review URL: https://codereview.chromium.org/149443007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@249198 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 212 insertions, 96 deletions

diff --git a/net/http/http_stream_factory_impl_job.cc b/net/http/http_stream_factory_impl_job.cc
index 40e2771..131a8db 100644
--- a/net/http/http_stream_factory_impl_job.cc
+++ b/net/http/http_stream_factory_impl_job.cc
@@ -760,8 +760,8 @@ int HttpStreamFactoryImpl::Job::DoInitConnection() {
     next_state_ = STATE_INIT_CONNECTION_COMPLETE;
     bool secure_quic = using_ssl_ || proxy_info_.is_quic();
     int rv = quic_request_.Request(
-        destination, secure_quic, session_->cert_verifier(), net_log_,
-        io_callback_);
+        destination, secure_quic, request_info_.method,
+        session_->cert_verifier(), net_log_, io_callback_);
     if (rv != OK) {
       // OK, there's no available QUIC session. Let |waiting_job_| resume
       // if it's paused.
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index 51681ad..215767a 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -47,6 +47,7 @@ class QuicStreamFactory::Job {
       HostResolver* host_resolver,
       const HostPortProxyPair& host_port_proxy_pair,
       bool is_https,
+      base::StringPiece method,
       CertVerifier* cert_verifier,
       const BoundNetLog& net_log);
 
@@ -84,6 +85,7 @@ class QuicStreamFactory::Job {
   SingleRequestHostResolver host_resolver_;
   const HostPortProxyPair host_port_proxy_pair_;
   bool is_https_;
+  bool is_post_;
   CertVerifier* cert_verifier_;
   const BoundNetLog net_log_;
   QuicClientSession* session_;
@@ -92,21 +94,21 @@ class QuicStreamFactory::Job {
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
-QuicStreamFactory::Job::Job(
-    QuicStreamFactory* factory,
-    HostResolver* host_resolver,
-    const HostPortProxyPair& host_port_proxy_pair,
-    bool is_https,
-    CertVerifier* cert_verifier,
-    const BoundNetLog& net_log)
+QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
+                            HostResolver* host_resolver,
+                            const HostPortProxyPair& host_port_proxy_pair,
+                            bool is_https,
+                            base::StringPiece method,
+                            CertVerifier* cert_verifier,
+                            const BoundNetLog& net_log)
     : factory_(factory),
       host_resolver_(host_resolver),
       host_port_proxy_pair_(host_port_proxy_pair),
       is_https_(is_https),
+      is_post_(method == "POST"),
       cert_verifier_(cert_verifier),
       net_log_(net_log),
-      session_(NULL) {
-}
+      session_(NULL) {}
 
 QuicStreamFactory::Job::~Job() {
 }
@@ -189,17 +191,17 @@ QuicStreamRequest::~QuicStreamRequest() {
     factory_->CancelRequest(this);
 }
 
-int QuicStreamRequest::Request(
-    const HostPortProxyPair& host_port_proxy_pair,
-    bool is_https,
-    CertVerifier* cert_verifier,
-    const BoundNetLog& net_log,
-    const CompletionCallback& callback) {
+int QuicStreamRequest::Request(const HostPortProxyPair& host_port_proxy_pair,
+                               bool is_https,
+                               base::StringPiece method,
+                               CertVerifier* cert_verifier,
+                               const BoundNetLog& net_log,
+                               const CompletionCallback& callback) {
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
   DCHECK(factory_);
-  int rv = factory_->Create(host_port_proxy_pair, is_https, cert_verifier,
-                            net_log, this);
+  int rv = factory_->Create(
+      host_port_proxy_pair, is_https, method, cert_verifier, net_log, this);
   if (rv == ERR_IO_PENDING) {
     host_port_proxy_pair_ = host_port_proxy_pair;
     is_https_ = is_https;
@@ -312,6 +314,7 @@ QuicStreamFactory::~QuicStreamFactory() {
 
 int QuicStreamFactory::Create(const HostPortProxyPair& host_port_proxy_pair,
                               bool is_https,
+                              base::StringPiece method,
                               CertVerifier* cert_verifier,
                               const BoundNetLog& net_log,
                               QuicStreamRequest* request) {
@@ -334,7 +337,7 @@ int QuicStreamFactory::Create(const HostPortProxyPair& host_port_proxy_pair,
   DCHECK(crypto_config);
 
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_proxy_pair,
-                              is_https, cert_verifier, net_log));
+                              is_https, method, cert_verifier, net_log));
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
 
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index 9097ece..311e90a 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -51,6 +51,7 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
   // For http, |is_https| is false and |cert_verifier| can be null.
   int Request(const HostPortProxyPair& host_port_proxy_pair,
               bool is_https,
+              base::StringPiece method,
               CertVerifier* cert_verifier,
               const BoundNetLog& net_log,
               const CompletionCallback& callback);
@@ -105,6 +106,7 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   // asynchronously.
   int Create(const HostPortProxyPair& host_port_proxy_pair,
              bool is_https,
+             base::StringPiece method,
              CertVerifier* cert_verifier,
              const BoundNetLog& net_log,
              QuicStreamRequest* request);
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index b2bdf90..f14c2d7 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -104,9 +104,13 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
     socket_factory_.AddSocketDataProvider(&socket_data);
 
     QuicStreamRequest request(&factory_);
-    EXPECT_EQ(ERR_IO_PENDING, request.Request(destination, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+    EXPECT_EQ(ERR_IO_PENDING,
+              request.Request(destination,
+                              is_https_,
+                              "GET",
+                              cert_verifier_.get(),
+                              net_log_,
+                              callback_.callback()));
 
     EXPECT_EQ(OK, callback_.WaitForResult());
     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -165,9 +169,13 @@ TEST_P(QuicStreamFactoryTest, Create) {
   socket_data.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -180,9 +188,13 @@ TEST_P(QuicStreamFactoryTest, Create) {
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(host_port_proxy_pair_, is_https_,
-                                 cert_verifier_.get(), net_log_,
-                                 callback_.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
   stream = request2.ReleaseStream();  // Will reset stream 5.
   stream.reset();  // Will reset stream 7.
 
@@ -209,17 +221,25 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
       "mail.google.com", "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(OK,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(server2, is_https_,
-                                 cert_verifier_.get(), net_log_,
-                                 callback.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(server2,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
@@ -253,17 +273,25 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
       "mail.google.com", "192.168.0.1", "");
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(OK,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(server2, is_https_,
-                                 cert_verifier_.get(), net_log_,
-                                 callback.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(server2,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
@@ -276,9 +304,13 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(&factory_);
-  EXPECT_EQ(OK, request3.Request(server2, is_https_,
-                                 cert_verifier_.get(), net_log_,
-                                 callback3.callback()));
+  EXPECT_EQ(OK,
+            request3.Request(server2,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback3.callback()));
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
 
@@ -323,15 +355,25 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
-  EXPECT_EQ(OK, request.Request(server1, is_https_, cert_verifier_.get(),
-                                net_log_, callback_.callback()));
+  EXPECT_EQ(OK,
+            request.Request(server1,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(server2, is_https_, cert_verifier_.get(),
-                                net_log_, callback_.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(server2,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
@@ -379,15 +421,25 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
 
   QuicStreamRequest request(&factory_);
   is_https_ = true;
-  EXPECT_EQ(OK, request.Request(server1, is_https_, cert_verifier_.get(),
-                                net_log_, callback_.callback()));
+  EXPECT_EQ(OK,
+            request.Request(server1,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(OK, request2.Request(server2, is_https_, cert_verifier_.get(),
-                                net_log_, callback_.callback()));
+  EXPECT_EQ(OK,
+            request2.Request(server2,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
@@ -412,9 +464,13 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -434,9 +490,13 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   // Create a new request for the same destination and verify that a
   // new session is created.
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request2.Request(host_port_proxy_pair_, is_https_,
-                                             cert_verifier_.get(), net_log_,
-                                             callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
@@ -478,8 +538,11 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   // 2 * kDefaultMaxStreamsPerConnection.
   for (size_t i = 0; i < 2 * kDefaultMaxStreamsPerConnection; i++) {
     QuicStreamRequest request(&factory_);
-    int rv = request.Request(host_port_proxy_pair_, is_https_,
-                             cert_verifier_.get(), net_log_,
+    int rv = request.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
                              callback_.callback());
     if (i == 0) {
       EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -495,9 +558,13 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   }
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(OK, request.Request(host_port_proxy_pair_, is_https_,
-                                cert_verifier_.get(), net_log_,
-                                CompletionCallback()));
+  EXPECT_EQ(OK,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            CompletionCallback()));
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream);
   EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
@@ -522,9 +589,13 @@ TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
 
@@ -540,9 +611,13 @@ TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
   socket_data.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
 
@@ -558,9 +633,13 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
   socket_factory_.AddSocketDataProvider(&socket_data);
   {
     QuicStreamRequest request(&factory_);
-    EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                              cert_verifier_.get(), net_log_,
-                                              callback_.callback()));
+    EXPECT_EQ(ERR_IO_PENDING,
+              request.Request(host_port_proxy_pair_,
+                              is_https_,
+                              "GET",
+                              cert_verifier_.get(),
+                              net_log_,
+                              callback_.callback()));
   }
 
   socket_data.StopAfter(1);
@@ -608,9 +687,13 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -628,9 +711,13 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   // a new session.
 
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request2.Request(host_port_proxy_pair_, is_https_,
-                                             cert_verifier_.get(), net_log_,
-                                             callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
@@ -658,9 +745,13 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -679,9 +770,13 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   // a new session.
 
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request2.Request(host_port_proxy_pair_, is_https_,
-                                             cert_verifier_.get(), net_log_,
-                                             callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
@@ -709,9 +804,13 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -730,9 +829,13 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
   // a new session.
 
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request2.Request(host_port_proxy_pair_, is_https_,
-                                             cert_verifier_.get(), net_log_,
-                                             callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();
@@ -760,9 +863,13 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
   socket_data2.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request.Request(host_port_proxy_pair_, is_https_,
-                                            cert_verifier_.get(), net_log_,
-                                            callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -781,9 +888,13 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
   // a new session.
 
   QuicStreamRequest request2(&factory_);
-  EXPECT_EQ(ERR_IO_PENDING, request2.Request(host_port_proxy_pair_, is_https_,
-                                             cert_verifier_.get(), net_log_,
-                                             callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   stream = request2.ReleaseStream();