Change the HttpStreamFactory::JobController to mark alternative service broken until default network changes.
Change the HttpStreamFactory::JobController to mark alternative service broken until default network changes iff TCP succeeds, QUIC fails on the defaut network but succeeds on the alternate network. The HttpServerProperties will clear the brokenness until default network changes.
Bug: 790547
Change-Id: Ib33def42b474898879bf9e39567632ed273c5ca2
Reviewed-on: https://chromium-review.googlesource.com/1212142
Commit-Queue: Zhongyi Shi <[email protected]>
Reviewed-by: Ryan Hamilton <[email protected]>
Cr-Commit-Position: refs/heads/master@{#593486}diff --git a/net/http/http_proxy_client_socket_wrapper.cc b/net/http/http_proxy_client_socket_wrapper.cc
index 1676547a..f1cad81 100644
--- a/net/http/http_proxy_client_socket_wrapper.cc
+++ b/net/http/http_proxy_client_socket_wrapper.cc
@@ -649,6 +649,7 @@
initial_socket_tag_, ssl_params_->ssl_config().GetCertVerifyFlags(),
GURL("https://" + proxy_server.ToString()), net_log_,
&quic_net_error_details_,
+ /*failed_on_default_network_callback=*/CompletionOnceCallback(),
base::Bind(&HttpProxyClientSocketWrapper::OnIOComplete,
base::Unretained(this)));
}
diff --git a/net/http/http_stream_factory_job.cc b/net/http/http_stream_factory_job.cc
index 7fe19b3..e0ab4b0 100644
--- a/net/http/http_stream_factory_job.cc
+++ b/net/http/http_stream_factory_job.cc
@@ -901,7 +901,10 @@
int rv = quic_request_.Request(
destination, quic_version_, request_info_.privacy_mode, priority_,
request_info_.socket_tag, ssl_config->GetCertVerifyFlags(), url,
- net_log_, &net_error_details_, io_callback_);
+ net_log_, &net_error_details_,
+ base::BindOnce(&Job::OnFailedOnDefaultNetwork,
+ ptr_factory_.GetWeakPtr()),
+ io_callback_);
if (rv == OK) {
using_existing_quic_session_ = true;
} else if (rv == ERR_IO_PENDING) {
@@ -999,6 +1002,12 @@
delegate_->OnConnectionInitialized(this, result);
}
+void HttpStreamFactory::Job::OnFailedOnDefaultNetwork(int result) {
+ DCHECK_EQ(job_type_, ALTERNATIVE);
+ DCHECK(using_quic_);
+ delegate_->OnFailedOnDefaultNetwork(this);
+}
+
int HttpStreamFactory::Job::DoInitConnectionComplete(int result) {
net_log_.EndEvent(NetLogEventType::HTTP_STREAM_JOB_INIT_CONNECTION);
if (job_type_ == PRECONNECT) {
diff --git a/net/http/http_stream_factory_job.h b/net/http/http_stream_factory_job.h
index 172a94c..047c9727 100644
--- a/net/http/http_stream_factory_job.h
+++ b/net/http/http_stream_factory_job.h
@@ -83,6 +83,9 @@
int status,
const SSLConfig& used_ssl_config) = 0;
+ // Invoked when |job| fails on the default network.
+ virtual void OnFailedOnDefaultNetwork(Job* job) = 0;
+
// Invoked when |job| has a certificate error for the HttpStreamRequest.
virtual void OnCertificateError(Job* job,
int status,
@@ -316,6 +319,9 @@
// resolution, not the result of host resolution itself.
void OnQuicHostResolution(int result);
+ // Invoked when the underlying connection fails on the default network.
+ void OnFailedOnDefaultNetwork(int result);
+
// Each of these methods corresponds to a State value. Those with an input
// argument receive the result from the previous state. If a method returns
// ERR_IO_PENDING, then the result from OnIOComplete will be passed to the
diff --git a/net/http/http_stream_factory_job_controller.cc b/net/http/http_stream_factory_job_controller.cc
index 6010490..d6410c9 100644
--- a/net/http/http_stream_factory_job_controller.cc
+++ b/net/http/http_stream_factory_job_controller.cc
@@ -78,7 +78,9 @@
is_websocket_(is_websocket),
enable_ip_based_pooling_(enable_ip_based_pooling),
enable_alternative_services_(enable_alternative_services),
+ main_job_net_error_(OK),
alternative_job_net_error_(OK),
+ alternative_job_failed_on_default_network_(false),
job_bound_(false),
main_job_is_blocked_(false),
main_job_is_resumed_(false),
@@ -209,6 +211,7 @@
main_job_.reset();
alternative_job_.reset();
+ ResetErrorStatusForJobs();
factory_->OnStreamReady(proxy_info, request_info_.privacy_mode);
@@ -226,6 +229,7 @@
main_job_.reset();
alternative_job_.reset();
+ ResetErrorStatusForJobs();
delegate_->OnBidirectionalStreamImplReady(used_ssl_config, used_proxy_info,
std::move(stream));
@@ -322,6 +326,9 @@
} else {
OnAlternativeServiceJobFailed(status);
}
+ } else {
+ DCHECK_EQ(main_job_.get(), job);
+ main_job_net_error_ = status;
}
MaybeResumeMainJob(job, base::TimeDelta());
@@ -365,6 +372,11 @@
delegate_->OnStreamFailed(status, *job->net_error_details(), used_ssl_config);
}
+void HttpStreamFactory::JobController::OnFailedOnDefaultNetwork(Job* job) {
+ DCHECK_EQ(job->job_type(), ALTERNATIVE);
+ alternative_job_failed_on_default_network_ = true;
+}
+
void HttpStreamFactory::JobController::OnCertificateError(
Job* job,
int status,
@@ -482,8 +494,6 @@
// Notify |request_|.
if (!is_preconnect_ && !is_job_orphaned) {
- if (job->job_type() == MAIN && alternative_job_net_error_ != OK)
- ReportBrokenAlternativeService();
DCHECK(request_);
@@ -528,6 +538,7 @@
void HttpStreamFactory::JobController::OnPreconnectsComplete(Job* job) {
DCHECK_EQ(main_job_.get(), job);
main_job_.reset();
+ ResetErrorStatusForJobs();
factory_->OnPreconnectsCompleteInternal();
MaybeNotifyFactoryOfCompletion();
}
@@ -579,6 +590,12 @@
main_job_wait_time_ = base::TimeDelta();
}
+void HttpStreamFactory::JobController::ResetErrorStatusForJobs() {
+ main_job_net_error_ = OK;
+ alternative_job_net_error_ = OK;
+ alternative_job_failed_on_default_network_ = false;
+}
+
void HttpStreamFactory::JobController::MaybeResumeMainJob(
Job* job,
const base::TimeDelta& delay) {
@@ -919,11 +936,17 @@
return;
}
- if (bound_job_->job_type() == ALTERNATIVE && main_job_) {
- // |request_| is bound to the alternative job. This means that the main job
+ if (bound_job_->job_type() == ALTERNATIVE && main_job_ &&
+ !alternative_job_failed_on_default_network_) {
+ // |request_| is bound to the alternative job and the alternative job
+ // succeeds on the default network. This means that the main job
// is no longer needed, so cancel it now. Pending ConnectJobs will return
// established sockets to socket pools if applicable.
// https://crbug.com/757548.
+ // The main job still needs to run if the alternative job succeeds on the
+ // alternate network in order to figure out whether QUIC should be marked as
+ // broken until the default network changes.
+ DCHECK_EQ(OK, alternative_job_net_error_);
main_job_.reset();
}
}
@@ -931,9 +954,6 @@
void HttpStreamFactory::JobController::OnJobSucceeded(Job* job) {
DCHECK(job);
- if (job->job_type() == MAIN && alternative_job_net_error_ != OK)
- ReportBrokenAlternativeService();
-
if (!bound_job_) {
if (main_job_ && alternative_job_)
ReportAlternateProtocolUsage(job);
@@ -958,14 +978,6 @@
DCHECK_NE(kProtoUnknown, alternative_service_info_.protocol());
alternative_job_net_error_ = net_error;
-
- if (IsJobOrphaned(alternative_job_.get())) {
- // If |request_| is gone, then it must have been successfully served by
- // |main_job_|.
- // If |request_| is bound to a different job, then it is being
- // successfully served by the main job.
- ReportBrokenAlternativeService();
- }
}
void HttpStreamFactory::JobController::OnAlternativeProxyJobFailed(
@@ -988,17 +1000,41 @@
}
}
-void HttpStreamFactory::JobController::ReportBrokenAlternativeService() {
+void HttpStreamFactory::JobController::MaybeReportBrokenAlternativeService() {
+ // If alternative job succeeds on the default network, no brokenness to
+ // report.
+ if (alternative_job_net_error_ == OK &&
+ !alternative_job_failed_on_default_network_)
+ return;
+
+ // No brokenness to report if the main job fails.
+ if (main_job_net_error_ != OK)
+ return;
+
DCHECK(alternative_service_info_.protocol() != kProtoUnknown);
- DCHECK_NE(OK, alternative_job_net_error_);
- int error_to_report = alternative_job_net_error_;
- alternative_job_net_error_ = OK;
- base::UmaHistogramSparse("Net.AlternateServiceFailed", -error_to_report);
+ if (alternative_job_failed_on_default_network_ &&
+ alternative_job_net_error_ == OK) {
+ // Alternative job failed on the default network but succeeds on the
+ // non-default network, mark alternative service broken until the default
+ // network changes.
+ session_->http_server_properties()
+ ->MarkAlternativeServiceBrokenUntilDefaultNetworkChanges(
+ alternative_service_info_.alternative_service());
+ // Reset error status for Jobs after reporting brokenness.
+ ResetErrorStatusForJobs();
+ return;
+ }
- if (error_to_report == ERR_NETWORK_CHANGED ||
- error_to_report == ERR_INTERNET_DISCONNECTED) {
+ // Report brokenness if alternative job failed.
+ base::UmaHistogramSparse("Net.AlternateServiceFailed",
+ -alternative_job_net_error_);
+
+ if (alternative_job_net_error_ == ERR_NETWORK_CHANGED ||
+ alternative_job_net_error_ == ERR_INTERNET_DISCONNECTED) {
// No need to mark alternative service as broken.
+ // Reset error status for Jobs.
+ ResetErrorStatusForJobs();
return;
}
@@ -1006,9 +1042,17 @@
BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_JOB_ALT);
session_->http_server_properties()->MarkAlternativeServiceBroken(
alternative_service_info_.alternative_service());
+ // Reset error status for Jobs after reporting brokenness.
+ ResetErrorStatusForJobs();
}
void HttpStreamFactory::JobController::MaybeNotifyFactoryOfCompletion() {
+ if (!main_job_ && !alternative_job_) {
+ // Both jobs are gone, report brokenness if apply. Error status for Jobs
+ // will be reset after reporting to avoid redundant reporting.
+ MaybeReportBrokenAlternativeService();
+ }
+
if (!request_ && !main_job_ && !alternative_job_) {
DCHECK(!bound_job_);
factory_->OnJobControllerComplete(this);
@@ -1306,6 +1350,7 @@
bound_job_ = nullptr;
alternative_job_.reset();
main_job_.reset();
+ ResetErrorStatusForJobs();
// Also resets states that related to the old main job. In particular,
// cancels |resume_main_job_callback_| so there won't be any delayed
// ResumeMainJob() left in the task queue.
diff --git a/net/http/http_stream_factory_job_controller.h b/net/http/http_stream_factory_job_controller.h
index e43c00f..6c4c2b0 100644
--- a/net/http/http_stream_factory_job_controller.h
+++ b/net/http/http_stream_factory_job_controller.h
@@ -111,6 +111,9 @@
int status,
const SSLConfig& used_ssl_config) override;
+ // Invoked when |job| fails on the default network.
+ void OnFailedOnDefaultNetwork(Job* job) override;
+
// Invoked when |job| has a certificate error for the Request.
void OnCertificateError(Job* job,
int status,
@@ -244,9 +247,14 @@
// net error of the failed alternative proxy job.
void OnAlternativeProxyJobFailed(int net_error);
- // Called to report to http_server_properties to mark alternative service
- // broken.
- void ReportBrokenAlternativeService();
+ // Called when all Jobs complete. Reports alternative service brokenness to
+ // HttpServerProperties if apply and resets net errors afterwards:
+ // - report broken if the main job has no error and the alternative job has an
+ // error;
+ // - report broken until default network change if the main job has no error,
+ // the alternative job has no error, but the alternative job failed on the
+ // default network.
+ void MaybeReportBrokenAlternativeService();
void MaybeNotifyFactoryOfCompletion();
@@ -262,6 +270,11 @@
// Resumes the main job immediately.
void ResumeMainJob();
+ // Reset error status to default value for Jobs:
+ // - reset |main_job_net_error_| and |alternative_job_net_error_| to OK;
+ // - reset |alternative_job_failed_on_default_network_| to false.
+ void ResetErrorStatusForJobs();
+
AlternativeServiceInfo GetAlternativeServiceInfoFor(
const HttpRequestInfo& request_info,
HttpStreamRequest::Delegate* delegate,
@@ -344,8 +357,13 @@
// (or by |main_job_| if |is_preconnect_|.)
AlternativeServiceInfo alternative_service_info_;
- // Net error code of the failed alternative job. Set to OK by default.
+ // Error status used for alternative service brokenness reporting.
+ // Net error code of the main job. Set to OK by default.
+ int main_job_net_error_;
+ // Net error code of the alternative job. Set to OK by default.
int alternative_job_net_error_;
+ // Set to true if the alternative job failed on the default network.
+ bool alternative_job_failed_on_default_network_;
// True if a Job has ever been bound to the |request_|.
bool job_bound_;
diff --git a/net/http/http_stream_factory_job_controller_unittest.cc b/net/http/http_stream_factory_job_controller_unittest.cc
index b8e9b74..35a402f 100644
--- a/net/http/http_stream_factory_job_controller_unittest.cc
+++ b/net/http/http_stream_factory_job_controller_unittest.cc
@@ -165,6 +165,11 @@
std::unique_ptr<HttpStream> http_stream) {
job->stream_ = std::move(http_stream);
}
+
+ static void SetQuicConnectionFailedOnDefaultNetwork(
+ HttpStreamFactory::Job* job) {
+ job->quic_request_.OnConnectionFailedOnDefaultNetwork();
+ }
};
class JobControllerPeer {
@@ -187,6 +192,13 @@
return job_controller->GetAlternativeServiceInfoFor(request_info, delegate,
stream_type);
}
+
+ static void SetAltJobFailedOnDefaultNetwork(
+ HttpStreamFactory::JobController* job_controller) {
+ DCHECK(job_controller->alternative_job() != nullptr);
+ HttpStreamFactoryJobPeer::SetQuicConnectionFailedOnDefaultNetwork(
+ job_controller->alternative_job_.get());
+ }
};
class HttpStreamFactoryJobControllerTest
@@ -308,6 +320,21 @@
alternative_service_info_vector[0].alternative_service()));
}
+ void TestAltJobSucceedsAfterMainJobFailed(
+ bool alt_job_retried_on_non_default_network);
+ void TestMainJobSucceedsAfterAltJobFailed(
+ bool alt_job_retried_on_non_default_network);
+ void TestAltJobSucceedsAfterMainJobSucceeded(
+ bool alt_job_retried_on_non_default_network);
+ void TestOnStreamFailedForBothJobs(
+ bool alt_job_retried_on_non_default_network);
+ void TestAltJobFailsAfterMainJobSucceeded(
+ bool alt_job_retried_on_non_default_network);
+ void TestMainJobSucceedsAfterAltJobSucceeded(
+ bool alt_job_retried_on_non_default_network);
+ void TestMainJobFailsAfterAltJobSucceeded(
+ bool alt_job_retried_on_non_default_network);
+
TestJobFactory job_factory_;
MockHttpStreamRequestDelegate request_delegate_;
SpdySessionDependencies session_deps_{ProxyResolutionService::CreateDirect()};
@@ -854,7 +881,8 @@
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
}
-TEST_F(HttpStreamFactoryJobControllerTest, OnStreamFailedForBothJobs) {
+void HttpStreamFactoryJobControllerTest::TestOnStreamFailedForBothJobs(
+ bool alt_job_retried_on_non_default_network) {
quic_data_ = std::make_unique<MockQuicData>();
quic_data_->AddConnect(ASYNC, ERR_FAILED);
tcp_data_ = std::make_unique<SequencedSocketData>();
@@ -875,6 +903,12 @@
EXPECT_TRUE(job_controller_->main_job());
EXPECT_TRUE(job_controller_->alternative_job());
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+
// The failure of second Job should be reported to Request as there's no more
// pending Job to serve the Request.
EXPECT_CALL(request_delegate_, OnStreamFailed(_, _, _)).Times(1);
@@ -884,7 +918,22 @@
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
}
-TEST_F(HttpStreamFactoryJobControllerTest, AltJobFailsAfterMainJobSucceeds) {
+// This test verifies that the alternative service is not marked broken if both
+// jobs fail, and the alternative job is not retried on the alternate network.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ OnStreamFailedForBothJobsWithoutQuicRetry) {
+ TestOnStreamFailedForBothJobs(false);
+}
+
+// This test verifies that the alternative service is not marked broken if both
+// jobs fail, and the alternative job is retried on the alternate network.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ OnStreamFailedForBothJobsWithQuicRetriedOnAlternateNetwork) {
+ TestOnStreamFailedForBothJobs(true);
+}
+
+void HttpStreamFactoryJobControllerTest::TestAltJobFailsAfterMainJobSucceeded(
+ bool alt_job_retried_on_non_default_network) {
quic_data_ = std::make_unique<MockQuicData>();
quic_data_->AddRead(ASYNC, ERR_FAILED);
crypto_client_stream_factory_.set_handshake_mode(
@@ -910,6 +959,12 @@
EXPECT_TRUE(job_controller_->main_job());
EXPECT_TRUE(job_controller_->alternative_job());
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+
// Main job succeeds, starts serving Request and it should report status
// to Request. The alternative job will mark the main job complete and gets
// orphaned.
@@ -920,10 +975,30 @@
base::RunLoop().RunUntilIdle();
- VerifyBrokenAlternateProtocolMapping(request_info, true);
// Reset the request as it's been successfully served.
request_.reset();
+ VerifyBrokenAlternateProtocolMapping(request_info, true);
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
+
+ // Verify the brokenness is not cleared when the default network changes.
+ session_->http_server_properties()->OnDefaultNetworkChanged();
+ VerifyBrokenAlternateProtocolMapping(request_info, true);
+}
+
+// This test verifies that the alternatvie service is marked broken when the
+// alternative job fails on default after the main job succeeded. The
+// brokenness should not be cleared when the default network changes.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobFailsOnDefaultNetworkAfterMainJobSucceeded) {
+ TestAltJobFailsAfterMainJobSucceeded(false);
+}
+
+// This test verifies that the alternatvie service is marked broken when the
+// alternative job fails on both networks after the main job succeeded. The
+// brokenness should not be cleared when the default network changes.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobFailsOnBothNetworksAfterMainJobSucceeded) {
+ TestAltJobFailsAfterMainJobSucceeded(true);
}
// Tests that when alt job succeeds, main job is destroyed.
@@ -1107,7 +1182,8 @@
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
}
-TEST_F(HttpStreamFactoryJobControllerTest, AltJobSucceedsAfterMainJobFailed) {
+void HttpStreamFactoryJobControllerTest::TestAltJobSucceedsAfterMainJobFailed(
+ bool alt_job_retried_on_non_default_network) {
quic_data_ = std::make_unique<MockQuicData>();
quic_data_->AddRead(SYNCHRONOUS, ERR_IO_PENDING);
// Use cold start and complete alt job manually.
@@ -1138,6 +1214,11 @@
EXPECT_TRUE(job_controller_->alternative_job());
base::RunLoop().RunUntilIdle();
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
// Make |alternative_job| succeed.
auto http_stream = std::make_unique<HttpBasicStream>(
@@ -1154,7 +1235,244 @@
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
}
-TEST_F(HttpStreamFactoryJobControllerTest, MainJobSucceedsAfterAltJobFailed) {
+// This test verifies that the alternative service is not mark broken if the
+// alternative job succeeds on the default network after the main job failed.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobSucceedsOnDefaultNetworkAfterMainJobFailed) {
+ TestAltJobSucceedsAfterMainJobFailed(false);
+}
+
+// This test verifies that the alternative service is not mark broken if the
+// alternative job succeeds on the alternate network after the main job failed.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobSucceedsOnAlternateNetwrokAfterMainJobFailed) {
+ TestAltJobSucceedsAfterMainJobFailed(true);
+}
+
+void HttpStreamFactoryJobControllerTest::
+ TestAltJobSucceedsAfterMainJobSucceeded(
+ bool alt_job_retried_on_non_default_network) {
+ quic_data_ = std::make_unique<MockQuicData>();
+ quic_data_->AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+ // Use cold start and complete alt job manually.
+ crypto_client_stream_factory_.set_handshake_mode(
+ MockCryptoClientStream::COLD_START);
+
+ tcp_data_ = std::make_unique<SequencedSocketData>();
+ tcp_data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
+ SSLSocketDataProvider ssl_data(ASYNC, OK);
+ session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data);
+
+ HttpRequestInfo request_info;
+ request_info.method = "GET";
+ request_info.url = GURL("https://www.google.com");
+
+ Initialize(request_info);
+
+ url::SchemeHostPort server(request_info.url);
+ AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
+ SetAlternativeService(request_info, alternative_service);
+
+ // |main_job| fails but should not report status to Request.
+ EXPECT_CALL(request_delegate_, OnStreamFailed(_, _, _)).Times(0);
+
+ request_ =
+ job_controller_->Start(&request_delegate_, nullptr, net_log_.bound(),
+ HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+ EXPECT_TRUE(job_controller_->main_job());
+ EXPECT_TRUE(job_controller_->alternative_job());
+
+ // Run the message loop to make |main_job| succeed and status will be
+ // reported to Request.
+ EXPECT_CALL(request_delegate_, OnStreamReadyImpl(_, _, _));
+ base::RunLoop().RunUntilIdle();
+ VerifyBrokenAlternateProtocolMapping(request_info, false);
+
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+
+ // Make |alternative_job| succeed.
+ auto http_stream = std::make_unique<HttpBasicStream>(
+ std::make_unique<ClientSocketHandle>(), false, false);
+
+ HttpStreamFactoryJobPeer::SetStream(job_factory_.alternative_job(),
+ std::move(http_stream));
+ job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig());
+
+ request_.reset();
+ // If alt job was retried on the alternate network, the alternative service
+ // should be marked broken until the default network changes.
+ VerifyBrokenAlternateProtocolMapping(request_info,
+ alt_job_retried_on_non_default_network);
+ EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
+ if (alt_job_retried_on_non_default_network) {
+ // Verify the brokenness is cleared when the default network changes.
+ session_->http_server_properties()->OnDefaultNetworkChanged();
+ VerifyBrokenAlternateProtocolMapping(request_info, false);
+ }
+}
+
+// This test verifies that the alternative service is not marked broken if the
+// alternative job succeeds on the default network after the main job succeeded.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobSucceedsOnDefaultNetworkAfterMainJobSucceeded) {
+ TestAltJobSucceedsAfterMainJobSucceeded(false);
+}
+
+// This test verifies that the alternative service is marked broken until the
+// default network changes if the alternative job succeeds on the non-default
+// network, which failed on the default network previously, after the main job
+// succeeded. The brokenness should be cleared when the default network
+// changes.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ AltJobSucceedsOnAlternateNetworkAfterMainJobSucceeded) {
+ TestAltJobSucceedsAfterMainJobSucceeded(true);
+}
+
+void HttpStreamFactoryJobControllerTest::
+ TestMainJobSucceedsAfterAltJobSucceeded(
+ bool alt_job_retried_on_non_default_network) {
+ quic_data_ = std::make_unique<MockQuicData>();
+ quic_data_->AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+ // Use cold start and complete alt job manually.
+ crypto_client_stream_factory_.set_handshake_mode(
+ MockCryptoClientStream::COLD_START);
+
+ tcp_data_ = std::make_unique<SequencedSocketData>();
+ tcp_data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
+ SSLSocketDataProvider ssl_data(ASYNC, OK);
+ session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data);
+
+ HttpRequestInfo request_info;
+ request_info.method = "GET";
+ request_info.url = GURL("https://www.google.com");
+
+ Initialize(request_info);
+
+ url::SchemeHostPort server(request_info.url);
+ AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
+ SetAlternativeService(request_info, alternative_service);
+
+ request_ =
+ job_controller_->Start(&request_delegate_, nullptr, net_log_.bound(),
+ HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+ EXPECT_TRUE(job_controller_->main_job());
+ EXPECT_TRUE(job_controller_->alternative_job());
+
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+ // Make |alternative_job| succeed.
+ auto http_stream = std::make_unique<HttpBasicStream>(
+ std::make_unique<ClientSocketHandle>(), false, false);
+ EXPECT_CALL(request_delegate_, OnStreamReadyImpl(_, _, http_stream.get()));
+
+ HttpStreamFactoryJobPeer::SetStream(job_factory_.alternative_job(),
+ std::move(http_stream));
+ job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig());
+
+ // Run message loop to make the main job succeed.
+ base::RunLoop().RunUntilIdle();
+ // If alt job was retried on the alternate network, the alternative service
+ // should be marked broken until the default network changes.
+ VerifyBrokenAlternateProtocolMapping(request_info,
+ alt_job_retried_on_non_default_network);
+ request_.reset();
+ EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
+ if (alt_job_retried_on_non_default_network) {
+ // Verify the brokenness is cleared when the default network changes.
+ session_->http_server_properties()->OnDefaultNetworkChanged();
+ VerifyBrokenAlternateProtocolMapping(request_info, false);
+ }
+}
+
+// This test verifies that the alternative service is not marked broken if the
+// main job succeeds after the alternative job succeeded on the default network.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobSucceedsAfterAltJobSucceededOnDefaultNetwork) {
+ TestMainJobSucceedsAfterAltJobSucceeded(false);
+}
+
+// This test verifies that the alternative service is marked broken until the
+// default network changes if the main job succeeds after the alternative job
+// succeeded on the non-default network, i.e., failed on the default network
+// previously. The brokenness should be cleared when the default network
+// changes.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobSucceedsAfterAltJobSucceededOnAlternateNetwork) {
+ TestAltJobSucceedsAfterMainJobSucceeded(true);
+}
+
+void HttpStreamFactoryJobControllerTest::TestMainJobFailsAfterAltJobSucceeded(
+ bool alt_job_retried_on_non_default_network) {
+ quic_data_ = std::make_unique<MockQuicData>();
+ quic_data_->AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+ // Use cold start and complete alt job manually.
+ crypto_client_stream_factory_.set_handshake_mode(
+ MockCryptoClientStream::COLD_START);
+
+ tcp_data_ = std::make_unique<SequencedSocketData>();
+ tcp_data_->set_connect_data(MockConnect(ASYNC, ERR_FAILED));
+
+ HttpRequestInfo request_info;
+ request_info.method = "GET";
+ request_info.url = GURL("https://www.google.com");
+
+ Initialize(request_info);
+
+ url::SchemeHostPort server(request_info.url);
+ AlternativeService alternative_service(kProtoQUIC, server.host(), 443);
+ SetAlternativeService(request_info, alternative_service);
+
+ request_ =
+ job_controller_->Start(&request_delegate_, nullptr, net_log_.bound(),
+ HttpStreamRequest::HTTP_STREAM, DEFAULT_PRIORITY);
+ EXPECT_TRUE(job_controller_->main_job());
+ EXPECT_TRUE(job_controller_->alternative_job());
+
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+ // Make |alternative_job| succeed.
+ auto http_stream = std::make_unique<HttpBasicStream>(
+ std::make_unique<ClientSocketHandle>(), false, false);
+ EXPECT_CALL(request_delegate_, OnStreamReadyImpl(_, _, http_stream.get()));
+
+ HttpStreamFactoryJobPeer::SetStream(job_factory_.alternative_job(),
+ std::move(http_stream));
+ job_controller_->OnStreamReady(job_factory_.alternative_job(), SSLConfig());
+
+ // Run message loop to make the main job fail.
+ base::RunLoop().RunUntilIdle();
+ VerifyBrokenAlternateProtocolMapping(request_info, false);
+ request_.reset();
+ EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
+}
+
+// This test verifies that the alternative service is not marked broken if the
+// main job fails after the alternative job succeeded on the default network.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobFailsAfterAltJobSucceededOnDefaultNetwork) {
+ TestMainJobFailsAfterAltJobSucceeded(false);
+}
+
+// This test verifies that the alternative service is not marked broken if the
+// main job fails after the alternative job succeeded on the non-default
+// network, i.e., failed on the default network previously.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobFailsAfterAltJobSucceededOnAlternateNetwork) {
+ TestMainJobFailsAfterAltJobSucceeded(true);
+}
+
+void HttpStreamFactoryJobControllerTest::TestMainJobSucceedsAfterAltJobFailed(
+ bool alt_job_retried_on_non_default_network) {
quic_data_ = std::make_unique<MockQuicData>();
quic_data_->AddConnect(SYNCHRONOUS, ERR_FAILED);
@@ -1185,14 +1503,38 @@
// |main_job| succeeds and should report status to Request.
EXPECT_CALL(request_delegate_, OnStreamReadyImpl(_, _, _));
+ if (alt_job_retried_on_non_default_network) {
+ // Set the alt job as if it failed on the default network and is retired on
+ // the alternate network.
+ JobControllerPeer::SetAltJobFailedOnDefaultNetwork(job_controller_);
+ }
+
base::RunLoop().RunUntilIdle();
+ request_.reset();
// Verify that the alternate protocol is marked as broken.
VerifyBrokenAlternateProtocolMapping(request_info, true);
histogram_tester.ExpectUniqueSample("Net.AlternateServiceFailed", -ERR_FAILED,
1);
- request_.reset();
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
+ // Verify the brokenness is not cleared when the default network changes.
+ session_->http_server_properties()->OnDefaultNetworkChanged();
+ VerifyBrokenAlternateProtocolMapping(request_info, true);
+}
+
+// This test verifies that the alternative service will be marked broken when
+// the alternative job fails on the default network and main job succeeds later.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobSucceedsAfterAltJobFailedOnDefaultNetwork) {
+ TestMainJobSucceedsAfterAltJobFailed(false);
+}
+
+// This test verifies that the alternative service will be marked broken when
+// the alternative job fails on both default and alternate networks and main job
+// succeeds later.
+TEST_F(HttpStreamFactoryJobControllerTest,
+ MainJobSucceedsAfterAltJobFailedOnBothNetworks) {
+ TestMainJobSucceedsAfterAltJobFailed(true);
}
// Verifies that if the alternative job fails due to a connection change event,
@@ -1228,12 +1570,12 @@
// |main_job| succeeds and should report status to Request.
EXPECT_CALL(request_delegate_, OnStreamReadyImpl(_, _, _));
base::RunLoop().RunUntilIdle();
+ request_.reset();
// Verify that the alternate protocol is not marked as broken.
VerifyBrokenAlternateProtocolMapping(request_info, false);
histogram_tester.ExpectUniqueSample("Net.AlternateServiceFailed",
-ERR_NETWORK_CHANGED, 1);
- request_.reset();
EXPECT_TRUE(HttpStreamFactoryPeer::IsJobControllerDeleted(factory_));
}
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index f5ee80c..26f05ae 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -816,6 +816,18 @@
socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
}
+ void SetUpTestForRetryConnectionOnAlternateNetwork() {
+ session_params_.quic_migrate_sessions_on_network_change_v2 = true;
+ session_params_.quic_migrate_sessions_early_v2 = true;
+ session_params_.quic_retry_on_alternate_network_before_handshake = true;
+ scoped_mock_change_notifier_.reset(new ScopedMockNetworkChangeNotifier());
+ MockNetworkChangeNotifier* mock_ncn =
+ scoped_mock_change_notifier_->mock_network_change_notifier();
+ mock_ncn->ForceNetworkHandlesSupported();
+ mock_ncn->SetConnectedNetworksList(
+ {kDefaultNetworkForTests, kNewNetworkForTests});
+ }
+
// Fetches two non-cryptographic URL requests via a HTTPS proxy with a QUIC
// alternative proxy. Verifies that if the alternative proxy job returns
// |error_code|, the request is fetched successfully by the main job.
@@ -919,6 +931,7 @@
BoundTestNetLog net_log_;
std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_;
SSLSocketDataProvider ssl_data_;
+ std::unique_ptr<ScopedMockNetworkChangeNotifier> scoped_mock_change_notifier_;
private:
void SendRequestAndExpectQuicResponseMaybeFromProxy(
@@ -2136,6 +2149,394 @@
EXPECT_TRUE(details.quic_port_migration_detected);
}
+// This test verifies that a new QUIC connection will be attempted on the
+// alternate network if the original QUIC connection fails with idle timeout
+// before handshake is confirmed. If TCP succeeds and QUIC fails on the
+// alternate network as well, QUIC is marked as broken and the brokenness will
+// not expire when default network changes.
+TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) {
+ SetUpTestForRetryConnectionOnAlternateNetwork();
+
+ std::string request_data;
+ client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
+ client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
+
+ // The request will initially go out over QUIC.
+ MockQuicData quic_data;
+ quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read
+ int packet_num = 1;
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO
+ // Retranmit the handshake messages.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ // TODO(zhongyi): remove condition check once b/115926584 is fixed.
+ if (version_ <= quic::QUIC_VERSION_39) {
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ }
+ // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ quic_data.AddSocketDataToFactory(&socket_factory_);
+
+ // Add successful TCP data so that TCP job will succeed.
+ MockWrite http_writes[] = {
+ MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
+ MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
+ MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
+
+ MockRead http_reads[] = {
+ MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+ MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
+ MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)};
+ SequencedSocketData http_data(http_reads, http_writes);
+ socket_factory_.AddSocketDataProvider(&http_data);
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
+
+ // Add data for the second QUIC connection to fail.
+ MockQuicData quic_data2;
+ quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+ quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); // Write error.
+ quic_data2.AddSocketDataToFactory(&socket_factory_);
+
+ // Resolve the host resolution synchronously.
+ host_resolver_.set_synchronous_mode(true);
+ host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
+ "");
+ HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
+ AddressList address;
+ std::unique_ptr<HostResolver::Request> request;
+ int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
+ CompletionOnceCallback(), &request,
+ net_log_.bound());
+ EXPECT_THAT(rv, IsOk());
+
+ CreateSession();
+ session_->quic_stream_factory()->set_require_confirmation(true);
+ // Use a TestTaskRunner to avoid waiting in real time for timeouts.
+ scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
+ QuicStreamFactoryPeer::SetAlarmFactory(
+ session_->quic_stream_factory(),
+ std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
+ &clock_));
+ // Add alternate protocol mapping to race QUIC and TCP.
+ // QUIC connection requires handshake to be confirmed and sends CHLO to the
+ // peer.
+ AddQuicAlternateProtocolMapping(
+ MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
+
+ HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
+ TestCompletionCallback callback;
+ rv = trans.Start(&request_, callback.callback(), net_log_.bound());
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+
+ // Pump the message loop to get the request started.
+ // Request will be served with TCP job.
+ base::RunLoop().RunUntilIdle();
+ EXPECT_THAT(callback.WaitForResult(), IsOk());
+ CheckResponseData(&trans, "TCP succeeds");
+
+ // Fire the retransmission alarm, from this point, connection will idle
+ // timeout after 4 seconds.
+ // TODO(zhongyi): remove manually firing the alarm when b/116260560 is fixed.
+ quic_task_runner_->RunNextTask();
+
+ // Fast forward to idle timeout the original connection. A new connection will
+ // be kicked off on the alternate network.
+ quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4));
+ ASSERT_TRUE(quic_data.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data.AllWriteDataConsumed());
+
+ // Run the message loop to execute posted tasks, which will report job status.
+ base::RunLoop().RunUntilIdle();
+
+ // Verify that QUIC is marked as broken.
+ ExpectBrokenAlternateProtocolMapping();
+
+ // Deliver a message to notify the new network becomes default, the brokenness
+ // will not expire as QUIC is broken on both networks.
+ scoped_mock_change_notifier_->mock_network_change_notifier()
+ ->NotifyNetworkMadeDefault(kNewNetworkForTests);
+ ExpectBrokenAlternateProtocolMapping();
+
+ ASSERT_TRUE(quic_data2.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data2.AllWriteDataConsumed());
+}
+
+// This test verifies that a new QUIC connection will be attempted on the
+// alternate network if the original QUIC connection fails with idle timeout
+// before handshake is confirmed. If TCP succeeds and QUIC succeeds on the
+// alternate network, QUIC is marked as broken. The brokenness will expire when
+// the default network changes.
+TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) {
+ SetUpTestForRetryConnectionOnAlternateNetwork();
+
+ std::string request_data;
+ client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
+ client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
+
+ // The request will initially go out over QUIC.
+ MockQuicData quic_data;
+ quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read
+ int packet_num = 1;
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO
+ // Retranmit the handshake messages.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ // TODO(zhongyi): remove condition check once b/115926584 is fixed.
+ if (version_ <= quic::QUIC_VERSION_39) {
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ }
+ // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ quic_data.AddSocketDataToFactory(&socket_factory_);
+
+ // Add successful TCP data so that TCP job will succeed.
+ MockWrite http_writes[] = {
+ MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
+ MockWrite(SYNCHRONOUS, 1, "Host: mail.example.org\r\n"),
+ MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
+
+ MockRead http_reads[] = {
+ MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+ MockRead(SYNCHRONOUS, 4, kQuicAlternativeServiceHeader),
+ MockRead(SYNCHRONOUS, 5, "TCP succeeds"), MockRead(SYNCHRONOUS, OK, 6)};
+ SequencedSocketData http_data(http_reads, http_writes);
+ socket_factory_.AddSocketDataProvider(&http_data);
+ socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
+
+ // Quic connection will be retried on the alternate network after the initial
+ // one fails on the default network.
+ MockQuicData quic_data2;
+ quic::QuicStreamOffset header_stream_offset = 0;
+ quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Handing read.
+ quic_data2.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(1)); // CHLO
+
+ client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
+ quic_data2.AddWrite(SYNCHRONOUS,
+ ConstructInitialSettingsPacket(2, &header_stream_offset));
+ quic_data2.AddSocketDataToFactory(&socket_factory_);
+
+ // Resolve the host resolution synchronously.
+ host_resolver_.set_synchronous_mode(true);
+ host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
+ "");
+ HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
+ AddressList address;
+ std::unique_ptr<HostResolver::Request> request;
+ int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
+ CompletionOnceCallback(), &request,
+ net_log_.bound());
+ EXPECT_THAT(rv, IsOk());
+
+ CreateSession();
+ session_->quic_stream_factory()->set_require_confirmation(true);
+ // Use a TestTaskRunner to avoid waiting in real time for timeouts.
+ scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
+ QuicStreamFactoryPeer::SetAlarmFactory(
+ session_->quic_stream_factory(),
+ std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
+ &clock_));
+ // Add alternate protocol mapping to race QUIC and TCP.
+ // QUIC connection requires handshake to be confirmed and sends CHLO to the
+ // peer.
+ AddQuicAlternateProtocolMapping(
+ MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
+
+ HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
+ TestCompletionCallback callback;
+ rv = trans.Start(&request_, callback.callback(), net_log_.bound());
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+
+ // Pump the message loop to get the request started.
+ // Request will be served with TCP job.
+ base::RunLoop().RunUntilIdle();
+ EXPECT_THAT(callback.WaitForResult(), IsOk());
+ CheckResponseData(&trans, "TCP succeeds");
+
+ // Fire the retransmission alarm, after which connection will idle
+ // timeout after 4 seconds.
+ // TODO(zhongyi): remove manually firing the alarm when b/116260560 is fixed.
+ quic_task_runner_->RunNextTask();
+
+ // Fast forward to idle timeout the original connection. A new connection will
+ // be kicked off on the alternate network.
+ quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4));
+ ASSERT_TRUE(quic_data.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data.AllWriteDataConsumed());
+
+ // The second connection hasn't finish handshake, verify that QUIC is not
+ // marked as broken.
+ ExpectQuicAlternateProtocolMapping();
+ // Explicitly confirm the handshake on the second connection.
+ crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
+ quic::QuicSession::HANDSHAKE_CONFIRMED);
+ // Run message loop to execute posted tasks, which will notify JoController
+ // about the orphaned job status.
+ base::RunLoop().RunUntilIdle();
+
+ // Verify that QUIC is marked as broken.
+ ExpectBrokenAlternateProtocolMapping();
+
+ // Deliver a message to notify the new network becomes default, the previous
+ // brokenness will be clear as the brokenness is bond with old default
+ // network.
+ scoped_mock_change_notifier_->mock_network_change_notifier()
+ ->NotifyNetworkMadeDefault(kNewNetworkForTests);
+ ExpectQuicAlternateProtocolMapping();
+
+ ASSERT_TRUE(quic_data2.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data2.AllWriteDataConsumed());
+}
+
+// This test verifies that a new QUIC connection will be attempted on the
+// alternate network if the original QUIC connection fails with idle timeout
+// before handshake is confirmed. If TCP doesn't succeed but QUIC on the
+// alternative network succeeds, QUIC is not marked as broken.
+TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) {
+ SetUpTestForRetryConnectionOnAlternateNetwork();
+
+ std::string request_data;
+ client_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
+ client_maker_.SetLongHeaderType(quic::ZERO_RTT_PROTECTED);
+
+ // The request will initially go out over QUIC.
+ MockQuicData quic_data;
+ quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read
+ int packet_num = 1;
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++)); // CHLO
+ // Retranmit the handshake messages.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ // TODO(zhongyi): remove condition check once b/115926584 is fixed, i.e.,
+ // quic_fix_has_pending_crypto_data is introduced and enabled.
+ if (version_ <= quic::QUIC_VERSION_39) {
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(packet_num++));
+ }
+ // After timeout, connection will be closed with QUIC_NETWORK_IDLE_TIMEOUT.
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ packet_num++, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ quic_data.AddSocketDataToFactory(&socket_factory_);
+
+ // Add hanging TCP data so that TCP job will never succeeded.
+ AddHangingNonAlternateProtocolSocketData();
+
+ // Quic connection will then be retried on the alternate network.
+ MockQuicData quic_data2;
+ quic::QuicStreamOffset header_stream_offset = 0;
+ quic_data2.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeDummyCHLOPacket(1)); // CHLO
+
+ client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
+ quic_data2.AddWrite(SYNCHRONOUS,
+ ConstructInitialSettingsPacket(2, &header_stream_offset));
+ quic_data2.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientRequestHeadersPacket(
+ 3, GetNthClientInitiatedStreamId(0), true, true,
+ GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
+ quic_data2.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
+ 1, GetNthClientInitiatedStreamId(0), false,
+ false, GetResponseHeaders("200 OK")));
+ quic_data2.AddRead(
+ ASYNC, ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0),
+ false, true, 0, "hello!"));
+ quic_data2.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(4, 2, 1, 1));
+ quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read
+ quic_data2.AddSocketDataToFactory(&socket_factory_);
+
+ // Resolve the host resolution synchronously.
+ host_resolver_.set_synchronous_mode(true);
+ host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1",
+ "");
+ HostResolver::RequestInfo info(HostPortPair("mail.example.org", 443));
+ AddressList address;
+ std::unique_ptr<HostResolver::Request> request;
+ int rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
+ CompletionOnceCallback(), &request,
+ net_log_.bound());
+ EXPECT_THAT(rv, IsOk());
+
+ CreateSession();
+ session_->quic_stream_factory()->set_require_confirmation(true);
+ // Use a TestTaskRunner to avoid waiting in real time for timeouts.
+ scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
+ QuicStreamFactoryPeer::SetAlarmFactory(
+ session_->quic_stream_factory(),
+ std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
+ &clock_));
+ // Add alternate protocol mapping to race QUIC and TCP.
+ // QUIC connection requires handshake to be confirmed and sends CHLO to the
+ // peer.
+ AddQuicAlternateProtocolMapping(
+ MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
+
+ HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
+ TestCompletionCallback callback;
+ rv = trans.Start(&request_, callback.callback(), net_log_.bound());
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+
+ // Pump the message loop to get the request started.
+ base::RunLoop().RunUntilIdle();
+ quic_task_runner_->RunNextTask();
+
+ // Fast forward to idle timeout the original connection. A new connection will
+ // be kicked off on the alternate network.
+ quic_task_runner_->FastForwardBy(quic::QuicTime::Delta::FromSeconds(4));
+ ASSERT_TRUE(quic_data.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data.AllWriteDataConsumed());
+
+ // Verify that QUIC is not marked as broken.
+ ExpectQuicAlternateProtocolMapping();
+ // Explicitly confirm the handshake on the second connection.
+ crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
+ quic::QuicSession::HANDSHAKE_CONFIRMED);
+
+ // Read the response.
+ EXPECT_THAT(callback.WaitForResult(), IsOk());
+ CheckResponseData(&trans, "hello!");
+ // Verify that QUIC is not marked as broken.
+ ExpectQuicAlternateProtocolMapping();
+
+ // Deliver a message to notify the new network becomes default.
+ scoped_mock_change_notifier_->mock_network_change_notifier()
+ ->NotifyNetworkMadeDefault(kNewNetworkForTests);
+ ExpectQuicAlternateProtocolMapping();
+ ASSERT_TRUE(quic_data2.AllReadDataConsumed());
+ ASSERT_TRUE(quic_data2.AllWriteDataConsumed());
+}
+
// Verify that if a QUIC connection times out, the QuicHttpStream will
// return QUIC_PROTOCOL_ERROR.
TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index d3ad539..5018f92 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -623,6 +623,10 @@
net_log_.AddEvent(
NetLogEventType::
QUIC_STREAM_FACTORY_JOB_RETRY_ON_ALTERNATE_NETWORK);
+ // Notify requests that connection on the default network failed.
+ for (auto* request : stream_requests_) {
+ request->OnConnectionFailedOnDefaultNetwork();
+ }
DVLOG(1) << "Retry connection on alternate network";
session_ = nullptr;
io_state_ = STATE_CONNECT;
@@ -661,16 +665,18 @@
factory_->CancelRequest(this);
}
-int QuicStreamRequest::Request(const HostPortPair& destination,
- quic::QuicTransportVersion quic_version,
- PrivacyMode privacy_mode,
- RequestPriority priority,
- const SocketTag& socket_tag,
- int cert_verify_flags,
- const GURL& url,
- const NetLogWithSource& net_log,
- NetErrorDetails* net_error_details,
- CompletionOnceCallback callback) {
+int QuicStreamRequest::Request(
+ const HostPortPair& destination,
+ quic::QuicTransportVersion quic_version,
+ PrivacyMode privacy_mode,
+ RequestPriority priority,
+ const SocketTag& socket_tag,
+ int cert_verify_flags,
+ const GURL& url,
+ const NetLogWithSource& net_log,
+ NetErrorDetails* net_error_details,
+ CompletionOnceCallback failed_on_default_network_callback,
+ CompletionOnceCallback callback) {
DCHECK_NE(quic_version, quic::QUIC_VERSION_UNSUPPORTED);
DCHECK(net_error_details);
DCHECK(callback_.is_null());
@@ -678,6 +684,8 @@
DCHECK(factory_);
net_error_details_ = net_error_details;
+ failed_on_default_network_callback_ =
+ std::move(failed_on_default_network_callback);
session_key_ =
QuicSessionKey(HostPortPair::FromURL(url), privacy_mode, socket_tag);
@@ -709,6 +717,11 @@
session_ = move(session);
}
+void QuicStreamRequest::OnConnectionFailedOnDefaultNetwork() {
+ if (!failed_on_default_network_callback_.is_null())
+ base::ResetAndReturn(&failed_on_default_network_callback_).Run(OK);
+}
+
void QuicStreamRequest::OnRequestComplete(int rv) {
factory_ = nullptr;
base::ResetAndReturn(&callback_).Run(rv);
@@ -1324,6 +1337,14 @@
if (!migrate_sessions_on_network_change_v2_)
return;
+ // Clear alternative services that were marked as broken until default network
+ // changes.
+ if (retry_on_alternate_network_before_handshake_ &&
+ default_network_ != NetworkChangeNotifier::kInvalidNetworkHandle &&
+ network != default_network_) {
+ http_server_properties_->OnDefaultNetworkChanged();
+ }
+
DCHECK_NE(NetworkChangeNotifier::kInvalidNetworkHandle, network);
default_network_ = network;
ScopedConnectionMigrationEventLog scoped_event_log(net_log_,
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index 554ebb8..a6667e9 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -123,6 +123,7 @@
const GURL& url,
const NetLogWithSource& net_log,
NetErrorDetails* net_error_details,
+ CompletionOnceCallback failed_on_default_network_callback,
CompletionOnceCallback callback);
// This function must be called after Request() returns ERR_IO_PENDING.
@@ -144,6 +145,11 @@
void OnRequestComplete(int rv);
+ // Called when the original connection created on the default network for
+ // |this| fails and a new connection has been created on the alternate
+ // network.
+ void OnConnectionFailedOnDefaultNetwork();
+
// Helper method that calls |factory_|'s GetTimeDelayForWaitingJob(). It
// returns the amount of time waiting job should be delayed.
base::TimeDelta GetTimeDelayForWaitingJob() const;
@@ -165,6 +171,7 @@
QuicSessionKey session_key_;
NetLogWithSource net_log_;
CompletionOnceCallback callback_;
+ CompletionOnceCallback failed_on_default_network_callback_;
NetErrorDetails* net_error_details_; // Unowned.
std::unique_ptr<QuicChromiumClientSession::Handle> session_;
diff --git a/net/quic/quic_stream_factory_fuzzer.cc b/net/quic/quic_stream_factory_fuzzer.cc
index c3054a4..b81ca077 100644
--- a/net/quic/quic_stream_factory_fuzzer.cc
+++ b/net/quic/quic_stream_factory_fuzzer.cc
@@ -159,7 +159,9 @@
env->host_port_pair,
data_provider.PickValueInArray(quic::kSupportedTransportVersions),
PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY, SocketTag(), kCertVerifyFlags,
- GURL(kUrl), env->net_log, &net_error_details, callback.callback());
+ GURL(kUrl), env->net_log, &net_error_details,
+ /*failed_on_default_network_callback=*/CompletionOnceCallback(),
+ callback.callback());
callback.WaitForResult();
std::unique_ptr<QuicChromiumClientSession::Handle> session =
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index 15849cd..0259777f 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -248,6 +248,10 @@
url3_(kServer3Url),
url4_(kServer4Url),
privacy_mode_(PRIVACY_MODE_DISABLED),
+ failed_on_default_network_callback_(base::BindRepeating(
+ &QuicStreamFactoryTestBase::OnFailedOnDefaultNetwork,
+ base::Unretained(this))),
+ failed_on_default_network_(false),
store_server_configs_in_properties_(false),
close_sessions_on_ip_change_(false),
goaway_sessions_on_ip_change_(false),
@@ -375,11 +379,12 @@
QuicStreamRequest request(factory_.get());
GURL url("https://" + destination.host() + "/");
- EXPECT_EQ(ERR_IO_PENDING,
- request.Request(destination, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request.Request(
+ destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -533,10 +538,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
// Run QuicChromiumClientSession::WriteToNewSocket()
@@ -724,7 +730,7 @@
HostPortPair(quic_server_id.host(), quic_server_id.port()),
version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
- callback_.callback()));
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
@@ -759,7 +765,8 @@
HostPortPair(quic_server_id2.host(), quic_server_id2.port()),
version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, GURL("https://mail.example.org/"),
- net_log_, &net_error_details_, callback_.callback()));
+ net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
@@ -790,6 +797,8 @@
return quic::test::GetNthServerInitiatedStreamId(version_, n);
}
+ void OnFailedOnDefaultNetwork(int rv) { failed_on_default_network_ = true; }
+
// Helper methods for tests of connection migration on write error.
void TestMigrationOnWriteErrorNonMigratableStream(IoMode write_error_mode);
// Migratable stream triggers write error.
@@ -849,6 +858,8 @@
PrivacyMode privacy_mode_;
NetLogWithSource net_log_;
TestCompletionCallback callback_;
+ const CompletionRepeatingCallback failed_on_default_network_callback_;
+ bool failed_on_default_network_;
NetErrorDetails net_error_details_;
// Variables to configure QuicStreamFactory.
@@ -895,10 +906,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -910,7 +922,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
// Will reset stream 3.
stream = CreateStream(&request2);
@@ -922,7 +936,9 @@
EXPECT_EQ(OK, request3.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
stream = CreateStream(&request3); // Will reset stream 5.
stream.reset(); // Will reset stream 7.
@@ -950,7 +966,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -970,10 +988,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -997,10 +1016,11 @@
auto request = std::make_unique<QuicStreamRequest>(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request->Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request->Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
request.reset();
EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
// Tearing down a QuicStreamFactory with a pending Job should not cause any
@@ -1026,10 +1046,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
IPAddress last_address;
EXPECT_FALSE(http_server_properties_.GetSupportsQuic(&last_address));
@@ -1066,10 +1087,11 @@
socket_data.AddSocketDataToFactory(socket_factory_.get());
QuicStreamRequest request(factory_.get());
- EXPECT_THAT(request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()),
+ EXPECT_THAT(request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()),
IsOk());
IPAddress last_address;
@@ -1105,10 +1127,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1137,10 +1160,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1169,10 +1193,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1196,10 +1221,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1227,10 +1253,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1275,16 +1302,19 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1332,10 +1362,10 @@
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(server2, version_, privacy_mode_, DEFAULT_PRIORITY,
- SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback.callback()));
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback.callback()));
EXPECT_EQ(OK, callback.WaitForResult());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1370,16 +1400,19 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1389,10 +1422,11 @@
TestCompletionCallback callback3;
QuicStreamRequest request3(factory_.get());
- EXPECT_EQ(OK, request3.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback3.callback()));
+ EXPECT_EQ(OK,
+ request3.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback3.callback()));
std::unique_ptr<HttpStream> stream3 = CreateStream(&request3);
EXPECT_TRUE(stream3.get());
@@ -1423,19 +1457,21 @@
host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
QuicStreamRequest request(factory_.get());
- EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request.Request(
+ server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1469,19 +1505,21 @@
host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
QuicStreamRequest request(factory_.get());
- EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request.Request(
+ server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1526,19 +1564,21 @@
host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
QuicStreamRequest request(factory_.get());
- EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request.Request(
+ server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
TestCompletionCallback callback;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1567,10 +1607,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1588,10 +1629,11 @@
// new session is created.
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -1636,10 +1678,10 @@
// quic::kDefaultMaxStreamsPerConnection / 2.
for (size_t i = 0; i < quic::kDefaultMaxStreamsPerConnection / 2; i++) {
QuicStreamRequest request(factory_.get());
- int rv = request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback());
+ int rv = request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback());
if (i == 0) {
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -1658,7 +1700,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, CompletionOnceCallback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ CompletionOnceCallback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream);
EXPECT_EQ(ERR_IO_PENDING,
@@ -1692,10 +1736,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
@@ -1712,10 +1757,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE));
@@ -1732,10 +1778,11 @@
{
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
}
base::RunLoop().RunUntilIdle();
@@ -1744,7 +1791,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
std::unique_ptr<HttpStream> stream = CreateStream(&request2);
EXPECT_TRUE(stream.get());
@@ -1777,10 +1826,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -1801,10 +1851,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
stream = CreateStream(&request2);
@@ -1836,10 +1887,11 @@
// Create request, should fail after the write of the CHLO fails.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -1856,10 +1908,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
// Run the message loop to complete host resolution.
@@ -1900,10 +1953,11 @@
// Create request, should fail immediately.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
// Check no active session, or active jobs left for this server.
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -1920,10 +1974,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -1968,10 +2023,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -2002,10 +2058,11 @@
// a new session.
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
stream = CreateStream(&request2);
@@ -2057,10 +2114,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2102,10 +2160,11 @@
// Second request should be sent on a new connection.
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -2140,10 +2199,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -2166,7 +2226,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
stream = CreateStream(&request2);
stream.reset();
@@ -2236,10 +2298,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2412,10 +2475,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2555,10 +2619,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2640,10 +2705,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2703,10 +2769,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2761,10 +2828,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2814,10 +2882,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2871,10 +2940,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2909,10 +2979,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -2979,10 +3050,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3094,10 +3166,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3252,10 +3325,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3422,10 +3496,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3557,10 +3632,11 @@
// Creat request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cerf_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cerf_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3597,10 +3673,11 @@
// Second request should be sent on a new connection.
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -3671,10 +3748,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3805,10 +3883,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -3959,10 +4038,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -4098,19 +4178,21 @@
// Create request and QuicHttpStream to create session1.
QuicStreamRequest request1(factory_.get());
- EXPECT_EQ(OK, request1.Request(server1, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request1.Request(
+ server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
// Create request and QuicHttpStream to create session2.
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -4219,10 +4301,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -4304,10 +4387,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -4368,10 +4452,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -4465,10 +4550,11 @@
// Create request #1 and QuicHttpStream.
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -4488,7 +4574,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -4597,10 +4685,11 @@
// Create request QuicHttpStream.
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -4717,10 +4806,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
base::RunLoop().RunUntilIdle();
@@ -4777,10 +4867,11 @@
// Create request.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
base::RunLoop().RunUntilIdle();
@@ -4895,10 +4986,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
base::RunLoop().RunUntilIdle();
@@ -4908,6 +5000,7 @@
QuicChromiumClientSession* session = GetPendingSession(host_port_pair_);
EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
+ EXPECT_FALSE(failed_on_default_network_);
quic::QuicString error_details;
if (quic_error == quic::QUIC_NETWORK_IDLE_TIMEOUT) {
@@ -4927,6 +5020,7 @@
EXPECT_FALSE(HasActiveSession(host_port_pair_));
QuicChromiumClientSession* session2 = GetPendingSession(host_port_pair_);
EXPECT_NE(session, session2);
+ EXPECT_TRUE(failed_on_default_network_);
// Confirm the handshake on the alternate network.
crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
@@ -5008,10 +5102,11 @@
// Create request, should fail after the write of the CHLO fails.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
@@ -5028,10 +5123,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_FALSE(HasActiveSession(host_port_pair_));
EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
// Run the message loop to complete host resolution.
@@ -5075,10 +5171,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -5169,10 +5266,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -5297,10 +5395,11 @@
// Create request #1 and QuicHttpStream.
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -5320,7 +5419,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
HttpRequestInfo request_info2;
@@ -5425,10 +5526,11 @@
// Create request #1 and QuicHttpStream.
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -5448,7 +5550,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -5563,10 +5667,11 @@
// Create request #1 and QuicHttpStream.
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -5586,7 +5691,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -5661,10 +5768,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -5728,10 +5836,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -5851,10 +5960,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -5945,10 +6055,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
// Deliver the network notification, which should cause the connection to be
// closed.
scoped_mock_network_change_notifier_->mock_network_change_notifier()
@@ -5983,10 +6094,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6114,10 +6226,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6251,10 +6364,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6379,10 +6493,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6481,10 +6596,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6592,10 +6708,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6704,10 +6821,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6846,10 +6964,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -6940,7 +7059,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -6977,10 +7098,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -7127,10 +7249,11 @@
// Create request and QuicHttpStream.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
EXPECT_TRUE(stream.get());
@@ -7189,10 +7312,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -7212,10 +7336,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
stream = CreateStream(&request2);
@@ -7246,10 +7371,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -7268,10 +7394,11 @@
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
@@ -7389,7 +7516,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
// If we are waiting for disk cache, we would have posted a task. Verify that
// the CancelWaitForDataReady task hasn't been posted.
@@ -7438,7 +7567,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(quic::kPingTimeoutSecs),
@@ -7471,10 +7602,11 @@
DVLOG(1) << "Create 2nd session and timeout with open stream";
TestCompletionCallback callback2;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2_, net_log_,
- &net_error_details_, callback2.callback()));
+ EXPECT_EQ(OK,
+ request2.Request(
+ server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback2.callback()));
QuicChromiumClientSession* session2 = GetActiveSession(server2);
EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(10),
session2->connection()->ping_timeout());
@@ -7542,10 +7674,11 @@
// Start a QUIC request.
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7592,7 +7725,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
// Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
// called.
@@ -7639,7 +7774,9 @@
EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
// Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
// called.
@@ -7669,10 +7806,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -7693,7 +7831,9 @@
EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback_.callback()));
EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
}
@@ -7720,10 +7860,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -7747,10 +7888,11 @@
// cancel it because the privacy modes do not match.
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(host_port_pair_, version_, PRIVACY_MODE_ENABLED,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request2.Request(
+ host_port_pair_, version_, PRIVACY_MODE_ENABLED,
+ DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
EXPECT_EQ(index->GetPromised(kDefaultUrl), nullptr);
@@ -7782,11 +7924,12 @@
socket_data.AddSocketDataToFactory(socket_factory_.get());
QuicStreamRequest request1(factory_.get());
- EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(destination1, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request1.Request(
+ destination1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -7798,7 +7941,9 @@
EXPECT_EQ(OK, request2.Request(destination2, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -7900,11 +8045,12 @@
AddHangingSocketData();
QuicStreamRequest request(factory_.get());
- EXPECT_EQ(ERR_IO_PENDING,
- request.Request(destination, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request.Request(
+ destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
@@ -7944,11 +8090,12 @@
sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data));
QuicStreamRequest request1(factory_.get());
- EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(destination, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url1, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request1.Request(
+ destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
@@ -7961,7 +8108,9 @@
EXPECT_EQ(OK, request2.Request(destination, version_, privacy_mode_,
DEFAULT_PRIORITY, SocketTag(),
/*cert_verify_flags=*/0, url2, net_log_,
- &net_error_details_, callback2.callback()));
+ &net_error_details_,
+ failed_on_default_network_callback_,
+ callback2.callback()));
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -8021,10 +8170,11 @@
QuicStreamRequest request1(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(destination, version_, PRIVACY_MODE_DISABLED,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url1, net_log_,
- &net_error_details_, callback_.callback()));
+ request1.Request(
+ destination, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_EQ(OK, callback_.WaitForResult());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -8033,10 +8183,11 @@
TestCompletionCallback callback2;
QuicStreamRequest request2(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(destination, version_, PRIVACY_MODE_ENABLED,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2, net_log_,
- &net_error_details_, callback2.callback()));
+ request2.Request(
+ destination, version_, PRIVACY_MODE_ENABLED, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback2.callback()));
EXPECT_EQ(OK, callback2.WaitForResult());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -8105,11 +8256,12 @@
sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1));
QuicStreamRequest request1(factory_.get());
- EXPECT_EQ(ERR_IO_PENDING,
- request1.Request(destination, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url1, net_log_,
- &net_error_details_, callback_.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request1.Request(
+ destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
EXPECT_TRUE(stream1.get());
@@ -8117,11 +8269,12 @@
TestCompletionCallback callback2;
QuicStreamRequest request2(factory_.get());
- EXPECT_EQ(ERR_IO_PENDING,
- request2.Request(destination, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url2, net_log_,
- &net_error_details_, callback2.callback()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ request2.Request(
+ destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+ /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback2.callback()));
EXPECT_THAT(callback2.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
EXPECT_TRUE(stream2.get());
@@ -8227,10 +8380,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- MAXIMUM_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, MAXIMUM_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
EXPECT_THAT(callback_.WaitForResult(), IsOk());
std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -8275,10 +8429,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
TestCompletionCallback host_resolution_callback;
EXPECT_TRUE(
@@ -8328,10 +8483,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
TestCompletionCallback host_resolution_callback;
EXPECT_TRUE(
@@ -8378,10 +8534,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
// WaitForHostResolution() should return false since host
// resolution has finished already.
@@ -8415,10 +8572,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
// WaitForHostResolution() should return false since host
// resolution has finished already.
@@ -8448,10 +8606,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_NAME_NOT_RESOLVED,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
// WaitForHostResolution() should return false since host
// resolution has failed already.
@@ -8473,10 +8632,11 @@
QuicStreamRequest request(factory_.get());
EXPECT_EQ(ERR_IO_PENDING,
- request.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, SocketTag(),
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback()));
+ request.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
+ SocketTag(),
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback()));
TestCompletionCallback host_resolution_callback;
EXPECT_TRUE(
@@ -8523,10 +8683,10 @@
// Request a stream with |tag1|.
QuicStreamRequest request1(factory_.get());
- int rv =
- request1.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, tag1, /*cert_verify_flags=*/0, url_,
- net_log_, &net_error_details_, callback_.callback());
+ int rv = request1.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback());
EXPECT_THAT(callback_.GetResult(rv), IsOk());
EXPECT_EQ(socket_factory->GetLastProducedUDPSocket()->tag(), tag1);
EXPECT_TRUE(socket_factory->GetLastProducedUDPSocket()
@@ -8538,10 +8698,10 @@
// Request a stream with |tag1| and verify underlying session is reused.
QuicStreamRequest request2(factory_.get());
- rv = request2.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, tag1,
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback());
+ rv = request2.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback());
EXPECT_THAT(callback_.GetResult(rv), IsOk());
std::unique_ptr<QuicChromiumClientSession::Handle> stream2 =
request2.ReleaseSessionHandle();
@@ -8551,10 +8711,10 @@
// Request a stream with |tag2| and verify a new session is created.
QuicStreamRequest request3(factory_.get());
- rv = request3.Request(host_port_pair_, version_, privacy_mode_,
- DEFAULT_PRIORITY, tag2,
- /*cert_verify_flags=*/0, url_, net_log_,
- &net_error_details_, callback_.callback());
+ rv = request3.Request(
+ host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag2,
+ /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+ failed_on_default_network_callback_, callback_.callback());
EXPECT_THAT(callback_.GetResult(rv), IsOk());
EXPECT_EQ(socket_factory->GetLastProducedUDPSocket()->tag(), tag2);
EXPECT_TRUE(socket_factory->GetLastProducedUDPSocket()
diff --git a/net/quic/test_task_runner.cc b/net/quic/test_task_runner.cc
index e60d280..0661fea1 100644
--- a/net/quic/test_task_runner.cc
+++ b/net/quic/test_task_runner.cc
@@ -50,6 +50,15 @@
return tasks_;
}
+quic::QuicTime::Delta TestTaskRunner::NextPendingTaskDelay() {
+ if (tasks_.empty())
+ return quic::QuicTime::Delta::Infinite();
+
+ auto next = FindNextTask();
+ return quic::QuicTime::Delta::FromMicroseconds(
+ (next->GetTimeToRun() - NowInTicks(*clock_)).InMicroseconds());
+}
+
void TestTaskRunner::RunNextTask() {
std::vector<PostedTask>::iterator next = FindNextTask();
DCHECK(next != tasks_.end());
@@ -60,6 +69,24 @@
std::move(task.task).Run();
}
+void TestTaskRunner::FastForwardBy(quic::QuicTime::Delta delta) {
+ DCHECK_GE(delta, quic::QuicTime::Delta::Zero());
+
+ quic::QuicTime end_timestamp = clock_->Now() + delta;
+
+ while (NextPendingTaskDelay() <= end_timestamp - clock_->Now()) {
+ RunNextTask();
+ }
+
+ if (clock_->Now() != end_timestamp)
+ clock_->AdvanceTime(end_timestamp - clock_->Now());
+
+ while (NextPendingTaskDelay() <= quic::QuicTime::Delta::Zero()) {
+ RunNextTask();
+ }
+ return;
+}
+
void TestTaskRunner::RunUntilIdle() {
while (!tasks_.empty())
RunNextTask();
diff --git a/net/quic/test_task_runner.h b/net/quic/test_task_runner.h
index ab2948a..bffabed 100644
--- a/net/quic/test_task_runner.h
+++ b/net/quic/test_task_runner.h
@@ -14,6 +14,7 @@
#include "base/sequenced_task_runner.h"
#include "base/task_runner.h"
#include "base/test/test_pending_task.h"
+#include "net/third_party/quic/core/quic_time.h"
namespace quic {
class MockClock;
@@ -40,10 +41,19 @@
const std::vector<PostedTask>& GetPostedTasks() const;
+ // Returns the delay for next task to run. If there is no pending task,
+ // return QuicTime::Delta::Infinite().
+ quic::QuicTime::Delta NextPendingTaskDelay();
+
// Finds the next task to run, advances the time to the correct time
// and then runs the task.
void RunNextTask();
+ // Fast forwards virtual time by |delta|, causing all tasks with a remaining
+ // delay less than or equal to |delta| to be executed. |delta| must be
+ // non-negative.
+ void FastForwardBy(quic::QuicTime::Delta delta);
+
// While there are posted tasks, finds the next task to run, advances the
// time to the correct time and then runs the task.
void RunUntilIdle();
