mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 14:26:09 +03:00
244 lines
7.6 KiB
C++
244 lines
7.6 KiB
C++
|
// Copyright 2013 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/chromium/quic_chromium_packet_writer.h"
|
||
|
|
||
|
#include <string>
|
||
|
|
||
|
#include "base/location.h"
|
||
|
#include "base/logging.h"
|
||
|
#include "base/metrics/histogram_macros.h"
|
||
|
#include "base/metrics/sparse_histogram.h"
|
||
|
#include "net/base/io_buffer.h"
|
||
|
#include "net/base/net_errors.h"
|
||
|
#include "net/quic/chromium/quic_chromium_client_session.h"
|
||
|
#include "net/traffic_annotation/network_traffic_annotation.h"
|
||
|
|
||
|
namespace net {
|
||
|
|
||
|
namespace {
|
||
|
|
||
|
enum NotReusableReason {
|
||
|
NOT_REUSABLE_NULLPTR = 0,
|
||
|
NOT_REUSABLE_TOO_SMALL = 1,
|
||
|
NOT_REUSABLE_REF_COUNT = 2,
|
||
|
NUM_NOT_REUSABLE_REASONS = 3,
|
||
|
};
|
||
|
|
||
|
const int kMaxRetries = 12; // 2^12 = 4 seconds, which should be a LOT.
|
||
|
|
||
|
void RecordNotReusableReason(NotReusableReason reason) {
|
||
|
UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.WritePacketNotReusable", reason,
|
||
|
NUM_NOT_REUSABLE_REASONS);
|
||
|
}
|
||
|
|
||
|
void RecordRetryCount(int count) {
|
||
|
UMA_HISTOGRAM_EXACT_LINEAR("Net.QuicSession.RetryAfterWriteErrorCount2",
|
||
|
count, kMaxRetries + 1);
|
||
|
}
|
||
|
|
||
|
const net::NetworkTrafficAnnotationTag kTrafficAnnotation =
|
||
|
net::DefineNetworkTrafficAnnotation("quic_chromium_packet_writer", R"(
|
||
|
semantics {
|
||
|
sender: "QUIC Packet Writer"
|
||
|
description:
|
||
|
"A QUIC packet is written to the wire based on a request from "
|
||
|
"a QUIC stream."
|
||
|
trigger:
|
||
|
"A request from QUIC stream."
|
||
|
data: "Any data sent by the stream."
|
||
|
destination: OTHER
|
||
|
destination_other: "Any destination choosen by the stream."
|
||
|
}
|
||
|
policy {
|
||
|
cookies_allowed: NO
|
||
|
setting: "This feature cannot be disabled in settings."
|
||
|
policy_exception_justification:
|
||
|
"Essential for network access."
|
||
|
}
|
||
|
comments:
|
||
|
"All requests that are received by QUIC streams have network traffic "
|
||
|
"annotation, but the annotation is not passed to the writer function "
|
||
|
"due to technial overheads. Please see QuicChromiumClientSession and "
|
||
|
"QuicChromiumClientStream classes for references."
|
||
|
)");
|
||
|
|
||
|
} // namespace
|
||
|
|
||
|
QuicChromiumPacketWriter::ReusableIOBuffer::ReusableIOBuffer(size_t capacity)
|
||
|
: IOBuffer(capacity), capacity_(capacity), size_(0) {}
|
||
|
|
||
|
QuicChromiumPacketWriter::ReusableIOBuffer::~ReusableIOBuffer() {}
|
||
|
|
||
|
void QuicChromiumPacketWriter::ReusableIOBuffer::Set(const char* buffer,
|
||
|
size_t buf_len) {
|
||
|
CHECK_LE(buf_len, capacity_);
|
||
|
CHECK(HasOneRef());
|
||
|
size_ = buf_len;
|
||
|
std::memcpy(data(), buffer, buf_len);
|
||
|
}
|
||
|
|
||
|
QuicChromiumPacketWriter::QuicChromiumPacketWriter() : weak_factory_(this) {}
|
||
|
|
||
|
QuicChromiumPacketWriter::QuicChromiumPacketWriter(
|
||
|
DatagramClientSocket* socket,
|
||
|
base::SequencedTaskRunner* task_runner)
|
||
|
: socket_(socket),
|
||
|
delegate_(nullptr),
|
||
|
packet_(new ReusableIOBuffer(kMaxPacketSize)),
|
||
|
write_blocked_(false),
|
||
|
retry_count_(0),
|
||
|
weak_factory_(this) {
|
||
|
retry_timer_.SetTaskRunner(task_runner);
|
||
|
write_callback_ = base::Bind(&QuicChromiumPacketWriter::OnWriteComplete,
|
||
|
weak_factory_.GetWeakPtr());
|
||
|
}
|
||
|
|
||
|
QuicChromiumPacketWriter::~QuicChromiumPacketWriter() {}
|
||
|
|
||
|
void QuicChromiumPacketWriter::SetPacket(const char* buffer, size_t buf_len) {
|
||
|
if (UNLIKELY(!packet_)) {
|
||
|
packet_ = new ReusableIOBuffer(
|
||
|
std::max(buf_len, static_cast<size_t>(kMaxPacketSize)));
|
||
|
RecordNotReusableReason(NOT_REUSABLE_NULLPTR);
|
||
|
}
|
||
|
if (UNLIKELY(packet_->capacity() < buf_len)) {
|
||
|
packet_ = new ReusableIOBuffer(buf_len);
|
||
|
RecordNotReusableReason(NOT_REUSABLE_TOO_SMALL);
|
||
|
}
|
||
|
if (UNLIKELY(!packet_->HasOneRef())) {
|
||
|
packet_ = new ReusableIOBuffer(
|
||
|
std::max(buf_len, static_cast<size_t>(kMaxPacketSize)));
|
||
|
RecordNotReusableReason(NOT_REUSABLE_REF_COUNT);
|
||
|
}
|
||
|
packet_->Set(buffer, buf_len);
|
||
|
}
|
||
|
|
||
|
WriteResult QuicChromiumPacketWriter::WritePacket(
|
||
|
const char* buffer,
|
||
|
size_t buf_len,
|
||
|
const QuicIpAddress& self_address,
|
||
|
const QuicSocketAddress& peer_address,
|
||
|
PerPacketOptions* /*options*/) {
|
||
|
DCHECK(!IsWriteBlocked());
|
||
|
SetPacket(buffer, buf_len);
|
||
|
return WritePacketToSocketImpl();
|
||
|
}
|
||
|
|
||
|
WriteResult QuicChromiumPacketWriter::WritePacketToSocket(
|
||
|
scoped_refptr<ReusableIOBuffer> packet) {
|
||
|
packet_ = std::move(packet);
|
||
|
return QuicChromiumPacketWriter::WritePacketToSocketImpl();
|
||
|
}
|
||
|
|
||
|
WriteResult QuicChromiumPacketWriter::WritePacketToSocketImpl() {
|
||
|
base::TimeTicks now = base::TimeTicks::Now();
|
||
|
|
||
|
int rv = socket_->Write(packet_.get(), packet_->size(), write_callback_,
|
||
|
kTrafficAnnotation);
|
||
|
|
||
|
if (MaybeRetryAfterWriteError(rv))
|
||
|
return WriteResult(WRITE_STATUS_BLOCKED, ERR_IO_PENDING);
|
||
|
|
||
|
if (rv < 0 && rv != ERR_IO_PENDING && delegate_ != nullptr) {
|
||
|
// If write error, then call delegate's HandleWriteError, which
|
||
|
// may be able to migrate and rewrite packet on a new socket.
|
||
|
// HandleWriteError returns the outcome of that rewrite attempt.
|
||
|
rv = delegate_->HandleWriteError(rv, std::move(packet_));
|
||
|
DCHECK(packet_ == nullptr);
|
||
|
}
|
||
|
|
||
|
WriteStatus status = WRITE_STATUS_OK;
|
||
|
if (rv < 0) {
|
||
|
if (rv != ERR_IO_PENDING) {
|
||
|
status = WRITE_STATUS_ERROR;
|
||
|
} else {
|
||
|
status = WRITE_STATUS_BLOCKED;
|
||
|
write_blocked_ = true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
base::TimeDelta delta = base::TimeTicks::Now() - now;
|
||
|
if (status == WRITE_STATUS_OK) {
|
||
|
UMA_HISTOGRAM_TIMES("Net.QuicSession.PacketWriteTime.Synchronous", delta);
|
||
|
} else if (status == WRITE_STATUS_BLOCKED) {
|
||
|
UMA_HISTOGRAM_TIMES("Net.QuicSession.PacketWriteTime.Asynchronous", delta);
|
||
|
}
|
||
|
|
||
|
return WriteResult(status, rv);
|
||
|
}
|
||
|
|
||
|
void QuicChromiumPacketWriter::RetryPacketAfterNoBuffers() {
|
||
|
DCHECK_GT(retry_count_, 0);
|
||
|
WriteResult result = WritePacketToSocketImpl();
|
||
|
if (result.error_code != ERR_IO_PENDING)
|
||
|
OnWriteComplete(result.error_code);
|
||
|
}
|
||
|
|
||
|
bool QuicChromiumPacketWriter::IsWriteBlockedDataBuffered() const {
|
||
|
// Chrome sockets' Write() methods buffer the data until the Write is
|
||
|
// permitted.
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool QuicChromiumPacketWriter::IsWriteBlocked() const {
|
||
|
return write_blocked_;
|
||
|
}
|
||
|
|
||
|
void QuicChromiumPacketWriter::SetWritable() {
|
||
|
write_blocked_ = false;
|
||
|
}
|
||
|
|
||
|
void QuicChromiumPacketWriter::OnWriteComplete(int rv) {
|
||
|
DCHECK_NE(rv, ERR_IO_PENDING);
|
||
|
DCHECK(delegate_) << "Uninitialized delegate.";
|
||
|
write_blocked_ = false;
|
||
|
if (rv < 0) {
|
||
|
if (MaybeRetryAfterWriteError(rv))
|
||
|
return;
|
||
|
|
||
|
// If write error, then call delegate's HandleWriteError, which
|
||
|
// may be able to migrate and rewrite packet on a new socket.
|
||
|
// HandleWriteError returns the outcome of that rewrite attempt.
|
||
|
rv = delegate_->HandleWriteError(rv, std::move(packet_));
|
||
|
DCHECK(packet_ == nullptr);
|
||
|
if (rv == ERR_IO_PENDING)
|
||
|
return;
|
||
|
}
|
||
|
if (retry_count_ != 0) {
|
||
|
RecordRetryCount(retry_count_);
|
||
|
retry_count_ = 0;
|
||
|
}
|
||
|
|
||
|
if (rv < 0)
|
||
|
delegate_->OnWriteError(rv);
|
||
|
else
|
||
|
delegate_->OnWriteUnblocked();
|
||
|
}
|
||
|
|
||
|
bool QuicChromiumPacketWriter::MaybeRetryAfterWriteError(int rv) {
|
||
|
if (rv != ERR_NO_BUFFER_SPACE)
|
||
|
return false;
|
||
|
|
||
|
if (retry_count_ >= kMaxRetries) {
|
||
|
RecordRetryCount(retry_count_);
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
retry_timer_.Start(
|
||
|
FROM_HERE, base::TimeDelta::FromMilliseconds(UINT64_C(1) << retry_count_),
|
||
|
base::Bind(&QuicChromiumPacketWriter::RetryPacketAfterNoBuffers,
|
||
|
weak_factory_.GetWeakPtr()));
|
||
|
retry_count_++;
|
||
|
write_blocked_ = true;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
QuicByteCount QuicChromiumPacketWriter::GetMaxPacketSize(
|
||
|
const QuicSocketAddress& peer_address) const {
|
||
|
return kMaxPacketSize;
|
||
|
}
|
||
|
|
||
|
} // namespace net
|