Clang format slam.

net/quic/quic_headers_stream.cc

 // Copyright 2013 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/quic/quic_headers_stream.h"
 
 #include "net/quic/quic_session.h"
 
 using base::StringPiece;
 
@@ skipping 136 matching lines @@
                                         SpdyFrameType type,
                                         size_t frame_len) OVERRIDE {
     if (stream_->IsConnected()) {
       stream_->OnCompressedFrameSize(frame_len);
     }
   }
 
  private:
   void CloseConnection(const string& details) {
     if (stream_->IsConnected()) {
-      stream_->CloseConnectionWithDetails(
-          QUIC_INVALID_HEADERS_STREAM_DATA, details);
+      stream_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                          details);
     }
   }
 
  private:
   QuicHeadersStream* stream_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 };
 
 QuicHeadersStream::QuicHeadersStream(QuicSession* session)
     : ReliableQuicStream(kHeadersStreamId, session),
       stream_id_(kInvalidStreamId),
       fin_(false),
       frame_len_(0),
       spdy_framer_(SPDY3),
       spdy_framer_visitor_(new SpdyFramerVisitor(this)) {
   spdy_framer_.set_visitor(spdy_framer_visitor_.get());
   spdy_framer_.set_debug_visitor(spdy_framer_visitor_.get());
   DisableFlowControl();
 }
 
-QuicHeadersStream::~QuicHeadersStream() {}
+QuicHeadersStream::~QuicHeadersStream() {
+}
 
 size_t QuicHeadersStream::WriteHeaders(
     QuicStreamId stream_id,
     const SpdyHeaderBlock& headers,
     bool fin,
     QuicAckNotifier::DelegateInterface* ack_notifier_delegate) {
   scoped_ptr<SpdySerializedFrame> frame;
   if (session()->is_server()) {
     SpdySynReplyIR syn_reply(stream_id);
     syn_reply.set_name_value_block(headers);
     syn_reply.set_fin(fin);
     frame.reset(spdy_framer_.SerializeFrame(syn_reply));
   } else {
     SpdySynStreamIR syn_stream(stream_id);
     syn_stream.set_name_value_block(headers);
     syn_stream.set_fin(fin);
     frame.reset(spdy_framer_.SerializeFrame(syn_stream));
   }
-  WriteOrBufferData(StringPiece(frame->data(), frame->size()), false,
-                    ack_notifier_delegate);
+  WriteOrBufferData(
+      StringPiece(frame->data(), frame->size()), false, ack_notifier_delegate);
   return frame->size();
 }
 
-uint32 QuicHeadersStream::ProcessRawData(const char* data,
-                                         uint32 data_len) {
+uint32 QuicHeadersStream::ProcessRawData(const char* data, uint32 data_len) {
   return spdy_framer_.ProcessInput(data, data_len);
 }
 
-QuicPriority QuicHeadersStream::EffectivePriority() const { return 0; }
+QuicPriority QuicHeadersStream::EffectivePriority() const {
+  return 0;
+}
 
 void QuicHeadersStream::OnSynStream(SpdyStreamId stream_id,
                                     SpdyPriority priority,
                                     bool fin) {
   if (!session()->is_server()) {
-    CloseConnectionWithDetails(
-        QUIC_INVALID_HEADERS_STREAM_DATA,
-        "SPDY SYN_STREAM frame received at the client");
+    CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
+                               "SPDY SYN_STREAM frame received at the client");
     return;
   }
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
   session()->OnStreamHeadersPriority(stream_id, priority);
 }
 
 void QuicHeadersStream::OnSynReply(SpdyStreamId stream_id, bool fin) {
   if (session()->is_server()) {
-    CloseConnectionWithDetails(
-        QUIC_INVALID_HEADERS_STREAM_DATA,
-        "SPDY SYN_REPLY frame received at the server");
+    CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
+                               "SPDY SYN_REPLY frame received at the server");
     return;
   }
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
 }
 
 void QuicHeadersStream::OnControlFrameHeaderData(SpdyStreamId stream_id,
                                                  const char* header_data,
                                                  size_t len) {
@@ skipping 15 matching lines @@
   DCHECK_EQ(kInvalidStreamId, stream_id_);
   DCHECK_EQ(0u, frame_len_);
   frame_len_ = frame_len;
 }
 
 bool QuicHeadersStream::IsConnected() {
   return session()->connection()->connected();
 }
 
 }  // namespace net