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));
 }