Clang format slam.

net/websockets/websocket_channel.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/websockets/websocket_channel.h"
 
 #include <limits.h>  // for INT_MAX
 
 #include <algorithm>
 #include <deque>
@@ skipping 68 matching lines @@
   DCHECK_LT(code, 65536);
   const int* upper = std::upper_bound(kInvalidRanges, kInvalidRangesEnd, code);
   DCHECK_NE(kInvalidRangesEnd, upper);
   DCHECK_GT(upper, kInvalidRanges);
   DCHECK_GT(*upper, code);
   DCHECK_LE(*(upper - 1), code);
   return ((upper - kInvalidRanges) % 2) == 0;
 }
 
 // This function avoids a bunch of boilerplate code.
-void AllowUnused(ChannelState ALLOW_UNUSED unused) {}
+void AllowUnused(ChannelState ALLOW_UNUSED unused) {
+}
 
 // Sets |name| to the name of the frame type for the given |opcode|. Note that
 // for all of Text, Binary and Continuation opcode, this method returns
 // "Data frame".
 void GetFrameTypeForOpcode(WebSocketFrameHeader::OpCode opcode,
                            std::string* name) {
   switch (opcode) {
     case WebSocketFrameHeader::kOpCodeText:    // fall-thru
     case WebSocketFrameHeader::kOpCodeBinary:  // fall-thru
     case WebSocketFrameHeader::kOpCodeContinuation:
@@ skipping 115 matching lines @@
   }
 
  private:
   WebSocketChannel* owner_;
   scoped_ptr<WebSocketHandshakeRequestInfo> handshake_request_info_;
   scoped_ptr<WebSocketHandshakeResponseInfo> handshake_response_info_;
 };
 
 WebSocketChannel::HandshakeNotificationSender::HandshakeNotificationSender(
     WebSocketChannel* channel)
-    : owner_(channel) {}
+    : owner_(channel) {
+}
 
-WebSocketChannel::HandshakeNotificationSender::~HandshakeNotificationSender() {}
+WebSocketChannel::HandshakeNotificationSender::~HandshakeNotificationSender() {
+}
 
 void WebSocketChannel::HandshakeNotificationSender::Send(
     base::WeakPtr<HandshakeNotificationSender> sender) {
   // Do nothing if |sender| is already destructed.
   if (sender) {
     WebSocketChannel* channel = sender->owner_;
     AllowUnused(sender->SendImmediately(channel->event_interface_.get()));
   }
 }
 
 ChannelState WebSocketChannel::HandshakeNotificationSender::SendImmediately(
     WebSocketEventInterface* event_interface) {
-
   if (handshake_request_info_.get()) {
-    if (CHANNEL_DELETED == event_interface->OnStartOpeningHandshake(
-                               handshake_request_info_.Pass()))
+    if (CHANNEL_DELETED ==
+        event_interface->OnStartOpeningHandshake(
+            handshake_request_info_.Pass()))
       return CHANNEL_DELETED;
   }
 
   if (handshake_response_info_.get()) {
-    if (CHANNEL_DELETED == event_interface->OnFinishOpeningHandshake(
-                               handshake_response_info_.Pass()))
+    if (CHANNEL_DELETED ==
+        event_interface->OnFinishOpeningHandshake(
+            handshake_response_info_.Pass()))
       return CHANNEL_DELETED;
 
     // TODO(yhirano): We can release |this| to save memory because
     // there will be no more opening handshake notification.
   }
 
   return CHANNEL_ALIVE;
 }
 
 WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
     bool final,
     WebSocketFrameHeader::OpCode opcode,
     const scoped_refptr<IOBuffer>& data,
     size_t offset,
     size_t size)
     : final_(final),
       opcode_(opcode),
       data_(data),
       offset_(offset),
-      size_(size) {}
+      size_(size) {
+}
 
-WebSocketChannel::PendingReceivedFrame::~PendingReceivedFrame() {}
+WebSocketChannel::PendingReceivedFrame::~PendingReceivedFrame() {
+}
 
 void WebSocketChannel::PendingReceivedFrame::ResetOpcode() {
   DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(opcode_));
   opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
 }
 
 void WebSocketChannel::PendingReceivedFrame::DidConsume(size_t bytes) {
   DCHECK_LE(offset_, size_);
   DCHECK_LE(bytes, size_ - offset_);
   offset_ += bytes;
 }
 
 WebSocketChannel::WebSocketChannel(
     scoped_ptr<WebSocketEventInterface> event_interface,
     URLRequestContext* url_request_context)
     : event_interface_(event_interface.Pass()),
       url_request_context_(url_request_context),
       send_quota_low_water_mark_(kDefaultSendQuotaLowWaterMark),
       send_quota_high_water_mark_(kDefaultSendQuotaHighWaterMark),
       current_send_quota_(0),
       current_receive_quota_(0),
       timeout_(base::TimeDelta::FromSeconds(kClosingHandshakeTimeoutSeconds)),
       received_close_code_(0),
       state_(FRESHLY_CONSTRUCTED),
       notification_sender_(new HandshakeNotificationSender(this)),
       sending_text_message_(false),
       receiving_text_message_(false),
       expecting_to_handle_continuation_(false),
-      initial_frame_forwarded_(false) {}
+      initial_frame_forwarded_(false) {
+}
 
 WebSocketChannel::~WebSocketChannel() {
   // The stream may hold a pointer to read_frames_, and so it needs to be
   // destroyed first.
   stream_.reset();
   // The timer may have a callback pointing back to us, so stop it just in case
   // someone decides to run the event loop from their destructor.
   timer_.Stop();
 }
 
 void WebSocketChannel::SendAddChannelRequest(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
     const url::Origin& origin) {
   // Delegate to the tested version.
   SendAddChannelRequestWithSuppliedCreator(
       socket_url,
       requested_subprotocols,
       origin,
       base::Bind(&WebSocketStream::CreateAndConnectStream));
 }
 
 void WebSocketChannel::SetState(State new_state) {
   DCHECK_NE(state_, new_state);
 
   if (new_state == CONNECTED)
     established_on_ = base::TimeTicks::Now();
   if (state_ == CONNECTED && !established_on_.is_null()) {
-    UMA_HISTOGRAM_LONG_TIMES(
-        "Net.WebSocket.Duration", base::TimeTicks::Now() - established_on_);
+    UMA_HISTOGRAM_LONG_TIMES("Net.WebSocket.Duration",
+                             base::TimeTicks::Now() - established_on_);
   }
 
   state_ = new_state;
 }
 
 bool WebSocketChannel::InClosingState() const {
   // The state RECV_CLOSED is not supported here, because it is only used in one
   // code path and should not leak into the code in general.
   DCHECK_NE(RECV_CLOSED, state_)
       << "InClosingState called with state_ == RECV_CLOSED";
@@ skipping 73 matching lines @@
   DCHECK_LE(quota, INT_MAX);
   if (!pending_received_frames_.empty()) {
     DCHECK_EQ(0, current_receive_quota_);
   }
   while (!pending_received_frames_.empty() && quota > 0) {
     PendingReceivedFrame& front = pending_received_frames_.front();
     const size_t data_size = front.size() - front.offset();
     const size_t bytes_to_send =
         std::min(base::checked_cast<size_t>(quota), data_size);
     const bool final = front.final() && data_size == bytes_to_send;
-    const char* data = front.data() ?
-        front.data()->data() + front.offset() : NULL;
+    const char* data =
+        front.data() ? front.data()->data() + front.offset() : NULL;
     DCHECK(!bytes_to_send || data) << "Non empty data should not be null.";
     const std::vector<char> data_vector(data, data + bytes_to_send);
     DVLOG(3) << "Sending frame previously split due to quota to the "
              << "renderer: quota=" << quota << " data_size=" << data_size
              << " bytes_to_send=" << bytes_to_send;
     if (event_interface_->OnDataFrame(final, front.opcode(), data_vector) ==
         CHANNEL_DELETED)
       return;
     if (bytes_to_send < data_size) {
       front.DidConsume(bytes_to_send);
@@ skipping 431 matching lines @@
   DCHECK(opcode == WebSocketFrameHeader::kOpCodeContinuation ||
          opcode == WebSocketFrameHeader::kOpCodeText ||
          opcode == WebSocketFrameHeader::kOpCodeBinary);
   const bool got_continuation =
       (opcode == WebSocketFrameHeader::kOpCodeContinuation);
   if (got_continuation != expecting_to_handle_continuation_) {
     const std::string console_log = got_continuation
         ? "Received unexpected continuation frame."
         : "Received start of new message but previous message is unfinished.";
     const std::string reason = got_continuation
-        ? "Unexpected continuation"
-        : "Previous data frame unfinished";
+                                   ? "Unexpected continuation"
+                                   : "Previous data frame unfinished";
     return FailChannel(console_log, kWebSocketErrorProtocolError, reason);
   }
   expecting_to_handle_continuation_ = !final;
   WebSocketFrameHeader::OpCode opcode_to_send = opcode;
   if (!initial_frame_forwarded_ &&
       opcode == WebSocketFrameHeader::kOpCodeContinuation) {
     opcode_to_send = receiving_text_message_
                          ? WebSocketFrameHeader::kOpCodeText
                          : WebSocketFrameHeader::kOpCodeBinary;
   }
@@ skipping 139 matching lines @@
   if (size < kWebSocketCloseCodeLength) {
     if (size == 0U) {
       *code = kWebSocketErrorNoStatusReceived;
       return true;
     }
 
     DVLOG(1) << "Close frame with payload size " << size << " received "
              << "(the first byte is " << std::hex
              << static_cast<int>(buffer->data()[0]) << ")";
     *code = kWebSocketErrorProtocolError;
-    *message =
-        "Received a broken close frame containing an invalid size body.";
+    *message = "Received a broken close frame containing an invalid size body.";
     return false;
   }
 
   const char* data = buffer->data();
   uint16 unchecked_code = 0;
   base::ReadBigEndian(data, &unchecked_code);
   COMPILE_ASSERT(sizeof(unchecked_code) == kWebSocketCloseCodeLength,
                  they_should_both_be_two_bytes);
 
   switch (unchecked_code) {
@@ skipping 35 matching lines @@
 }
 
 void WebSocketChannel::CloseTimeout() {
   stream_->Close();
   SetState(CLOSED);
   AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
   // |this| has been deleted.
 }
 
 }  // namespace net