Clang format slam.

net/spdy/spdy_protocol.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_protocol.h"
 
 namespace net {
 
 SpdyFrameWithNameValueBlockIR::SpdyFrameWithNameValueBlockIR(
-    SpdyStreamId stream_id) : SpdyFrameWithFinIR(stream_id) {}
+    SpdyStreamId stream_id)
+    : SpdyFrameWithFinIR(stream_id) {
+}
 
-SpdyFrameWithNameValueBlockIR::~SpdyFrameWithNameValueBlockIR() {}
+SpdyFrameWithNameValueBlockIR::~SpdyFrameWithNameValueBlockIR() {
+}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data)
     : SpdyFrameWithFinIR(stream_id),
       pad_low_(false),
       pad_high_(false),
       padding_payload_len_(0) {
   SetDataDeep(data);
 }
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id)
     : SpdyFrameWithFinIR(stream_id),
       pad_low_(false),
       pad_high_(false),
-      padding_payload_len_(0) {}
+      padding_payload_len_(0) {
+}
 
-SpdyDataIR::~SpdyDataIR() {}
+SpdyDataIR::~SpdyDataIR() {
+}
 
 bool SpdyConstants::IsValidFrameType(SpdyMajorVersion version,
                                      int frame_type_field) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       // SYN_STREAM is the first valid frame.
       if (frame_type_field < SerializeFrameType(version, SYN_STREAM)) {
         return false;
       }
@@ skipping 218 matching lines @@
           return SETTINGS_INITIAL_WINDOW_SIZE;
       }
       break;
   }
 
   LOG(DFATAL) << "Unhandled setting ID " << setting_id_field;
   return SETTINGS_UPLOAD_BANDWIDTH;
 }
 
 int SpdyConstants::SerializeSettingId(SpdyMajorVersion version,
-                                       SpdySettingsIds id) {
+                                      SpdySettingsIds id) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       switch (id) {
         case SETTINGS_UPLOAD_BANDWIDTH:
           return 1;
         case SETTINGS_DOWNLOAD_BANDWIDTH:
           return 2;
         case SETTINGS_ROUND_TRIP_TIME:
           return 3;
@@ skipping 161 matching lines @@
           return 7;
         case RST_STREAM_STREAM_IN_USE:
           return 8;
         case RST_STREAM_STREAM_ALREADY_CLOSED:
           return 9;
         case RST_STREAM_INVALID_CREDENTIALS:
           return 10;
         case RST_STREAM_FRAME_TOO_LARGE:
           return 11;
         default:
-          LOG(DFATAL) << "Unhandled RST_STREAM status "
-                      << rst_stream_status;
+          LOG(DFATAL) << "Unhandled RST_STREAM status " << rst_stream_status;
           return -1;
       }
     case SPDY4:
     case SPDY5:
       switch (rst_stream_status) {
         case RST_STREAM_PROTOCOL_ERROR:
           return 1;
         case RST_STREAM_INTERNAL_ERROR:
           return 2;
         case RST_STREAM_FLOW_CONTROL_ERROR:
           return 3;
         case RST_STREAM_STREAM_CLOSED:
           return 5;
         case RST_STREAM_FRAME_SIZE_ERROR:
           return 6;
         case RST_STREAM_REFUSED_STREAM:
           return 7;
         case RST_STREAM_CANCEL:
           return 8;
         case RST_STREAM_CONNECT_ERROR:
           return 10;
         case RST_STREAM_ENHANCE_YOUR_CALM:
           return 11;
         default:
-          LOG(DFATAL) << "Unhandled RST_STREAM status "
-                      << rst_stream_status;
+          LOG(DFATAL) << "Unhandled RST_STREAM status " << rst_stream_status;
           return -1;
       }
   }
   LOG(DFATAL) << "Unhandled SPDY version " << version;
   return -1;
 }
 
 bool SpdyConstants::IsValidGoAwayStatus(SpdyMajorVersion version,
                                         int goaway_status_field) {
   switch (version) {
     case SPDY2:
     case SPDY3:
       // GOAWAY_OK is the first valid status.
       if (goaway_status_field < SerializeGoAwayStatus(version, GOAWAY_OK)) {
         return false;
       }
 
       // GOAWAY_INTERNAL_ERROR is the last valid status.
-      if (goaway_status_field > SerializeGoAwayStatus(version,
-                                                      GOAWAY_INTERNAL_ERROR)) {
+      if (goaway_status_field >
+          SerializeGoAwayStatus(version, GOAWAY_INTERNAL_ERROR)) {
         return false;
       }
 
       return true;
     case SPDY4:
     case SPDY5:
       // GOAWAY_NO_ERROR is the first valid status.
-      if (goaway_status_field < SerializeGoAwayStatus(version,
-                                                      GOAWAY_NO_ERROR)) {
+      if (goaway_status_field <
+          SerializeGoAwayStatus(version, GOAWAY_NO_ERROR)) {
         return false;
       }
 
       // GOAWAY_INADEQUATE_SECURITY is the last valid status.
       if (goaway_status_field >
           SerializeGoAwayStatus(version, GOAWAY_INADEQUATE_SECURITY)) {
         return false;
       }
 
       return true;
@@ skipping 167 matching lines @@
     case SPDY5:
       return 8;
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,
                                       SpdyMajorVersion version) {
   if (type != DATA) {
-     return GetControlFrameHeaderSize(version);
+    return GetControlFrameHeaderSize(version);
   } else {
-     return GetDataFrameMinimumSize();
+    return GetDataFrameMinimumSize();
   }
 }
 
 size_t SpdyConstants::GetFrameMaximumSize(SpdyMajorVersion version) {
   if (version < SPDY4) {
     // 24-bit length field plus eight-byte frame header.
-    return ((1<<24) - 1) + 8;
+    return ((1 << 24) - 1) + 8;
   } else {
     // 14-bit length field.
-    return (1<<14) - 1;
+    return (1 << 14) - 1;
   }
 }
 
 void SpdyDataIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitData(*this);
 }
 
 void SpdySynStreamIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSynStream(*this);
 }
 
 void SpdySynReplyIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSynReply(*this);
 }
 
 SpdyRstStreamIR::SpdyRstStreamIR(SpdyStreamId stream_id,
                                  SpdyRstStreamStatus status,
                                  base::StringPiece description)
-    : SpdyFrameWithStreamIdIR(stream_id),
-      description_(description) {
+    : SpdyFrameWithStreamIdIR(stream_id), description_(description) {
   set_status(status);
 }
 
-SpdyRstStreamIR::~SpdyRstStreamIR() {}
+SpdyRstStreamIR::~SpdyRstStreamIR() {
+}
 
 void SpdyRstStreamIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitRstStream(*this);
 }
 
-SpdySettingsIR::SpdySettingsIR()
-    : clear_settings_(false),
-      is_ack_(false) {}
+SpdySettingsIR::SpdySettingsIR() : clear_settings_(false), is_ack_(false) {
+}
 
-SpdySettingsIR::~SpdySettingsIR() {}
+SpdySettingsIR::~SpdySettingsIR() {
+}
 
 void SpdySettingsIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSettings(*this);
 }
 
 void SpdyPingIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPing(*this);
 }
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                            SpdyGoAwayStatus status,
                            const base::StringPiece& description)
     : description_(description) {
-      set_last_good_stream_id(last_good_stream_id);
+  set_last_good_stream_id(last_good_stream_id);
   set_status(status);
 }
 
-SpdyGoAwayIR::~SpdyGoAwayIR() {}
+SpdyGoAwayIR::~SpdyGoAwayIR() {
+}
 
 const base::StringPiece& SpdyGoAwayIR::description() const {
   return description_;
 }
 
 void SpdyGoAwayIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitGoAway(*this);
 }
 
 void SpdyHeadersIR::Visit(SpdyFrameVisitor* visitor) const {
@@ skipping 10 matching lines @@
 
 void SpdyPushPromiseIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPushPromise(*this);
 }
 
 void SpdyContinuationIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitContinuation(*this);
 }
 
 }  // namespace net