Use overloaded operators with QuicTime for addition, subtraction and scalar

net/quic/quic_framer.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/quic/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 1577 matching lines @@
     uint32_t time_delta_us;
     if (!reader->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
       set_detailed_error("Unable to read time delta in received packets.");
       return false;
     }
 
     last_timestamp_ = CalculateTimestampFromWire(time_delta_us);
 
     ack_frame->received_packet_times.reserve(num_received_packets);
     ack_frame->received_packet_times.push_back(
-        std::make_pair(seq_num, creation_time_.Add(last_timestamp_)));
+        std::make_pair(seq_num, creation_time_ + last_timestamp_));
 
     for (uint8_t i = 1; i < num_received_packets; ++i) {
       if (!reader->ReadBytes(&delta_from_largest_observed,
                              PACKET_1BYTE_PACKET_NUMBER)) {
         set_detailed_error(
             "Unable to read sequence delta in received packets.");
         return false;
       }
       seq_num = ack_frame->largest_observed - delta_from_largest_observed;
 
       // Time delta from the previous timestamp.
       uint64_t incremental_time_delta_us;
       if (!reader->ReadUFloat16(&incremental_time_delta_us)) {
         set_detailed_error(
             "Unable to read incremental time delta in received packets.");
         return false;
       }
 
-      last_timestamp_ = last_timestamp_.Add(
-          QuicTime::Delta::FromMicroseconds(incremental_time_delta_us));
+      last_timestamp_ = last_timestamp_ + QuicTime::Delta::FromMicroseconds(
+                                              incremental_time_delta_us);
       ack_frame->received_packet_times.push_back(
-          std::make_pair(seq_num, creation_time_.Add(last_timestamp_)));
+          std::make_pair(seq_num, creation_time_ + last_timestamp_));
     }
   }
   return true;
 }
 
 bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
                                          const QuicPacketHeader& header,
                                          QuicStopWaitingFrame* stop_waiting) {
   if (quic_version_ <= QUIC_VERSION_33) {
     if (!reader->ReadBytes(&stop_waiting->entropy_hash, 1)) {
@@ skipping 809 matching lines @@
     return false;
   }
 
   if (!writer->WriteUInt8(delta_from_largest_observed &
                           k1ByteSequenceNumberMask)) {
     return false;
   }
 
   // Use the lowest 4 bytes of the time delta from the creation_time_.
   const uint64_t time_epoch_delta_us = UINT64_C(1) << 32;
-  uint32_t time_delta_us = static_cast<uint32_t>(
-      it->second.Subtract(creation_time_).ToMicroseconds() &
-      (time_epoch_delta_us - 1));
+  uint32_t time_delta_us =
+      static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() &
+                            (time_epoch_delta_us - 1));
   if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
     return false;
   }
 
   QuicTime prev_time = it->second;
 
   for (++it; it != frame.received_packet_times.end(); ++it) {
     packet_number = it->first;
     delta_from_largest_observed = frame.largest_observed - packet_number;
 
     if (delta_from_largest_observed > numeric_limits<uint8_t>::max()) {
       return false;
     }
 
     if (!writer->WriteUInt8(delta_from_largest_observed &
                             k1ByteSequenceNumberMask)) {
       return false;
     }
 
-    uint64_t frame_time_delta_us =
-        it->second.Subtract(prev_time).ToMicroseconds();
+    uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds();
     prev_time = it->second;
     if (!writer->WriteUFloat16(frame_time_delta_us)) {
       return false;
     }
   }
   return true;
 }
 
 bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
                                         const QuicStopWaitingFrame& frame,
@@ skipping 107 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net