Add a merely pass-through QuicMultipathSentPacketManager. Protected behind blocked flag FLAGS_quic_…

net/quic/quic_server_session_base.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_server_session_base.h"
 
 #include "base/logging.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection.h"
@@ skipping 109 matching lines @@
   int64_t packets_since_last_scup =
       connection()->packet_number_of_last_sent_packet() -
       last_scup_packet_number_;
   if (now_ms < (kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms) ||
       now_ms < kMinIntervalBetweenServerConfigUpdatesMs ||
       packets_since_last_scup < kMinPacketsBetweenServerConfigUpdates) {
     return;
   }
 
   // If the bandwidth recorder does not have a valid estimate, return early.
-  const QuicSustainedBandwidthRecorder& bandwidth_recorder =
+  const QuicSustainedBandwidthRecorder* bandwidth_recorder =
       sent_packet_manager.SustainedBandwidthRecorder();
-  if (!bandwidth_recorder.HasEstimate()) {
+  if (bandwidth_recorder == nullptr || !bandwidth_recorder->HasEstimate()) {
     return;
   }
 
   // The bandwidth recorder has recorded at least one sustained bandwidth
   // estimate. Check that it's substantially different from the last one that
   // we sent to the client, and if so, send the new one.
-  QuicBandwidth new_bandwidth_estimate = bandwidth_recorder.BandwidthEstimate();
+  QuicBandwidth new_bandwidth_estimate =
+      bandwidth_recorder->BandwidthEstimate();
 
   int64_t bandwidth_delta =
       std::abs(new_bandwidth_estimate.ToBitsPerSecond() -
                bandwidth_estimate_sent_to_client_.ToBitsPerSecond());
 
   // Define "substantial" difference as a 50% increase or decrease from the
   // last estimate.
   bool substantial_difference =
       bandwidth_delta >
       0.5 * bandwidth_estimate_sent_to_client_.ToBitsPerSecond();
   if (!substantial_difference) {
     return;
   }
 
   bandwidth_estimate_sent_to_client_ = new_bandwidth_estimate;
   DVLOG(1) << "Server: sending new bandwidth estimate (KBytes/s): "
            << bandwidth_estimate_sent_to_client_.ToKBytesPerSecond();
 
   // Include max bandwidth in the update.
   QuicBandwidth max_bandwidth_estimate =
-      bandwidth_recorder.MaxBandwidthEstimate();
-  int32_t max_bandwidth_timestamp = bandwidth_recorder.MaxBandwidthTimestamp();
+      bandwidth_recorder->MaxBandwidthEstimate();
+  int32_t max_bandwidth_timestamp = bandwidth_recorder->MaxBandwidthTimestamp();
 
   // Fill the proto before passing it to the crypto stream to send.
   const int32_t bw_estimate_bytes_per_second =
       BandwidthToCachedParameterBytesPerSecond(
           bandwidth_estimate_sent_to_client_);
   const int32_t max_bw_estimate_bytes_per_second =
       BandwidthToCachedParameterBytesPerSecond(max_bandwidth_estimate);
   QUIC_BUG_IF(max_bw_estimate_bytes_per_second < 0)
       << max_bw_estimate_bytes_per_second;
   QUIC_BUG_IF(bw_estimate_bytes_per_second < 0) << bw_estimate_bytes_per_second;
 
   CachedNetworkParameters cached_network_params;
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
       bw_estimate_bytes_per_second);
   cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
       max_bw_estimate_bytes_per_second);
   cached_network_params.set_max_bandwidth_timestamp_seconds(
       max_bandwidth_timestamp);
   cached_network_params.set_min_rtt_ms(
       sent_packet_manager.GetRttStats()->min_rtt().ToMilliseconds());
   cached_network_params.set_previous_connection_state(
-      bandwidth_recorder.EstimateRecordedDuringSlowStart()
+      bandwidth_recorder->EstimateRecordedDuringSlowStart()
           ? CachedNetworkParameters::SLOW_START
           : CachedNetworkParameters::CONGESTION_AVOIDANCE);
   cached_network_params.set_timestamp(
       connection()->clock()->WallNow().ToUNIXSeconds());
   if (!serving_region_.empty()) {
     cached_network_params.set_serving_region(serving_region_);
   }
 
   crypto_stream_->SendServerConfigUpdate(&cached_network_params);
 
@@ skipping 54 matching lines @@
 
 int32_t QuicServerSessionBase::BandwidthToCachedParameterBytesPerSecond(
     const QuicBandwidth& bandwidth) {
   int64_t bytes_per_second = bandwidth.ToBytesPerSecond();
   return (bytes_per_second > static_cast<int64_t>(INT32_MAX)
               ? INT32_MAX
               : static_cast<int32_t>(bytes_per_second));
 }
 
 }  // namespace net