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))));
 }