OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h" |
| 6 |
| 7 #include <memory> |
| 8 |
| 9 #include "base/memory/ref_counted.h" |
| 10 #include "base/message_loop/message_loop.h" |
| 11 #include "base/run_loop.h" |
| 12 #include "base/single_thread_task_runner.h" |
| 13 #include "content/child/child_process.h" |
| 14 #include "content/renderer/media/media_stream_audio_source.h" |
| 15 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.
h" |
| 16 #include "testing/gtest/include/gtest/gtest.h" |
| 17 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h" |
| 18 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" |
| 19 #include "third_party/WebKit/public/platform/WebString.h" |
| 20 #include "third_party/WebKit/public/web/WebHeap.h" |
| 21 |
| 22 namespace content { |
| 23 |
| 24 class WebRtcMediaStreamTrackAdapterMapTest : public ::testing::Test { |
| 25 public: |
| 26 void SetUp() override { |
| 27 dependency_factory_.reset(new MockPeerConnectionDependencyFactory()); |
| 28 main_thread_ = base::ThreadTaskRunnerHandle::Get(); |
| 29 map_ = new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(), |
| 30 main_thread_); |
| 31 } |
| 32 |
| 33 void TearDown() override { blink::WebHeap::CollectAllGarbageForTesting(); } |
| 34 |
| 35 blink::WebMediaStreamTrack CreateLocalTrack(const std::string& id) { |
| 36 blink::WebMediaStreamSource web_source; |
| 37 web_source.Initialize( |
| 38 blink::WebString::FromUTF8(id), blink::WebMediaStreamSource::kTypeAudio, |
| 39 blink::WebString::FromUTF8("local_audio_track"), false); |
| 40 MediaStreamAudioSource* audio_source = new MediaStreamAudioSource(true); |
| 41 // Takes ownership of |audio_source|. |
| 42 web_source.SetExtraData(audio_source); |
| 43 |
| 44 blink::WebMediaStreamTrack web_track; |
| 45 web_track.Initialize(web_source.Id(), web_source); |
| 46 audio_source->ConnectToTrack(web_track); |
| 47 return web_track; |
| 48 } |
| 49 |
| 50 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> |
| 51 GetOrCreateRemoteTrackAdapter( |
| 52 webrtc::MediaStreamTrackInterface* webrtc_track) { |
| 53 DCHECK(main_thread_->BelongsToCurrentThread()); |
| 54 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter; |
| 55 dependency_factory_->GetWebRtcSignalingThread()->PostTask( |
| 56 FROM_HERE, |
| 57 base::Bind(&WebRtcMediaStreamTrackAdapterMapTest:: |
| 58 GetOrCreateRemoteTrackAdapterOnSignalingThread, |
| 59 base::Unretained(this), webrtc_track, &adapter)); |
| 60 RunMessageLoopsUntilIdle(); |
| 61 return adapter; |
| 62 } |
| 63 |
| 64 void GetOrCreateRemoteTrackAdapterOnSignalingThread( |
| 65 webrtc::MediaStreamTrackInterface* webrtc_track, |
| 66 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>* adapter) { |
| 67 DCHECK(dependency_factory_->GetWebRtcSignalingThread() |
| 68 ->BelongsToCurrentThread()); |
| 69 *adapter = map_->GetOrCreateRemoteTrackAdapter(webrtc_track); |
| 70 } |
| 71 |
| 72 // Runs message loops on the webrtc signaling thread and the main thread until |
| 73 // idle. |
| 74 void RunMessageLoopsUntilIdle() { |
| 75 DCHECK(main_thread_->BelongsToCurrentThread()); |
| 76 base::WaitableEvent waitable_event( |
| 77 base::WaitableEvent::ResetPolicy::MANUAL, |
| 78 base::WaitableEvent::InitialState::NOT_SIGNALED); |
| 79 dependency_factory_->GetWebRtcSignalingThread()->PostTask( |
| 80 FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapterMapTest:: |
| 81 RunMessageLoopUntilIdleOnSignalingThread, |
| 82 base::Unretained(this), &waitable_event)); |
| 83 waitable_event.Wait(); |
| 84 base::RunLoop().RunUntilIdle(); |
| 85 } |
| 86 |
| 87 void RunMessageLoopUntilIdleOnSignalingThread( |
| 88 base::WaitableEvent* waitable_event) { |
| 89 DCHECK(dependency_factory_->GetWebRtcSignalingThread() |
| 90 ->BelongsToCurrentThread()); |
| 91 base::RunLoop().RunUntilIdle(); |
| 92 waitable_event->Signal(); |
| 93 } |
| 94 |
| 95 protected: |
| 96 // Message loop and child processes is needed for task queues and threading to |
| 97 // work, as is necessary to create tracks and adapters. |
| 98 base::MessageLoop message_loop_; |
| 99 ChildProcess child_process_; |
| 100 |
| 101 std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_; |
| 102 scoped_refptr<base::SingleThreadTaskRunner> main_thread_; |
| 103 scoped_refptr<WebRtcMediaStreamTrackAdapterMap> map_; |
| 104 }; |
| 105 |
| 106 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndRemoveLocalTrackAdapter) { |
| 107 blink::WebMediaStreamTrack web_track = CreateLocalTrack("local_track"); |
| 108 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter_ref = |
| 109 map_->GetOrCreateLocalTrackAdapter(web_track); |
| 110 EXPECT_TRUE(adapter_ref->is_initialized()); |
| 111 EXPECT_EQ(adapter_ref->GetAdapterForTesting(), |
| 112 map_->GetLocalTrackAdapter(web_track.Id().Utf8()) |
| 113 ->GetAdapterForTesting()); |
| 114 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 115 |
| 116 // "GetOrCreate" for already existing track. |
| 117 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter_ref2 = |
| 118 map_->GetOrCreateLocalTrackAdapter(web_track); |
| 119 EXPECT_EQ(adapter_ref->GetAdapterForTesting(), |
| 120 adapter_ref2->GetAdapterForTesting()); |
| 121 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 122 |
| 123 adapter_ref2.reset(); // Not the last reference. |
| 124 EXPECT_TRUE(adapter_ref->GetAdapterForTesting()->is_initialized()); |
| 125 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 126 |
| 127 // Destroying all references to the adapter should remove it from the map and |
| 128 // dispose it. |
| 129 adapter_ref.reset(); |
| 130 EXPECT_EQ(0u, map_->GetLocalTrackCount()); |
| 131 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(web_track.Id().Utf8())); |
| 132 // Allow the disposing of track to occur. |
| 133 RunMessageLoopsUntilIdle(); |
| 134 } |
| 135 |
| 136 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndRemoveRemoteTrackAdapter) { |
| 137 scoped_refptr<MockWebRtcAudioTrack> webrtc_track = |
| 138 MockWebRtcAudioTrack::Create("remote_track"); |
| 139 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter_ref = |
| 140 GetOrCreateRemoteTrackAdapter(webrtc_track.get()); |
| 141 EXPECT_TRUE(adapter_ref->is_initialized()); |
| 142 EXPECT_EQ( |
| 143 adapter_ref->GetAdapterForTesting(), |
| 144 map_->GetRemoteTrackAdapter(webrtc_track->id())->GetAdapterForTesting()); |
| 145 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 146 |
| 147 // "GetOrCreate" for already existing track. |
| 148 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> adapter_ref2 = |
| 149 GetOrCreateRemoteTrackAdapter(webrtc_track.get()); |
| 150 EXPECT_EQ(adapter_ref->GetAdapterForTesting(), |
| 151 adapter_ref2->GetAdapterForTesting()); |
| 152 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 153 |
| 154 adapter_ref2.reset(); // Not the last reference. |
| 155 EXPECT_TRUE(adapter_ref->GetAdapterForTesting()->is_initialized()); |
| 156 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 157 |
| 158 // Destroying all references to the adapter should remove it from the map and |
| 159 // dispose it. |
| 160 adapter_ref.reset(); |
| 161 EXPECT_EQ(0u, map_->GetRemoteTrackCount()); |
| 162 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter(webrtc_track->id())); |
| 163 // Allow the disposing of track to occur. |
| 164 RunMessageLoopsUntilIdle(); |
| 165 } |
| 166 |
| 167 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, |
| 168 LocalAndRemoteTrackAdaptersWithSameID) { |
| 169 // Local and remote tracks should be able to use the same id without conflict. |
| 170 const char* id = "id"; |
| 171 |
| 172 blink::WebMediaStreamTrack local_web_track = CreateLocalTrack(id); |
| 173 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> local_adapter = |
| 174 map_->GetOrCreateLocalTrackAdapter(local_web_track); |
| 175 EXPECT_TRUE(local_adapter->is_initialized()); |
| 176 EXPECT_EQ(local_adapter->GetAdapterForTesting(), |
| 177 map_->GetLocalTrackAdapter(id)->GetAdapterForTesting()); |
| 178 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 179 |
| 180 scoped_refptr<MockWebRtcAudioTrack> remote_webrtc_track = |
| 181 MockWebRtcAudioTrack::Create(id); |
| 182 std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> remote_adapter = |
| 183 GetOrCreateRemoteTrackAdapter(remote_webrtc_track.get()); |
| 184 EXPECT_TRUE(remote_adapter->is_initialized()); |
| 185 EXPECT_EQ(remote_adapter->GetAdapterForTesting(), |
| 186 map_->GetRemoteTrackAdapter(id)->GetAdapterForTesting()); |
| 187 EXPECT_NE(local_adapter->GetAdapterForTesting(), |
| 188 remote_adapter->GetAdapterForTesting()); |
| 189 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 190 |
| 191 // Destroying all references to the adapters should remove them from the map. |
| 192 local_adapter.reset(); |
| 193 remote_adapter.reset(); |
| 194 EXPECT_EQ(0u, map_->GetLocalTrackCount()); |
| 195 EXPECT_EQ(0u, map_->GetRemoteTrackCount()); |
| 196 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(id)); |
| 197 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter(id)); |
| 198 // Allow the disposing of tracks to occur. |
| 199 RunMessageLoopsUntilIdle(); |
| 200 } |
| 201 |
| 202 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetLocalTrackAdapterInvalidID) { |
| 203 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter("invalid")); |
| 204 } |
| 205 |
| 206 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetRemoteTrackAdapterInvalidID) { |
| 207 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter("invalid")); |
| 208 } |
| 209 |
| 210 } // namespace content |
OLD | NEW |