Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(546)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/quic_http_stream_test.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/base/mime_util_unittest.cc ('K') | « net/quic/quic_http_stream.cc ('k') | net/quic/quic_http_utils.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_http_stream_test.cc
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index f54d3d1d94a91bcf7fe6f2b42a93c49184630e3a..6a1a977139fe95756496fe429b2bc1424aed37a8 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -59,9 +59,13 @@ class TestQuicConnection : public QuicConnection {
IPEndPoint address,
QuicConnectionHelper* helper,
QuicPacketWriter* writer)
- : QuicConnection(connection_id, address, helper, writer, false,
- versions, kInitialFlowControlWindowForTest) {
- }
+ : QuicConnection(connection_id,
+ address,
+ helper,
+ writer,
+ false,
+ versions,
+ kInitialFlowControlWindowForTest) {}
void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
@@ -88,8 +92,7 @@ class TestReceiveAlgorithm : public ReceiveAlgorithmInterface {
class AutoClosingStream : public QuicHttpStream {
public:
explicit AutoClosingStream(const base::WeakPtr<QuicClientSession>& session)
- : QuicHttpStream(session) {
- }
+ : QuicHttpStream(session) {}
virtual int OnDataReceived(const char* data, int length) OVERRIDE {
Close(false);
@@ -117,9 +120,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
// be used by the mock socket when performing the write.
struct PacketToWrite {
PacketToWrite(IoMode mode, QuicEncryptedPacket* packet)
- : mode(mode),
- packet(packet) {
- }
+ : mode(mode), packet(packet) {}
IoMode mode;
QuicEncryptedPacket* packet;
};
@@ -151,9 +152,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
}
// Returns the packet to be written at position |pos|.
- QuicEncryptedPacket* GetWrite(size_t pos) {
- return writes_[pos].packet;
- }
+ QuicEncryptedPacket* GetWrite(size_t pos) { return writes_[pos].packet; }
bool AtEof() {
return socket_data_->at_read_eof() && socket_data_->at_write_eof();
@@ -172,52 +171,57 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
writes_[i].packet->length());
};
- socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(),
- writes_.size()));
+ socket_data_.reset(new StaticSocketDataProvider(
+ NULL, 0, mock_writes_.get(), writes_.size()));
- MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(),
- net_log_.net_log());
+ MockUDPClientSocket* socket =
+ new MockUDPClientSocket(socket_data_.get(), net_log_.net_log());
socket->Connect(peer_addr_);
runner_ = new TestTaskRunner(&clock_);
send_algorithm_ = new MockSendAlgorithm();
receive_algorithm_ = new TestReceiveAlgorithm();
- EXPECT_CALL(*receive_algorithm_, RecordIncomingPacket(_, _, _)).
- Times(AnyNumber());
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _, _)).WillRepeatedly(Return(true));
- EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
- Return(QuicTime::Delta::Zero()));
- EXPECT_CALL(*send_algorithm_, GetCongestionWindow()).WillRepeatedly(
- Return(kMaxPacketSize));
- EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)).
- WillRepeatedly(Return(QuicTime::Delta::Zero()));
- EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(
- Return(QuicBandwidth::Zero()));
+ EXPECT_CALL(*receive_algorithm_, RecordIncomingPacket(_, _, _))
+ .Times(AnyNumber());
+ EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _))
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
+ .WillRepeatedly(Return(QuicTime::Delta::Zero()));
+ EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
+ .WillRepeatedly(Return(kMaxPacketSize));
+ EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
+ .WillRepeatedly(Return(QuicTime::Delta::Zero()));
+ EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
+ .WillRepeatedly(Return(QuicBandwidth::Zero()));
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
- helper_.reset(new QuicConnectionHelper(runner_.get(), &clock_,
- &random_generator_));
+ helper_.reset(
+ new QuicConnectionHelper(runner_.get(), &clock_, &random_generator_));
writer_.reset(new QuicDefaultPacketWriter(socket));
connection_ = new TestQuicConnection(SupportedVersions(GetParam()),
- connection_id_, peer_addr_,
- helper_.get(), writer_.get());
+ connection_id_,
+ peer_addr_,
+ helper_.get(),
+ writer_.get());
connection_->set_visitor(&visitor_);
connection_->SetSendAlgorithm(send_algorithm_);
connection_->SetReceiveAlgorithm(receive_algorithm_);
crypto_config_.SetDefaults();
- session_.reset(
- new QuicClientSession(connection_,
- scoped_ptr<DatagramClientSocket>(socket),
- writer_.Pass(), NULL,
- &crypto_client_stream_factory_,
- make_scoped_ptr((QuicServerInfo*)NULL),
- QuicServerId(kServerHostname, kServerPort,
- false, PRIVACY_MODE_DISABLED),
- DefaultQuicConfig(), &crypto_config_, NULL));
+ session_.reset(new QuicClientSession(
+ connection_,
+ scoped_ptr<DatagramClientSocket>(socket),
+ writer_.Pass(),
+ NULL,
+ &crypto_client_stream_factory_,
+ make_scoped_ptr((QuicServerInfo*)NULL),
+ QuicServerId(
+ kServerHostname, kServerPort, false, PRIVACY_MODE_DISABLED),
+ DefaultQuicConfig(),
+ &crypto_config_,
+ NULL));
session_->GetCryptoStream()->CryptoConnect();
EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
- stream_.reset(use_closing_stream_ ?
- new AutoClosingStream(session_->GetWeakPtr()) :
- new QuicHttpStream(session_->GetWeakPtr()));
+ stream_.reset(use_closing_stream_
+ ? new AutoClosingStream(session_->GetWeakPtr())
+ : new QuicHttpStream(session_->GetWeakPtr()));
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
}
@@ -259,23 +263,31 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
QuicPacketSequenceNumber sequence_number) {
return maker_.MakeRstPacket(
- sequence_number, true, stream_id_,
+ sequence_number,
+ true,
+ stream_id_,
AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
}
scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket(
QuicPacketSequenceNumber sequence_number) {
- return maker_.MakeAckAndRstPacket(
- sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED,
- 2, 1, !kIncludeCongestionFeedback);
+ return maker_.MakeAckAndRstPacket(sequence_number,
+ !kIncludeVersion,
+ stream_id_,
+ QUIC_STREAM_CANCELLED,
+ 2,
+ 1,
+ !kIncludeCongestionFeedback);
}
scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
QuicPacketSequenceNumber sequence_number,
QuicPacketSequenceNumber largest_received,
QuicPacketSequenceNumber least_unacked) {
- return maker_.MakeAckPacket(sequence_number, largest_received,
- least_unacked, !kIncludeCongestionFeedback);
+ return maker_.MakeAckPacket(sequence_number,
+ largest_received,
+ least_unacked,
+ !kIncludeCongestionFeedback);
}
BoundNetLog net_log_;
@@ -314,7 +326,8 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<QuicVersion> {
std::vector<PacketToWrite> writes_;
};
-INSTANTIATE_TEST_CASE_P(Version, QuicHttpStreamTest,
+INSTANTIATE_TEST_CASE_P(Version,
+ QuicHttpStreamTest,
::testing::ValuesIn(QuicSupportedVersions()));
TEST_P(QuicHttpStreamTest, RenewStreamForAuth) {
@@ -340,17 +353,17 @@ TEST_P(QuicHttpStreamTest, GetRequest) {
request_.method = "GET";
request_.url = GURL("http://www.google.com/");
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
- net_log_, callback_.callback()));
- EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, DEFAULT_PRIORITY, net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
// Ack the request.
ProcessPacket(ConstructAckPacket(1, 0, 0));
- EXPECT_EQ(ERR_IO_PENDING,
- stream_->ReadResponseHeaders(callback_.callback()));
+ EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
SetResponse("404 Not Found", std::string());
ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
@@ -362,9 +375,10 @@ TEST_P(QuicHttpStreamTest, GetRequest) {
EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
// There is no body, so this should return immediately.
- EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
- read_buffer_->size(),
- callback_.callback()));
+ EXPECT_EQ(
+ 0,
+ stream_->ReadResponseBody(
+ read_buffer_.get(), read_buffer_->size(), callback_.callback()));
EXPECT_TRUE(stream_->IsResponseBodyComplete());
EXPECT_TRUE(AtEof());
}
@@ -378,17 +392,17 @@ TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) {
request_.method = "GET";
request_.url = GURL("http://www.google.com/");
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
- net_log_, callback_.callback()));
- EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, DEFAULT_PRIORITY, net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
// Ack the request.
ProcessPacket(ConstructAckPacket(1, 0, 0));
- EXPECT_EQ(ERR_IO_PENDING,
- stream_->ReadResponseHeaders(callback_.callback()));
+ EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
SpdyHeaderBlock headers;
headers[":status"] = "200 OK";
@@ -408,9 +422,10 @@ TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) {
EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
// There is no body, so this should return immediately.
- EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
- read_buffer_->size(),
- callback_.callback()));
+ EXPECT_EQ(
+ 0,
+ stream_->ReadResponseBody(
+ read_buffer_.get(), read_buffer_->size(), callback_.callback()));
EXPECT_TRUE(stream_->IsResponseBodyComplete());
EXPECT_TRUE(AtEof());
}
@@ -432,10 +447,11 @@ TEST_P(QuicHttpStreamTest, SendPostRequest) {
request_.upload_data_stream = &upload_data_stream;
ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
- net_log_, callback_.callback()));
- EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, DEFAULT_PRIORITY, net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
// Ack both packets in the request.
@@ -455,9 +471,10 @@ TEST_P(QuicHttpStreamTest, SendPostRequest) {
const char kResponseBody[] = "Hello world!";
ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody));
// Since the body has already arrived, this should return immediately.
- EXPECT_EQ(static_cast<int>(strlen(kResponseBody)),
- stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
- callback_.callback()));
+ EXPECT_EQ(
+ static_cast<int>(strlen(kResponseBody)),
+ stream_->ReadResponseBody(
+ read_buffer_.get(), read_buffer_->size(), callback_.callback()));
EXPECT_TRUE(stream_->IsResponseBodyComplete());
EXPECT_TRUE(AtEof());
@@ -468,8 +485,8 @@ TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
size_t chunk_size = strlen(kUploadData);
AddWrite(ConstructRequestHeadersPacket(1, !kFin));
AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData));
- AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size,
- kUploadData));
+ AddWrite(
+ ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, kUploadData));
AddWrite(ConstructAckPacket(4, 3, 1));
Initialize();
@@ -481,10 +498,11 @@ TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
request_.upload_data_stream = &upload_data_stream;
ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
- ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
- net_log_, callback_.callback()));
- ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ ASSERT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, DEFAULT_PRIORITY, net_log_, callback_.callback()));
+ ASSERT_EQ(ERR_IO_PENDING,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
upload_data_stream.AppendChunk(kUploadData, chunk_size, true);
@@ -504,13 +522,14 @@ TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
// Send the response body.
const char kResponseBody[] = "Hello world!";
- ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
- kResponseBody));
+ ProcessPacket(ConstructDataPacket(
+ 3, false, kFin, response_data_.length(), kResponseBody));
// Since the body has already arrived, this should return immediately.
- ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
- stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
- callback_.callback()));
+ ASSERT_EQ(
+ static_cast<int>(strlen(kResponseBody)),
+ stream_->ReadResponseBody(
+ read_buffer_.get(), read_buffer_->size(), callback_.callback()));
EXPECT_TRUE(stream_->IsResponseBodyComplete());
EXPECT_TRUE(AtEof());
@@ -526,16 +545,16 @@ TEST_P(QuicHttpStreamTest, DestroyedEarly) {
request_.method = "GET";
request_.url = GURL("http://www.google.com/");
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
- net_log_, callback_.callback()));
- EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, DEFAULT_PRIORITY, net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
// Ack the request.
ProcessPacket(ConstructAckPacket(1, 0, 0));
- EXPECT_EQ(ERR_IO_PENDING,
- stream_->ReadResponseHeaders(callback_.callback()));
+ EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
// Send the response with a body.
SetResponse("404 OK", "hello world!");
@@ -555,8 +574,9 @@ TEST_P(QuicHttpStreamTest, Priority) {
request_.method = "GET";
request_.url = GURL("http://www.google.com/");
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
- net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, MEDIUM, net_log_, callback_.callback()));
// Check that priority is highest.
QuicReliableClientStream* reliable_stream =
@@ -565,18 +585,18 @@ TEST_P(QuicHttpStreamTest, Priority) {
DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
reliable_stream->EffectivePriority());
- EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
- callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->SendRequest(headers_, &response_, callback_.callback()));
EXPECT_EQ(&response_, stream_->GetResponseInfo());
// Check that priority has now dropped back to MEDIUM.
- DCHECK_EQ(MEDIUM, ConvertQuicPriorityToRequestPriority(
- reliable_stream->EffectivePriority()));
+ DCHECK_EQ(MEDIUM,
+ ConvertQuicPriorityToRequestPriority(
+ reliable_stream->EffectivePriority()));
// Ack the request.
ProcessPacket(ConstructAckPacket(1, 0, 0));
- EXPECT_EQ(ERR_IO_PENDING,
- stream_->ReadResponseHeaders(callback_.callback()));
+ EXPECT_EQ(ERR_IO_PENDING, stream_->ReadResponseHeaders(callback_.callback()));
// Send the response with a body.
SetResponse("404 OK", "hello world!");
@@ -598,8 +618,9 @@ TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) {
request_.method = "GET";
request_.url = GURL("http://www.google.com/");
- EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
- net_log_, callback_.callback()));
+ EXPECT_EQ(OK,
+ stream_->InitializeStream(
+ &request_, MEDIUM, net_log_, callback_.callback()));
// Check that priority is highest.
QuicReliableClientStream* reliable_stream =
« net/base/mime_util_unittest.cc ('K') | « net/quic/quic_http_stream.cc ('k') | net/quic/quic_http_utils.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698