base: Remove the string logging from CHECK().

net/spdy/spdy_stream.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_stream.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 572 matching lines @@
   // May close the stream.
   DecreaseRecvWindowSize(static_cast<int32_t>(len));
   if (!weak_this)
     return;
   IncreaseRecvWindowSize(static_cast<int32_t>(len));
 }
 
 void SpdyStream::OnFrameWriteComplete(SpdyFrameType frame_type,
                                       size_t frame_size) {
   DCHECK_NE(type_, SPDY_PUSH_STREAM);
-  CHECK(frame_type == HEADERS || frame_type == DATA) << frame_type;
+  CHECK(frame_type == HEADERS || frame_type == DATA);
 
   int result =
       (frame_type == HEADERS) ? OnHeadersSent() : OnDataSent(frame_size);
   if (result == ERR_IO_PENDING) {
     // The write operation hasn't completed yet.
     return;
   }
 
   if (pending_send_status_ == NO_MORE_DATA_TO_SEND) {
     if (io_state_ == STATE_OPEN) {
@@ skipping 26 matching lines @@
 
 int SpdyStream::OnHeadersSent() {
   CHECK_EQ(io_state_, STATE_IDLE);
   CHECK_NE(stream_id_, 0u);
 
   io_state_ = STATE_OPEN;
   return OK;
 }
 
 int SpdyStream::OnDataSent(size_t frame_size) {
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE);
 
   size_t frame_payload_size = frame_size - session_->GetDataFrameMinimumSize();
 
   CHECK_GE(frame_size, session_->GetDataFrameMinimumSize());
   CHECK_LE(frame_payload_size, session_->GetDataFrameMaximumPayload());
 
   send_bytes_ += frame_payload_size;
 
   // If more data is available to send, dispatch it and
   // return that the write operation is still ongoing.
@@ skipping 78 matching lines @@
                                std::unique_ptr<SpdyBufferProducer>(
                                    new HeadersBufferProducer(GetWeakPtr())));
   return ERR_IO_PENDING;
 }
 
 void SpdyStream::SendData(IOBuffer* data,
                           int length,
                           SpdySendStatus send_status) {
   CHECK_NE(type_, SPDY_PUSH_STREAM);
   CHECK_EQ(pending_send_status_, MORE_DATA_TO_SEND);
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE);
   CHECK(!pending_send_data_.get());
   pending_send_data_ = new DrainableIOBuffer(data, length);
   pending_send_status_ = send_status;
   QueueNextDataFrame();
 }
 
 bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info) const {
   return session_->GetSSLInfo(ssl_info);
 }
 
@@ skipping 88 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
                       recv_last_byte_time_ - effective_send_time);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 void SpdyStream::QueueNextDataFrame() {
   // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
-  CHECK(io_state_ == STATE_OPEN ||
-        io_state_ == STATE_HALF_CLOSED_REMOTE) << io_state_;
+  CHECK(io_state_ == STATE_OPEN || io_state_ == STATE_HALF_CLOSED_REMOTE);
   CHECK_GT(stream_id_, 0u);
   CHECK(pending_send_data_.get());
   // Only the final fame may have a length of 0.
   if (pending_send_status_ == NO_MORE_DATA_TO_SEND) {
     CHECK_GE(pending_send_data_->BytesRemaining(), 0);
   } else {
     CHECK_GT(pending_send_data_->BytesRemaining(), 0);
   }
 
   SpdyDataFlags flags =
@@ skipping 73 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net