Move the check for QUIC silent close from SendConnectionClosePacket, to

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>
@@ skipping 2038 matching lines @@
   // serialized packet.
   SendConnectionClosePacket(error, details);
   CloseConnection(error, false);
 }
 
 void QuicConnection::SendConnectionClosePacket(QuicErrorCode error,
                                                const string& details) {
   DVLOG(1) << ENDPOINT << "Force closing " << connection_id() << " with error "
            << QuicUtils::ErrorToString(error) << " (" << error << ") "
            << details;
-  // Don't send explicit connection close packets for timeouts.
-  // This is particularly important on mobile, where connections are short.
-  if (silent_close_enabled_ &&
-      error == QuicErrorCode::QUIC_NETWORK_IDLE_TIMEOUT) {
-    return;
-  }
   ClearQueuedPackets();
   ScopedPacketBundler ack_bundler(this, SEND_ACK);
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame();
   frame->error_code = error;
   frame->error_details = details;
   packet_generator_.AddControlFrame(QuicFrame(frame));
   packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::CloseConnection(QuicErrorCode error, bool from_peer) {
@@ skipping 131 matching lines @@
   // timeout handling.
   QuicTime::Delta idle_duration = now.Subtract(time_of_last_packet);
   DVLOG(1) << ENDPOINT << "last packet "
            << time_of_last_packet.ToDebuggingValue()
            << " now:" << now.ToDebuggingValue()
            << " idle_duration:" << idle_duration.ToMicroseconds()
            << " idle_network_timeout: "
            << idle_network_timeout_.ToMicroseconds();
   if (idle_duration >= idle_network_timeout_) {
     DVLOG(1) << ENDPOINT << "Connection timedout due to no network activity.";
-    SendConnectionCloseWithDetails(QUIC_NETWORK_IDLE_TIMEOUT,
-                                   "No recent network activity");
+    if (silent_close_enabled_) {
+      // Just clean up local state, don't send a connection close packet.
+      CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, /*from_peer=*/false);
+    } else {
+      SendConnectionCloseWithDetails(QUIC_NETWORK_IDLE_TIMEOUT,
+                                     "No recent network activity");
+    }
     return;
   }
 
   if (!handshake_timeout_.IsInfinite()) {
     QuicTime::Delta connected_duration =
         now.Subtract(stats_.connection_creation_time);
     DVLOG(1) << ENDPOINT
              << "connection time: " << connected_duration.ToMicroseconds()
              << " handshake timeout: " << handshake_timeout_.ToMicroseconds();
     if (connected_duration >= handshake_timeout_) {
@@ skipping 306 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net