diff --git a/http2/adapter/http2_adapter.h b/http2/adapter/http2_adapter.h
index c1ee479..2c66081 100644
--- a/http2/adapter/http2_adapter.h
+++ b/http2/adapter/http2_adapter.h
@@ -67,7 +67,8 @@
   virtual void SubmitMetadata(Http2StreamId stream_id, bool fin) = 0;
 
   // Invokes the visitor's OnReadyToSend() method for serialized frame data.
-  virtual void Send() = 0;
+  // Returns 0 on success.
+  virtual int Send() = 0;
 
   // Returns the connection-level flow control window advertised by the peer.
   virtual int GetSendWindowSize() const = 0;
diff --git a/http2/adapter/nghttp2_adapter.cc b/http2/adapter/nghttp2_adapter.cc
index 316fc40..8eac860 100644
--- a/http2/adapter/nghttp2_adapter.cc
+++ b/http2/adapter/nghttp2_adapter.cc
@@ -95,11 +95,12 @@
   QUICHE_LOG(DFATAL) << "Not implemented";
 }
 
-void NgHttp2Adapter::Send() {
+int NgHttp2Adapter::Send() {
   const int result = nghttp2_session_send(session_->raw_ptr());
   if (result != 0) {
     visitor_.OnConnectionError();
   }
+  return result;
 }
 
 int NgHttp2Adapter::GetSendWindowSize() const {
diff --git a/http2/adapter/nghttp2_adapter.h b/http2/adapter/nghttp2_adapter.h
index 10573f2..c49d017 100644
--- a/http2/adapter/nghttp2_adapter.h
+++ b/http2/adapter/nghttp2_adapter.h
@@ -47,7 +47,7 @@
 
   void SubmitMetadata(Http2StreamId stream_id, bool end_metadata) override;
 
-  void Send() override;
+  int Send() override;
 
   int GetSendWindowSize() const override;
   int GetStreamSendWindowSize(Http2StreamId stream_id) const override;
diff --git a/http2/adapter/nghttp2_adapter_test.cc b/http2/adapter/nghttp2_adapter_test.cc
index 92ac949..21a1ded 100644
--- a/http2/adapter/nghttp2_adapter_test.cc
+++ b/http2/adapter/nghttp2_adapter_test.cc
@@ -57,7 +57,8 @@
 TEST(NgHttp2AdapterTest, ClientHandlesFrames) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
-  adapter->Send();
+  int result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(),
               testing::StrEq(spdy::kHttp2ConnectionHeaderPrefix));
   visitor.Clear();
@@ -86,7 +87,8 @@
 
   EXPECT_EQ(adapter->GetSendWindowSize(), kInitialFlowControlWindowSize + 1000);
   // Some bytes should have been serialized.
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
                                             spdy::SpdyFrameType::PING}));
   visitor.Clear();
@@ -136,7 +138,8 @@
   adapter->SetStreamUserData(stream_id2, const_cast<char*>(kSentinel2));
   adapter->SetStreamUserData(stream_id3, nullptr);
 
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::HEADERS}));
@@ -244,14 +247,16 @@
 
   // Client will not have anything else to write.
   EXPECT_FALSE(adapter->session().want_write());
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), testing::IsEmpty());
 }
 
 TEST(NgHttp2AdapterTest, ClientSubmitRequest) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
-  adapter->Send();
+  int result = adapter->Send();
+  EXPECT_EQ(0, result);
   // Client preface does not appear to include the mandatory SETTINGS frame.
   EXPECT_THAT(visitor.data(),
               testing::StrEq(spdy::kHttp2ConnectionHeaderPrefix));
@@ -270,7 +275,8 @@
   EXPECT_EQ(initial_frames.size(), initial_result);
 
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS}));
   visitor.Clear();
 
@@ -287,7 +293,8 @@
                              &body1, const_cast<char*>(kSentinel));
   EXPECT_GT(stream_id, 0);
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
 
   EXPECT_EQ(kInitialFlowControlWindowSize,
             adapter->GetStreamReceiveWindowSize(stream_id));
@@ -323,7 +330,8 @@
   EXPECT_EQ(nullptr, adapter->GetStreamUserData(stream_id));
   adapter->SetStreamUserData(stream_id, const_cast<char*>(kSentinel2));
 
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS}));
 
   EXPECT_EQ(kSentinel2, adapter->GetStreamUserData(stream_id));
@@ -339,7 +347,8 @@
 TEST(NgHttp2AdapterTest, ClientSubmitRequestWithDataProvider) {
   DataSavingVisitor visitor;
   auto adapter = NgHttp2Adapter::CreateClientAdapter(visitor);
-  adapter->Send();
+  int result = adapter->Send();
+  EXPECT_EQ(0, result);
   // Client preface does not appear to include the mandatory SETTINGS frame.
   EXPECT_THAT(visitor.data(),
               testing::StrEq(spdy::kHttp2ConnectionHeaderPrefix));
@@ -358,7 +367,8 @@
   EXPECT_EQ(initial_frames.size(), initial_result);
 
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS}));
   visitor.Clear();
 
@@ -382,7 +392,8 @@
                              frame_source.get(), nullptr);
   EXPECT_GT(stream_id, 0);
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::DATA}));
   EXPECT_THAT(visitor.data(), testing::HasSubstr(kBody));
@@ -416,7 +427,8 @@
   EXPECT_GT(stream_id, 0);
   EXPECT_TRUE(adapter->session().want_write());
 
-  adapter->Send();
+  int result = adapter->Send();
+  EXPECT_EQ(0, result);
   // Client preface does not appear to include the mandatory SETTINGS frame.
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
@@ -431,7 +443,8 @@
   EXPECT_TRUE(adapter->ResumeStream(stream_id));
   EXPECT_TRUE(adapter->session().want_write());
 
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::DATA}));
   EXPECT_FALSE(adapter->session().want_write());
 
@@ -467,12 +480,14 @@
   EXPECT_TRUE(adapter->session().want_write());
 
   visitor.set_is_write_blocked(true);
-  adapter->Send();
+  int result = adapter->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), testing::IsEmpty());
   EXPECT_TRUE(adapter->session().want_write());
 
   visitor.set_is_write_blocked(false);
-  adapter->Send();
+  result = adapter->Send();
+  EXPECT_EQ(0, result);
 
   // Client preface does not appear to include the mandatory SETTINGS frame.
   absl::string_view serialized = visitor.data();
@@ -590,7 +605,8 @@
 
   EXPECT_TRUE(adapter->session().want_write());
   // Some bytes should have been serialized.
-  adapter->Send();
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   // SETTINGS ack, two PING acks.
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
                                             spdy::SpdyFrameType::PING,
@@ -639,7 +655,8 @@
 
   // Server will want to send a SETTINGS ack.
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS}));
   visitor.Clear();
 
@@ -661,7 +678,8 @@
   adapter->SetStreamUserData(1, nullptr);
   EXPECT_EQ(nullptr, adapter->GetStreamUserData(1));
 
-  adapter->Send();
+  send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
 
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::DATA}));
@@ -714,7 +732,8 @@
   adapter->SubmitShutdownNotice();
 
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
                                             spdy::SpdyFrameType::GOAWAY}));
 }
@@ -754,7 +773,8 @@
 
   // Server will want to send a SETTINGS ack.
   EXPECT_TRUE(adapter->session().want_write());
-  adapter->Send();
+  int send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS}));
   visitor.Clear();
 
@@ -770,7 +790,8 @@
   EXPECT_EQ(submit_result, 0);
   EXPECT_TRUE(adapter->session().want_write());
   EXPECT_CALL(visitor, OnCloseStream(1, Http2ErrorCode::NO_ERROR));
-  adapter->Send();
+  send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::DATA}));
   EXPECT_THAT(visitor.data(), testing::HasSubstr(kBody));
@@ -784,7 +805,8 @@
   ASSERT_EQ(trailer_result, 0);
   EXPECT_TRUE(adapter->session().want_write());
 
-  adapter->Send();
+  send_result = adapter->Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS}));
 }
 
diff --git a/http2/adapter/oghttp2_adapter.cc b/http2/adapter/oghttp2_adapter.cc
index e87afa9..6f56d40 100644
--- a/http2/adapter/oghttp2_adapter.cc
+++ b/http2/adapter/oghttp2_adapter.cc
@@ -79,9 +79,7 @@
   QUICHE_BUG(oghttp2_submit_metadata) << "Not implemented";
 }
 
-void OgHttp2Adapter::Send() {
-  session_->Send();
-}
+int OgHttp2Adapter::Send() { return session_->Send(); }
 
 int OgHttp2Adapter::GetSendWindowSize() const {
   return session_->GetRemoteWindowSize();
diff --git a/http2/adapter/oghttp2_adapter.h b/http2/adapter/oghttp2_adapter.h
index 03f7b69..b796e1e 100644
--- a/http2/adapter/oghttp2_adapter.h
+++ b/http2/adapter/oghttp2_adapter.h
@@ -34,7 +34,7 @@
   void SubmitWindowUpdate(Http2StreamId stream_id,
                           int window_increment) override;
   void SubmitMetadata(Http2StreamId stream_id, bool fin) override;
-  void Send() override;
+  int Send() override;
   int GetSendWindowSize() const override;
   int GetStreamSendWindowSize(Http2StreamId stream_id) const override;
   int GetStreamReceiveWindowLimit(Http2StreamId stream_id) const override;
diff --git a/http2/adapter/oghttp2_adapter_test.cc b/http2/adapter/oghttp2_adapter_test.cc
index 1675bda..9f4da15 100644
--- a/http2/adapter/oghttp2_adapter_test.cc
+++ b/http2/adapter/oghttp2_adapter_test.cc
@@ -68,7 +68,8 @@
   adapter_->SubmitWindowUpdate(3, 127);
   EXPECT_TRUE(adapter_->session().want_write());
 
-  adapter_->Send();
+  int result = adapter_->Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(
       http2_visitor_.data(),
       EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::PRIORITY,
@@ -87,11 +88,14 @@
   EXPECT_TRUE(adapter_->session().want_write());
 
   http2_visitor_.set_send_limit(20);
-  adapter_->Send();
+  int result = adapter_->Send();
+  EXPECT_EQ(0, result);
   EXPECT_TRUE(adapter_->session().want_write());
-  adapter_->Send();
+  result = adapter_->Send();
+  EXPECT_EQ(0, result);
   EXPECT_TRUE(adapter_->session().want_write());
-  adapter_->Send();
+  result = adapter_->Send();
+  EXPECT_EQ(0, result);
   EXPECT_FALSE(adapter_->session().want_write());
   EXPECT_THAT(http2_visitor_.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY,
diff --git a/http2/adapter/oghttp2_session.cc b/http2/adapter/oghttp2_session.cc
index 0ee64d7..949c67b 100644
--- a/http2/adapter/oghttp2_session.cc
+++ b/http2/adapter/oghttp2_session.cc
@@ -163,7 +163,7 @@
   frames_.push_back(std::move(frame));
 }
 
-void OgHttp2Session::Send() {
+int OgHttp2Session::Send() {
   MaybeSetupPreface();
   ssize_t result = std::numeric_limits<ssize_t>::max();
   // Flush any serialized prefix.
@@ -174,7 +174,7 @@
     }
   }
   if (!serialized_prefix_.empty()) {
-    return;
+    return result < 0 ? result : 0;
   }
   bool continue_writing = SendQueuedFrames();
   // Wake streams for writes.
@@ -188,6 +188,7 @@
   if (continue_writing) {
     SendQueuedFrames();
   }
+  return 0;
 }
 
 bool OgHttp2Session::SendQueuedFrames() {
diff --git a/http2/adapter/oghttp2_session.h b/http2/adapter/oghttp2_session.h
index 8e2a7ee..a22811f 100644
--- a/http2/adapter/oghttp2_session.h
+++ b/http2/adapter/oghttp2_session.h
@@ -35,7 +35,7 @@
   void StartGracefulShutdown();
 
   // Invokes the visitor's OnReadyToSend() method for serialized frame data.
-  void Send();
+  int Send();
 
   int32_t SubmitRequest(absl::Span<const Header> headers,
                         DataFrameSource* data_source,
@@ -180,7 +180,8 @@
 
   void SendWindowUpdate(Http2StreamId stream_id, size_t update_delta);
 
-  // Sends queued frames, returning true if all frames were flushed.
+  // Sends queued frames, returning true if all frames were flushed
+  // successfully.
   bool SendQueuedFrames();
 
   // Returns false if the connection is write-blocked (due to flow control or
diff --git a/http2/adapter/oghttp2_session_test.cc b/http2/adapter/oghttp2_session_test.cc
index be53e47..73e59b0 100644
--- a/http2/adapter/oghttp2_session_test.cc
+++ b/http2/adapter/oghttp2_session_test.cc
@@ -138,7 +138,8 @@
   OgHttp2Session session(
       visitor, OgHttp2Session::Options{.perspective = Perspective::kClient});
   EXPECT_FALSE(session.want_write());
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -155,7 +156,8 @@
   EXPECT_FALSE(session.want_write());
   session.EnqueueFrame(absl::make_unique<spdy::SpdyPingIR>(42));
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -173,7 +175,8 @@
   EXPECT_FALSE(session.want_write());
   session.EnqueueFrame(absl::make_unique<spdy::SpdySettingsIR>());
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -190,7 +193,8 @@
 
   // Even though the user has not queued any frames for the session, it should
   // still send the connection preface.
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -213,7 +217,8 @@
 
   // Session will want to write a SETTINGS ack.
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::SETTINGS}));
   visitor.Clear();
 
@@ -230,7 +235,8 @@
   EXPECT_GT(stream_id, 0);
   EXPECT_TRUE(session.want_write());
   EXPECT_EQ(kSentinel1, session.GetStreamUserData(stream_id));
-  session.Send();
+  result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS,
                                             spdy::SpdyFrameType::DATA}));
   visitor.Clear();
@@ -259,7 +265,8 @@
   session.SetStreamUserData(stream_id, const_cast<char*>(kSentinel2));
   EXPECT_EQ(kSentinel2, session.GetStreamUserData(stream_id));
 
-  session.Send();
+  result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::HEADERS}));
 
   // No data was sent (just HEADERS), so the remaining send window size should
@@ -288,7 +295,8 @@
   EXPECT_GT(stream_id, 0);
   EXPECT_TRUE(session.want_write());
   EXPECT_EQ(kSentinel1, session.GetStreamUserData(stream_id));
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -302,7 +310,8 @@
   body1.set_is_data_available(true);
   EXPECT_TRUE(session.ResumeStream(stream_id));
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::DATA}));
   EXPECT_FALSE(session.want_write());
 
@@ -331,12 +340,14 @@
   EXPECT_TRUE(session.want_write());
   EXPECT_EQ(kSentinel1, session.GetStreamUserData(stream_id));
   visitor.set_is_write_blocked(true);
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
 
   EXPECT_THAT(visitor.data(), testing::IsEmpty());
   EXPECT_TRUE(session.want_write());
   visitor.set_is_write_blocked(false);
-  session.Send();
+  result = session.Send();
+  EXPECT_EQ(0, result);
 
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
@@ -359,7 +370,9 @@
   session.StartGracefulShutdown();
   EXPECT_FALSE(session.want_write());
 
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
+
   absl::string_view serialized = visitor.data();
   EXPECT_THAT(serialized,
               testing::StartsWith(spdy::kHttp2ConnectionHeaderPrefix));
@@ -477,7 +490,8 @@
 
   EXPECT_TRUE(session.want_write());
   // Some bytes should have been serialized.
-  session.Send();
+  int send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   // Initial SETTINGS, SETTINGS ack.
   // TODO(birenroy): automatically queue PING acks.
   EXPECT_THAT(visitor.data(), EqualsFrames({spdy::SpdyFrameType::SETTINGS,
@@ -493,7 +507,8 @@
   EXPECT_FALSE(session.want_write());
   session.EnqueueFrame(absl::make_unique<spdy::SpdyPingIR>(42));
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::PING}));
 }
@@ -507,7 +522,8 @@
   EXPECT_FALSE(session.want_write());
   session.EnqueueFrame(absl::make_unique<spdy::SpdySettingsIR>());
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::SETTINGS}));
 }
 
@@ -557,7 +573,8 @@
 
   // Server will want to send initial SETTINGS, and a SETTINGS ack.
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
   visitor.Clear();
@@ -578,7 +595,8 @@
   session.SetStreamUserData(1, nullptr);
   EXPECT_EQ(nullptr, session.GetStreamUserData(1));
 
-  session.Send();
+  send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::HEADERS, SpdyFrameType::DATA}));
   EXPECT_FALSE(session.want_write());
@@ -602,7 +620,8 @@
   session.StartGracefulShutdown();
   EXPECT_TRUE(session.want_write());
 
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY}));
 }
@@ -619,7 +638,8 @@
   session.EnqueueFrame(std::move(goaway));
   EXPECT_TRUE(session.want_write());
 
-  session.Send();
+  int result = session.Send();
+  EXPECT_EQ(0, result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::GOAWAY}));
 
@@ -667,7 +687,8 @@
 
   // Server will want to send initial SETTINGS, and a SETTINGS ack.
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
   visitor.Clear();
@@ -683,7 +704,8 @@
       &body1);
   EXPECT_EQ(submit_result, 0);
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::HEADERS, SpdyFrameType::DATA}));
   visitor.Clear();
@@ -697,7 +719,8 @@
   ASSERT_EQ(trailer_result, 0);
   EXPECT_TRUE(session.want_write());
 
-  session.Send();
+  send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(), EqualsFrames({SpdyFrameType::HEADERS}));
 }
 
@@ -740,7 +763,8 @@
 
   // Server will want to send initial SETTINGS, and a SETTINGS ack.
   EXPECT_TRUE(session.want_write());
-  session.Send();
+  int send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::SETTINGS, SpdyFrameType::SETTINGS}));
   visitor.Clear();
@@ -765,7 +789,8 @@
   EXPECT_TRUE(session.want_write());
 
   EXPECT_CALL(visitor, OnCloseStream(1, Http2ErrorCode::NO_ERROR));
-  session.Send();
+  send_result = session.Send();
+  EXPECT_EQ(0, send_result);
   EXPECT_THAT(visitor.data(),
               EqualsFrames({SpdyFrameType::HEADERS, SpdyFrameType::DATA,
                             SpdyFrameType::HEADERS}));
