Notfiy NQE of QUIC RTT

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 226 matching lines @@
     TransmissionType transmission_type,
     QuicPacketNumber original_packet_number)
     : serialized_packet(packet),
       encryption_level(level),
       transmission_type(transmission_type),
       original_packet_number(original_packet_number) {}
 
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
-QuicConnection::QuicConnection(QuicConnectionId connection_id,
-                               IPEndPoint address,
-                               QuicConnectionHelperInterface* helper,
-                               const PacketWriterFactory& writer_factory,
-                               bool owns_writer,
-                               Perspective perspective,
-                               bool is_secure,
-                               const QuicVersionVector& supported_versions)
+QuicConnection::QuicConnection(
+    QuicConnectionId connection_id,
+    IPEndPoint address,
+    QuicConnectionHelperInterface* helper,
+    const PacketWriterFactory& writer_factory,
+    bool owns_writer,
+    Perspective perspective,
+    bool is_secure,
+    const QuicVersionVector& supported_versions,
+    scoped_ptr<SocketPerformanceWatcher> socket_performance_watcher)
     : framer_(supported_versions,
               helper->GetClock()->ApproximateNow(),
               perspective),
       helper_(helper),
       writer_(writer_factory.Create(this)),
       owns_writer_(owns_writer),
       encryption_level_(ENCRYPTION_NONE),
       has_forward_secure_encrypter_(false),
       first_required_forward_secure_packet_(0),
       clock_(helper->GetClock()),
@@ skipping 48 matching lines @@
       self_ip_changed_(false),
       self_port_changed_(false),
       can_truncate_connection_ids_(true),
       is_secure_(is_secure),
       mtu_discovery_target_(0),
       mtu_probe_count_(0),
       packets_between_mtu_probes_(kPacketsBetweenMtuProbesBase),
       next_mtu_probe_at_(kPacketsBetweenMtuProbesBase),
       largest_received_packet_size_(0),
       goaway_sent_(false),
-      goaway_received_(false) {
+      goaway_received_(false),
+      socket_performance_watcher_(socket_performance_watcher.Pass()) {
   DVLOG(1) << ENDPOINT << "Created connection with connection_id: "
            << connection_id;
   framer_.set_visitor(this);
   framer_.set_received_entropy_calculator(&received_packet_manager_);
   stats_.connection_creation_time = clock_->ApproximateNow();
   sent_packet_manager_.set_network_change_visitor(this);
   if (perspective_ == Perspective::IS_SERVER) {
     set_max_packet_length(kDefaultServerMaxPacketSize);
   }
 }
@@ skipping 1047 matching lines @@
     DVLOG(1) << ENDPOINT << "Unable to process packet.  Last packet processed: "
              << last_header_.packet_packet_number;
     return;
   }
 
   ++stats_.packets_processed;
   MaybeProcessUndecryptablePackets();
   MaybeProcessRevivedPacket();
   MaybeSendInResponseToPacket();
   SetPingAlarm();
+
+  // Notify socket performance watcher of the updated RTT value.
+  if (socket_performance_watcher_) {
+    socket_performance_watcher_->OnUpdatedRTTAvailable(
+        base::TimeDelta::FromMicroseconds(sent_packet_manager_.GetRttStats()
+                                              ->smoothed_rtt()
+                                              .ToMicroseconds()));
+  }
 }
 
 void QuicConnection::CheckForAddressMigration(
     const IPEndPoint& self_address, const IPEndPoint& peer_address) {
   peer_ip_changed_ = false;
   peer_port_changed_ = false;
   self_ip_changed_ = false;
   self_port_changed_ = false;
 
   if (peer_address_.address().empty()) {
@@ skipping 322 matching lines @@
 
   if (result.status == WRITE_STATUS_ERROR) {
     OnWriteError(result.error_code);
     DLOG(ERROR) << ENDPOINT << "failed writing " << encrypted->length()
                 << " bytes "
                 << " from host " << self_address().ToStringWithoutPort()
                 << " to address " << peer_address().ToString();
     return false;
   }
 
+  // Notify socket performance watcher of the updated RTT value.
+  if (socket_performance_watcher_) {
+    socket_performance_watcher_->OnUpdatedRTTAvailable(
+        base::TimeDelta::FromMicroseconds(sent_packet_manager_.GetRttStats()
+                                              ->smoothed_rtt()
+                                              .ToMicroseconds()));
+  }
   return true;
 }
 
 bool QuicConnection::ShouldDiscardPacket(const QueuedPacket& packet) {
   if (!connected_) {
     DVLOG(1) << ENDPOINT
              << "Not sending packet as connection is disconnected.";
     return true;
   }
 
@@ skipping 653 matching lines @@
       packet_number_of_last_sent_packet_ + packets_between_mtu_probes_ + 1;
   ++mtu_probe_count_;
 
   DVLOG(2) << "Sending a path MTU discovery packet #" << mtu_probe_count_;
   SendMtuDiscoveryPacket(mtu_discovery_target_);
 
   DCHECK(!mtu_discovery_alarm_->IsSet());
 }
 
 }  // namespace net