Update Http2VisitorInterface::OnHeaderResult from enum to enum class. This update aligns with internal change 691497117, which did the same for another class, following https://abseil.io/tips/86. No functional change is intended. NOT generated via copybara. PiperOrigin-RevId: 696578103

diff --git a/quiche/http2/adapter/callback_visitor.cc b/quiche/http2/adapter/callback_visitor.cc
index 89b02b5..97a2c29 100644
--- a/quiche/http2/adapter/callback_visitor.cc
+++ b/quiche/http2/adapter/callback_visitor.cc

@@ -77,6 +77,8 @@
 namespace http2 {
 namespace adapter {
 
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
+
 CallbackVisitor::CallbackVisitor(Perspective perspective,
                                  const nghttp2_session_callbacks& callbacks,
                                  void* user_data)
@@ -240,8 +242,9 @@
   return true;
 }
 
-Http2VisitorInterface::OnHeaderResult CallbackVisitor::OnHeaderForStream(
-    Http2StreamId stream_id, absl::string_view name, absl::string_view value) {
+OnHeaderResult CallbackVisitor::OnHeaderForStream(Http2StreamId stream_id,
+                                                  absl::string_view name,
+                                                  absl::string_view value) {
   QUICHE_VLOG(2) << "OnHeaderForStream(stream_id=" << stream_id << ", name=["
                  << absl::CEscape(name) << "], value=[" << absl::CEscape(value)
                  << "])";
@@ -251,15 +254,15 @@
         ToUint8Ptr(value.data()), value.size(), NGHTTP2_NV_FLAG_NONE,
         user_data_);
     if (result == 0) {
-      return HEADER_OK;
+      return OnHeaderResult::HEADER_OK;
     } else if (result == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) {
-      return HEADER_RST_STREAM;
+      return OnHeaderResult::HEADER_RST_STREAM;
     } else {
       // Assume NGHTTP2_ERR_CALLBACK_FAILURE.
-      return HEADER_CONNECTION_ERROR;
+      return OnHeaderResult::HEADER_CONNECTION_ERROR;
     }
   }
-  return HEADER_OK;
+  return OnHeaderResult::HEADER_OK;
 }
 
 bool CallbackVisitor::OnEndHeadersForStream(Http2StreamId stream_id) {

diff --git a/quiche/http2/adapter/http2_visitor_interface.h b/quiche/http2/adapter/http2_visitor_interface.h
index 3bf489f..f00ac61 100644
--- a/quiche/http2/adapter/http2_visitor_interface.h
+++ b/quiche/http2/adapter/http2_visitor_interface.h

@@ -150,7 +150,7 @@
   // different error code instead, which should be done before returning
   // HEADER_RST_STREAM. Returning HEADER_CONNECTION_ERROR will lead to a
   // non-recoverable error on the connection.
-  enum OnHeaderResult {
+  enum class OnHeaderResult {
     // The header was accepted.
     HEADER_OK,
     // The application considers the header a connection error.

diff --git a/quiche/http2/adapter/mock_http2_visitor.h b/quiche/http2/adapter/mock_http2_visitor.h
index a99c944..2e68cb2 100644
--- a/quiche/http2/adapter/mock_http2_visitor.h
+++ b/quiche/http2/adapter/mock_http2_visitor.h

@@ -19,7 +19,8 @@
     ON_CALL(*this, OnFrameHeader).WillByDefault(testing::Return(true));
     ON_CALL(*this, OnBeginHeadersForStream)
         .WillByDefault(testing::Return(true));
-    ON_CALL(*this, OnHeaderForStream).WillByDefault(testing::Return(HEADER_OK));
+    ON_CALL(*this, OnHeaderForStream)
+        .WillByDefault(testing::Return(OnHeaderResult::HEADER_OK));
     ON_CALL(*this, OnEndHeadersForStream).WillByDefault(testing::Return(true));
     ON_CALL(*this, OnDataPaddingLength).WillByDefault(testing::Return(true));
     ON_CALL(*this, OnBeginDataForStream).WillByDefault(testing::Return(true));

diff --git a/quiche/http2/adapter/nghttp2_adapter_test.cc b/quiche/http2/adapter/nghttp2_adapter_test.cc
index 073f73c..1e83bbf 100644
--- a/quiche/http2/adapter/nghttp2_adapter_test.cc
+++ b/quiche/http2/adapter/nghttp2_adapter_test.cc

@@ -20,6 +20,7 @@
 namespace {
 
 using ConnectionError = Http2VisitorInterface::ConnectionError;
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
 
 using spdy::SpdyFrameType;
 using testing::_;
@@ -1521,7 +1522,7 @@
           testing::InvokeWithoutArgs([&adapter]() {
             adapter->SubmitRst(1, Http2ErrorCode::REFUSED_STREAM);
           }),
-          testing::Return(Http2VisitorInterface::HEADER_RST_STREAM)));
+          testing::Return(OnHeaderResult::HEADER_RST_STREAM)));
 
   const int64_t stream_result = adapter->ProcessBytes(stream_frames);
   EXPECT_EQ(stream_frames.size(), stream_result);
@@ -1592,8 +1593,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, "server", "my-fake-server"));
   EXPECT_CALL(visitor,
               OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT"))
-      .WillOnce(
-          testing::Return(Http2VisitorInterface::HEADER_CONNECTION_ERROR));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_CONNECTION_ERROR));
   // Translation to nghttp2 treats this error as a general parsing error.
   EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kParseError));
 
@@ -1659,8 +1659,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, "server", "my-fake-server"));
   EXPECT_CALL(visitor,
               OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT"))
-      .WillOnce(
-          testing::Return(Http2VisitorInterface::HEADER_CONNECTION_ERROR));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_CONNECTION_ERROR));
   // Translation to nghttp2 treats this error as a general parsing error.
   EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kParseError));
 
@@ -4146,7 +4145,7 @@
   EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
   EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(5);
   EXPECT_CALL(visitor, OnHeaderForStream(1, "header2", _))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   // The CONTINUATION frame header and header fields are not processed.
 
   int64_t result = adapter->ProcessBytes(frames);
@@ -4927,7 +4926,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, ":authority", "example.com"));
   EXPECT_CALL(visitor, OnHeaderForStream(1, ":path", "/this/is/request/one"));
   EXPECT_CALL(visitor, OnHeaderForStream(1, "accept", "some bogus value!"))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   EXPECT_CALL(visitor, OnFrameHeader(1, 4, WINDOW_UPDATE, 0));
   EXPECT_CALL(visitor, OnWindowUpdate(1, 2000));
   // DATA frame is not delivered to the visitor.
@@ -4993,7 +4992,7 @@
   EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
   EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(4);
   EXPECT_CALL(visitor, OnHeaderForStream(1, "accept", "some bogus value!"))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   // For the RST_STREAM-marked stream, the control frames and METADATA frame but
   // not the DATA frame are delivered to the visitor.
   EXPECT_CALL(visitor, OnFrameHeader(1, 4, WINDOW_UPDATE, 0));

diff --git a/quiche/http2/adapter/nghttp2_callbacks.cc b/quiche/http2/adapter/nghttp2_callbacks.cc
index 7a0b795..243495a 100644
--- a/quiche/http2/adapter/nghttp2_callbacks.cc
+++ b/quiche/http2/adapter/nghttp2_callbacks.cc

@@ -18,6 +18,8 @@
 namespace adapter {
 namespace callbacks {
 
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
+
 ssize_t OnReadyToSend(nghttp2_session* /* session */, const uint8_t* data,
                       size_t length, int flags, void* user_data) {
   QUICHE_CHECK_NE(user_data, nullptr);
@@ -187,18 +189,17 @@
                  << "], value=[" << absl::CEscape(ToStringView(value)) << "])";
   QUICHE_CHECK_NE(user_data, nullptr);
   auto* visitor = static_cast<Http2VisitorInterface*>(user_data);
-  const Http2VisitorInterface::OnHeaderResult result =
-      visitor->OnHeaderForStream(frame->hd.stream_id, ToStringView(name),
-                                 ToStringView(value));
+  const OnHeaderResult result = visitor->OnHeaderForStream(
+      frame->hd.stream_id, ToStringView(name), ToStringView(value));
   switch (result) {
-    case Http2VisitorInterface::HEADER_OK:
+    case OnHeaderResult::HEADER_OK:
       return 0;
-    case Http2VisitorInterface::HEADER_CONNECTION_ERROR:
-    case Http2VisitorInterface::HEADER_COMPRESSION_ERROR:
+    case OnHeaderResult::HEADER_CONNECTION_ERROR:
+    case OnHeaderResult::HEADER_COMPRESSION_ERROR:
       return NGHTTP2_ERR_CALLBACK_FAILURE;
-    case Http2VisitorInterface::HEADER_RST_STREAM:
-    case Http2VisitorInterface::HEADER_FIELD_INVALID:
-    case Http2VisitorInterface::HEADER_HTTP_MESSAGING:
+    case OnHeaderResult::HEADER_RST_STREAM:
+    case OnHeaderResult::HEADER_FIELD_INVALID:
+    case OnHeaderResult::HEADER_HTTP_MESSAGING:
       return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
   }
   // Unexpected value.

diff --git a/quiche/http2/adapter/oghttp2_adapter_test.cc b/quiche/http2/adapter/oghttp2_adapter_test.cc
index 610809c..e68509a 100644
--- a/quiche/http2/adapter/oghttp2_adapter_test.cc
+++ b/quiche/http2/adapter/oghttp2_adapter_test.cc

@@ -23,6 +23,7 @@
 namespace {
 
 using ConnectionError = Http2VisitorInterface::ConnectionError;
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
 
 using spdy::SpdyFrameType;
 using testing::_;
@@ -1832,7 +1833,7 @@
           testing::InvokeWithoutArgs([&adapter]() {
             adapter->SubmitRst(1, Http2ErrorCode::REFUSED_STREAM);
           }),
-          testing::Return(Http2VisitorInterface::HEADER_RST_STREAM)));
+          testing::Return(OnHeaderResult::HEADER_RST_STREAM)));
 
   const int64_t stream_result = adapter->ProcessBytes(stream_frames);
   EXPECT_EQ(stream_frames.size(), static_cast<size_t>(stream_result));
@@ -1910,8 +1911,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, "server", "my-fake-server"));
   EXPECT_CALL(visitor,
               OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT"))
-      .WillOnce(
-          testing::Return(Http2VisitorInterface::HEADER_CONNECTION_ERROR));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_CONNECTION_ERROR));
   EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kHeaderError));
 
   const int64_t stream_result = adapter->ProcessBytes(stream_frames);
@@ -1985,8 +1985,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, "server", "my-fake-server"));
   EXPECT_CALL(visitor,
               OnHeaderForStream(1, "date", "Tue, 6 Apr 2021 12:54:01 GMT"))
-      .WillOnce(
-          testing::Return(Http2VisitorInterface::HEADER_CONNECTION_ERROR));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_CONNECTION_ERROR));
   EXPECT_CALL(visitor, OnConnectionError(ConnectionError::kHeaderError));
 
   const int64_t stream_result = adapter->ProcessBytes(stream_frames);
@@ -4913,7 +4912,7 @@
   EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
   EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(5);
   EXPECT_CALL(visitor, OnHeaderForStream(1, "header2", _))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   // The CONTINUATION frame header and header fields are not processed.
 
   int64_t result = adapter->ProcessBytes(frames);
@@ -6246,7 +6245,7 @@
   EXPECT_CALL(visitor, OnHeaderForStream(1, ":authority", "example.com"));
   EXPECT_CALL(visitor, OnHeaderForStream(1, ":path", "/this/is/request/one"));
   EXPECT_CALL(visitor, OnHeaderForStream(1, "accept", "some bogus value!"))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   // Stream WINDOW_UPDATE and DATA frames are not delivered to the visitor.
   EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));
   EXPECT_CALL(visitor, OnWindowUpdate(0, 2000));
@@ -6315,7 +6314,7 @@
   EXPECT_CALL(visitor, OnBeginHeadersForStream(1));
   EXPECT_CALL(visitor, OnHeaderForStream(1, _, _)).Times(4);
   EXPECT_CALL(visitor, OnHeaderForStream(1, "accept", "some bogus value!"))
-      .WillOnce(testing::Return(Http2VisitorInterface::HEADER_RST_STREAM));
+      .WillOnce(testing::Return(OnHeaderResult::HEADER_RST_STREAM));
   // Frames for the RST_STREAM-marked stream are not delivered to the visitor.
   // Note: nghttp2 still delivers control frames and metadata for the stream.
   EXPECT_CALL(visitor, OnFrameHeader(0, 4, WINDOW_UPDATE, 0));

diff --git a/quiche/http2/adapter/oghttp2_session.cc b/quiche/http2/adapter/oghttp2_session.cc
index 442a4d6..6d9bb13 100644
--- a/quiche/http2/adapter/oghttp2_session.cc
+++ b/quiche/http2/adapter/oghttp2_session.cc

@@ -29,6 +29,7 @@
 
 using ConnectionError = Http2VisitorInterface::ConnectionError;
 using DataFrameHeaderInfo = Http2VisitorInterface::DataFrameHeaderInfo;
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
 using SpdyFramerError = Http2DecoderAdapter::SpdyFramerError;
 
 using ::spdy::SpdySettingsIR;
@@ -226,23 +227,22 @@
   if (!status) {
     QUICHE_VLOG(1)
         << "Visitor rejected header block, returning HEADER_CONNECTION_ERROR";
-    SetResult(Http2VisitorInterface::HEADER_CONNECTION_ERROR);
+    SetResult(OnHeaderResult::HEADER_CONNECTION_ERROR);
   }
   validator_->StartHeaderBlock();
 }
 
-Http2VisitorInterface::OnHeaderResult InterpretHeaderStatus(
-    HeaderValidator::HeaderStatus status) {
+OnHeaderResult InterpretHeaderStatus(HeaderValidator::HeaderStatus status) {
   switch (status) {
     case HeaderValidator::HEADER_OK:
     case HeaderValidator::HEADER_SKIP:
-      return Http2VisitorInterface::HEADER_OK;
+      return OnHeaderResult::HEADER_OK;
     case HeaderValidator::HEADER_FIELD_INVALID:
-      return Http2VisitorInterface::HEADER_FIELD_INVALID;
+      return OnHeaderResult::HEADER_FIELD_INVALID;
     case HeaderValidator::HEADER_FIELD_TOO_LONG:
-      return Http2VisitorInterface::HEADER_RST_STREAM;
+      return OnHeaderResult::HEADER_RST_STREAM;
   }
-  return Http2VisitorInterface::HEADER_CONNECTION_ERROR;
+  return OnHeaderResult::HEADER_CONNECTION_ERROR;
 }
 
 void OgHttp2Session::PassthroughHeadersHandler::OnHeader(
@@ -262,7 +262,7 @@
     SetResult(InterpretHeaderStatus(validation_result));
     return;
   }
-  const Http2VisitorInterface::OnHeaderResult result =
+  const OnHeaderResult result =
       visitor_.OnHeaderForStream(stream_id_, key, value);
   SetResult(result);
 }
@@ -277,13 +277,13 @@
   if (!validator_->FinishHeaderBlock(type_)) {
     QUICHE_VLOG(1) << "FinishHeaderBlock returned false; returning "
                    << "HEADER_HTTP_MESSAGING";
-    SetResult(Http2VisitorInterface::HEADER_HTTP_MESSAGING);
+    SetResult(OnHeaderResult::HEADER_HTTP_MESSAGING);
     return;
   }
   if (frame_contains_fin_ && IsResponse(type_) &&
       StatusIs1xx(status_header())) {
     QUICHE_VLOG(1) << "Unexpected end of stream without final headers";
-    SetResult(Http2VisitorInterface::HEADER_HTTP_MESSAGING);
+    SetResult(OnHeaderResult::HEADER_HTTP_MESSAGING);
     return;
   }
   const bool result = visitor_.OnEndHeadersForStream(stream_id_);
@@ -313,8 +313,8 @@
 }
 
 void OgHttp2Session::PassthroughHeadersHandler::SetResult(
-    Http2VisitorInterface::OnHeaderResult result) {
-  if (result != Http2VisitorInterface::HEADER_OK) {
+    OnHeaderResult result) {
+  if (result != OnHeaderResult::HEADER_OK) {
     error_encountered_ = true;
     session_.OnHeaderStatus(stream_id_, result);
   }
@@ -1641,24 +1641,24 @@
   }
 }
 
-void OgHttp2Session::OnHeaderStatus(
-    Http2StreamId stream_id, Http2VisitorInterface::OnHeaderResult result) {
-  QUICHE_DCHECK_NE(result, Http2VisitorInterface::HEADER_OK);
+void OgHttp2Session::OnHeaderStatus(Http2StreamId stream_id,
+                                    OnHeaderResult result) {
+  QUICHE_DCHECK(result != OnHeaderResult::HEADER_OK);
   QUICHE_VLOG(1) << "OnHeaderStatus(stream_id=" << stream_id
-                 << ", result=" << result << ")";
+                 << ", result=" << static_cast<int>(result) << ")";
   const bool should_reset_stream =
-      result == Http2VisitorInterface::HEADER_RST_STREAM ||
-      result == Http2VisitorInterface::HEADER_FIELD_INVALID ||
-      result == Http2VisitorInterface::HEADER_HTTP_MESSAGING;
+      result == OnHeaderResult::HEADER_RST_STREAM ||
+      result == OnHeaderResult::HEADER_FIELD_INVALID ||
+      result == OnHeaderResult::HEADER_HTTP_MESSAGING;
   if (should_reset_stream) {
     const Http2ErrorCode error_code =
-        (result == Http2VisitorInterface::HEADER_RST_STREAM)
+        (result == OnHeaderResult::HEADER_RST_STREAM)
             ? Http2ErrorCode::INTERNAL_ERROR
             : Http2ErrorCode::PROTOCOL_ERROR;
     const spdy::SpdyErrorCode spdy_error_code = TranslateErrorCode(error_code);
     const Http2VisitorInterface::InvalidFrameError frame_error =
-        (result == Http2VisitorInterface::HEADER_RST_STREAM ||
-         result == Http2VisitorInterface::HEADER_FIELD_INVALID)
+        (result == OnHeaderResult::HEADER_RST_STREAM ||
+         result == OnHeaderResult::HEADER_FIELD_INVALID)
             ? Http2VisitorInterface::InvalidFrameError::kHttpHeader
             : Http2VisitorInterface::InvalidFrameError::kHttpMessaging;
     auto it = streams_reset_.find(stream_id);
@@ -1666,8 +1666,8 @@
       EnqueueFrame(
           std::make_unique<spdy::SpdyRstStreamIR>(stream_id, spdy_error_code));
 
-      if (result == Http2VisitorInterface::HEADER_FIELD_INVALID ||
-          result == Http2VisitorInterface::HEADER_HTTP_MESSAGING) {
+      if (result == OnHeaderResult::HEADER_FIELD_INVALID ||
+          result == OnHeaderResult::HEADER_HTTP_MESSAGING) {
         const bool ok = visitor_.OnInvalidFrame(stream_id, frame_error);
         if (!ok) {
           fatal_visitor_callback_failure_ = true;
@@ -1675,11 +1675,11 @@
         }
       }
     }
-  } else if (result == Http2VisitorInterface::HEADER_CONNECTION_ERROR) {
+  } else if (result == OnHeaderResult::HEADER_CONNECTION_ERROR) {
     fatal_visitor_callback_failure_ = true;
     LatchErrorAndNotify(Http2ErrorCode::INTERNAL_ERROR,
                         ConnectionError::kHeaderError);
-  } else if (result == Http2VisitorInterface::HEADER_COMPRESSION_ERROR) {
+  } else if (result == OnHeaderResult::HEADER_COMPRESSION_ERROR) {
     LatchErrorAndNotify(Http2ErrorCode::COMPRESSION_ERROR,
                         ConnectionError::kHeaderError);
   }

diff --git a/quiche/http2/adapter/recording_http2_visitor.cc b/quiche/http2/adapter/recording_http2_visitor.cc
index d1f37b5..a33ce36 100644
--- a/quiche/http2/adapter/recording_http2_visitor.cc
+++ b/quiche/http2/adapter/recording_http2_visitor.cc

@@ -8,6 +8,8 @@
 namespace adapter {
 namespace test {
 
+using OnHeaderResult = ::http2::adapter::Http2VisitorInterface::OnHeaderResult;
+
 int64_t RecordingHttp2Visitor::OnReadyToSend(absl::string_view serialized) {
   events_.push_back(absl::StrFormat("OnReadyToSend %d", serialized.size()));
   return serialized.size();
@@ -64,11 +66,11 @@
   return true;
 }
 
-Http2VisitorInterface::OnHeaderResult RecordingHttp2Visitor::OnHeaderForStream(
+OnHeaderResult RecordingHttp2Visitor::OnHeaderForStream(
     Http2StreamId stream_id, absl::string_view name, absl::string_view value) {
   events_.push_back(
       absl::StrFormat("OnHeaderForStream %d %s %s", stream_id, name, value));
-  return HEADER_OK;
+  return OnHeaderResult::HEADER_OK;
 }
 
 bool RecordingHttp2Visitor::OnEndHeadersForStream(Http2StreamId stream_id) {