@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/spdy/core/metadata_extension_test.cc

@@ -27,7 +27,7 @@ using ::testing::IsEmpty;
 const size_t kBufferSize = 64 * 1024;
 char kBuffer[kBufferSize];
 
-class MetadataExtensionTest : public QuicheTest {
+class MetadataExtensionTest : public quiche::test::QuicheTest {
  protected:
   MetadataExtensionTest() : test_buffer_(kBuffer, kBufferSize) {}
 

package/third_party/quiche/quiche/spdy/core/spdy_framer_test.cc

@@ -353,12 +353,13 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
     ++goaway_count_;
   }
 
-  void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
-                 SpdyStreamId parent_stream_id, bool exclusive, bool fin,
-                 bool end) override {
-    QUICHE_VLOG(1) << "OnHeaders(" << stream_id << ", " << has_priority << ", "
-                   << weight << ", " << parent_stream_id << ", " << exclusive
-                   << ", " << fin << ", " << end << ")";
+  void OnHeaders(SpdyStreamId stream_id, size_t payload_length,
+                 bool has_priority, int weight, SpdyStreamId parent_stream_id,
+                 bool exclusive, bool fin, bool end) override {
+    QUICHE_VLOG(1) << "OnHeaders(" << stream_id << ", " << payload_length
+                   << ", " << has_priority << ", " << weight << ", "
+                   << parent_stream_id << ", " << exclusive << ", " << fin
+                   << ", " << end << ")";
     ++headers_frame_count_;
     InitHeaderStreaming(SpdyFrameType::HEADERS, stream_id);
     if (fin) {
@@ -386,8 +387,10 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
     last_push_promise_promised_stream_ = promised_stream_id;
   }
 
-  void OnContinuation(SpdyStreamId stream_id, bool end) override {
-    QUICHE_VLOG(1) << "OnContinuation(" << stream_id << ", " << end << ")";
+  void OnContinuation(SpdyStreamId stream_id, size_t payload_size,
+                      bool end) override {
+    QUICHE_VLOG(1) << "OnContinuation(" << stream_id << ", " << payload_size
+                   << ", " << end << ")";
     ++continuation_count_;
   }
 
@@ -568,7 +571,7 @@ class TestSpdyUnknownIR : public SpdyUnknownIR {
 
 enum Output { USE, NOT_USE };
 
-class SpdyFramerTest : public QuicheTestWithParam<Output> {
+class SpdyFramerTest : public quiche::test::QuicheTestWithParam<Output> {
  public:
   SpdyFramerTest()
       : output_(output_buffer, kSize),
@@ -852,7 +855,7 @@ TEST_P(SpdyFramerTest, OversizedHeadersPaddingError) {
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnCommonHeader(1, 5, 0x1, 0x8));
-  EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
+  EXPECT_CALL(visitor, OnHeaders(1, 5, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_CALL(visitor, OnError(Http2DecoderAdapter::SPDY_INVALID_PADDING, _));
   EXPECT_EQ(frame.size(), deframer_->ProcessInput(frame.data(), frame.size()));
@@ -883,7 +886,7 @@ TEST_P(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnCommonHeader(1, 5, 0x1, 0x8));
-  EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
+  EXPECT_CALL(visitor, OnHeaders(1, 5, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
 
   EXPECT_EQ(frame.size(), deframer_->ProcessInput(frame.data(), frame.size()));
@@ -1316,14 +1319,14 @@ TEST_P(SpdyFramerTest, BasicWithError) {
 
   testing::InSequence s;
   EXPECT_CALL(visitor, OnCommonHeader(1, 1, 0x1, 0x4));
-  EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, true));
+  EXPECT_CALL(visitor, OnHeaders(1, 1, false, 0, 0, false, false, true));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1));
   EXPECT_CALL(visitor, OnHeaderFrameEnd(1));
   EXPECT_CALL(visitor, OnCommonHeader(1, 12, 0x0, 0x0));
   EXPECT_CALL(visitor, OnDataFrameHeader(1, 12, false));
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 12));
   EXPECT_CALL(visitor, OnCommonHeader(3, 6, 0x1, 0x24));
-  EXPECT_CALL(visitor, OnHeaders(3, true, 131, 0, false, false, true));
+  EXPECT_CALL(visitor, OnHeaders(3, 6, true, 131, 0, false, false, true));
   EXPECT_CALL(visitor, OnHeaderFrameStart(3));
   EXPECT_CALL(visitor, OnHeaderFrameEnd(3));
   EXPECT_CALL(visitor, OnCommonHeader(3, 8, 0x0, 0x0));
@@ -2935,7 +2938,7 @@ TEST_P(SpdyFramerTest, PushPromiseFramesWithIterator) {
   EXPECT_FALSE(frame_it.HasNextFrame());
 }
 
-class SpdyControlFrameIteratorTest : public QuicheTest {
+class SpdyControlFrameIteratorTest : public quiche::test::QuicheTest {
  public:
   SpdyControlFrameIteratorTest() : output_(output_buffer, kSize) {}
 
@@ -4196,7 +4199,7 @@ TEST_P(SpdyFramerTest, HeadersFrameFlags) {
       exclusive = true;
     }
     EXPECT_CALL(visitor, OnCommonHeader(stream_id, _, 0x1, set_flags));
-    EXPECT_CALL(visitor, OnHeaders(stream_id, has_priority, weight,
+    EXPECT_CALL(visitor, OnHeaders(stream_id, _, has_priority, weight,
                                    parent_stream_id, exclusive, fin, end));
     EXPECT_CALL(visitor, OnHeaderFrameStart(57)).Times(1);
     if (end) {
@@ -4338,7 +4341,7 @@ TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
     EXPECT_CALL(debug_visitor,
                 OnReceiveCompressedFrame(42, SpdyFrameType::HEADERS, _));
     EXPECT_CALL(visitor, OnCommonHeader(42, _, 0x1, 0));
-    EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false));
+    EXPECT_CALL(visitor, OnHeaders(42, _, false, 0, 0, false, false, false));
     EXPECT_CALL(visitor, OnHeaderFrameStart(42)).Times(1);
 
     SpdyHeadersIR headers_ir(/* stream_id = */ 42);
@@ -4367,7 +4370,8 @@ TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
     EXPECT_CALL(debug_visitor,
                 OnReceiveCompressedFrame(42, SpdyFrameType::CONTINUATION, _));
     EXPECT_CALL(visitor, OnCommonHeader(42, _, 0x9, flags));
-    EXPECT_CALL(visitor, OnContinuation(42, flags & HEADERS_FLAG_END_HEADERS));
+    EXPECT_CALL(visitor,
+                OnContinuation(42, _, flags & HEADERS_FLAG_END_HEADERS));
     bool end = flags & HEADERS_FLAG_END_HEADERS;
     if (end) {
       EXPECT_CALL(visitor, OnHeaderFrameEnd(42)).Times(1);

package/third_party/quiche/quiche/spdy/core/spdy_intrusive_list_test.cc

@@ -29,11 +29,11 @@ void swap(TestItem &a, TestItem &b) {
   swap(a.n, b.n);
 }
 
-class IntrusiveListTest : public QuicheTest {
+class IntrusiveListTest : public quiche::test::QuicheTest {
  protected:
   void CheckLists() {
     CheckLists(l1, ll1);
-    if (QuicheTest::HasFailure()) return;
+    if (quiche::test::QuicheTest::HasFailure()) return;
     CheckLists(l2, ll2);
   }
 
@@ -402,7 +402,7 @@ TEST(NewIntrusiveListTest, HandleInheritanceHierarchies) {
   }
 }
 
-class IntrusiveListTagTypeTest : public QuicheTest {
+class IntrusiveListTagTypeTest : public quiche::test::QuicheTest {
  protected:
   struct Tag {};
   class Element : public SpdyIntrusiveLink<Element, Tag> {};

package/third_party/quiche/quiche/spdy/core/spdy_no_op_visitor.h

@@ -46,15 +46,17 @@ class QUICHE_EXPORT_PRIVATE SpdyNoOpVisitor
   void OnSettingsAck() override {}
   void OnGoAway(SpdyStreamId /*last_accepted_stream_id*/,
                 SpdyErrorCode /*error_code*/) override {}
-  void OnHeaders(SpdyStreamId /*stream_id*/, bool /*has_priority*/,
-                 int /*weight*/, SpdyStreamId /*parent_stream_id*/,
-                 bool /*exclusive*/, bool /*fin*/, bool /*end*/) override {}
+  void OnHeaders(SpdyStreamId /*stream_id*/, size_t /*payload_length*/,
+                 bool /*has_priority*/, int /*weight*/,
+                 SpdyStreamId /*parent_stream_id*/, bool /*exclusive*/,
+                 bool /*fin*/, bool /*end*/) override {}
   void OnWindowUpdate(SpdyStreamId /*stream_id*/,
                       int /*delta_window_size*/) override {}
   void OnPushPromise(SpdyStreamId /*stream_id*/,
                      SpdyStreamId /*promised_stream_id*/,
                      bool /*end*/) override {}
-  void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
+  void OnContinuation(SpdyStreamId /*stream_id*/, size_t /*payload_size*/,
+                      bool /*end*/) override {}
   void OnAltSvc(SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                 /*altsvc_vector*/) override {}

package/third_party/quiche/quiche/spdy/core/spdy_pinnable_buffer_piece_test.cc

@@ -13,7 +13,7 @@ namespace spdy {
 
 namespace test {
 
-class SpdyPinnableBufferPieceTest : public QuicheTest {
+class SpdyPinnableBufferPieceTest : public quiche::test::QuicheTest {
  protected:
   SpdyPrefixedBufferReader Build(const std::string& prefix,
                                  const std::string& suffix) {

package/third_party/quiche/quiche/spdy/core/spdy_prefixed_buffer_reader_test.cc

@@ -15,7 +15,7 @@ namespace test {
 
 using testing::ElementsAreArray;
 
-class SpdyPrefixedBufferReaderTest : public QuicheTest {
+class SpdyPrefixedBufferReaderTest : public quiche::test::QuicheTest {
  protected:
   SpdyPrefixedBufferReader Build(const std::string& prefix,
                                  const std::string& suffix) {

package/third_party/quiche/quiche/spdy/core/spdy_protocol_test.cc

@@ -8,8 +8,8 @@
 #include <limits>
 #include <memory>
 
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/common/platform/api/quiche_test_helpers.h"
 #include "quiche/spdy/core/spdy_bitmasks.h"
 #include "quiche/spdy/test_tools/spdy_test_utils.h"
 

package/third_party/quiche/quiche/spdy/test_tools/mock_spdy_framer_visitor.h

@@ -59,9 +59,9 @@ class QUICHE_NO_EXPORT MockSpdyFramerVisitor
   MOCK_METHOD(bool, OnGoAwayFrameData, (const char* goaway_data, size_t len),
               (override));
   MOCK_METHOD(void, OnHeaders,
-              (SpdyStreamId stream_id, bool has_priority, int weight,
-               SpdyStreamId parent_stream_id, bool exclusive, bool fin,
-               bool end),
+              (SpdyStreamId stream_id, size_t payload_length, bool has_priority,
+               int weight, SpdyStreamId parent_stream_id, bool exclusive,
+               bool fin, bool end),
               (override));
   MOCK_METHOD(void, OnWindowUpdate,
               (SpdyStreamId stream_id, int delta_window_size), (override));
@@ -69,7 +69,8 @@ class QUICHE_NO_EXPORT MockSpdyFramerVisitor
               (SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
                bool end),
               (override));
-  MOCK_METHOD(void, OnContinuation, (SpdyStreamId stream_id, bool end),
+  MOCK_METHOD(void, OnContinuation,
+              (SpdyStreamId stream_id, size_t payload_length, bool end),
               (override));
   MOCK_METHOD(
       void, OnAltSvc,

package/third_party/boringssl/src/util/bot/cmake-win32.zip.sha1

@@ -1 +0,0 @@
-b106d66bcdc8a71ea2cdf5446091327bfdb1bcd7

package/third_party/quiche/quiche/common/platform/api/quiche_mock_log.h

@@ -1,18 +0,0 @@
-// Copyright (c) 2017 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_MOCK_LOG_H_
-#define QUICHE_COMMON_PLATFORM_API_QUICHE_MOCK_LOG_H_
-
-#include "quiche_platform_impl/quiche_mock_log_impl.h"
-
-using QuicheMockLog = QuicheMockLogImpl;
-#define CREATE_QUICHE_MOCK_LOG(log) CREATE_QUICHE_MOCK_LOG_IMPL(log)
-
-#define EXPECT_QUICHE_LOG_CALL(log) EXPECT_QUICHE_LOG_CALL_IMPL(log)
-
-#define EXPECT_QUICHE_LOG_CALL_CONTAINS(log, level, content) \
-  EXPECT_QUICHE_LOG_CALL_CONTAINS_IMPL(log, level, content)
-
-#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_MOCK_LOG_H_

package/third_party/quiche/quiche/common/platform/api/quiche_test_helpers.h

@@ -1,8 +0,0 @@
-#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_
-#define QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_
-
-#include "quiche_platform_impl/quiche_test_helpers_impl.h"
-
-#define EXPECT_QUICHE_BUG EXPECT_QUICHE_BUG_IMPL
-
-#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_TEST_HELPERS_H_

package/third_party/quiche/quiche/quic/platform/api/quic_mock_log.h

@@ -1,19 +0,0 @@
-// Copyright (c) 2017 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_MOCK_LOG_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MOCK_LOG_H_
-
-#include "quiche/common/platform/api/quiche_mock_log.h"
-
-using QuicMockLog = QuicheMockLogImpl;
-
-#define CREATE_QUIC_MOCK_LOG(log) CREATE_QUICHE_MOCK_LOG(log)
-
-#define EXPECT_QUIC_LOG_CALL(log) EXPECT_QUICHE_LOG_CALL(log)
-
-#define EXPECT_QUIC_LOG_CALL_CONTAINS(log, level, content) \
-  EXPECT_QUICHE_LOG_CALL_CONTAINS(log, level, content)
-
-#endif  // QUICHE_QUIC_PLATFORM_API_QUIC_MOCK_LOG_H_

package/third_party/quiche/quiche/quic/tools/quic_transport_simple_server_dispatcher.cc

@@ -1,51 +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.
-
-#include "quiche/quic/tools/quic_transport_simple_server_dispatcher.h"
-
-#include <memory>
-
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/quic_connection.h"
-#include "quiche/quic/core/quic_dispatcher.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/tools/quic_transport_simple_server_session.h"
-
-namespace quic {
-
-QuicTransportSimpleServerDispatcher::QuicTransportSimpleServerDispatcher(
-    const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
-    QuicVersionManager* version_manager,
-    std::unique_ptr<QuicConnectionHelperInterface> helper,
-    std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
-    std::unique_ptr<QuicAlarmFactory> alarm_factory,
-    uint8_t expected_server_connection_id_length,
-    std::vector<url::Origin> accepted_origins)
-    : QuicDispatcher(config, crypto_config, version_manager, std::move(helper),
-                     std::move(session_helper), std::move(alarm_factory),
-                     expected_server_connection_id_length),
-      accepted_origins_(accepted_origins) {}
-
-std::unique_ptr<QuicSession>
-QuicTransportSimpleServerDispatcher::CreateQuicSession(
-    QuicConnectionId server_connection_id,
-    const QuicSocketAddress& self_address,
-    const QuicSocketAddress& peer_address, absl::string_view /*alpn*/,
-    const ParsedQuicVersion& version,
-    const ParsedClientHello& /*parsed_chlo*/) {
-  auto connection = std::make_unique<QuicConnection>(
-      server_connection_id, self_address, peer_address, helper(),
-      alarm_factory(), writer(),
-      /*owns_writer=*/false, Perspective::IS_SERVER,
-      ParsedQuicVersionVector{version});
-  auto session = std::make_unique<QuicTransportSimpleServerSession>(
-      connection.release(), /*owns_connection=*/true, this, config(),
-      GetSupportedVersions(), crypto_config(), compressed_certs_cache(),
-      accepted_origins_);
-  session->Initialize();
-  return session;
-}
-
-}  // namespace quic

package/third_party/quiche/quiche/quic/tools/quic_transport_simple_server_dispatcher.h

@@ -1,41 +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_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_DISPATCHER_H_
-#define QUICHE_QUIC_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_DISPATCHER_H_
-
-#include "absl/strings/string_view.h"
-#include "url/origin.h"
-#include "quiche/quic/core/quic_dispatcher.h"
-#include "quiche/quic/tools/quic_transport_simple_server_session.h"
-
-namespace quic {
-
-// Dispatcher that creates a QuicTransportSimpleServerSession for every incoming
-// connection.
-class QuicTransportSimpleServerDispatcher : public QuicDispatcher {
- public:
-  QuicTransportSimpleServerDispatcher(
-      const QuicConfig* config, const QuicCryptoServerConfig* crypto_config,
-      QuicVersionManager* version_manager,
-      std::unique_ptr<QuicConnectionHelperInterface> helper,
-      std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
-      std::unique_ptr<QuicAlarmFactory> alarm_factory,
-      uint8_t expected_server_connection_id_length,
-      std::vector<url::Origin> accepted_origins);
-
- protected:
-  std::unique_ptr<QuicSession> CreateQuicSession(
-      QuicConnectionId server_connection_id,
-      const QuicSocketAddress& self_address,
-      const QuicSocketAddress& peer_address, absl::string_view alpn,
-      const ParsedQuicVersion& version,
-      const ParsedClientHello& parsed_chlo) override;
-
-  std::vector<url::Origin> accepted_origins_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_DISPATCHER_H_

package/third_party/quiche/quiche/quic/tools/quic_transport_simple_server_session.cc

@@ -1,168 +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.
-
-#include "quiche/quic/tools/quic_transport_simple_server_session.h"
-
-#include <memory>
-
-#include "url/gurl.h"
-#include "url/origin.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/platform/api/quic_flags.h"
-#include "quiche/quic/platform/api/quic_logging.h"
-#include "quiche/quic/quic_transport/quic_transport_protocol.h"
-#include "quiche/quic/quic_transport/quic_transport_stream.h"
-#include "quiche/quic/tools/web_transport_test_visitors.h"
-#include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/common/quiche_buffer_allocator.h"
-
-namespace quic {
-
-QuicTransportSimpleServerSession::QuicTransportSimpleServerSession(
-    QuicConnection* connection, bool owns_connection, Visitor* owner,
-    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
-    const QuicCryptoServerConfig* crypto_config,
-    QuicCompressedCertsCache* compressed_certs_cache,
-    std::vector<url::Origin> accepted_origins)
-    : QuicTransportServerSession(connection, owner, config, supported_versions,
-                                 crypto_config, compressed_certs_cache, this),
-      owns_connection_(owns_connection),
-      mode_(DISCARD),
-      accepted_origins_(accepted_origins) {}
-
-QuicTransportSimpleServerSession::~QuicTransportSimpleServerSession() {
-  if (owns_connection_) {
-    DeleteConnection();
-  }
-}
-
-void QuicTransportSimpleServerSession::OnIncomingDataStream(
-    QuicTransportStream* stream) {
-  switch (mode_) {
-    case DISCARD:
-      stream->SetVisitor(std::make_unique<WebTransportDiscardVisitor>(stream));
-      break;
-
-    case ECHO:
-      switch (stream->type()) {
-        case BIDIRECTIONAL:
-          QUIC_DVLOG(1) << "Opening bidirectional echo stream " << stream->id();
-          stream->SetVisitor(
-              std::make_unique<WebTransportBidirectionalEchoVisitor>(stream));
-          break;
-        case READ_UNIDIRECTIONAL:
-          QUIC_DVLOG(1)
-              << "Started receiving data on unidirectional echo stream "
-              << stream->id();
-          stream->SetVisitor(
-              std::make_unique<WebTransportUnidirectionalEchoReadVisitor>(
-                  stream,
-                  [this](const std::string& s) { this->EchoStreamBack(s); }));
-          break;
-        default:
-          QUIC_NOTREACHED();
-          break;
-      }
-      break;
-
-    case OUTGOING_BIDIRECTIONAL:
-      stream->SetVisitor(std::make_unique<WebTransportDiscardVisitor>(stream));
-      ++pending_outgoing_bidirectional_streams_;
-      MaybeCreateOutgoingBidirectionalStream();
-      break;
-  }
-}
-
-void QuicTransportSimpleServerSession::OnCanCreateNewOutgoingStream(
-    bool unidirectional) {
-  if (mode_ == ECHO && unidirectional) {
-    MaybeEchoStreamsBack();
-  } else if (mode_ == OUTGOING_BIDIRECTIONAL && !unidirectional) {
-    MaybeCreateOutgoingBidirectionalStream();
-  }
-}
-
-bool QuicTransportSimpleServerSession::CheckOrigin(url::Origin origin) {
-  if (accepted_origins_.empty()) {
-    return true;
-  }
-
-  for (const url::Origin& accepted_origin : accepted_origins_) {
-    if (origin.IsSameOriginWith(accepted_origin)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool QuicTransportSimpleServerSession::ProcessPath(const GURL& url) {
-  if (url.path() == "/discard") {
-    mode_ = DISCARD;
-    return true;
-  }
-  if (url.path() == "/echo") {
-    mode_ = ECHO;
-    return true;
-  }
-  if (url.path() == "/receive-bidirectional") {
-    mode_ = OUTGOING_BIDIRECTIONAL;
-    return true;
-  }
-
-  QUIC_DLOG(WARNING) << "Unknown path requested: " << url.path();
-  return false;
-}
-
-void QuicTransportSimpleServerSession::OnMessageReceived(
-    absl::string_view message) {
-  if (mode_ != ECHO) {
-    return;
-  }
-  datagram_queue()->SendOrQueueDatagram(
-      quiche::QuicheMemSlice(quiche::QuicheBuffer::Copy(
-          connection()->helper()->GetStreamSendBufferAllocator(), message)));
-}
-
-void QuicTransportSimpleServerSession::MaybeEchoStreamsBack() {
-  while (!streams_to_echo_back_.empty() &&
-         CanOpenNextOutgoingUnidirectionalStream()) {
-    // Remove the stream from the queue first, in order to avoid accidentally
-    // entering an infinite loop in case any of the following code calls
-    // OnCanCreateNewOutgoingStream().
-    std::string data = std::move(streams_to_echo_back_.front());
-    streams_to_echo_back_.pop_front();
-
-    auto stream_owned = std::make_unique<QuicTransportStream>(
-        GetNextOutgoingUnidirectionalStreamId(), this, this);
-    QuicTransportStream* stream = stream_owned.get();
-    ActivateStream(std::move(stream_owned));
-    QUIC_DVLOG(1) << "Opened echo response stream " << stream->id();
-
-    stream->SetVisitor(
-        std::make_unique<WebTransportUnidirectionalEchoWriteVisitor>(stream,
-                                                                     data));
-    stream->visitor()->OnCanWrite();
-  }
-}
-
-void QuicTransportSimpleServerSession::
-    MaybeCreateOutgoingBidirectionalStream() {
-  while (pending_outgoing_bidirectional_streams_ > 0 &&
-         CanOpenNextOutgoingBidirectionalStream()) {
-    auto stream_owned = std::make_unique<QuicTransportStream>(
-        GetNextOutgoingBidirectionalStreamId(), this, this);
-    QuicTransportStream* stream = stream_owned.get();
-    ActivateStream(std::move(stream_owned));
-    QUIC_DVLOG(1) << "Opened outgoing bidirectional stream " << stream->id();
-    stream->SetVisitor(
-        std::make_unique<WebTransportBidirectionalEchoVisitor>(stream));
-    if (!stream->Write("hello")) {
-      QUIC_DVLOG(1) << "Write failed.";
-    }
-    --pending_outgoing_bidirectional_streams_;
-  }
-}
-
-}  // namespace quic

package/third_party/quiche/quiche/quic/tools/quic_transport_simple_server_session.h

@@ -1,78 +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_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_SESSION_H_
-#define QUICHE_QUIC_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_SESSION_H_
-
-#include <memory>
-#include <vector>
-
-#include "url/origin.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/platform/api/quic_flags.h"
-#include "quiche/quic/quic_transport/quic_transport_server_session.h"
-#include "quiche/quic/quic_transport/quic_transport_stream.h"
-
-namespace quic {
-
-// QuicTransport simple server is a non-production server that can be used for
-// testing QuicTransport.  It has two modes that can be changed using the
-// command line flags, "echo" and "discard".
-class QuicTransportSimpleServerSession
-    : public QuicTransportServerSession,
-      QuicTransportServerSession::ServerVisitor {
- public:
-  enum Mode {
-    // In DISCARD mode, any data on incoming streams is discarded and no
-    // outgoing streams are initiated.
-    DISCARD,
-    // In ECHO mode, any data sent on a bidirectional stream is echoed back.
-    // Any data sent on a unidirectional stream is buffered, and echoed back on
-    // a server-initiated unidirectional stream that is sent as soon as a FIN is
-    // received on the incoming stream.
-    ECHO,
-    // In OUTGOING_BIDIRECTIONAL mode, a server-originated bidirectional stream
-    // is created on receipt of a unidirectional stream. The contents of the
-    // unidirectional stream are disregarded. The bidirectional stream initially
-    // sends "hello", then any received data is echoed back.
-    // TODO(ricea): Maybe this should be replaced by a more general mechanism
-    // where commands on the unidirectional stream trigger different behaviour?
-    OUTGOING_BIDIRECTIONAL,
-  };
-
-  QuicTransportSimpleServerSession(
-      QuicConnection* connection, bool owns_connection, Visitor* owner,
-      const QuicConfig& config,
-      const ParsedQuicVersionVector& supported_versions,
-      const QuicCryptoServerConfig* crypto_config,
-      QuicCompressedCertsCache* compressed_certs_cache,
-      std::vector<url::Origin> accepted_origins);
-  ~QuicTransportSimpleServerSession();
-
-  void OnIncomingDataStream(QuicTransportStream* stream) override;
-  void OnCanCreateNewOutgoingStream(bool unidirectional) override;
-  bool CheckOrigin(url::Origin origin) override;
-  bool ProcessPath(const GURL& url) override;
-  void OnMessageReceived(absl::string_view message) override;
-
-  void EchoStreamBack(const std::string& data) {
-    streams_to_echo_back_.push_back(data);
-    MaybeEchoStreamsBack();
-  }
-
- private:
-  void MaybeEchoStreamsBack();
-  void MaybeCreateOutgoingBidirectionalStream();
-
-  const bool owns_connection_;
-  size_t pending_outgoing_bidirectional_streams_ = 0u;
-  Mode mode_;
-  std::vector<url::Origin> accepted_origins_;
-  quiche::QuicheCircularDeque<std::string> streams_to_echo_back_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_TOOLS_QUIC_TRANSPORT_SIMPLE_SERVER_SESSION_H_