Add tests for WebRtcMessageHandler

Tests the public interfaces of WebRtcMessageHandler and its interactions
with SharingServiceHost.

Bug: 1021987
Change-Id: I6826dbf5ac6306ba2364517e19a06c142d9c13b1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2038695Reviewed-by: Richard Knoll <knollr@chromium.org>
Commit-Queue: Himanshu Jaju <himanshujaju@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738554}

chrome/browser/sharing/webrtc/sharing_service_host.h

@@ -60,13 +60,13 @@ class SharingServiceHost : public SharingMessageSender::SendMessageDelegate {
                              chrome_browser_sharing::SharingMessage message,
                              SendMessageCallback callback) override;
 
-  void OnOfferReceived(
+  virtual void OnOfferReceived(
       const std::string& device_guid,
       const chrome_browser_sharing::FCMChannelConfiguration& fcm_configuration,
       const std::string& offer,
       base::OnceCallback<void(const std::string&)> callback);
 
-  void OnIceCandidatesReceived(
+  virtual void OnIceCandidatesReceived(
       const std::string& device_guid,
       const chrome_browser_sharing::FCMChannelConfiguration& fcm_configuration,
       std::vector<sharing::mojom::IceCandidatePtr> ice_candidates);

chrome/browser/sharing/webrtc/webrtc_message_handler_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 "chrome/browser/sharing/webrtc/webrtc_message_handler.h"
+
+#include "base/test/mock_callback.h"
+#include "chrome/browser/sharing/webrtc/sharing_service_host.h"
+#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
+#include "services/network/test/test_url_loader_factory.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockSharingServiceHost : public SharingServiceHost {
+ public:
+  MockSharingServiceHost()
+      : SharingServiceHost(
+            /*message_sender=*/nullptr,
+            /*gcm_driver=*/nullptr,
+            /*sync_prefs=*/nullptr,
+            base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
+                &test_url_loader_factory_)) {}
+  MockSharingServiceHost(const MockSharingServiceHost&) = delete;
+  MockSharingServiceHost& operator=(const MockSharingServiceHost&) = delete;
+  ~MockSharingServiceHost() override = default;
+
+  MOCK_METHOD4(OnOfferReceived,
+               void(const std::string& device_guid,
+                    const chrome_browser_sharing::FCMChannelConfiguration&
+                        fcm_configuration,
+                    const std::string& offer,
+                    base::OnceCallback<void(const std::string&)> callback));
+
+  MOCK_METHOD3(
+      OnIceCandidatesReceived,
+      void(const std::string& device_guid,
+           const chrome_browser_sharing::FCMChannelConfiguration&
+               fcm_configuration,
+           std::vector<sharing::mojom::IceCandidatePtr> ice_candidates));
+
+ private:
+  network::TestURLLoaderFactory test_url_loader_factory_;
+};
+
+MATCHER_P(ProtoEquals, message, "") {
+  if (!arg)
+    return false;
+
+  std::string expected_serialized, actual_serialized;
+  message.SerializeToString(&expected_serialized);
+  arg->SerializeToString(&actual_serialized);
+  return expected_serialized == actual_serialized;
+}
+
+}  // namespace
+
+class WebRtcMessageHandlerTest : public testing::Test {
+ public:
+  WebRtcMessageHandlerTest()
+      : webrtc_message_handler_(&mock_sharing_service_host_) {}
+  WebRtcMessageHandlerTest(const WebRtcMessageHandlerTest&) = delete;
+  WebRtcMessageHandlerTest& operator=(const WebRtcMessageHandlerTest&) = delete;
+  ~WebRtcMessageHandlerTest() override = default;
+
+ protected:
+  testing::NiceMock<MockSharingServiceHost> mock_sharing_service_host_;
+  WebRtcMessageHandler webrtc_message_handler_;
+};
+
+TEST_F(WebRtcMessageHandlerTest, IceCandidateMessageTest) {
+  std::vector<sharing::mojom::IceCandidatePtr> expected_ice_candidates;
+  expected_ice_candidates.push_back(
+      sharing::mojom::IceCandidate::New("candidate0", "mid0", 0));
+  expected_ice_candidates.push_back(
+      sharing::mojom::IceCandidate::New("candidate1", "mid1", 1));
+
+  chrome_browser_sharing::SharingMessage message;
+  message.mutable_fcm_channel_configuration();
+  for (const auto& ice_candidate : expected_ice_candidates) {
+    chrome_browser_sharing::PeerConnectionIceCandidate* peer_candidate =
+        message.mutable_peer_connection_ice_candidates_message()
+            ->add_ice_candidates();
+    peer_candidate->set_candidate(ice_candidate->candidate);
+    peer_candidate->set_sdp_mid(ice_candidate->sdp_mid);
+    peer_candidate->set_sdp_mline_index(ice_candidate->sdp_mline_index);
+  }
+
+  base::MockCallback<SharingMessageHandler::DoneCallback> mock_done_callback_;
+  EXPECT_CALL(mock_sharing_service_host_,
+              OnIceCandidatesReceived(testing::_, testing::_, testing::_))
+      .WillOnce(
+          [&](const std::string& device_guid,
+              const chrome_browser_sharing::FCMChannelConfiguration&
+                  fcm_configuration,
+              std::vector<sharing::mojom::IceCandidatePtr> ice_candidates) {
+            ASSERT_EQ(expected_ice_candidates, ice_candidates);
+          });
+  EXPECT_CALL(mock_done_callback_, Run(testing::Eq(nullptr)));
+
+  webrtc_message_handler_.OnMessage(std::move(message),
+                                    mock_done_callback_.Get());
+}
+
+TEST_F(WebRtcMessageHandlerTest, OfferMessageTest) {
+  const std::string answer = "answer";
+  chrome_browser_sharing::ResponseMessage expected_answer;
+  expected_answer.mutable_peer_connection_answer_message_response()->set_sdp(
+      answer);
+
+  const std::string offer = "offer";
+  chrome_browser_sharing::SharingMessage message;
+  message.mutable_fcm_channel_configuration();
+  message.mutable_peer_connection_offer_message()->set_sdp(offer);
+
+  base::MockCallback<SharingMessageHandler::DoneCallback> mock_done_callback_;
+  EXPECT_CALL(
+      mock_sharing_service_host_,
+      OnOfferReceived(testing::_, testing::_, testing::Eq(offer), testing::_))
+      .WillOnce([&](const std::string& device_guid,
+                    const chrome_browser_sharing::FCMChannelConfiguration&
+                        fcm_configuration,
+                    const std::string& offer,
+                    base::OnceCallback<void(const std::string&)> callback) {
+        std::move(callback).Run(answer);
+      });
+  EXPECT_CALL(mock_done_callback_, Run(ProtoEquals(expected_answer)));
+
+  webrtc_message_handler_.OnMessage(std::move(message),
+                                    mock_done_callback_.Get());
+}

chrome/test/BUILD.gn

@@ -4274,6 +4274,7 @@ test("unit_tests") {
       "../browser/sharing/sms/sms_fetch_request_handler_unittest.cc",
       "../browser/sharing/sms/sms_remote_fetcher_unittest.cc",
       "../browser/sharing/webrtc/ice_config_fetcher_unittest.cc",
+      "../browser/sharing/webrtc/webrtc_message_handler_unittest.cc",
       "../browser/ui/autofill/payments/local_card_migration_bubble_controller_impl_unittest.cc",
       "../browser/ui/autofill/payments/save_card_bubble_controller_impl_unittest.cc",
       "../browser/ui/bluetooth/bluetooth_chooser_controller_unittest.cc",