Use overloaded operators with QuicTime for addition, subtraction and scalar

net/quic/quic_buffered_packet_store_test.cc

 // Copyright (c) 2016 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/quic/quic_buffered_packet_store.h"
 
 #include <list>
 #include <string>
 
 #include "base/stl_util.h"
@@ skipping 41 matching lines @@
   BufferedPacketList last_expired_packet_queue_;
 };
 
 class QuicBufferedPacketStoreTest : public ::testing::Test {
  public:
   QuicBufferedPacketStoreTest()
       : store_(&visitor_, &clock_, &alarm_factory_),
         server_address_(Loopback6(), 65535),
         client_address_(Loopback6(), 65535),
         packet_content_("some encrypted content"),
-        packet_time_(
-            QuicTime::Zero().Add(QuicTime::Delta::FromMicroseconds(42))),
+        packet_time_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(42)),
         data_packet_(packet_content_.data(),
                      packet_content_.size(),
                      packet_time_) {}
 
  protected:
   QuicBufferedPacketStoreVisitor visitor_;
   MockClock clock_;
   MockAlarmFactory alarm_factory_;
   QuicBufferedPacketStore store_;
   IPEndPoint server_address_;
@@ skipping 109 matching lines @@
                        client_address_);
   // Packet for another connection arrive 1ms later.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   QuicConnectionId connection_id2 = 2;
   // Use different client address to differetiate packets from different
   // connections.
   IPEndPoint another_client_address(Loopback4(), 255);
   store_.EnqueuePacket(connection_id2, data_packet_, server_address_,
                        another_client_address);
   // Advance clock to the time when connection 1 expires.
-  clock_.AdvanceTime(QuicBufferedPacketStorePeer::expiration_alarm(&store_)
-                         ->deadline()
-                         .Subtract(clock_.ApproximateNow()));
+  clock_.AdvanceTime(
+      QuicBufferedPacketStorePeer::expiration_alarm(&store_)->deadline() -
+      clock_.ApproximateNow());
   ASSERT_GE(clock_.ApproximateNow(),
             QuicBufferedPacketStorePeer::expiration_alarm(&store_)->deadline());
   // Fire alarm to remove long-staying connection 1 packets.
   alarm_factory_.FireAlarm(
       QuicBufferedPacketStorePeer::expiration_alarm(&store_));
   EXPECT_EQ(1u, visitor_.last_expired_packet_queue_.buffered_packets.size());
   // Try to deliver packets, but packet queue has been removed so no
   // packets can be returned.
   ASSERT_EQ(0u, store_.DeliverPackets(connection_id).size());
 
   // Deliver packets on connection 2. And the queue for connection 2 should be
   // returned.
   list<BufferedPacket> queue = store_.DeliverPackets(connection_id2);
   ASSERT_EQ(1u, queue.size());
   // Packets in connection 2 should use another client address.
   EXPECT_EQ(another_client_address, queue.front().client_address);
 
   // Test the alarm is reset by enqueueing 2 packets for 3rd connection and wait
   // for them to expire.
   QuicConnectionId connection_id3 = 3;
   store_.EnqueuePacket(connection_id3, data_packet_, server_address_,
                        client_address_);
   store_.EnqueuePacket(connection_id3, data_packet_, server_address_,
                        client_address_);
-  clock_.AdvanceTime(QuicBufferedPacketStorePeer::expiration_alarm(&store_)
-                         ->deadline()
-                         .Subtract(clock_.ApproximateNow()));
+  clock_.AdvanceTime(
+      QuicBufferedPacketStorePeer::expiration_alarm(&store_)->deadline() -
+      clock_.ApproximateNow());
   alarm_factory_.FireAlarm(
       QuicBufferedPacketStorePeer::expiration_alarm(&store_));
   // |last_expired_packet_queue_| should be updated.
   EXPECT_EQ(2u, visitor_.last_expired_packet_queue_.buffered_packets.size());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net