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))));
}
diff --git a/spdy/core/spdy_header_block.h b/spdy/core/spdy_header_block.h
index 71e1537..b9c0967 100644
--- a/spdy/core/spdy_header_block.h
+++ b/spdy/core/spdy_header_block.h
@@ -133,8 +133,6 @@
};
typedef iterator const_iterator;
- class ValueProxy;
-
SpdyHeaderBlock();
SpdyHeaderBlock(const SpdyHeaderBlock& other) = delete;
SpdyHeaderBlock(SpdyHeaderBlock&& other);
@@ -151,15 +149,15 @@
// keys and values.
std::string DebugString() const;
- iterator begin() { return iterator(block_.begin()); }
- iterator end() { return iterator(block_.end()); }
- const_iterator begin() const { return const_iterator(block_.begin()); }
- const_iterator end() const { return const_iterator(block_.end()); }
- bool empty() const { return block_.empty(); }
- size_t size() const { return block_.size(); }
- iterator find(SpdyStringPiece key) { return iterator(block_.find(key)); }
+ iterator begin() { return iterator(map_.begin()); }
+ iterator end() { return iterator(map_.end()); }
+ const_iterator begin() const { return const_iterator(map_.begin()); }
+ const_iterator end() const { return const_iterator(map_.end()); }
+ bool empty() const { return map_.empty(); }
+ size_t size() const { return map_.size(); }
+ iterator find(SpdyStringPiece key) { return iterator(map_.find(key)); }
const_iterator find(SpdyStringPiece key) const {
- return const_iterator(block_.find(key));
+ return const_iterator(map_.find(key));
}
void erase(SpdyStringPiece key);
@@ -179,9 +177,6 @@
void AppendValueOrAddHeader(const SpdyStringPiece key,
const SpdyStringPiece value);
- // Allows either lookup or mutation of the value associated with a key.
- SPDY_MUST_USE_RESULT ValueProxy operator[](const SpdyStringPiece key);
-
// This object provides automatic conversions that allow SpdyHeaderBlock to be
// nearly a drop-in replacement for
// SpdyLinkedHashMap<std::string, std::string>.
@@ -207,20 +202,21 @@
friend class SpdyHeaderBlock;
friend class test::ValueProxyPeer;
- ValueProxy(SpdyHeaderBlock::MapType* block,
- SpdyHeaderBlock::Storage* storage,
+ ValueProxy(SpdyHeaderBlock* block,
SpdyHeaderBlock::MapType::iterator lookup_result,
const SpdyStringPiece key,
size_t* spdy_header_block_value_size);
- SpdyHeaderBlock::MapType* block_;
- SpdyHeaderBlock::Storage* storage_;
+ SpdyHeaderBlock* block_;
SpdyHeaderBlock::MapType::iterator lookup_result_;
SpdyStringPiece key_;
size_t* spdy_header_block_value_size_;
bool valid_;
};
+ // Allows either lookup or mutation of the value associated with a key.
+ SPDY_MUST_USE_RESULT ValueProxy operator[](const SpdyStringPiece key);
+
// Returns the estimate of dynamically allocated memory in bytes.
size_t EstimateMemoryUsage() const;
@@ -234,9 +230,9 @@
SpdyStringPiece WriteKey(const SpdyStringPiece key);
size_t bytes_allocated() const;
- // SpdyStringPieces held by |block_| point to memory owned by |*storage_|.
- // |storage_| might be nullptr as long as |block_| is empty.
- MapType block_;
+ // SpdyStringPieces held by |map_| point to memory owned by |*storage_|.
+ // |storage_| might be nullptr as long as |map_| is empty.
+ MapType map_;
std::unique_ptr<Storage> storage_;
size_t key_size_ = 0;
