Clang format slam.

net/server/web_socket.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/server/web_socket.h"
 
 #include <limits>
 
 #include "base/base64.h"
 #include "base/rand_util.h"
@@ skipping 93 matching lines @@
     connection_->Send(&message_start, 1);
     connection_->Send(message);
     connection_->Send(&message_end, 1);
   }
 
  private:
   static const int kWebSocketHandshakeBodyLen;
 
   WebSocketHixie76(HttpConnection* connection,
                    const HttpServerRequestInfo& request,
-                   size_t* pos) : WebSocket(connection) {
+                   size_t* pos)
+      : WebSocket(connection) {
     std::string key1 = request.GetHeaderValue("sec-websocket-key1");
     std::string key2 = request.GetHeaderValue("sec-websocket-key2");
 
     if (key1.empty()) {
       connection->Send(HttpServerResponseInfo::CreateFor500(
           "Invalid request format. Sec-WebSocket-Key1 is empty or isn't "
           "specified."));
       return;
     }
 
     if (key2.empty()) {
       connection->Send(HttpServerResponseInfo::CreateFor500(
           "Invalid request format. Sec-WebSocket-Key2 is empty or isn't "
           "specified."));
       return;
     }
 
-    key3_ = connection->recv_data().substr(
-        *pos,
-        *pos + kWebSocketHandshakeBodyLen);
+    key3_ =
+        connection->recv_data().substr(*pos, *pos + kWebSocketHandshakeBodyLen);
     *pos += kWebSocketHandshakeBodyLen;
   }
 
   std::string key3_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHixie76);
 };
 
 const int WebSocketHixie76::kWebSocketHandshakeBodyLen = 8;
 
-
 // Constants for hybi-10 frame format.
 
 typedef int OpCode;
 
 const OpCode kOpCodeContinuation = 0x0;
 const OpCode kOpCodeText = 0x1;
 const OpCode kOpCodeBinary = 0x2;
 const OpCode kOpCodeClose = 0x8;
 const OpCode kOpCodePing = 0x9;
 const OpCode kOpCodePong = 0xA;
@@ skipping 65 matching lines @@
     if (closed_)
       return;
     std::string data = WebSocket::EncodeFrameHybi17(message, 0);
     connection_->Send(data);
   }
 
  private:
   WebSocketHybi17(HttpConnection* connection,
                   const HttpServerRequestInfo& request,
                   size_t* pos)
-    : WebSocket(connection),
-      op_code_(0),
-      final_(false),
-      reserved1_(false),
-      reserved2_(false),
-      reserved3_(false),
-      masked_(false),
-      payload_(0),
-      payload_length_(0),
-      frame_end_(0),
-      closed_(false) {
-  }
+      : WebSocket(connection),
+        op_code_(0),
+        final_(false),
+        reserved1_(false),
+        reserved2_(false),
+        reserved3_(false),
+        masked_(false),
+        payload_(0),
+        payload_length_(0),
+        frame_end_(0),
+        closed_(false) {}
 
   OpCode op_code_;
   bool final_;
   bool reserved1_;
   bool reserved2_;
   bool reserved3_;
   bool masked_;
   const char* payload_;
   size_t payload_length_;
   const char* frame_end_;
@@ skipping 34 matching lines @@
   bool reserved1 = (first_byte & kReserved1Bit) != 0;
   bool reserved2 = (first_byte & kReserved2Bit) != 0;
   bool reserved3 = (first_byte & kReserved3Bit) != 0;
   int op_code = first_byte & kOpCodeMask;
   bool masked = (second_byte & kMaskBit) != 0;
   if (!final || reserved1 || reserved2 || reserved3)
     return FRAME_ERROR;  // Extensions and not supported.
 
   bool closed = false;
   switch (op_code) {
-  case kOpCodeClose:
-    closed = true;
-    break;
-  case kOpCodeText:
-    break;
-  case kOpCodeBinary: // We don't support binary frames yet.
-  case kOpCodeContinuation: // We don't support binary frames yet.
-  case kOpCodePing: // We don't support binary frames yet.
-  case kOpCodePong: // We don't support binary frames yet.
-  default:
-    return FRAME_ERROR;
+    case kOpCodeClose:
+      closed = true;
+      break;
+    case kOpCodeText:
+      break;
+    case kOpCodeBinary:        // We don't support binary frames yet.
+    case kOpCodeContinuation:  // We don't support binary frames yet.
+    case kOpCodePing:          // We don't support binary frames yet.
+    case kOpCodePong:          // We don't support binary frames yet.
+    default:
+      return FRAME_ERROR;
   }
 
-  if (client_frame && !masked) // In Hybi-17 spec client MUST mask his frame.
+  if (client_frame && !masked)  // In Hybi-17 spec client MUST mask his frame.
     return FRAME_ERROR;
 
   uint64 payload_length64 = second_byte & kPayloadLengthMask;
   if (payload_length64 > kMaxSingleBytePayloadLength) {
     int extended_payload_length_size;
     if (payload_length64 == kTwoBytePayloadLengthField)
       extended_payload_length_size = 2;
     else {
       DCHECK(payload_length64 == kEightBytePayloadLengthField);
       extended_payload_length_size = 8;
@@ skipping 54 matching lines @@
     frame.push_back(data_length & 0xFF);
   } else {
     frame.push_back(kEightBytePayloadLengthField | mask_key_bit);
     char extended_payload_length[8];
     size_t remaining = data_length;
     // Fill the length into extended_payload_length in the network byte order.
     for (int i = 0; i < 8; ++i) {
       extended_payload_length[7 - i] = remaining & 0xFF;
       remaining >>= 8;
     }
-    frame.insert(frame.end(),
-                 extended_payload_length,
-                 extended_payload_length + 8);
+    frame.insert(
+        frame.end(), extended_payload_length, extended_payload_length + 8);
     DCHECK(!remaining);
   }
 
   const char* data = const_cast<char*>(message.data());
   if (masking_key != 0) {
     const char* mask_bytes = reinterpret_cast<char*>(&masking_key);
     frame.insert(frame.end(), mask_bytes, mask_bytes + 4);
     for (size_t i = 0; i < data_length; ++i)  // Mask the payload.
       frame.push_back(data[i] ^ mask_bytes[i % kMaskingKeyWidthInBytes]);
   } else {
     frame.insert(frame.end(), data, data + data_length);
   }
   return std::string(&frame[0], frame.size());
 }
 
 WebSocket::WebSocket(HttpConnection* connection) : connection_(connection) {
 }
 
 }  // namespace net