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 scoped_refptr<WebRtcMediaStreamTrackAdapter> GetOrCreateRemoteTrackAdapter( |
| 51 webrtc::MediaStreamTrackInterface* webrtc_track) { |
| 52 DCHECK(main_thread_->BelongsToCurrentThread()); |
| 53 scoped_refptr<WebRtcMediaStreamTrackAdapter> track; |
| 54 dependency_factory_->GetWebRtcSignalingThread()->PostTask( |
| 55 FROM_HERE, |
| 56 base::Bind(&WebRtcMediaStreamTrackAdapterMapTest:: |
| 57 GetOrCreateRemoteTrackAdapterOnSignalingThread, |
| 58 base::Unretained(this), webrtc_track, &track)); |
| 59 RunMessageLoopsUntilIdle(); |
| 60 return track; |
| 61 } |
| 62 |
| 63 void GetOrCreateRemoteTrackAdapterOnSignalingThread( |
| 64 webrtc::MediaStreamTrackInterface* webrtc_track, |
| 65 scoped_refptr<WebRtcMediaStreamTrackAdapter>* track) { |
| 66 DCHECK(dependency_factory_->GetWebRtcSignalingThread() |
| 67 ->BelongsToCurrentThread()); |
| 68 *track = map_->GetOrCreateRemoteTrackAdapter(webrtc_track); |
| 69 } |
| 70 |
| 71 // Runs message loops on the webrtc signaling thread and the main thread until |
| 72 // idle. |
| 73 void RunMessageLoopsUntilIdle() { |
| 74 DCHECK(main_thread_->BelongsToCurrentThread()); |
| 75 base::WaitableEvent waitable_event( |
| 76 base::WaitableEvent::ResetPolicy::MANUAL, |
| 77 base::WaitableEvent::InitialState::NOT_SIGNALED); |
| 78 dependency_factory_->GetWebRtcSignalingThread()->PostTask( |
| 79 FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapterMapTest:: |
| 80 RunMessageLoopUntilIdleOnSignalingThread, |
| 81 base::Unretained(this), &waitable_event)); |
| 82 waitable_event.Wait(); |
| 83 base::RunLoop().RunUntilIdle(); |
| 84 } |
| 85 |
| 86 void RunMessageLoopUntilIdleOnSignalingThread( |
| 87 base::WaitableEvent* waitable_event) { |
| 88 DCHECK(dependency_factory_->GetWebRtcSignalingThread() |
| 89 ->BelongsToCurrentThread()); |
| 90 base::RunLoop().RunUntilIdle(); |
| 91 waitable_event->Signal(); |
| 92 } |
| 93 |
| 94 protected: |
| 95 // Message loop and child processes is needed for task queues and threading to |
| 96 // work, as is necessary to create tracks and adapters. |
| 97 base::MessageLoop message_loop_; |
| 98 ChildProcess child_process_; |
| 99 |
| 100 std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_; |
| 101 scoped_refptr<base::SingleThreadTaskRunner> main_thread_; |
| 102 scoped_refptr<WebRtcMediaStreamTrackAdapterMap> map_; |
| 103 }; |
| 104 |
| 105 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndRemoveLocalTrackAdapter) { |
| 106 blink::WebMediaStreamTrack web_track = CreateLocalTrack("local_track"); |
| 107 scoped_refptr<WebRtcMediaStreamTrackAdapter> track = |
| 108 map_->GetOrCreateLocalTrackAdapter(web_track); |
| 109 DCHECK(track); |
| 110 EXPECT_TRUE(track->is_initialized()); |
| 111 EXPECT_EQ(track, map_->GetLocalTrackAdapter(web_track.Id().Utf8())); |
| 112 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 113 |
| 114 // "GetOrCreate" for already existing track. |
| 115 EXPECT_EQ(track, map_->GetOrCreateLocalTrackAdapter(web_track)); |
| 116 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 117 |
| 118 // Dispose track adapter. Must not hold references to adapter. |
| 119 track = nullptr; |
| 120 map_->DisposeLocalTrackAdapter(web_track.Id().Utf8()); |
| 121 EXPECT_EQ(0u, map_->GetLocalTrackCount()); |
| 122 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(web_track.Id().Utf8())); |
| 123 // Allow the disposing of track to occur. |
| 124 RunMessageLoopsUntilIdle(); |
| 125 } |
| 126 |
| 127 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndDisposeRemoteTrackAdapter) { |
| 128 scoped_refptr<MockWebRtcAudioTrack> webrtc_track = |
| 129 MockWebRtcAudioTrack::Create("remote_track"); |
| 130 scoped_refptr<WebRtcMediaStreamTrackAdapter> track = |
| 131 GetOrCreateRemoteTrackAdapter(webrtc_track.get()); |
| 132 DCHECK(track); |
| 133 EXPECT_TRUE(track->is_initialized()); |
| 134 EXPECT_EQ(track, map_->GetRemoteTrackAdapter(webrtc_track->id())); |
| 135 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 136 |
| 137 // "GetOrCreate" for already existing track. |
| 138 EXPECT_EQ(track, GetOrCreateRemoteTrackAdapter(webrtc_track.get())); |
| 139 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 140 |
| 141 // Dispose track adapter. Must not hold references to adapter. |
| 142 track = nullptr; |
| 143 map_->DisposeRemoteTrackAdapter(webrtc_track->id()); |
| 144 EXPECT_EQ(0u, map_->GetRemoteTrackCount()); |
| 145 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter(webrtc_track->id())); |
| 146 // Allow the disposing of track to occur. |
| 147 RunMessageLoopsUntilIdle(); |
| 148 } |
| 149 |
| 150 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, AddAndDisposeAllTrackAdapters) { |
| 151 // Local and remote tracks should be able to use the same id without conflict. |
| 152 const char* id = "id"; |
| 153 |
| 154 // Add local track. |
| 155 blink::WebMediaStreamTrack local_web_track = CreateLocalTrack(id); |
| 156 scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track = |
| 157 map_->GetOrCreateLocalTrackAdapter(local_web_track); |
| 158 DCHECK(local_track); |
| 159 EXPECT_TRUE(local_track->is_initialized()); |
| 160 EXPECT_EQ(local_track, map_->GetLocalTrackAdapter(id)); |
| 161 EXPECT_EQ(1u, map_->GetLocalTrackCount()); |
| 162 |
| 163 // Add remote track. |
| 164 scoped_refptr<MockWebRtcAudioTrack> remote_webrtc_track = |
| 165 MockWebRtcAudioTrack::Create(id); |
| 166 scoped_refptr<WebRtcMediaStreamTrackAdapter> remote_track = |
| 167 GetOrCreateRemoteTrackAdapter(remote_webrtc_track.get()); |
| 168 DCHECK(remote_track); |
| 169 EXPECT_TRUE(remote_track->is_initialized()); |
| 170 EXPECT_EQ(remote_track, map_->GetRemoteTrackAdapter(id)); |
| 171 EXPECT_NE(local_track, remote_track); |
| 172 EXPECT_EQ(1u, map_->GetRemoteTrackCount()); |
| 173 |
| 174 // Dispose all track adapters. Must not hold references to adapters. |
| 175 local_track = nullptr; |
| 176 remote_track = nullptr; |
| 177 map_->DisposeAllTrackAdapters(); |
| 178 EXPECT_EQ(0u, map_->GetLocalTrackCount()); |
| 179 EXPECT_EQ(0u, map_->GetRemoteTrackCount()); |
| 180 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter(id)); |
| 181 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter(id)); |
| 182 // Allow the disposing of tracks to occur. |
| 183 RunMessageLoopsUntilIdle(); |
| 184 } |
| 185 |
| 186 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetLocalTrackAdapterInvalidID) { |
| 187 EXPECT_EQ(nullptr, map_->GetLocalTrackAdapter("invalid")); |
| 188 } |
| 189 |
| 190 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, GetRemoteTrackAdapterInvalidID) { |
| 191 EXPECT_EQ(nullptr, map_->GetRemoteTrackAdapter("invalid")); |
| 192 } |
| 193 |
| 194 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, |
| 195 DisposeLocalTrackAdapterInvalidID) { |
| 196 EXPECT_FALSE(map_->DisposeLocalTrackAdapter("invalid")); |
| 197 } |
| 198 |
| 199 TEST_F(WebRtcMediaStreamTrackAdapterMapTest, |
| 200 DisposeRemoteTrackAdapterInvalidID) { |
| 201 EXPECT_FALSE(map_->DisposeRemoteTrackAdapter("invalid")); |
| 202 } |
| 203 |
| 204 } // namespace content |
OLD | NEW |