diff --git a/quiche/spdy/core/array_output_buffer.cc b/quiche/spdy/core/array_output_buffer.cc
index 8cebea7..8ceba2c 100644
--- a/quiche/spdy/core/array_output_buffer.cc
+++ b/quiche/spdy/core/array_output_buffer.cc
@@ -16,8 +16,6 @@
   capacity_ -= count;
 }
 
-uint64_t ArrayOutputBuffer::BytesFree() const {
-  return capacity_;
-}
+uint64_t ArrayOutputBuffer::BytesFree() const { return capacity_; }
 
 }  // namespace spdy
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter.cc b/quiche/spdy/core/http2_frame_decoder_adapter.cc
index d5ebcab..c783a5d 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter.cc
+++ b/quiche/spdy/core/http2_frame_decoder_adapter.cc
@@ -575,8 +575,7 @@
 }
 
 void Http2DecoderAdapter::OnPushPromiseStart(
-    const Http2FrameHeader& header,
-    const Http2PushPromiseFields& promise,
+    const Http2FrameHeader& header, const Http2PushPromiseFields& promise,
     size_t total_padding_length) {
   QUICHE_DVLOG(1) << "OnPushPromiseStart: " << header
                   << "; promise: " << promise
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter.h b/quiche/spdy/core/http2_frame_decoder_adapter.h
index 1798ae0..cc71433 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter.h
+++ b/quiche/spdy/core/http2_frame_decoder_adapter.h
@@ -59,16 +59,16 @@
   // Framer error codes.
   enum SpdyFramerError {
     SPDY_NO_ERROR,
-    SPDY_INVALID_STREAM_ID,            // Stream ID is invalid
-    SPDY_INVALID_CONTROL_FRAME,        // Control frame is mal-formatted.
-    SPDY_CONTROL_PAYLOAD_TOO_LARGE,    // Control frame payload was too large.
-    SPDY_DECOMPRESS_FAILURE,           // There was an error decompressing.
-    SPDY_INVALID_PADDING,              // HEADERS or DATA frame padding invalid
-    SPDY_INVALID_DATA_FRAME_FLAGS,     // Data frame has invalid flags.
-    SPDY_UNEXPECTED_FRAME,             // Frame received out of order.
-    SPDY_INTERNAL_FRAMER_ERROR,        // SpdyFramer was used incorrectly.
-    SPDY_INVALID_CONTROL_FRAME_SIZE,   // Control frame not sized to spec
-    SPDY_OVERSIZED_PAYLOAD,            // Payload size was too large
+    SPDY_INVALID_STREAM_ID,           // Stream ID is invalid
+    SPDY_INVALID_CONTROL_FRAME,       // Control frame is mal-formatted.
+    SPDY_CONTROL_PAYLOAD_TOO_LARGE,   // Control frame payload was too large.
+    SPDY_DECOMPRESS_FAILURE,          // There was an error decompressing.
+    SPDY_INVALID_PADDING,             // HEADERS or DATA frame padding invalid
+    SPDY_INVALID_DATA_FRAME_FLAGS,    // Data frame has invalid flags.
+    SPDY_UNEXPECTED_FRAME,            // Frame received out of order.
+    SPDY_INTERNAL_FRAMER_ERROR,       // SpdyFramer was used incorrectly.
+    SPDY_INVALID_CONTROL_FRAME_SIZE,  // Control frame not sized to spec
+    SPDY_OVERSIZED_PAYLOAD,           // Payload size was too large
 
     // HttpDecoder or HttpDecoderAdapter error.
     // See HpackDecodingError for description of each error code.
@@ -201,8 +201,7 @@
   void OnGoAwayEnd() override;
   void OnWindowUpdate(const Http2FrameHeader& header,
                       uint32_t increment) override;
-  void OnAltSvcStart(const Http2FrameHeader& header,
-                     size_t origin_length,
+  void OnAltSvcStart(const Http2FrameHeader& header, size_t origin_length,
                      size_t value_length) override;
   void OnAltSvcOriginData(const char* data, size_t len) override;
   void OnAltSvcValueData(const char* data, size_t len) override;
@@ -374,24 +373,20 @@
 
   // Called when the common header for a frame is received. Validating the
   // common header occurs in later processing.
-  virtual void OnCommonHeader(SpdyStreamId /*stream_id*/,
-                              size_t /*length*/,
-                              uint8_t /*type*/,
-                              uint8_t /*flags*/) {}
+  virtual void OnCommonHeader(SpdyStreamId /*stream_id*/, size_t /*length*/,
+                              uint8_t /*type*/, uint8_t /*flags*/) {}
 
   // Called when a data frame header is received. The frame's data
   // payload will be provided via subsequent calls to
   // OnStreamFrameData().
-  virtual void OnDataFrameHeader(SpdyStreamId stream_id,
-                                 size_t length,
+  virtual void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
                                  bool fin) = 0;
 
   // Called when data is received.
   // |stream_id| The stream receiving data.
   // |data| A buffer containing the data received.
   // |len| The length of the data buffer.
-  virtual void OnStreamFrameData(SpdyStreamId stream_id,
-                                 const char* data,
+  virtual void OnStreamFrameData(SpdyStreamId stream_id, const char* data,
                                  size_t len) = 0;
 
   // Called when the other side has finished sending data on this stream.
@@ -460,13 +455,9 @@
   // |fin| Whether FIN flag is set in frame headers.
   // |end| False if HEADERs frame is to be followed by a CONTINUATION frame,
   //     or true if not.
-  virtual void OnHeaders(SpdyStreamId stream_id,
-                         bool has_priority,
-                         int weight,
-                         SpdyStreamId parent_stream_id,
-                         bool exclusive,
-                         bool fin,
-                         bool end) = 0;
+  virtual void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
+                         SpdyStreamId parent_stream_id, bool exclusive,
+                         bool fin, bool end) = 0;
 
   // Called when a WINDOW_UPDATE frame has been parsed.
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
@@ -484,8 +475,7 @@
   // Called when a PUSH_PROMISE frame is received.
   // Note that header block data is not included. See OnHeaderFrameStart().
   virtual void OnPushPromise(SpdyStreamId stream_id,
-                             SpdyStreamId promised_stream_id,
-                             bool end) = 0;
+                             SpdyStreamId promised_stream_id, bool end) = 0;
 
   // Called when a CONTINUATION frame is received.
   // Note that header block data is not included. See OnHeaderFrameStart().
@@ -493,8 +483,7 @@
 
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(
-      SpdyStreamId /*stream_id*/,
-      absl::string_view /*origin*/,
+      SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
       const SpdyAltSvcWireFormat::AlternativeServiceVector& /*altsvc_vector*/) {
   }
 
@@ -504,10 +493,8 @@
   // |weight| Stream weight, in the range [1, 256].
   // |exclusive| Whether |stream_id| should be an only child of
   //     |parent_stream_id|.
-  virtual void OnPriority(SpdyStreamId stream_id,
-                          SpdyStreamId parent_stream_id,
-                          int weight,
-                          bool exclusive) = 0;
+  virtual void OnPriority(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                          int weight, bool exclusive) = 0;
 
   // Called when a PRIORITY_UPDATE frame is received on stream 0.
   // |prioritized_stream_id| is the Prioritized Stream ID and
@@ -531,10 +518,8 @@
   virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
 
   // Called when non-standard frames are received.
-  virtual bool OnFrameHeader(SpdyStreamId stream_id,
-                             size_t length,
-                             uint8_t type,
-                             uint8_t flags) = 0;
+  virtual bool OnFrameHeader(SpdyStreamId stream_id, size_t length,
+                             uint8_t type, uint8_t flags) = 0;
 
   // The payload for a single frame may be delivered as multiple calls to
   // OnFramePayload. Since the length field is passed in OnFrameHeader, there is
diff --git a/quiche/spdy/core/metadata_extension.cc b/quiche/spdy/core/metadata_extension.cc
index 6eb10af..7ebc444 100644
--- a/quiche/spdy/core/metadata_extension.cc
+++ b/quiche/spdy/core/metadata_extension.cc
@@ -121,8 +121,8 @@
   if (it == metadata_map_.end()) {
     auto state = absl::make_unique<MetadataPayloadState>(
         length, flags & kEndMetadataFlag);
-    auto result = metadata_map_.insert(std::make_pair(stream_id,
-                                                      std::move(state)));
+    auto result =
+        metadata_map_.insert(std::make_pair(stream_id, std::move(state)));
     QUICHE_BUG_IF(bug_if_2781_1, !result.second) << "Map insertion failed.";
     it = result.first;
   } else {
diff --git a/quiche/spdy/core/mock_spdy_framer_visitor.cc b/quiche/spdy/core/mock_spdy_framer_visitor.cc
index cdc8906..332186b 100644
--- a/quiche/spdy/core/mock_spdy_framer_visitor.cc
+++ b/quiche/spdy/core/mock_spdy_framer_visitor.cc
@@ -8,9 +8,7 @@
 
 namespace test {
 
-MockSpdyFramerVisitor::MockSpdyFramerVisitor() {
-  DelegateHeaderHandling();
-}
+MockSpdyFramerVisitor::MockSpdyFramerVisitor() { DelegateHeaderHandling(); }
 
 MockSpdyFramerVisitor::~MockSpdyFramerVisitor() = default;
 
diff --git a/quiche/spdy/core/mock_spdy_framer_visitor.h b/quiche/spdy/core/mock_spdy_framer_visitor.h
index 8aa79fd..7893bda 100644
--- a/quiche/spdy/core/mock_spdy_framer_visitor.h
+++ b/quiche/spdy/core/mock_spdy_framer_visitor.h
@@ -25,8 +25,7 @@
   MockSpdyFramerVisitor();
   ~MockSpdyFramerVisitor() override;
 
-  MOCK_METHOD(void,
-              OnError,
+  MOCK_METHOD(void, OnError,
               (http2::Http2DecoderAdapter::SpdyFramerError error,
                std::string detailed_error),
               (override));
@@ -34,90 +33,59 @@
               (SpdyStreamId stream_id, size_t length, uint8_t type,
                uint8_t flags),
               (override));
-  MOCK_METHOD(void,
-              OnDataFrameHeader,
-              (SpdyStreamId stream_id, size_t length, bool fin),
-              (override));
-  MOCK_METHOD(void,
-              OnStreamFrameData,
+  MOCK_METHOD(void, OnDataFrameHeader,
+              (SpdyStreamId stream_id, size_t length, bool fin), (override));
+  MOCK_METHOD(void, OnStreamFrameData,
               (SpdyStreamId stream_id, const char* data, size_t len),
               (override));
   MOCK_METHOD(void, OnStreamEnd, (SpdyStreamId stream_id), (override));
-  MOCK_METHOD(void,
-              OnStreamPadLength,
-              (SpdyStreamId stream_id, size_t value),
+  MOCK_METHOD(void, OnStreamPadLength, (SpdyStreamId stream_id, size_t value),
               (override));
-  MOCK_METHOD(void,
-              OnStreamPadding,
-              (SpdyStreamId stream_id, size_t len),
+  MOCK_METHOD(void, OnStreamPadding, (SpdyStreamId stream_id, size_t len),
               (override));
-  MOCK_METHOD(SpdyHeadersHandlerInterface*,
-              OnHeaderFrameStart,
-              (SpdyStreamId stream_id),
-              (override));
+  MOCK_METHOD(SpdyHeadersHandlerInterface*, OnHeaderFrameStart,
+              (SpdyStreamId stream_id), (override));
   MOCK_METHOD(void, OnHeaderFrameEnd, (SpdyStreamId stream_id), (override));
-  MOCK_METHOD(void,
-              OnRstStream,
-              (SpdyStreamId stream_id, SpdyErrorCode error_code),
-              (override));
+  MOCK_METHOD(void, OnRstStream,
+              (SpdyStreamId stream_id, SpdyErrorCode error_code), (override));
   MOCK_METHOD(void, OnSettings, (), (override));
   MOCK_METHOD(void, OnSetting, (SpdySettingsId id, uint32_t value), (override));
   MOCK_METHOD(void, OnPing, (SpdyPingId unique_id, bool is_ack), (override));
   MOCK_METHOD(void, OnSettingsEnd, (), (override));
   MOCK_METHOD(void, OnSettingsAck, (), (override));
-  MOCK_METHOD(void,
-              OnGoAway,
+  MOCK_METHOD(void, OnGoAway,
               (SpdyStreamId last_accepted_stream_id, SpdyErrorCode error_code),
               (override));
   MOCK_METHOD(bool, OnGoAwayFrameData, (const char* goaway_data, size_t len),
               (override));
-  MOCK_METHOD(void,
-              OnHeaders,
-              (SpdyStreamId stream_id,
-               bool has_priority,
-               int weight,
-               SpdyStreamId parent_stream_id,
-               bool exclusive,
-               bool fin,
+  MOCK_METHOD(void, OnHeaders,
+              (SpdyStreamId stream_id, bool has_priority, int weight,
+               SpdyStreamId parent_stream_id, bool exclusive, bool fin,
                bool end),
               (override));
-  MOCK_METHOD(void,
-              OnWindowUpdate,
-              (SpdyStreamId stream_id, int delta_window_size),
-              (override));
-  MOCK_METHOD(void,
-              OnPushPromise,
-              (SpdyStreamId stream_id,
-               SpdyStreamId promised_stream_id,
+  MOCK_METHOD(void, OnWindowUpdate,
+              (SpdyStreamId stream_id, int delta_window_size), (override));
+  MOCK_METHOD(void, OnPushPromise,
+              (SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                bool end),
               (override));
-  MOCK_METHOD(void,
-              OnContinuation,
-              (SpdyStreamId stream_id, bool end),
+  MOCK_METHOD(void, OnContinuation, (SpdyStreamId stream_id, bool end),
               (override));
   MOCK_METHOD(
-      void,
-      OnAltSvc,
-      (SpdyStreamId stream_id,
-       absl::string_view origin,
+      void, OnAltSvc,
+      (SpdyStreamId stream_id, absl::string_view origin,
        const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector),
       (override));
-  MOCK_METHOD(void,
-              OnPriority,
-              (SpdyStreamId stream_id,
-               SpdyStreamId parent_stream_id,
-               int weight,
-               bool exclusive),
+  MOCK_METHOD(void, OnPriority,
+              (SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+               int weight, bool exclusive),
               (override));
-  MOCK_METHOD(void,
-              OnPriorityUpdate,
+  MOCK_METHOD(void, OnPriorityUpdate,
               (SpdyStreamId prioritized_stream_id,
                absl::string_view priority_field_value),
               (override));
-  MOCK_METHOD(bool,
-              OnUnknownFrame,
-              (SpdyStreamId stream_id, uint8_t frame_type),
-              (override));
+  MOCK_METHOD(bool, OnUnknownFrame,
+              (SpdyStreamId stream_id, uint8_t frame_type), (override));
 
   void DelegateHeaderHandling() {
     ON_CALL(*this, OnHeaderFrameStart(testing::_))
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format.cc b/quiche/spdy/core/spdy_alt_svc_wire_format.cc
index 08c301e..6a68ebb 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format.cc
+++ b/quiche/spdy/core/spdy_alt_svc_wire_format.cc
@@ -9,7 +9,6 @@
 #include <limits>
 
 #include "absl/strings/str_cat.h"
-
 #include "quiche/common/platform/api/quiche_logging.h"
 
 namespace spdy {
@@ -18,8 +17,7 @@
 
 template <class T>
 bool ParsePositiveIntegerImpl(absl::string_view::const_iterator c,
-                              absl::string_view::const_iterator end,
-                              T* value) {
+                              absl::string_view::const_iterator end, T* value) {
   *value = 0;
   for (; c != end && std::isdigit(*c); ++c) {
     if (*value > std::numeric_limits<T>::max() / 10) {
@@ -54,8 +52,7 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseHeaderFieldValue(
-    absl::string_view value,
-    AlternativeServiceVector* altsvc_vector) {
+    absl::string_view value, AlternativeServiceVector* altsvc_vector) {
   // Empty value is invalid according to the specification.
   if (value.empty()) {
     return false;
@@ -326,10 +323,8 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseAltAuthority(
-    absl::string_view::const_iterator c,
-    absl::string_view::const_iterator end,
-    std::string* host,
-    uint16_t* port) {
+    absl::string_view::const_iterator c, absl::string_view::const_iterator end,
+    std::string* host, uint16_t* port) {
   host->clear();
   if (c == end) {
     return false;
@@ -373,16 +368,14 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger16(
-    absl::string_view::const_iterator c,
-    absl::string_view::const_iterator end,
+    absl::string_view::const_iterator c, absl::string_view::const_iterator end,
     uint16_t* value) {
   return ParsePositiveIntegerImpl<uint16_t>(c, end, value);
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger32(
-    absl::string_view::const_iterator c,
-    absl::string_view::const_iterator end,
+    absl::string_view::const_iterator c, absl::string_view::const_iterator end,
     uint32_t* value) {
   return ParsePositiveIntegerImpl<uint32_t>(c, end, value);
 }
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format.h b/quiche/spdy/core/spdy_alt_svc_wire_format.h
index b81a979..66e54c7 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format.h
+++ b/quiche/spdy/core/spdy_alt_svc_wire_format.h
@@ -76,8 +76,7 @@
   // |*port|.  Return true on success, false if input is invalid.
   static bool ParseAltAuthority(absl::string_view::const_iterator c,
                                 absl::string_view::const_iterator end,
-                                std::string* host,
-                                uint16_t* port);
+                                std::string* host, uint16_t* port);
   // Parse a positive integer between |c| and |end| into |*value|.
   // Return true on success, false if input is not a positive integer or it
   // cannot be represented on uint16_t.
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc b/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc
index e9cbc67..68f988d 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc
+++ b/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc
@@ -24,8 +24,7 @@
   }
   static bool ParseAltAuthority(absl::string_view::const_iterator c,
                                 absl::string_view::const_iterator end,
-                                std::string* host,
-                                uint16_t* port) {
+                                std::string* host, uint16_t* port) {
     return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port);
   }
   static bool ParsePositiveInteger16(absl::string_view::const_iterator c,
@@ -53,8 +52,7 @@
 // Generate header field values, possibly with multiply defined parameters and
 // random case, and corresponding AlternativeService entries.
 void FuzzHeaderFieldValue(
-    int i,
-    std::string* header_field_value,
+    int i, std::string* header_field_value,
     SpdyAltSvcWireFormat::AlternativeService* expected_altsvc) {
   if (!header_field_value->empty()) {
     header_field_value->push_back(',');
diff --git a/quiche/spdy/core/spdy_frame_builder.cc b/quiche/spdy/core/spdy_frame_builder.cc
index a9a8923..c0558ac 100644
--- a/quiche/spdy/core/spdy_frame_builder.cc
+++ b/quiche/spdy/core/spdy_frame_builder.cc
@@ -61,8 +61,7 @@
   return true;
 }
 
-bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type,
-                                     uint8_t flags,
+bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type, uint8_t flags,
                                      SpdyStreamId stream_id) {
   uint8_t raw_frame_type = SerializeFrameType(type);
   QUICHE_DCHECK(IsDefinedFrameType(raw_frame_type));
@@ -84,10 +83,8 @@
   return success;
 }
 
-bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type,
-                                     uint8_t flags,
-                                     SpdyStreamId stream_id,
-                                     size_t length) {
+bool SpdyFrameBuilder::BeginNewFrame(SpdyFrameType type, uint8_t flags,
+                                     SpdyStreamId stream_id, size_t length) {
   uint8_t raw_frame_type = SerializeFrameType(type);
   QUICHE_DCHECK(IsDefinedFrameType(raw_frame_type));
   QUICHE_DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
diff --git a/quiche/spdy/core/spdy_frame_builder.h b/quiche/spdy/core/spdy_frame_builder.h
index 129a784..8fec09b 100644
--- a/quiche/spdy/core/spdy_frame_builder.h
+++ b/quiche/spdy/core/spdy_frame_builder.h
@@ -52,17 +52,13 @@
 
   // Populates this frame with a HTTP2 frame prefix with type and length
   // information.  |type| must be a defined frame type.
-  bool BeginNewFrame(SpdyFrameType type,
-                     uint8_t flags,
-                     SpdyStreamId stream_id,
+  bool BeginNewFrame(SpdyFrameType type, uint8_t flags, SpdyStreamId stream_id,
                      size_t length);
 
   // Populates this frame with a HTTP2 frame prefix with type and length
   // information.  |raw_frame_type| may be a defined or undefined frame type.
-  bool BeginNewUncheckedFrame(uint8_t raw_frame_type,
-                              uint8_t flags,
-                              SpdyStreamId stream_id,
-                              size_t length);
+  bool BeginNewUncheckedFrame(uint8_t raw_frame_type, uint8_t flags,
+                              SpdyStreamId stream_id, size_t length);
 
   // Takes the buffer from the SpdyFrameBuilder.
   SpdySerializedFrame take() {
@@ -111,10 +107,8 @@
 
   // Populates this frame with a HTTP2 frame prefix with type and length
   // information.
-  bool BeginNewFrameInternal(uint8_t raw_frame_type,
-                             uint8_t flags,
-                             SpdyStreamId stream_id,
-                             size_t length);
+  bool BeginNewFrameInternal(uint8_t raw_frame_type, uint8_t flags,
+                             SpdyStreamId stream_id, size_t length);
 
   // Returns a writeable buffer of given size in bytes, to be appended to the
   // currently written frame. Does bounds checking on length but does not
diff --git a/quiche/spdy/core/spdy_frame_builder_test.cc b/quiche/spdy/core/spdy_frame_builder_test.cc
index 66656e3..b981a58 100644
--- a/quiche/spdy/core/spdy_frame_builder_test.cc
+++ b/quiche/spdy/core/spdy_frame_builder_test.cc
@@ -23,8 +23,7 @@
   }
 
   static char* GetWritableOutput(SpdyFrameBuilder* builder,
-                                 size_t desired_length,
-                                 size_t* actual_length) {
+                                 size_t desired_length, size_t* actual_length) {
     return builder->GetWritableOutput(desired_length, actual_length);
   }
 };
diff --git a/quiche/spdy/core/spdy_framer.cc b/quiche/spdy/core/spdy_framer.cc
index f568a05..a127c1b 100644
--- a/quiche/spdy/core/spdy_framer.cc
+++ b/quiche/spdy/core/spdy_framer.cc
@@ -165,8 +165,7 @@
 
 bool WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                   const std::string& hpack_encoding,
-                                  SpdyStreamId stream_id,
-                                  SpdyFrameType type,
+                                  SpdyStreamId stream_id, SpdyFrameType type,
                                   int padding_payload_len) {
   uint8_t end_flag = 0;
   uint8_t flags = 0;
@@ -213,8 +212,7 @@
   return ret;
 }
 
-void SerializeDataBuilderHelper(const SpdyDataIR& data_ir,
-                                uint8_t* flags,
+void SerializeDataBuilderHelper(const SpdyDataIR& data_ir, uint8_t* flags,
                                 int* num_padding_fields,
                                 size_t* size_with_padding) {
   if (data_ir.fin()) {
@@ -231,9 +229,7 @@
 }
 
 void SerializeDataFrameHeaderWithPaddingLengthFieldBuilderHelper(
-    const SpdyDataIR& data_ir,
-    uint8_t* flags,
-    size_t* frame_size,
+    const SpdyDataIR& data_ir, uint8_t* flags, size_t* frame_size,
     size_t* num_padding_fields) {
   *flags = DATA_FLAG_NONE;
   if (data_ir.fin()) {
@@ -249,8 +245,7 @@
 }
 
 void SerializeSettingsBuilderHelper(const SpdySettingsIR& settings,
-                                    uint8_t* flags,
-                                    const SettingsMap* values,
+                                    uint8_t* flags, const SettingsMap* values,
                                     size_t* size) {
   if (settings.is_ack()) {
     *flags = *flags | SETTINGS_FLAG_ACK;
@@ -260,8 +255,7 @@
 }
 
 void SerializeAltSvcBuilderHelper(const SpdyAltSvcIR& altsvc_ir,
-                                  std::string* value,
-                                  size_t* size) {
+                                  std::string* value, size_t* size) {
   *size = kGetAltSvcFrameMinimumSize;
   *size = *size + altsvc_ir.origin().length();
   *value = SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
@@ -334,8 +328,7 @@
 }
 
 SpdyFramer::SpdyHeaderFrameIterator::SpdyHeaderFrameIterator(
-    SpdyFramer* framer,
-    std::unique_ptr<const SpdyHeadersIR> headers_ir)
+    SpdyFramer* framer, std::unique_ptr<const SpdyHeadersIR> headers_ir)
     : SpdyFrameIterator(framer), headers_ir_(std::move(headers_ir)) {
   SetEncoder(headers_ir_.get());
 }
@@ -351,8 +344,7 @@
 }
 
 bool SpdyFramer::SpdyHeaderFrameIterator::SerializeGivenEncoding(
-    const std::string& encoding,
-    ZeroCopyOutputBuffer* output) const {
+    const std::string& encoding, ZeroCopyOutputBuffer* output) const {
   return SerializeHeadersGivenEncoding(*headers_ir_, encoding,
                                        !has_next_frame(), output);
 }
@@ -376,15 +368,13 @@
 }
 
 bool SpdyFramer::SpdyPushPromiseFrameIterator::SerializeGivenEncoding(
-    const std::string& encoding,
-    ZeroCopyOutputBuffer* output) const {
+    const std::string& encoding, ZeroCopyOutputBuffer* output) const {
   return SerializePushPromiseGivenEncoding(*push_promise_ir_, encoding,
                                            !has_next_frame(), output);
 }
 
 SpdyFramer::SpdyControlFrameIterator::SpdyControlFrameIterator(
-    SpdyFramer* framer,
-    std::unique_ptr<const SpdyFrameIR> frame_ir)
+    SpdyFramer* framer, std::unique_ptr<const SpdyFrameIR> frame_ir)
     : framer_(framer), frame_ir_(std::move(frame_ir)) {}
 
 SpdyFramer::SpdyControlFrameIterator::~SpdyControlFrameIterator() = default;
@@ -405,8 +395,7 @@
 }
 
 std::unique_ptr<SpdyFrameSequence> SpdyFramer::CreateIterator(
-    SpdyFramer* framer,
-    std::unique_ptr<const SpdyFrameIR> frame_ir) {
+    SpdyFramer* framer, std::unique_ptr<const SpdyFrameIR> frame_ir) {
   switch (frame_ir->frame_type()) {
     case SpdyFrameType::HEADERS: {
       return std::make_unique<SpdyHeaderFrameIterator>(
@@ -547,8 +536,7 @@
 }
 
 void SpdyFramer::SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
-                                               uint8_t* flags,
-                                               size_t* size,
+                                               uint8_t* flags, size_t* size,
                                                std::string* hpack_encoding,
                                                int* weight,
                                                size_t* length_field) {
@@ -654,10 +642,8 @@
 }
 
 void SpdyFramer::SerializePushPromiseBuilderHelper(
-    const SpdyPushPromiseIR& push_promise,
-    uint8_t* flags,
-    std::string* hpack_encoding,
-    size_t* size) {
+    const SpdyPushPromiseIR& push_promise, uint8_t* flags,
+    std::string* hpack_encoding, size_t* size) {
   *flags = 0;
   // This will get overwritten if we overflow into a CONTINUATION frame.
   *flags = *flags | PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
@@ -998,8 +984,7 @@
 }
 
 bool SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
-    const SpdyDataIR& data_ir,
-    ZeroCopyOutputBuffer* output) const {
+    const SpdyDataIR& data_ir, ZeroCopyOutputBuffer* output) const {
   uint8_t flags = DATA_FLAG_NONE;
   size_t frame_size = 0;
   size_t num_padding_fields = 0;
diff --git a/quiche/spdy/core/spdy_framer.h b/quiche/spdy/core/spdy_framer.h
index dcf2e1d..8af13f5 100644
--- a/quiche/spdy/core/spdy_framer.h
+++ b/quiche/spdy/core/spdy_framer.h
@@ -56,8 +56,7 @@
 
   // Create a SpdyFrameSequence to serialize |frame_ir|.
   static std::unique_ptr<SpdyFrameSequence> CreateIterator(
-      SpdyFramer* framer,
-      std::unique_ptr<const SpdyFrameIR> frame_ir);
+      SpdyFramer* framer, std::unique_ptr<const SpdyFrameIR> frame_ir);
 
   // Gets the serialized flags for the given |frame|.
   static uint8_t GetSerializedFlags(const SpdyFrameIR& frame);
@@ -146,8 +145,7 @@
   // Serializes the data frame header and optionally padding length fields,
   // excluding actual data payload and padding.
   bool SerializeDataFrameHeaderWithPaddingLengthField(
-      const SpdyDataIR& data,
-      ZeroCopyOutputBuffer* output) const;
+      const SpdyDataIR& data, ZeroCopyOutputBuffer* output) const;
 
   bool SerializeRstStream(const SpdyRstStreamIR& rst_stream,
                           ZeroCopyOutputBuffer* output) const;
@@ -360,10 +358,8 @@
 
  private:
   void SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
-                                     uint8_t* flags,
-                                     size_t* size,
-                                     std::string* hpack_encoding,
-                                     int* weight,
+                                     uint8_t* flags, size_t* size,
+                                     std::string* hpack_encoding, int* weight,
                                      size_t* length_field);
   void SerializePushPromiseBuilderHelper(const SpdyPushPromiseIR& push_promise,
                                          uint8_t* flags,
diff --git a/quiche/spdy/core/spdy_framer_test.cc b/quiche/spdy/core/spdy_framer_test.cc
index a99a08d..0f599fc 100644
--- a/quiche/spdy/core/spdy_framer_test.cc
+++ b/quiche/spdy/core/spdy_framer_test.cc
@@ -46,14 +46,11 @@
 class MockDebugVisitor : public SpdyFramerDebugVisitorInterface {
  public:
   MOCK_METHOD4(OnSendCompressedFrame,
-               void(SpdyStreamId stream_id,
-                    SpdyFrameType type,
-                    size_t payload_len,
-                    size_t frame_len));
+               void(SpdyStreamId stream_id, SpdyFrameType type,
+                    size_t payload_len, size_t frame_len));
 
   MOCK_METHOD3(OnReceiveCompressedFrame,
-               void(SpdyStreamId stream_id,
-                    SpdyFrameType type,
+               void(SpdyStreamId stream_id, SpdyFrameType type,
                     size_t frame_len));
 };
 
@@ -165,8 +162,7 @@
   }
 
   static SpdySerializedFrame SerializePushPromise(
-      SpdyFramer* framer,
-      const SpdyPushPromiseIR& push_promise) {
+      SpdyFramer* framer, const SpdyPushPromiseIR& push_promise) {
     SpdySerializedFrame serialized_headers_old_version =
         framer->SerializePushPromise(push_promise);
     framer->hpack_encoder_.reset(nullptr);
@@ -192,8 +188,7 @@
   }
 
   static SpdySerializedFrame SerializePushPromise(
-      SpdyFramer* framer,
-      const SpdyPushPromiseIR& push_promise,
+      SpdyFramer* framer, const SpdyPushPromiseIR& push_promise,
       ArrayOutputBuffer* output) {
     if (output == nullptr) {
       return SerializePushPromise(framer, push_promise);
@@ -272,8 +267,7 @@
     ++error_count_;
   }
 
-  void OnDataFrameHeader(SpdyStreamId stream_id,
-                         size_t length,
+  void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
                          bool fin) override {
     QUICHE_VLOG(1) << "OnDataFrameHeader(" << stream_id << ", " << length
                    << ", " << fin << ")";
@@ -281,8 +275,7 @@
     header_stream_id_ = stream_id;
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
+  void OnStreamFrameData(SpdyStreamId stream_id, const char* data,
                          size_t len) override {
     QUICHE_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len
                    << ", "
@@ -360,12 +353,8 @@
     ++goaway_count_;
   }
 
-  void OnHeaders(SpdyStreamId stream_id,
-                 bool has_priority,
-                 int weight,
-                 SpdyStreamId parent_stream_id,
-                 bool exclusive,
-                 bool fin,
+  void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
+                 SpdyStreamId parent_stream_id, bool exclusive, bool fin,
                  bool end) override {
     QUICHE_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", "
                    << weight << ", " << parent_stream_id << ", " << exclusive
@@ -387,8 +376,7 @@
     last_window_update_delta_ = delta_window_size;
   }
 
-  void OnPushPromise(SpdyStreamId stream_id,
-                     SpdyStreamId promised_stream_id,
+  void OnPushPromise(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                      bool end) override {
     QUICHE_VLOG(1) << "OnPushPromise(" << stream_id << ", "
                    << promised_stream_id << ", " << end << ")";
@@ -403,8 +391,7 @@
     ++continuation_count_;
   }
 
-  void OnAltSvc(SpdyStreamId stream_id,
-                absl::string_view origin,
+  void OnAltSvc(SpdyStreamId stream_id, absl::string_view origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override {
     QUICHE_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
@@ -419,10 +406,8 @@
     ++altsvc_count_;
   }
 
-  void OnPriority(SpdyStreamId stream_id,
-                  SpdyStreamId parent_stream_id,
-                  int weight,
-                  bool exclusive) override {
+  void OnPriority(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                  int weight, bool exclusive) override {
     QUICHE_VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id
                    << ", " << weight << ", " << (exclusive ? 1 : 0) << ")";
     ++priority_count_;
@@ -440,18 +425,15 @@
     return on_unknown_frame_result_;
   }
 
-  void OnSendCompressedFrame(SpdyStreamId stream_id,
-                             SpdyFrameType type,
-                             size_t payload_len,
-                             size_t frame_len) override {
+  void OnSendCompressedFrame(SpdyStreamId stream_id, SpdyFrameType type,
+                             size_t payload_len, size_t frame_len) override {
     QUICHE_VLOG(1) << "OnSendCompressedFrame(" << stream_id << ", " << type
                    << ", " << payload_len << ", " << frame_len << ")";
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
-  void OnReceiveCompressedFrame(SpdyStreamId stream_id,
-                                SpdyFrameType type,
+  void OnReceiveCompressedFrame(SpdyStreamId stream_id, SpdyFrameType type,
                                 size_t frame_len) override {
     QUICHE_VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type
                    << ", " << frame_len << ")";
@@ -554,9 +536,7 @@
   }
 
   // Called when non-standard frames are received.
-  bool OnFrameHeader(SpdyStreamId stream_id,
-                     size_t length,
-                     uint8_t type,
+  bool OnFrameHeader(SpdyStreamId stream_id, size_t length, uint8_t type,
                      uint8_t flags) override {
     stream_id_ = stream_id;
     length_ = length;
@@ -611,8 +591,7 @@
 
   void CompareFrame(const std::string& description,
                     const SpdySerializedFrame& actual_frame,
-                    const unsigned char* expected,
-                    const int expected_len) {
+                    const unsigned char* expected, const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     CompareCharArraysWithHexError(description, actual, actual_frame.size(),
@@ -625,8 +604,7 @@
   std::unique_ptr<Http2DecoderAdapter> deframer_;
 };
 
-INSTANTIATE_TEST_SUITE_P(SpdyFramerTests,
-                         SpdyFramerTest,
+INSTANTIATE_TEST_SUITE_P(SpdyFramerTests, SpdyFramerTest,
                          ::testing::Values(USE, NOT_USE));
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
@@ -4997,8 +4975,7 @@
 }
 
 namespace {
-void CheckFrameAndIRSize(SpdyFrameIR* ir,
-                         SpdyFramer* framer,
+void CheckFrameAndIRSize(SpdyFrameIR* ir, SpdyFramer* framer,
                          ArrayOutputBuffer* output_buffer) {
   output_buffer->Reset();
   SpdyFrameType type = ir->frame_type();
diff --git a/quiche/spdy/core/spdy_header_block.cc b/quiche/spdy/core/spdy_header_block.cc
index 3a59c33..fe11260 100644
--- a/quiche/spdy/core/spdy_header_block.cc
+++ b/quiche/spdy/core/spdy_header_block.cc
@@ -98,10 +98,8 @@
 Http2HeaderBlock::iterator::~iterator() = default;
 
 Http2HeaderBlock::ValueProxy::ValueProxy(
-    Http2HeaderBlock* block,
-    Http2HeaderBlock::MapType::iterator lookup_result,
-    const absl::string_view key,
-    size_t* spdy_header_block_value_size)
+    Http2HeaderBlock* block, Http2HeaderBlock::MapType::iterator lookup_result,
+    const absl::string_view key, size_t* spdy_header_block_value_size)
     : block_(block),
       lookup_result_(lookup_result),
       key_(key),
diff --git a/quiche/spdy/core/spdy_header_block.h b/quiche/spdy/core/spdy_header_block.h
index 795d350..21bde19 100644
--- a/quiche/spdy/core/spdy_header_block.h
+++ b/quiche/spdy/core/spdy_header_block.h
@@ -52,8 +52,7 @@
   // key-dependent separator.
   class QUICHE_EXPORT_PRIVATE HeaderValue {
    public:
-    HeaderValue(SpdyHeaderStorage* storage,
-                absl::string_view key,
+    HeaderValue(SpdyHeaderStorage* storage, absl::string_view key,
                 absl::string_view initial_value);
 
     // Moves are allowed.
@@ -257,7 +256,7 @@
       outer_iterator.forbid_dereference();
     }
     return outer_iterator;
-#else  // SPDY_HEADER_DEBUG
+#else   // SPDY_HEADER_DEBUG
     return iterator(inner_iterator);
 #endif  // SPDY_HEADER_DEBUG
   }
@@ -270,7 +269,7 @@
       outer_iterator.forbid_dereference();
     }
     return outer_iterator;
-#else  // SPDY_HEADER_DEBUG
+#else   // SPDY_HEADER_DEBUG
     return iterator(inner_iterator);
 #endif  // SPDY_HEADER_DEBUG
   }
diff --git a/quiche/spdy/core/spdy_header_storage.cc b/quiche/spdy/core/spdy_header_storage.cc
index 8fab19d..29eefb2 100644
--- a/quiche/spdy/core/spdy_header_storage.cc
+++ b/quiche/spdy/core/spdy_header_storage.cc
@@ -38,8 +38,7 @@
   return absl::string_view(dst, total_size);
 }
 
-size_t Join(char* dst,
-            const std::vector<absl::string_view>& fragments,
+size_t Join(char* dst, const std::vector<absl::string_view>& fragments,
             absl::string_view separator) {
   if (fragments.empty()) {
     return 0;
diff --git a/quiche/spdy/core/spdy_header_storage.h b/quiche/spdy/core/spdy_header_storage.h
index 42b1b9f..8f28de9 100644
--- a/quiche/spdy/core/spdy_header_storage.h
+++ b/quiche/spdy/core/spdy_header_storage.h
@@ -50,8 +50,7 @@
 // Writes |fragments| to |dst|, joined by |separator|. |dst| must be large
 // enough to hold the result. Returns the number of bytes written.
 QUICHE_EXPORT_PRIVATE size_t
-Join(char* dst,
-     const std::vector<absl::string_view>& fragments,
+Join(char* dst, const std::vector<absl::string_view>& fragments,
      absl::string_view separator);
 
 }  // namespace spdy
diff --git a/quiche/spdy/core/spdy_intrusive_list.h b/quiche/spdy/core/spdy_intrusive_list.h
index 405ab28..4fb4967 100644
--- a/quiche/spdy/core/spdy_intrusive_list.h
+++ b/quiche/spdy/core/spdy_intrusive_list.h
@@ -93,7 +93,8 @@
 
 namespace spdy {
 
-template <typename T, typename ListID> class SpdyIntrusiveList;
+template <typename T, typename ListID>
+class SpdyIntrusiveList;
 
 template <typename T, typename ListID = void>
 class QUICHE_EXPORT_PRIVATE SpdyIntrusiveLink {
@@ -122,14 +123,15 @@
 
 template <typename T, typename ListID = void>
 class QUICHE_EXPORT_PRIVATE SpdyIntrusiveList {
-  template <typename QualifiedT, typename QualifiedLinkT> class iterator_impl;
+  template <typename QualifiedT, typename QualifiedLinkT>
+  class iterator_impl;
 
  public:
   typedef T value_type;
-  typedef value_type *pointer;
-  typedef const value_type *const_pointer;
-  typedef value_type &reference;
-  typedef const value_type &const_reference;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
 
@@ -185,7 +187,7 @@
   reference back() { return *(--end()); }
   const_reference back() const { return *(--end()); }
 
-  static iterator insert(iterator position, T *obj) {
+  static iterator insert(iterator position, T* obj) {
     return insert_link(position.link(), obj);
   }
   void push_front(T* obj) { insert(begin(), obj); }
@@ -294,16 +296,22 @@
       return link_->cast_to_derived();
     }
 
-    QualifiedLinkT *link() const { return link_; }
+    QualifiedLinkT* link() const { return link_; }
 
 #ifndef SWIG  // SWIG can't wrap these operator overloads.
-    iterator_impl& operator++() { link_ = link_->next_; return *this; }
+    iterator_impl& operator++() {
+      link_ = link_->next_;
+      return *this;
+    }
     iterator_impl operator++(int /*unused*/) {
       iterator_impl tmp = *this;
       ++*this;
       return tmp;
     }
-    iterator_impl& operator--() { link_ = link_->prev_; return *this; }
+    iterator_impl& operator--() {
+      link_ = link_->prev_;
+      return *this;
+    }
     iterator_impl operator--(int /*unused*/) {
       iterator_impl tmp = *this;
       --*this;
@@ -313,7 +321,8 @@
 
    private:
     // Ensure iterators can access other iterators node directly.
-    template <typename U, typename V> friend class iterator_impl;
+    template <typename U, typename V>
+    friend class iterator_impl;
 
     QualifiedLinkT* link_ = nullptr;
   };
diff --git a/quiche/spdy/core/spdy_intrusive_list_test.cc b/quiche/spdy/core/spdy_intrusive_list_test.cc
index f52313f..507c707 100644
--- a/quiche/spdy/core/spdy_intrusive_list_test.cc
+++ b/quiche/spdy/core/spdy_intrusive_list_test.cc
@@ -22,7 +22,7 @@
   int n;
 };
 typedef SpdyIntrusiveList<TestItem> TestList;
-typedef std::list<TestItem*> CanonicalList;
+typedef std::list<TestItem *> CanonicalList;
 
 void swap(TestItem &a, TestItem &b) {
   using std::swap;
@@ -33,8 +33,7 @@
  protected:
   void CheckLists() {
     CheckLists(l1, ll1);
-    if (QuicheTest::HasFailure())
-      return;
+    if (QuicheTest::HasFailure()) return;
     CheckLists(l2, ll2);
   }
 
@@ -73,7 +72,7 @@
 TEST(NewIntrusiveListTest, Basic) {
   TestList list1;
 
-  EXPECT_EQ(sizeof(SpdyIntrusiveLink<TestItem>), sizeof(void*) * 2);
+  EXPECT_EQ(sizeof(SpdyIntrusiveLink<TestItem>), sizeof(void *) * 2);
 
   for (int i = 0; i < 10; ++i) {
     TestItem *e = new TestItem;
@@ -87,21 +86,17 @@
   EXPECT_EQ(list1.size(), 10u);
 
   // Check both const and non-const forward iteration.
-  const TestList& clist1 = list1;
+  const TestList &clist1 = list1;
   int i = 0;
   TestList::iterator iter = list1.begin();
-  for (;
-       iter != list1.end();
-       ++iter, ++i) {
+  for (; iter != list1.end(); ++iter, ++i) {
     EXPECT_EQ(iter->n, i);
   }
   EXPECT_EQ(iter, clist1.end());
   EXPECT_NE(iter, clist1.begin());
   i = 0;
   iter = list1.begin();
-  for (;
-       iter != list1.end();
-       ++iter, ++i) {
+  for (; iter != list1.end(); ++iter, ++i) {
     EXPECT_EQ(iter->n, i);
   }
   EXPECT_EQ(iter, clist1.end());
@@ -117,12 +112,10 @@
   EXPECT_EQ(list2.size(), 10u);
 
   // Check both const and non-const reverse iteration.
-  const TestList& clist2 = list2;
+  const TestList &clist2 = list2;
   TestList::reverse_iterator riter = list2.rbegin();
   i = 9;
-  for (;
-       riter != list2.rend();
-       ++riter, --i) {
+  for (; riter != list2.rend(); ++riter, --i) {
     EXPECT_EQ(riter->n, i);
   }
   EXPECT_EQ(riter, clist2.rend());
@@ -130,9 +123,7 @@
 
   riter = list2.rbegin();
   i = 9;
-  for (;
-       riter != list2.rend();
-       ++riter, --i) {
+  for (; riter != list2.rend(); ++riter, --i) {
     EXPECT_EQ(riter->n, i);
   }
   EXPECT_EQ(riter, clist2.rend());
@@ -242,7 +233,7 @@
   // We verify that the contents of this secondary list aren't affected by any
   // of the splices.
   SpdyIntrusiveList<TestItem, ListId2> secondary_list;
-  for (int i  = 0; i < 3; ++i) {
+  for (int i = 0; i < 3; ++i) {
     secondary_list.push_back(&e[i]);
   }
 
@@ -324,14 +315,16 @@
 
 // Test for multiple layers between the element type and the link.
 namespace templated_base_link {
-template <typename T> struct AbstractBase : public SpdyIntrusiveLink<T> {
+template <typename T>
+struct AbstractBase : public SpdyIntrusiveLink<T> {
   virtual ~AbstractBase() = 0;
 };
-template <typename T> AbstractBase<T>::~AbstractBase() {}
+template <typename T>
+AbstractBase<T>::~AbstractBase() {}
 struct DerivedClass : public AbstractBase<DerivedClass> {
   int n;
 };
-}
+}  // namespace templated_base_link
 
 TEST(NewIntrusiveListTest, HandleInheritanceHierarchies) {
   {
@@ -389,7 +382,7 @@
     list.push_back(&d4);
     EXPECT_EQ(4u, list.size());
     SpdyIntrusiveList<AbstractBase, BaseLinkId>::iterator it = list.begin();
-    EXPECT_EQ("DerivedClass",           (it++)->name());
+    EXPECT_EQ("DerivedClass", (it++)->name());
     EXPECT_EQ("VirtuallyDerivedClassA", (it++)->name());
     EXPECT_EQ("VirtuallyDerivedClassB", (it++)->name());
     EXPECT_EQ("VirtuallyDerivedClassC", (it++)->name());
diff --git a/quiche/spdy/core/spdy_no_op_visitor.h b/quiche/spdy/core/spdy_no_op_visitor.h
index 65ab142..b0fa009 100644
--- a/quiche/spdy/core/spdy_no_op_visitor.h
+++ b/quiche/spdy/core/spdy_no_op_visitor.h
@@ -32,11 +32,9 @@
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override;
   void OnHeaderFrameEnd(SpdyStreamId /*stream_id*/) override {}
-  void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
-                         size_t /*length*/,
+  void OnDataFrameHeader(SpdyStreamId /*stream_id*/, size_t /*length*/,
                          bool /*fin*/) override {}
-  void OnStreamFrameData(SpdyStreamId /*stream_id*/,
-                         const char* /*data*/,
+  void OnStreamFrameData(SpdyStreamId /*stream_id*/, const char* /*data*/,
                          size_t /*len*/) override {}
   void OnStreamEnd(SpdyStreamId /*stream_id*/) override {}
   void OnStreamPadding(SpdyStreamId /*stream_id*/, size_t /*len*/) override {}
@@ -48,35 +46,27 @@
   void OnSettingsAck() override {}
   void OnGoAway(SpdyStreamId /*last_accepted_stream_id*/,
                 SpdyErrorCode /*error_code*/) override {}
-  void OnHeaders(SpdyStreamId /*stream_id*/,
-                 bool /*has_priority*/,
-                 int /*weight*/,
-                 SpdyStreamId /*parent_stream_id*/,
-                 bool /*exclusive*/,
-                 bool /*fin*/,
-                 bool /*end*/) override {}
+  void OnHeaders(SpdyStreamId /*stream_id*/, bool /*has_priority*/,
+                 int /*weight*/, SpdyStreamId /*parent_stream_id*/,
+                 bool /*exclusive*/, bool /*fin*/, bool /*end*/) override {}
   void OnWindowUpdate(SpdyStreamId /*stream_id*/,
                       int /*delta_window_size*/) override {}
   void OnPushPromise(SpdyStreamId /*stream_id*/,
                      SpdyStreamId /*promised_stream_id*/,
                      bool /*end*/) override {}
   void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
-  void OnAltSvc(SpdyStreamId /*stream_id*/,
-                absl::string_view /*origin*/,
+  void OnAltSvc(SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                 /*altsvc_vector*/) override {}
-  void OnPriority(SpdyStreamId /*stream_id*/,
-                  SpdyStreamId /*parent_stream_id*/,
-                  int /*weight*/,
-                  bool /*exclusive*/) override {}
+  void OnPriority(SpdyStreamId /*stream_id*/, SpdyStreamId /*parent_stream_id*/,
+                  int /*weight*/, bool /*exclusive*/) override {}
   void OnPriorityUpdate(SpdyStreamId /*prioritized_stream_id*/,
                         absl::string_view /*priority_field_value*/) override {}
   bool OnUnknownFrame(SpdyStreamId /*stream_id*/,
                       uint8_t /*frame_type*/) override;
 
   // SpdyFramerDebugVisitorInterface methods:
-  void OnSendCompressedFrame(SpdyStreamId /*stream_id*/,
-                             SpdyFrameType /*type*/,
+  void OnSendCompressedFrame(SpdyStreamId /*stream_id*/, SpdyFrameType /*type*/,
                              size_t /*payload_len*/,
                              size_t /*frame_len*/) override {}
   void OnReceiveCompressedFrame(SpdyStreamId /*stream_id*/,
diff --git a/quiche/spdy/core/spdy_prefixed_buffer_reader.h b/quiche/spdy/core/spdy_prefixed_buffer_reader.h
index 8f51f86..d0d3956 100644
--- a/quiche/spdy/core/spdy_prefixed_buffer_reader.h
+++ b/quiche/spdy/core/spdy_prefixed_buffer_reader.h
@@ -16,10 +16,8 @@
 // from a disjoint buffer prefix & suffix.
 class QUICHE_EXPORT_PRIVATE SpdyPrefixedBufferReader {
  public:
-  SpdyPrefixedBufferReader(const char* prefix,
-                           size_t prefix_length,
-                           const char* suffix,
-                           size_t suffix_length);
+  SpdyPrefixedBufferReader(const char* prefix, size_t prefix_length,
+                           const char* suffix, size_t suffix_length);
 
   // Returns number of bytes available to be read.
   size_t Available();
diff --git a/quiche/spdy/core/spdy_protocol.cc b/quiche/spdy/core/spdy_protocol.cc
index 7588806..35c2c40 100644
--- a/quiche/spdy/core/spdy_protocol.cc
+++ b/quiche/spdy/core/spdy_protocol.cc
@@ -292,21 +292,14 @@
 
 const char* const kHttp2StatusHeader = ":status";
 
-bool SpdyFrameIR::fin() const {
-  return false;
-}
+bool SpdyFrameIR::fin() const { return false; }
 
-int SpdyFrameIR::flow_control_window_consumed() const {
-  return 0;
-}
+int SpdyFrameIR::flow_control_window_consumed() const { return 0; }
 
-bool SpdyFrameWithFinIR::fin() const {
-  return fin_;
-}
+bool SpdyFrameWithFinIR::fin() const { return fin_; }
 
 SpdyFrameWithHeaderBlockIR::SpdyFrameWithHeaderBlockIR(
-    SpdyStreamId stream_id,
-    Http2HeaderBlock header_block)
+    SpdyStreamId stream_id, Http2HeaderBlock header_block)
     : SpdyFrameWithFinIR(stream_id), header_block_(std::move(header_block)) {}
 
 SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() = default;
@@ -344,9 +337,7 @@
   return visitor->VisitData(*this);
 }
 
-SpdyFrameType SpdyDataIR::frame_type() const {
-  return SpdyFrameType::DATA;
-}
+SpdyFrameType SpdyDataIR::frame_type() const { return SpdyFrameType::DATA; }
 
 int SpdyDataIR::flow_control_window_consumed() const {
   return padded_ ? 1 + padding_payload_len_ + data_len_ : data_len_;
@@ -373,9 +364,7 @@
   return SpdyFrameType::RST_STREAM;
 }
 
-size_t SpdyRstStreamIR::size() const {
-  return kRstStreamFrameSize;
-}
+size_t SpdyRstStreamIR::size() const { return kRstStreamFrameSize; }
 
 SpdySettingsIR::SpdySettingsIR() : is_ack_(false) {}
 
@@ -397,13 +386,9 @@
   return visitor->VisitPing(*this);
 }
 
-SpdyFrameType SpdyPingIR::frame_type() const {
-  return SpdyFrameType::PING;
-}
+SpdyFrameType SpdyPingIR::frame_type() const { return SpdyFrameType::PING; }
 
-size_t SpdyPingIR::size() const {
-  return kPingFrameSize;
-}
+size_t SpdyPingIR::size() const { return kPingFrameSize; }
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                            SpdyErrorCode error_code,
@@ -414,15 +399,12 @@
 }
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-                           SpdyErrorCode error_code,
-                           const char* description)
-    : SpdyGoAwayIR(last_good_stream_id,
-                   error_code,
+                           SpdyErrorCode error_code, const char* description)
+    : SpdyGoAwayIR(last_good_stream_id, error_code,
                    absl::string_view(description)) {}
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-                           SpdyErrorCode error_code,
-                           std::string description)
+                           SpdyErrorCode error_code, std::string description)
     : description_store_(std::move(description)),
       description_(description_store_) {
   set_last_good_stream_id(last_good_stream_id);
@@ -435,17 +417,14 @@
   return visitor->VisitGoAway(*this);
 }
 
-SpdyFrameType SpdyGoAwayIR::frame_type() const {
-  return SpdyFrameType::GOAWAY;
-}
+SpdyFrameType SpdyGoAwayIR::frame_type() const { return SpdyFrameType::GOAWAY; }
 
 size_t SpdyGoAwayIR::size() const {
   return kGoawayFrameMinimumSize + description_.size();
 }
 
 SpdyContinuationIR::SpdyContinuationIR(SpdyStreamId stream_id)
-    : SpdyFrameIR(stream_id), end_headers_(false) {
-}
+    : SpdyFrameIR(stream_id), end_headers_(false) {}
 
 SpdyContinuationIR::~SpdyContinuationIR() = default;
 
@@ -503,9 +482,7 @@
   return SpdyFrameType::WINDOW_UPDATE;
 }
 
-size_t SpdyWindowUpdateIR::size() const {
-  return kWindowUpdateFrameSize;
-}
+size_t SpdyWindowUpdateIR::size() const { return kWindowUpdateFrameSize; }
 
 void SpdyPushPromiseIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPushPromise(*this);
@@ -540,9 +517,7 @@
   return visitor->VisitAltSvc(*this);
 }
 
-SpdyFrameType SpdyAltSvcIR::frame_type() const {
-  return SpdyFrameType::ALTSVC;
-}
+SpdyFrameType SpdyAltSvcIR::frame_type() const { return SpdyFrameType::ALTSVC; }
 
 size_t SpdyAltSvcIR::size() const {
   size_t size = kGetAltSvcFrameMinimumSize;
@@ -562,9 +537,7 @@
   return SpdyFrameType::PRIORITY;
 }
 
-size_t SpdyPriorityIR::size() const {
-  return kPriorityFrameSize;
-}
+size_t SpdyPriorityIR::size() const { return kPriorityFrameSize; }
 
 void SpdyPriorityUpdateIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriorityUpdate(*this);
diff --git a/quiche/spdy/core/spdy_protocol.h b/quiche/spdy/core/spdy_protocol.h
index 2368f9c..81db503 100644
--- a/quiche/spdy/core/spdy_protocol.h
+++ b/quiche/spdy/core/spdy_protocol.h
@@ -256,8 +256,7 @@
 // (stream-specific xor connection-level). Returns false iff we know
 // the given frame type does not align with the given streamID.
 QUICHE_EXPORT_PRIVATE bool IsValidHTTP2FrameStreamId(
-    SpdyStreamId current_frame_stream_id,
-    SpdyFrameType frame_type_field);
+    SpdyStreamId current_frame_stream_id, SpdyFrameType frame_type_field);
 
 // Serialize |frame_type| to string for logging/debugging.
 QUICHE_EXPORT_PRIVATE const char* FrameTypeToString(SpdyFrameType frame_type);
@@ -661,20 +660,17 @@
  public:
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-               SpdyErrorCode error_code,
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
                absl::string_view description);
 
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-               SpdyErrorCode error_code,
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
                const char* description);
 
   // Moves description into description_store_, so caller doesn't need to
   // keep description live after constructing this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-               SpdyErrorCode error_code,
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
                std::string description);
   SpdyGoAwayIR(const SpdyGoAwayIR&) = delete;
   SpdyGoAwayIR& operator=(const SpdyGoAwayIR&) = delete;
@@ -780,8 +776,7 @@
  public:
   SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
       : SpdyPushPromiseIR(stream_id, promised_stream_id, Http2HeaderBlock()) {}
-  SpdyPushPromiseIR(SpdyStreamId stream_id,
-                    SpdyStreamId promised_stream_id,
+  SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                     Http2HeaderBlock header_block)
       : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)),
         promised_stream_id_(promised_stream_id),
@@ -866,10 +861,8 @@
 
 class QUICHE_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameIR {
  public:
-  SpdyPriorityIR(SpdyStreamId stream_id,
-                 SpdyStreamId parent_stream_id,
-                 int weight,
-                 bool exclusive)
+  SpdyPriorityIR(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                 int weight, bool exclusive)
       : SpdyFrameIR(stream_id),
         parent_stream_id_(parent_stream_id),
         weight_(weight),
@@ -950,9 +943,7 @@
 // Represents a frame of unrecognized type.
 class QUICHE_EXPORT_PRIVATE SpdyUnknownIR : public SpdyFrameIR {
  public:
-  SpdyUnknownIR(SpdyStreamId stream_id,
-                uint8_t type,
-                uint8_t flags,
+  SpdyUnknownIR(SpdyStreamId stream_id, uint8_t type, uint8_t flags,
                 std::string payload)
       : SpdyFrameIR(stream_id),
         type_(type),
diff --git a/quiche/spdy/core/spdy_protocol_test_utils.cc b/quiche/spdy/core/spdy_protocol_test_utils.cc
index 9bd3a06..46b2d65 100644
--- a/quiche/spdy/core/spdy_protocol_test_utils.cc
+++ b/quiche/spdy/core/spdy_protocol_test_utils.cc
@@ -64,8 +64,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyHeadersIR& expected,
-    const SpdyHeadersIR& actual) {
+    const SpdyHeadersIR& expected, const SpdyHeadersIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyHeadersIR";
   VERIFY_EQ(expected.stream_id(), actual.stream_id());
   VERIFY_EQ(expected.fin(), actual.fin());
@@ -87,8 +86,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyPriorityIR& expected,
-    const SpdyPriorityIR& actual) {
+    const SpdyPriorityIR& expected, const SpdyPriorityIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPriorityIR";
   VERIFY_EQ(expected.stream_id(), actual.stream_id());
   VERIFY_SUCCESS(VerifySpdyFrameWithPriorityIREquals(expected, actual));
@@ -96,8 +94,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyPushPromiseIR& expected,
-    const SpdyPushPromiseIR& actual) {
+    const SpdyPushPromiseIR& expected, const SpdyPushPromiseIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPushPromiseIR";
   VERIFY_EQ(expected.stream_id(), actual.stream_id());
   VERIFY_SUCCESS(VerifySpdyFrameWithPaddingIREquals(expected, actual));
@@ -107,8 +104,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyRstStreamIR& expected,
-    const SpdyRstStreamIR& actual) {
+    const SpdyRstStreamIR& expected, const SpdyRstStreamIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyRstStreamIR";
   VERIFY_EQ(expected.stream_id(), actual.stream_id());
   VERIFY_EQ(expected.error_code(), actual.error_code());
@@ -116,8 +112,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdySettingsIR& expected,
-    const SpdySettingsIR& actual) {
+    const SpdySettingsIR& expected, const SpdySettingsIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdySettingsIR";
   // Note, ignoring non-HTTP/2 fields such as clear_settings.
   VERIFY_EQ(expected.is_ack(), actual.is_ack());
@@ -143,8 +138,7 @@
 }
 
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyWindowUpdateIR& expected,
-    const SpdyWindowUpdateIR& actual) {
+    const SpdyWindowUpdateIR& expected, const SpdyWindowUpdateIR& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyWindowUpdateIR";
   VERIFY_EQ(expected.stream_id(), actual.stream_id());
   VERIFY_EQ(expected.delta(), actual.delta());
diff --git a/quiche/spdy/core/spdy_protocol_test_utils.h b/quiche/spdy/core/spdy_protocol_test_utils.h
index 515a903..88c4763 100644
--- a/quiche/spdy/core/spdy_protocol_test_utils.h
+++ b/quiche/spdy/core/spdy_protocol_test_utils.h
@@ -50,8 +50,7 @@
 // Verify the priority fields in two frames of type T are the same.
 template <class T>
 ::testing::AssertionResult VerifySpdyFrameWithPriorityIREquals(
-    const T& expected,
-    const T& actual) {
+    const T& expected, const T& actual) {
   QUICHE_VLOG(1) << "VerifySpdyFrameWithPriorityIREquals";
   VERIFY_EQ(expected.parent_stream_id(), actual.parent_stream_id());
   VERIFY_EQ(expected.weight(), actual.weight());
@@ -85,8 +84,7 @@
 
 // Verify that two SpdyHeadersIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyHeadersIR& expected,
-    const SpdyHeadersIR& actual);
+    const SpdyHeadersIR& expected, const SpdyHeadersIR& actual);
 
 // Verify that two SpdyPingIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyPingIR& expected,
@@ -94,28 +92,23 @@
 
 // Verify that two SpdyPriorityIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyPriorityIR& expected,
-    const SpdyPriorityIR& actual);
+    const SpdyPriorityIR& expected, const SpdyPriorityIR& actual);
 
 // Verify that two SpdyPushPromiseIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyPushPromiseIR& expected,
-    const SpdyPushPromiseIR& actual);
+    const SpdyPushPromiseIR& expected, const SpdyPushPromiseIR& actual);
 
 // Verify that two SpdyRstStreamIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyRstStreamIR& expected,
-    const SpdyRstStreamIR& actual);
+    const SpdyRstStreamIR& expected, const SpdyRstStreamIR& actual);
 
 // Verify that two SpdySettingsIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdySettingsIR& expected,
-    const SpdySettingsIR& actual);
+    const SpdySettingsIR& expected, const SpdySettingsIR& actual);
 
 // Verify that two SpdyWindowUpdateIR frames are the same.
 ::testing::AssertionResult VerifySpdyFrameIREquals(
-    const SpdyWindowUpdateIR& expected,
-    const SpdyWindowUpdateIR& actual);
+    const SpdyWindowUpdateIR& expected, const SpdyWindowUpdateIR& actual);
 
 // Verify that either expected and actual are both nullptr, or that both are not
 // nullptr, and that actual is of type E, and that it matches expected.
diff --git a/quiche/spdy/core/spdy_test_utils.cc b/quiche/spdy/core/spdy_test_utils.cc
index b896d93..bb27d6a 100644
--- a/quiche/spdy/core/spdy_test_utils.cc
+++ b/quiche/spdy/core/spdy_test_utils.cc
@@ -18,10 +18,8 @@
 namespace spdy {
 namespace test {
 
-std::string HexDumpWithMarks(const unsigned char* data,
-                             int length,
-                             const bool* marks,
-                             int mark_length) {
+std::string HexDumpWithMarks(const unsigned char* data, int length,
+                             const bool* marks, int mark_length) {
   static const char kHexChars[] = "0123456789abcdef";
   static const int kColumns = 4;
 
@@ -78,8 +76,7 @@
   for (int i = min_len; i < max_len; ++i) {
     marks[i] = true;
   }
-  if (identical)
-    return;
+  if (identical) return;
   ADD_FAILURE() << "Description:\n"
                 << description << "\n\nExpected:\n"
                 << HexDumpWithMarks(expected, expected_len, marks.get(),
diff --git a/quiche/spdy/core/spdy_test_utils.h b/quiche/spdy/core/spdy_test_utils.h
index 27f42e9..f0d5b7a 100644
--- a/quiche/spdy/core/spdy_test_utils.h
+++ b/quiche/spdy/core/spdy_test_utils.h
@@ -22,10 +22,8 @@
 
 namespace test {
 
-std::string HexDumpWithMarks(const unsigned char* data,
-                             int length,
-                             const bool* marks,
-                             int mark_length);
+std::string HexDumpWithMarks(const unsigned char* data, int length,
+                             const bool* marks, int mark_length);
 
 void CompareCharArraysWithHexError(const std::string& description,
                                    const unsigned char* actual,