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;