0

Cleanups from stricter span usage of size_t: net

More use of first(), compile-time sizes, etc.

Bug: none
Change-Id: Idc0bc924edcd456d60fc7fde57e0491f6fc7311f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6027100
Reviewed-by: Adam Rice <ricea@chromium.org>
Commit-Queue: Adam Rice <ricea@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Code-Coverage: findit-for-me@appspot.gserviceaccount.com <findit-for-me@appspot.gserviceaccount.com>
Cr-Commit-Position: refs/heads/main@{#1384120}
This commit is contained in:
Peter Kasting
2024-11-17 22:41:10 +00:00
committed by Chromium LUCI CQ
parent e1aa4cf01f
commit c588bd45e4
10 changed files with 23 additions and 24 deletions

@@ -53,7 +53,7 @@ std::string LoadFlagsToString(int load_flags) {
flag_names.reserve(expected_size);
// Skip the first entry in kInfo as including LOAD_NORMAL in the output would
// be confusing.
for (const auto& flag : base::span(kInfo).subspan(1)) {
for (const auto& flag : base::span(kInfo).subspan<1>()) {
if (load_flags & flag.value) {
flag_names.push_back(flag.name);
}

@@ -113,7 +113,7 @@ bool FixedSetIncrementalLookup::Advance(char input) {
// If this is not the last character in the label, the next byte should
// be interpreted as a character or return value. Otherwise, the next
// byte should be interpreted as a list of child node offsets.
bytes_ = bytes_.subspan(1);
bytes_ = bytes_.subspan<1>();
DCHECK(!bytes_.empty());
bytes_starts_with_label_character_ = !is_last_char_in_label;
return true;
@@ -144,7 +144,7 @@ bool FixedSetIncrementalLookup::Advance(char input) {
// should be interpreted as a character or return value. Otherwise,
// the next byte should be interpreted as a list of child node
// offsets.
bytes_ = offset_bytes.subspan(1);
bytes_ = offset_bytes.subspan<1>();
DCHECK(!bytes_.empty());
bytes_starts_with_label_character_ = !is_last_char_in_label;
return true;

@@ -635,7 +635,7 @@ bool Job::ConsumeBytesRead(URLRequest* request, int num_bytes) {
// Append the data to |response_body_|.
response_body_.reserve(response_body_.size() + num_bytes_s);
base::Extend(response_body_, read_buffer_->span().subspan(0, num_bytes_s));
base::Extend(response_body_, read_buffer_->span().first(num_bytes_s));
return true;
}

@@ -22,12 +22,12 @@ static constexpr size_t kCompressionTypeBrotliSignatureSize =
sizeof(kCompressionTypeBrotliSignature);
static constexpr size_t kCompressionTypeZstdSignatureSize =
sizeof(kCompressionTypeZstdSignature);
static constexpr int kCompressionDictionaryHashSize = 32;
static constexpr size_t kCompressionDictionaryHashSize = 32;
static_assert(sizeof(SHA256HashValue) == kCompressionDictionaryHashSize,
"kCompressionDictionaryHashSize mismatch");
static constexpr int kCompressionTypeBrotliHeaderSize =
static constexpr size_t kCompressionTypeBrotliHeaderSize =
kCompressionTypeBrotliSignatureSize + kCompressionDictionaryHashSize;
static constexpr int kCompressionTypeZstdHeaderSize =
static constexpr size_t kCompressionTypeZstdHeaderSize =
kCompressionTypeZstdSignatureSize + kCompressionDictionaryHashSize;
size_t GetSignatureSize(SharedDictionaryHeaderCheckerSourceStream::Type type) {
@@ -171,7 +171,7 @@ void SharedDictionaryHeaderCheckerSourceStream::HeaderCheckCompleted(
base::span<const unsigned char>
SharedDictionaryHeaderCheckerSourceStream::GetSignatureInBuffer() const {
return head_read_buffer_->everything().subspan(0, GetSignatureSize(type_));
return head_read_buffer_->everything().first(GetSignatureSize(type_));
}
base::span<const unsigned char>

@@ -336,8 +336,7 @@ const MockWrite& StaticSocketDataHelper::PeekRealWrite() const {
return writes_[i];
}
CHECK(false) << "No write data available.";
return writes_[0]; // Avoid warning about unreachable missing return.
NOTREACHED() << "No write data available.";
}
StaticSocketDataProvider::StaticSocketDataProvider()

@@ -374,7 +374,7 @@ MockTransportClientSocketFactory::CreateTransportClientSocket(
Rule rule(client_socket_type_);
if (!rules_.empty()) {
rule = rules_.front();
rules_ = rules_.subspan(1);
rules_ = rules_.subspan<1>();
}
if (rule.expected_addresses) {

@@ -412,9 +412,10 @@ class SpdyNetworkTransactionTest
void UseComplexPostRequest() {
ASSERT_FALSE(upload_data_stream_);
const int kFileRangeOffset = 1;
const int kFileRangeLength = 3;
CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
static constexpr size_t kFileRangeOffset = 1;
static constexpr size_t kFileRangeLength = 3;
CHECK_LT(static_cast<int>(kFileRangeOffset + kFileRangeLength),
kUploadDataSize);
base::FilePath file_path;
CHECK(base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &file_path));
@@ -422,14 +423,13 @@ class SpdyNetworkTransactionTest
std::vector<std::unique_ptr<UploadElementReader>> element_readers;
element_readers.push_back(std::make_unique<UploadBytesElementReader>(
base::byte_span_from_cstring(kUploadData)
.first(base::checked_cast<size_t>(kFileRangeOffset))));
base::byte_span_from_cstring(kUploadData).first<kFileRangeOffset>()));
element_readers.push_back(std::make_unique<UploadFileElementReader>(
base::SingleThreadTaskRunner::GetCurrentDefault().get(), file_path,
kFileRangeOffset, kFileRangeLength, base::Time()));
element_readers.push_back(std::make_unique<UploadBytesElementReader>(
base::byte_span_from_cstring(kUploadData)
.subspan(kFileRangeOffset + kFileRangeLength)));
.subspan<kFileRangeOffset + kFileRangeLength>()));
upload_data_stream_ = std::make_unique<ElementsUploadDataStream>(
std::move(element_readers), 0);

@@ -263,7 +263,7 @@ void WebSocketConnection::OnReadComplete(int result)
}
base::span<uint8_t> data_span =
read_buffer_->span().subspan(0, static_cast<size_t>(result));
read_buffer_->span().first(static_cast<size_t>(result));
WebSocketFrameParser parser;
std::vector<std::unique_ptr<WebSocketFrameChunk>> frame_chunks;

@@ -35,9 +35,10 @@ void WebSocketSplitPacketCloseHandler::SendSplitCloseFrame() {
// Split the close frame into two parts and send each separately.
const auto close_frame_span = close_frame->span();
const size_t split_index = 1; // Split after the first byte
connection()->SendRaw(close_frame_span.subspan(0, split_index));
connection()->SendRaw(close_frame_span.subspan(split_index));
// Split after the first byte
const auto [first, rest] = close_frame_span.split_at<1>();
connection()->SendRaw(first);
connection()->SendRaw(rest);
connection()->DisconnectAfterAnyWritesDone();
}

@@ -156,7 +156,7 @@ size_t WebSocketFrameParser::DecodeFrameHeader(base::span<const uint8_t> data) {
WebSocketMaskingKey masking_key = {};
const bool masked = (second_byte & kMaskBit) != 0;
static constexpr int kMaskingKeyLength =
static constexpr size_t kMaskingKeyLength =
WebSocketFrameHeader::kMaskingKeyLength;
if (masked) {
if (data.size() < current + kMaskingKeyLength)
@@ -194,8 +194,7 @@ std::unique_ptr<WebSocketFrameChunk> WebSocketFrameParser::DecodeFramePayload(
frame_chunk->final_chunk = false;
if (chunk_data_size) {
const auto split_point = base::checked_cast<size_t>(chunk_data_size);
frame_chunk->payload =
base::as_writable_chars(data->subspan(0, split_point));
frame_chunk->payload = base::as_writable_chars(data->first(split_point));
*data = data->subspan(split_point);
frame_offset_ += chunk_data_size;
}