diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index 123a963..3c1edc4 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -23,4 +23,229 @@
 
 QuicWriteBlockedList::~QuicWriteBlockedList() {}
 
+bool QuicWriteBlockedList::ShouldYield(QuicStreamId id) const {
+  for (const auto& stream : static_stream_collection_) {
+    if (stream.id == id) {
+      // Static streams should never yield to data streams, or to lower
+      // priority static stream.
+      return false;
+    }
+    if (stream.is_blocked) {
+      return true;  // All data streams yield to static streams.
+    }
+  }
+
+  return priority_write_scheduler_->ShouldYield(id);
+}
+
+bool QuicWriteBlockedList::SwitchWriteScheduler(spdy::WriteSchedulerType type,
+                                                QuicTransportVersion version) {
+  if (scheduler_type_ == type) {
+    return true;
+  }
+  if (priority_write_scheduler_->NumRegisteredStreams() != 0) {
+    QUIC_BUG << "Cannot switch scheduler with registered streams";
+    return false;
+  }
+  QUIC_DVLOG(1) << "Switching to scheduler type: "
+                << spdy::WriteSchedulerTypeToString(type);
+  switch (type) {
+    case spdy::WriteSchedulerType::LIFO:
+      priority_write_scheduler_ =
+          std::make_unique<spdy::LifoWriteScheduler<QuicStreamId>>();
+      break;
+    case spdy::WriteSchedulerType::SPDY:
+      priority_write_scheduler_ =
+          std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
+              QuicVersionUsesCryptoFrames(version)
+                  ? std::numeric_limits<QuicStreamId>::max()
+                  : 0);
+      break;
+    case spdy::WriteSchedulerType::HTTP2:
+      priority_write_scheduler_ =
+          std::make_unique<spdy::Http2PriorityWriteScheduler<QuicStreamId>>();
+      break;
+    case spdy::WriteSchedulerType::FIFO:
+      priority_write_scheduler_ =
+          std::make_unique<spdy::FifoWriteScheduler<QuicStreamId>>();
+      break;
+    default:
+      QUIC_BUG << "Scheduler is not supported for type: "
+               << spdy::WriteSchedulerTypeToString(type);
+      return false;
+  }
+  scheduler_type_ = type;
+  return true;
+}
+
+QuicStreamId QuicWriteBlockedList::PopFront() {
+  QuicStreamId static_stream_id;
+  if (static_stream_collection_.UnblockFirstBlocked(&static_stream_id)) {
+    return static_stream_id;
+  }
+
+  const auto id_and_precedence =
+      priority_write_scheduler_->PopNextReadyStreamAndPrecedence();
+  const QuicStreamId id = std::get<0>(id_and_precedence);
+  if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
+    // No batch writing logic for non-SPDY priority write scheduler.
+    return id;
+  }
+  const spdy::SpdyPriority priority =
+      std::get<1>(id_and_precedence).spdy3_priority();
+
+  if (!priority_write_scheduler_->HasReadyStreams()) {
+    // If no streams are blocked, don't bother latching.  This stream will be
+    // the first popped for its priority anyway.
+    batch_write_stream_id_[priority] = 0;
+    last_priority_popped_ = priority;
+  } else if (batch_write_stream_id_[priority] != id) {
+    // If newly latching this batch write stream, let it write 16k.
+    batch_write_stream_id_[priority] = id;
+    bytes_left_for_batch_write_[priority] = 16000;
+    last_priority_popped_ = priority;
+  }
+
+  return id;
+}
+
+void QuicWriteBlockedList::RegisterStream(
+    QuicStreamId stream_id,
+    bool is_static_stream,
+    const spdy::SpdyStreamPrecedence& precedence) {
+  DCHECK(!priority_write_scheduler_->StreamRegistered(stream_id))
+      << "stream " << stream_id << " already registered";
+  DCHECK(PrecedenceMatchesSchedulerType(precedence));
+  if (is_static_stream) {
+    static_stream_collection_.Register(stream_id);
+    return;
+  }
+
+  priority_write_scheduler_->RegisterStream(stream_id, precedence);
+}
+
+void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id,
+                                            bool is_static) {
+  if (is_static) {
+    static_stream_collection_.Unregister(stream_id);
+    return;
+  }
+  priority_write_scheduler_->UnregisterStream(stream_id);
+}
+
+void QuicWriteBlockedList::UpdateStreamPriority(
+    QuicStreamId stream_id,
+    const spdy::SpdyStreamPrecedence& new_precedence) {
+  DCHECK(!static_stream_collection_.IsRegistered(stream_id));
+  DCHECK(PrecedenceMatchesSchedulerType(new_precedence));
+  priority_write_scheduler_->UpdateStreamPrecedence(stream_id, new_precedence);
+}
+
+void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
+                                                size_t bytes) {
+  if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
+    return;
+  }
+  if (batch_write_stream_id_[last_priority_popped_] == stream_id) {
+    // If this was the last data stream popped by PopFront, update the
+    // bytes remaining in its batch write.
+    bytes_left_for_batch_write_[last_priority_popped_] -=
+        static_cast<int32_t>(bytes);
+  }
+}
+
+void QuicWriteBlockedList::AddStream(QuicStreamId stream_id) {
+  if (static_stream_collection_.SetBlocked(stream_id)) {
+    return;
+  }
+
+  bool push_front =
+      scheduler_type_ == spdy::WriteSchedulerType::SPDY &&
+      stream_id == batch_write_stream_id_[last_priority_popped_] &&
+      bytes_left_for_batch_write_[last_priority_popped_] > 0;
+  priority_write_scheduler_->MarkStreamReady(stream_id, push_front);
+}
+
+bool QuicWriteBlockedList::IsStreamBlocked(QuicStreamId stream_id) const {
+  for (const auto& stream : static_stream_collection_) {
+    if (stream.id == stream_id) {
+      return stream.is_blocked;
+    }
+  }
+
+  return priority_write_scheduler_->IsStreamReady(stream_id);
+}
+
+bool QuicWriteBlockedList::PrecedenceMatchesSchedulerType(
+    const spdy::SpdyStreamPrecedence& precedence) {
+  switch (scheduler_type_) {
+    case spdy::WriteSchedulerType::LIFO:
+      break;
+    case spdy::WriteSchedulerType::SPDY:
+      return precedence.is_spdy3_priority();
+    case spdy::WriteSchedulerType::HTTP2:
+      return !precedence.is_spdy3_priority();
+    case spdy::WriteSchedulerType::FIFO:
+      break;
+    default:
+      DCHECK(false);
+      return false;
+  }
+  return true;
+}
+
+void QuicWriteBlockedList::StaticStreamCollection::Register(QuicStreamId id) {
+  DCHECK(!IsRegistered(id));
+  streams_.push_back({id, false});
+}
+
+bool QuicWriteBlockedList::StaticStreamCollection::IsRegistered(
+    QuicStreamId id) const {
+  for (const auto& stream : streams_) {
+    if (stream.id == id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void QuicWriteBlockedList::StaticStreamCollection::Unregister(QuicStreamId id) {
+  for (auto it = streams_.begin(); it != streams_.end(); ++it) {
+    if (it->id == id) {
+      if (it->is_blocked) {
+        --num_blocked_;
+      }
+      streams_.erase(it);
+      return;
+    }
+  }
+  DCHECK(false) << "Erasing a non-exist stream with id " << id;
+}
+
+bool QuicWriteBlockedList::StaticStreamCollection::SetBlocked(QuicStreamId id) {
+  for (auto& stream : streams_) {
+    if (stream.id == id) {
+      if (!stream.is_blocked) {
+        stream.is_blocked = true;
+        ++num_blocked_;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+bool QuicWriteBlockedList::StaticStreamCollection::UnblockFirstBlocked(
+    QuicStreamId* id) {
+  for (auto& stream : streams_) {
+    if (stream.is_blocked) {
+      --num_blocked_;
+      stream.is_blocked = false;
+      *id = stream.id;
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace quic
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index 4100df0..fd875bc 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -51,20 +51,7 @@
            priority_write_scheduler_->NumReadyStreams();
   }
 
-  bool ShouldYield(QuicStreamId id) const {
-    for (const auto& stream : static_stream_collection_) {
-      if (stream.id == id) {
-        // Static streams should never yield to data streams, or to lower
-        // priority static stream.
-        return false;
-      }
-      if (stream.is_blocked) {
-        return true;  // All data streams yield to static streams.
-      }
-    }
-
-    return priority_write_scheduler_->ShouldYield(id);
-  }
+  bool ShouldYield(QuicStreamId id) const;
 
   spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId id) const {
     return priority_write_scheduler_->GetStreamPrecedence(id).spdy3_priority();
@@ -73,168 +60,38 @@
   // Switches write scheduler. This can only be called before any stream is
   // registered.
   bool SwitchWriteScheduler(spdy::WriteSchedulerType type,
-                            QuicTransportVersion version) {
-    if (scheduler_type_ == type) {
-      return true;
-    }
-    if (priority_write_scheduler_->NumRegisteredStreams() != 0) {
-      QUIC_BUG << "Cannot switch scheduler with registered streams";
-      return false;
-    }
-    QUIC_DVLOG(1) << "Switching to scheduler type: "
-                  << spdy::WriteSchedulerTypeToString(type);
-    switch (type) {
-      case spdy::WriteSchedulerType::LIFO:
-        priority_write_scheduler_ =
-            std::make_unique<spdy::LifoWriteScheduler<QuicStreamId>>();
-        break;
-      case spdy::WriteSchedulerType::SPDY:
-        priority_write_scheduler_ =
-            std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
-                QuicVersionUsesCryptoFrames(version)
-                    ? std::numeric_limits<QuicStreamId>::max()
-                    : 0);
-        break;
-      case spdy::WriteSchedulerType::HTTP2:
-        priority_write_scheduler_ =
-            std::make_unique<spdy::Http2PriorityWriteScheduler<QuicStreamId>>();
-        break;
-      case spdy::WriteSchedulerType::FIFO:
-        priority_write_scheduler_ =
-            std::make_unique<spdy::FifoWriteScheduler<QuicStreamId>>();
-        break;
-      default:
-        QUIC_BUG << "Scheduler is not supported for type: "
-                 << spdy::WriteSchedulerTypeToString(type);
-        return false;
-    }
-    scheduler_type_ = type;
-    return true;
-  }
+                            QuicTransportVersion version);
 
   // Pops the highest priority stream, special casing crypto and headers
   // streams. Latches the most recently popped data stream for batch writing
   // purposes.
-  QuicStreamId PopFront() {
-    QuicStreamId static_stream_id;
-    if (static_stream_collection_.UnblockFirstBlocked(&static_stream_id)) {
-      return static_stream_id;
-    }
-
-    const auto id_and_precedence =
-        priority_write_scheduler_->PopNextReadyStreamAndPrecedence();
-    const QuicStreamId id = std::get<0>(id_and_precedence);
-    if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
-      // No batch writing logic for non-SPDY priority write scheduler.
-      return id;
-    }
-    const spdy::SpdyPriority priority =
-        std::get<1>(id_and_precedence).spdy3_priority();
-
-    if (!priority_write_scheduler_->HasReadyStreams()) {
-      // If no streams are blocked, don't bother latching.  This stream will be
-      // the first popped for its priority anyway.
-      batch_write_stream_id_[priority] = 0;
-      last_priority_popped_ = priority;
-    } else if (batch_write_stream_id_[priority] != id) {
-      // If newly latching this batch write stream, let it write 16k.
-      batch_write_stream_id_[priority] = id;
-      bytes_left_for_batch_write_[priority] = 16000;
-      last_priority_popped_ = priority;
-    }
-
-    return id;
-  }
+  QuicStreamId PopFront();
 
   void RegisterStream(QuicStreamId stream_id,
                       bool is_static_stream,
-                      const spdy::SpdyStreamPrecedence& precedence) {
-    DCHECK(!priority_write_scheduler_->StreamRegistered(stream_id))
-        << "stream " << stream_id << " already registered";
-    DCHECK(PrecedenceMatchesSchedulerType(precedence));
-    if (is_static_stream) {
-      static_stream_collection_.Register(stream_id);
-      return;
-    }
+                      const spdy::SpdyStreamPrecedence& precedence);
 
-    priority_write_scheduler_->RegisterStream(stream_id, precedence);
-  }
-
-  void UnregisterStream(QuicStreamId stream_id, bool is_static) {
-    if (is_static) {
-      static_stream_collection_.Unregister(stream_id);
-      return;
-    }
-    priority_write_scheduler_->UnregisterStream(stream_id);
-  }
+  void UnregisterStream(QuicStreamId stream_id, bool is_static);
 
   void UpdateStreamPriority(QuicStreamId stream_id,
-                            const spdy::SpdyStreamPrecedence& new_precedence) {
-    DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-    DCHECK(PrecedenceMatchesSchedulerType(new_precedence));
-    priority_write_scheduler_->UpdateStreamPrecedence(stream_id,
-                                                      new_precedence);
-  }
+                            const spdy::SpdyStreamPrecedence& new_precedence);
 
-  void UpdateBytesForStream(QuicStreamId stream_id, size_t bytes) {
-    if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
-      return;
-    }
-    if (batch_write_stream_id_[last_priority_popped_] == stream_id) {
-      // If this was the last data stream popped by PopFront, update the
-      // bytes remaining in its batch write.
-      bytes_left_for_batch_write_[last_priority_popped_] -=
-          static_cast<int32_t>(bytes);
-    }
-  }
+  void UpdateBytesForStream(QuicStreamId stream_id, size_t bytes);
 
   // Pushes a stream to the back of the list for its priority level *unless* it
   // is latched for doing batched writes in which case it goes to the front of
   // the list for its priority level.
   // Headers and crypto streams are special cased to always resume first.
-  void AddStream(QuicStreamId stream_id) {
-    if (static_stream_collection_.SetBlocked(stream_id)) {
-      return;
-    }
-
-    bool push_front =
-        scheduler_type_ == spdy::WriteSchedulerType::SPDY &&
-        stream_id == batch_write_stream_id_[last_priority_popped_] &&
-        bytes_left_for_batch_write_[last_priority_popped_] > 0;
-    priority_write_scheduler_->MarkStreamReady(stream_id, push_front);
-  }
+  void AddStream(QuicStreamId stream_id);
 
   // Returns true if stream with |stream_id| is write blocked.
-  bool IsStreamBlocked(QuicStreamId stream_id) const {
-    for (const auto& stream : static_stream_collection_) {
-      if (stream.id == stream_id) {
-        return stream.is_blocked;
-      }
-    }
-
-    return priority_write_scheduler_->IsStreamReady(stream_id);
-  }
+  bool IsStreamBlocked(QuicStreamId stream_id) const;
 
   spdy::WriteSchedulerType scheduler_type() const { return scheduler_type_; }
 
  private:
   bool PrecedenceMatchesSchedulerType(
-      const spdy::SpdyStreamPrecedence& precedence) {
-    switch (scheduler_type_) {
-      case spdy::WriteSchedulerType::LIFO:
-        break;
-      case spdy::WriteSchedulerType::SPDY:
-        return precedence.is_spdy3_priority();
-      case spdy::WriteSchedulerType::HTTP2:
-        return !precedence.is_spdy3_priority();
-      case spdy::WriteSchedulerType::FIFO:
-        break;
-      default:
-        DCHECK(false);
-        return false;
-    }
-    return true;
-  }
+      const spdy::SpdyStreamPrecedence& precedence);
 
   std::unique_ptr<QuicPriorityWriteScheduler> priority_write_scheduler_;
 
@@ -269,66 +126,24 @@
     size_t num_blocked() const { return num_blocked_; }
 
     // Add |id| to the collection in unblocked state.
-    void Register(QuicStreamId id) {
-      DCHECK(!IsRegistered(id));
-      streams_.push_back({id, false});
-    }
+    void Register(QuicStreamId id);
 
     // True if |id| is in the collection, regardless of its state.
-    bool IsRegistered(QuicStreamId id) const {
-      for (const auto& stream : streams_) {
-        if (stream.id == id) {
-          return true;
-        }
-      }
-      return false;
-    }
+    bool IsRegistered(QuicStreamId id) const;
 
     // Remove |id| from the collection, if it is in the blocked state, reduce
     // |num_blocked_| by 1.
-    void Unregister(QuicStreamId id) {
-      for (auto it = streams_.begin(); it != streams_.end(); ++it) {
-        if (it->id == id) {
-          if (it->is_blocked) {
-            --num_blocked_;
-          }
-          streams_.erase(it);
-          return;
-        }
-      }
-      DCHECK(false) << "Erasing a non-exist stream with id " << id;
-    }
+    void Unregister(QuicStreamId id);
 
     // Set |id| to be blocked. If |id| is not already blocked, increase
     // |num_blocked_| by 1.
     // Return true if |id| is in the collection.
-    bool SetBlocked(QuicStreamId id) {
-      for (auto& stream : streams_) {
-        if (stream.id == id) {
-          if (!stream.is_blocked) {
-            stream.is_blocked = true;
-            ++num_blocked_;
-          }
-          return true;
-        }
-      }
-      return false;
-    }
+    bool SetBlocked(QuicStreamId id);
 
     // Unblock the first blocked stream in the collection.
     // If no stream is blocked, return false. Otherwise return true, set *id to
     // the unblocked stream id and reduce |num_blocked_| by 1.
-    bool UnblockFirstBlocked(QuicStreamId* id) {
-      for (auto& stream : streams_) {
-        if (stream.is_blocked) {
-          --num_blocked_;
-          stream.is_blocked = false;
-          *id = stream.id;
-          return true;
-        }
-      }
-      return false;
-    }
+    bool UnblockFirstBlocked(QuicStreamId* id);
 
    private:
     size_t num_blocked_ = 0;