Remove default constructors for QuicTime and QuicTime::Delta and used static Zero() methods instead…

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 "base/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
+using std::make_pair;
 using std::map;
 using std::numeric_limits;
 
 namespace net {
 
 bool kQuicAllowOversizedPacketsForTest = false;
 
 QuicFramer::QuicFramer(QuicDecrypter* decrypter, QuicEncrypter* encrypter)
     : visitor_(NULL),
       fec_builder_(NULL),
@@ skipping 467 matching lines @@
           set_detailed_error("Unable to read smallest received.");
           return false;
         }
 
         uint64 time_received_us;
         if (!reader_->ReadUInt64(&time_received_us)) {
           set_detailed_error("Unable to read time received.");
           return false;
         }
 
-        inter_arrival->received_packet_times[smallest_received] =
-            QuicTime::FromMicroseconds(time_received_us);
+        inter_arrival->received_packet_times.insert(
+            make_pair(smallest_received,
+                      QuicTime::FromMicroseconds(time_received_us)));
 
         for (int i = 0; i < num_received_packets - 1; ++i) {
           uint16 sequence_delta;
           if (!reader_->ReadUInt16(&sequence_delta)) {
             set_detailed_error(
                 "Unable to read sequence delta in received packets.");
             return false;
           }
 
           int32 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;
           }
           QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
-          inter_arrival->received_packet_times[packet] =
-              QuicTime::FromMicroseconds(time_received_us + time_delta_us);
+          inter_arrival->received_packet_times.insert(
+              make_pair(packet, QuicTime::FromMicroseconds(time_received_us +
+                                                           time_delta_us)));
         }
       }
       break;
     }
     case kFixRate: {
       CongestionFeedbackMessageFixRate* fix_rate = &frame->fix_rate;
       if (!reader_->ReadUInt32(&fix_rate->bitrate_in_bytes_per_second)) {
         set_detailed_error("Unable to read bitrate.");
         return false;
       }
@@ skipping 393 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net