Clang format slam.

net/websockets/websocket_deflate_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/websockets/websocket_deflate_stream.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 35 matching lines @@
       current_reading_opcode_(WebSocketFrameHeader::kOpCodeText),
       current_writing_opcode_(WebSocketFrameHeader::kOpCodeText),
       predictor_(predictor.Pass()) {
   DCHECK(stream_);
   DCHECK_GE(client_window_bits, 8);
   DCHECK_LE(client_window_bits, 15);
   deflater_.Initialize(client_window_bits);
   inflater_.Initialize(kWindowBits);
 }
 
-WebSocketDeflateStream::~WebSocketDeflateStream() {}
+WebSocketDeflateStream::~WebSocketDeflateStream() {
+}
 
 int WebSocketDeflateStream::ReadFrames(ScopedVector<WebSocketFrame>* frames,
                                        const CompletionCallback& callback) {
-  int result = stream_->ReadFrames(
-      frames,
-      base::Bind(&WebSocketDeflateStream::OnReadComplete,
-                 base::Unretained(this),
-                 base::Unretained(frames),
-                 callback));
+  int result =
+      stream_->ReadFrames(frames,
+                          base::Bind(&WebSocketDeflateStream::OnReadComplete,
+                                     base::Unretained(this),
+                                     base::Unretained(frames),
+                                     callback));
   if (result < 0)
     return result;
   DCHECK_EQ(OK, result);
   DCHECK(!frames->empty());
 
   return InflateAndReadIfNecessary(frames, callback);
 }
 
 int WebSocketDeflateStream::WriteFrames(ScopedVector<WebSocketFrame>* frames,
                                         const CompletionCallback& callback) {
   int result = Deflate(frames);
   if (result != OK)
     return result;
   if (frames->empty())
     return OK;
   return stream_->WriteFrames(frames, callback);
 }
 
-void WebSocketDeflateStream::Close() { stream_->Close(); }
+void WebSocketDeflateStream::Close() {
+  stream_->Close();
+}
 
 std::string WebSocketDeflateStream::GetSubProtocol() const {
   return stream_->GetSubProtocol();
 }
 
 std::string WebSocketDeflateStream::GetExtensions() const {
   return stream_->GetExtensions();
 }
 
 void WebSocketDeflateStream::OnReadComplete(
@@ skipping 30 matching lines @@
     (*frames)[i] = NULL;
     predictor_->RecordInputDataFrame(frame.get());
 
     if (writing_state_ == WRITING_UNCOMPRESSED_MESSAGE) {
       if (frame->header.final)
         writing_state_ = NOT_WRITING;
       predictor_->RecordWrittenDataFrame(frame.get());
       frames_to_write.push_back(frame.release());
       current_writing_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
     } else {
-      if (frame->data && !deflater_.AddBytes(frame->data->data(),
-                                             frame->header.payload_length)) {
+      if (frame->data &&
+          !deflater_.AddBytes(frame->data->data(),
+                              frame->header.payload_length)) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "deflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
       if (frame->header.final && !deflater_.Finish()) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "deflater_.Finish() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
 
@@ skipping 20 matching lines @@
         }
       }
     }
   }
   DCHECK_NE(WRITING_POSSIBLY_COMPRESSED_MESSAGE, writing_state_);
   frames->swap(frames_to_write);
   return OK;
 }
 
 void WebSocketDeflateStream::OnMessageStart(
-    const ScopedVector<WebSocketFrame>& frames, size_t index) {
+    const ScopedVector<WebSocketFrame>& frames,
+    size_t index) {
   WebSocketFrame* frame = frames[index];
   current_writing_opcode_ = frame->header.opcode;
   DCHECK(current_writing_opcode_ == WebSocketFrameHeader::kOpCodeText ||
          current_writing_opcode_ == WebSocketFrameHeader::kOpCodeBinary);
   WebSocketDeflatePredictor::Result prediction =
       predictor_->Predict(frames, index);
 
   switch (prediction) {
     case WebSocketDeflatePredictor::DEFLATE:
       writing_state_ = WRITING_COMPRESSED_MESSAGE;
@@ skipping 46 matching lines @@
     DVLOG(1) << "WebSocket protocol error. "
              << "deflater_.GetOutput() returns an error.";
     return ERR_WS_PROTOCOL_ERROR;
   }
 
   uint64 original_payload_length = 0;
   for (size_t i = 0; i < frames->size(); ++i) {
     WebSocketFrame* frame = (*frames)[i];
     // Asserts checking that frames represent one whole data message.
     DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode));
-    DCHECK_EQ(i == 0,
-              WebSocketFrameHeader::kOpCodeContinuation !=
-              frame->header.opcode);
+    DCHECK_EQ(
+        i == 0,
+        WebSocketFrameHeader::kOpCodeContinuation != frame->header.opcode);
     DCHECK_EQ(i == frames->size() - 1, frame->header.final);
     original_payload_length += frame->header.payload_length;
   }
   if (original_payload_length <=
       static_cast<uint64>(compressed_payload->size())) {
     // Compression is not effective. Use the original frames.
     for (size_t i = 0; i < frames->size(); ++i) {
       WebSocketFrame* frame = (*frames)[i];
       frames_to_write->push_back(frame);
       predictor_->RecordWrittenDataFrame(frame);
@@ skipping 46 matching lines @@
       }
     }
 
     if (reading_state_ == READING_UNCOMPRESSED_MESSAGE) {
       if (frame->header.final)
         reading_state_ = NOT_READING;
       current_reading_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
       frames_to_output.push_back(frame.release());
     } else {
       DCHECK_EQ(reading_state_, READING_COMPRESSED_MESSAGE);
-      if (frame->data && !inflater_.AddBytes(frame->data->data(),
-                                             frame->header.payload_length)) {
+      if (frame->data &&
+          !inflater_.AddBytes(frame->data->data(),
+                              frame->header.payload_length)) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "inflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
       }
       if (frame->header.final) {
         if (!inflater_.Finish()) {
           DVLOG(1) << "WebSocket protocol error. "
                    << "inflater_.Finish() returns an error.";
           return ERR_WS_PROTOCOL_ERROR;
         }
@@ skipping 37 matching lines @@
   return frames->empty() ? ERR_IO_PENDING : OK;
 }
 
 int WebSocketDeflateStream::InflateAndReadIfNecessary(
     ScopedVector<WebSocketFrame>* frames,
     const CompletionCallback& callback) {
   int result = Inflate(frames);
   while (result == ERR_IO_PENDING) {
     DCHECK(frames->empty());
 
-    result = stream_->ReadFrames(
-        frames,
-        base::Bind(&WebSocketDeflateStream::OnReadComplete,
-                   base::Unretained(this),
-                   base::Unretained(frames),
-                   callback));
+    result =
+        stream_->ReadFrames(frames,
+                            base::Bind(&WebSocketDeflateStream::OnReadComplete,
+                                       base::Unretained(this),
+                                       base::Unretained(frames),
+                                       callback));
     if (result < 0)
       break;
     DCHECK_EQ(OK, result);
     DCHECK(!frames->empty());
 
     result = Inflate(frames);
   }
   if (result < 0)
     frames->clear();
   return result;
 }
 
 }  // namespace net