mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 06:16:30 +03:00
123 lines
3.9 KiB
C++
123 lines
3.9 KiB
C++
// Copyright 2017 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/nqe/event_creator.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#include "base/bind.h"
|
|
#include "base/callback.h"
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "base/values.h"
|
|
#include "net/log/net_log_capture_mode.h"
|
|
#include "net/log/net_log_with_source.h"
|
|
|
|
namespace net {
|
|
|
|
namespace nqe {
|
|
|
|
namespace internal {
|
|
|
|
namespace {
|
|
|
|
std::unique_ptr<base::Value> NetworkQualityChangedNetLogCallback(
|
|
base::TimeDelta http_rtt,
|
|
base::TimeDelta transport_rtt,
|
|
int32_t downstream_throughput_kbps,
|
|
EffectiveConnectionType effective_connection_type,
|
|
NetLogCaptureMode capture_mode) {
|
|
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
|
|
dict->SetInteger("http_rtt_ms", http_rtt.InMilliseconds());
|
|
dict->SetInteger("transport_rtt_ms", transport_rtt.InMilliseconds());
|
|
dict->SetInteger("downstream_throughput_kbps", downstream_throughput_kbps);
|
|
dict->SetString("effective_connection_type",
|
|
GetNameForEffectiveConnectionType(effective_connection_type));
|
|
return std::move(dict);
|
|
}
|
|
|
|
bool MetricChangedMeaningfully(int32_t past_value, int32_t current_value) {
|
|
if ((past_value == INVALID_RTT_THROUGHPUT) !=
|
|
(current_value == INVALID_RTT_THROUGHPUT)) {
|
|
return true;
|
|
}
|
|
|
|
if (past_value == INVALID_RTT_THROUGHPUT &&
|
|
current_value == INVALID_RTT_THROUGHPUT) {
|
|
return false;
|
|
}
|
|
|
|
// Create a new entry only if (i) the difference between the two values exceed
|
|
// the threshold; and, (ii) the ratio of the values also exceeds the
|
|
// threshold.
|
|
static const int kMinDifferenceInMetrics = 100;
|
|
static const float kMinRatio = 1.2f;
|
|
|
|
if (std::abs(past_value - current_value) < kMinDifferenceInMetrics) {
|
|
// The absolute change in the value is not sufficient enough.
|
|
return false;
|
|
}
|
|
|
|
if (past_value < (kMinRatio * current_value) &&
|
|
current_value < (kMinRatio * past_value)) {
|
|
// The relative change in the value is not sufficient enough.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
EventCreator::EventCreator(NetLogWithSource net_log)
|
|
: net_log_(net_log),
|
|
past_effective_connection_type_(EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {}
|
|
|
|
EventCreator::~EventCreator() {
|
|
DCHECK(thread_checker_.CalledOnValidThread());
|
|
}
|
|
|
|
void EventCreator::MaybeAddNetworkQualityChangedEventToNetLog(
|
|
EffectiveConnectionType effective_connection_type,
|
|
const NetworkQuality& network_quality) {
|
|
DCHECK(thread_checker_.CalledOnValidThread());
|
|
|
|
// Check if any of the network quality metrics changed meaningfully.
|
|
bool effective_connection_type_changed =
|
|
past_effective_connection_type_ != effective_connection_type;
|
|
bool http_rtt_changed = MetricChangedMeaningfully(
|
|
past_network_quality_.http_rtt().InMilliseconds(),
|
|
network_quality.http_rtt().InMilliseconds());
|
|
|
|
bool transport_rtt_changed = MetricChangedMeaningfully(
|
|
past_network_quality_.transport_rtt().InMilliseconds(),
|
|
network_quality.transport_rtt().InMilliseconds());
|
|
bool kbps_changed = MetricChangedMeaningfully(
|
|
past_network_quality_.downstream_throughput_kbps(),
|
|
network_quality.downstream_throughput_kbps());
|
|
|
|
if (!effective_connection_type_changed && !http_rtt_changed &&
|
|
!transport_rtt_changed && !kbps_changed) {
|
|
// Return since none of the metrics changed meaningfully.
|
|
return;
|
|
}
|
|
|
|
past_effective_connection_type_ = effective_connection_type;
|
|
past_network_quality_ = network_quality;
|
|
|
|
net_log_.AddEvent(
|
|
NetLogEventType::NETWORK_QUALITY_CHANGED,
|
|
base::Bind(&NetworkQualityChangedNetLogCallback,
|
|
network_quality.http_rtt(), network_quality.transport_rtt(),
|
|
network_quality.downstream_throughput_kbps(),
|
|
effective_connection_type));
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
} // namespace nqe
|
|
|
|
} // namespace net
|