base: Remove the string logging from CHECK().

net/spdy/spdy_deframer_visitor.cc

 // Copyright 2016 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_deframer_visitor.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 267 matching lines @@
         std::move(*goaway_description_)));
     CHECK_EQ(0u, goaway_description_->size());
   }
   goaway_description_.reset();
   goaway_ir_.reset();
   frame_type_ = UNSET;
 }
 
 void SpdyTestDeframerImpl::AtHeadersEnd() {
   DVLOG(1) << "AtDataEnd";
-  CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
-  CHECK(end_) << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+  CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION);
+  CHECK(end_);
   CHECK(got_hpack_end_);
 
   CHECK(headers_ir_);
   CHECK(headers_);
   CHECK(headers_handler_);
 
   CHECK_LE(0u, padding_len_);
   CHECK_LE(padding_len_, 256u);
   if (padding_len_ > 0) {
     headers_ir_->set_padding_len(padding_len_);
   }
   padding_len_ = 0;
 
   headers_ir_->set_header_block(headers_handler_->decoded_block().Clone());
   headers_handler_.reset();
   listener_->OnHeaders(std::move(headers_ir_), std::move(headers_));
 
   frame_type_ = UNSET;
   fin_ = false;
   end_ = false;
   got_hpack_end_ = false;
 }
 
 void SpdyTestDeframerImpl::AtPushPromiseEnd() {
   DVLOG(1) << "AtDataEnd";
-  CHECK(frame_type_ == PUSH_PROMISE || frame_type_ == CONTINUATION)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
-  CHECK(end_) << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+  CHECK(frame_type_ == PUSH_PROMISE || frame_type_ == CONTINUATION);
+  CHECK(end_);
 
   CHECK(push_promise_ir_);
   CHECK(headers_);
   CHECK(headers_handler_);
 
   CHECK_EQ(headers_ir_.get(), nullptr);
 
   CHECK_LE(0u, padding_len_);
   CHECK_LE(padding_len_, 256u);
   if (padding_len_ > 0) {
@@ skipping 80 matching lines @@
   return true;
 }
 
 // Overridden methods from SpdyFramerVisitorInterface in alpha order...
 
 void SpdyTestDeframerImpl::OnAltSvc(
     SpdyStreamId stream_id,
     StringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
   auto ptr = MakeUnique<SpdyAltSvcIR>(stream_id);
   ptr->set_origin(origin.as_string());
   for (auto& altsvc : altsvc_vector) {
     ptr->add_altsvc(altsvc);
   }
   listener_->OnAltSvc(std::move(ptr));
 }
 
 // Frame type BLOCKED was removed in draft 12 of HTTP/2. The intent appears to
 // have been to support debugging; it is not expected to be seen except if the
 // peer "thinks" that a bug exists in the flow control such that the peer can't
 // send because the receiver hasn't sent WINDOW_UPDATE frames. Since we might
 // be talking to multiple backends, it is quite plausible that one backend
 // is unable to take more input from the client (hence no WINDOW_UPDATE), yet
 // other backends can take more input.
 void SpdyTestDeframerImpl::OnBlocked(SpdyStreamId stream_id) {
   LOG(FATAL) << "OnBlocked stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
   frame_type_ = UNSET;
   stream_id_ = stream_id;
 }
 
 // A CONTINUATION frame contains a Header Block Fragment, and immediately
 // follows another frame that contains a Header Block Fragment (HEADERS,
 // PUSH_PROMISE or CONTINUATION). The last such frame has the END flag set.
 // SpdyFramer ensures that the behavior is correct before calling the visitor.
 void SpdyTestDeframerImpl::OnContinuation(SpdyStreamId stream_id, bool end) {
   DVLOG(1) << "OnContinuation stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
   CHECK_NE(nullptr, headers_.get());
   frame_type_ = CONTINUATION;
 
   stream_id_ = stream_id;
   end_ = end;
 }
 
 // Note that length includes the padding length (0 to 256, when the optional
 // padding length field is counted). Padding comes after the payload, both
 // for DATA frames and for control frames.
 void SpdyTestDeframerImpl::OnDataFrameHeader(SpdyStreamId stream_id,
                                              size_t length,
                                              bool fin) {
   DVLOG(1) << "OnDataFrameHeader stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
   CHECK_EQ(data_.get(), nullptr);
   frame_type_ = DATA;
 
   stream_id_ = stream_id;
   fin_ = fin;
   data_len_ = length;
   data_.reset(new string());
 }
 
 // The SpdyFramer will not process any more data at this point.
 void SpdyTestDeframerImpl::OnError(SpdyFramer* framer) {
   DVLOG(1) << "SpdyFramer detected an error in the stream: "
            << SpdyFramer::ErrorCodeToString(framer->error_code())
            << "     frame_type_: " << Http2FrameTypeToString(frame_type_);
   listener_->OnError(framer, this);
 }
 
 // Received a GOAWAY frame from the peer. The last stream id it accepted from us
 // is |last_accepted_stream_id|. |status| is a protocol defined error code.
 // The frame may also contain data. After this OnGoAwayFrameData will be called
 // for any non-zero amount of data, and after that it will be called with len==0
 // to indicate the end of the GOAWAY frame.
 void SpdyTestDeframerImpl::OnGoAway(SpdyStreamId last_good_stream_id,
                                     SpdyGoAwayStatus status) {
   DVLOG(1) << "OnGoAway last_good_stream_id: " << last_good_stream_id
            << "     status: " << status;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   frame_type_ = GOAWAY;
   goaway_ir_ = MakeUnique<SpdyGoAwayIR>(last_good_stream_id, status, "");
   goaway_description_.reset(new string());
 }
 
 // If len==0 then we've reached the end of the GOAWAY frame.
 bool SpdyTestDeframerImpl::OnGoAwayFrameData(const char* goaway_data,
                                              size_t len) {
   DVLOG(1) << "OnGoAwayFrameData";
-  CHECK_EQ(frame_type_, GOAWAY) << "   frame_type_="
-                                << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, GOAWAY);
   CHECK(goaway_description_);
   StringPiece(goaway_data, len).AppendToString(goaway_description_.get());
   return true;
 }
 
 SpdyHeadersHandlerInterface* SpdyTestDeframerImpl::OnHeaderFrameStart(
     SpdyStreamId stream_id) {
   return this;
 }
 
@@ skipping 11 matching lines @@
 // frame; else if true then there will be CONTINATION frames(s) immediately
 // following this frame, terminated by a CONTINUATION frame with end==true.
 void SpdyTestDeframerImpl::OnHeaders(SpdyStreamId stream_id,
                                      bool has_priority,
                                      int weight,
                                      SpdyStreamId parent_stream_id,
                                      bool exclusive,
                                      bool fin,
                                      bool end) {
   DVLOG(1) << "OnHeaders stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
   frame_type_ = HEADERS;
 
   stream_id_ = stream_id;
   fin_ = fin;
   end_ = end;
 
   headers_.reset(new StringPairVector());
   headers_handler_.reset(new TestHeadersHandler());
   headers_ir_ = MakeUnique<SpdyHeadersIR>(stream_id);
   headers_ir_->set_fin(fin);
   if (has_priority) {
     headers_ir_->set_has_priority(true);
     headers_ir_->set_weight(weight);
     headers_ir_->set_parent_stream_id(parent_stream_id);
     headers_ir_->set_exclusive(exclusive);
   }
 }
 
 // The HTTP/2 protocol refers to the payload, |unique_id| here, as 8 octets of
 // opaque data that is to be echoed back to the sender, with the ACK bit added.
 // It isn't defined as a counter,
 // or frame id, as the SpdyPingId naming might imply.
 // Responding to a PING is supposed to be at the highest priority.
 void SpdyTestDeframerImpl::OnPing(uint64_t unique_id, bool is_ack) {
   DVLOG(1) << "OnPing unique_id: " << unique_id
            << "      is_ack: " << (is_ack ? "true" : "false");
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   auto ptr = MakeUnique<SpdyPingIR>(unique_id);
   if (is_ack) {
     ptr->set_is_ack(is_ack);
     listener_->OnPingAck(std::move(ptr));
   } else {
     listener_->OnPing(std::move(ptr));
   }
 }
 
 void SpdyTestDeframerImpl::OnPriority(SpdyStreamId stream_id,
                                       SpdyStreamId parent_stream_id,
                                       int weight,
                                       bool exclusive) {
   DVLOG(1) << "OnPriority stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
 
   listener_->OnPriority(MakeUnique<SpdyPriorityIR>(stream_id, parent_stream_id,
                                                    weight, exclusive));
 }
 
 void SpdyTestDeframerImpl::OnPushPromise(SpdyStreamId stream_id,
                                          SpdyStreamId promised_stream_id,
                                          bool end) {
   DVLOG(1) << "OnPushPromise stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
 
   frame_type_ = PUSH_PROMISE;
   stream_id_ = stream_id;
   end_ = end;
 
   headers_.reset(new StringPairVector());
   headers_handler_.reset(new TestHeadersHandler());
   push_promise_ir_ =
       MakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
 }
 
 // Closes the specified stream. After this the sender may still send PRIORITY
 // frames for this stream, which we can ignore.
 void SpdyTestDeframerImpl::OnRstStream(SpdyStreamId stream_id,
                                        SpdyRstStreamStatus status) {
   DVLOG(1) << "OnRstStream stream_id: " << stream_id
            << "     status: " << status;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_GT(stream_id, 0u);
 
   listener_->OnRstStream(MakeUnique<SpdyRstStreamIR>(stream_id, status));
 }
 
 // The HTTP/2 spec states that there is no data in the frame other that the
 // SpdyRstStreamStatus passed to OnRstStream, so it appears that SpdyFramer's
 // comments w.r.t. this method are obsolete. We still receive a zero length
 // invocation when RST_STREAM frame processing completes.
 bool SpdyTestDeframerImpl::OnRstStreamFrameData(const char* rst_stream_data,
                                                 size_t len) {
   DVLOG(1) << "OnRstStreamFrameData";
   CHECK_EQ(0u, len);
   return true;
 }
 
 // Called for an individual setting. There is no negotiation, the sender is
 // stating the value that the sender is using.
 void SpdyTestDeframerImpl::OnSetting(SpdySettingsIds id,
                                      uint8_t flags,
                                      uint32_t value) {
   DVLOG(1) << "OnSetting id: " << id << std::hex << "   flags: " << flags
            << "    value: " << value;
-  CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
-                                  << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, SETTINGS);
   CHECK(settings_);
   settings_->push_back(std::make_pair(id, value));
   settings_ir_->AddSetting(id, true, true, value);
 }
 
 // Called at the start of a SETTINGS frame with setting entries, but not the
 // (required) ACK of a SETTINGS frame. There is no stream_id because
 // the settings apply to the entire connection, not to an individual stream.
 // The |clear_persisted| flag is a pre-HTTP/2 remnant.
 void SpdyTestDeframerImpl::OnSettings(bool /*clear_persisted*/) {
   DVLOG(1) << "OnSettings";
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_EQ(nullptr, settings_ir_.get());
   CHECK_EQ(nullptr, settings_.get());
   frame_type_ = SETTINGS;
   ack_ = false;
 
   settings_.reset(new SettingVector());
   settings_ir_.reset(new SpdySettingsIR());
 }
 
 void SpdyTestDeframerImpl::OnSettingsAck() {
   DVLOG(1) << "OnSettingsAck";
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   auto ptr = MakeUnique<SpdySettingsIR>();
   ptr->set_is_ack(true);
   listener_->OnSettingsAck(std::move(ptr));
 }
 
 void SpdyTestDeframerImpl::OnSettingsEnd() {
   DVLOG(1) << "OnSettingsEnd";
-  CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
-                                  << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, SETTINGS);
   CHECK(!ack_);
   CHECK_NE(nullptr, settings_ir_.get());
   CHECK_NE(nullptr, settings_.get());
   listener_->OnSettings(std::move(settings_ir_), std::move(settings_));
   frame_type_ = UNSET;
 }
 
 // Called for a zero length DATA frame with the END_STREAM flag set, or at the
 // end a complete HPACK block (and its padding) that started with a HEADERS
 // frame with the END_STREAM flag set. Doesn't apply to PUSH_PROMISE frames
 // because they don't have END_STREAM flags.
 void SpdyTestDeframerImpl::OnStreamEnd(SpdyStreamId stream_id) {
   DVLOG(1) << "OnStreamEnd stream_id: " << stream_id;
   CHECK_EQ(stream_id_, stream_id);
   CHECK(frame_type_ == DATA || frame_type_ == HEADERS ||
-        frame_type_ == CONTINUATION)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+        frame_type_ == CONTINUATION);
   CHECK(fin_);
 }
 
 // The data arg points into the non-padding payload of a DATA frame.
 // This must be a DATA frame (i.e. this method will not be
 // called for HEADERS or CONTINUATION frames).
 // This method may be called multiple times for a single DATA frame, depending
 // upon buffer boundaries.
 void SpdyTestDeframerImpl::OnStreamFrameData(SpdyStreamId stream_id,
                                              const char* data,
                                              size_t len) {
   DVLOG(1) << "OnStreamFrameData stream_id: " << stream_id
            << "    len: " << len;
   CHECK_EQ(stream_id_, stream_id);
   CHECK_EQ(frame_type_, DATA);
   StringPiece(data, len).AppendToString(data_.get());
 }
 
 // Called when padding is skipped over, including the padding length field at
 // the start of the frame payload, and the actual padding at the end. len will
 // be in the range 1 to 255.
 void SpdyTestDeframerImpl::OnStreamPadding(SpdyStreamId stream_id, size_t len) {
   DVLOG(1) << "OnStreamPadding stream_id: " << stream_id << "    len: " << len;
   CHECK(frame_type_ == DATA || frame_type_ == HEADERS ||
-        frame_type_ == PUSH_PROMISE)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+        frame_type_ == PUSH_PROMISE);
   CHECK_EQ(stream_id_, stream_id);
   CHECK_LE(1u, len);
   CHECK_GE(255u, len);
   padding_len_ += len;
-  CHECK_LE(padding_len_, 256u) << "len=" << len;
+  CHECK_LE(padding_len_, 256u);
 }
 
 // WINDOW_UPDATE is supposed to be hop-by-hop, according to the spec.
 // stream_id is 0 if the update applies to the connection, else stream_id
 // will be the id of a stream previously seen, which maybe half or fully
 // closed.
 void SpdyTestDeframerImpl::OnWindowUpdate(SpdyStreamId stream_id,
                                           int delta_window_size) {
   DVLOG(1) << "OnWindowUpdate stream_id: " << stream_id
            << "    delta_window_size: " << delta_window_size;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   CHECK_NE(0, delta_window_size);
 
   listener_->OnWindowUpdate(
       MakeUnique<SpdyWindowUpdateIR>(stream_id, delta_window_size));
 }
 
 // Return true to indicate that the stream_id is valid; if not valid then
 // SpdyFramer considers the connection corrupted. Requires keeping track
 // of the set of currently open streams. For now we'll assume that unknown
 // frame types are unsupported.
 bool SpdyTestDeframerImpl::OnUnknownFrame(SpdyStreamId stream_id,
                                           int frame_type) {
   DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
-  CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
-                               << Http2FrameTypeToString(frame_type_);
+  CHECK_EQ(frame_type_, UNSET);
   frame_type_ = UNKNOWN;
 
   stream_id_ = stream_id;
   return false;
 }
 
 // Callbacks defined in SpdyHeadersHandlerInterface.
 
 void SpdyTestDeframerImpl::OnHeaderBlockStart() {
-  CHECK(frame_type_ == HEADERS || frame_type_ == PUSH_PROMISE)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+  CHECK(frame_type_ == HEADERS || frame_type_ == PUSH_PROMISE);
   CHECK(headers_);
   CHECK_EQ(0u, headers_->size());
   got_hpack_end_ = false;
 }
 
 void SpdyTestDeframerImpl::OnHeader(StringPiece key, StringPiece value) {
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
-        frame_type_ == PUSH_PROMISE)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+        frame_type_ == PUSH_PROMISE);
   CHECK(!got_hpack_end_);
   CHECK(headers_);
   headers_->emplace_back(key.as_string(), value.as_string());
   CHECK(headers_handler_);
   headers_handler_->OnHeader(key, value);
 }
 
 void SpdyTestDeframerImpl::OnHeaderBlockEnd(size_t header_bytes_parsed) {
   CHECK(headers_);
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
-        frame_type_ == PUSH_PROMISE)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+        frame_type_ == PUSH_PROMISE);
   CHECK(end_);
   CHECK(!got_hpack_end_);
   got_hpack_end_ = true;
 }
 
 void SpdyTestDeframerImpl::OnHeaderBlockEnd(
     size_t /* header_bytes_parsed */,
     size_t /* compressed_header_bytes_parsed */) {
   CHECK(headers_);
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
-        frame_type_ == PUSH_PROMISE)
-      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+        frame_type_ == PUSH_PROMISE);
   CHECK(end_);
   CHECK(!got_hpack_end_);
   got_hpack_end_ = true;
 }
 
 class LoggingSpdyDeframerDelegate : public SpdyDeframerVisitorInterface {
  public:
   explicit LoggingSpdyDeframerDelegate(
       std::unique_ptr<SpdyDeframerVisitorInterface> wrapped)
       : wrapped_(std::move(wrapped)) {
@@ skipping 239 matching lines @@
 // The SpdyFramer will not process any more data at this point.
 void DeframerCallbackCollector::OnError(SpdyFramer* framer,
                                         SpdyTestDeframer* deframer) {
   CollectedFrame cf;
   cf.error_reported = true;
   collected_frames_->push_back(std::move(cf));
 }
 
 }  // namespace test
 }  // namespace net