Refactor QuicConnection to use explicit notification for getting onto

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 749 matching lines @@
   if (delay.IsZero()) {
     send_alarm_->Cancel();
     WriteIfNotBlocked();
   } else if (!delay.IsInfinite()) {
     send_alarm_->Cancel();
     send_alarm_->Set(time_of_last_received_packet_.Add(delay));
   }
 }
 
 void QuicConnection::SendVersionNegotiationPacket() {
+  // TODO(alyssar): implement zero server state negotiation.
+  pending_version_negotiation_packet_ = true;
+  if (writer_->IsWriteBlocked()) {
+    visitor_->OnWriteBlocked();
+    return;
+  }
   scoped_ptr<QuicEncryptedPacket> version_packet(
       packet_creator_.SerializeVersionNegotiationPacket(
           framer_.supported_versions()));
-  // TODO(satyamshekhar): implement zero server state negotiation.
-  WriteResult result =
-      writer_->WritePacket(version_packet->data(), version_packet->length(),
-                           self_address().address(), peer_address(), this);
-  if (result.status == WRITE_STATUS_OK ||
-      (result.status == WRITE_STATUS_BLOCKED &&
-       writer_->IsWriteBlockedDataBuffered())) {
-    pending_version_negotiation_packet_ = false;
-    return;
-  }
+  WriteResult result = writer_->WritePacket(
+      version_packet->data(), version_packet->length(),
+      self_address().address(), peer_address(), this);
+
   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;
   }
-  pending_version_negotiation_packet_ = true;
+  if (result.status == WRITE_STATUS_BLOCKED) {
+    visitor_->OnWriteBlocked();
+    if (writer_->IsWriteBlockedDataBuffered()) {
+      pending_version_negotiation_packet_ = false;
+    }
+    return;
+  }
+
+  pending_version_negotiation_packet_ = false;
 }
 
 QuicConsumedData QuicConnection::SendStreamData(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
     QuicAckNotifier::DelegateInterface* delegate) {
   if (!fin && data.Empty()) {
     LOG(DFATAL) << "Attempt to send empty stream frame";
@@ skipping 226 matching lines @@
     return true;
   }
 
   return CanWrite(transmission_type, retransmittable, handshake);
 }
 
 bool QuicConnection::CanWrite(TransmissionType transmission_type,
                               HasRetransmittableData retransmittable,
                               IsHandshake handshake) {
   if (writer_->IsWriteBlocked()) {
+    visitor_->OnWriteBlocked();
     return false;
   }
 
   // TODO(rch): consider removing this check so that if an ACK comes in
   // before the alarm goes it, we might be able send out a packet.
   // This check assumes that if the send alarm is set, it applies equally to all
   // types of transmissions.
   if (send_alarm_->IsSet()) {
     DVLOG(1) << "Send alarm set.  Not sending.";
     return false;
@@ skipping 60 matching lines @@
   // deleted at the end of this call.
   scoped_ptr<QuicEncryptedPacket> encrypted_deleter;
   if (forced == NO_FORCE) {
     encrypted_deleter.reset(encrypted);
   } else {  // forced == FORCE
     DCHECK(connection_close_packet_.get() == NULL);
     connection_close_packet_.reset(encrypted);
     // This assures we won't try to write *forced* packets when blocked.
     // Return true to stop processing.
     if (writer_->IsWriteBlocked()) {
+      visitor_->OnWriteBlocked();
       return true;
     }
   }
 
   if (encrypted->length() > options()->max_packet_length) {
     LOG(DFATAL) << "Writing an encrypted packet larger than max_packet_length:"
                 << options()->max_packet_length << " encrypted length: "
                 << encrypted->length();
   }
   DVLOG(1) << ENDPOINT << "Sending packet number " << sequence_number
@@ skipping 23 matching lines @@
       writer_->WritePacket(encrypted->data(), encrypted->length(),
                            self_address().address(), peer_address(), this);
   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, level, *encrypted, result);
   }
   if (result.status == WRITE_STATUS_BLOCKED) {
+    visitor_->OnWriteBlocked();
     // If the socket buffers the the data, then the packet should not
     // be queued and sent again, which would result in an unnecessary
     // duplicate packet being sent.  The helper must call OnPacketSent
     // when the packet is actually sent.
     if (writer_->IsWriteBlockedDataBuffered()) {
       return true;
     }
     pending_write_.reset();
     return false;
   }
@@ skipping 498 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