Replace quiche_error_code_wrapper platform API with a virtual method on the writer.

PiperOrigin-RevId: 439783894

common/platform/api/quiche_error_code_wrappers.h

diff --git a/common/platform/api/quiche_error_code_wrappers.h b/common/platform/api/quiche_error_code_wrappers.h
deleted file mode 100644
index ef08dce..0000000
--- a/common/platform/api/quiche_error_code_wrappers.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2019 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_COMMON_PLATFORM_API_QUICHE_ERROR_CODE_WRAPPERS_H_
-#define QUICHE_COMMON_PLATFORM_API_QUICHE_ERROR_CODE_WRAPPERS_H_
-
-#include "quiche_platform_impl/quiche_error_code_wrappers_impl.h"
-
-// TODO(vasilvv): ensure WRITE_STATUS_MSG_TOO_BIG works everywhere and remove
-// this.
-#define QUICHE_EMSGSIZE QUICHE_EMSGSIZE_IMPL
-
-#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_ERROR_CODE_WRAPPERS_H_

quic/core/batch_writer/quic_batch_writer_base.h

diff --git a/quic/core/batch_writer/quic_batch_writer_base.h b/quic/core/batch_writer/quic_batch_writer_base.h
index e7d1f12..bca8646 100644
--- a/quic/core/batch_writer/quic_batch_writer_base.h
+++ b/quic/core/batch_writer/quic_batch_writer_base.h
@@ -38,6 +38,10 @@
 
   void SetWritable() final { write_blocked_ = false; }
 
+  absl::optional<int> MessageTooBigErrorCode() const override {
+    return EMSGSIZE;
+  }
+
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& /*peer_address*/) const final {
     return kMaxOutgoingPacketSize;

quic/core/http/end_to_end_test.cc

diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 95b274a..b995d39 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -32,7 +32,6 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_utils.h"
 #include "quic/platform/api/quic_epoll.h"
-#include "quic/platform/api/quic_error_code_wrappers.h"
 #include "quic/platform/api/quic_expect_bug.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
@@ -5614,7 +5613,7 @@
         TypeByteIsServerHello(type_byte)) {
       QUIC_DVLOG(1) << "Return write error for packet containing ServerHello";
       error_returned_ = true;
-      return WriteResult(WRITE_STATUS_ERROR, QUIC_EMSGSIZE);
+      return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
     }
     return result;
   }
@@ -5698,7 +5697,7 @@
     } else if (!error_returned_) {
       QUIC_DVLOG(1) << "Return write error for short header packet";
       error_returned_ = true;
-      return WriteResult(WRITE_STATUS_ERROR, QUIC_EMSGSIZE);
+      return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
     }
     return QuicPacketWriterWrapper::WritePacket(buffer, buf_len, self_address,
                                                 peer_address, options);

quic/core/quic_connection.cc

diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 0cc3296..0716c52 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -39,7 +39,6 @@
 #include "quic/core/quic_utils.h"
 #include "quic/platform/api/quic_bug_tracker.h"
 #include "quic/platform/api/quic_client_stats.h"
-#include "quic/platform/api/quic_error_code_wrappers.h"
 #include "quic/platform/api/quic_exported_stats.h"
 #include "quic/platform/api/quic_flag_utils.h"
 #include "quic/platform/api/quic_flags.h"
@@ -3089,7 +3088,7 @@
         packet.encrypted_buffer.data(), packet.encrypted_buffer.length(),
         packet.self_address.host(), packet.peer_address, per_packet_options_);
     QUIC_DVLOG(1) << ENDPOINT << "Sending buffered packet, result: " << result;
-    if (IsMsgTooBig(result) &&
+    if (IsMsgTooBig(writer_, result) &&
         packet.encrypted_buffer.length() > long_term_mtu_) {
       // When MSG_TOO_BIG is returned, the system typically knows what the
       // actual MTU is, so there is no need to probe further.
@@ -3530,7 +3529,7 @@
 
   // In some cases, an MTU probe can cause EMSGSIZE. This indicates that the
   // MTU discovery is permanently unsuccessful.
-  if (IsMsgTooBig(result)) {
+  if (IsMsgTooBig(writer_, result)) {
     if (is_mtu_discovery) {
       // When MSG_TOO_BIG is returned, the system typically knows what the
       // actual MTU is, so there is no need to probe further.
@@ -3824,9 +3823,12 @@
   }
 }
 
-bool QuicConnection::IsMsgTooBig(const WriteResult& result) {
+bool QuicConnection::IsMsgTooBig(const QuicPacketWriter* writer,
+                                 const WriteResult& result) {
+  absl::optional<int> writer_error_code = writer->MessageTooBigErrorCode();
   return (result.status == WRITE_STATUS_MSG_TOO_BIG) ||
-         (IsWriteError(result.status) && result.error_code == QUIC_EMSGSIZE);
+         (writer_error_code.has_value() && IsWriteError(result.status) &&
+          result.error_code == *writer_error_code);
 }
 
 bool QuicConnection::ShouldDiscardPacket(EncryptionLevel encryption_level) {
@@ -3883,22 +3885,20 @@
   const std::string error_details = absl::StrCat(
       "Write failed with error: ", error_code, " (", strerror(error_code), ")");
   QUIC_LOG_FIRST_N(ERROR, 2) << ENDPOINT << error_details;
-  switch (error_code) {
-    case QUIC_EMSGSIZE:
-      CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
-                      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-      break;
-    default:
-      // We can't send an error as the socket is presumably borked.
-      if (version().HasIetfInvariantHeader()) {
-        QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
-      } else {
-        QUIC_CODE_COUNT(
-            quic_tear_down_local_connection_on_write_error_non_ietf);
-      }
-      CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
-                      ConnectionCloseBehavior::SILENT_CLOSE);
+  absl::optional<int> writer_error_code = writer_->MessageTooBigErrorCode();
+  if (writer_error_code.has_value() && error_code == *writer_error_code) {
+    CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
+                    ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
+    return;
   }
+  // We can't send an error as the socket is presumably borked.
+  if (version().HasIetfInvariantHeader()) {
+    QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
+  } else {
+    QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_non_ietf);
+  }
+  CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
+                  ConnectionCloseBehavior::SILENT_CLOSE);
 }
 
 QuicPacketBuffer QuicConnection::GetPacketBuffer() {

quic/core/quic_connection.h

diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 17c0830..7f4ac8b 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -599,7 +599,7 @@
   void OnWriteError(int error_code);
 
   // Whether |result| represents a MSG TOO BIG write error.
-  bool IsMsgTooBig(const WriteResult& result);
+  bool IsMsgTooBig(const QuicPacketWriter* writer, const WriteResult& result);
 
   // If the socket is not blocked, writes queued packets.
   void WriteIfNotBlocked();

quic/core/quic_connection_test.cc

diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 6061fd5..6cab381 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -34,7 +34,6 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_utils.h"
 #include "quic/core/quic_versions.h"
-#include "quic/platform/api/quic_error_code_wrappers.h"
 #include "quic/platform/api/quic_expect_bug.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_ip_address.h"
@@ -12320,7 +12319,7 @@
   uint32_t num_packets_write_attempts = writer_->packets_write_attempts();
 
   writer_->SetShouldWriteFail();
-  writer_->SetWriteError(QUIC_EMSGSIZE);
+  writer_->SetWriteError(*writer_->MessageTooBigErrorCode());
   const QuicSocketAddress kNewPeerAddress(QuicIpAddress::Any4(), 12345);
   EXPECT_CALL(visitor_, OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
       .Times(0u);

quic/core/quic_default_packet_writer.cc

diff --git a/quic/core/quic_default_packet_writer.cc b/quic/core/quic_default_packet_writer.cc
index e71169a..23ff3c2 100644
--- a/quic/core/quic_default_packet_writer.cc
+++ b/quic/core/quic_default_packet_writer.cc
@@ -41,6 +41,10 @@
   write_blocked_ = false;
 }
 
+absl::optional<int> QuicDefaultPacketWriter::MessageTooBigErrorCode() const {
+  return EMSGSIZE;
+}
+
 QuicByteCount QuicDefaultPacketWriter::GetMaxPacketSize(
     const QuicSocketAddress& /*peer_address*/) const {
   return kMaxOutgoingPacketSize;

quic/core/quic_default_packet_writer.h

diff --git a/quic/core/quic_default_packet_writer.h b/quic/core/quic_default_packet_writer.h
index df30f24..f332c96 100644
--- a/quic/core/quic_default_packet_writer.h
+++ b/quic/core/quic_default_packet_writer.h
@@ -31,6 +31,7 @@
                           PerPacketOptions* options) override;
   bool IsWriteBlocked() const override;
   void SetWritable() override;
+  absl::optional<int> MessageTooBigErrorCode() const override;
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& peer_address) const override;
   bool SupportsReleaseTime() const override;

quic/core/quic_packet_writer.h

diff --git a/quic/core/quic_packet_writer.h b/quic/core/quic_packet_writer.h
index 107c818..78b576a 100644
--- a/quic/core/quic_packet_writer.h
+++ b/quic/core/quic_packet_writer.h
@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <utility>
 
+#include "absl/types/optional.h"
 #include "quic/core/quic_packets.h"
 #include "quic/platform/api/quic_export.h"
 #include "quic/platform/api/quic_ip_address.h"
@@ -114,6 +115,11 @@
   // is received or an asynchronous write completes.
   virtual void SetWritable() = 0;
 
+  // The error code used by the writer to indicate that the write failed due to
+  // supplied packet being too big.  This is equivalent to returning
+  // WRITE_STATUS_MSG_TOO_BIG as a status.
+  virtual absl::optional<int> MessageTooBigErrorCode() const = 0;
+
   // Returns the maximum size of the packet which can be written using this
   // writer for the supplied peer address.  This size may actually exceed the
   // size of a valid QUIC packet.

quic/core/quic_packet_writer_wrapper.cc

diff --git a/quic/core/quic_packet_writer_wrapper.cc b/quic/core/quic_packet_writer_wrapper.cc
index 6f7c54e..62ec0cf 100644
--- a/quic/core/quic_packet_writer_wrapper.cc
+++ b/quic/core/quic_packet_writer_wrapper.cc
@@ -32,6 +32,10 @@
   writer_->SetWritable();
 }
 
+absl::optional<int> QuicPacketWriterWrapper::MessageTooBigErrorCode() const {
+  return writer_->MessageTooBigErrorCode();
+}
+
 QuicByteCount QuicPacketWriterWrapper::GetMaxPacketSize(
     const QuicSocketAddress& peer_address) const {
   return writer_->GetMaxPacketSize(peer_address);

quic/core/quic_packet_writer_wrapper.h

diff --git a/quic/core/quic_packet_writer_wrapper.h b/quic/core/quic_packet_writer_wrapper.h
index e6dac04..a7f2d01 100644
--- a/quic/core/quic_packet_writer_wrapper.h
+++ b/quic/core/quic_packet_writer_wrapper.h
@@ -31,6 +31,7 @@
                           PerPacketOptions* options) override;
   bool IsWriteBlocked() const override;
   void SetWritable() override;
+  absl::optional<int> MessageTooBigErrorCode() const override;
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& peer_address) const override;
   bool SupportsReleaseTime() const override;

quic/masque/masque_encapsulated_epoll_client.cc

diff --git a/quic/masque/masque_encapsulated_epoll_client.cc b/quic/masque/masque_encapsulated_epoll_client.cc
index 8891e4a..047d25c 100644
--- a/quic/masque/masque_encapsulated_epoll_client.cc
+++ b/quic/masque/masque_encapsulated_epoll_client.cc
@@ -39,6 +39,10 @@
 
   void SetWritable() override {}
 
+  absl::optional<int> MessageTooBigErrorCode() const override {
+    return EMSGSIZE;
+  }
+
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& /*peer_address*/) const override {
     return kMasqueMaxEncapsulatedPacketSize;

quic/platform/api/quic_error_code_wrappers.h

diff --git a/quic/platform/api/quic_error_code_wrappers.h b/quic/platform/api/quic_error_code_wrappers.h
deleted file mode 100644
index 173c240..0000000
--- a/quic/platform/api/quic_error_code_wrappers.h
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2019 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_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_
-
-#include "common/platform/api/quiche_error_code_wrappers.h"
-
-// TODO(vasilvv): ensure WRITE_STATUS_MSG_TOO_BIG works everywhere and remove
-// this.
-#define QUIC_EMSGSIZE QUICHE_EMSGSIZE
-
-#endif  // QUICHE_QUIC_PLATFORM_API_QUIC_ERROR_CODE_WRAPPERS_H_

quic/qbone/qbone_stream_test.cc

diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index c2c862a..0ec7871 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -108,6 +108,10 @@
 
   void SetWritable() override {}
 
+  absl::optional<int> MessageTooBigErrorCode() const override {
+    return absl::nullopt;
+  }
+
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& peer_address) const override {
     return 0;

quic/test_tools/first_flight.h

diff --git a/quic/test_tools/first_flight.h b/quic/test_tools/first_flight.h
index 448a189..7c6123d 100644
--- a/quic/test_tools/first_flight.h
+++ b/quic/test_tools/first_flight.h
@@ -44,6 +44,9 @@
   // Overrides for QuicPacketWriter.
   bool IsWriteBlocked() const override { return false; }
   void SetWritable() override {}
+  absl::optional<int> MessageTooBigErrorCode() const override {
+    return absl::nullopt;
+  }
   QuicByteCount GetMaxPacketSize(
       const QuicSocketAddress& /*peer_address*/) const override {
     return kMaxOutgoingPacketSize;

quic/test_tools/quic_test_utils.cc

diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 9bc950f..17804a1 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -28,7 +28,6 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_utils.h"
 #include "quic/core/quic_versions.h"
-#include "quic/platform/api/quic_error_code_wrappers.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
 #include "quic/test_tools/crypto_test_utils.h"
@@ -1452,10 +1451,10 @@
   }
   if (next_packet_too_large_) {
     next_packet_too_large_ = false;
-    return WriteResult(WRITE_STATUS_ERROR, QUIC_EMSGSIZE);
+    return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
   }
   if (always_get_packet_too_large_) {
-    return WriteResult(WRITE_STATUS_ERROR, QUIC_EMSGSIZE);
+    return WriteResult(WRITE_STATUS_ERROR, *MessageTooBigErrorCode());
   }
   if (IsWriteBlocked()) {
     return WriteResult(is_write_blocked_data_buffered_

quic/test_tools/quic_test_utils.h

diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 82262eb..7e474b5 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1148,6 +1148,8 @@
               (override));
   MOCK_METHOD(bool, IsWriteBlocked, (), (const, override));
   MOCK_METHOD(void, SetWritable, (), (override));
+  MOCK_METHOD(absl::optional<int>, MessageTooBigErrorCode, (),
+              (const, override));
   MOCK_METHOD(QuicByteCount, GetMaxPacketSize,
               (const QuicSocketAddress& peer_address), (const, override));
   MOCK_METHOD(bool, SupportsReleaseTime, (), (const, override));
@@ -1745,6 +1747,8 @@
 
   bool IsWriteBlocked() const override { return write_blocked_; }
 
+  absl::optional<int> MessageTooBigErrorCode() const override { return 0x1234; }
+
   void SetWriteBlocked() { write_blocked_ = true; }
 
   void SetWritable() override { write_blocked_ = false; }

quic/test_tools/simulator/quic_endpoint_base.cc

diff --git a/quic/test_tools/simulator/quic_endpoint_base.cc b/quic/test_tools/simulator/quic_endpoint_base.cc
index b4882b8..e66af8b 100644
--- a/quic/test_tools/simulator/quic_endpoint_base.cc
+++ b/quic/test_tools/simulator/quic_endpoint_base.cc
@@ -165,6 +165,10 @@
   is_blocked_ = false;
 }
 
+absl::optional<int> QuicEndpointBase::Writer::MessageTooBigErrorCode() const {
+  return absl::nullopt;
+}
+
 QuicByteCount QuicEndpointBase::Writer::GetMaxPacketSize(
     const QuicSocketAddress& /*peer_address*/) const {
   return kMaxOutgoingPacketSize;

quic/test_tools/simulator/quic_endpoint_base.h

diff --git a/quic/test_tools/simulator/quic_endpoint_base.h b/quic/test_tools/simulator/quic_endpoint_base.h
index 8fbb9c0..9578c79 100644
--- a/quic/test_tools/simulator/quic_endpoint_base.h
+++ b/quic/test_tools/simulator/quic_endpoint_base.h
@@ -84,6 +84,7 @@
                             PerPacketOptions* options) override;
     bool IsWriteBlocked() const override;
     void SetWritable() override;
+    absl::optional<int> MessageTooBigErrorCode() const override;
     QuicByteCount GetMaxPacketSize(
         const QuicSocketAddress& peer_address) const override;
     bool SupportsReleaseTime() const override;