Move shared files in net/quic/ into net/quic/core/

net/quic/quic_multipath_sent_packet_manager.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_multipath_sent_packet_manager.h"
-
-#include <cstdint>
-
-#include "base/strings/string_number_conversions.h"
-#include "net/quic/quic_bug_tracker.h"
-
-using std::string;
-using std::max;
-
-namespace net {
-
-QuicMultipathSentPacketManager::QuicMultipathSentPacketManager(
-    QuicSentPacketManagerInterface* manager,
-    QuicConnectionCloseDelegateInterface* delegate)
-    : delegate_(delegate) {
-  path_managers_info_.push_back(PathSentPacketManagerInfo(manager, ACTIVE));
-}
-
-QuicMultipathSentPacketManager::~QuicMultipathSentPacketManager() {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    delete path_manager_info.manager;
-  }
-}
-
-void QuicMultipathSentPacketManager::SetFromConfig(const QuicConfig& config) {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr) {
-      path_manager_info.manager->SetFromConfig(config);
-    }
-  }
-}
-
-void QuicMultipathSentPacketManager::ResumeConnectionState(
-    const CachedNetworkParameters& cached_network_params,
-    bool max_bandwidth_resumption) {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    return;
-  }
-  path_manager->ResumeConnectionState(cached_network_params,
-                                      max_bandwidth_resumption);
-}
-
-void QuicMultipathSentPacketManager::SetNumOpenStreams(size_t num_streams) {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr) {
-      path_manager_info.manager->SetNumOpenStreams(num_streams);
-    }
-  }
-}
-
-void QuicMultipathSentPacketManager::SetMaxPacingRate(
-    QuicBandwidth max_pacing_rate) {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    return;
-  }
-  path_manager->SetMaxPacingRate(max_pacing_rate);
-}
-
-void QuicMultipathSentPacketManager::SetHandshakeConfirmed() {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    return;
-  }
-  path_manager->SetHandshakeConfirmed();
-}
-
-void QuicMultipathSentPacketManager::OnIncomingAck(
-    const QuicAckFrame& ack_frame,
-    QuicTime ack_receive_time) {
-  if (ack_frame.path_id >= path_managers_info_.size() ||
-      path_managers_info_[ack_frame.path_id].state != ACTIVE) {
-    return;
-  }
-  path_managers_info_[ack_frame.path_id].manager->OnIncomingAck(
-      ack_frame, ack_receive_time);
-}
-
-void QuicMultipathSentPacketManager::RetransmitUnackedPackets(
-    TransmissionType retransmission_type) {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    return;
-  }
-  path_manager->RetransmitUnackedPackets(retransmission_type);
-}
-
-bool QuicMultipathSentPacketManager::MaybeRetransmitTailLossProbe() {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr &&
-        path_manager_info.state == ACTIVE) {
-      if (path_manager_info.manager->MaybeRetransmitTailLossProbe()) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-void QuicMultipathSentPacketManager::NeuterUnencryptedPackets() {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    return;
-  }
-  path_manager->NeuterUnencryptedPackets();
-}
-
-bool QuicMultipathSentPacketManager::HasPendingRetransmissions() const {
-  // TODO(fayang): Move pending_retransmissions_ from path sent packet manager
-  // to multipath sent packet manager.
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  return path_manager != nullptr && path_manager->HasPendingRetransmissions();
-}
-
-PendingRetransmission
-QuicMultipathSentPacketManager::NextPendingRetransmission() {
-  // TODO(fayang): Move pending_retransmissions_ from path sent packet manager
-  // to multipath sent packet manager.
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(kDefaultPathId);
-    QuicFrames retransmittable_frames;
-    return PendingRetransmission(kInvalidPathId, 0u, NOT_RETRANSMISSION,
-                                 retransmittable_frames, false, 0,
-                                 ENCRYPTION_NONE, PACKET_1BYTE_PACKET_NUMBER);
-  }
-  return path_manager->NextPendingRetransmission();
-}
-
-bool QuicMultipathSentPacketManager::HasUnackedPackets() const {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr &&
-        path_manager_info.state == ACTIVE &&
-        path_manager_info.manager->HasUnackedPackets()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-QuicPacketNumber QuicMultipathSentPacketManager::GetLeastUnacked(
-    QuicPathId path_id) const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForPath(path_id);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetLeastUnacked(path_id);
-}
-
-bool QuicMultipathSentPacketManager::OnPacketSent(
-    SerializedPacket* serialized_packet,
-    QuicPathId original_path_id,
-    QuicPacketNumber original_packet_number,
-    QuicTime sent_time,
-    TransmissionType transmission_type,
-    HasRetransmittableData has_retransmittable_data) {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(serialized_packet->path_id);
-  // TODO(fayang): Handle packets retransmitted on different path.
-  DCHECK(original_packet_number == 0 ||
-         original_path_id == serialized_packet->path_id);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(serialized_packet->path_id);
-    return false;
-  }
-
-  return path_manager->OnPacketSent(
-      serialized_packet, original_path_id, original_packet_number, sent_time,
-      transmission_type, has_retransmittable_data);
-}
-
-void QuicMultipathSentPacketManager::OnRetransmissionTimeout() {
-  QuicPathId rto_path = DetermineRetransmissionTimeoutPath();
-  DCHECK_NE(kInvalidPathId, rto_path);
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(rto_path);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(rto_path);
-    return;
-  }
-  path_manager->OnRetransmissionTimeout();
-}
-
-QuicTime::Delta QuicMultipathSentPacketManager::TimeUntilSend(
-    QuicTime now,
-    HasRetransmittableData retransmittable,
-    QuicPathId* path_id) {
-  QuicTime::Delta delay = QuicTime::Delta::Infinite();
-  *path_id = kInvalidPathId;
-  for (size_t i = 0; i < path_managers_info_.size(); ++i) {
-    if (path_managers_info_[i].manager == nullptr ||
-        path_managers_info_[i].state != ACTIVE) {
-      continue;
-    }
-
-    QuicTime::Delta path_delay = path_managers_info_[i].manager->TimeUntilSend(
-        now, retransmittable, path_id);
-    if (!path_delay.IsInfinite() && path_delay < delay) {
-      delay = path_delay;
-      *path_id = i;
-    }
-  }
-  DCHECK(*path_id == kInvalidPathId || !delay.IsInfinite());
-  return delay;
-}
-
-const QuicTime QuicMultipathSentPacketManager::GetRetransmissionTime() const {
-  QuicTime retransmission_time = QuicTime::Zero();
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager == nullptr ||
-        path_manager_info.state != ACTIVE) {
-      continue;
-    }
-    QuicTime path_retransmission_time =
-        path_manager_info.manager->GetRetransmissionTime();
-    if (!path_retransmission_time.IsInitialized()) {
-      continue;
-    }
-    if (!retransmission_time.IsInitialized() ||
-        path_retransmission_time < retransmission_time) {
-      retransmission_time = path_retransmission_time;
-    }
-  }
-
-  return retransmission_time;
-}
-
-const RttStats* QuicMultipathSentPacketManager::GetRttStats() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return nullptr;
-  }
-  return path_manager->GetRttStats();
-}
-
-QuicBandwidth QuicMultipathSentPacketManager::BandwidthEstimate() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return QuicBandwidth::Zero();
-  }
-  return path_manager->BandwidthEstimate();
-}
-
-const QuicSustainedBandwidthRecorder*
-QuicMultipathSentPacketManager::SustainedBandwidthRecorder() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return nullptr;
-  }
-  return path_manager->SustainedBandwidthRecorder();
-}
-
-QuicPacketCount QuicMultipathSentPacketManager::GetCongestionWindowInTcpMss()
-    const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetCongestionWindowInTcpMss();
-}
-
-QuicPacketCount QuicMultipathSentPacketManager::EstimateMaxPacketsInFlight(
-    QuicByteCount max_packet_length) const {
-  QuicPacketCount max_packets_in_flight = 0;
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr) {
-      max_packets_in_flight =
-          max(max_packets_in_flight,
-              path_manager_info.manager->EstimateMaxPacketsInFlight(
-                  max_packet_length));
-    }
-  }
-  DCHECK_LT(0u, max_packets_in_flight);
-  return max_packets_in_flight;
-}
-
-QuicByteCount QuicMultipathSentPacketManager::GetCongestionWindowInBytes()
-    const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetCongestionWindowInBytes();
-}
-
-QuicPacketCount QuicMultipathSentPacketManager::GetSlowStartThresholdInTcpMss()
-    const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetSlowStartThresholdInTcpMss();
-}
-
-void QuicMultipathSentPacketManager::CancelRetransmissionsForStream(
-    QuicStreamId stream_id) {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager != nullptr) {
-      path_manager_info.manager->CancelRetransmissionsForStream(stream_id);
-    }
-  }
-}
-
-void QuicMultipathSentPacketManager::OnConnectionMigration(
-    QuicPathId path_id,
-    PeerAddressChangeType type) {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(path_id);
-  if (path_manager == nullptr) {
-    OnUnrecoverablePathError(path_id);
-    return;
-  }
-  path_manager->OnConnectionMigration(path_id, type);
-}
-
-bool QuicMultipathSentPacketManager::IsHandshakeConfirmed() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  return path_manager != nullptr && path_manager->IsHandshakeConfirmed();
-}
-
-void QuicMultipathSentPacketManager::SetDebugDelegate(
-    DebugDelegate* debug_delegate) {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager == nullptr) {
-      continue;
-    }
-    path_manager_info.manager->SetDebugDelegate(debug_delegate);
-  }
-}
-
-QuicPacketNumber QuicMultipathSentPacketManager::GetLargestObserved(
-    QuicPathId path_id) const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForPath(path_id);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetLargestObserved(path_id);
-}
-
-QuicPacketNumber QuicMultipathSentPacketManager::GetLargestSentPacket(
-    QuicPathId path_id) const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForPath(path_id);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetLargestSentPacket(path_id);
-}
-
-QuicPacketNumber QuicMultipathSentPacketManager::GetLeastPacketAwaitedByPeer(
-    QuicPathId path_id) const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForPath(path_id);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetLeastPacketAwaitedByPeer(path_id);
-}
-
-void QuicMultipathSentPacketManager::SetNetworkChangeVisitor(
-    NetworkChangeVisitor* visitor) {
-  for (PathSentPacketManagerInfo path_manager_info : path_managers_info_) {
-    if (path_manager_info.manager == nullptr ||
-        path_manager_info.state != ACTIVE) {
-      continue;
-    }
-    path_manager_info.manager->SetNetworkChangeVisitor(visitor);
-  }
-}
-
-bool QuicMultipathSentPacketManager::InSlowStart() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  return path_manager != nullptr && path_manager->InSlowStart();
-}
-
-size_t QuicMultipathSentPacketManager::GetConsecutiveRtoCount() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetConsecutiveRtoCount();
-}
-size_t QuicMultipathSentPacketManager::GetConsecutiveTlpCount() const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForActivePath(kDefaultPathId);
-  if (path_manager == nullptr) {
-    return 0;
-  }
-  return path_manager->GetConsecutiveTlpCount();
-}
-
-QuicMultipathSentPacketManager::PathSentPacketManagerInfo::
-    PathSentPacketManagerInfo()
-    : manager(nullptr), state(CLOSING) {}
-
-QuicMultipathSentPacketManager::PathSentPacketManagerInfo::
-    PathSentPacketManagerInfo(QuicSentPacketManagerInterface* manager,
-                              PathSentPacketManagerState state)
-    : manager(manager), state(state) {}
-
-QuicMultipathSentPacketManager::PathSentPacketManagerInfo::
-    PathSentPacketManagerInfo(const PathSentPacketManagerInfo& other) = default;
-
-QuicSentPacketManagerInterface*
-QuicMultipathSentPacketManager::MaybeGetSentPacketManagerForPath(
-    QuicPathId path_id) const {
-  if (path_id >= path_managers_info_.size() ||
-      path_managers_info_[path_id].manager == nullptr) {
-    QUIC_BUG << "Sent packet manager of path: (" + base::IntToString(path_id) +
-                    ") must exist but does not.";
-    return nullptr;
-  }
-
-  return path_managers_info_[path_id].manager;
-}
-
-QuicSentPacketManagerInterface*
-QuicMultipathSentPacketManager::MaybeGetSentPacketManagerForActivePath(
-    QuicPathId path_id) const {
-  QuicSentPacketManagerInterface* path_manager =
-      MaybeGetSentPacketManagerForPath(path_id);
-  if (path_manager == nullptr) {
-    return nullptr;
-  }
-  if (path_managers_info_[path_id].state != ACTIVE) {
-    QUIC_BUG << "Sent packet manager of path: (" + base::IntToString(path_id) +
-                    ") must be active but is not.";
-    return nullptr;
-  }
-
-  return path_manager;
-}
-
-QuicPathId QuicMultipathSentPacketManager::DetermineRetransmissionTimeoutPath()
-    const {
-  QuicTime retransmission_time = QuicTime::Zero();
-  QuicPathId rto_path = kInvalidPathId;
-  for (size_t i = 0; i < path_managers_info_.size(); ++i) {
-    if (path_managers_info_[i].manager == nullptr ||
-        path_managers_info_[i].state != ACTIVE) {
-      continue;
-    }
-    QuicTime path_retransmission_time =
-        path_managers_info_[i].manager->GetRetransmissionTime();
-    if (!path_retransmission_time.IsInitialized()) {
-      continue;
-    }
-    if (!retransmission_time.IsInitialized() ||
-        path_retransmission_time < retransmission_time) {
-      retransmission_time = path_retransmission_time;
-      rto_path = i;
-    }
-  }
-  return rto_path;
-}
-
-void QuicMultipathSentPacketManager::OnUnrecoverablePathError(
-    QuicPathId path_id) {
-  if (MaybeGetSentPacketManagerForPath(path_id) == nullptr) {
-    const string error_details = "Sent packet manager of path: (" +
-                                 base::IntToString(path_id) +
-                                 ") must exist but does not.";
-    delegate_->OnUnrecoverableError(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST,
-                                    error_details,
-                                    ConnectionCloseSource::FROM_SELF);
-    return;
-  }
-  const string error_details = "Sent packet manager of path: (" +
-                               base::IntToString(path_id) +
-                               ") must be active but is not.";
-  delegate_->OnUnrecoverableError(QUIC_MULTIPATH_PATH_NOT_ACTIVE, error_details,
-                                  ConnectionCloseSource::FROM_SELF);
-}
-
-}  // namespace net