Update quic flags.

net/quic/core/quic_flags.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/core/quic_flags.h"
 
 // If true, it will return as soon as an error is detected while validating
 // CHLO.
 bool FLAGS_use_early_return_when_verifying_chlo = true;
 
@@ skipping 79 matching lines @@
 // longer necessary.
 bool FLAGS_quic_simple_packet_number_length = true;
 
 // If true, enables QUIC_VERSION_35.
 bool FLAGS_quic_enable_version_35 = true;
 
 // If true, re-enables QUIC_VERSION_36.
 bool FLAGS_quic_enable_version_36 = true;
 
 // If true, enables QUIC_VERSION_36.
-bool FLAGS_quic_enable_version_36_v2 = true;
+bool FLAGS_quic_enable_version_36_v2 = false;
 
 // If true, requires support for X509 certificates in QUIC CHLO PDMDs.
 bool FLAGS_quic_require_x509 = true;
 
 // If true, deprecate safeguards for b/26023400.
-bool FLAGS_quic_deprecate_kfixd = false;
+bool FLAGS_quic_deprecate_kfixd = true;
 
 // If true, use async codepaths to invoke ProofSource::GetProof.
 bool FLAGS_enable_async_get_proof = false;
 
 // If true, neuter null encrypted packets before sending the next handshake
 // message.
-bool FLAGS_quic_neuter_unencrypted_when_sending = false;
+bool FLAGS_quic_neuter_unencrypted_when_sending = true;
 
 // If true, QuicAlarm::Update will call a faster UpdateImpl implementation
 // instead of canceling and reregistering the alarm.
 bool FLAGS_quic_change_alarms_efficiently = false;
 
 // If true, requires handshake confirmations for all QUIC handshakes with
 // versions less than 33.
 bool FLAGS_quic_require_handshake_confirmation_pre33 = false;
 
 // If true, use the interval form of iteration over a PacketNumberQueue instead
 // of iterating over the individual numbers.
-bool FLAGS_quic_use_packet_number_queue_intervals = false;
+bool FLAGS_quic_use_packet_number_queue_intervals = true;
 
-bool FLAGS_quic_sequencer_buffer_retire_block_in_time = true;
+bool FLAGS_quic_sequencer_buffer_retire_block_in_time = false;

[Ryan Hamilton, 2016/08/10 16:22:22]

Was this true because it fixes a crash bug?

[danzh1, 2016/08/10 18:05:06]

This fix just makes chunks of memory released more frequently as they should.
Otherwise, after all data in a memory block is read out, the memory block is not
released but stays there till sequencer buffer is destructed or it is reused by
following new data. This bug shouldn't cause any crush but allow memory
deallocation to happen in time.

As the current code doesn't cause any problem, this flag is by default false for
now.

 
 // Remove obsolete code to force QUIC to go forward secure, now that the server
 // immediately goes forward secure.
 bool FLAGS_quic_remove_obsolete_forward_secure = false;
 
 // If true, close QUIC connection explicitly on write error due to packet being
 // too large.
 bool FLAGS_quic_close_connection_on_packet_too_large = true;
 
 // Use GetLeastUnacked when updating the packet number length, instead of
 // GetLeastPacketAwaitedByPeer.
 bool FLAGS_quic_least_unacked_packet_number_length = true;
 
 // If true, close the write side of a QUIC spdy stream when all queued bytes
 // have been written and a FIN has been sent.
 bool FLAGS_quic_close_stream_after_writing_queued_data = false;
 
 // If true, close connection with QUIC_TOO_MANY_FRAME_GAPS error when number of
 // gaps in QuicStreamSequenceBuffer exceeds allowed limit.
 bool FLAGS_quic_limit_frame_gaps_in_buffer = false;
 
 // If true, v33 QUIC client uses 1 bit to specify 8-byte connection id in public
 // flag.
 bool FLAGS_quic_remove_v33_hacks = true;
 
 // If true, use the CHLO packet size, not message size when determining how
 // large a REJ can be.
-bool FLAGS_quic_use_chlo_packet_size = true;
+bool FLAGS_quic_use_chlo_packet_size = false;
 
 // If true, defer creation of new connection till its CHLO arrives.
-bool FLAGS_quic_buffer_packet_till_chlo = true;
+bool FLAGS_quic_buffer_packet_till_chlo = false;
 
 // If true, the connection will check whether it is application-limited, and
 // notify the congestion controller about it.
 bool FLAGS_quic_enable_app_limited_check = true;