C++ unit tests for RTCQuicStream

Bug: 874296
Change-Id: I8c0d22bf4d688accf30ea1fef0109723c319234b
Reviewed-on: https://chromium-review.googlesource.com/c/1278385Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Henrik Boström <hbos@chromium.org>
Commit-Queue: Steve Anton <steveanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600018}

third_party/blink/renderer/modules/BUILD.gn

@@ -194,6 +194,7 @@ jumbo_source_set("modules_testing") {
     "peerconnection/adapters/test/mock_ice_transport_adapter.h",
     "peerconnection/adapters/test/mock_ice_transport_adapter_cross_thread_factory.h",
     "peerconnection/adapters/test/mock_p2p_quic_packet_transport.h",
+    "peerconnection/adapters/test/mock_p2p_quic_stream.h",
     "peerconnection/adapters/test/mock_p2p_quic_transport.h",
     "peerconnection/adapters/test/mock_p2p_quic_transport_factory.h",
     "peerconnection/testing/internals_rtc_certificate.cc",
@@ -309,6 +310,7 @@ jumbo_source_set("unit_tests") {
     "peerconnection/rtc_ice_transport_test.cc",
     "peerconnection/rtc_ice_transport_test.h",
     "peerconnection/rtc_peer_connection_test.cc",
+    "peerconnection/rtc_quic_stream_test.cc",
     "peerconnection/rtc_quic_transport_test.cc",
     "peerconnection/rtc_quic_transport_test.h",
     "picture_in_picture/html_video_element_picture_in_picture_test.cc",

third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h

@@ -38,6 +38,8 @@ class P2PQuicStream {
     virtual void OnRemoteFinish() {}
   };
 
+  virtual ~P2PQuicStream() = default;
+
   // Sends a RST_STREAM frame to the remote side. This closes the P2PQuicStream
   // for reading & writing and it will be deleted by the quic::QuicSession. When
   // the remote side receives the RST_STREAM frame it will close the stream for

third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream.h

+// Copyright 2018 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 THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_TEST_MOCK_P2P_QUIC_STREAM_H_
+#define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_TEST_MOCK_P2P_QUIC_STREAM_H_
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_stream.h"
+
+namespace blink {
+
+class MockP2PQuicStream : public testing::NiceMock<P2PQuicStream> {
+ public:
+  // P2PQuicStream overrides.
+  MOCK_METHOD0(Reset, void());
+  MOCK_METHOD0(Finish, void());
+  MOCK_METHOD1(SetDelegate, void(Delegate*));
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_ADAPTERS_TEST_MOCK_P2P_QUIC_STREAM_H_

third_party/blink/renderer/modules/peerconnection/rtc_quic_stream_event.h

@@ -12,7 +12,7 @@ namespace blink {
 class RTCQuicStream;
 class RTCQuicStreamEventInit;
 
-class RTCQuicStreamEvent final : public Event {
+class MODULES_EXPORT RTCQuicStreamEvent final : public Event {
   DEFINE_WRAPPERTYPEINFO();
 
  public:

third_party/blink/renderer/modules/peerconnection/rtc_quic_stream_test.cc

+// Copyright 2018 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.
+
+// This file tests the RTCQuicStream Blink bindings, QuicStreamProxy and
+// QuicStreamHost by mocking out the underlying P2PQuicTransport.
+// Everything is run on a single thread but with separate TestSimpleTaskRunners
+// for the main thread / worker thread.
+
+#include "third_party/blink/renderer/modules/peerconnection/rtc_quic_stream.h"
+#include "third_party/blink/renderer/modules/peerconnection/adapters/test/mock_p2p_quic_stream.h"
+#include "third_party/blink/renderer/modules/peerconnection/rtc_quic_stream_event.h"
+#include "third_party/blink/renderer/modules/peerconnection/rtc_quic_transport_test.h"
+
+namespace blink {
+namespace {
+
+using testing::_;
+using testing::Invoke;
+using testing::InvokeWithoutArgs;
+using testing::Return;
+using testing::SaveArg;
+
+}  // namespace
+
+class RTCQuicStreamTest : public RTCQuicTransportTest {};
+
+// Test that RTCQuicTransport.createStream causes CreateStream to be called on
+// the underlying transport and a P2PQuicStream::Delegate to be set on the
+// underlying P2PQuicStream.
+TEST_F(RTCQuicStreamTest, RTCQuicTransportCreateStreamCallsUnderlying) {
+  V8TestingScope scope;
+
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>();
+  EXPECT_CALL(*p2p_quic_stream, SetDelegate(_))
+      .WillOnce(Invoke(
+          [](P2PQuicStream::Delegate* delegate) { EXPECT_TRUE(delegate); }));
+
+  auto p2p_quic_transport = std::make_unique<MockP2PQuicTransport>();
+  EXPECT_CALL(*p2p_quic_transport, CreateStream())
+      .WillOnce(Return(p2p_quic_stream.get()));
+
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateConnectedQuicTransport(scope, std::move(p2p_quic_transport));
+  Persistent<RTCQuicStream> quic_stream =
+      quic_transport->createStream(ASSERT_NO_EXCEPTION);
+
+  RunUntilIdle();
+}
+
+// Test that calling OnStream on the P2PQuicTransport delegate causes a
+// quicstream event to fire with a new RTCQuicStream.
+TEST_F(RTCQuicStreamTest, NewRemoteStreamFiresEvent) {
+  V8TestingScope scope;
+
+  P2PQuicTransport::Delegate* transport_delegate = nullptr;
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateConnectedQuicTransport(scope, &transport_delegate);
+
+  Persistent<MockEventListener> quic_stream_listener =
+      CreateMockEventListener();
+  EXPECT_CALL(*quic_stream_listener, handleEvent(_, _))
+      .WillOnce(Invoke([](ExecutionContext*, Event* event) {
+        auto* stream_event = static_cast<RTCQuicStreamEvent*>(event);
+        EXPECT_NE(nullptr, stream_event->stream());
+      }));
+  quic_transport->addEventListener(EventTypeNames::quicstream,
+                                   quic_stream_listener);
+
+  ASSERT_TRUE(transport_delegate);
+
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>();
+  EXPECT_CALL(*p2p_quic_stream, SetDelegate(_))
+      .WillOnce(Invoke(
+          [](P2PQuicStream::Delegate* delegate) { EXPECT_TRUE(delegate); }));
+  transport_delegate->OnStream(p2p_quic_stream.get());
+
+  RunUntilIdle();
+}
+
+// Test that calling reset() calls Reset() on the underlying P2PQuicStream.
+TEST_F(RTCQuicStreamTest, ResetCallsUnderlying) {
+  V8TestingScope scope;
+
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>();
+  EXPECT_CALL(*p2p_quic_stream, Reset()).Times(1);
+
+  auto p2p_quic_transport = std::make_unique<MockP2PQuicTransport>();
+  EXPECT_CALL(*p2p_quic_transport, CreateStream())
+      .WillOnce(Return(p2p_quic_stream.get()));
+
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateConnectedQuicTransport(scope, std::move(p2p_quic_transport));
+  Persistent<RTCQuicStream> stream =
+      quic_transport->createStream(ASSERT_NO_EXCEPTION);
+
+  stream->reset();
+
+  RunUntilIdle();
+}
+
+// Test that calling OnRemoteReset() on the P2PQuicStream delegate fires a
+// statechange event to 'closed'.
+TEST_F(RTCQuicStreamTest, OnRemoteResetFiresStateChangeToClosed) {
+  V8TestingScope scope;
+
+  P2PQuicStream::Delegate* stream_delegate = nullptr;
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>();
+  EXPECT_CALL(*p2p_quic_stream, SetDelegate(_))
+      .WillOnce(SaveArg<0>(&stream_delegate));
+
+  auto p2p_quic_transport = std::make_unique<MockP2PQuicTransport>();
+  EXPECT_CALL(*p2p_quic_transport, CreateStream())
+      .WillOnce(Return(p2p_quic_stream.get()));
+
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateConnectedQuicTransport(scope, std::move(p2p_quic_transport));
+  Persistent<RTCQuicStream> quic_stream =
+      quic_transport->createStream(ASSERT_NO_EXCEPTION);
+
+  Persistent<MockEventListener> state_change_listener =
+      CreateMockEventListener();
+  EXPECT_CALL(*state_change_listener, handleEvent(_, _))
+      .WillOnce(InvokeWithoutArgs(
+          [quic_stream]() { EXPECT_EQ("closed", quic_stream->state()); }));
+  quic_stream->addEventListener(EventTypeNames::statechange,
+                                state_change_listener);
+
+  RunUntilIdle();
+
+  ASSERT_TRUE(stream_delegate);
+  stream_delegate->OnRemoteReset();
+
+  RunUntilIdle();
+}
+
+// Test that a pending OnRemoteReset() is ignored if reset() is called first.
+TEST_F(RTCQuicStreamTest, PendingOnRemoteResetIgnoredAfterReset) {
+  V8TestingScope scope;
+
+  P2PQuicStream::Delegate* stream_delegate = nullptr;
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>();
+  EXPECT_CALL(*p2p_quic_stream, SetDelegate(_))
+      .WillOnce(SaveArg<0>(&stream_delegate));
+
+  auto p2p_quic_transport = std::make_unique<MockP2PQuicTransport>();
+  EXPECT_CALL(*p2p_quic_transport, CreateStream())
+      .WillOnce(Return(p2p_quic_stream.get()));
+
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateConnectedQuicTransport(scope, std::move(p2p_quic_transport));
+  Persistent<RTCQuicStream> quic_stream =
+      quic_transport->createStream(ASSERT_NO_EXCEPTION);
+
+  // Expect no statechange event since reset() will already transition the state
+  // to 'closed'.
+  Persistent<MockEventListener> state_change_listener =
+      CreateMockEventListener();
+  EXPECT_CALL(*state_change_listener, handleEvent(_, _)).Times(0);
+  quic_stream->addEventListener(EventTypeNames::statechange,
+                                state_change_listener);
+
+  RunUntilIdle();
+
+  ASSERT_TRUE(stream_delegate);
+  stream_delegate->OnRemoteReset();
+  quic_stream->reset();
+  EXPECT_EQ("closed", quic_stream->state());
+
+  RunUntilIdle();
+
+  EXPECT_EQ("closed", quic_stream->state());
+}
+
+}  // namespace blink

third_party/blink/renderer/modules/peerconnection/rtc_quic_transport_test.cc

@@ -73,6 +73,36 @@ RTCQuicTransport* RTCQuicTransportTest::CreateQuicTransport(
                                   std::move(mock_factory));
 }
 
+RTCQuicTransport* RTCQuicTransportTest::CreateConnectedQuicTransport(
+    V8TestingScope& scope,
+    P2PQuicTransport::Delegate** delegate_out) {
+  return CreateConnectedQuicTransport(
+      scope, std::make_unique<MockP2PQuicTransport>(), delegate_out);
+}
+
+RTCQuicTransport* RTCQuicTransportTest::CreateConnectedQuicTransport(
+    V8TestingScope& scope,
+    std::unique_ptr<MockP2PQuicTransport> mock_transport,
+    P2PQuicTransport::Delegate** delegate_out) {
+  Persistent<RTCIceTransport> ice_transport = CreateIceTransport(scope);
+  ice_transport->start(CreateRemoteRTCIceParameters1(), "controlling",
+                       ASSERT_NO_EXCEPTION);
+  P2PQuicTransport::Delegate* delegate = nullptr;
+  Persistent<RTCQuicTransport> quic_transport =
+      CreateQuicTransport(scope, ice_transport, GenerateLocalRTCCertificates(),
+                          std::move(mock_transport), &delegate);
+  quic_transport->start(CreateRemoteRTCQuicParameters1(), ASSERT_NO_EXCEPTION);
+  RunUntilIdle();
+  DCHECK(delegate);
+  delegate->OnConnected();
+  RunUntilIdle();
+  DCHECK_EQ("connected", quic_transport->state());
+  if (delegate_out) {
+    *delegate_out = delegate;
+  }
+  return quic_transport;
+}
+
 // Test that calling start() creates a P2PQuicTransport with the correct
 // P2PQuicTransportConfig. The config should have:
 // 1. The P2PQuicPacketTransport returned by the MockIceTransportAdapter.

third_party/blink/renderer/modules/peerconnection/rtc_quic_transport_test.h

@@ -33,6 +33,16 @@ class RTCQuicTransportTest : public RTCIceTransportTest {
       RTCIceTransport* ice_transport,
       const HeapVector<Member<RTCCertificate>>& certificates,
       std::unique_ptr<MockP2PQuicTransportFactory> mock_factory);
+
+  // Construct a new RTCQuicTransport and RTCIceTransport and call start() on
+  // both objects.
+  RTCQuicTransport* CreateConnectedQuicTransport(
+      V8TestingScope& scope,
+      P2PQuicTransport::Delegate** delegate_out = nullptr);
+  RTCQuicTransport* CreateConnectedQuicTransport(
+      V8TestingScope& scope,
+      std::unique_ptr<MockP2PQuicTransport> mock_transport,
+      P2PQuicTransport::Delegate** delegate_out = nullptr);
 };
 
 }  // namespace blink