#include "net/quic/crypto/proof_verifier_chromium.h"
#include "net/quic/crypto/quic_decrypter.h"
#include "net/quic/crypto/quic_encrypter.h"
+#include "net/quic/crypto/quic_server_info.h"
#include "net/quic/quic_http_stream.h"
#include "net/quic/quic_server_id.h"
#include "net/quic/test_tools/mock_clock.h"
#include "net/quic/test_tools/mock_random.h"
#include "net/quic/test_tools/quic_test_packet_maker.h"
#include "net/quic/test_tools/quic_test_utils.h"
+#include "net/quic/test_tools/test_task_runner.h"
#include "net/socket/socket_test_util.h"
#include "net/spdy/spdy_test_utils.h"
#include "net/ssl/channel_id_service.h"
static void DisableConnectionPooling(QuicStreamFactory* factory) {
factory->disable_connection_pooling_ = true;
}
+
+ static void SetTaskRunner(QuicStreamFactory* factory,
+ base::TaskRunner* task_runner) {
+ factory->task_runner_ = task_runner;
+ }
+
+ static void SetLoadServerInfoTimeout(QuicStreamFactory* factory,
+ size_t load_server_info_timeout) {
+ factory->load_server_info_timeout_ms_ = load_server_info_timeout;
+ }
+};
+
+class MockQuicServerInfo : public QuicServerInfo {
+ public:
+ MockQuicServerInfo(const QuicServerId& server_id)
+ : QuicServerInfo(server_id) {}
+ virtual ~MockQuicServerInfo() {}
+
+ virtual void Start() override {};
+
+ virtual int WaitForDataReady(const CompletionCallback& callback) override {
+ return ERR_IO_PENDING;
+ }
+
+ virtual void CancelWaitForDataReadyCallback() override {}
+
+ virtual bool IsDataReady() override { return false; }
+
+ virtual bool IsReadyToPersist() override { return false; }
+
+ virtual void Persist() override {};
+
+ virtual void OnExternalCacheHit() override {};
+};
+
+class MockQuicServerInfoFactory : public QuicServerInfoFactory {
+ public:
+ MockQuicServerInfoFactory() {}
+ virtual ~MockQuicServerInfoFactory() {}
+
+ virtual QuicServerInfo* GetForServer(const QuicServerId& server_id) override {
+ return new MockQuicServerInfo(server_id);
+ }
};
+
class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
protected:
QuicStreamFactoryTest()
: random_generator_(0),
clock_(new MockClock()),
+ runner_(new TestTaskRunner(clock_)),
maker_(GetParam(), 0, clock_),
cert_verifier_(CertVerifier::CreateDefault()),
channel_id_service_(
- new ChannelIDService(new DefaultChannelIDStore(NULL),
+ new ChannelIDService(new DefaultChannelIDStore(nullptr),
base::MessageLoopProxy::current())),
factory_(&host_resolver_,
&socket_factory_,
std::string(),
SupportedVersions(GetParam()),
/*enable_port_selection=*/true,
- /*enable_time_based_loss_detection=*/true,
/*always_require_handshake_confirmation=*/false,
/*disable_connection_pooling=*/false,
+ /*load_server_info_timeout=*/0u,
QuicTagVector()),
host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
is_https_(false),
int GetSourcePortForNewSessionInner(const HostPortPair& destination,
bool goaway_received) {
// Should only be called if there is no active session for this destination.
- EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());
+ EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
size_t socket_count = socket_factory_.udp_client_sockets().size();
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_data.StopAfter(1);
socket_factory_.AddSocketDataProvider(&socket_data);
}
factory_.OnSessionClosed(session);
- EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());
+ EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
EXPECT_TRUE(socket_data.at_read_eof());
EXPECT_TRUE(socket_data.at_write_eof());
return port;
QuicStreamId stream_id = kClientDataStreamId1;
return maker_.MakeRstPacket(
1, true, stream_id,
- AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
+ AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
}
+ MockQuicServerInfoFactory quic_server_info_factory_;
MockHostResolver host_resolver_;
DeterministicMockClientSocketFactory socket_factory_;
MockCryptoClientStreamFactory crypto_client_stream_factory_;
MockRandom random_generator_;
MockClock* clock_; // Owned by factory_.
+ scoped_refptr<TestTaskRunner> runner_;
QuicTestPacketMaker maker_;
scoped_ptr<CertVerifier> cert_verifier_;
scoped_ptr<ChannelIDService> channel_id_service_;
::testing::ValuesIn(QuicSupportedVersions()));
TEST_P(QuicStreamFactoryTest, CreateIfSessionExists) {
- EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get());
+ EXPECT_EQ(nullptr, CreateIfSessionExists(host_port_pair_, net_log_).get());
}
TEST_P(QuicStreamFactoryTest, Create) {
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
verify_details.cert_verify_result.is_issued_by_known_root = true;
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
verify_details.cert_verify_result.is_issued_by_known_root = true;
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
crypto_client_stream_factory_.set_proof_verify_details(&verify_details);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
verify_details.cert_verify_result.is_issued_by_known_root = true;
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
verify_details.cert_verify_result.is_issued_by_known_root = true;
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data1);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data1.StopAfter(1);
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
ProofVerifyDetailsChromium verify_details;
verify_details.cert_verify_result.verified_cert = test_cert;
verify_details.cert_verify_result.is_issued_by_known_root = true;
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_data.StopAfter(1);
socket_factory_.AddSocketDataProvider(&socket_data);
- DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
socket_data2.StopAfter(1);
socket_factory_.AddSocketDataProvider(&socket_data2);
EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
&factory_, host_port_pair_, is_https_));
- EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get());
+ EXPECT_EQ(nullptr, CreateIfSessionExists(host_port_pair_, net_log_).get());
// Create a new request for the same destination and verify that a
// new session is created.
}
TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
- DeterministicSocketData socket_data(NULL, 0, NULL, 0);
+ DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
- DeterministicSocketData socket_data(NULL, 0, NULL, 0);
+ DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
socket_data.set_connect_data(connect);
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads[] = {
MockRead(ASYNC, OK, 0) // EOF
};
- DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data);
{
QuicStreamRequest request(&factory_);
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
DeterministicSocketData socket_data(reads, arraysize(reads),
- writes.empty() ? NULL : &writes[0],
+ writes.empty() ? nullptr : &writes[0],
writes.size());
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads2[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+ DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data2.StopAfter(1);
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
DeterministicSocketData socket_data(reads, arraysize(reads),
- writes.empty() ? NULL : &writes[0],
+ writes.empty() ? nullptr : &writes[0],
writes.size());
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads2[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+ DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data2.StopAfter(1);
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
DeterministicSocketData socket_data(reads, arraysize(reads),
- writes.empty() ? NULL : &writes[0],
+ writes.empty() ? nullptr : &writes[0],
writes.size());
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads2[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+ DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data2.StopAfter(1);
net_log_, CompletionCallback()));
// Add a cert and verify that stream saw the event.
- factory_.OnCertAdded(NULL);
+ factory_.OnCertAdded(nullptr);
EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
stream->ReadResponseHeaders(callback_.callback()));
EXPECT_FALSE(factory_.require_confirmation());
std::vector<MockWrite> writes;
writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
DeterministicSocketData socket_data(reads, arraysize(reads),
- writes.empty() ? NULL : &writes[0],
+ writes.empty() ? nullptr : &writes[0],
writes.size());
socket_factory_.AddSocketDataProvider(&socket_data);
socket_data.StopAfter(1);
MockRead reads2[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
+ DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
socket_factory_.AddSocketDataProvider(&socket_data2);
socket_data2.StopAfter(1);
net_log_, CompletionCallback()));
// Change the CA cert and verify that stream saw the event.
- factory_.OnCACertChanged(NULL);
+ factory_.OnCACertChanged(nullptr);
EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
stream->ReadResponseHeaders(callback_.callback()));
EXPECT_FALSE(factory_.require_confirmation());
}
}
+TEST_P(QuicStreamFactoryTest, CancelWaitForDataReady) {
+ factory_.set_quic_server_info_factory(&quic_server_info_factory_);
+ QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
+ const size_t kLoadServerInfoTimeoutMs = 50;
+ QuicStreamFactoryPeer::SetLoadServerInfoTimeout(
+ &factory_, kLoadServerInfoTimeoutMs);
+
+ MockRead reads[] = {
+ MockRead(ASYNC, OK, 0) // EOF
+ };
+ DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
+ socket_factory_.AddSocketDataProvider(&socket_data);
+ socket_data.StopAfter(1);
+
+ crypto_client_stream_factory_.set_handshake_mode(
+ MockCryptoClientStream::ZERO_RTT);
+ host_resolver_.set_synchronous_mode(true);
+ host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
+ "192.168.0.1", "");
+
+ QuicStreamRequest request(&factory_);
+ EXPECT_EQ(ERR_IO_PENDING,
+ request.Request(host_port_pair_,
+ is_https_,
+ privacy_mode_,
+ "GET",
+ net_log_,
+ callback_.callback()));
+
+ // Verify that the CancelWaitForDataReady task has been posted.
+ ASSERT_EQ(1u, runner_->GetPostedTasks().size());
+ EXPECT_EQ(base::TimeDelta::FromMilliseconds(kLoadServerInfoTimeoutMs),
+ runner_->GetPostedTasks()[0].delay);
+
+ runner_->RunNextTask();
+ ASSERT_EQ(0u, runner_->GetPostedTasks().size());
+
+ scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
+ EXPECT_TRUE(stream.get());
+ EXPECT_TRUE(socket_data.at_read_eof());
+ EXPECT_TRUE(socket_data.at_write_eof());
+}
+
} // namespace test
} // namespace net
projects / platform / framework / web / crosswalk.git / blobdiff