Clang format slam.

net/spdy/spdy_stream.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_stream.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 88 matching lines @@
       request_time_(base::Time::Now()),
       response_headers_status_(RESPONSE_HEADERS_ARE_INCOMPLETE),
       io_state_(STATE_IDLE),
       response_status_(OK),
       net_log_(net_log),
       raw_received_bytes_(0),
       send_bytes_(0),
       recv_bytes_(0),
       write_handler_guard_(false) {
   CHECK(type_ == SPDY_BIDIRECTIONAL_STREAM ||
-        type_ == SPDY_REQUEST_RESPONSE_STREAM ||
-        type_ == SPDY_PUSH_STREAM);
+        type_ == SPDY_REQUEST_RESPONSE_STREAM || type_ == SPDY_PUSH_STREAM);
   CHECK_GE(priority_, MINIMUM_PRIORITY);
   CHECK_LE(priority_, MAXIMUM_PRIORITY);
 }
 
 SpdyStream::~SpdyStream() {
   CHECK(!write_handler_guard_);
   UpdateHistograms();
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(!delegate_);
   CHECK(delegate);
   delegate_ = delegate;
 
   CHECK(io_state_ == STATE_IDLE ||
         io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED);
 
   if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) {
     DCHECK_EQ(type_, SPDY_PUSH_STREAM);
     base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&SpdyStream::PushedStreamReplay, GetWeakPtr()));
+        FROM_HERE, base::Bind(&SpdyStream::PushedStreamReplay, GetWeakPtr()));
   }
 }
 
 void SpdyStream::PushedStreamReplay() {
   DCHECK_EQ(type_, SPDY_PUSH_STREAM);
   DCHECK_NE(stream_id_, 0u);
   CHECK_EQ(stream_id_ % 2, 0u);
 
   CHECK_EQ(io_state_, STATE_HALF_CLOSED_LOCAL_UNCLAIMED);
   io_state_ = STATE_HALF_CLOSED_LOCAL;
@@ skipping 47 matching lines @@
       break;
     }
   }
 }
 
 scoped_ptr<SpdyFrame> SpdyStream::ProduceSynStreamFrame() {
   CHECK_EQ(io_state_, STATE_IDLE);
   CHECK(request_headers_);
   CHECK_GT(stream_id_, 0u);
 
-  SpdyControlFlags flags =
-      (pending_send_status_ == NO_MORE_DATA_TO_SEND) ?
-      CONTROL_FLAG_FIN : CONTROL_FLAG_NONE;
+  SpdyControlFlags flags = (pending_send_status_ == NO_MORE_DATA_TO_SEND)
+                               ? CONTROL_FLAG_FIN
+                               : CONTROL_FLAG_NONE;
   scoped_ptr<SpdyFrame> frame(session_->CreateSynStream(
       stream_id_, priority_, flags, *request_headers_));
   send_time_ = base::TimeTicks::Now();
   return frame.Pass();
 }
 
 void SpdyStream::DetachDelegate() {
   DCHECK(!IsClosed());
   delegate_ = NULL;
   Cancel();
@@ skipping 41 matching lines @@
   // Ignore late WINDOW_UPDATEs.
   if (IsClosed())
     return;
 
   if (send_window_size_ > 0) {
     // Check for overflow.
     int32 max_delta_window_size = kint32max - send_window_size_;
     if (delta_window_size > max_delta_window_size) {
       std::string desc = base::StringPrintf(
           "Received WINDOW_UPDATE [delta: %d] for stream %d overflows "
-          "send_window_size_ [current: %d]", delta_window_size, stream_id_,
+          "send_window_size_ [current: %d]",
+          delta_window_size,
+          stream_id_,
           send_window_size_);
       session_->ResetStream(stream_id_, RST_STREAM_FLOW_CONTROL_ERROR, desc);
       return;
     }
   }
 
   send_window_size_ += delta_window_size;
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, delta_window_size, send_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
+                    base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
+                               stream_id_,
+                               delta_window_size,
+                               send_window_size_));
 
   PossiblyResumeIfSendStalled();
 }
 
 void SpdyStream::DecreaseSendWindowSize(int32 delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   if (IsClosed())
     return;
 
   // We only call this method when sending a frame. Therefore,
   // |delta_window_size| should be within the valid frame size range.
   DCHECK_GE(delta_window_size, 1);
   DCHECK_LE(delta_window_size, kMaxSpdyFrameChunkSize);
 
   // |send_window_size_| should have been at least |delta_window_size| for
   // this call to happen.
   DCHECK_GE(send_window_size_, delta_window_size);
 
   send_window_size_ -= delta_window_size;
 
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, -delta_window_size, send_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_UPDATE_SEND_WINDOW,
+                    base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
+                               stream_id_,
+                               -delta_window_size,
+                               send_window_size_));
 }
 
 void SpdyStream::OnReadBufferConsumed(
     size_t consume_size,
     SpdyBuffer::ConsumeSource consume_source) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(consume_size, 1u);
   DCHECK_LE(consume_size, static_cast<size_t>(kint32max));
   IncreaseRecvWindowSize(static_cast<int32>(consume_size));
 }
 
 void SpdyStream::IncreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
 
   // By the time a read is processed by the delegate, this stream may
   // already be inactive.
   if (!session_->IsStreamActive(stream_id_))
     return;
 
   DCHECK_GE(unacked_recv_window_bytes_, 0);
   DCHECK_GE(recv_window_size_, unacked_recv_window_bytes_);
   DCHECK_GE(delta_window_size, 1);
   // Check for overflow.
   DCHECK_LE(delta_window_size, kint32max - recv_window_size_);
 
   recv_window_size_ += delta_window_size;
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, delta_window_size, recv_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
+                    base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
+                               stream_id_,
+                               delta_window_size,
+                               recv_window_size_));
 
   unacked_recv_window_bytes_ += delta_window_size;
   if (unacked_recv_window_bytes_ >
       session_->stream_initial_recv_window_size() / 2) {
     session_->SendStreamWindowUpdate(
         stream_id_, static_cast<uint32>(unacked_recv_window_bytes_));
     unacked_recv_window_bytes_ = 0;
   }
 }
 
 void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK(session_->IsStreamActive(stream_id_));
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(delta_window_size, 1);
 
   // Since we never decrease the initial receive window size,
   // |delta_window_size| should never cause |recv_window_size_| to go
   // negative. If we do, the receive window isn't being respected.
   if (delta_window_size > recv_window_size_) {
     session_->ResetStream(
-        stream_id_, RST_STREAM_PROTOCOL_ERROR,
+        stream_id_,
+        RST_STREAM_PROTOCOL_ERROR,
         "delta_window_size is " + base::IntToString(delta_window_size) +
             " in DecreaseRecvWindowSize, which is larger than the receive " +
             "window size of " + base::IntToString(recv_window_size_));
     return;
   }
 
   recv_window_size_ -= delta_window_size;
-  net_log_.AddEvent(
-      NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
-      base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
-                 stream_id_, -delta_window_size, recv_window_size_));
+  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
+                    base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
+                               stream_id_,
+                               -delta_window_size,
+                               recv_window_size_));
 }
 
 int SpdyStream::GetPeerAddress(IPEndPoint* address) const {
   return session_->GetPeerAddress(address);
 }
 
 int SpdyStream::GetLocalAddress(IPEndPoint* address) const {
   return session_->GetLocalAddress(address);
 }
 
@@ skipping 16 matching lines @@
   // SpdySession guarantees that this is called at most once.
   CHECK(response_headers_.empty());
 
   // Check to make sure that we don't receive the response headers
   // before we're ready for it.
   switch (type_) {
     case SPDY_BIDIRECTIONAL_STREAM:
       // For a bidirectional stream, we're ready for the response
       // headers once we've finished sending the request headers.
       if (io_state_ == STATE_IDLE) {
-        session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
+        session_->ResetStream(stream_id_,
+                              RST_STREAM_PROTOCOL_ERROR,
                               "Response received before request sent");
         return ERR_SPDY_PROTOCOL_ERROR;
       }
       break;
 
     case SPDY_REQUEST_RESPONSE_STREAM:
       // For a request/response stream, we're ready for the response
       // headers once we've finished sending the request headers.
       if (io_state_ == STATE_IDLE) {
-        session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
+        session_->ResetStream(stream_id_,
+                              RST_STREAM_PROTOCOL_ERROR,
                               "Response received before request sent");
         return ERR_SPDY_PROTOCOL_ERROR;
       }
       break;
 
     case SPDY_PUSH_STREAM:
       // Push streams transition to a locally half-closed state upon headers.
       // We must continue to buffer data while waiting for a call to
       // SetDelegate() (which may not ever happen).
       // TODO(jgraettinger): When PUSH_PROMISE is added, Handle RESERVED_REMOTE
@@ skipping 10 matching lines @@
 
   response_time_ = response_time;
   recv_first_byte_time_ = recv_first_byte_time;
   return MergeWithResponseHeaders(initial_response_headers);
 }
 
 int SpdyStream::OnAdditionalResponseHeadersReceived(
     const SpdyHeaderBlock& additional_response_headers) {
   if (type_ == SPDY_REQUEST_RESPONSE_STREAM) {
     session_->ResetStream(
-        stream_id_, RST_STREAM_PROTOCOL_ERROR,
+        stream_id_,
+        RST_STREAM_PROTOCOL_ERROR,
         "Additional headers received for request/response stream");
     return ERR_SPDY_PROTOCOL_ERROR;
   } else if (type_ == SPDY_PUSH_STREAM &&
              response_headers_status_ == RESPONSE_HEADERS_ARE_COMPLETE) {
-    session_->ResetStream(
-        stream_id_, RST_STREAM_PROTOCOL_ERROR,
-        "Additional headers received for push stream");
+    session_->ResetStream(stream_id_,
+                          RST_STREAM_PROTOCOL_ERROR,
+                          "Additional headers received for push stream");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
   return MergeWithResponseHeaders(additional_response_headers);
 }
 
 void SpdyStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   DCHECK(session_->IsStreamActive(stream_id_));
 
   // If we're still buffering data for a push stream, we will do the
   // check for data received with incomplete headers in
@@ skipping 57 matching lines @@
 
 void SpdyStream::OnFrameWriteComplete(SpdyFrameType frame_type,
                                       size_t frame_size) {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
 
   if (frame_size < session_->GetFrameMinimumSize() ||
       frame_size > session_->GetFrameMaximumSize()) {
     NOTREACHED();
     return;
   }
-  CHECK(frame_type == SYN_STREAM ||
-        frame_type == DATA) << frame_type;
+  CHECK(frame_type == SYN_STREAM || frame_type == DATA) << frame_type;
 
-  int result = (frame_type == SYN_STREAM) ?
-      OnRequestHeadersSent() : OnDataSent(frame_size);
+  int result = (frame_type == SYN_STREAM) ? OnRequestHeadersSent()
+                                          : OnDataSent(frame_size);
   if (result == ERR_IO_PENDING) {
     // The write operation hasn't completed yet.
     return;
   }
 
   if (pending_send_status_ == NO_MORE_DATA_TO_SEND) {
-    if(io_state_ == STATE_OPEN) {
+    if (io_state_ == STATE_OPEN) {
       io_state_ = STATE_HALF_CLOSED_LOCAL;
-    } else if(io_state_ == STATE_HALF_CLOSED_REMOTE) {
+    } else if (io_state_ == STATE_HALF_CLOSED_REMOTE) {
       io_state_ = STATE_CLOSED;
     } else {
       NOTREACHED() << io_state_;
     }
   }
   // Notify delegate of write completion. Must not destroy |this|.
   CHECK(delegate_);
   {
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
     write_handler_guard_ = true;
@@ skipping 14 matching lines @@
 
 int SpdyStream::OnRequestHeadersSent() {
   CHECK_EQ(io_state_, STATE_IDLE);
   CHECK_NE(stream_id_, 0u);
 
   io_state_ = STATE_OPEN;
   return OK;
 }
 
 int SpdyStream::OnDataSent(size_t frame_size) {
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE)
+      << io_state_;
 
   size_t frame_payload_size = frame_size - session_->GetDataFrameMinimumSize();
 
   CHECK_GE(frame_size, session_->GetDataFrameMinimumSize());
   CHECK_LE(frame_payload_size, session_->GetDataFrameMaximumPayload());
 
   send_bytes_ += frame_payload_size;
 
   // If more data is available to send, dispatch it and
   // return that the write operation is still ongoing.
   pending_send_data_->DidConsume(frame_payload_size);
   if (pending_send_data_->BytesRemaining() > 0) {
     QueueNextDataFrame();
     return ERR_IO_PENDING;
   } else {
     pending_send_data_ = NULL;
     return OK;
   }
 }
 
 SpdyMajorVersion SpdyStream::GetProtocolVersion() const {
   return session_->GetProtocolVersion();
 }
 
 void SpdyStream::LogStreamError(int status, const std::string& description) {
-  net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ERROR,
-                    base::Bind(&NetLogSpdyStreamErrorCallback,
-                               stream_id_, status, &description));
+  net_log_.AddEvent(
+      NetLog::TYPE_SPDY_STREAM_ERROR,
+      base::Bind(
+          &NetLogSpdyStreamErrorCallback, stream_id_, status, &description));
 }
 
 void SpdyStream::OnClose(int status) {
   // In most cases, the stream should already be CLOSED. The exception is when a
   // SpdySession is shutting down while the stream is in an intermediate state.
   io_state_ = STATE_CLOSED;
   response_status_ = status;
   Delegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate)
@@ skipping 34 matching lines @@
 
 int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> request_headers,
                                    SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND);
   CHECK(!request_headers_);
   CHECK(!pending_send_data_.get());
   CHECK_EQ(io_state_, STATE_IDLE);
   request_headers_ = request_headers.Pass();
   pending_send_status_ = send_status;
-  session_->EnqueueStreamWrite(
-      GetWeakPtr(), SYN_STREAM,
-      scoped_ptr<SpdyBufferProducer>(
-          new SynStreamBufferProducer(GetWeakPtr())));
+  session_->EnqueueStreamWrite(GetWeakPtr(),
+                               SYN_STREAM,
+                               scoped_ptr<SpdyBufferProducer>(
+                                   new SynStreamBufferProducer(GetWeakPtr())));
   return ERR_IO_PENDING;
 }
 
 void SpdyStream::SendData(IOBuffer* data,
                           int length,
                           SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND);
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE)
+      << io_state_;
   CHECK(!pending_send_data_.get());
   pending_send_data_ = new DrainableIOBuffer(data, length);
   pending_send_status_ = send_status;
   QueueNextDataFrame();
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info,
                             bool* was_npn_negotiated,
                             NextProto* protocol_negotiated) {
   return session_->GetSSLInfo(
       ssl_info, was_npn_negotiated, protocol_negotiated);
 }
 
 bool SpdyStream::GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) {
   return session_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 void SpdyStream::PossiblyResumeIfSendStalled() {
   if (IsLocallyClosed()) {
     return;
   }
   if (send_stalled_by_flow_control_ && !session_->IsSendStalled() &&
       send_window_size_ > 0) {
-    net_log_.AddEvent(
-        NetLog::TYPE_SPDY_STREAM_FLOW_CONTROL_UNSTALLED,
-        NetLog::IntegerCallback("stream_id", stream_id_));
+    net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_FLOW_CONTROL_UNSTALLED,
+                      NetLog::IntegerCallback("stream_id", stream_id_));
     send_stalled_by_flow_control_ = false;
     QueueNextDataFrame();
   }
 }
 
 bool SpdyStream::IsClosed() const {
   return io_state_ == STATE_CLOSED;
 }
 
 bool SpdyStream::IsLocallyClosed() const {
   return io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED ||
-      io_state_ == STATE_HALF_CLOSED_LOCAL ||
-      io_state_ == STATE_CLOSED;
+         io_state_ == STATE_HALF_CLOSED_LOCAL || io_state_ == STATE_CLOSED;
 }
 
 bool SpdyStream::IsIdle() const {
   return io_state_ == STATE_IDLE;
 }
 
 bool SpdyStream::IsOpen() const {
   return io_state_ == STATE_OPEN;
 }
 
 NextProto SpdyStream::GetProtocol() const {
   return session_->protocol();
 }
 
 bool SpdyStream::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   if (stream_id_ == 0)
     return false;
 
   return session_->GetLoadTimingInfo(stream_id_, load_timing_info);
 }
 
 GURL SpdyStream::GetUrlFromHeaders() const {
   if (type_ != SPDY_PUSH_STREAM && !request_headers_)
     return GURL();
 
   const SpdyHeaderBlock& headers =
       (type_ == SPDY_PUSH_STREAM) ? response_headers_ : *request_headers_;
-  return GetUrlFromHeaderBlock(headers, GetProtocolVersion(),
-                               type_ == SPDY_PUSH_STREAM);
+  return GetUrlFromHeaderBlock(
+      headers, GetProtocolVersion(), type_ == SPDY_PUSH_STREAM);
 }
 
 bool SpdyStream::HasUrlFromHeaders() const {
   return !GetUrlFromHeaders().is_empty();
 }
 
 void SpdyStream::UpdateHistograms() {
   // We need at least the receive timers to be filled in, as otherwise
   // metrics can be bogus.
   if (recv_first_byte_time_.is_null() || recv_last_byte_time_.is_null())
@@ skipping 19 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
                       recv_last_byte_time_ - effective_send_time);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 void SpdyStream::QueueNextDataFrame() {
   // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE)
+      << io_state_;
   CHECK_GT(stream_id_, 0u);
   CHECK(pending_send_data_.get());
   CHECK_GT(pending_send_data_->BytesRemaining(), 0);
 
-  SpdyDataFlags flags =
-      (pending_send_status_ == NO_MORE_DATA_TO_SEND) ?
-      DATA_FLAG_FIN : DATA_FLAG_NONE;
+  SpdyDataFlags flags = (pending_send_status_ == NO_MORE_DATA_TO_SEND)
+                            ? DATA_FLAG_FIN
+                            : DATA_FLAG_NONE;
   scoped_ptr<SpdyBuffer> data_buffer(
       session_->CreateDataBuffer(stream_id_,
                                  pending_send_data_.get(),
                                  pending_send_data_->BytesRemaining(),
                                  flags));
   // We'll get called again by PossiblyResumeIfSendStalled().
   if (!data_buffer)
     return;
 
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     DCHECK_GE(data_buffer->GetRemainingSize(),
               session_->GetDataFrameMinimumSize());
     size_t payload_size =
         data_buffer->GetRemainingSize() - session_->GetDataFrameMinimumSize();
     DCHECK_LE(payload_size, session_->GetDataFrameMaximumPayload());
     DecreaseSendWindowSize(static_cast<int32>(payload_size));
     // This currently isn't strictly needed, since write frames are
     // discarded only if the stream is about to be closed. But have it
     // here anyway just in case this changes.
-    data_buffer->AddConsumeCallback(
-        base::Bind(&SpdyStream::OnWriteBufferConsumed,
-                   GetWeakPtr(), payload_size));
+    data_buffer->AddConsumeCallback(base::Bind(
+        &SpdyStream::OnWriteBufferConsumed, GetWeakPtr(), payload_size));
   }
 
   session_->EnqueueStreamWrite(
-      GetWeakPtr(), DATA,
+      GetWeakPtr(),
+      DATA,
       scoped_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(data_buffer.Pass())));
 }
 
 int SpdyStream::MergeWithResponseHeaders(
     const SpdyHeaderBlock& new_response_headers) {
   if (new_response_headers.find("transfer-encoding") !=
       new_response_headers.end()) {
-    session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
-                         "Received transfer-encoding header");
+    session_->ResetStream(stream_id_,
+                          RST_STREAM_PROTOCOL_ERROR,
+                          "Received transfer-encoding header");
     return ERR_SPDY_PROTOCOL_ERROR;
   }
 
   for (SpdyHeaderBlock::const_iterator it = new_response_headers.begin();
-      it != new_response_headers.end(); ++it) {
+       it != new_response_headers.end();
+       ++it) {
     // Disallow uppercase headers.
     if (ContainsUppercaseAscii(it->first)) {
-      session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
+      session_->ResetStream(stream_id_,
+                            RST_STREAM_PROTOCOL_ERROR,
                             "Upper case characters in header: " + it->first);
       return ERR_SPDY_PROTOCOL_ERROR;
     }
 
     SpdyHeaderBlock::iterator it2 = response_headers_.lower_bound(it->first);
     // Disallow duplicate headers.  This is just to be conservative.
     if (it2 != response_headers_.end() && it2->first == it->first) {
-      session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
+      session_->ResetStream(stream_id_,
+                            RST_STREAM_PROTOCOL_ERROR,
                             "Duplicate header: " + it->first);
       return ERR_SPDY_PROTOCOL_ERROR;
     }
 
     response_headers_.insert(it2, *it);
   }
 
   // If delegate_ is not yet attached, we'll call
   // OnResponseHeadersUpdated() after the delegate gets attached to
   // the stream.
   if (delegate_) {
     // The call to OnResponseHeadersUpdated() below may delete |this|,
     // so use |weak_this| to detect that.
     base::WeakPtr<SpdyStream> weak_this = GetWeakPtr();
 
     SpdyResponseHeadersStatus status =
         delegate_->OnResponseHeadersUpdated(response_headers_);
     if (status == RESPONSE_HEADERS_ARE_INCOMPLETE) {
       // Since RESPONSE_HEADERS_ARE_INCOMPLETE was returned, we must not
       // have been closed.
       CHECK(weak_this);
       // Incomplete headers are OK only for push streams.
       if (type_ != SPDY_PUSH_STREAM) {
-        session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
-                              "Incomplete headers");
+        session_->ResetStream(
+            stream_id_, RST_STREAM_PROTOCOL_ERROR, "Incomplete headers");
         return ERR_INCOMPLETE_SPDY_HEADERS;
       }
     } else if (weak_this) {
       response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE;
     }
   }
 
   return OK;
 }
 
-#define STATE_CASE(s) \
-  case s: \
+#define STATE_CASE(s)                                       \
+  case s:                                                   \
     description = base::StringPrintf("%s (0x%08X)", #s, s); \
     break
 
 std::string SpdyStream::DescribeState(State state) {
   std::string description;
   switch (state) {
     STATE_CASE(STATE_IDLE);
     STATE_CASE(STATE_OPEN);
     STATE_CASE(STATE_HALF_CLOSED_LOCAL_UNCLAIMED);
     STATE_CASE(STATE_HALF_CLOSED_LOCAL);
     STATE_CASE(STATE_CLOSED);
     default:
-      description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
-                                       state);
+      description =
+          base::StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net