Clang format slam.

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/spdy/spdy_framer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 14 matching lines @@
 uLong CalculateDictionaryId(const char* dictionary,
                             const size_t dictionary_size) {
   uLong initial_value = adler32(0L, Z_NULL, 0);
   return adler32(initial_value,
                  reinterpret_cast<const Bytef*>(dictionary),
                  dictionary_size);
 }
 
 struct DictionaryIds {
   DictionaryIds()
-    : v2_dictionary_id(CalculateDictionaryId(kV2Dictionary, kV2DictionarySize)),
-      v3_dictionary_id(CalculateDictionaryId(kV3Dictionary, kV3DictionarySize))
-  {}
+      : v2_dictionary_id(
+            CalculateDictionaryId(kV2Dictionary, kV2DictionarySize)),
+        v3_dictionary_id(
+            CalculateDictionaryId(kV3Dictionary, kV3DictionarySize)) {}
   const uLong v2_dictionary_id;
   const uLong v3_dictionary_id;
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
 // Used to indicate no flags in a SPDY flags field.
 const uint8 kNoFlags = 0;
 
 }  // namespace
 
 const SpdyStreamId SpdyFramer::kInvalidStream = -1;
 const size_t SpdyFramer::kHeaderDataChunkMaxSize = 1024;
 // The size of the control frame buffer. Must be >= the minimum size of the
 // largest control frame, which is SYN_STREAM. See GetSynStreamMinimumSize() for
 // calculation details.
 const size_t SpdyFramer::kControlFrameBufferSize = 18;
 
 #ifdef DEBUG_SPDY_STATE_CHANGES
-#define CHANGE_STATE(newstate)                                  \
-  do {                                                          \
-    DVLOG(1) << "Changing state from: "                         \
-             << StateToString(state_)                           \
-             << " to " << StateToString(newstate) << "\n";      \
-    DCHECK(state_ != SPDY_ERROR);                               \
-    DCHECK_EQ(previous_state_, state_);                         \
-    previous_state_ = state_;                                   \
-    state_ = newstate;                                          \
+#define CHANGE_STATE(newstate)                                             \
+  do {                                                                     \
+    DVLOG(1) << "Changing state from: " << StateToString(state_) << " to " \
+             << StateToString(newstate) << "\n";                           \
+    DCHECK(state_ != SPDY_ERROR);                                          \
+    DCHECK_EQ(previous_state_, state_);                                    \
+    previous_state_ = state_;                                              \
+    state_ = newstate;                                                     \
   } while (false)
 #else
-#define CHANGE_STATE(newstate)                                  \
-  do {                                                          \
-    DCHECK(state_ != SPDY_ERROR);                               \
-    DCHECK_EQ(previous_state_, state_);                         \
-    previous_state_ = state_;                                   \
-    state_ = newstate;                                          \
+#define CHANGE_STATE(newstate)          \
+  do {                                  \
+    DCHECK(state_ != SPDY_ERROR);       \
+    DCHECK_EQ(previous_state_, state_); \
+    previous_state_ = state_;           \
+    state_ = newstate;                  \
   } while (false)
 #endif
 
-SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(
-    SpdyMajorVersion version, uint32 wire) {
+SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(SpdyMajorVersion version,
+                                                      uint32 wire) {
   if (version < SPDY3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return SettingsFlagsAndId(ntohl(wire) >> 24, ntohl(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
     : flags_(flags), id_(id & 0x00ffffff) {
   LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large: " << id;
 }
 
-uint32 SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version)
-    const {
+uint32 SettingsFlagsAndId::GetWireFormat(SpdyMajorVersion version) const {
   uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
   if (version < SPDY3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
 // SPDY 2 had a bug in it with respect to byte ordering of id/flags field.
 // This method is used to preserve buggy behavior and works on both
 // little-endian and big-endian hosts.
 // This method is also bidirectional (can be used to translate SPDY 2 to SPDY 3
 // as well as vice versa).
 void SettingsFlagsAndId::ConvertFlagsAndIdForSpdy2(uint32* val) {
-    uint8* wire_array = reinterpret_cast<uint8*>(val);
-    std::swap(wire_array[0], wire_array[3]);
-    std::swap(wire_array[1], wire_array[2]);
+  uint8* wire_array = reinterpret_cast<uint8*>(val);
+  std::swap(wire_array[0], wire_array[3]);
+  std::swap(wire_array[1], wire_array[2]);
 }
 
 bool SpdyFramerVisitorInterface::OnGoAwayFrameData(const char* goaway_data,
                                                    size_t len) {
   return true;
 }
 
 bool SpdyFramerVisitorInterface::OnRstStreamFrameData(
     const char* rst_stream_data,
     size_t len) {
@@ skipping 131 matching lines @@
   size += 4;
 
   // 3. SPDY 3+ GOAWAY frames also contain a status (4 bytes)
   if (protocol_version() >= SPDY3) {
     size += 4;
   }
 
   return size;
 }
 
-size_t SpdyFramer::GetHeadersMinimumSize() const  {
+size_t SpdyFramer::GetHeadersMinimumSize() const {
   // Size, in bytes, of a HEADERS frame not including the variable-length
   // name-value block.
   size_t size = GetControlFrameHeaderSize();
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 4 (stream IDs)
     size += 4;
   }
 
   // In SPDY 2, there were 2 unused bytes before payload.
@@ skipping 24 matching lines @@
   return GetControlFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetPushPromiseMinimumSize() const {
   DCHECK_LT(SPDY3, protocol_version());
   // Size, in bytes, of a PUSH_PROMISE frame, sans the embedded header block.
   // Calculated as frame prefix + 4 (promised stream id).
   return GetControlFrameHeaderSize() + 4;
 }
 
-size_t SpdyFramer::GetContinuationMinimumSize() const  {
+size_t SpdyFramer::GetContinuationMinimumSize() const {
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetControlFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return std::min(GetDataFrameMinimumSize(), GetControlFrameHeaderSize());
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
@@ skipping 261 matching lines @@
 
       default:
         LOG(DFATAL) << "Invalid value for " << display_protocol_
                     << " framer state: " << state_;
         // This ensures that we don't infinite-loop if state_ gets an
         // invalid value somehow, such as due to a SpdyFramer getting deleted
         // from a callback it calls.
         goto bottom;
     }
   } while (state_ != previous_state_);
- bottom:
+bottom:
   DCHECK(len == 0 || state_ == SPDY_ERROR);
-  if (current_frame_buffer_length_ == 0 &&
-      remaining_data_length_ == 0 &&
+  if (current_frame_buffer_length_ == 0 && remaining_data_length_ == 0 &&
       remaining_control_header_ == 0) {
     DCHECK(state_ == SPDY_RESET || state_ == SPDY_ERROR)
         << "State: " << StateToString(state_);
   }
 
   return original_len - len;
 }
 
 size_t SpdyFramer::ProcessCommonHeader(const char* data, size_t len) {
   // This should only be called when we're in the SPDY_READING_COMMON_HEADER
   // state.
   DCHECK_EQ(state_, SPDY_READING_COMMON_HEADER);
 
   size_t original_len = len;
 
   // Update current frame buffer as needed.
   if (current_frame_buffer_length_ < GetControlFrameHeaderSize()) {
     size_t bytes_desired =
         GetControlFrameHeaderSize() - current_frame_buffer_length_;
     UpdateCurrentFrameBuffer(&data, &len, bytes_desired);
   }
 
   if (current_frame_buffer_length_ < GetControlFrameHeaderSize()) {
     // Not enough information to do anything meaningful.
     return original_len - len;
   }
 
   // Using a scoped_ptr here since we may need to create a new SpdyFrameReader
   // when processing DATA frames below.
-  scoped_ptr<SpdyFrameReader> reader(
-      new SpdyFrameReader(current_frame_buffer_.get(),
-                          current_frame_buffer_length_));
+  scoped_ptr<SpdyFrameReader> reader(new SpdyFrameReader(
+      current_frame_buffer_.get(), current_frame_buffer_length_));
 
   uint16 version = 0;
   bool is_control_frame = false;
 
   uint16 control_frame_type_field = DATA;
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
   if (protocol_version() <= SPDY3) {
     bool successful_read = reader->ReadUInt16(&version);
     DCHECK(successful_read);
     is_control_frame = (version & kControlFlagMask) != 0;
     version &= ~kControlFlagMask;  // Only valid for control frames.
     if (is_control_frame) {
       // We check version before we check validity: version can never be
       // 'invalid', it can only be unsupported.
       if (version < SpdyConstants::SerializeMajorVersion(SPDY_MIN_VERSION) ||
           version > SpdyConstants::SerializeMajorVersion(SPDY_MAX_VERSION) ||
           SpdyConstants::ParseMajorVersion(version) != protocol_version()) {
         // Version does not match the version the framer was initialized with.
-        DVLOG(1) << "Unsupported SPDY version "
-                 << version
-                 << " (expected " << protocol_version() << ")";
+        DVLOG(1) << "Unsupported SPDY version " << version << " (expected "
+                 << protocol_version() << ")";
         set_error(SPDY_UNSUPPORTED_VERSION);
         return 0;
       } else {
         // Convert version from wire format to SpdyMajorVersion.
         version = SpdyConstants::ParseMajorVersion(version);
       }
       // We check control_frame_type_field's validity in
       // ProcessControlFrameHeader().
       successful_read = reader->ReadUInt16(&control_frame_type_field);
     } else {
@@ skipping 33 matching lines @@
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     successful_read = reader->ReadUInt31(&current_frame_stream_id_);
     DCHECK(successful_read);
 
     remaining_data_length_ = current_frame_length_ - reader->GetBytesConsumed();
 
     // Before we accept a DATA frame, we need to make sure we're not in the
     // middle of processing a header block.
-    const bool is_continuation_frame = (control_frame_type_field ==
-        SpdyConstants::SerializeFrameType(protocol_version(), CONTINUATION));
+    const bool is_continuation_frame =
+        (control_frame_type_field ==
+         SpdyConstants::SerializeFrameType(protocol_version(), CONTINUATION));
     if ((expect_continuation_ != 0) != is_continuation_frame) {
       if (expect_continuation_ != 0) {
         DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
                     << "frame, but instead received frame type "
                     << control_frame_type_field;
       } else {
         DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
       }
       set_error(SPDY_UNEXPECTED_FRAME);
       return original_len - len;
@@ skipping 24 matching lines @@
   if (!is_control_frame) {
     if (protocol_version() > SPDY3) {
       // Catch bogus tests sending oversized DATA frames.
       DCHECK_GE(GetFrameMaximumSize(), current_frame_length_)
           << "DATA frame too large for SPDY >= 4.";
     }
 
     uint8 valid_data_flags = 0;
     if (protocol_version() > SPDY3) {
       valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
-          DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
+                         DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
     } else {
       valid_data_flags = DATA_FLAG_FIN;
     }
 
     if (current_frame_flags_ & ~valid_data_flags) {
       set_error(SPDY_INVALID_DATA_FRAME_FLAGS);
     } else {
       visitor_->OnDataFrameHeader(current_frame_stream_id_,
                                   remaining_data_length_,
                                   current_frame_flags_ & DATA_FLAG_FIN);
       if (remaining_data_length_ > 0) {
         CHANGE_STATE(SPDY_READ_PADDING_LENGTH);
       } else {
         // Empty data frame.
         if (current_frame_flags_ & DATA_FLAG_FIN) {
-          visitor_->OnStreamFrameData(
-              current_frame_stream_id_, NULL, 0, true);
+          visitor_->OnStreamFrameData(current_frame_stream_id_, NULL, 0, true);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
     }
   } else {
     ProcessControlFrameHeader(control_frame_type_field);
   }
 
   return original_len - len;
 }
@@ skipping 54 matching lines @@
       // opaque data, so we only have a lower limit on the frame size.
       if ((current_frame_length_ != GetRstStreamMinimumSize() &&
            protocol_version() <= SPDY3) ||
           (current_frame_length_ < GetRstStreamMinimumSize() &&
            protocol_version() > SPDY3)) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
-    case SETTINGS:
-    {
+    case SETTINGS: {
       // Make sure that we have an integral number of 8-byte key/value pairs,
       // plus a 4-byte length field in SPDY3 and below.
       size_t values_prefix_size = (protocol_version() <= SPDY3 ? 4 : 0);
       // Size of each key/value pair in bytes.
       size_t setting_size = (protocol_version() <= SPDY3 ? 8 : 5);
       if (current_frame_length_ < GetSettingsMinimumSize() ||
-          (current_frame_length_ - GetControlFrameHeaderSize())
-          % setting_size != values_prefix_size) {
+          (current_frame_length_ - GetControlFrameHeaderSize()) %
+                  setting_size !=
+              values_prefix_size) {
         DLOG(WARNING) << "Invalid length for SETTINGS frame: "
                       << current_frame_length_;
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (protocol_version() <= SPDY3 &&
                  current_frame_flags_ &
-                 ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
+                     ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       } else if (protocol_version() > SPDY3 &&
                  current_frame_flags_ & ~SETTINGS_FLAG_ACK) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       } else if (protocol_version() > SPDY3 &&
                  current_frame_flags_ & SETTINGS_FLAG_ACK &&
                  current_frame_length_ > GetSettingsMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       }
       break;
     }
     case PING:
       if (current_frame_length_ != GetPingSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if ((protocol_version() <= SPDY3 && current_frame_flags_ != 0) ||
                  (current_frame_flags_ & ~PING_FLAG_ACK)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
-    case GOAWAY:
-      {
-        // For SPDY version < 4, there are only mandatory fields and the header
-        // has a fixed length. For SPDY version >= 4, optional opaque data may
-        // be appended to the GOAWAY frame, thus there is only a minimal length
-        // restriction.
-        if ((current_frame_length_ != GetGoAwayMinimumSize() &&
-             protocol_version() <= SPDY3) ||
-            (current_frame_length_ < GetGoAwayMinimumSize() &&
-             protocol_version() > SPDY3)) {
-          set_error(SPDY_INVALID_CONTROL_FRAME);
-        } else if (current_frame_flags_ != 0) {
-          set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-        }
-        break;
-      }
-    case HEADERS:
-      {
-        size_t min_size = GetHeadersMinimumSize();
-        if (protocol_version() > SPDY3 &&
-            (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
-          min_size += 4;
-        }
-        if (current_frame_length_ < min_size) {
-          set_error(SPDY_INVALID_CONTROL_FRAME);
-        } else if (protocol_version() <= SPDY3 &&
-                   current_frame_flags_ & ~CONTROL_FLAG_FIN) {
-          set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-        } else if (protocol_version() > SPDY3 && current_frame_flags_ &
-                   ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
-                     HEADERS_FLAG_END_HEADERS)) {
-          set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-        }
+    case GOAWAY: {
+      // For SPDY version < 4, there are only mandatory fields and the header
+      // has a fixed length. For SPDY version >= 4, optional opaque data may
+      // be appended to the GOAWAY frame, thus there is only a minimal length
+      // restriction.
+      if ((current_frame_length_ != GetGoAwayMinimumSize() &&
+           protocol_version() <= SPDY3) ||
+          (current_frame_length_ < GetGoAwayMinimumSize() &&
+           protocol_version() > SPDY3)) {
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+      } else if (current_frame_flags_ != 0) {
+        set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
+    }
+    case HEADERS: {
+      size_t min_size = GetHeadersMinimumSize();
+      if (protocol_version() > SPDY3 &&
+          (current_frame_flags_ & HEADERS_FLAG_PRIORITY)) {
+        min_size += 4;
+      }
+      if (current_frame_length_ < min_size) {
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+      } else if (protocol_version() <= SPDY3 &&
+                 current_frame_flags_ & ~CONTROL_FLAG_FIN) {
+        set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
+      } else if (protocol_version() > SPDY3 &&
+                 current_frame_flags_ &
+                     ~(CONTROL_FLAG_FIN | HEADERS_FLAG_PRIORITY |
+                       HEADERS_FLAG_END_HEADERS)) {
+        set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
+      }
+    } break;
     case WINDOW_UPDATE:
       if (current_frame_length_ != GetWindowUpdateSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case BLOCKED:
       if (current_frame_length_ != GetBlockedSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case PUSH_PROMISE:
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (protocol_version() <= SPDY3 && current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
-      } else if (protocol_version() > SPDY3 && current_frame_flags_ &
-                 ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE) {
+      } else if (protocol_version() > SPDY3 &&
+                 current_frame_flags_ & ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CONTINUATION:
       if (current_frame_length_ < GetContinuationMinimumSize() ||
           protocol_version() <= SPDY3) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ & ~HEADERS_FLAG_END_HEADERS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
@@ skipping 75 matching lines @@
     }
     return;
   }
 
   if (frame_size_without_variable_data > 0) {
     // We have a control frame with a header block. We need to parse the
     // remainder of the control frame's header before we can parse the header
     // block. The start of the header block varies with the control type.
     DCHECK_GE(frame_size_without_variable_data,
               static_cast<int32>(current_frame_buffer_length_));
-    remaining_control_header_ = frame_size_without_variable_data -
-        current_frame_buffer_length_;
+    remaining_control_header_ =
+        frame_size_without_variable_data - current_frame_buffer_length_;
 
     CHANGE_STATE(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK);
     return;
   }
 
   CHANGE_STATE(SPDY_CONTROL_FRAME_PAYLOAD);
 }
 
-size_t SpdyFramer::UpdateCurrentFrameBuffer(const char** data, size_t* len,
+size_t SpdyFramer::UpdateCurrentFrameBuffer(const char** data,
+                                            size_t* len,
                                             size_t max_bytes) {
   size_t bytes_to_read = std::min(*len, max_bytes);
   if (bytes_to_read > 0) {
     DCHECK_GE(kControlFrameBufferSize,
               current_frame_buffer_length_ + bytes_to_read);
     memcpy(current_frame_buffer_.get() + current_frame_buffer_length_,
            *data,
            bytes_to_read);
     current_frame_buffer_length_ += bytes_to_read;
     *data += bytes_to_read;
     *len -= bytes_to_read;
   }
   return bytes_to_read;
 }
 
-size_t SpdyFramer::GetSerializedLength(
-    const SpdyMajorVersion spdy_version,
-    const SpdyHeaderBlock* headers) {
-  const size_t num_name_value_pairs_size
-      = (spdy_version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
+size_t SpdyFramer::GetSerializedLength(const SpdyMajorVersion spdy_version,
+                                       const SpdyHeaderBlock* headers) {
+  const size_t num_name_value_pairs_size =
+      (spdy_version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
   const size_t length_of_name_size = num_name_value_pairs_size;
   const size_t length_of_value_size = num_name_value_pairs_size;
 
   size_t total_length = num_name_value_pairs_size;
   for (SpdyHeaderBlock::const_iterator it = headers->begin();
        it != headers->end();
        ++it) {
     // We add space for the length of the name and the length of the value as
     // well as the length of the name and the length of the value.
     total_length += length_of_name_size + it->first.size() +
@@ skipping 45 matching lines @@
 
 // WriteZ writes |data| to the deflate context |out|. WriteZ will flush as
 // needed when switching between classes of data.
 static void WriteZ(const base::StringPiece& data,
                    ZDataClass clas,
                    z_stream* out) {
   int rv;
 
   // If we are switching from standard to non-standard data then we need to end
   // the current Huffman context to avoid it leaking between them.
-  if (out->clas == kZStandardData &&
-      clas != kZStandardData) {
+  if (out->clas == kZStandardData && clas != kZStandardData) {
     out->avail_in = 0;
     rv = deflate(out, Z_PARTIAL_FLUSH);
     DCHECK_EQ(Z_OK, rv);
     DCHECK_EQ(0u, out->avail_in);
     DCHECK_LT(0u, out->avail_out);
   }
 
   out->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(data.data()));
   out->avail_in = data.size();
   out->clas = clas;
@@ skipping 85 matching lines @@
           cookie = cookie_values[i].as_string();
         } else if (i == 0) {
           cookie = cookie_values[i].as_string() + ";";
         } else if (i < cookie_values.size() - 1) {
           cookie = " " + cookie_values[i].as_string() + ";";
         } else {
           cookie = " " + cookie_values[i].as_string();
         }
         WriteZ(cookie, kZCookieData, z);
       }
-    } else if (it->first == "accept" ||
-               it->first == "accept-charset" ||
+    } else if (it->first == "accept" || it->first == "accept-charset" ||
                it->first == "accept-encoding" ||
-               it->first == "accept-language" ||
-               it->first == "host" ||
-               it->first == "version" ||
-               it->first == "method" ||
-               it->first == "scheme" ||
-               it->first == ":host" ||
-               it->first == ":version" ||
-               it->first == ":method" ||
-               it->first == ":scheme" ||
-               it->first == "user-agent") {
+               it->first == "accept-language" || it->first == "host" ||
+               it->first == "version" || it->first == "method" ||
+               it->first == "scheme" || it->first == ":host" ||
+               it->first == ":version" || it->first == ":method" ||
+               it->first == ":scheme" || it->first == "user-agent") {
       WriteLengthZ(it->second.size(), length_length, kZStandardData, z);
       WriteZ(it->second, kZStandardData, z);
     } else {
       // Non-whitelisted headers are Huffman compressed in their own block, but
       // don't match against the window.
       WriteLengthZ(it->second.size(), length_length, kZStandardData, z);
       WriteZ(it->second, kZHuffmanOnlyData, z);
     }
   }
 
   z->avail_in = 0;
   int rv = deflate(z, Z_SYNC_FLUSH);
   DCHECK_EQ(Z_OK, rv);
   z->clas = kZStandardData;
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 size_t SpdyFramer::ProcessControlFrameBeforeHeaderBlock(const char* data,
                                                         size_t len) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK, state_);
   const size_t original_len = len;
 
   if (remaining_control_header_ > 0) {
-    size_t bytes_read = UpdateCurrentFrameBuffer(&data, &len,
-                                                 remaining_control_header_);
+    size_t bytes_read =
+        UpdateCurrentFrameBuffer(&data, &len, remaining_control_header_);
     remaining_control_header_ -= bytes_read;
     remaining_data_length_ -= bytes_read;
   }
 
   if (remaining_control_header_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.get(),
                            current_frame_buffer_length_);
     reader.Seek(GetControlFrameHeaderSize());  // Seek past frame header.
 
     switch (current_frame_type_) {
-      case SYN_STREAM:
-        {
-          DCHECK_GE(SPDY3, protocol_version());
-          bool successful_read = true;
-          successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-          DCHECK(successful_read);
-          if (current_frame_stream_id_ == 0) {
-            set_error(SPDY_INVALID_CONTROL_FRAME);
-            break;
-          }
+      case SYN_STREAM: {
+        DCHECK_GE(SPDY3, protocol_version());
+        bool successful_read = true;
+        successful_read = reader.ReadUInt31(&current_frame_stream_id_);
+        DCHECK(successful_read);
+        if (current_frame_stream_id_ == 0) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+          break;
+        }
 
-          SpdyStreamId associated_to_stream_id = kInvalidStream;
-          successful_read = reader.ReadUInt31(&associated_to_stream_id);
-          DCHECK(successful_read);
+        SpdyStreamId associated_to_stream_id = kInvalidStream;
+        successful_read = reader.ReadUInt31(&associated_to_stream_id);
+        DCHECK(successful_read);
 
-          SpdyPriority priority = 0;
-          successful_read = reader.ReadUInt8(&priority);
-          DCHECK(successful_read);
-          if (protocol_version() <= SPDY2) {
-            priority = priority >> 6;
-          } else {
-            priority = priority >> 5;
-          }
+        SpdyPriority priority = 0;
+        successful_read = reader.ReadUInt8(&priority);
+        DCHECK(successful_read);
+        if (protocol_version() <= SPDY2) {
+          priority = priority >> 6;
+        } else {
+          priority = priority >> 5;
+        }
 
-         // Seek past unused byte; used to be credential slot in SPDY 3.
-         reader.Seek(1);
+        // Seek past unused byte; used to be credential slot in SPDY 3.
+        reader.Seek(1);
 
-          DCHECK(reader.IsDoneReading());
-          if (debug_visitor_) {
-            debug_visitor_->OnReceiveCompressedFrame(
-                current_frame_stream_id_,
-                current_frame_type_,
-                current_frame_length_);
-          }
-          visitor_->OnSynStream(
-              current_frame_stream_id_,
-              associated_to_stream_id,
-              priority,
-              (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
-              (current_frame_flags_ & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
+        DCHECK(reader.IsDoneReading());
+        if (debug_visitor_) {
+          debug_visitor_->OnReceiveCompressedFrame(current_frame_stream_id_,
+                                                   current_frame_type_,
+                                                   current_frame_length_);
         }
+        visitor_->OnSynStream(
+            current_frame_stream_id_,
+            associated_to_stream_id,
+            priority,
+            (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
+            (current_frame_flags_ & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
+      }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case SETTINGS:
         if (protocol_version() > SPDY3 &&
             current_frame_flags_ & SETTINGS_FLAG_ACK) {
           visitor_->OnSettingsAck();
           CHANGE_STATE(SPDY_AUTO_RESET);
         } else {
-          visitor_->OnSettings(current_frame_flags_ &
+          visitor_->OnSettings(
+              current_frame_flags_ &
               SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS);
           CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
         }
         break;
       case SYN_REPLY:
       case HEADERS:
         // SYN_REPLY and HEADERS are the same, save for the visitor call.
         {
           if (protocol_version() > SPDY3) {
             DCHECK_EQ(HEADERS, current_frame_type_);
           }
           bool successful_read = true;
           if (protocol_version() <= SPDY3) {
             successful_read = reader.ReadUInt31(&current_frame_stream_id_);
             DCHECK(successful_read);
           }
           if (current_frame_stream_id_ == 0) {
             set_error(SPDY_INVALID_CONTROL_FRAME);
             break;
           }
           if (protocol_version() <= SPDY2) {
             // SPDY 2 had two unused bytes here. Seek past them.
             reader.Seek(2);
           }
           if (protocol_version() > SPDY3 &&
-             !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
-             current_frame_type_ == HEADERS) {
+              !(current_frame_flags_ & HEADERS_FLAG_END_HEADERS) &&
+              current_frame_type_ == HEADERS) {
             expect_continuation_ = current_frame_stream_id_;
             end_stream_when_done_ = current_frame_flags_ & CONTROL_FLAG_FIN;
           }
           const bool has_priority =
               (current_frame_flags_ & HEADERS_FLAG_PRIORITY) != 0;
           uint32 priority = 0;
           if (protocol_version() > SPDY3 && has_priority) {
             successful_read = reader.ReadUInt31(&priority);
             DCHECK(successful_read);
           }
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             // SPDY 4 reports HEADERS with PRIORITY as SYN_STREAM.
             SpdyFrameType reported_type = current_frame_type_;
             if (protocol_version() > SPDY3 && has_priority) {
               reported_type = SYN_STREAM;
             }
             debug_visitor_->OnReceiveCompressedFrame(
-                current_frame_stream_id_,
-                reported_type,
-                current_frame_length_);
+                current_frame_stream_id_, reported_type, current_frame_length_);
           }
           if (current_frame_type_ == SYN_REPLY) {
             visitor_->OnSynReply(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
           } else if (protocol_version() > SPDY3 &&
-              current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
+                     current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
             // SPDY 4+ is missing SYN_STREAM. Simulate it so that API changes
             // can be made independent of wire changes.
-            visitor_->OnSynStream(
-                current_frame_stream_id_,
-                0,  // associated_to_stream_id
-                priority,
-                current_frame_flags_ & CONTROL_FLAG_FIN,
-                false);  // unidirectional
+            visitor_->OnSynStream(current_frame_stream_id_,
+                                  0,  // associated_to_stream_id
+                                  priority,
+                                  current_frame_flags_ & CONTROL_FLAG_FIN,
+                                  false);  // unidirectional
           } else {
-            visitor_->OnHeaders(
-                current_frame_stream_id_,
-                (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
-                expect_continuation_ == 0);
+            visitor_->OnHeaders(current_frame_stream_id_,
+                                (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
+                                expect_continuation_ == 0);
           }
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
-      case PUSH_PROMISE:
-        {
-          DCHECK_LT(SPDY3, protocol_version());
-          if (current_frame_stream_id_ == 0) {
-            set_error(SPDY_INVALID_CONTROL_FRAME);
-            break;
-          }
-          SpdyStreamId promised_stream_id = kInvalidStream;
-          bool successful_read = reader.ReadUInt31(&promised_stream_id);
-          DCHECK(successful_read);
-          DCHECK(reader.IsDoneReading());
-          if (promised_stream_id == 0) {
-            set_error(SPDY_INVALID_CONTROL_FRAME);
-            break;
-          }
-          if (!(current_frame_flags_ & PUSH_PROMISE_FLAG_END_PUSH_PROMISE)) {
-            expect_continuation_ = current_frame_stream_id_;
-          }
-          if (debug_visitor_) {
-            debug_visitor_->OnReceiveCompressedFrame(
-                current_frame_stream_id_,
-                current_frame_type_,
-                current_frame_length_);
-          }
-          visitor_->OnPushPromise(current_frame_stream_id_,
-                                  promised_stream_id,
-                                  (current_frame_flags_ &
-                                   PUSH_PROMISE_FLAG_END_PUSH_PROMISE) != 0);
+      case PUSH_PROMISE: {
+        DCHECK_LT(SPDY3, protocol_version());
+        if (current_frame_stream_id_ == 0) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+          break;
         }
+        SpdyStreamId promised_stream_id = kInvalidStream;
+        bool successful_read = reader.ReadUInt31(&promised_stream_id);
+        DCHECK(successful_read);
+        DCHECK(reader.IsDoneReading());
+        if (promised_stream_id == 0) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+          break;
+        }
+        if (!(current_frame_flags_ & PUSH_PROMISE_FLAG_END_PUSH_PROMISE)) {
+          expect_continuation_ = current_frame_stream_id_;
+        }
+        if (debug_visitor_) {
+          debug_visitor_->OnReceiveCompressedFrame(current_frame_stream_id_,
+                                                   current_frame_type_,
+                                                   current_frame_length_);
+        }
+        visitor_->OnPushPromise(
+            current_frame_stream_id_,
+            promised_stream_id,
+            (current_frame_flags_ & PUSH_PROMISE_FLAG_END_PUSH_PROMISE) != 0);
+      }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
-      case CONTINUATION:
-        {
-          // Check to make sure the stream id of the current frame is
-          // the same as that of the preceding frame.
-          // If we're at this point we should already know that
-          // expect_continuation_ != 0, so this doubles as a check
-          // that current_frame_stream_id != 0.
-          if (current_frame_stream_id_ != expect_continuation_) {
-            set_error(SPDY_INVALID_CONTROL_FRAME);
-            break;
-          }
-          if (current_frame_flags_ & HEADERS_FLAG_END_HEADERS) {
-            expect_continuation_ = 0;
-          }
-          if (debug_visitor_) {
-            debug_visitor_->OnReceiveCompressedFrame(
-                current_frame_stream_id_,
-                current_frame_type_,
-                current_frame_length_);
-          }
-          visitor_->OnContinuation(current_frame_stream_id_,
-                                   (current_frame_flags_ &
-                                    HEADERS_FLAG_END_HEADERS) != 0);
+      case CONTINUATION: {
+        // Check to make sure the stream id of the current frame is
+        // the same as that of the preceding frame.
+        // If we're at this point we should already know that
+        // expect_continuation_ != 0, so this doubles as a check
+        // that current_frame_stream_id != 0.
+        if (current_frame_stream_id_ != expect_continuation_) {
+          set_error(SPDY_INVALID_CONTROL_FRAME);
+          break;
         }
+        if (current_frame_flags_ & HEADERS_FLAG_END_HEADERS) {
+          expect_continuation_ = 0;
+        }
+        if (debug_visitor_) {
+          debug_visitor_->OnReceiveCompressedFrame(current_frame_stream_id_,
+                                                   current_frame_type_,
+                                                   current_frame_length_);
+        }
+        visitor_->OnContinuation(
+            current_frame_stream_id_,
+            (current_frame_flags_ & HEADERS_FLAG_END_HEADERS) != 0);
+      }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       default:
         DCHECK(false);
     }
   }
   return original_len - len;
 }
 
 // Does not buffer the control payload. Instead, either passes directly to the
 // visitor or decompresses and then passes directly to the visitor, via
 // IncrementallyDeliverControlFrameHeaderData() or
 // IncrementallyDecompressControlFrameHeaderData() respectively.
 size_t SpdyFramer::ProcessControlFrameHeaderBlock(const char* data,
                                                   size_t data_len,
                                                   bool is_hpack_header_block) {
   DCHECK_EQ(SPDY_CONTROL_FRAME_HEADER_BLOCK, state_);
 
   bool processed_successfully = true;
-  if (current_frame_type_ != SYN_STREAM &&
-      current_frame_type_ != SYN_REPLY &&
-      current_frame_type_ != HEADERS &&
-      current_frame_type_ != PUSH_PROMISE &&
+  if (current_frame_type_ != SYN_STREAM && current_frame_type_ != SYN_REPLY &&
+      current_frame_type_ != HEADERS && current_frame_type_ != PUSH_PROMISE &&
       current_frame_type_ != CONTINUATION) {
     LOG(DFATAL) << "Unhandled frame type in ProcessControlFrameHeaderBlock.";
   }
   size_t process_bytes = std::min(data_len, remaining_data_length_);
   if (is_hpack_header_block) {
-    if (!hpack_decoder_.HandleControlFrameHeadersData(current_frame_stream_id_,
-                                                      data,
-                                                      process_bytes)) {
+    if (!hpack_decoder_.HandleControlFrameHeadersData(
+            current_frame_stream_id_, data, process_bytes)) {
       // TODO(jgraettinger): Finer-grained HPACK error codes.
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   } else if (process_bytes > 0) {
     if (enable_compression_ && protocol_version() <= SPDY3) {
       processed_successfully = IncrementallyDecompressControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     } else {
       processed_successfully = IncrementallyDeliverControlFrameHeaderData(
           current_frame_stream_id_, data, process_bytes);
     }
   }
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_data_length_ == 0 && processed_successfully) {
     if (expect_continuation_ == 0) {
       if (is_hpack_header_block) {
         if (!hpack_decoder_.HandleControlFrameHeadersComplete(
-            current_frame_stream_id_)) {
+                current_frame_stream_id_)) {
           set_error(SPDY_DECOMPRESS_FAILURE);
           processed_successfully = false;
         } else {
           // TODO(jgraettinger): To be removed with migration to
           // SpdyHeadersHandlerInterface. Serializes the HPACK block as a SPDY3
           // block, delivered via reentrant call to
           // ProcessControlFrameHeaderBlock().
           DeliverHpackBlockAsSpdy3Block();
           return process_bytes;
         }
@@ skipping 80 matching lines @@
 void SpdyFramer::DeliverHpackBlockAsSpdy3Block() {
   DCHECK_LT(SPDY3, protocol_version());
   DCHECK_EQ(0u, remaining_data_length_);
 
   const SpdyNameValueBlock& block = hpack_decoder_.decoded_block();
   if (block.empty()) {
     // Special-case this to make tests happy.
     ProcessControlFrameHeaderBlock(NULL, 0, false);
     return;
   }
-  SpdyFrameBuilder builder(
-      GetSerializedLength(protocol_version(), &block),
-      SPDY3);
+  SpdyFrameBuilder builder(GetSerializedLength(protocol_version(), &block),
+                           SPDY3);
 
   SerializeNameValueBlockWithoutCompression(&builder, block);
   scoped_ptr<SpdyFrame> frame(builder.take());
 
   remaining_data_length_ = frame->size();
   ProcessControlFrameHeaderBlock(frame->data(), frame->size(), false);
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
   int id_field;
   SpdySettingsIds id;
   uint8 flags = 0;
   uint32 value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
   if (protocol_version() <= SPDY3) {
     const uint32 id_and_flags_wire = *(reinterpret_cast<const uint32*>(data));
-    SettingsFlagsAndId id_and_flags =
-      SettingsFlagsAndId::FromWireFormat(protocol_version(), id_and_flags_wire);
+    SettingsFlagsAndId id_and_flags = SettingsFlagsAndId::FromWireFormat(
+        protocol_version(), id_and_flags_wire);
     id_field = id_and_flags.id();
     flags = id_and_flags.flags();
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 4)));
   } else {
     id_field = *(reinterpret_cast<const uint8*>(data));
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 1)));
   }
 
   // Validate id.
   if (!SpdyConstants::IsValidSettingId(protocol_version(), id_field)) {
@@ skipping 22 matching lines @@
     }
   }
 
   // Validation succeeded. Pass on to visitor.
   visitor_->OnSetting(id, flags, value);
   return true;
 }
 
 size_t SpdyFramer::ProcessControlFramePayload(const char* data, size_t len) {
   size_t original_len = len;
-  size_t bytes_read = UpdateCurrentFrameBuffer(&data, &len,
-                                               remaining_data_length_);
+  size_t bytes_read =
+      UpdateCurrentFrameBuffer(&data, &len, remaining_data_length_);
   remaining_data_length_ -= bytes_read;
   if (remaining_data_length_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.get(),
                            current_frame_buffer_length_);
     reader.Seek(GetControlFrameHeaderSize());  // Skip frame header.
 
     // Use frame-specific handlers.
     switch (current_frame_type_) {
       case PING: {
-          SpdyPingId id = 0;
-          bool is_ack = protocol_version() > SPDY3 &&
-              (current_frame_flags_ & PING_FLAG_ACK);
-          bool successful_read = true;
-          if (protocol_version() <= SPDY3) {
-            uint32 id32 = 0;
-            successful_read = reader.ReadUInt32(&id32);
-            id = id32;
-          } else {
-            successful_read = reader.ReadUInt64(&id);
-          }
+        SpdyPingId id = 0;
+        bool is_ack = protocol_version() > SPDY3 &&
+                      (current_frame_flags_ & PING_FLAG_ACK);
+        bool successful_read = true;
+        if (protocol_version() <= SPDY3) {
+          uint32 id32 = 0;
+          successful_read = reader.ReadUInt32(&id32);
+          id = id32;
+        } else {
+          successful_read = reader.ReadUInt64(&id);
+        }
+        DCHECK(successful_read);
+        DCHECK(reader.IsDoneReading());
+        visitor_->OnPing(id, is_ack);
+      } break;
+      case WINDOW_UPDATE: {
+        uint32 delta_window_size = 0;
+        bool successful_read = true;
+        if (protocol_version() <= SPDY3) {
+          successful_read = reader.ReadUInt31(&current_frame_stream_id_);
           DCHECK(successful_read);
-          DCHECK(reader.IsDoneReading());
-          visitor_->OnPing(id, is_ack);
         }
-        break;
-      case WINDOW_UPDATE: {
-          uint32 delta_window_size = 0;
-          bool successful_read = true;
-          if (protocol_version() <= SPDY3) {
-            successful_read = reader.ReadUInt31(&current_frame_stream_id_);
-            DCHECK(successful_read);
-          }
-          successful_read = reader.ReadUInt32(&delta_window_size);
-          DCHECK(successful_read);
-          DCHECK(reader.IsDoneReading());
-          visitor_->OnWindowUpdate(current_frame_stream_id_,
-                                   delta_window_size);
-        }
-        break;
+        successful_read = reader.ReadUInt32(&delta_window_size);
+        DCHECK(successful_read);
+        DCHECK(reader.IsDoneReading());
+        visitor_->OnWindowUpdate(current_frame_stream_id_, delta_window_size);
+      } break;
       case BLOCKED: {
-          DCHECK_LT(SPDY3, protocol_version());
-          DCHECK(reader.IsDoneReading());
-          visitor_->OnBlocked(current_frame_stream_id_);
-        }
-        break;
+        DCHECK_LT(SPDY3, protocol_version());
+        DCHECK(reader.IsDoneReading());
+        visitor_->OnBlocked(current_frame_stream_id_);
+      } break;
       default:
         // Unreachable.
         LOG(FATAL) << "Unhandled control frame " << current_frame_type_;
     }
 
     CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
   }
   return original_len - len;
 }
 
@@ skipping 25 matching lines @@
       DCHECK(successful_read);
 
       // In SPDYv3 and up, frames also specify a status code - parse it out.
       SpdyGoAwayStatus status = GOAWAY_OK;
       if (protocol_version() >= SPDY3) {
         uint32 status_raw = GOAWAY_OK;
         successful_read = reader.ReadUInt32(&status_raw);
         DCHECK(successful_read);
         if (SpdyConstants::IsValidGoAwayStatus(protocol_version(),
                                                status_raw)) {
-          status = SpdyConstants::ParseGoAwayStatus(protocol_version(),
-                                                    status_raw);
+          status =
+              SpdyConstants::ParseGoAwayStatus(protocol_version(), status_raw);
         } else {
           DCHECK(false);
           // Throw an error for SPDY4+, keep liberal behavior
           // for earlier versions.
           if (protocol_version() > SPDY3) {
             DLOG(WARNING) << "Invalid GO_AWAY status " << status_raw;
             set_error(SPDY_INVALID_CONTROL_FRAME);
             return 0;
           }
         }
@@ skipping 194 matching lines @@
     remaining_data_length_ -= amount_to_ignore;
   }
 
   if (remaining_data_length_ == 0) {
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len - len;
 }
 
 size_t SpdyFramer::ParseHeaderBlockInBuffer(const char* header_data,
-                                          size_t header_length,
-                                          SpdyHeaderBlock* block) const {
+                                            size_t header_length,
+                                            SpdyHeaderBlock* block) const {
   SpdyFrameReader reader(header_data, header_length);
 
   // Read number of headers.
   uint32 num_headers;
   if (protocol_version() <= SPDY2) {
     uint16 temp;
     if (!reader.ReadUInt16(&temp)) {
       DVLOG(1) << "Unable to read number of headers.";
       return 0;
     }
     num_headers = temp;
   } else {
     if (!reader.ReadUInt32(&num_headers)) {
       DVLOG(1) << "Unable to read number of headers.";
       return 0;
     }
   }
 
   // Read each header.
   for (uint32 index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
     if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
-                            : !reader.ReadStringPiece32(&temp)) {
+                                      : !reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return 0;
     }
     std::string name = temp.as_string();
 
     // Read header value.
     if ((protocol_version() <= SPDY2) ? !reader.ReadStringPiece16(&temp)
-                            : !reader.ReadStringPiece32(&temp)) {
+                                      : !reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
       return 0;
     }
     std::string value = temp.as_string();
 
     // Ensure no duplicates.
     if (block->find(name) != block->end()) {
       DVLOG(1) << "Duplicate header '" << name << "' (" << index + 1 << " of "
                << num_headers << ").";
@@ skipping 17 matching lines @@
     int num_padding_fields = 0;
     if (data_ir.pad_low()) {
       flags |= DATA_FLAG_PAD_LOW;
       ++num_padding_fields;
     }
     if (data_ir.pad_high()) {
       flags |= DATA_FLAG_PAD_HIGH;
       ++num_padding_fields;
     }
 
-    const size_t size_with_padding = num_padding_fields +
-        data_ir.data().length() + data_ir.padding_payload_len() +
-        GetDataFrameMinimumSize();
+    const size_t size_with_padding =
+        num_padding_fields + data_ir.data().length() +
+        data_ir.padding_payload_len() + GetDataFrameMinimumSize();
     SpdyFrameBuilder builder(size_with_padding, protocol_version());
     builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
     if (data_ir.pad_high()) {
       builder.WriteUInt8(data_ir.padding_payload_len() >> 8);
     }
     if (data_ir.pad_low()) {
       builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
     }
     builder.WriteBytes(data_ir.data().data(), data_ir.data().length());
     if (data_ir.padding_payload_len() > 0) {
@@ skipping 35 matching lines @@
 
   SpdyFrameBuilder builder(frame_size, protocol_version());
   builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
   if (protocol_version() > SPDY3) {
     if (data_ir.pad_high()) {
       builder.WriteUInt8(data_ir.padding_payload_len() >> 8);
     }
     if (data_ir.pad_low()) {
       builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
     }
-    builder.OverwriteLength(*this,  num_padding_fields +
-        data_ir.data().length() + data_ir.padding_payload_len());
+    builder.OverwriteLength(*this,
+                            num_padding_fields + data_ir.data().length() +
+                                data_ir.padding_payload_len());
   } else {
     builder.OverwriteLength(*this, data_ir.data().length());
   }
   DCHECK_EQ(frame_size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
@@ skipping 17 matching lines @@
     DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynStreamMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
-          syn_stream.name_value_block(), &hpack_encoding);
+      hpack_encoder_.EncodeHeaderSet(syn_stream.name_value_block(),
+                                     &hpack_encoding);
     } else {
       hpack_encoder_.EncodeHeaderSetWithoutCompression(
           syn_stream.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_stream.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
     builder.WriteUInt32(syn_stream.stream_id());
     builder.WriteUInt32(syn_stream.associated_to_stream_id());
     builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
     builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
   } else {
-    builder.BeginNewFrame(*this,
-                          HEADERS,
-                          flags,
-                          syn_stream.stream_id());
+    builder.BeginNewFrame(*this, HEADERS, flags, syn_stream.stream_id());
     builder.WriteUInt32(priority);
   }
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_stream);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
-        GetSerializedLength(protocol_version(),
-                            &(syn_stream.name_value_block()));
+    const size_t payload_len =
+        protocol_version() > SPDY3
+            ? hpack_encoding.size()
+            : GetSerializedLength(protocol_version(),
+                                  &(syn_stream.name_value_block()));
     // SPDY 4 reports this compression as a SYN_STREAM compression.
-    debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
-                                          SYN_STREAM,
-                                          payload_len,
-                                          builder.length());
+    debug_visitor_->OnSendCompressedFrame(
+        syn_stream.stream_id(), SYN_STREAM, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     const SpdySynReplyIR& syn_reply) {
   uint8 flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   // In SPDY >= 4, SYN_REPLY frames are HEADERS frames, but for now
   // we never expect to have to overflow into a CONTINUATION frame.
   if (protocol_version() > SPDY3) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetSynReplyMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
-          syn_reply.name_value_block(), &hpack_encoding);
+      hpack_encoder_.EncodeHeaderSet(syn_reply.name_value_block(),
+                                     &hpack_encoding);
     } else {
       hpack_encoder_.EncodeHeaderSetWithoutCompression(
           syn_reply.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
   } else {
     size += GetSerializedLength(syn_reply.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SYN_REPLY, flags);
     builder.WriteUInt32(syn_reply.stream_id());
   } else {
-    builder.BeginNewFrame(*this,
-                          HEADERS,
-                          flags,
-                          syn_reply.stream_id());
+    builder.BeginNewFrame(*this, HEADERS, flags, syn_reply.stream_id());
   }
   if (protocol_version() < SPDY3) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_reply);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
-        GetSerializedLength(protocol_version(),
-                            &(syn_reply.name_value_block()));
-    debug_visitor_->OnSendCompressedFrame(syn_reply.stream_id(),
-                                          SYN_REPLY,
-                                          payload_len,
-                                          builder.length());
+    const size_t payload_len =
+        protocol_version() > SPDY3
+            ? hpack_encoding.size()
+            : GetSerializedLength(protocol_version(),
+                                  &(syn_reply.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(
+        syn_reply.stream_id(), SYN_REPLY, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
   // TODO(jgraettinger): For now, Chromium will support parsing RST_STREAM
   // payloads, but will not emit them. SPDY4 is used for draft HTTP/2,
   // which doesn't currently include RST_STREAM payloads. GFE flags have been
@@ skipping 35 matching lines @@
     }
   } else {
     if (settings.is_ack()) {
       flags |= SETTINGS_FLAG_ACK;
     }
   }
   const SpdySettingsIR::ValueMap* values = &(settings.values());
 
   size_t setting_size = (protocol_version() <= SPDY3 ? 8 : 5);
   // Size, in bytes, of this SETTINGS frame.
-  const size_t size = GetSettingsMinimumSize() +
-                      (values->size() * setting_size);
+  const size_t size =
+      GetSettingsMinimumSize() + (values->size() * setting_size);
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, SETTINGS, flags);
   } else {
     builder.BeginNewFrame(*this, SETTINGS, flags, 0);
   }
 
   // If this is an ACK, payload should be empty.
   if (protocol_version() > SPDY3 && settings.is_ack()) {
     return builder.take();
@@ skipping 13 matching lines @@
       }
       if (it->second.persisted) {
         setting_flags |= SETTINGS_FLAG_PERSISTED;
       }
       SettingsFlagsAndId flags_and_id(
           setting_flags,
           SpdyConstants::SerializeSettingId(protocol_version(), it->first));
       uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
       builder.WriteBytes(&id_and_flags_wire, 4);
     } else {
-      builder.WriteUInt8(SpdyConstants::SerializeSettingId(protocol_version(),
-                                                           it->first));
+      builder.WriteUInt8(
+          SpdyConstants::SerializeSettingId(protocol_version(), it->first));
     }
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
   SpdyFrameBuilder builder(GetPingSize(), protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, PING, kNoFlags);
     builder.WriteUInt32(static_cast<uint32>(ping.id()));
   } else {
     uint8 flags = 0;
     if (ping.is_ack()) {
       flags |= PING_FLAG_ACK;
     }
     builder.BeginNewFrame(*this, PING, flags, 0);
     builder.WriteUInt64(ping.id());
   }
   DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeGoAway(
     const SpdyGoAwayIR& goaway) const {
-
   // Compute the output buffer size, take opaque data into account.
   uint16 expected_length = GetGoAwayMinimumSize();
   if (protocol_version() > SPDY3) {
     expected_length += goaway.description().size();
   }
   SpdyFrameBuilder builder(expected_length, protocol_version());
 
   // Serialize the GOAWAY frame.
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, GOAWAY, kNoFlags);
@@ skipping 45 matching lines @@
     if (priority > GetLowestPriority()) {
       DLOG(DFATAL) << "Priority out-of-bounds.";
       priority = GetLowestPriority();
     }
     size += 4;
   }
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
-          headers.name_value_block(), &hpack_encoding);
+      hpack_encoder_.EncodeHeaderSet(headers.name_value_block(),
+                                     &hpack_encoding);
     } else {
       hpack_encoder_.EncodeHeaderSetWithoutCompression(
           headers.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
     if (size > GetControlFrameBufferMaxSize()) {
       size += GetNumberRequiredContinuationFrames(size) *
               GetContinuationMinimumSize();
       flags &= ~HEADERS_FLAG_END_HEADERS;
     }
   } else {
     size += GetSerializedLength(headers.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, HEADERS, flags);
     builder.WriteUInt32(headers.stream_id());
   } else {
-    builder.BeginNewFrame(*this,
-                          HEADERS,
-                          flags,
-                          headers.stream_id());
+    builder.BeginNewFrame(*this, HEADERS, flags, headers.stream_id());
     if (headers.has_priority()) {
       builder.WriteUInt32(priority);
     }
   }
   if (protocol_version() <= SPDY2) {
     builder.WriteUInt16(0);  // Unused.
   }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   if (protocol_version() > SPDY3) {
-    WritePayloadWithContinuation(&builder,
-                                 hpack_encoding,
-                                 headers.stream_id(),
-                                 HEADERS);
+    WritePayloadWithContinuation(
+        &builder, hpack_encoding, headers.stream_id(), HEADERS);
   } else {
     SerializeNameValueBlock(&builder, headers);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
-        GetSerializedLength(protocol_version(),
-                            &(headers.name_value_block()));
-    debug_visitor_->OnSendCompressedFrame(headers.stream_id(),
-                                          HEADERS,
-                                          payload_len,
-                                          builder.length());
+    const size_t payload_len =
+        protocol_version() > SPDY3
+            ? hpack_encoding.size()
+            : GetSerializedLength(protocol_version(),
+                                  &(headers.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(
+        headers.stream_id(), HEADERS, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeWindowUpdate(
     const SpdyWindowUpdateIR& window_update) const {
   SpdyFrameBuilder builder(GetWindowUpdateSize(), protocol_version());
   if (protocol_version() <= SPDY3) {
     builder.WriteControlFrameHeader(*this, WINDOW_UPDATE, kNoFlags);
     builder.WriteUInt32(window_update.stream_id());
   } else {
-    builder.BeginNewFrame(*this,
-                          WINDOW_UPDATE,
-                          kNoFlags,
-                          window_update.stream_id());
+    builder.BeginNewFrame(
+        *this, WINDOW_UPDATE, kNoFlags, window_update.stream_id());
   }
   builder.WriteUInt32(window_update.delta());
   DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializeBlocked(const SpdyBlockedIR& blocked) const {
   DCHECK_LT(SPDY3, protocol_version());
   SpdyFrameBuilder builder(GetBlockedSize(), protocol_version());
   builder.BeginNewFrame(*this, BLOCKED, kNoFlags, blocked.stream_id());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   DCHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   // TODO(mlavan): If we overflow into a CONTINUATION frame, this will
   // get overwritten below, so we should probably just get rid of the
   // end_push_promise field.
   if (push_promise.end_push_promise()) {
     flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   }
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   string hpack_encoding;
   if (protocol_version() > SPDY3) {
     if (enable_compression_) {
-      hpack_encoder_.EncodeHeaderSet(
-          push_promise.name_value_block(), &hpack_encoding);
+      hpack_encoder_.EncodeHeaderSet(push_promise.name_value_block(),
+                                     &hpack_encoding);
     } else {
       hpack_encoder_.EncodeHeaderSetWithoutCompression(
           push_promise.name_value_block(), &hpack_encoding);
     }
     size += hpack_encoding.size();
     if (size > GetControlFrameBufferMaxSize()) {
       size += GetNumberRequiredContinuationFrames(size) *
               GetContinuationMinimumSize();
       flags &= ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
     }
   } else {
     size += GetSerializedLength(push_promise.name_value_block());
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
-  builder.BeginNewFrame(*this,
-                        PUSH_PROMISE,
-                        flags,
-                        push_promise.stream_id());
+  builder.BeginNewFrame(*this, PUSH_PROMISE, flags, push_promise.stream_id());
   builder.WriteUInt32(push_promise.promised_stream_id());
   DCHECK_EQ(GetPushPromiseMinimumSize(), builder.length());
 
   if (protocol_version() > SPDY3) {
-    WritePayloadWithContinuation(&builder,
-                                 hpack_encoding,
-                                 push_promise.stream_id(),
-                                 PUSH_PROMISE);
+    WritePayloadWithContinuation(
+        &builder, hpack_encoding, push_promise.stream_id(), PUSH_PROMISE);
   } else {
     SerializeNameValueBlock(&builder, push_promise);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
-        GetSerializedLength(protocol_version(),
-                            &(push_promise.name_value_block()));
-    debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
-        PUSH_PROMISE, payload_len, builder.length());
+    const size_t payload_len =
+        protocol_version() > SPDY3
+            ? hpack_encoding.size()
+            : GetSerializedLength(protocol_version(),
+                                  &(push_promise.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(
+        push_promise.stream_id(), PUSH_PROMISE, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 // TODO(jgraettinger): This implementation is incorrect. The continuation
 // frame continues a previously-begun HPACK encoding; it doesn't begin a
 // new one. Figure out whether it makes sense to keep SerializeContinuation().
 SpdyFrame* SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) {
   CHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   if (continuation.end_headers()) {
     flags |= HEADERS_FLAG_END_HEADERS;
   }
 
   // The size of this frame, including variable-length name-value block.
   size_t size = GetContinuationMinimumSize();
   string hpack_encoding;
   if (enable_compression_) {
-    hpack_encoder_.EncodeHeaderSet(
-        continuation.name_value_block(), &hpack_encoding);
+    hpack_encoder_.EncodeHeaderSet(continuation.name_value_block(),
+                                   &hpack_encoding);
   } else {
     hpack_encoder_.EncodeHeaderSetWithoutCompression(
         continuation.name_value_block(), &hpack_encoding);
   }
   size += hpack_encoding.size();
 
   SpdyFrameBuilder builder(size, protocol_version());
-  builder.BeginNewFrame(*this, CONTINUATION, flags,
-      continuation.stream_id());
+  builder.BeginNewFrame(*this, CONTINUATION, flags, continuation.stream_id());
   DCHECK_EQ(GetContinuationMinimumSize(), builder.length());
 
   builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
 
   if (debug_visitor_) {
     const size_t payload_len = hpack_encoding.size();
-    debug_visitor_->OnSendCompressedFrame(continuation.stream_id(),
-        CONTINUATION, payload_len, builder.length());
+    debug_visitor_->OnSendCompressedFrame(
+        continuation.stream_id(), CONTINUATION, payload_len, builder.length());
   }
 
   return builder.take();
 }
 
 namespace {
 
 class FrameSerializationVisitor : public SpdyFrameVisitor {
  public:
   explicit FrameSerializationVisitor(SpdyFramer* framer) : framer_(framer) {}
@@ skipping 50 matching lines @@
 
 SpdySerializedFrame* SpdyFramer::SerializeFrame(const SpdyFrameIR& frame) {
   FrameSerializationVisitor visitor(this);
   frame.Visit(&visitor);
   return visitor.ReleaseSerializedFrame();
 }
 
 size_t SpdyFramer::GetSerializedLength(const SpdyHeaderBlock& headers) {
   CHECK_GE(SPDY3, protocol_version());
   const size_t uncompressed_length =
-    GetSerializedLength(protocol_version(), &headers);
+      GetSerializedLength(protocol_version(), &headers);
   if (!enable_compression_) {
     return uncompressed_length;
   }
   z_stream* compressor = GetHeaderCompressor();
   // Since we'll be performing lots of flushes when compressing the data,
   // zlib's lower bounds may be insufficient.
   return 2 * deflateBound(compressor, uncompressed_length);
 }
 
 size_t SpdyFramer::GetNumberRequiredContinuationFrames(size_t size) {
   const size_t kMaxControlFrameSize = GetControlFrameBufferMaxSize();
   DCHECK_GT(protocol_version(), SPDY3);
   DCHECK_GT(size, kMaxControlFrameSize);
   size_t overflow = size - kMaxControlFrameSize;
   return overflow / (kMaxControlFrameSize - GetContinuationMinimumSize()) + 1;
 }
 
 void SpdyFramer::WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                               const string& hpack_encoding,
                                               SpdyStreamId stream_id,
                                               SpdyFrameType type) {
   const size_t kMaxControlFrameSize = GetControlFrameBufferMaxSize();
 
-    // In addition to the prefix, fixed_field_size includes the size of
-    // any fields that come before the variable-length name/value block.
-    size_t fixed_field_size = 0;
-    uint8 end_flag = 0;
-    uint8 flags = 0;
-    if (type == HEADERS) {
-      fixed_field_size = GetHeadersMinimumSize();
-      end_flag = HEADERS_FLAG_END_HEADERS;
-    } else if (type == PUSH_PROMISE) {
-      fixed_field_size = GetPushPromiseMinimumSize();
-      end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
-    } else {
-      DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
-                  << FrameTypeToString(type);
+  // In addition to the prefix, fixed_field_size includes the size of
+  // any fields that come before the variable-length name/value block.
+  size_t fixed_field_size = 0;
+  uint8 end_flag = 0;
+  uint8 flags = 0;
+  if (type == HEADERS) {
+    fixed_field_size = GetHeadersMinimumSize();
+    end_flag = HEADERS_FLAG_END_HEADERS;
+  } else if (type == PUSH_PROMISE) {
+    fixed_field_size = GetPushPromiseMinimumSize();
+    end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
+  } else {
+    DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
+                << FrameTypeToString(type);
+  }
+
+  // Write as much of the payload as possible into the initial frame.
+  size_t bytes_remaining =
+      hpack_encoding.size() -
+      std::min(hpack_encoding.size(), kMaxControlFrameSize - fixed_field_size);
+  builder->WriteBytes(&hpack_encoding[0],
+                      hpack_encoding.size() - bytes_remaining);
+
+  if (bytes_remaining > 0) {
+    builder->OverwriteLength(
+        *this, kMaxControlFrameSize - GetControlFrameHeaderSize());
+  }
+
+  // Tack on CONTINUATION frames for the overflow.
+  while (bytes_remaining > 0) {
+    size_t bytes_to_write = std::min(
+        bytes_remaining, kMaxControlFrameSize - GetContinuationMinimumSize());
+    // Write CONTINUATION frame prefix.
+    if (bytes_remaining == bytes_to_write) {
+      flags |= end_flag;
     }
-
-    // Write as much of the payload as possible into the initial frame.
-    size_t bytes_remaining = hpack_encoding.size() -
-        std::min(hpack_encoding.size(),
-                 kMaxControlFrameSize - fixed_field_size);
-    builder->WriteBytes(&hpack_encoding[0],
-                        hpack_encoding.size() - bytes_remaining);
-
-    if (bytes_remaining > 0) {
-      builder->OverwriteLength(*this,
-          kMaxControlFrameSize - GetControlFrameHeaderSize());
-    }
-
-    // Tack on CONTINUATION frames for the overflow.
-    while (bytes_remaining > 0) {
-      size_t bytes_to_write = std::min(bytes_remaining,
-                                       kMaxControlFrameSize -
-                                       GetContinuationMinimumSize());
-      // Write CONTINUATION frame prefix.
-      if (bytes_remaining == bytes_to_write) {
-        flags |= end_flag;
-      }
-      builder->BeginNewFrame(*this,
-                             CONTINUATION,
-                             flags,
-                             stream_id);
-      // Write payload fragment.
-      builder->WriteBytes(&hpack_encoding[hpack_encoding.size() -
-                                          bytes_remaining],
-                          bytes_to_write);
-      bytes_remaining -= bytes_to_write;
-    }
+    builder->BeginNewFrame(*this, CONTINUATION, flags, stream_id);
+    // Write payload fragment.
+    builder->WriteBytes(
+        &hpack_encoding[hpack_encoding.size() - bytes_remaining],
+        bytes_to_write);
+    bytes_remaining -= bytes_to_write;
+  }
 }
 
 // The following compression setting are based on Brian Olson's analysis. See
 // https://groups.google.com/group/spdy-dev/browse_thread/thread/dfaf498542fac792
 // for more details.
 #if defined(USE_SYSTEM_ZLIB)
 // System zlib is not expected to have workaround for http://crbug.com/139744,
 // so disable compression in that case.
 // TODO(phajdan.jr): Remove the special case when it's no longer necessary.
 static const int kCompressorLevel = 0;
-#else  // !defined(USE_SYSTEM_ZLIB)
+#else   // !defined(USE_SYSTEM_ZLIB)
 static const int kCompressorLevel = 9;
 #endif  // !defined(USE_SYSTEM_ZLIB)
 static const int kCompressorWindowSizeInBits = 11;
 static const int kCompressorMemLevel = 1;
 
 z_stream* SpdyFramer::GetHeaderCompressor() {
   if (header_compressor_.get())
     return header_compressor_.get();  // Already initialized.
 
   header_compressor_.reset(new z_stream);
   memset(header_compressor_.get(), 0, sizeof(z_stream));
 
   int success = deflateInit2(header_compressor_.get(),
                              kCompressorLevel,
                              Z_DEFLATED,
                              kCompressorWindowSizeInBits,
                              kCompressorMemLevel,
                              Z_DEFAULT_STRATEGY);
   if (success == Z_OK) {
-    const char* dictionary = (protocol_version() <= SPDY2) ?
-        kV2Dictionary : kV3Dictionary;
-    const int dictionary_size = (protocol_version() <= SPDY2) ?
-        kV2DictionarySize : kV3DictionarySize;
+    const char* dictionary =
+        (protocol_version() <= SPDY2) ? kV2Dictionary : kV3Dictionary;
+    const int dictionary_size =
+        (protocol_version() <= SPDY2) ? kV2DictionarySize : kV3DictionarySize;
     success = deflateSetDictionary(header_compressor_.get(),
                                    reinterpret_cast<const Bytef*>(dictionary),
                                    dictionary_size);
   }
   if (success != Z_OK) {
     LOG(WARNING) << "deflateSetDictionary failure: " << success;
     header_compressor_.reset(NULL);
     return NULL;
   }
   return header_compressor_.get();
@@ skipping 39 matching lines @@
   // If we get a SYN_STREAM/SYN_REPLY/HEADERS frame with stream ID zero, we
   // signal an error back in ProcessControlFrameBeforeHeaderBlock.  So if we've
   // reached this method successfully, stream_id should be nonzero.
   DCHECK_LT(0u, stream_id);
   while (decomp->avail_in > 0 && processed_successfully) {
     decomp->next_out = reinterpret_cast<Bytef*>(buffer);
     decomp->avail_out = arraysize(buffer);
 
     int rv = inflate(decomp, Z_SYNC_FLUSH);
     if (rv == Z_NEED_DICT) {
-      const char* dictionary = (protocol_version() <= SPDY2) ? kV2Dictionary
-                                                             : kV3Dictionary;
-      const int dictionary_size = (protocol_version() <= SPDY2) ?
-          kV2DictionarySize : kV3DictionarySize;
+      const char* dictionary =
+          (protocol_version() <= SPDY2) ? kV2Dictionary : kV3Dictionary;
+      const int dictionary_size =
+          (protocol_version() <= SPDY2) ? kV2DictionarySize : kV3DictionarySize;
       const DictionaryIds& ids = g_dictionary_ids.Get();
-      const uLong dictionary_id = (protocol_version() <= SPDY2) ?
-          ids.v2_dictionary_id : ids.v3_dictionary_id;
+      const uLong dictionary_id = (protocol_version() <= SPDY2)
+                                      ? ids.v2_dictionary_id
+                                      : ids.v3_dictionary_id;
       // Need to try again with the right dictionary.
       if (decomp->adler == dictionary_id) {
         rv = inflateSetDictionary(decomp,
                                   reinterpret_cast<const Bytef*>(dictionary),
                                   dictionary_size);
         if (rv == Z_OK)
           rv = inflate(decomp, Z_SYNC_FLUSH);
       }
     }
 
@@ skipping 16 matching lines @@
     } else {
       DLOG(WARNING) << "inflate failure: " << rv << " " << len;
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   }
   return processed_successfully;
 }
 
 bool SpdyFramer::IncrementallyDeliverControlFrameHeaderData(
-    SpdyStreamId stream_id, const char* data, size_t len) {
+    SpdyStreamId stream_id,
+    const char* data,
+    size_t len) {
   bool read_successfully = true;
   while (read_successfully && len > 0) {
     size_t bytes_to_deliver = std::min(len, kHeaderDataChunkMaxSize);
-    read_successfully = visitor_->OnControlFrameHeaderData(stream_id, data,
-                                                           bytes_to_deliver);
+    read_successfully =
+        visitor_->OnControlFrameHeaderData(stream_id, data, bytes_to_deliver);
     data += bytes_to_deliver;
     len -= bytes_to_deliver;
     if (!read_successfully) {
       // Assume that the problem was the header block was too large for the
       // visitor.
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
 }
@@ skipping 25 matching lines @@
 void SpdyFramer::SerializeNameValueBlock(
     SpdyFrameBuilder* builder,
     const SpdyFrameWithNameValueBlockIR& frame) {
   CHECK_GE(SPDY3, protocol_version());
   if (!enable_compression_) {
     return SerializeNameValueBlockWithoutCompression(builder,
                                                      frame.name_value_block());
   }
 
   // First build an uncompressed version to be fed into the compressor.
-  const size_t uncompressed_len = GetSerializedLength(
-      protocol_version(), &(frame.name_value_block()));
+  const size_t uncompressed_len =
+      GetSerializedLength(protocol_version(), &(frame.name_value_block()));
   SpdyFrameBuilder uncompressed_builder(uncompressed_len, protocol_version());
   SerializeNameValueBlockWithoutCompression(&uncompressed_builder,
                                             frame.name_value_block());
   scoped_ptr<SpdyFrame> uncompressed_payload(uncompressed_builder.take());
 
   z_stream* compressor = GetHeaderCompressor();
   if (!compressor) {
     LOG(DFATAL) << "Could not obtain compressor.";
     return;
   }
 
   base::StatsCounter compressed_frames("spdy.CompressedFrames");
   base::StatsCounter pre_compress_bytes("spdy.PreCompressSize");
   base::StatsCounter post_compress_bytes("spdy.PostCompressSize");
 
   // Create an output frame.
   // Since we'll be performing lots of flushes when compressing the data,
   // zlib's lower bounds may be insufficient.
   //
   // TODO(akalin): Avoid the duplicate calculation with
   // GetSerializedLength(const SpdyHeaderBlock&).
   const int compressed_max_size =
       2 * deflateBound(compressor, uncompressed_len);
 
-  // TODO(phajdan.jr): Clean up after we no longer need
-  // to workaround http://crbug.com/139744.
+// TODO(phajdan.jr): Clean up after we no longer need
+// to workaround http://crbug.com/139744.
 #if defined(USE_SYSTEM_ZLIB)
   compressor->next_in = reinterpret_cast<Bytef*>(uncompressed_payload->data());
   compressor->avail_in = uncompressed_len;
 #endif  // defined(USE_SYSTEM_ZLIB)
-  compressor->next_out = reinterpret_cast<Bytef*>(
-      builder->GetWritableBuffer(compressed_max_size));
+  compressor->next_out =
+      reinterpret_cast<Bytef*>(builder->GetWritableBuffer(compressed_max_size));
   compressor->avail_out = compressed_max_size;
 
-  // TODO(phajdan.jr): Clean up after we no longer need
-  // to workaround http://crbug.com/139744.
+// TODO(phajdan.jr): Clean up after we no longer need
+// to workaround http://crbug.com/139744.
 #if defined(USE_SYSTEM_ZLIB)
   int rv = deflate(compressor, Z_SYNC_FLUSH);
   if (rv != Z_OK) {  // How can we know that it compressed everything?
     // This shouldn't happen, right?
     LOG(WARNING) << "deflate failure: " << rv;
     // TODO(akalin): Upstream this return.
     return;
   }
 #else
   WriteHeaderBlockToZ(&frame.name_value_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net