Minor cleanup to SpdyHeaderBlock.
The short term goal is to hide more of the details of the implementation, so it's easier to change that implementation without affecting code that uses SpdyHeaderBlock.
gfe-relnote: Cleanup, no functional change. Not protected.
PiperOrigin-RevId: 284281201
Change-Id: Iaddadd363706fbd3e0bb19bae7b4de161692918d
diff --git a/spdy/core/spdy_header_block.cc b/spdy/core/spdy_header_block.cc
index 8a1b65f..91c8494 100644
--- a/spdy/core/spdy_header_block.cc
+++ b/spdy/core/spdy_header_block.cc
@@ -154,13 +154,11 @@
SpdyHeaderBlock::iterator::~iterator() = default;
SpdyHeaderBlock::ValueProxy::ValueProxy(
- SpdyHeaderBlock::MapType* block,
- SpdyHeaderBlock::Storage* storage,
+ SpdyHeaderBlock* block,
SpdyHeaderBlock::MapType::iterator lookup_result,
const SpdyStringPiece key,
size_t* spdy_header_block_value_size)
: block_(block),
- storage_(storage),
lookup_result_(lookup_result),
key_(key),
spdy_header_block_value_size_(spdy_header_block_value_size),
@@ -168,7 +166,6 @@
SpdyHeaderBlock::ValueProxy::ValueProxy(ValueProxy&& other)
: block_(other.block_),
- storage_(other.storage_),
lookup_result_(other.lookup_result_),
key_(other.key_),
spdy_header_block_value_size_(other.spdy_header_block_value_size_),
@@ -179,7 +176,6 @@
SpdyHeaderBlock::ValueProxy& SpdyHeaderBlock::ValueProxy::operator=(
SpdyHeaderBlock::ValueProxy&& other) {
block_ = other.block_;
- storage_ = other.storage_;
lookup_result_ = other.lookup_result_;
key_ = other.key_;
valid_ = true;
@@ -193,43 +189,43 @@
// the assignment operator was never used, and the block's Storage can
// reclaim the memory used by the key. This makes lookup-only access to
// SpdyHeaderBlock through operator[] memory-neutral.
- if (valid_ && lookup_result_ == block_->end()) {
- storage_->Rewind(key_);
+ if (valid_ && lookup_result_ == block_->map_.end()) {
+ block_->GetStorage()->Rewind(key_);
}
}
SpdyHeaderBlock::ValueProxy& SpdyHeaderBlock::ValueProxy::operator=(
const SpdyStringPiece value) {
*spdy_header_block_value_size_ += value.size();
- if (lookup_result_ == block_->end()) {
+ Storage* storage = block_->GetStorage();
+ if (lookup_result_ == block_->map_.end()) {
SPDY_DVLOG(1) << "Inserting: (" << key_ << ", " << value << ")";
lookup_result_ =
- block_
- ->emplace(std::make_pair(
- key_, HeaderValue(storage_, key_, storage_->Write(value))))
+ block_->map_
+ .emplace(std::make_pair(
+ key_, HeaderValue(storage, key_, storage->Write(value))))
.first;
} else {
SPDY_DVLOG(1) << "Updating key: " << key_ << " with value: " << value;
*spdy_header_block_value_size_ -= lookup_result_->second.SizeEstimate();
- lookup_result_->second =
- HeaderValue(storage_, key_, storage_->Write(value));
+ lookup_result_->second = HeaderValue(storage, key_, storage->Write(value));
}
return *this;
}
std::string SpdyHeaderBlock::ValueProxy::as_string() const {
- if (lookup_result_ == block_->end()) {
+ if (lookup_result_ == block_->map_.end()) {
return "";
} else {
return std::string(lookup_result_->second.value());
}
}
-SpdyHeaderBlock::SpdyHeaderBlock() : block_(kInitialMapBuckets) {}
+SpdyHeaderBlock::SpdyHeaderBlock() : map_(kInitialMapBuckets) {}
SpdyHeaderBlock::SpdyHeaderBlock(SpdyHeaderBlock&& other)
- : block_(kInitialMapBuckets) {
- block_.swap(other.block_);
+ : map_(kInitialMapBuckets) {
+ map_.swap(other.map_);
storage_.swap(other.storage_);
key_size_ = other.key_size_;
value_size_ = other.value_size_;
@@ -238,7 +234,7 @@
SpdyHeaderBlock::~SpdyHeaderBlock() = default;
SpdyHeaderBlock& SpdyHeaderBlock::operator=(SpdyHeaderBlock&& other) {
- block_.swap(other.block_);
+ map_.swap(other.map_);
storage_.swap(other.storage_);
key_size_ = other.key_size_;
value_size_ = other.value_size_;
@@ -275,19 +271,19 @@
}
void SpdyHeaderBlock::erase(SpdyStringPiece key) {
- auto iter = block_.find(key);
- if (iter != block_.end()) {
+ auto iter = map_.find(key);
+ if (iter != map_.end()) {
SPDY_DVLOG(1) << "Erasing header with name: " << key;
key_size_ -= key.size();
value_size_ -= iter->second.SizeEstimate();
- block_.erase(iter);
+ map_.erase(iter);
}
}
void SpdyHeaderBlock::clear() {
key_size_ = 0;
value_size_ = 0;
- block_.clear();
+ map_.clear();
storage_.reset();
}
@@ -295,8 +291,8 @@
// TODO(birenroy): Write new value in place of old value, if it fits.
value_size_ += value.second.size();
- auto iter = block_.find(value.first);
- if (iter == block_.end()) {
+ auto iter = map_.find(value.first);
+ if (iter == map_.end()) {
SPDY_DVLOG(1) << "Inserting: (" << value.first << ", " << value.second
<< ")";
AppendHeader(value.first, value.second);
@@ -314,8 +310,8 @@
const SpdyStringPiece key) {
SPDY_DVLOG(2) << "Operator[] saw key: " << key;
SpdyStringPiece out_key;
- auto iter = block_.find(key);
- if (iter == block_.end()) {
+ auto iter = map_.find(key);
+ if (iter == map_.end()) {
// We write the key first, to assure that the ValueProxy has a
// reference to a valid SpdyStringPiece in its operator=.
out_key = WriteKey(key);
@@ -325,15 +321,15 @@
} else {
out_key = iter->first;
}
- return ValueProxy(&block_, GetStorage(), iter, out_key, &value_size_);
+ return ValueProxy(this, iter, out_key, &value_size_);
}
void SpdyHeaderBlock::AppendValueOrAddHeader(const SpdyStringPiece key,
const SpdyStringPiece value) {
value_size_ += value.size();
- auto iter = block_.find(key);
- if (iter == block_.end()) {
+ auto iter = map_.find(key);
+ if (iter == map_.end()) {
SPDY_DVLOG(1) << "Inserting: (" << key << ", " << value << ")";
AppendHeader(key, value);
@@ -346,7 +342,7 @@
}
size_t SpdyHeaderBlock::EstimateMemoryUsage() const {
- // TODO(xunjieli): https://crbug.com/669108. Also include |block_| when EMU()
+ // TODO(xunjieli): https://crbug.com/669108. Also include |map_| when EMU()
// supports linked_hash_map.
return SpdyEstimateMemoryUsage(storage_);
}
@@ -355,7 +351,7 @@
const SpdyStringPiece value) {
auto backed_key = WriteKey(key);
auto* storage = GetStorage();
- block_.emplace(std::make_pair(
+ map_.emplace(std::make_pair(
backed_key, HeaderValue(storage, backed_key, storage->Write(value))));
}
