diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index 8adf0ae..5f98345 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -226,6 +226,7 @@
                                                 // has the highest priority.
 const QuicTag kLIFO = TAG('L', 'I', 'F', 'O');  // Stream with the largest ID
                                                 // has the highest priority.
+const QuicTag kRRWS = TAG('R', 'R', 'W', 'S');  // Round robin write scheduling.
 
 // Proof types (i.e. certificate types)
 // NOTE: although it would be silly to do so, specifying both kX509 and kX59R
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 9b812de..9ede3f8 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -93,7 +93,8 @@
       use_http2_priority_write_scheduler_(false),
       is_configured_(false),
       num_expected_unidirectional_static_streams_(
-          num_expected_unidirectional_static_streams) {
+          num_expected_unidirectional_static_streams),
+      enable_round_robin_scheduling_(false) {
   closed_streams_clean_up_alarm_ =
       QuicWrapUnique<QuicAlarm>(connection_->alarm_factory()->CreateAlarm(
           new ClosedStreamsCleanUpDelegate(this)));
@@ -1000,6 +1001,12 @@
                 spdy::WriteSchedulerType::LIFO, transport_version())) {
           QUIC_RELOADABLE_FLAG_COUNT(quic_enable_lifo_write_scheduler);
         }
+      } else if (GetQuicReloadableFlag(quic_enable_rr_write_scheduler) &&
+                 ContainsQuicTag(config_.ReceivedConnectionOptions(), kRRWS) &&
+                 write_blocked_streams_.scheduler_type() ==
+                     spdy::WriteSchedulerType::SPDY) {
+        QUIC_RELOADABLE_FLAG_COUNT(quic_enable_rr_write_scheduler);
+        enable_round_robin_scheduling_ = true;
       }
     }
 
@@ -1157,6 +1164,13 @@
     QuicStreamId id,
     bool is_static,
     const spdy::SpdyStreamPrecedence& precedence) {
+  if (enable_round_robin_scheduling_) {
+    // Ignore provided precedence, instead, put all streams at the same priority
+    // bucket.
+    write_blocked_streams()->RegisterStream(
+        id, is_static, spdy::SpdyStreamPrecedence(spdy::kV3LowestPriority));
+    return;
+  }
   write_blocked_streams()->RegisterStream(id, is_static, precedence);
 }
 
@@ -1167,6 +1181,10 @@
 void QuicSession::UpdateStreamPriority(
     QuicStreamId id,
     const spdy::SpdyStreamPrecedence& new_precedence) {
+  if (enable_round_robin_scheduling_) {
+    // Ignore updated precedence.
+    return;
+  }
   write_blocked_streams()->UpdateStreamPriority(id, new_precedence);
 }
 
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 5250f9b..6fb4c8d 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -756,6 +756,9 @@
 
   // The number of expected static streams.
   QuicStreamCount num_expected_unidirectional_static_streams_;
+
+  // If true, enables round robin scheduling.
+  bool enable_round_robin_scheduling_;
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index f7ab416..004af59 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1000,6 +1000,50 @@
   session_.OnCanWrite();
 }
 
+TEST_P(QuicSessionTestServer, RoundRobinScheduling) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
+    return;
+  }
+  SetQuicReloadableFlag(quic_enable_rr_write_scheduler, true);
+  QuicTagVector copt;
+  copt.push_back(kRRWS);
+  QuicConfigPeer::SetReceivedConnectionOptions(session_.config(), copt);
+  session_.OnConfigNegotiated();
+
+  session_.set_writev_consumes_all_data(true);
+  TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
+  TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
+  TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
+
+  session_.set_writev_consumes_all_data(true);
+  session_.MarkConnectionLevelWriteBlocked(stream2->id());
+  session_.MarkConnectionLevelWriteBlocked(stream4->id());
+  session_.MarkConnectionLevelWriteBlocked(stream6->id());
+
+  // Verify streams are scheduled round robin.
+  InSequence s;
+  EXPECT_CALL(*stream2, OnCanWrite());
+  EXPECT_CALL(*stream4, OnCanWrite());
+  EXPECT_CALL(*stream6, OnCanWrite());
+  session_.OnCanWrite();
+
+  /* 2, 4, 6, 8 */
+  TestStream* stream8 = session_.CreateOutgoingBidirectionalStream();
+
+  // Verify updated priority is ignored.
+  stream4->SetPriority(spdy::SpdyStreamPrecedence(spdy::kV3HighestPriority));
+  session_.MarkConnectionLevelWriteBlocked(stream8->id());
+  session_.MarkConnectionLevelWriteBlocked(stream4->id());
+  session_.MarkConnectionLevelWriteBlocked(stream2->id());
+  session_.MarkConnectionLevelWriteBlocked(stream6->id());
+
+  EXPECT_CALL(*stream8, OnCanWrite());
+  EXPECT_CALL(*stream4, OnCanWrite());
+  EXPECT_CALL(*stream2, OnCanWrite());
+  EXPECT_CALL(*stream6, OnCanWrite());
+  session_.OnCanWrite();
+}
+
 TEST_P(QuicSessionTestServer, OnCanWriteBundlesStreams) {
   // Encryption needs to be established before data can be sent.
   CryptoHandshakeMessage msg;
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index 72ebc05..f77a2cd 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -210,6 +210,8 @@
     return priority_write_scheduler_->IsStreamReady(stream_id);
   }
 
+  spdy::WriteSchedulerType scheduler_type() const { return scheduler_type_; }
+
  private:
   bool PrecedenceMatchesSchedulerType(
       const spdy::SpdyStreamPrecedence& precedence) {