Back out "Implement server-side ALPN for WebTransport"

Summary:
Original commit changeset: e4955bc68a91

Original Phabricator Diff: D81896045

Reviewed By: hanidamlaj

Differential Revision: D83367386

fbshipit-source-id: 63db2fa09d5d30ee4bd4ffd9ab56699a96084f7a

Author: Joanna Jo

proxygen/httpserver/samples/hq/SampleHandlers.cpp

@@ -7,7 +7,6 @@
  */
 
 #include <proxygen/httpserver/samples/hq/SampleHandlers.h>
-#include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/split.hpp>
@@ -359,19 +358,6 @@ void DeviousBatonHandler::onHeadersComplete(
     resp.setWantsKeepalive(false);
     devious_.reset();
   }
-  std::vector<std::string> supportedProtocols{"deviousbaton-01"};
-  if (auto wtAvailableProtocols =
-          HTTPWebTransport::getWTAvailableProtocols(*msg)) {
-    if (auto wtProtocol = HTTPWebTransport::negotiateWTProtocol(
-            wtAvailableProtocols.value(), supportedProtocols)) {
-      // TODO: Set the version from the negotiated protocol instead of query
-      // param
-      HTTPWebTransport::setWTProtocol(resp, wtProtocol.value());
-    } else {
-      VLOG(4) << "Failed to negotiate WebTransport protocol";
-      resp.setStatusCode(400);
-    }
-  }
   resp.dumpMessage(4);
   txn_->sendHeaders(resp);
 

proxygen/httpserver/samples/hq/devious/html/devious_baton_client.js

@@ -46,10 +46,8 @@ class DeviousBatonClient {
 
   async connect() {
     try {
-      // Create WebTransport connection with deviousbaton-01 subprotocol
-      this.transport = new WebTransport(this.serverUrl.toString(), {
-        protocols: ["deviousbaton-01"]
-      });
+      // Create WebTransport connection
+      this.transport = new WebTransport(this.serverUrl.toString());
 
       // Wait for connection to be established
       await this.transport.ready;

proxygen/lib/http/HeaderConstants.h

@@ -26,7 +26,4 @@ extern const std::string kMasque;
 extern const std::string kWebsocketString;
 extern const std::string kStatus200;
 
-constexpr std::string_view kWTAvailableProtocols{"wt-available-protocols"};
-constexpr std::string_view kWTProtocol{"wt-protocol"};
-
 } // namespace proxygen::headers

proxygen/lib/http/webtransport/HTTPWebTransport.cpp

@@ -9,103 +9,13 @@
 #include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
 
 #include <proxygen/lib/http/HTTPMessage.h>
-#include <proxygen/lib/http/structuredheaders/StructuredHeadersDecoder.h>
-#include <proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.h>
 
 namespace proxygen {
 
-using WTProtocolError = HTTPWebTransport::WTProtocolError;
-
 /*static*/ bool HTTPWebTransport::isConnectMessage(const HTTPMessage& msg) {
   constexpr std::string_view kWebTransport{"webtransport"};
   return msg.isRequest() && msg.getMethod() == proxygen::HTTPMethod::CONNECT &&
          msg.getUpgradeProtocol() && *msg.getUpgradeProtocol() == kWebTransport;
 }
 
-/*static*/ void HTTPWebTransport::setWTAvailableProtocols(
-    HTTPMessage& msg, const std::vector<std::string>& protocols) {
-  std::vector<StructuredHeaders::StructuredHeaderItem> items;
-  items.reserve(protocols.size());
-  for (const auto& protocol : protocols) {
-    items.emplace_back(StructuredHeaderItem::Type::STRING, protocol);
-  }
-
-  if (!items.empty()) {
-    StructuredHeadersEncoder encoder;
-    encoder.encodeList(items);
-    msg.getHeaders().set(headers::kWTAvailableProtocols, encoder.get());
-  }
-}
-
-/*static*/ void HTTPWebTransport::setWTProtocol(HTTPMessage& msg,
-                                                std::string protocol) {
-  StructuredHeadersEncoder encoder;
-  StructuredHeaderItem item(StructuredHeaderItem::Type::STRING, protocol);
-  encoder.encodeItem(item);
-  msg.getHeaders().set(headers::kWTProtocol, encoder.get());
-}
-
-/*static*/ folly::Expected<std::vector<std::string>, WTProtocolError>
-HTTPWebTransport::getWTAvailableProtocols(const HTTPMessage& msg) {
-  auto header = msg.getHeaders().combine(headers::kWTAvailableProtocols);
-  if (header.empty()) {
-    return folly::makeUnexpected(WTProtocolError::HeaderMissing);
-  }
-
-  StructuredHeadersDecoder decoder(header);
-  std::vector<StructuredHeaderItem> list;
-
-  if (decoder.decodeList(list) != DecodeError::OK) {
-    return folly::makeUnexpected(WTProtocolError::ParseFailed);
-  }
-
-  std::vector<std::string> protocols;
-  for (const auto& item : list) {
-    if (item.tag != StructuredHeaders::StructuredHeaderItem::Type::STRING) {
-      return folly::makeUnexpected(WTProtocolError::ParseFailed);
-    }
-    protocols.emplace_back(item.get<std::string>());
-  }
-
-  if (protocols.empty()) {
-    return folly::makeUnexpected(WTProtocolError::EmptyList);
-  }
-
-  return protocols;
-}
-
-/*static*/ folly::Expected<std::string, WTProtocolError>
-HTTPWebTransport::getWTProtocol(const HTTPMessage& msg) {
-  auto header = msg.getHeaders().getSingleOrEmpty(headers::kWTProtocol);
-  if (header.empty()) {
-    return folly::makeUnexpected(WTProtocolError::HeaderMissing);
-  }
-
-  StructuredHeadersDecoder decoder(header);
-  StructuredHeaderItem item;
-
-  if (decoder.decodeItem(item) != DecodeError::OK) {
-    return folly::makeUnexpected(WTProtocolError::ParseFailed);
-  }
-  if (item.tag != StructuredHeaders::StructuredHeaderItem::Type::STRING) {
-    return folly::makeUnexpected(WTProtocolError::ParseFailed);
-  }
-
-  return item.get<std::string>();
-}
-
-/*static*/ folly::Optional<std::string> HTTPWebTransport::negotiateWTProtocol(
-    const std::vector<std::string>& wtAvailableProtocols,
-    const std::vector<std::string>& supportedProtocols) {
-  for (const auto& protocol : supportedProtocols) {
-    if (std::find(wtAvailableProtocols.begin(),
-                  wtAvailableProtocols.end(),
-                  protocol) != wtAvailableProtocols.end()) {
-      return protocol;
-    }
-  }
-
-  return folly::none;
-}
-
 }; // namespace proxygen

proxygen/lib/http/webtransport/HTTPWebTransport.h

@@ -8,37 +8,13 @@
 
 #pragma once
 
-#include <folly/Expected.h>
-#include <folly/Optional.h>
-
 namespace proxygen {
 
 class HTTPMessage;
 
 class HTTPWebTransport {
  public:
-  enum class WTProtocolError : uint8_t {
-    HeaderMissing,
-    ParseFailed,
-    EmptyList
-  };
-
   static bool isConnectMessage(const proxygen::HTTPMessage& msg);
-
-  static void setWTAvailableProtocols(
-      HTTPMessage& msg, const std::vector<std::string>& protocols);
-
-  static void setWTProtocol(HTTPMessage& msg, std::string protocol);
-
-  static folly::Expected<std::vector<std::string>, WTProtocolError>
-  getWTAvailableProtocols(const HTTPMessage& msg);
-
-  static folly::Expected<std::string, WTProtocolError> getWTProtocol(
-      const HTTPMessage& msg);
-
-  static folly::Optional<std::string> negotiateWTProtocol(
-      const std::vector<std::string>& wtAvailableProtocols,
-      const std::vector<std::string>& supportedProtocols);
 };
 
 } // namespace proxygen