Port QuicServer to Chrome network stack

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 217 matching lines @@
       sequence_number_of_last_sent_packet_(0),
       sent_packet_manager_(
           is_server, clock_, &stats_, kTCP,
           FLAGS_quic_use_time_loss_detection ? kTime : kNack),
       version_negotiation_state_(START_NEGOTIATION),
       is_server_(is_server),
       connected_(true),
       peer_ip_changed_(false),
       peer_port_changed_(false),
       self_ip_changed_(false),
-      self_port_changed_(false) {
+      self_port_changed_(false),
+      weak_factory_(this)  {
   if (!is_server_) {
     // Pacing will be enabled if the client negotiates it.
     sent_packet_manager_.MaybeEnablePacing();
   }
   DVLOG(1) << ENDPOINT << "Created connection with connection_id: "
            << connection_id;
   timeout_alarm_->Set(clock_->ApproximateNow().Add(idle_network_timeout_));
   framer_.set_visitor(this);
   framer_.set_received_entropy_calculator(&received_packet_manager_);
   stats_.connection_creation_time = clock_->ApproximateNow();
@@ skipping 714 matching lines @@
   // TODO(alyssar): implement zero server state negotiation.
   pending_version_negotiation_packet_ = true;
   if (writer_->IsWriteBlocked()) {
     visitor_->OnWriteBlocked();
     return;
   }
   scoped_ptr<QuicEncryptedPacket> version_packet(
       packet_generator_.SerializeVersionNegotiationPacket(
           framer_.supported_versions()));
   WriteResult result = writer_->WritePacket(
-      version_packet->data(), version_packet->length(),
-      self_address().address(), peer_address());
+      version_packet->data(),
+      version_packet->length(),
+      self_address().address(),
+      peer_address(),
+      base::Callback<void(WriteResult wr)>());
 
   if (result.status == WRITE_STATUS_ERROR) {
     // We can't send an error as the socket is presumably borked.
     CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
     return;
   }
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
     if (writer_->IsWriteBlockedDataBuffered()) {
       pending_version_negotiation_packet_ = false;
@@ skipping 398 matching lines @@
 
   DCHECK(encrypted->length() <= kMaxPacketSize ||
          FLAGS_quic_allow_oversized_packets_for_test)
       << "Packet " << sequence_number << " will not be read; too large: "
       << packet.packet->length() << " " << encrypted->length() << " "
       << " close: " << (packet.type == CONNECTION_CLOSE ? "yes" : "no");
 
   DCHECK(pending_write_.get() == NULL);
   pending_write_.reset(new QueuedPacket(packet));
 
-  WriteResult result = writer_->WritePacket(encrypted->data(),
-                                            encrypted->length(),
-                                            self_address().address(),
-                                            peer_address());
+  WriteResult result = writer_->WritePacket(
+      encrypted->data(),
+      encrypted->length(),
+      self_address().address(),
+      peer_address(),
+      base::Bind(base::IgnoreResult(&QuicConnection::OnPacketSent),
+                 weak_factory_.GetWeakPtr()));
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
   if (debug_visitor_) {
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(sequence_number,
                                  packet.encryption_level,
                                  packet.transmission_type,
                                  *encrypted,
                                  result);
@@ skipping 571 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net