Replaces all flavors of SPDY_LOG with the QUICHE equivalents.
PiperOrigin-RevId: 367497148
Change-Id: I5a7092649df7d919d23bc80a3cd1f4002472fa22
diff --git a/spdy/core/http2_frame_decoder_adapter.cc b/spdy/core/http2_frame_decoder_adapter.cc
index 59fea3a..041a2ec 100644
--- a/spdy/core/http2_frame_decoder_adapter.cc
+++ b/spdy/core/http2_frame_decoder_adapter.cc
@@ -4,9 +4,9 @@
#include "spdy/core/http2_frame_decoder_adapter.h"
-// Logging policy: If an error in the input is detected, SPDY_VLOG(n) is used so
-// that the option exists to debug the situation. Otherwise, this code mostly
-// uses SPDY_DVLOG so that the logging does not slow down production code when
+// Logging policy: If an error in the input is detected, QUICHE_VLOG(n) is used
+// so that the option exists to debug the situation. Otherwise, this code mostly
+// uses QUICHE_DVLOG so that the logging does not slow down production code when
// things are working OK.
#include <stddef.h>
@@ -22,6 +22,7 @@
#include "http2/http2_constants.h"
#include "http2/http2_structures.h"
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "common/quiche_endian.h"
#include "spdy/core/hpack/hpack_decoder_adapter.h"
#include "spdy/core/hpack/hpack_header_table.h"
@@ -31,7 +32,6 @@
#include "spdy/core/spdy_protocol.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
#include "spdy/platform/api/spdy_flags.h"
-#include "spdy/platform/api/spdy_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
using ::spdy::ExtensionVisitorInterface;
@@ -257,7 +257,7 @@
}
Http2DecoderAdapter::Http2DecoderAdapter() {
- SPDY_DVLOG(1) << "Http2DecoderAdapter ctor";
+ QUICHE_DVLOG(1) << "Http2DecoderAdapter ctor";
ResetInternal();
}
@@ -335,7 +335,7 @@
// This function is largely based on Http2DecoderAdapter::ValidateFrameHeader
// and some parts of Http2DecoderAdapter::ProcessCommonHeader.
bool Http2DecoderAdapter::OnFrameHeader(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnFrameHeader: " << header;
+ QUICHE_DVLOG(1) << "OnFrameHeader: " << header;
decoded_frame_header_ = true;
if (!latched_probable_http_response_) {
latched_probable_http_response_ = header.IsProbableHttpResponse();
@@ -347,10 +347,10 @@
// Report an unexpected frame error and close the connection if we
// expect a known frame type (probably CONTINUATION) and receive an
// unknown frame.
- SPDY_VLOG(1) << "The framer was expecting to receive a "
- << expected_frame_type_
- << " frame, but instead received an unknown frame of type "
- << header.type;
+ QUICHE_VLOG(1) << "The framer was expecting to receive a "
+ << expected_frame_type_
+ << " frame, but instead received an unknown frame of type "
+ << header.type;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, "");
return false;
}
@@ -366,34 +366,35 @@
visitor()->OnUnknownFrame(header.stream_id, raw_frame_type);
if (!valid_stream) {
// Report an invalid frame error if the stream_id is not valid.
- SPDY_VLOG(1) << "Unknown control frame type " << header.type
- << " received on invalid stream " << header.stream_id;
+ QUICHE_VLOG(1) << "Unknown control frame type " << header.type
+ << " received on invalid stream " << header.stream_id;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, "");
return false;
} else {
- SPDY_DVLOG(1) << "Ignoring unknown frame type " << header.type;
+ QUICHE_DVLOG(1) << "Ignoring unknown frame type " << header.type;
return true;
}
}
SpdyFrameType frame_type = ToSpdyFrameType(header.type);
if (!IsValidHTTP2FrameStreamId(header.stream_id, frame_type)) {
- SPDY_VLOG(1) << "The framer received an invalid streamID of "
- << header.stream_id << " for a frame of type " << header.type;
+ QUICHE_VLOG(1) << "The framer received an invalid streamID of "
+ << header.stream_id << " for a frame of type "
+ << header.type;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, "");
return false;
}
if (has_expected_frame_type_ && header.type != expected_frame_type_) {
- SPDY_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not "
- << header.type;
+ QUICHE_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not "
+ << header.type;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, "");
return false;
}
if (!has_expected_frame_type_ &&
header.type == Http2FrameType::CONTINUATION) {
- SPDY_VLOG(1) << "Got CONTINUATION frame when not expected.";
+ QUICHE_VLOG(1) << "Got CONTINUATION frame when not expected.";
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, "");
return false;
}
@@ -411,7 +412,7 @@
}
void Http2DecoderAdapter::OnDataStart(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnDataStart: " << header;
+ QUICHE_DVLOG(1) << "OnDataStart: " << header;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
frame_header_ = header;
@@ -422,14 +423,14 @@
}
void Http2DecoderAdapter::OnDataPayload(const char* data, size_t len) {
- SPDY_DVLOG(1) << "OnDataPayload: len=" << len;
+ QUICHE_DVLOG(1) << "OnDataPayload: len=" << len;
QUICHE_DCHECK(has_frame_header_);
QUICHE_DCHECK_EQ(frame_header_.type, Http2FrameType::DATA);
visitor()->OnStreamFrameData(frame_header().stream_id, data, len);
}
void Http2DecoderAdapter::OnDataEnd() {
- SPDY_DVLOG(1) << "OnDataEnd";
+ QUICHE_DVLOG(1) << "OnDataEnd";
QUICHE_DCHECK(has_frame_header_);
QUICHE_DCHECK_EQ(frame_header_.type, Http2FrameType::DATA);
if (frame_header().IsEndStream()) {
@@ -439,7 +440,7 @@
}
void Http2DecoderAdapter::OnHeadersStart(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnHeadersStart: " << header;
+ QUICHE_DVLOG(1) << "OnHeadersStart: " << header;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
frame_header_ = header;
has_frame_header_ = true;
@@ -462,7 +463,7 @@
void Http2DecoderAdapter::OnHeadersPriority(
const Http2PriorityFields& priority) {
- SPDY_DVLOG(1) << "OnHeadersPriority: " << priority;
+ QUICHE_DVLOG(1) << "OnHeadersPriority: " << priority;
QUICHE_DCHECK(has_frame_header_);
QUICHE_DCHECK_EQ(frame_type(), Http2FrameType::HEADERS) << frame_header_;
QUICHE_DCHECK(frame_header_.HasPriority());
@@ -483,7 +484,7 @@
}
void Http2DecoderAdapter::OnHpackFragment(const char* data, size_t len) {
- SPDY_DVLOG(1) << "OnHpackFragment: len=" << len;
+ QUICHE_DVLOG(1) << "OnHpackFragment: len=" << len;
on_hpack_fragment_called_ = true;
auto* decoder = GetHpackDecoder();
if (!decoder->HandleControlFrameHeadersData(data, len)) {
@@ -494,14 +495,15 @@
}
void Http2DecoderAdapter::OnHeadersEnd() {
- SPDY_DVLOG(1) << "OnHeadersEnd";
+ QUICHE_DVLOG(1) << "OnHeadersEnd";
CommonHpackFragmentEnd();
opt_pad_length_.reset();
}
void Http2DecoderAdapter::OnPriorityFrame(const Http2FrameHeader& header,
const Http2PriorityFields& priority) {
- SPDY_DVLOG(1) << "OnPriorityFrame: " << header << "; priority: " << priority;
+ QUICHE_DVLOG(1) << "OnPriorityFrame: " << header
+ << "; priority: " << priority;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
visitor()->OnPriority(header.stream_id, priority.stream_dependency,
priority.weight, priority.is_exclusive);
@@ -509,7 +511,7 @@
}
void Http2DecoderAdapter::OnContinuationStart(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnContinuationStart: " << header;
+ QUICHE_DVLOG(1) << "OnContinuationStart: " << header;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
QUICHE_DCHECK(has_hpack_first_frame_header_);
if (header.stream_id != hpack_first_frame_header_.stream_id) {
@@ -524,12 +526,12 @@
}
void Http2DecoderAdapter::OnContinuationEnd() {
- SPDY_DVLOG(1) << "OnContinuationEnd";
+ QUICHE_DVLOG(1) << "OnContinuationEnd";
CommonHpackFragmentEnd();
}
void Http2DecoderAdapter::OnPadLength(size_t trailing_length) {
- SPDY_DVLOG(1) << "OnPadLength: " << trailing_length;
+ QUICHE_DVLOG(1) << "OnPadLength: " << trailing_length;
opt_pad_length_ = trailing_length;
QUICHE_DCHECK_LT(trailing_length, 256u);
if (frame_header_.type == Http2FrameType::DATA) {
@@ -539,7 +541,7 @@
void Http2DecoderAdapter::OnPadding(const char* /*padding*/,
size_t skipped_length) {
- SPDY_DVLOG(1) << "OnPadding: " << skipped_length;
+ QUICHE_DVLOG(1) << "OnPadding: " << skipped_length;
if (frame_header_.type == Http2FrameType::DATA) {
visitor()->OnStreamPadding(stream_id(), skipped_length);
} else {
@@ -549,7 +551,7 @@
void Http2DecoderAdapter::OnRstStream(const Http2FrameHeader& header,
Http2ErrorCode http2_error_code) {
- SPDY_DVLOG(1) << "OnRstStream: " << header << "; code=" << http2_error_code;
+ QUICHE_DVLOG(1) << "OnRstStream: " << header << "; code=" << http2_error_code;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
SpdyErrorCode error_code =
ParseErrorCode(static_cast<uint32_t>(http2_error_code));
@@ -558,7 +560,7 @@
}
void Http2DecoderAdapter::OnSettingsStart(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnSettingsStart: " << header;
+ QUICHE_DVLOG(1) << "OnSettingsStart: " << header;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) {
frame_header_ = header;
has_frame_header_ = true;
@@ -567,7 +569,7 @@
}
void Http2DecoderAdapter::OnSetting(const Http2SettingFields& setting_fields) {
- SPDY_DVLOG(1) << "OnSetting: " << setting_fields;
+ QUICHE_DVLOG(1) << "OnSetting: " << setting_fields;
const auto parameter = static_cast<SpdySettingsId>(setting_fields.parameter);
visitor()->OnSetting(parameter, setting_fields.value);
if (extension_ != nullptr) {
@@ -576,12 +578,12 @@
}
void Http2DecoderAdapter::OnSettingsEnd() {
- SPDY_DVLOG(1) << "OnSettingsEnd";
+ QUICHE_DVLOG(1) << "OnSettingsEnd";
visitor()->OnSettingsEnd();
}
void Http2DecoderAdapter::OnSettingsAck(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnSettingsAck: " << header;
+ QUICHE_DVLOG(1) << "OnSettingsAck: " << header;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) {
visitor()->OnSettingsAck();
}
@@ -591,8 +593,9 @@
const Http2FrameHeader& header,
const Http2PushPromiseFields& promise,
size_t total_padding_length) {
- SPDY_DVLOG(1) << "OnPushPromiseStart: " << header << "; promise: " << promise
- << "; total_padding_length: " << total_padding_length;
+ QUICHE_DVLOG(1) << "OnPushPromiseStart: " << header
+ << "; promise: " << promise
+ << "; total_padding_length: " << total_padding_length;
if (IsOkToStartFrame(header) && HasRequiredStreamId(header)) {
if (promise.promised_stream_id == 0) {
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, "");
@@ -608,14 +611,14 @@
}
void Http2DecoderAdapter::OnPushPromiseEnd() {
- SPDY_DVLOG(1) << "OnPushPromiseEnd";
+ QUICHE_DVLOG(1) << "OnPushPromiseEnd";
CommonHpackFragmentEnd();
opt_pad_length_.reset();
}
void Http2DecoderAdapter::OnPing(const Http2FrameHeader& header,
const Http2PingFields& ping) {
- SPDY_DVLOG(1) << "OnPing: " << header << "; ping: " << ping;
+ QUICHE_DVLOG(1) << "OnPing: " << header << "; ping: " << ping;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) {
visitor()->OnPing(ToSpdyPingId(ping), false);
}
@@ -623,7 +626,7 @@
void Http2DecoderAdapter::OnPingAck(const Http2FrameHeader& header,
const Http2PingFields& ping) {
- SPDY_DVLOG(1) << "OnPingAck: " << header << "; ping: " << ping;
+ QUICHE_DVLOG(1) << "OnPingAck: " << header << "; ping: " << ping;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) {
visitor()->OnPing(ToSpdyPingId(ping), true);
}
@@ -631,7 +634,7 @@
void Http2DecoderAdapter::OnGoAwayStart(const Http2FrameHeader& header,
const Http2GoAwayFields& goaway) {
- SPDY_DVLOG(1) << "OnGoAwayStart: " << header << "; goaway: " << goaway;
+ QUICHE_DVLOG(1) << "OnGoAwayStart: " << header << "; goaway: " << goaway;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header)) {
frame_header_ = header;
has_frame_header_ = true;
@@ -642,18 +645,19 @@
}
void Http2DecoderAdapter::OnGoAwayOpaqueData(const char* data, size_t len) {
- SPDY_DVLOG(1) << "OnGoAwayOpaqueData: len=" << len;
+ QUICHE_DVLOG(1) << "OnGoAwayOpaqueData: len=" << len;
visitor()->OnGoAwayFrameData(data, len);
}
void Http2DecoderAdapter::OnGoAwayEnd() {
- SPDY_DVLOG(1) << "OnGoAwayEnd";
+ QUICHE_DVLOG(1) << "OnGoAwayEnd";
visitor()->OnGoAwayFrameData(nullptr, 0);
}
void Http2DecoderAdapter::OnWindowUpdate(const Http2FrameHeader& header,
uint32_t increment) {
- SPDY_DVLOG(1) << "OnWindowUpdate: " << header << "; increment=" << increment;
+ QUICHE_DVLOG(1) << "OnWindowUpdate: " << header
+ << "; increment=" << increment;
if (IsOkToStartFrame(header)) {
visitor()->OnWindowUpdate(header.stream_id, increment);
}
@@ -666,9 +670,9 @@
void Http2DecoderAdapter::OnAltSvcStart(const Http2FrameHeader& header,
size_t origin_length,
size_t value_length) {
- SPDY_DVLOG(1) << "OnAltSvcStart: " << header
- << "; origin_length: " << origin_length
- << "; value_length: " << value_length;
+ QUICHE_DVLOG(1) << "OnAltSvcStart: " << header
+ << "; origin_length: " << origin_length
+ << "; value_length: " << value_length;
if (!IsOkToStartFrame(header)) {
return;
}
@@ -679,24 +683,24 @@
}
void Http2DecoderAdapter::OnAltSvcOriginData(const char* data, size_t len) {
- SPDY_DVLOG(1) << "OnAltSvcOriginData: len=" << len;
+ QUICHE_DVLOG(1) << "OnAltSvcOriginData: len=" << len;
alt_svc_origin_.append(data, len);
}
// Called when decoding the Alt-Svc-Field-Value of an ALTSVC;
// the field is uninterpreted.
void Http2DecoderAdapter::OnAltSvcValueData(const char* data, size_t len) {
- SPDY_DVLOG(1) << "OnAltSvcValueData: len=" << len;
+ QUICHE_DVLOG(1) << "OnAltSvcValueData: len=" << len;
alt_svc_value_.append(data, len);
}
void Http2DecoderAdapter::OnAltSvcEnd() {
- SPDY_DVLOG(1) << "OnAltSvcEnd: origin.size(): " << alt_svc_origin_.size()
- << "; value.size(): " << alt_svc_value_.size();
+ QUICHE_DVLOG(1) << "OnAltSvcEnd: origin.size(): " << alt_svc_origin_.size()
+ << "; value.size(): " << alt_svc_value_.size();
SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
if (!SpdyAltSvcWireFormat::ParseHeaderFieldValue(alt_svc_value_,
&altsvc_vector)) {
- SPDY_DLOG(ERROR) << "SpdyAltSvcWireFormat::ParseHeaderFieldValue failed.";
+ QUICHE_DLOG(ERROR) << "SpdyAltSvcWireFormat::ParseHeaderFieldValue failed.";
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_CONTROL_FRAME, "");
return;
}
@@ -711,9 +715,9 @@
void Http2DecoderAdapter::OnPriorityUpdateStart(
const Http2FrameHeader& header,
const Http2PriorityUpdateFields& priority_update) {
- SPDY_DVLOG(1) << "OnPriorityUpdateStart: " << header
- << "; prioritized_stream_id: "
- << priority_update.prioritized_stream_id;
+ QUICHE_DVLOG(1) << "OnPriorityUpdateStart: " << header
+ << "; prioritized_stream_id: "
+ << priority_update.prioritized_stream_id;
if (IsOkToStartFrame(header) && HasRequiredStreamIdZero(header) &&
HasRequiredStreamId(priority_update.prioritized_stream_id)) {
frame_header_ = header;
@@ -724,13 +728,13 @@
void Http2DecoderAdapter::OnPriorityUpdatePayload(const char* data,
size_t len) {
- SPDY_DVLOG(1) << "OnPriorityUpdatePayload: len=" << len;
+ QUICHE_DVLOG(1) << "OnPriorityUpdatePayload: len=" << len;
priority_field_value_.append(data, len);
}
void Http2DecoderAdapter::OnPriorityUpdateEnd() {
- SPDY_DVLOG(1) << "OnPriorityUpdateEnd: priority_field_value.size(): "
- << priority_field_value_.size();
+ QUICHE_DVLOG(1) << "OnPriorityUpdateEnd: priority_field_value.size(): "
+ << priority_field_value_.size();
visitor()->OnPriorityUpdate(prioritized_stream_id_, priority_field_value_);
priority_field_value_.clear();
}
@@ -738,7 +742,7 @@
// Except for BLOCKED frames, all other unknown frames are either dropped or
// passed to a registered extension.
void Http2DecoderAdapter::OnUnknownStart(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnUnknownStart: " << header;
+ QUICHE_DVLOG(1) << "OnUnknownStart: " << header;
if (IsOkToStartFrame(header)) {
if (extension_ != nullptr) {
const uint8_t type = static_cast<uint8_t>(header.type);
@@ -753,19 +757,19 @@
if (handling_extension_payload_) {
extension_->OnFramePayload(data, len);
} else {
- SPDY_DVLOG(1) << "OnUnknownPayload: len=" << len;
+ QUICHE_DVLOG(1) << "OnUnknownPayload: len=" << len;
}
}
void Http2DecoderAdapter::OnUnknownEnd() {
- SPDY_DVLOG(1) << "OnUnknownEnd";
+ QUICHE_DVLOG(1) << "OnUnknownEnd";
handling_extension_payload_ = false;
}
void Http2DecoderAdapter::OnPaddingTooLong(const Http2FrameHeader& header,
size_t missing_length) {
- SPDY_DVLOG(1) << "OnPaddingTooLong: " << header
- << "; missing_length: " << missing_length;
+ QUICHE_DVLOG(1) << "OnPaddingTooLong: " << header
+ << "; missing_length: " << missing_length;
if (header.type == Http2FrameType::DATA) {
if (header.payload_length == 0) {
QUICHE_DCHECK_EQ(1u, missing_length);
@@ -778,7 +782,7 @@
}
void Http2DecoderAdapter::OnFrameSizeError(const Http2FrameHeader& header) {
- SPDY_DVLOG(1) << "OnFrameSizeError: " << header;
+ QUICHE_DVLOG(1) << "OnFrameSizeError: " << header;
size_t recv_limit = recv_frame_size_limit_;
if (header.payload_length > recv_limit) {
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_OVERSIZED_PAYLOAD, "");
@@ -809,8 +813,8 @@
if (spdy_state_ != SpdyState::SPDY_ERROR) {
DetermineSpdyState(status);
} else {
- SPDY_VLOG(1) << "ProcessInputFrame spdy_framer_error_="
- << SpdyFramerErrorToString(spdy_framer_error_);
+ QUICHE_VLOG(1) << "ProcessInputFrame spdy_framer_error_="
+ << SpdyFramerErrorToString(spdy_framer_error_);
if (spdy_framer_error_ == SpdyFramerError::SPDY_INVALID_PADDING &&
has_frame_header_ && frame_type() != Http2FrameType::DATA) {
// spdy_framer_test checks that all of the available frame payload
@@ -818,8 +822,8 @@
size_t total = remaining_total_payload();
if (total <= frame_header().payload_length) {
size_t avail = db.MinLengthRemaining(total);
- SPDY_VLOG(1) << "Skipping past " << avail << " bytes, of " << total
- << " total remaining in the frame's payload.";
+ QUICHE_VLOG(1) << "Skipping past " << avail << " bytes, of " << total
+ << " total remaining in the frame's payload.";
db.AdvanceCursor(avail);
} else {
QUICHE_BUG(spdy_bug_1_2)
@@ -841,11 +845,11 @@
QUICHE_DCHECK(!HasError()) << spdy_framer_error_;
switch (status) {
case DecodeStatus::kDecodeDone:
- SPDY_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeDone";
+ QUICHE_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeDone";
ResetBetweenFrames();
break;
case DecodeStatus::kDecodeInProgress:
- SPDY_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeInProgress";
+ QUICHE_DVLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeInProgress";
if (decoded_frame_header_) {
if (IsDiscardingPayload()) {
set_spdy_state(SpdyState::SPDY_IGNORE_REMAINING_PAYLOAD);
@@ -865,7 +869,7 @@
}
break;
case DecodeStatus::kDecodeError:
- SPDY_VLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeError";
+ QUICHE_VLOG(1) << "ProcessInputFrame -> DecodeStatus::kDecodeError";
if (IsDiscardingPayload()) {
if (remaining_total_payload() == 0) {
// Push the Http2FrameDecoder out of state kDiscardPayload now
@@ -921,7 +925,7 @@
}
void Http2DecoderAdapter::set_spdy_state(SpdyState v) {
- SPDY_DVLOG(2) << "set_spdy_state(" << StateToString(v) << ")";
+ QUICHE_DVLOG(2) << "set_spdy_state(" << StateToString(v) << ")";
spdy_state_ = v;
}
@@ -930,8 +934,8 @@
if (HasError()) {
QUICHE_DCHECK_EQ(spdy_state_, SpdyState::SPDY_ERROR);
} else {
- SPDY_VLOG(2) << "SetSpdyErrorAndNotify(" << SpdyFramerErrorToString(error)
- << ")";
+ QUICHE_VLOG(2) << "SetSpdyErrorAndNotify(" << SpdyFramerErrorToString(error)
+ << ")";
QUICHE_DCHECK_NE(error, SpdyFramerError::SPDY_NO_ERROR);
spdy_framer_error_ = error;
set_spdy_state(SpdyState::SPDY_ERROR);
@@ -974,33 +978,33 @@
bool Http2DecoderAdapter::IsReadingPaddingLength() {
bool result = frame_header_.IsPadded() && !opt_pad_length_;
- SPDY_DVLOG(2) << "Http2DecoderAdapter::IsReadingPaddingLength: " << result;
+ QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsReadingPaddingLength: " << result;
return result;
}
bool Http2DecoderAdapter::IsSkippingPadding() {
bool result = frame_header_.IsPadded() && opt_pad_length_ &&
frame_decoder_->remaining_payload() == 0 &&
frame_decoder_->remaining_padding() > 0;
- SPDY_DVLOG(2) << "Http2DecoderAdapter::IsSkippingPadding: " << result;
+ QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsSkippingPadding: " << result;
return result;
}
bool Http2DecoderAdapter::IsDiscardingPayload() {
bool result = decoded_frame_header_ && frame_decoder_->IsDiscardingPayload();
- SPDY_DVLOG(2) << "Http2DecoderAdapter::IsDiscardingPayload: " << result;
+ QUICHE_DVLOG(2) << "Http2DecoderAdapter::IsDiscardingPayload: " << result;
return result;
}
// Called from OnXyz or OnXyzStart methods to decide whether it is OK to
// handle the callback.
bool Http2DecoderAdapter::IsOkToStartFrame(const Http2FrameHeader& header) {
- SPDY_DVLOG(3) << "IsOkToStartFrame";
+ QUICHE_DVLOG(3) << "IsOkToStartFrame";
if (HasError()) {
- SPDY_VLOG(2) << "HasError()";
+ QUICHE_VLOG(2) << "HasError()";
return false;
}
QUICHE_DCHECK(!has_frame_header_);
if (has_expected_frame_type_ && header.type != expected_frame_type_) {
- SPDY_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not "
- << header.type;
+ QUICHE_VLOG(1) << "Expected frame type " << expected_frame_type_ << ", not "
+ << header.type;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_UNEXPECTED_FRAME, "");
return false;
}
@@ -1009,15 +1013,15 @@
}
bool Http2DecoderAdapter::HasRequiredStreamId(uint32_t stream_id) {
- SPDY_DVLOG(3) << "HasRequiredStreamId: " << stream_id;
+ QUICHE_DVLOG(3) << "HasRequiredStreamId: " << stream_id;
if (HasError()) {
- SPDY_VLOG(2) << "HasError()";
+ QUICHE_VLOG(2) << "HasError()";
return false;
}
if (stream_id != 0) {
return true;
}
- SPDY_VLOG(1) << "Stream Id is required, but zero provided";
+ QUICHE_VLOG(1) << "Stream Id is required, but zero provided";
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, "");
return false;
}
@@ -1027,15 +1031,15 @@
}
bool Http2DecoderAdapter::HasRequiredStreamIdZero(uint32_t stream_id) {
- SPDY_DVLOG(3) << "HasRequiredStreamIdZero: " << stream_id;
+ QUICHE_DVLOG(3) << "HasRequiredStreamIdZero: " << stream_id;
if (HasError()) {
- SPDY_VLOG(2) << "HasError()";
+ QUICHE_VLOG(2) << "HasError()";
return false;
}
if (stream_id == 0) {
return true;
}
- SPDY_VLOG(1) << "Stream Id was not zero, as required: " << stream_id;
+ QUICHE_VLOG(1) << "Stream Id was not zero, as required: " << stream_id;
SetSpdyErrorAndNotify(SpdyFramerError::SPDY_INVALID_STREAM_ID, "");
return false;
}
@@ -1062,7 +1066,7 @@
}
void Http2DecoderAdapter::CommonStartHpackBlock() {
- SPDY_DVLOG(1) << "CommonStartHpackBlock";
+ QUICHE_DVLOG(1) << "CommonStartHpackBlock";
QUICHE_DCHECK(!has_hpack_first_frame_header_);
if (!frame_header_.IsEndHeaders()) {
hpack_first_frame_header_ = frame_header_;
@@ -1091,9 +1095,9 @@
}
void Http2DecoderAdapter::CommonHpackFragmentEnd() {
- SPDY_DVLOG(1) << "CommonHpackFragmentEnd: stream_id=" << stream_id();
+ QUICHE_DVLOG(1) << "CommonHpackFragmentEnd: stream_id=" << stream_id();
if (HasError()) {
- SPDY_VLOG(1) << "HasError(), returning";
+ QUICHE_VLOG(1) << "HasError(), returning";
return;
}
QUICHE_DCHECK(has_frame_header_);
