relnote: Moving many QUIC DFATALS over to QUIC_BUG

net/quic/quic_session.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_session.h"
 
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/crypto/proof_verifier.h"
+#include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/ssl/ssl_info.h"
 
 using base::StringPiece;
 using base::hash_map;
 using base::hash_set;
 using std::make_pair;
 using std::map;
@@ skipping 168 matching lines @@
   if (error_ == QUIC_NO_ERROR) {
     error_ = error;
   }
 
   while (!dynamic_stream_map_.empty()) {
     StreamMap::iterator it = dynamic_stream_map_.begin();
     QuicStreamId id = it->first;
     it->second->OnConnectionClosed(error, from_peer);
     // The stream should call CloseStream as part of OnConnectionClosed.
     if (dynamic_stream_map_.find(id) != dynamic_stream_map_.end()) {
-      LOG(DFATAL) << ENDPOINT
-                  << "Stream failed to close under OnConnectionClosed";
+      QUIC_BUG << ENDPOINT << "Stream failed to close under OnConnectionClosed";
       CloseStream(id);
     }
   }
 }
 
 void QuicSession::OnSuccessfulVersionNegotiation(
     const QuicVersion& /*version*/) {}
 
 void QuicSession::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {
   // Stream may be closed by the time we receive a WINDOW_UPDATE, so we can't
@@ skipping 43 matching lines @@
   if (num_writes == 0) {
     return;
   }
 
   QuicConnection::ScopedPacketBundler ack_bundler(connection_.get(),
                                                   QuicConnection::NO_ACK);
   for (size_t i = 0; i < num_writes; ++i) {
     if (!(write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
           write_blocked_streams_.HasWriteBlockedDataStreams())) {
       // Writing one stream removed another!? Something's broken.
-      LOG(DFATAL) << "WriteBlockedStream is missing";
+      QUIC_BUG << "WriteBlockedStream is missing";
       connection_->CloseConnection(QUIC_INTERNAL_ERROR, false);
       return;
     }
     if (!connection_->CanWriteStreamData()) {
       return;
     }
     QuicStreamId stream_id = write_blocked_streams_.PopFront();
     ReliableQuicStream* stream = GetStream(stream_id);
     if (stream != nullptr && !stream->flow_controller()->IsBlocked()) {
       // If the stream can't write all bytes it'll re-add itself to the blocked
@@ skipping 38 matching lines @@
   QuicConsumedData data = connection_->SendStreamData(
       id, iov, offset, fin, fec_protection, ack_notifier_delegate);
   write_blocked_streams_.UpdateBytesForStream(id, data.bytes_consumed);
   return data;
 }
 
 void QuicSession::SendRstStream(QuicStreamId id,
                                 QuicRstStreamErrorCode error,
                                 QuicStreamOffset bytes_written) {
   if (ContainsKey(static_stream_map_, id)) {
-    LOG(DFATAL) << "Cannot send RST for a static stream with ID " << id;
+    QUIC_BUG << "Cannot send RST for a static stream with ID " << id;
     return;
   }
 
   if (connection()->connected()) {
     // Only send a RST_STREAM frame if still connected.
     connection_->SendRstStream(id, error, bytes_written);
   }
   CloseStreamInner(id, true);
 }
 
@@ skipping 436 matching lines @@
 void QuicSession::MarkConnectionLevelWriteBlocked(QuicStreamId id,
                                                   SpdyPriority priority) {
 #ifndef NDEBUG
   ReliableQuicStream* stream = GetStream(id);
   if (stream != nullptr) {
     LOG_IF(DFATAL, priority != stream->Priority())
         << ENDPOINT << "Stream " << id
         << "Priorities do not match.  Got: " << static_cast<int>(priority)
         << " Expected: " << static_cast<int>(stream->Priority());
   } else {
-    LOG(DFATAL) << "Marking unknown stream " << id << " blocked.";
+    QUIC_BUG << "Marking unknown stream " << id << " blocked.";
   }
 #endif
 
   write_blocked_streams_.AddStream(id, priority);
 }
 
 bool QuicSession::HasDataToWrite() const {
   return write_blocked_streams_.HasWriteBlockedCryptoOrHeadersStream() ||
          write_blocked_streams_.HasWriteBlockedDataStreams() ||
          connection_->HasQueuedData();
@@ skipping 33 matching lines @@
     }
   }
   return false;
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
   return id % 2 != next_outgoing_stream_id_ % 2;
 }
 
 }  // namespace net