Simplify the QuicDispatcher::OnCanWrite logic

net/quic/quic_dispatcher.cc

 // Copyright 2014 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_dispatcher.h"
 
 #include <errno.h>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 274 matching lines @@
 }
 
 void QuicDispatcher::DeleteSessions() {
   STLDeleteElements(&closed_session_list_);
 }
 
 void QuicDispatcher::OnCanWrite() {
   // We finished a write: the socket should not be blocked.
   writer_->SetWritable();
 
-  // Let all the blocked writers try to write, until we're blocked again or
-  // there's no work left.
+  // Give all the blocked writers one chance to write, until we're blocked again
+  // or there's no work left.
   while (!write_blocked_list_.empty() && !writer_->IsWriteBlocked()) {
     QuicBlockedWriterInterface* blocked_writer =
         write_blocked_list_.begin()->first;
     write_blocked_list_.erase(write_blocked_list_.begin());
     blocked_writer->OnCanWrite();
   }
 }
 
 bool QuicDispatcher::HasPendingWrites() const {
   return !write_blocked_list_.empty();
@@ skipping 23 matching lines @@
                                       << connection_id
                                       << ") due to error: "
                                       << QuicUtils::ErrorToString(error);
   if (closed_session_list_.empty()) {
     delete_sessions_alarm_->Set(helper_->GetClock()->ApproximateNow());
   }
   closed_session_list_.push_back(it->second);
   CleanUpSession(it);
 }
 
-void QuicDispatcher::OnWriteBlocked(QuicBlockedWriterInterface* writer) {
-  DCHECK(writer_->IsWriteBlocked());
-  write_blocked_list_.insert(make_pair(writer, true));
+void QuicDispatcher::OnWriteBlocked(
+    QuicBlockedWriterInterface* blocked_writer) {
+  if (!writer_->IsWriteBlocked()) {
+    LOG(DFATAL) <<
+        "QuicDispatcher::OnWriteBlocked called when the writer is not blocked.";
+    // Return without adding the connection to the blocked list, to avoid
+    // infinite loops in OnCanWrite.
+    return;
+  }
+  write_blocked_list_.insert(make_pair(blocked_writer, true));
 }
 
 QuicSession* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& server_address,
     const IPEndPoint& client_address) {
   QuicPerConnectionPacketWriter* per_connection_packet_writer =
       new QuicPerConnectionPacketWriter(writer_.get());
   QuicConnection* connection =
       CreateQuicConnection(connection_id,
@@ skipping 46 matching lines @@
   // be parsed correctly.
   framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
       header.connection_id));
 
   // Continue parsing the packet to extract the sequence number.  Then
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 }  // namespace net