Per-packet options now passed through to QuicPacketWriter, instead of

net/tools/quic/test_tools/packet_dropping_test_writer.cc

 // Copyright 2013 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/test_tools/packet_dropping_test_writer.h"
 
 #include <limits>
 
 #include "base/rand_util.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
@@ skipping 56 matching lines @@
   write_unblocked_alarm_.reset(
       helper->CreateAlarm(new WriteUnblockedAlarm(this)));
   delay_alarm_.reset(helper->CreateAlarm(new DelayAlarm(this)));
   on_can_write_.reset(on_can_write);
 }
 
 WriteResult PacketDroppingTestWriter::WritePacket(
     const char* buffer,
     size_t buf_len,
     const net::IPAddressNumber& self_address,
-    const net::IPEndPoint& peer_address) {
+    const net::IPEndPoint& peer_address,
+    PerPacketOptions* options) {
   ++num_calls_to_write_;
   ReleaseOldPackets();
 
   base::AutoLock locked(config_mutex_);
   if (fake_drop_first_n_packets_ > 0 &&
       num_calls_to_write_ <=
           static_cast<uint64_t>(fake_drop_first_n_packets_)) {
     DVLOG(1) << "Dropping first " << fake_drop_first_n_packets_
              << " packets (packet number " << num_calls_to_write_ << ")";
     return WriteResult(WRITE_STATUS_OK, buf_len);
@@ skipping 26 matching lines @@
     // Queue it to be sent.
     QuicTime send_time = clock_->ApproximateNow().Add(fake_packet_delay_);
     if (!fake_bandwidth_.IsZero()) {
       // Calculate a time the bandwidth limit would impose.
       QuicTime::Delta bandwidth_delay = QuicTime::Delta::FromMicroseconds(
           (buf_len * kNumMicrosPerSecond) / fake_bandwidth_.ToBytesPerSecond());
       send_time = delayed_packets_.empty()
                       ? send_time.Add(bandwidth_delay)
                       : delayed_packets_.back().send_time.Add(bandwidth_delay);
     }
+    std::unique_ptr<PerPacketOptions> delayed_options;
+    if (options != nullptr) {
+      delayed_options.reset(options->Clone());
+    }
     delayed_packets_.push_back(
-        DelayedWrite(buffer, buf_len, self_address, peer_address, send_time));
+        DelayedWrite(buffer, buf_len, self_address, peer_address,
+                     std::move(delayed_options), send_time));
     cur_buffer_size_ += buf_len;
 
     // Set the alarm if it's not yet set.
     if (!delay_alarm_->IsSet()) {
       delay_alarm_->Set(send_time);
     }
 
     return WriteResult(WRITE_STATUS_OK, buf_len);
   }
 
   return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
-                                              peer_address);
+                                              peer_address, options);
 }
 
 bool PacketDroppingTestWriter::IsWriteBlocked() const {
   if (write_unblocked_alarm_.get() != nullptr &&
       write_unblocked_alarm_->IsSet()) {
     return true;
   }
   return QuicPacketWriterWrapper::IsWriteBlocked();
 }
 
@@ skipping 17 matching lines @@
           static_cast<uint64_t>(fake_packet_reorder_percentage_)) {
     DVLOG(1) << "Reordering packets.";
     ++iter;
     // Swap the send times when re-ordering packets.
     delayed_packets_.begin()->send_time = iter->send_time;
   }
 
   DVLOG(1) << "Releasing packet.  " << (delayed_packets_.size() - 1)
            << " remaining.";
   // Grab the next one off the queue and send it.
-  QuicPacketWriterWrapper::WritePacket(iter->buffer.data(),
-                                       iter->buffer.length(),
-                                       iter->self_address, iter->peer_address);
+  QuicPacketWriterWrapper::WritePacket(
+      iter->buffer.data(), iter->buffer.length(), iter->self_address,
+      iter->peer_address, iter->options.get());
   DCHECK_GE(cur_buffer_size_, iter->buffer.length());
   cur_buffer_size_ -= iter->buffer.length();
   delayed_packets_.erase(iter);
 
   // If there are others, find the time for the next to be sent.
   if (delayed_packets_.empty()) {
     return QuicTime::Zero();
   }
   return delayed_packets_.begin()->send_time;
 }
@@ skipping 11 matching lines @@
 
 void PacketDroppingTestWriter::OnCanWrite() {
   on_can_write_->OnCanWrite();
 }
 
 PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
     const char* buffer,
     size_t buf_len,
     const net::IPAddressNumber& self_address,
     const net::IPEndPoint& peer_address,
+    std::unique_ptr<PerPacketOptions> options,
     QuicTime send_time)
     : buffer(buffer, buf_len),
       self_address(self_address),
       peer_address(peer_address),
+      options(std::move(options)),
       send_time(send_time) {}
 
+// TODO(rtenneti): on windows RValue reference gives errors.
+PacketDroppingTestWriter::DelayedWrite::DelayedWrite(
+    PacketDroppingTestWriter::DelayedWrite&& other) = default;
+
+// TODO(rtenneti): on windows RValue reference gives errors.
+// IPAddressNumber has no move assignment operator.
+//
+// PacketDroppingTestWriter::DelayedWrite&
+// PacketDroppingTestWriter::DelayedWrite::operator=(
+//    PacketDroppingTestWriter::DelayedWrite&& other) = default;
+
 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {}
 
 }  // namespace test
 }  // namespace net