Land Recent QUIC changes.

net/tools/quic/quic_epoll_connection_helper_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
@@ skipping 12 matching lines @@
 using net::tools::test::MockEpollServer;
 using testing::_;
 using testing::AnyNumber;
 using testing::Return;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
-const char data1[] = "foo";
+const char kData[] = "foo";
 const bool kFromPeer = true;
 
 class TestConnectionHelper : public QuicEpollConnectionHelper {
  public:
   TestConnectionHelper(int fd, EpollServer* eps)
       : QuicEpollConnectionHelper(fd, eps) {
   }
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
                                 int* error) OVERRIDE {
@@ skipping 30 matching lines @@
 };
 
 class QuicEpollConnectionHelperTest : public ::testing::Test {
  protected:
   QuicEpollConnectionHelperTest()
       : guid_(42),
         framer_(QuicVersionMax(), QuicTime::Zero(), false),
         send_algorithm_(new testing::StrictMock<MockSendAlgorithm>),
         helper_(new TestConnectionHelper(0, &epoll_server_)),
         connection_(guid_, IPEndPoint(), helper_),
-        frame1_(3, false, 0, data1) {
+        frame_(3, false, 0, kData) {
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     epoll_server_.set_timeout_in_us(-1);
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(Return(
         QuicBandwidth::FromKBitsPerSecond(100)));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(Return(
         QuicTime::Delta::FromMilliseconds(100)));
     ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .WillByDefault(Return(true));
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
                                   QuicFecGroupNumber fec_group) {
     header_.public_header.version_flag = false;
     header_.public_header.reset_flag = false;
     header_.fec_flag = false;
     header_.entropy_flag = false;
     header_.packet_sequence_number = number;
     header_.is_in_fec_group = fec_group == 0 ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
     header_.fec_group = fec_group;
 
     QuicFrames frames;
-    QuicFrame frame(&frame1_);
-    frames.push_back(frame);
+    frames.push_back(QuicFrame(&frame_));
     return framer_.BuildUnsizedDataPacket(header_, frames).packet;
   }
 
   QuicGuid guid_;
   QuicFramer framer_;
 
   MockEpollServer epoll_server_;
   testing::StrictMock<MockSendAlgorithm>* send_algorithm_;
   TestConnectionHelper* helper_;
   TestConnection connection_;
   testing::StrictMock<MockConnectionVisitor> visitor_;
 
   QuicPacketHeader header_;
-  QuicStreamFrame frame1_;
+  QuicStreamFrame frame_;
 };
 
 TEST_F(QuicEpollConnectionHelperTest, DISABLED_TestRTORetransmission) {
   //FLAGS_fake_packet_loss_percentage = 100;
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       Return(QuicTime::Delta::Zero()));
   const int64 kDefaultRetransmissionTimeMs = 500;
 
   const char buffer[] = "foo";
   const size_t packet_size =
@@ skipping 86 matching lines @@
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
   EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net