Add path_id to SerializedPacket. No functional change.

net/quic/quic_packet_creator.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_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 630 matching lines @@
   // not in AddFrame, because when the first padded frame is added to the queue,
   // it might not be retransmittable, and hence the flag would end up being not
   // set.
   if (queued_retransmittable_frames_.get() != nullptr) {
     queued_retransmittable_frames_->set_needs_padding(needs_padding_);
   }
 
   packet_size_ = 0;
   queued_frames_.clear();
   needs_padding_ = false;
-  return SerializedPacket(
-      header.packet_number, header.public_header.packet_number_length,
-      encrypted_buffer, encrypted_length, /* owns_buffer*/ false,
-      QuicFramer::GetPacketEntropyHash(header),
-      queued_retransmittable_frames_.release(), has_ack_, has_stop_waiting_,
-      encryption_level_);
+  return SerializedPacket(current_path_, header.packet_number,
+                          header.public_header.packet_number_length,
+                          encrypted_buffer, encrypted_length,
+                          /* owns_buffer*/ false,
+                          QuicFramer::GetPacketEntropyHash(header),
+                          queued_retransmittable_frames_.release(), has_ack_,
+                          has_stop_waiting_, encryption_level_);
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
                                                  size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     return NoPacket();
   }
   DCHECK_EQ(0u, queued_frames_.size());
   QuicPacketHeader header;
   FillPacketHeader(fec_group_->FecGroupNumber(), true, &header);
   scoped_ptr<QuicPacket> packet(
       framer_->BuildFecPacket(header, fec_group_->PayloadParity()));
   fec_group_.reset(nullptr);
   packet_size_ = 0;
   LOG_IF(DFATAL, packet == nullptr)
       << "Failed to serialize fec packet for group:"
       << fec_group_->FecGroupNumber();
   DCHECK_GE(max_packet_length_, packet->length());
   // Immediately encrypt the packet, to ensure we don't encrypt the same packet
   // packet number multiple times.
   size_t encrypted_length = framer_->EncryptPayload(
       encryption_level_, packet_number_, *packet, buffer, buffer_len);
   if (encrypted_length == 0) {
     LOG(DFATAL) << "Failed to encrypt packet number " << packet_number_;
     return NoPacket();
   }
-  SerializedPacket serialized(header.packet_number,
+  SerializedPacket serialized(current_path_, header.packet_number,
                               header.public_header.packet_number_length, buffer,
                               encrypted_length, /* owns_buffer */ false,
                               QuicFramer::GetPacketEntropyHash(header), nullptr,
                               false, false, encryption_level_);
   serialized.is_fec_packet = true;
   return serialized;
 }
 
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   QuicEncryptedPacket* encrypted = QuicFramer::BuildVersionNegotiationPacket(
       connection_id_, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
 }
 
 SerializedPacket QuicPacketCreator::NoPacket() {
-  return SerializedPacket(0, PACKET_1BYTE_PACKET_NUMBER, nullptr, 0, nullptr,
-                          false, false);
+  return SerializedPacket(kInvalidPathId, 0, PACKET_1BYTE_PACKET_NUMBER,
+                          nullptr, 0, nullptr, false, false);
 }
 
 void QuicPacketCreator::FillPacketHeader(QuicFecGroupNumber fec_group,
                                          bool fec_flag,
                                          QuicPacketHeader* header) {
   header->public_header.connection_id = connection_id_;
   header->public_header.connection_id_length = connection_id_length_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
@@ skipping 147 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net