blob: 37f99d4f649b9b8c7bb1cbdef5120d93dd1b60b0 [file] [log] [blame] [edit]
// Copyright 2021 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_QUIC_CORE_QUIC_CONNECTION_CONTEXT_H_
#define QUICHE_QUIC_CORE_QUIC_CONNECTION_CONTEXT_H_
#include <memory>
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/common/platform/api/quiche_logging.h"
namespace quic {
// QuicConnectionTracer is responsible for emit trace messages for a single
// QuicConnection.
// QuicConnectionTracer is part of the QuicConnectionContext.
class QUICHE_EXPORT QuicConnectionTracer {
public:
virtual ~QuicConnectionTracer() = default;
// Emit a trace message from a string literal. The trace may simply remember
// the address of the literal in this function and read it at a later time.
virtual void PrintLiteral(const char* literal) = 0;
// Emit a trace message from a string_view. Unlike PrintLiteral, this function
// will not read |s| after it returns.
virtual void PrintString(absl::string_view s) = 0;
// Emit a trace message from printf-style arguments.
template <typename... Args>
void Printf(const absl::FormatSpec<Args...>& format, const Args&... args) {
std::string s = absl::StrFormat(format, args...);
PrintString(s);
}
};
// QuicBugListener is a helper class for implementing QUIC_BUG. The QUIC_BUG
// implementation can send the bug information into quic::CurrentBugListener().
class QUICHE_EXPORT QuicBugListener {
public:
virtual ~QuicBugListener() = default;
virtual void OnQuicBug(const char* bug_id, const char* file, int line,
absl::string_view bug_message) = 0;
};
// QuicConnectionContextListener provides the interfaces that are called when
// a QuicConnection becomes active or inactive. If there are platform-specific
// preparation or cleanup work needed for the members of QuicConnectionContext
// to function, those work can be done in the implementation of this interface.
class QUICHE_EXPORT QuicConnectionContextListener {
public:
virtual ~QuicConnectionContextListener() = default;
private:
friend class QuicConnectionContextSwitcher;
// Called by QuicConnectionContextSwitcher when a QUIC connection becomes
// active in the current thread.
//
// Activate/Deactivate are only called by QuicConnectionContextSwitcher's
// constructor/destructor, they always come in pairs.
virtual void Activate() = 0;
// Called by QuicConnectionContextSwitcher when a QUIC connection becomes
// inactive in the current thread.
//
// Activate/Deactivate are only called by QuicConnectionContextSwitcher's
// constructor/destructor, they always come in pairs.
virtual void Deactivate() = 0;
};
// QuicConnectionContext is a per-QuicConnection context that includes
// facilities useable by any part of a QuicConnection. A QuicConnectionContext
// is owned by a QuicConnection.
//
// The 'top-level' QuicConnection functions are responsible for maintaining the
// thread-local QuicConnectionContext pointer, such that any function called by
// them(directly or indirectly) can access the context.
//
// Like QuicConnection, all facilities in QuicConnectionContext are assumed to
// be called from a single thread at a time, they are NOT thread-safe.
struct QUICHE_EXPORT QuicConnectionContext final {
// Get the context on the current executing thread. nullptr if the current
// function is not called from a 'top-level' QuicConnection function.
static QuicConnectionContext* Current();
std::unique_ptr<QuicConnectionContextListener> listener;
std::unique_ptr<QuicConnectionTracer> tracer;
std::unique_ptr<QuicBugListener> bug_listener;
};
// QuicConnectionContextSwitcher is a RAII object used for maintaining the
// thread-local QuicConnectionContext pointer.
class QUICHE_EXPORT QuicConnectionContextSwitcher final {
public:
// The constructor switches from QuicConnectionContext::Current() to
// |new_context|.
explicit QuicConnectionContextSwitcher(QuicConnectionContext* new_context);
// The destructor switches from QuicConnectionContext::Current() back to the
// old context.
~QuicConnectionContextSwitcher();
private:
QuicConnectionContext* old_context_;
};
// Emit a trace message from a string literal to the current tracer(if any).
inline void QUIC_TRACELITERAL(const char* literal) {
QuicConnectionContext* current = QuicConnectionContext::Current();
if (current && current->tracer) {
current->tracer->PrintLiteral(literal);
}
}
// Emit a trace message from a string_view to the current tracer(if any).
inline void QUIC_TRACESTRING(absl::string_view s) {
QuicConnectionContext* current = QuicConnectionContext::Current();
if (current && current->tracer) {
current->tracer->PrintString(s);
}
}
// Emit a trace message from printf-style arguments to the current tracer(if
// any).
template <typename... Args>
void QUIC_TRACEPRINTF(const absl::FormatSpec<Args...>& format,
const Args&... args) {
QuicConnectionContext* current = QuicConnectionContext::Current();
if (current && current->tracer) {
current->tracer->Printf(format, args...);
}
}
inline QuicBugListener* CurrentBugListener() {
QuicConnectionContext* current = QuicConnectionContext::Current();
return (current != nullptr) ? current->bug_listener.get() : nullptr;
}
} // namespace quic
#endif // QUICHE_QUIC_CORE_QUIC_CONNECTION_CONTEXT_H_