Within WindowManager, changes the representation of flow control windows from size_t to int64_t.
This is preparation for handling negative window values within WindowManager. Refactoring, no functional change.
PiperOrigin-RevId: 429021557
diff --git a/http2/adapter/window_manager.cc b/http2/adapter/window_manager.cc
index de45dc3..9ab661d 100644
--- a/http2/adapter/window_manager.cc
+++ b/http2/adapter/window_manager.cc
@@ -8,12 +8,14 @@
namespace http2 {
namespace adapter {
-WindowManager::WindowManager(size_t window_size_limit,
+WindowManager::WindowManager(int64_t window_size_limit,
WindowUpdateListener listener)
- : limit_(window_size_limit), window_(window_size_limit), buffered_(0),
+ : limit_(window_size_limit),
+ window_(window_size_limit),
+ buffered_(0),
listener_(std::move(listener)) {}
-void WindowManager::OnWindowSizeLimitChange(const size_t new_limit) {
+void WindowManager::OnWindowSizeLimitChange(const int64_t new_limit) {
QUICHE_VLOG(2) << "WindowManager@" << this
<< " OnWindowSizeLimitChange from old limit of " << limit_
<< " to new limit of " << new_limit;
@@ -26,7 +28,7 @@
limit_ = new_limit;
}
-void WindowManager::SetWindowSizeLimit(size_t new_limit) {
+void WindowManager::SetWindowSizeLimit(int64_t new_limit) {
QUICHE_VLOG(2) << "WindowManager@" << this
<< " SetWindowSizeLimit from old limit of " << limit_
<< " to new limit of " << new_limit;
@@ -34,7 +36,7 @@
MaybeNotifyListener();
}
-bool WindowManager::MarkDataBuffered(size_t bytes) {
+bool WindowManager::MarkDataBuffered(int64_t bytes) {
QUICHE_VLOG(2) << "WindowManager@" << this << " window: " << window_
<< " bytes: " << bytes;
if (window_ < bytes) {
@@ -52,7 +54,7 @@
return window_ > 0;
}
-void WindowManager::MarkDataFlushed(size_t bytes) {
+void WindowManager::MarkDataFlushed(int64_t bytes) {
QUICHE_VLOG(2) << "WindowManager@" << this << " buffered: " << buffered_
<< " bytes: " << bytes;
if (buffered_ < bytes) {
@@ -73,9 +75,9 @@
}
// For the sake of efficiency, we want to send window updates if less than
// half of the max quota is available to the peer at any point in time.
- const size_t kDesiredMinWindow = limit_ / 2;
- const size_t kDesiredMinDelta = limit_ / 3;
- const size_t delta = limit_ - (buffered_ + window_);
+ const int64_t kDesiredMinWindow = limit_ / 2;
+ const int64_t kDesiredMinDelta = limit_ / 3;
+ const int64_t delta = limit_ - (buffered_ + window_);
bool send_update = false;
if (delta >= kDesiredMinDelta) {
// This particular window update was sent because the available delta
diff --git a/http2/adapter/window_manager.h b/http2/adapter/window_manager.h
index 5a7701e..a4fe468 100644
--- a/http2/adapter/window_manager.h
+++ b/http2/adapter/window_manager.h
@@ -19,34 +19,33 @@
class QUICHE_EXPORT_PRIVATE WindowManager {
public:
// A WindowUpdateListener is invoked when it is time to send a window update.
- typedef std::function<void(size_t)> WindowUpdateListener;
+ typedef std::function<void(int64_t)> WindowUpdateListener;
- WindowManager(size_t window_size_limit,
- WindowUpdateListener listener);
+ WindowManager(int64_t window_size_limit, WindowUpdateListener listener);
- size_t CurrentWindowSize() const { return window_; }
- size_t WindowSizeLimit() const { return limit_; }
+ int64_t CurrentWindowSize() const { return window_; }
+ int64_t WindowSizeLimit() const { return limit_; }
// Called when the window size limit is changed (typically via settings) but
// no window update should be sent.
- void OnWindowSizeLimitChange(size_t new_limit);
+ void OnWindowSizeLimitChange(int64_t new_limit);
// Sets the window size limit to |new_limit| and notifies the listener to
// update as necessary.
- void SetWindowSizeLimit(size_t new_limit);
+ void SetWindowSizeLimit(int64_t new_limit);
// Increments the running total of data bytes buffered. Returns true iff there
// is more window remaining.
- bool MarkDataBuffered(size_t bytes);
+ bool MarkDataBuffered(int64_t bytes);
// Increments the running total of data bytes that have been flushed or
// dropped. Invokes the listener if the current window is smaller than some
// threshold and there is quota available to send.
- void MarkDataFlushed(size_t bytes);
+ void MarkDataFlushed(int64_t bytes);
// Convenience method, used when incoming data is immediately dropped or
// ignored.
- void MarkWindowConsumed(size_t bytes) {
+ void MarkWindowConsumed(int64_t bytes) {
MarkDataBuffered(bytes);
MarkDataFlushed(bytes);
}
@@ -58,16 +57,16 @@
// The upper bound on the flow control window. The GFE attempts to maintain a
// window of this size at the peer as data is proxied through.
- size_t limit_;
+ int64_t limit_;
// The current flow control window that has not been advertised to the peer
// and not yet consumed. The peer can send this many bytes before becoming
// blocked.
- size_t window_;
+ int64_t window_;
// The amount of data already buffered, which should count against the flow
// control window upper bound.
- size_t buffered_;
+ int64_t buffered_;
WindowUpdateListener listener_;
};
diff --git a/http2/adapter/window_manager_test.cc b/http2/adapter/window_manager_test.cc
index e706156..e81dc94 100644
--- a/http2/adapter/window_manager_test.cc
+++ b/http2/adapter/window_manager_test.cc
@@ -16,9 +16,7 @@
public:
explicit WindowManagerPeer(const WindowManager& wm) : wm_(wm) {}
- size_t buffered() {
- return wm_.buffered_;
- }
+ int64_t buffered() { return wm_.buffered_; }
private:
const WindowManager& wm_;
@@ -32,12 +30,10 @@
: wm_(kDefaultLimit, absl::bind_front(&WindowManagerTest::OnCall, this)),
peer_(wm_) {}
- void OnCall(size_t s) {
- call_sequence_.push_back(s);
- }
+ void OnCall(int64_t s) { call_sequence_.push_back(s); }
- const size_t kDefaultLimit = 32 * 1024 * 3;
- std::list<size_t> call_sequence_;
+ const int64_t kDefaultLimit = 32 * 1024 * 3;
+ std::list<int64_t> call_sequence_;
WindowManager wm_;
WindowManagerPeer peer_;
::http2::test::Http2Random random_;
@@ -56,9 +52,9 @@
// This test verifies that WindowManager does not notify its listener when data
// is only buffered, and never flushed.
TEST_F(WindowManagerTest, DataOnlyBuffered) {
- size_t total = 0;
+ int64_t total = 0;
while (total < kDefaultLimit) {
- size_t s = std::min<size_t>(kDefaultLimit - total, random_.Uniform(1024));
+ int64_t s = std::min<int64_t>(kDefaultLimit - total, random_.Uniform(1024));
total += s;
wm_.MarkDataBuffered(s);
}
@@ -68,15 +64,15 @@
// This test verifies that WindowManager does notify its listener when data is
// buffered and subsequently flushed.
TEST_F(WindowManagerTest, DataBufferedAndFlushed) {
- size_t total_buffered = 0;
- size_t total_flushed = 0;
+ int64_t total_buffered = 0;
+ int64_t total_flushed = 0;
while (call_sequence_.empty()) {
- size_t buffered =
- std::min<size_t>(kDefaultLimit - total_buffered, random_.Uniform(1024));
+ int64_t buffered = std::min<int64_t>(kDefaultLimit - total_buffered,
+ random_.Uniform(1024));
wm_.MarkDataBuffered(buffered);
total_buffered += buffered;
EXPECT_TRUE(call_sequence_.empty());
- size_t flushed = random_.Uniform(total_buffered - total_flushed);
+ int64_t flushed = random_.Uniform(total_buffered - total_flushed);
wm_.MarkDataFlushed(flushed);
total_flushed += flushed;
}
@@ -110,10 +106,10 @@
// This test verifies that WindowManager notifies its listener when window is
// consumed (data is ignored or immediately dropped).
TEST_F(WindowManagerTest, WindowConsumed) {
- size_t consumed = kDefaultLimit / 3 - 1;
+ int64_t consumed = kDefaultLimit / 3 - 1;
wm_.MarkWindowConsumed(consumed);
EXPECT_TRUE(call_sequence_.empty());
- const size_t extra = 1;
+ const int64_t extra = 1;
wm_.MarkWindowConsumed(extra);
EXPECT_THAT(call_sequence_, testing::ElementsAre(consumed + extra));
}
