base: Remove the string logging from CHECK().

net/websockets/websocket_basic_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_basic_stream.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 39 matching lines @@
   const uint64_t kMaximumTotalSize = std::numeric_limits<int>::max();
 
   uint64_t total_size = 0;
   for (const auto& frame : *frames) {
     // Force the masked bit on.
     frame->header.masked = true;
     // We enforce flow control so the renderer should never be able to force us
     // to cache anywhere near 2GB of frames.
     uint64_t frame_size = frame->header.payload_length +
                           GetWebSocketFrameHeaderSize(frame->header);
-    CHECK_LE(frame_size, kMaximumTotalSize - total_size)
-        << "Aborting to prevent overflow";
+    // Aborting to prevent overflow
+    CHECK_LE(frame_size, kMaximumTotalSize - total_size);
     total_size += frame_size;
   }
   return static_cast<int>(total_size);
 }
 
 }  // namespace
 
 WebSocketBasicStream::WebSocketBasicStream(
     std::unique_ptr<ClientSocketHandle> connection,
     const scoped_refptr<GrowableIOBuffer>& http_read_buffer,
@@ skipping 74 matching lines @@
 
   char* dest = combined_buffer->data();
   int remaining_size = total_size;
   for (const auto& frame : *frames) {
     WebSocketMaskingKey mask = generate_websocket_masking_key_();
     int result =
         WriteWebSocketFrameHeader(frame->header, &mask, dest, remaining_size);
     DCHECK_NE(ERR_INVALID_ARGUMENT, result)
         << "WriteWebSocketFrameHeader() says that " << remaining_size
         << " is not enough to write the header in. This should not happen.";
-    CHECK_GE(result, 0) << "Potentially security-critical check failed";
+    // Potentially security-critical check failed
+    CHECK_GE(result, 0);
     dest += result;
     remaining_size -= result;
 
     CHECK_LE(frame->header.payload_length,
              static_cast<uint64_t>(remaining_size));
     const int frame_size = static_cast<int>(frame->header.payload_length);
     if (frame_size > 0) {
       const char* const frame_data = frame->data->data();
       std::copy(frame_data, frame_data + frame_size, dest);
       MaskWebSocketFramePayload(mask, 0, dest, frame_size);
@@ skipping 225 matching lines @@
     current_frame_header_.reset();
   return result_frame;
 }
 
 void WebSocketBasicStream::AddToIncompleteControlFrameBody(
     const scoped_refptr<IOBufferWithSize>& data_buffer) {
   if (!data_buffer.get())
     return;
   const int new_offset =
       incomplete_control_frame_body_->offset() + data_buffer->size();
-  CHECK_GE(incomplete_control_frame_body_->capacity(), new_offset)
-      << "Control frame body larger than frame header indicates; frame parser "
-         "bug?";
+  // Control frame body larger than frame header indicates; frame parser bug?
+  CHECK_GE(incomplete_control_frame_body_->capacity(), new_offset);
   memcpy(incomplete_control_frame_body_->data(),
          data_buffer->data(),
          data_buffer->size());
   incomplete_control_frame_body_->set_offset(new_offset);
 }
 
 void WebSocketBasicStream::OnReadComplete(
     std::vector<std::unique_ptr<WebSocketFrame>>* frames,
     const CompletionCallback& callback,
     int result) {
   result = HandleReadResult(result, frames);
   if (result == ERR_IO_PENDING)
     result = ReadFrames(frames, callback);
   if (result != ERR_IO_PENDING)
     callback.Run(result);
 }
 
 }  // namespace net