blob: 716e6bb08f8455b71054f83608a92d47acade903 [file] [log] [blame]
#include "quiche/http2/adapter/event_forwarder.h"
namespace http2 {
namespace adapter {
EventForwarder::EventForwarder(ForwardPredicate can_forward,
spdy::SpdyFramerVisitorInterface& receiver)
: can_forward_(std::move(can_forward)), receiver_(receiver) {}
void EventForwarder::OnError(Http2DecoderAdapter::SpdyFramerError error,
std::string detailed_error) {
if (can_forward_()) {
receiver_.OnError(error, std::move(detailed_error));
}
}
void EventForwarder::OnCommonHeader(spdy::SpdyStreamId stream_id, size_t length,
uint8_t type, uint8_t flags) {
if (can_forward_()) {
receiver_.OnCommonHeader(stream_id, length, type, flags);
}
}
void EventForwarder::OnDataFrameHeader(spdy::SpdyStreamId stream_id,
size_t length, bool fin) {
if (can_forward_()) {
receiver_.OnDataFrameHeader(stream_id, length, fin);
}
}
void EventForwarder::OnStreamFrameData(spdy::SpdyStreamId stream_id,
const char* data, size_t len) {
if (can_forward_()) {
receiver_.OnStreamFrameData(stream_id, data, len);
}
}
void EventForwarder::OnStreamEnd(spdy::SpdyStreamId stream_id) {
if (can_forward_()) {
receiver_.OnStreamEnd(stream_id);
}
}
void EventForwarder::OnStreamPadLength(spdy::SpdyStreamId stream_id,
size_t value) {
if (can_forward_()) {
receiver_.OnStreamPadLength(stream_id, value);
}
}
void EventForwarder::OnStreamPadding(spdy::SpdyStreamId stream_id, size_t len) {
if (can_forward_()) {
receiver_.OnStreamPadding(stream_id, len);
}
}
spdy::SpdyHeadersHandlerInterface* EventForwarder::OnHeaderFrameStart(
spdy::SpdyStreamId stream_id) {
return receiver_.OnHeaderFrameStart(stream_id);
}
void EventForwarder::OnHeaderFrameEnd(spdy::SpdyStreamId stream_id) {
if (can_forward_()) {
receiver_.OnHeaderFrameEnd(stream_id);
}
}
void EventForwarder::OnRstStream(spdy::SpdyStreamId stream_id,
spdy::SpdyErrorCode error_code) {
if (can_forward_()) {
receiver_.OnRstStream(stream_id, error_code);
}
}
void EventForwarder::OnSettings() {
if (can_forward_()) {
receiver_.OnSettings();
}
}
void EventForwarder::OnSetting(spdy::SpdySettingsId id, uint32_t value) {
if (can_forward_()) {
receiver_.OnSetting(id, value);
}
}
void EventForwarder::OnSettingsEnd() {
if (can_forward_()) {
receiver_.OnSettingsEnd();
}
}
void EventForwarder::OnSettingsAck() {
if (can_forward_()) {
receiver_.OnSettingsAck();
}
}
void EventForwarder::OnPing(spdy::SpdyPingId unique_id, bool is_ack) {
if (can_forward_()) {
receiver_.OnPing(unique_id, is_ack);
}
}
void EventForwarder::OnGoAway(spdy::SpdyStreamId last_accepted_stream_id,
spdy::SpdyErrorCode error_code) {
if (can_forward_()) {
receiver_.OnGoAway(last_accepted_stream_id, error_code);
}
}
bool EventForwarder::OnGoAwayFrameData(const char* goaway_data, size_t len) {
if (can_forward_()) {
return receiver_.OnGoAwayFrameData(goaway_data, len);
}
return false;
}
void EventForwarder::OnHeaders(spdy::SpdyStreamId stream_id,
size_t payload_length, bool has_priority,
int weight, spdy::SpdyStreamId parent_stream_id,
bool exclusive, bool fin, bool end) {
if (can_forward_()) {
receiver_.OnHeaders(stream_id, payload_length, has_priority, weight,
parent_stream_id, exclusive, fin, end);
}
}
void EventForwarder::OnWindowUpdate(spdy::SpdyStreamId stream_id,
int delta_window_size) {
if (can_forward_()) {
receiver_.OnWindowUpdate(stream_id, delta_window_size);
}
}
void EventForwarder::OnPushPromise(spdy::SpdyStreamId stream_id,
spdy::SpdyStreamId promised_stream_id,
bool end) {
if (can_forward_()) {
receiver_.OnPushPromise(stream_id, promised_stream_id, end);
}
}
void EventForwarder::OnContinuation(spdy::SpdyStreamId stream_id,
size_t payload_length, bool end) {
if (can_forward_()) {
receiver_.OnContinuation(stream_id, payload_length, end);
}
}
void EventForwarder::OnAltSvc(
spdy::SpdyStreamId stream_id, absl::string_view origin,
const spdy::SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
if (can_forward_()) {
receiver_.OnAltSvc(stream_id, origin, altsvc_vector);
}
}
void EventForwarder::OnPriority(spdy::SpdyStreamId stream_id,
spdy::SpdyStreamId parent_stream_id, int weight,
bool exclusive) {
if (can_forward_()) {
receiver_.OnPriority(stream_id, parent_stream_id, weight, exclusive);
}
}
void EventForwarder::OnPriorityUpdate(spdy::SpdyStreamId prioritized_stream_id,
absl::string_view priority_field_value) {
if (can_forward_()) {
receiver_.OnPriorityUpdate(prioritized_stream_id, priority_field_value);
}
}
bool EventForwarder::OnUnknownFrame(spdy::SpdyStreamId stream_id,
uint8_t frame_type) {
if (can_forward_()) {
return receiver_.OnUnknownFrame(stream_id, frame_type);
}
return false;
}
} // namespace adapter
} // namespace http2