Replaces all flavors of SPDY_LOG with the QUICHE equivalents.
PiperOrigin-RevId: 367497148
Change-Id: I5a7092649df7d919d23bc80a3cd1f4002472fa22
diff --git a/http2/core/http2_priority_write_scheduler.h b/http2/core/http2_priority_write_scheduler.h
index 27e84ad..efc4d7f 100644
--- a/http2/core/http2_priority_write_scheduler.h
+++ b/http2/core/http2_priority_write_scheduler.h
@@ -20,10 +20,10 @@
#include "absl/strings/str_cat.h"
#include "http2/core/write_scheduler.h"
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/spdy_intrusive_list.h"
#include "spdy/core/spdy_protocol.h"
#include "spdy/platform/api/spdy_containers.h"
-#include "spdy/platform/api/spdy_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
namespace http2 {
@@ -233,8 +233,8 @@
StreamInfo* parent = FindStream(precedence.parent_id());
if (parent == nullptr) {
// parent_id may legitimately not be registered yet--see b/15676312.
- SPDY_VLOG(1) << "Parent stream " << precedence.parent_id()
- << " not registered";
+ QUICHE_VLOG(1) << "Parent stream " << precedence.parent_id()
+ << " not registered";
parent = root_stream_info_;
}
@@ -322,7 +322,7 @@
if (stream_info == nullptr) {
// Unknown streams tolerated due to b/15676312. However, return lowest
// weight.
- SPDY_VLOG(1) << "Stream " << stream_id << " not registered";
+ QUICHE_VLOG(1) << "Stream " << stream_id << " not registered";
return StreamPrecedenceType(spdy::kHttp2RootStreamId,
spdy::kHttp2MinStreamWeight, false);
}
@@ -364,7 +364,7 @@
StreamInfo* stream_info = FindStream(stream_id);
if (stream_info == nullptr) {
// TODO(mpw): add to all_stream_infos_ on demand--see b/15676312.
- SPDY_VLOG(1) << "Stream " << stream_id << " not registered";
+ QUICHE_VLOG(1) << "Stream " << stream_id << " not registered";
return;
}
UpdateStreamParent(stream_info, precedence.parent_id(),
@@ -400,7 +400,7 @@
StreamInfo* new_parent = FindStream(parent_id);
if (new_parent == nullptr) {
// parent_id may legitimately not be registered yet--see b/15676312.
- SPDY_VLOG(1) << "Parent stream " << parent_id << " not registered";
+ QUICHE_VLOG(1) << "Parent stream " << parent_id << " not registered";
return;
}
@@ -734,8 +734,8 @@
// Verify each StreamInfo mapped under the proper stream ID.
if (stream_id != stream_info.id) {
- SPDY_DLOG(INFO) << "Stream ID " << stream_id
- << " maps to StreamInfo with ID " << stream_info.id;
+ QUICHE_DLOG(INFO) << "Stream ID " << stream_id
+ << " maps to StreamInfo with ID " << stream_info.id;
return false;
}
@@ -743,9 +743,9 @@
// the children of that parent.
if (stream_info.id != spdy::kHttp2RootStreamId &&
!StreamHasChild(*stream_info.parent, &stream_info)) {
- SPDY_DLOG(INFO) << "Parent stream " << stream_info.parent->id
- << " is not registered, or does not list stream "
- << stream_info.id << " as its child.";
+ QUICHE_DLOG(INFO) << "Parent stream " << stream_info.parent->id
+ << " is not registered, or does not list stream "
+ << stream_info.id << " as its child.";
return false;
}
@@ -757,20 +757,19 @@
// Each stream in the list should exist and should have this stream
// set as its parent.
if (!StreamRegistered(child->id) || child->parent != &stream_info) {
- SPDY_DLOG(INFO) << "Child stream " << child->id
- << " is not registered, "
- << "or does not list " << stream_info.id
- << " as its parent.";
+ QUICHE_DLOG(INFO)
+ << "Child stream " << child->id << " is not registered, "
+ << "or does not list " << stream_info.id << " as its parent.";
return false;
}
total_child_weights += child->weight;
}
// Verify that total_child_weights is correct.
if (total_child_weights != stream_info.total_child_weights) {
- SPDY_DLOG(INFO) << "Child weight totals do not agree. For stream "
- << stream_info.id << " total_child_weights has value "
- << stream_info.total_child_weights << ", expected "
- << total_child_weights;
+ QUICHE_DLOG(INFO) << "Child weight totals do not agree. For stream "
+ << stream_info.id << " total_child_weights has value "
+ << stream_info.total_child_weights << ", expected "
+ << total_child_weights;
return false;
}
}
@@ -779,7 +778,7 @@
// Make sure NumRegisteredStreams() reflects the total number of streams the
// map contains.
if (total_streams != NumRegisteredStreams()) {
- SPDY_DLOG(INFO) << "Map contains incorrect number of streams.";
+ QUICHE_DLOG(INFO) << "Map contains incorrect number of streams.";
return false;
}
// Validate the validation function; we should have visited each stream twice
diff --git a/http2/core/priority_write_scheduler.h b/http2/core/priority_write_scheduler.h
index 1014050..b59e294 100644
--- a/http2/core/priority_write_scheduler.h
+++ b/http2/core/priority_write_scheduler.h
@@ -18,8 +18,8 @@
#include "absl/strings/str_cat.h"
#include "http2/core/write_scheduler.h"
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/spdy_protocol.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace http2 {
@@ -56,8 +56,8 @@
// parent_id not used here, but may as well validate it. However,
// parent_id may legitimately not be registered yet--see b/15676312.
StreamIdType parent_id = precedence.parent_id();
- SPDY_DVLOG_IF(1,
- parent_id != root_stream_id_ && !StreamRegistered(parent_id))
+ QUICHE_DVLOG_IF(
+ 1, parent_id != root_stream_id_ && !StreamRegistered(parent_id))
<< "Parent stream " << parent_id << " not registered";
if (stream_id == root_stream_id_) {
@@ -95,7 +95,7 @@
StreamIdType stream_id) const override {
auto it = stream_infos_.find(stream_id);
if (it == stream_infos_.end()) {
- SPDY_DVLOG(1) << "Stream " << stream_id << " not registered";
+ QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered";
return StreamPrecedenceType(spdy::kV3LowestPriority);
}
return StreamPrecedenceType(it->second.priority);
@@ -109,14 +109,14 @@
// parent_id not used here, but may as well validate it. However,
// parent_id may legitimately not be registered yet--see b/15676312.
StreamIdType parent_id = precedence.parent_id();
- SPDY_DVLOG_IF(1,
- parent_id != root_stream_id_ && !StreamRegistered(parent_id))
+ QUICHE_DVLOG_IF(
+ 1, parent_id != root_stream_id_ && !StreamRegistered(parent_id))
<< "Parent stream " << parent_id << " not registered";
auto it = stream_infos_.find(stream_id);
if (it == stream_infos_.end()) {
// TODO(mpw): add to stream_infos_ on demand--see b/15676312.
- SPDY_DVLOG(1) << "Stream " << stream_id << " not registered";
+ QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered";
return;
}
StreamInfo& stream_info = it->second;
@@ -275,7 +275,7 @@
bool IsStreamReady(StreamIdType stream_id) const override {
auto it = stream_infos_.find(stream_id);
if (it == stream_infos_.end()) {
- SPDY_DLOG(INFO) << "Stream " << stream_id << " not registered";
+ QUICHE_DLOG(INFO) << "Stream " << stream_id << " not registered";
return false;
}
return it->second.ready;
diff --git a/spdy/core/hpack/hpack_constants.cc b/spdy/core/hpack/hpack_constants.cc
index 231fd54..a8e48a2 100644
--- a/spdy/core/hpack/hpack_constants.cc
+++ b/spdy/core/hpack/hpack_constants.cc
@@ -9,8 +9,8 @@
#include <vector>
#include "absl/base/macros.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/hpack/hpack_static_table.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
diff --git a/spdy/core/hpack/hpack_decoder_adapter.cc b/spdy/core/hpack/hpack_decoder_adapter.cc
index 4d03cc5..eed658b 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter.cc
@@ -6,9 +6,9 @@
#include "http2/decoder/decode_buffer.h"
#include "http2/decoder/decode_status.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
#include "spdy/platform/api/spdy_flags.h"
-#include "spdy/platform/api/spdy_logging.h"
using ::http2::DecodeBuffer;
@@ -27,13 +27,13 @@
HpackDecoderAdapter::~HpackDecoderAdapter() = default;
void HpackDecoderAdapter::ApplyHeaderTableSizeSetting(size_t size_setting) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::ApplyHeaderTableSizeSetting";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::ApplyHeaderTableSizeSetting";
hpack_decoder_.ApplyHeaderTableSizeSetting(size_setting);
}
void HpackDecoderAdapter::HandleControlFrameHeadersStart(
SpdyHeadersHandlerInterface* handler) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersStart";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersStart";
QUICHE_DCHECK(!header_block_started_);
listener_adapter_.set_handler(handler);
}
@@ -41,8 +41,8 @@
bool HpackDecoderAdapter::HandleControlFrameHeadersData(
const char* headers_data,
size_t headers_data_length) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersData: len="
- << headers_data_length;
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersData: len="
+ << headers_data_length;
if (!header_block_started_) {
// Initialize the decoding process here rather than in
// HandleControlFrameHeadersStart because that method is not always called.
@@ -61,9 +61,9 @@
if (headers_data_length > 0) {
QUICHE_DCHECK_NE(headers_data, nullptr);
if (headers_data_length > max_decode_buffer_size_bytes_) {
- SPDY_DVLOG(1) << "max_decode_buffer_size_bytes_ < headers_data_length: "
- << max_decode_buffer_size_bytes_ << " < "
- << headers_data_length;
+ QUICHE_DVLOG(1) << "max_decode_buffer_size_bytes_ < headers_data_length: "
+ << max_decode_buffer_size_bytes_ << " < "
+ << headers_data_length;
error_ = http2::HpackDecodingError::kFragmentTooLong;
detailed_error_ = "";
return false;
@@ -89,12 +89,12 @@
bool HpackDecoderAdapter::HandleControlFrameHeadersComplete(
size_t* compressed_len) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersComplete";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::HandleControlFrameHeadersComplete";
if (compressed_len != nullptr) {
*compressed_len = listener_adapter_.total_hpack_bytes();
}
if (!hpack_decoder_.EndDecodingBlock()) {
- SPDY_DVLOG(3) << "EndDecodingBlock returned false";
+ QUICHE_DVLOG(3) << "EndDecodingBlock returned false";
error_ = hpack_decoder_.error();
detailed_error_ = hpack_decoder_.detailed_error();
return false;
@@ -109,7 +109,7 @@
void HpackDecoderAdapter::set_max_decode_buffer_size_bytes(
size_t max_decode_buffer_size_bytes) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::set_max_decode_buffer_size_bytes";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::set_max_decode_buffer_size_bytes";
max_decode_buffer_size_bytes_ = max_decode_buffer_size_bytes;
hpack_decoder_.set_max_string_size_bytes(max_decode_buffer_size_bytes);
}
@@ -132,7 +132,7 @@
}
void HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart() {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListStart";
total_hpack_bytes_ = 0;
total_uncompressed_bytes_ = 0;
decoded_block_.clear();
@@ -143,20 +143,20 @@
void HpackDecoderAdapter::ListenerAdapter::OnHeader(const std::string& name,
const std::string& value) {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeader:\n name: "
- << name << "\n value: " << value;
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeader:\n name: "
+ << name << "\n value: " << value;
total_uncompressed_bytes_ += name.size() + value.size();
if (handler_ == nullptr) {
- SPDY_DVLOG(3) << "Adding to decoded_block";
+ QUICHE_DVLOG(3) << "Adding to decoded_block";
decoded_block_.AppendValueOrAddHeader(name, value);
} else {
- SPDY_DVLOG(3) << "Passing to handler";
+ QUICHE_DVLOG(3) << "Passing to handler";
handler_->OnHeader(name, value);
}
}
void HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd() {
- SPDY_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd";
+ QUICHE_DVLOG(2) << "HpackDecoderAdapter::ListenerAdapter::OnHeaderListEnd";
// We don't clear the SpdyHeaderBlock here to allow access to it until the
// next HPACK block is decoded.
if (handler_ != nullptr) {
@@ -167,7 +167,7 @@
void HpackDecoderAdapter::ListenerAdapter::OnHeaderErrorDetected(
absl::string_view error_message) {
- SPDY_VLOG(1) << error_message;
+ QUICHE_VLOG(1) << error_message;
}
} // namespace spdy
diff --git a/spdy/core/hpack/hpack_decoder_adapter_test.cc b/spdy/core/hpack/hpack_decoder_adapter_test.cc
index 0a12fe4..44597ef 100644
--- a/spdy/core/hpack/hpack_decoder_adapter_test.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter_test.cc
@@ -18,13 +18,13 @@
#include "http2/hpack/decoder/hpack_decoder_tables.h"
#include "http2/hpack/tools/hpack_block_builder.h"
#include "http2/test_tools/http2_random.h"
+#include "common/platform/api/quiche_logging.h"
#include "common/platform/api/quiche_test.h"
#include "spdy/core/hpack/hpack_constants.h"
#include "spdy/core/hpack/hpack_encoder.h"
#include "spdy/core/hpack/hpack_output_stream.h"
#include "spdy/core/recording_headers_handler.h"
#include "spdy/core/spdy_test_utils.h"
-#include "spdy/platform/api/spdy_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
using ::http2::HpackEntryType;
@@ -134,7 +134,7 @@
}
bool HandleControlFrameHeadersData(absl::string_view str) {
- SPDY_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str);
+ QUICHE_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str);
bytes_passed_in_ += str.size();
return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
}
diff --git a/spdy/core/hpack/hpack_encoder.cc b/spdy/core/hpack/hpack_encoder.cc
index 4c2907b..3fa453a 100644
--- a/spdy/core/hpack/hpack_encoder.cc
+++ b/spdy/core/hpack/hpack_encoder.cc
@@ -10,13 +10,13 @@
#include "http2/hpack/huffman/hpack_huffman_encoder.h"
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/hpack/hpack_constants.h"
#include "spdy/core/hpack/hpack_header_table.h"
#include "spdy/core/hpack/hpack_output_stream.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
#include "spdy/platform/api/spdy_flag_utils.h"
#include "spdy/platform/api/spdy_flags.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
@@ -156,14 +156,14 @@
}
void HpackEncoder::EmitIndex(size_t index) {
- SPDY_DVLOG(2) << "Emitting index " << index;
+ QUICHE_DVLOG(2) << "Emitting index " << index;
output_stream_.AppendPrefix(kIndexedOpcode);
output_stream_.AppendUint32(index);
}
void HpackEncoder::EmitIndexedLiteral(const Representation& representation) {
- SPDY_DVLOG(2) << "Emitting indexed literal: (" << representation.first << ", "
- << representation.second << ")";
+ QUICHE_DVLOG(2) << "Emitting indexed literal: (" << representation.first
+ << ", " << representation.second << ")";
output_stream_.AppendPrefix(kLiteralIncrementalIndexOpcode);
EmitLiteral(representation);
header_table_.TryAddEntry(representation.first, representation.second);
@@ -171,8 +171,8 @@
void HpackEncoder::EmitNonIndexedLiteral(const Representation& representation,
bool enable_compression) {
- SPDY_DVLOG(2) << "Emitting nonindexed literal: (" << representation.first
- << ", " << representation.second << ")";
+ QUICHE_DVLOG(2) << "Emitting nonindexed literal: (" << representation.first
+ << ", " << representation.second << ")";
output_stream_.AppendPrefix(kLiteralNoIndexOpcode);
size_t name_index = header_table_.GetByName(representation.first);
if (enable_compression && name_index != kHpackEntryNotFound) {
@@ -199,13 +199,13 @@
size_t encoded_size =
enable_compression_ ? http2::HuffmanSize(str) : str.size();
if (encoded_size < str.size()) {
- SPDY_DVLOG(2) << "Emitted Huffman-encoded string of length "
- << encoded_size;
+ QUICHE_DVLOG(2) << "Emitted Huffman-encoded string of length "
+ << encoded_size;
output_stream_.AppendPrefix(kStringLiteralHuffmanEncoded);
output_stream_.AppendUint32(encoded_size);
http2::HuffmanEncodeFast(str, encoded_size, output_stream_.MutableString());
} else {
- SPDY_DVLOG(2) << "Emitted literal string of length " << str.size();
+ QUICHE_DVLOG(2) << "Emitted literal string of length " << str.size();
output_stream_.AppendPrefix(kStringLiteralIdentityEncoded);
output_stream_.AppendUint32(str.size());
output_stream_.AppendBytes(str);
@@ -217,9 +217,9 @@
return;
}
const size_t current_size = CurrentHeaderTableSizeSetting();
- SPDY_DVLOG(1) << "MaybeEmitTableSize current_size=" << current_size;
- SPDY_DVLOG(1) << "MaybeEmitTableSize min_table_size_setting_received_="
- << min_table_size_setting_received_;
+ QUICHE_DVLOG(1) << "MaybeEmitTableSize current_size=" << current_size;
+ QUICHE_DVLOG(1) << "MaybeEmitTableSize min_table_size_setting_received_="
+ << min_table_size_setting_received_;
if (min_table_size_setting_received_ < current_size) {
output_stream_.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream_.AppendUint32(min_table_size_setting_received_);
diff --git a/spdy/core/hpack/hpack_entry.cc b/spdy/core/hpack/hpack_entry.cc
index b8350df..4deb0df 100644
--- a/spdy/core/hpack/hpack_entry.cc
+++ b/spdy/core/hpack/hpack_entry.cc
@@ -6,7 +6,6 @@
#include "absl/strings/str_cat.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
diff --git a/spdy/core/hpack/hpack_header_table.cc b/spdy/core/hpack/hpack_header_table.cc
index ec69d47..8536a85 100644
--- a/spdy/core/hpack/hpack_header_table.cc
+++ b/spdy/core/hpack/hpack_header_table.cc
@@ -6,10 +6,10 @@
#include <algorithm>
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/hpack/hpack_constants.h"
#include "spdy/core/hpack/hpack_static_table.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
@@ -155,9 +155,9 @@
if (!index_result.second) {
// An entry with the same name and value already exists in the dynamic
// index. We should replace it with the newly added entry.
- SPDY_DVLOG(1) << "Found existing entry at: " << index_result.first->second
- << " replacing with: " << new_entry->GetDebugString()
- << " at: " << index;
+ QUICHE_DVLOG(1) << "Found existing entry at: " << index_result.first->second
+ << " replacing with: " << new_entry->GetDebugString()
+ << " at: " << index;
QUICHE_DCHECK_GT(index, index_result.first->second);
dynamic_index_.erase(index_result.first);
auto insert_result = dynamic_index_.insert(std::make_pair(
@@ -170,9 +170,9 @@
if (!name_result.second) {
// An entry with the same name already exists in the dynamic index. We
// should replace it with the newly added entry.
- SPDY_DVLOG(1) << "Found existing entry at: " << name_result.first->second
- << " replacing with: " << new_entry->GetDebugString()
- << " at: " << index;
+ QUICHE_DVLOG(1) << "Found existing entry at: " << name_result.first->second
+ << " replacing with: " << new_entry->GetDebugString()
+ << " at: " << index;
QUICHE_DCHECK_GT(index, name_result.first->second);
dynamic_name_index_.erase(name_result.first);
auto insert_result =
diff --git a/spdy/core/hpack/hpack_output_stream.cc b/spdy/core/hpack/hpack_output_stream.cc
index d2ec46c..7b92568 100644
--- a/spdy/core/hpack/hpack_output_stream.cc
+++ b/spdy/core/hpack/hpack_output_stream.cc
@@ -6,8 +6,8 @@
#include <utility>
+#include "common/platform/api/quiche_logging.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
diff --git a/spdy/core/hpack/hpack_static_table.cc b/spdy/core/hpack/hpack_static_table.cc
index 8c8248c..7594943 100644
--- a/spdy/core/hpack/hpack_static_table.cc
+++ b/spdy/core/hpack/hpack_static_table.cc
@@ -5,10 +5,10 @@
#include "spdy/core/hpack/hpack_static_table.h"
#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/hpack/hpack_constants.h"
#include "spdy/core/hpack/hpack_entry.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
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_);
diff --git a/spdy/core/spdy_alt_svc_wire_format.cc b/spdy/core/spdy_alt_svc_wire_format.cc
index 5b6af98..dd35a48 100644
--- a/spdy/core/spdy_alt_svc_wire_format.cc
+++ b/spdy/core/spdy_alt_svc_wire_format.cc
@@ -9,7 +9,8 @@
#include <limits>
#include "absl/strings/str_cat.h"
-#include "spdy/platform/api/spdy_logging.h"
+
+#include "common/platform/api/quiche_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
namespace spdy {
diff --git a/spdy/core/spdy_alt_svc_wire_format_test.cc b/spdy/core/spdy_alt_svc_wire_format_test.cc
index e698c2f..80f846d 100644
--- a/spdy/core/spdy_alt_svc_wire_format_test.cc
+++ b/spdy/core/spdy_alt_svc_wire_format_test.cc
@@ -5,7 +5,6 @@
#include "spdy/core/spdy_alt_svc_wire_format.h"
#include "common/platform/api/quiche_test.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
diff --git a/spdy/core/spdy_frame_builder.cc b/spdy/core/spdy_frame_builder.cc
index d50668e..0b75271 100644
--- a/spdy/core/spdy_frame_builder.cc
+++ b/spdy/core/spdy_frame_builder.cc
@@ -10,9 +10,9 @@
#include <new>
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/spdy_protocol.h"
#include "spdy/core/zero_copy_output_buffer.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
@@ -168,8 +168,9 @@
if (output_ == nullptr) {
if (offset_ + length_ + length > capacity_) {
- SPDY_DLOG(FATAL) << "Requested: " << length << " capacity: " << capacity_
- << " used: " << offset_ + length_;
+ QUICHE_DLOG(FATAL) << "Requested: " << length
+ << " capacity: " << capacity_
+ << " used: " << offset_ + length_;
return false;
}
} else {
diff --git a/spdy/core/spdy_framer.cc b/spdy/core/spdy_framer.cc
index 8569576..d6f0f88 100644
--- a/spdy/core/spdy_framer.cc
+++ b/spdy/core/spdy_framer.cc
@@ -14,11 +14,11 @@
#include "absl/memory/memory.h"
#include "http2/platform/api/http2_macros.h"
#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/spdy_bitmasks.h"
#include "spdy/core/spdy_frame_builder.h"
#include "spdy/core/spdy_frame_reader.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
namespace spdy {
@@ -129,7 +129,8 @@
}
if (!ret) {
- SPDY_DLOG(WARNING) << "Failed to build HEADERS. Not enough space in output";
+ QUICHE_DLOG(WARNING)
+ << "Failed to build HEADERS. Not enough space in output";
}
return ret;
}
@@ -159,7 +160,7 @@
ok = builder.WriteBytes(padding.data(), padding.length());
}
- SPDY_DLOG_IF(ERROR, !ok)
+ QUICHE_DLOG_IF(ERROR, !ok)
<< "Failed to write PUSH_PROMISE encoding, not enough "
<< "space in output";
return ok;
@@ -177,8 +178,8 @@
} else if (type == SpdyFrameType::PUSH_PROMISE) {
end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
} else {
- SPDY_DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
- << FrameTypeToString(type);
+ QUICHE_DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
+ << FrameTypeToString(type);
}
// Write all the padding payload and as much of the data payload as possible
@@ -422,7 +423,7 @@
frame_ir.release())));
}
case SpdyFrameType::DATA: {
- SPDY_DVLOG(1) << "Serialize a stream end DATA frame for VTL";
+ QUICHE_DVLOG(1) << "Serialize a stream end DATA frame for VTL";
HTTP2_FALLTHROUGH;
}
default: {
diff --git a/spdy/core/spdy_framer_test.cc b/spdy/core/spdy_framer_test.cc
index d7fb6a7..eda2c90 100644
--- a/spdy/core/spdy_framer_test.cc
+++ b/spdy/core/spdy_framer_test.cc
@@ -14,6 +14,7 @@
#include <vector>
#include "absl/base/macros.h"
+#include "common/platform/api/quiche_logging.h"
#include "common/platform/api/quiche_test.h"
#include "spdy/core/array_output_buffer.h"
#include "spdy/core/mock_spdy_framer_visitor.h"
@@ -24,7 +25,6 @@
#include "spdy/core/spdy_protocol.h"
#include "spdy/core/spdy_test_utils.h"
#include "spdy/platform/api/spdy_flags.h"
-#include "spdy/platform/api/spdy_logging.h"
#include "spdy/platform/api/spdy_string_utils.h"
using ::http2::Http2DecoderAdapter;
@@ -62,7 +62,7 @@
size_t size_verified = 0;
for (const auto& frame : *frame_list) {
if (arg.size() < size_verified + frame.size()) {
- SPDY_LOG(FATAL)
+ QUICHE_LOG(FATAL)
<< "Incremental header serialization should not lead to a "
<< "higher total frame length than non-incremental method.";
return false;
@@ -268,16 +268,16 @@
void OnError(Http2DecoderAdapter::SpdyFramerError error,
std::string /*detailed_error*/) override {
- SPDY_VLOG(1) << "SpdyFramer Error: "
- << Http2DecoderAdapter::SpdyFramerErrorToString(error);
+ QUICHE_VLOG(1) << "SpdyFramer Error: "
+ << Http2DecoderAdapter::SpdyFramerErrorToString(error);
++error_count_;
}
void OnDataFrameHeader(SpdyStreamId stream_id,
size_t length,
bool fin) override {
- SPDY_VLOG(1) << "OnDataFrameHeader(" << stream_id << ", " << length << ", "
- << fin << ")";
+ QUICHE_VLOG(1) << "OnDataFrameHeader(" << stream_id << ", " << length
+ << ", " << fin << ")";
++data_frame_count_;
header_stream_id_ = stream_id;
}
@@ -285,30 +285,30 @@
void OnStreamFrameData(SpdyStreamId stream_id,
const char* data,
size_t len) override {
- SPDY_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len
- << ", "
- << ") data:\n"
- << SpdyHexDump(absl::string_view(data, len));
+ QUICHE_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len
+ << ", "
+ << ") data:\n"
+ << SpdyHexDump(absl::string_view(data, len));
EXPECT_EQ(header_stream_id_, stream_id);
data_bytes_ += len;
}
void OnStreamEnd(SpdyStreamId stream_id) override {
- SPDY_VLOG(1) << "OnStreamEnd(" << stream_id << ")";
+ QUICHE_VLOG(1) << "OnStreamEnd(" << stream_id << ")";
EXPECT_EQ(header_stream_id_, stream_id);
++end_of_stream_count_;
}
void OnStreamPadLength(SpdyStreamId stream_id, size_t value) override {
- SPDY_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << value << ")\n";
+ QUICHE_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << value << ")\n";
EXPECT_EQ(header_stream_id_, stream_id);
// Count the padding length field byte against total data bytes.
data_bytes_ += 1;
}
void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
- SPDY_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n";
+ QUICHE_VLOG(1) << "OnStreamPadding(" << stream_id << ", " << len << ")\n";
EXPECT_EQ(header_stream_id_, stream_id);
data_bytes_ += len;
}
@@ -329,34 +329,34 @@
}
void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {
- SPDY_VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")";
+ QUICHE_VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")";
++fin_frame_count_;
}
void OnSetting(SpdySettingsId id, uint32_t value) override {
- SPDY_VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")";
+ QUICHE_VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")";
++setting_count_;
}
void OnSettingsAck() override {
- SPDY_VLOG(1) << "OnSettingsAck";
+ QUICHE_VLOG(1) << "OnSettingsAck";
++settings_ack_received_;
}
void OnSettingsEnd() override {
- SPDY_VLOG(1) << "OnSettingsEnd";
+ QUICHE_VLOG(1) << "OnSettingsEnd";
++settings_ack_sent_;
}
void OnPing(SpdyPingId unique_id, bool is_ack) override {
- SPDY_LOG(DFATAL) << "OnPing(" << unique_id << ", " << (is_ack ? 1 : 0)
- << ")";
+ QUICHE_LOG(DFATAL) << "OnPing(" << unique_id << ", " << (is_ack ? 1 : 0)
+ << ")";
}
void OnGoAway(SpdyStreamId last_accepted_stream_id,
SpdyErrorCode error_code) override {
- SPDY_VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", " << error_code
- << ")";
+ QUICHE_VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", "
+ << error_code << ")";
++goaway_count_;
}
@@ -367,9 +367,9 @@
bool exclusive,
bool fin,
bool end) override {
- SPDY_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", "
- << weight << ", " << parent_stream_id << ", " << exclusive
- << ", " << fin << ", " << end << ")";
+ QUICHE_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", "
+ << weight << ", " << parent_stream_id << ", " << exclusive
+ << ", " << fin << ", " << end << ")";
++headers_frame_count_;
InitHeaderStreaming(SpdyFrameType::HEADERS, stream_id);
if (fin) {
@@ -381,8 +381,8 @@
}
void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {
- SPDY_VLOG(1) << "OnWindowUpdate(" << stream_id << ", " << delta_window_size
- << ")";
+ QUICHE_VLOG(1) << "OnWindowUpdate(" << stream_id << ", "
+ << delta_window_size << ")";
last_window_update_stream_ = stream_id;
last_window_update_delta_ = delta_window_size;
}
@@ -390,8 +390,8 @@
void OnPushPromise(SpdyStreamId stream_id,
SpdyStreamId promised_stream_id,
bool end) override {
- SPDY_VLOG(1) << "OnPushPromise(" << stream_id << ", " << promised_stream_id
- << ", " << end << ")";
+ QUICHE_VLOG(1) << "OnPushPromise(" << stream_id << ", "
+ << promised_stream_id << ", " << end << ")";
++push_promise_frame_count_;
InitHeaderStreaming(SpdyFrameType::PUSH_PROMISE, stream_id);
last_push_promise_stream_ = stream_id;
@@ -399,7 +399,7 @@
}
void OnContinuation(SpdyStreamId stream_id, bool end) override {
- SPDY_VLOG(1) << "OnContinuation(" << stream_id << ", " << end << ")";
+ QUICHE_VLOG(1) << "OnContinuation(" << stream_id << ", " << end << ")";
++continuation_count_;
}
@@ -407,8 +407,8 @@
absl::string_view origin,
const SpdyAltSvcWireFormat::AlternativeServiceVector&
altsvc_vector) override {
- SPDY_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
- << "\", altsvc_vector)";
+ QUICHE_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
+ << "\", altsvc_vector)";
test_altsvc_ir_ = std::make_unique<SpdyAltSvcIR>(stream_id);
if (origin.length() > 0) {
test_altsvc_ir_->set_origin(std::string(origin));
@@ -423,19 +423,20 @@
SpdyStreamId parent_stream_id,
int weight,
bool exclusive) override {
- SPDY_VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id
- << ", " << weight << ", " << (exclusive ? 1 : 0) << ")";
+ QUICHE_VLOG(1) << "OnPriority(" << stream_id << ", " << parent_stream_id
+ << ", " << weight << ", " << (exclusive ? 1 : 0) << ")";
++priority_count_;
}
void OnPriorityUpdate(SpdyStreamId prioritized_stream_id,
absl::string_view priority_field_value) override {
- SPDY_VLOG(1) << "OnPriorityUpdate(" << prioritized_stream_id << ", "
- << priority_field_value << ")";
+ QUICHE_VLOG(1) << "OnPriorityUpdate(" << prioritized_stream_id << ", "
+ << priority_field_value << ")";
}
bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override {
- SPDY_VLOG(1) << "OnUnknownFrame(" << stream_id << ", " << frame_type << ")";
+ QUICHE_VLOG(1) << "OnUnknownFrame(" << stream_id << ", " << frame_type
+ << ")";
return on_unknown_frame_result_;
}
@@ -443,8 +444,8 @@
SpdyFrameType type,
size_t payload_len,
size_t frame_len) override {
- SPDY_VLOG(1) << "OnSendCompressedFrame(" << stream_id << ", " << type
- << ", " << payload_len << ", " << frame_len << ")";
+ QUICHE_VLOG(1) << "OnSendCompressedFrame(" << stream_id << ", " << type
+ << ", " << payload_len << ", " << frame_len << ")";
last_payload_len_ = payload_len;
last_frame_len_ = frame_len;
}
@@ -452,8 +453,8 @@
void OnReceiveCompressedFrame(SpdyStreamId stream_id,
SpdyFrameType type,
size_t frame_len) override {
- SPDY_VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type
- << ", " << frame_len << ")";
+ QUICHE_VLOG(1) << "OnReceiveCompressedFrame(" << stream_id << ", " << type
+ << ", " << frame_len << ")";
last_frame_len_ = frame_len;
}
@@ -479,8 +480,9 @@
void InitHeaderStreaming(SpdyFrameType header_control_type,
SpdyStreamId stream_id) {
if (!IsDefinedFrameType(SerializeFrameType(header_control_type))) {
- SPDY_DLOG(FATAL) << "Attempted to init header streaming with "
- << "invalid control frame type: " << header_control_type;
+ QUICHE_DLOG(FATAL) << "Attempted to init header streaming with "
+ << "invalid control frame type: "
+ << header_control_type;
}
memset(header_buffer_.get(), 0, header_buffer_size_);
header_buffer_length_ = 0;
@@ -4817,8 +4819,8 @@
const size_t frame1_size = frame1.size();
const size_t frame2_size = frame2.size();
- SPDY_VLOG(1) << "frame1_size = " << frame1_size;
- SPDY_VLOG(1) << "frame2_size = " << frame2_size;
+ QUICHE_VLOG(1) << "frame1_size = " << frame1_size;
+ QUICHE_VLOG(1) << "frame2_size = " << frame2_size;
std::string input_buffer;
input_buffer.append(frame1.data(), frame1_size);
@@ -4827,7 +4829,7 @@
const char* buf = input_buffer.data();
const size_t buf_size = input_buffer.size();
- SPDY_VLOG(1) << "buf_size = " << buf_size;
+ QUICHE_VLOG(1) << "buf_size = " << buf_size;
size_t processed = deframer_.ProcessInput(buf, buf_size);
EXPECT_EQ(buf_size, processed);
diff --git a/spdy/core/spdy_header_block.cc b/spdy/core/spdy_header_block.cc
index 59a9069..b579047 100644
--- a/spdy/core/spdy_header_block.cc
+++ b/spdy/core/spdy_header_block.cc
@@ -10,8 +10,8 @@
#include <utility>
#include "absl/strings/str_cat.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
namespace {
@@ -144,14 +144,14 @@
*spdy_header_block_value_size_ += value.size();
SpdyHeaderStorage* storage = &block_->storage_;
if (lookup_result_ == block_->map_.end()) {
- SPDY_DVLOG(1) << "Inserting: (" << key_ << ", " << value << ")";
+ QUICHE_DVLOG(1) << "Inserting: (" << key_ << ", " << value << ")";
lookup_result_ =
block_->map_
.emplace(std::make_pair(
key_, HeaderValue(storage, key_, storage->Write(value))))
.first;
} else {
- SPDY_DVLOG(1) << "Updating key: " << key_ << " with value: " << value;
+ QUICHE_DVLOG(1) << "Updating key: " << key_ << " with value: " << value;
*spdy_header_block_value_size_ -= lookup_result_->second.SizeEstimate();
lookup_result_->second = HeaderValue(storage, key_, storage->Write(value));
}
@@ -232,7 +232,7 @@
void Http2HeaderBlock::erase(absl::string_view key) {
auto iter = map_.find(key);
if (iter != map_.end()) {
- SPDY_DVLOG(1) << "Erasing header with name: " << key;
+ QUICHE_DVLOG(1) << "Erasing header with name: " << key;
key_size_ -= key.size();
value_size_ -= iter->second.SizeEstimate();
map_.erase(iter);
@@ -252,12 +252,12 @@
auto iter = map_.find(value.first);
if (iter == map_.end()) {
- SPDY_DVLOG(1) << "Inserting: (" << value.first << ", " << value.second
- << ")";
+ QUICHE_DVLOG(1) << "Inserting: (" << value.first << ", " << value.second
+ << ")";
AppendHeader(value.first, value.second);
} else {
- SPDY_DVLOG(1) << "Updating key: " << iter->first
- << " with value: " << value.second;
+ QUICHE_DVLOG(1) << "Updating key: " << iter->first
+ << " with value: " << value.second;
value_size_ -= iter->second.SizeEstimate();
iter->second =
HeaderValue(&storage_, iter->first, storage_.Write(value.second));
@@ -266,16 +266,16 @@
Http2HeaderBlock::ValueProxy Http2HeaderBlock::operator[](
const absl::string_view key) {
- SPDY_DVLOG(2) << "Operator[] saw key: " << key;
+ QUICHE_DVLOG(2) << "Operator[] saw key: " << key;
absl::string_view out_key;
auto iter = map_.find(key);
if (iter == map_.end()) {
// We write the key first, to assure that the ValueProxy has a
// reference to a valid absl::string_view in its operator=.
out_key = WriteKey(key);
- SPDY_DVLOG(2) << "Key written as: " << std::hex
- << static_cast<const void*>(key.data()) << ", " << std::dec
- << key.size();
+ QUICHE_DVLOG(2) << "Key written as: " << std::hex
+ << static_cast<const void*>(key.data()) << ", " << std::dec
+ << key.size();
} else {
out_key = iter->first;
}
@@ -288,13 +288,13 @@
auto iter = map_.find(key);
if (iter == map_.end()) {
- SPDY_DVLOG(1) << "Inserting: (" << key << ", " << value << ")";
+ QUICHE_DVLOG(1) << "Inserting: (" << key << ", " << value << ")";
AppendHeader(key, value);
return;
}
- SPDY_DVLOG(1) << "Updating key: " << iter->first
- << "; appending value: " << value;
+ QUICHE_DVLOG(1) << "Updating key: " << iter->first
+ << "; appending value: " << value;
value_size_ += SeparatorForKey(key).size();
iter->second.Append(storage_.Write(value));
}
diff --git a/spdy/core/spdy_header_storage.cc b/spdy/core/spdy_header_storage.cc
index 207a3be..e995905 100644
--- a/spdy/core/spdy_header_storage.cc
+++ b/spdy/core/spdy_header_storage.cc
@@ -2,7 +2,7 @@
#include <cstring>
-#include "spdy/platform/api/spdy_logging.h"
+#include "common/platform/api/quiche_logging.h"
namespace spdy {
namespace {
diff --git a/spdy/core/spdy_prefixed_buffer_reader.cc b/spdy/core/spdy_prefixed_buffer_reader.cc
index 0cb07cf..767dea3 100644
--- a/spdy/core/spdy_prefixed_buffer_reader.cc
+++ b/spdy/core/spdy_prefixed_buffer_reader.cc
@@ -6,7 +6,7 @@
#include <new>
-#include "spdy/platform/api/spdy_logging.h"
+#include "common/platform/api/quiche_logging.h"
namespace spdy {
diff --git a/spdy/core/spdy_protocol.cc b/spdy/core/spdy_protocol.cc
index e1de5c1..4bde56a 100644
--- a/spdy/core/spdy_protocol.cc
+++ b/spdy/core/spdy_protocol.cc
@@ -462,7 +462,7 @@
size_t SpdyContinuationIR::size() const {
// We don't need to get the size of CONTINUATION frame directly. It is
// calculated in HEADERS or PUSH_PROMISE frame.
- SPDY_DLOG(WARNING) << "Shouldn't not call size() for CONTINUATION frame.";
+ QUICHE_DLOG(WARNING) << "Shouldn't not call size() for CONTINUATION frame.";
return 0;
}
diff --git a/spdy/core/spdy_protocol.h b/spdy/core/spdy_protocol.h
index 485818f..16d6b9a 100644
--- a/spdy/core/spdy_protocol.h
+++ b/spdy/core/spdy_protocol.h
@@ -21,10 +21,10 @@
#include "absl/strings/string_view.h"
#include "common/platform/api/quiche_export.h"
+#include "common/platform/api/quiche_logging.h"
#include "spdy/core/spdy_alt_svc_wire_format.h"
#include "spdy/core/spdy_bitmasks.h"
#include "spdy/core/spdy_header_block.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
diff --git a/spdy/core/spdy_protocol_test_utils.cc b/spdy/core/spdy_protocol_test_utils.cc
index 6391749..1888176 100644
--- a/spdy/core/spdy_protocol_test_utils.cc
+++ b/spdy/core/spdy_protocol_test_utils.cc
@@ -17,7 +17,7 @@
::testing::AssertionResult VerifySpdyFrameWithHeaderBlockIREquals(
const SpdyFrameWithHeaderBlockIR& expected,
const SpdyFrameWithHeaderBlockIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameWithHeaderBlockIREquals";
+ QUICHE_VLOG(1) << "VerifySpdyFrameWithHeaderBlockIREquals";
VERIFY_TRUE(actual.header_block() == expected.header_block());
return ::testing::AssertionSuccess();
}
@@ -40,7 +40,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyDataIR& expected,
const SpdyDataIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyDataIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyDataIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_EQ(expected.fin(), actual.fin());
VERIFY_EQ(expected.data_len(), actual.data_len());
@@ -56,7 +56,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyGoAwayIR& expected,
const SpdyGoAwayIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyGoAwayIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyGoAwayIR";
VERIFY_EQ(expected.last_good_stream_id(), actual.last_good_stream_id());
VERIFY_EQ(expected.error_code(), actual.error_code());
VERIFY_EQ(expected.description(), actual.description());
@@ -66,7 +66,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdyHeadersIR& expected,
const SpdyHeadersIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyHeadersIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyHeadersIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_EQ(expected.fin(), actual.fin());
VERIFY_SUCCESS(VerifySpdyFrameWithHeaderBlockIREquals(expected, actual));
@@ -80,7 +80,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(const SpdyPingIR& expected,
const SpdyPingIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPingIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPingIR";
VERIFY_EQ(expected.id(), actual.id());
VERIFY_EQ(expected.is_ack(), actual.is_ack());
return ::testing::AssertionSuccess();
@@ -89,7 +89,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdyPriorityIR& expected,
const SpdyPriorityIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPriorityIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPriorityIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_SUCCESS(VerifySpdyFrameWithPriorityIREquals(expected, actual));
return ::testing::AssertionSuccess();
@@ -98,7 +98,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdyPushPromiseIR& expected,
const SpdyPushPromiseIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyPushPromiseIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyPushPromiseIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_SUCCESS(VerifySpdyFrameWithPaddingIREquals(expected, actual));
VERIFY_EQ(expected.promised_stream_id(), actual.promised_stream_id());
@@ -109,7 +109,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdyRstStreamIR& expected,
const SpdyRstStreamIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyRstStreamIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyRstStreamIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_EQ(expected.error_code(), actual.error_code());
return ::testing::AssertionSuccess();
@@ -118,7 +118,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdySettingsIR& expected,
const SpdySettingsIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdySettingsIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdySettingsIR";
// Note, ignoring non-HTTP/2 fields such as clear_settings.
VERIFY_EQ(expected.is_ack(), actual.is_ack());
@@ -145,7 +145,7 @@
::testing::AssertionResult VerifySpdyFrameIREquals(
const SpdyWindowUpdateIR& expected,
const SpdyWindowUpdateIR& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals SpdyWindowUpdateIR";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals SpdyWindowUpdateIR";
VERIFY_EQ(expected.stream_id(), actual.stream_id());
VERIFY_EQ(expected.delta(), actual.delta());
return ::testing::AssertionSuccess();
diff --git a/spdy/core/spdy_protocol_test_utils.h b/spdy/core/spdy_protocol_test_utils.h
index daccebb..de716d5 100644
--- a/spdy/core/spdy_protocol_test_utils.h
+++ b/spdy/core/spdy_protocol_test_utils.h
@@ -20,10 +20,10 @@
#include <typeinfo>
#include "http2/platform/api/http2_test_helpers.h"
+#include "common/platform/api/quiche_logging.h"
#include "common/platform/api/quiche_test.h"
#include "spdy/core/spdy_protocol.h"
#include "spdy/core/spdy_test_utils.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
namespace test {
@@ -38,7 +38,7 @@
template <class T>
::testing::AssertionResult VerifySpdyFrameWithPaddingIREquals(const T& expected,
const T& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameWithPaddingIREquals";
+ QUICHE_VLOG(1) << "VerifySpdyFrameWithPaddingIREquals";
VERIFY_EQ(expected.padded(), actual.padded());
if (expected.padded()) {
VERIFY_EQ(expected.padding_payload_len(), actual.padding_payload_len());
@@ -52,7 +52,7 @@
::testing::AssertionResult VerifySpdyFrameWithPriorityIREquals(
const T& expected,
const T& actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameWithPriorityIREquals";
+ QUICHE_VLOG(1) << "VerifySpdyFrameWithPriorityIREquals";
VERIFY_EQ(expected.parent_stream_id(), actual.parent_stream_id());
VERIFY_EQ(expected.weight(), actual.weight());
VERIFY_EQ(expected.exclusive(), actual.exclusive());
@@ -123,12 +123,12 @@
::testing::AssertionResult VerifySpdyFrameIREquals(const E* expected,
const SpdyFrameIR* actual) {
if (expected == nullptr || actual == nullptr) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals one null";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals one null";
VERIFY_EQ(expected, nullptr);
VERIFY_EQ(actual, nullptr);
return ::testing::AssertionSuccess();
}
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals not null";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals not null";
VERIFY_EQ(actual->frame_type(), expected->frame_type());
const E* actual2 = static_cast<const E*>(actual);
return VerifySpdyFrameIREquals(*expected, *actual2);
@@ -139,7 +139,7 @@
template <class E>
::testing::AssertionResult VerifySpdyFrameIREquals(const E& expected,
const SpdyFrameIR* actual) {
- SPDY_VLOG(1) << "VerifySpdyFrameIREquals";
+ QUICHE_VLOG(1) << "VerifySpdyFrameIREquals";
return VerifySpdyFrameIREquals(&expected, actual);
}
diff --git a/spdy/core/spdy_simple_arena.cc b/spdy/core/spdy_simple_arena.cc
index 15c8fea..4df2246 100644
--- a/spdy/core/spdy_simple_arena.cc
+++ b/spdy/core/spdy_simple_arena.cc
@@ -7,7 +7,7 @@
#include <algorithm>
#include <cstring>
-#include "spdy/platform/api/spdy_logging.h"
+#include "common/platform/api/quiche_logging.h"
namespace spdy {
diff --git a/spdy/core/spdy_test_utils.cc b/spdy/core/spdy_test_utils.cc
index 482d8e2..4ea1ce8 100644
--- a/spdy/core/spdy_test_utils.cc
+++ b/spdy/core/spdy_test_utils.cc
@@ -11,9 +11,9 @@
#include <utility>
#include <vector>
+#include "common/platform/api/quiche_logging.h"
#include "common/platform/api/quiche_test.h"
#include "common/quiche_endian.h"
-#include "spdy/platform/api/spdy_logging.h"
namespace spdy {
namespace test {
@@ -27,7 +27,7 @@
const int kSizeLimit = 1024;
if (length > kSizeLimit || mark_length > kSizeLimit) {
- SPDY_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
+ QUICHE_LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
length = std::min(length, kSizeLimit);
mark_length = std::min(mark_length, kSizeLimit);
}
diff --git a/spdy/platform/api/spdy_logging.h b/spdy/platform/api/spdy_logging.h
deleted file mode 100644
index c1f5268..0000000
--- a/spdy/platform/api/spdy_logging.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2019 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.
-
-#ifndef QUICHE_SPDY_PLATFORM_API_SPDY_LOGGING_H_
-#define QUICHE_SPDY_PLATFORM_API_SPDY_LOGGING_H_
-
-#include "common/platform/api/quiche_logging.h"
-
-#define SPDY_LOG(severity) QUICHE_LOG(severity)
-
-#define SPDY_VLOG(verbose_level) QUICHE_VLOG(verbose_level)
-
-#define SPDY_DLOG(severity) QUICHE_DLOG(severity)
-
-#define SPDY_DLOG_IF(severity, condition) QUICHE_DLOG_IF(severity, condition)
-
-#define SPDY_DVLOG(verbose_level) QUICHE_DVLOG(verbose_level)
-
-#define SPDY_DVLOG_IF(verbose_level, condition) \
- QUICHE_DVLOG_IF(verbose_level, condition)
-
-#endif // QUICHE_SPDY_PLATFORM_API_SPDY_LOGGING_H_
