Port QuicServer to Chrome network stack

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 60 matching lines @@
       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,
+    base::Callback<void(WriteResult wr)> callback) {
   ReleaseOldPackets();
 
   base::AutoLock locked(config_mutex_);
   if (fake_packet_loss_percentage_ > 0 &&
       simple_random_.RandUint64() % 100 <
           static_cast<uint64>(fake_packet_loss_percentage_)) {
     DVLOG(1) << "Dropping packet.";
     return WriteResult(WRITE_STATUS_OK, buf_len);
   }
   if (fake_blocked_socket_percentage_ > 0 &&
@@ skipping 32 matching lines @@
 
     // 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);
+      buffer, buf_len, self_address, peer_address, callback);
 }
 
 bool PacketDroppingTestWriter::IsWriteBlocked() const {
   if (write_unblocked_alarm_.get() != NULL && write_unblocked_alarm_->IsSet()) {
     return true;
   }
   return QuicPacketWriterWrapper::IsWriteBlocked();
 }
 
 void PacketDroppingTestWriter::SetWritable() {
@@ skipping 17 matching lines @@
     ++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);
+      iter->self_address, iter->peer_address,
+      base::Callback<void(WriteResult wr)>());
   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 22 matching lines @@
     : buffer(buffer, buf_len),
       self_address(self_address),
       peer_address(peer_address),
       send_time(send_time) {}
 
 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {}
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net