[cast_streaming] Add unit tests for the Cast Streaming Receiver

* Add basic start/stop and send/receive tests for the Cast Streaming
  component
* Merge 2 core targets in cast_streaming into one.

Bug: 1110490

Change-Id: Ia949ca73c69badeaaad60adb024b3f4bcb44f40a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2553143Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Sergey Ulanov <sergeyu@chromium.org>
Commit-Queue: Fabrice de Gans-Riberi <fdegans@chromium.org>
Cr-Commit-Position: refs/heads/master@{#837890}

fuchsia/cast_streaming/BUILD.gn

@@ -6,30 +6,22 @@ assert(is_fuchsia)
 
 import("//testing/test.gni")
 
-source_set("cast_streaming_config_conversions") {
+source_set("cast_streaming_core") {
   deps = [
     "//base",
     "//media",
-    "//third_party/openscreen/src/cast/streaming:common",
-  ]
-  visibility = [ ":*" ]
-  sources = [
-    "config_conversions.cc",
-    "config_conversions.h",
   ]
-}
-
-source_set("cast_streaming_message_port") {
-  deps = [
-    "//base",
+  public_deps = [
+    "//components/cast/message_port",
     "//third_party/openscreen/src/cast/common:public",
     "//third_party/openscreen/src/cast/streaming:common",
   ]
   visibility = [ ":*" ]
-  public_deps = [ "//components/cast/message_port" ]
   sources = [
     "cast_message_port_impl.cc",
     "cast_message_port_impl.h",
+    "config_conversions.cc",
+    "config_conversions.h",
     "message_serialization.cc",
     "message_serialization.h",
   ]
@@ -37,8 +29,7 @@ source_set("cast_streaming_message_port") {
 
 source_set("cast_streaming_session") {
   deps = [
-    ":cast_streaming_config_conversions",
-    ":cast_streaming_message_port",
+    ":cast_streaming_core",
     "//base",
     "//components/openscreen_platform",
     "//media",
@@ -80,8 +71,7 @@ source_set("cast_streaming") {
 source_set("cast_streaming_test_sender") {
   testonly = true
   deps = [
-    ":cast_streaming_config_conversions",
-    ":cast_streaming_message_port",
+    ":cast_streaming_core",
     "//base",
     "//components/openscreen_platform",
     "//media",
@@ -124,16 +114,22 @@ source_set("cast_streaming_test_receiver") {
 }
 
 test("cast_streaming_unittests") {
-  sources = [ "cast_message_port_impl_unittest.cc" ]
   deps = [
-    ":cast_streaming_message_port",
-    "//base/test:run_all_unittests",
+    ":cast_streaming_core",
+    ":cast_streaming_session",
+    ":cast_streaming_test_receiver",
+    ":cast_streaming_test_sender",
     "//base/test:test_support",
     "//components/cast/message_port:test_message_port_receiver",
-    "//components/openscreen_platform",
-    "//components/openscreen_platform:openscreen_platform_network_service",
+    "//components/openscreen_platform:openscreen_platform_net",
     "//media",
+    "//mojo/core/embedder",
     "//testing/gtest",
     "//third_party/openscreen/src/platform:api",
   ]
+  sources = [
+    "cast_message_port_impl_unittest.cc",
+    "cast_streaming_session_unittest.cc",
+    "test/run_all_unittests.cc",
+  ]
 }

fuchsia/cast_streaming/DEPS

@@ -3,6 +3,7 @@ include_rules = [
   "+components/openscreen_platform",
   "+media/base",
   "+media/mojo",
+  "+mojo/core",
   "+mojo/public",
   "+third_party/openscreen/src",
 ]

fuchsia/cast_streaming/cast_streaming_session_unittest.cc

+// Copyright 2020 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 "fuchsia/cast_streaming/public/cast_streaming_session.h"
+
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "fuchsia/cast_streaming/test/cast_streaming_test_receiver.h"
+#include "fuchsia/cast_streaming/test/cast_streaming_test_sender.h"
+#include "media/base/media_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cast_streaming {
+
+namespace {
+
+media::AudioDecoderConfig GetDefaultAudioConfig() {
+  return media::AudioDecoderConfig(
+      media::AudioCodec::kCodecOpus, media::SampleFormat::kSampleFormatF32,
+      media::ChannelLayout::CHANNEL_LAYOUT_STEREO,
+      48000 /* samples_per_second */, media::EmptyExtraData(),
+      media::EncryptionScheme::kUnencrypted);
+}
+
+media::VideoDecoderConfig GetDefaultVideoConfig() {
+  const gfx::Size kVideoSize = {1920, 1080};
+  const gfx::Rect kVideoRect(kVideoSize);
+
+  return media::VideoDecoderConfig(
+      media::VideoCodec::kCodecVP8, media::VideoCodecProfile::VP8PROFILE_MIN,
+      media::VideoDecoderConfig::AlphaMode::kIsOpaque, media::VideoColorSpace(),
+      media::VideoTransformation(), kVideoSize, kVideoRect, kVideoSize,
+      media::EmptyExtraData(), media::EncryptionScheme::kUnencrypted);
+}
+
+// Compare |decoder_buffer| to |data_buffer| metadata and data. Returns true if
+// these are equivalent.
+void VerifyAreEquals(const scoped_refptr<media::DecoderBuffer>& decoder_buffer,
+                     const scoped_refptr<media::DataBuffer>& data_buffer) {
+  if (decoder_buffer->end_of_stream() || data_buffer->end_of_stream()) {
+    EXPECT_EQ(decoder_buffer->end_of_stream(), data_buffer->end_of_stream());
+    return;
+  }
+
+  ASSERT_EQ(decoder_buffer->timestamp(), data_buffer->timestamp());
+
+  // Signed to unsigned conversion.
+  size_t data_buffer_size = data_buffer->data_size();
+  ASSERT_EQ(decoder_buffer->data_size(), data_buffer_size);
+
+  ASSERT_EQ(
+      memcmp(decoder_buffer->data(), data_buffer->data(), data_buffer_size), 0);
+}
+
+}  // namespace
+
+class CastStreamingSessionTest : public testing::Test {
+ public:
+  CastStreamingSessionTest() = default;
+  ~CastStreamingSessionTest() override = default;
+
+  CastStreamingSessionTest(const CastStreamingSessionTest&) = delete;
+  CastStreamingSessionTest& operator=(const CastStreamingSessionTest&) = delete;
+
+ protected:
+  void StartSession() {
+    std::unique_ptr<cast_api_bindings::MessagePort> sender_message_port;
+    std::unique_ptr<cast_api_bindings::MessagePort> receiver_message_port;
+    cast_api_bindings::MessagePort::CreatePair(&sender_message_port,
+                                               &receiver_message_port);
+
+    receiver_.Start(std::move(receiver_message_port));
+    EXPECT_TRUE(sender_.Start(
+        std::move(sender_message_port), net::IPAddress::IPv6Localhost(),
+        GetDefaultAudioConfig(), GetDefaultVideoConfig()));
+    sender_.RunUntilStarted();
+    receiver_.RunUntilStarted();
+  }
+
+  void StopReceiverSession() {
+    receiver_.Stop();
+    receiver_.RunUntilStopped();
+    sender_.RunUntilStopped();
+  }
+
+  base::test::TaskEnvironment task_environment_{
+      base::test::TaskEnvironment::MainThreadType::IO};
+
+  CastStreamingTestSender sender_;
+  CastStreamingTestReceiver receiver_;
+};
+
+// Basic sanity check for the test fixture.
+TEST_F(CastStreamingSessionTest, DoNothing) {}
+
+// Tests session lifespan is correct.
+TEST_F(CastStreamingSessionTest, StartAndStopSession) {
+  StartSession();
+
+  // Sender-initiated closure.
+  sender_.Stop();
+  sender_.RunUntilStopped();
+  receiver_.RunUntilStopped();
+
+  // Start a new session.
+  StartSession();
+
+  // Renderer-initiated closure.
+  StopReceiverSession();
+}
+
+// Tests buffers sent from the sender are properly received by the receiver.
+TEST_F(CastStreamingSessionTest, SendAndReceiveBuffers) {
+  StartSession();
+
+  const uint8_t kAudioData[] = {42};
+  scoped_refptr<media::DataBuffer> audio_buffer =
+      media::DataBuffer::CopyFrom(kAudioData, sizeof(kAudioData));
+  audio_buffer->set_timestamp(base::TimeDelta::FromSeconds(0));
+
+  const uint8_t kVideoData[] = {42, 84};
+  scoped_refptr<media::DataBuffer> video_buffer =
+      media::DataBuffer::CopyFrom(kVideoData, sizeof(kVideoData));
+  video_buffer->set_timestamp(base::TimeDelta::FromSeconds(0));
+
+  sender_.SendAudioBuffer(audio_buffer);
+  sender_.SendVideoBuffer(video_buffer, true);
+
+  ASSERT_TRUE(receiver_.RunUntilAudioFramesCountIsAtLeast(1u));
+  VerifyAreEquals(receiver_.audio_buffers()[0], audio_buffer);
+
+  ASSERT_TRUE(receiver_.RunUntilVideoFramesCountIsAtLeast(1u));
+  VerifyAreEquals(receiver_.video_buffers()[0], video_buffer);
+  EXPECT_TRUE(receiver_.video_buffers()[0]->is_key_frame());
+
+  StopReceiverSession();
+}
+
+}  // namespace cast_streaming

fuchsia/cast_streaming/test/run_all_unittests.cc

+// Copyright 2020 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 "base/bind.h"
+#include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/test_suite.h"
+#include "fuchsia/cast_streaming/public/cast_streaming_session.h"
+#include "mojo/core/embedder/embedder.h"
+
+int main(int argc, char** argv) {
+  base::TestSuite test_suite(argc, argv);
+  mojo::core::Init();
+
+  return base::LaunchUnitTests(
+      argc, argv,
+      base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
+}