Expose ECT to render frames, Blink and NetInfo

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

 /*
  * 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 41 matching lines @@
   DCHECK(IsMainThread());
   before_ = notifier_.has_override_ ? notifier_.override_ : notifier_.state_;
 }
 
 NetworkStateNotifier::ScopedNotifier::~ScopedNotifier() {
   DCHECK(IsMainThread());
   const NetworkState& after =
       notifier_.has_override_ ? notifier_.override_ : notifier_.state_;
   if ((after.type != before_.type ||
        after.max_bandwidth_mbps != before_.max_bandwidth_mbps ||
+       after.effective_type != before_.effective_type ||
        after.http_rtt != before_.http_rtt ||
        after.transport_rtt != before_.transport_rtt ||
        after.downlink_throughput_mbps != before_.downlink_throughput_mbps) &&
       before_.connection_initialized) {
     notifier_.NotifyObservers(notifier_.connection_observers_,
                               ObserverType::CONNECTION_TYPE, after);
   }
   if (after.on_line != before_.on_line && before_.on_line_initialized) {
     notifier_.NotifyObservers(notifier_.on_line_state_observers_,
                               ObserverType::ONLINE_STATE, after);
@@ skipping 15 matching lines @@
   DCHECK(IsMainThread());
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(mutex_);
     state_.connection_initialized = true;
     state_.type = type;
     state_.max_bandwidth_mbps = max_bandwidth_mbps;
   }
 }
 
-void NetworkStateNotifier::SetNetworkQuality(TimeDelta http_rtt,
+void NetworkStateNotifier::SetNetworkQuality(WebEffectiveConnectionType type,
+                                             TimeDelta http_rtt,
                                              TimeDelta transport_rtt,
                                              int downlink_throughput_kbps) {
   DCHECK(IsMainThread());
   ScopedNotifier notifier(*this);
   {
     MutexLocker locker(mutex_);
 
+    state_.effective_type = type;
     state_.http_rtt = base::nullopt;
     state_.transport_rtt = base::nullopt;
     state_.downlink_throughput_mbps = base::nullopt;
 
     if (http_rtt.InMilliseconds() >= 0)
       state_.http_rtt = http_rtt;
 
     if (transport_rtt.InMilliseconds() >= 0)
       state_.transport_rtt = transport_rtt;
 
@@ skipping 87 matching lines @@
   for (size_t i = 0; i < observer_list->observers.size(); ++i) {
     // Observers removed during iteration are zeroed out, skip them.
     if (!observer_list->observers[i])
       continue;
     switch (type) {
       case ObserverType::ONLINE_STATE:
         observer_list->observers[i]->OnLineStateChange(state.on_line);
         continue;
       case ObserverType::CONNECTION_TYPE:
         observer_list->observers[i]->ConnectionChange(
-            state.type, state.max_bandwidth_mbps, state.http_rtt,
-            state.transport_rtt, state.downlink_throughput_mbps);
+            state.type, state.max_bandwidth_mbps, state.effective_type,
+            state.http_rtt, state.transport_rtt,
+            state.downlink_throughput_mbps);
         continue;
     }
     NOTREACHED();
   }
 
   observer_list->iterating = false;
 
   if (!observer_list->zeroed_observers.IsEmpty())
     CollectZeroedObservers(*map, observer_list, std::move(task_runner));
 }
@@ skipping 58 matching lines @@
 
   list->zeroed_observers.clear();
 
   if (list->observers.IsEmpty()) {
     MutexLocker locker(mutex_);
     map.erase(task_runner);  // deletes list
   }
 }
 
 }  // namespace blink