Expose ECT to render frames, Blink and NetInfo

third_party/WebKit/Source/platform/network/NetworkStateNotifier.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "platform/PlatformExport.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/Noncopyable.h"
 #include "platform/wtf/Optional.h"
 #include "platform/wtf/ThreadingPrimitives.h"
 #include "platform/wtf/Time.h"
 #include "platform/wtf/Vector.h"
 #include "public/platform/WebConnectionType.h"
+#include "public/platform/WebEffectiveConnectionType.h"
 
 namespace blink {
 
 class PLATFORM_EXPORT NetworkStateNotifier {
   WTF_MAKE_NONCOPYABLE(NetworkStateNotifier);
   USING_FAST_MALLOC(NetworkStateNotifier);
 
  public:
   struct NetworkState {
     static const int kInvalidMaxBandwidth = -1;
     bool on_line_initialized = false;
     bool on_line = true;
     bool connection_initialized = false;
     WebConnectionType type = kWebConnectionTypeOther;
     double max_bandwidth_mbps = kInvalidMaxBandwidth;
+    WebEffectiveConnectionType effective_type =
+        WebEffectiveConnectionType::kTypeUnknown;
     Optional<TimeDelta> http_rtt;
     Optional<TimeDelta> transport_rtt;
     Optional<double> downlink_throughput_mbps;
   };
 
   class NetworkStateObserver {
    public:
     // Will be called on the task runner that is passed in add*Observer.
     virtual void ConnectionChange(
         WebConnectionType,
         double max_bandwidth_mbps,
+        WebEffectiveConnectionType,
         const Optional<TimeDelta>& http_rtt,
         const Optional<TimeDelta>& transport_rtt,
         const Optional<double>& downlink_throughput_mbps) {}
     virtual void OnLineStateChange(bool on_line) {}
   };
 
   NetworkStateNotifier() : has_override_(false) {}
 
   // Can be called on any thread.
   bool OnLine() const {
     MutexLocker locker(mutex_);
     const NetworkState& state = has_override_ ? override_ : state_;
     DCHECK(state.on_line_initialized);
     return state.on_line;
   }
 
+  // Returns the current effective connection type, which is the connection type
+  // whose typical performance is most similar to the measured performance of
+  // the network in use.
+  WebEffectiveConnectionType EffectiveType() const {
+    MutexLocker locker(mutex_);
+    const NetworkState& state = has_override_ ? override_ : state_;
+    DCHECK(state.on_line_initialized);
+    return state.effective_type;
+  }
+
   // Returns the current HTTP RTT estimate. If the estimate is unavailable, the
   // returned optional value is null.
   Optional<TimeDelta> HttpRtt() const {
     MutexLocker locker(mutex_);
     const NetworkState& state = has_override_ ? override_ : state_;
     DCHECK(state.on_line_initialized);
     return state.http_rtt;
   }
 
   // Returns the current transport RTT estimate. If the estimate is unavailable,
@@ skipping 46 matching lines @@
 
   // Can be called on any thread.
   double MaxBandwidth() const {
     MutexLocker locker(mutex_);
     const NetworkState& state = has_override_ ? override_ : state_;
     DCHECK(state.connection_initialized);
     return state.max_bandwidth_mbps;
   }
 
   void SetWebConnection(WebConnectionType, double max_bandwidth_mbps);
-  void SetNetworkQuality(TimeDelta http_rtt,
+  void SetNetworkQuality(WebEffectiveConnectionType,
+                         TimeDelta http_rtt,
                          TimeDelta transport_rtt,
                          int downlink_throughput_kbps);
 
   // When called, successive setWebConnectionType/setOnLine calls are stored,
   // and supplied overridden values are used instead until clearOverride() is
   // called.  This is used for layout tests (see crbug.com/377736) and inspector
   // emulation.
   //
   // Since this class is a singleton, tests must clear override when completed
   // to avoid indeterminate state across the test harness.
@@ skipping 72 matching lines @@
 
   ObserverListMap connection_observers_;
   ObserverListMap on_line_state_observers_;
 };
 
 PLATFORM_EXPORT NetworkStateNotifier& GetNetworkStateNotifier();
 
 }  // namespace blink
 
 #endif  // NetworkStateNotifier_h