WebRtcMediaStreamAdapter using WebRtcMediaStreamTrackMap.

content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc

 // Copyright 2014 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 "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/message_loop/message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_audio_device_factory.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.h"
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 using ::testing::_;
 
 namespace content {
 
 class WebRtcMediaStreamAdapterTest : public ::testing::Test {
  public:
   void SetUp() override {
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
+    track_adapter_map_ = new WebRtcMediaStreamTrackAdapterMap(
+        dependency_factory_.get(), base::ThreadTaskRunnerHandle::Get());
   }
 
   void TearDown() override {
     adapter_.reset();
+    track_adapter_map_ = nullptr;
     blink::WebHeap::CollectAllGarbageForTesting();
   }
 
   blink::WebMediaStream CreateBlinkMediaStream(bool audio, bool video) {
     blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
         audio ? static_cast<size_t>(1) : 0);
     if (audio) {
       blink::WebMediaStreamSource audio_source;
       audio_source.Initialize("audio", blink::WebMediaStreamSource::kTypeAudio,
                               "audio", false /* remote */);
@@ skipping 37 matching lines @@
     stream_desc.Initialize("media stream", audio_track_vector,
                            video_track_vector);
     stream_desc.SetExtraData(new MediaStream());
     return stream_desc;
   }
 
   void CreateWebRtcMediaStream(const blink::WebMediaStream& blink_stream,
                                size_t expected_number_of_audio_tracks,
                                size_t expected_number_of_video_tracks) {
     adapter_.reset(new WebRtcMediaStreamAdapter(
-        blink_stream, dependency_factory_.get()));
+        dependency_factory_.get(), track_adapter_map_, blink_stream));
 
     EXPECT_EQ(expected_number_of_audio_tracks,
               adapter_->webrtc_media_stream()->GetAudioTracks().size());
     EXPECT_EQ(expected_number_of_video_tracks,
               adapter_->webrtc_media_stream()->GetVideoTracks().size());
     EXPECT_EQ(blink_stream.Id().Utf8(),
               adapter_->webrtc_media_stream()->label());
   }
 
   webrtc::MediaStreamInterface* webrtc_stream() {
     return adapter_->webrtc_media_stream();
   }
 
  private:
   static void OnAudioSourceStarted(MediaStreamSource* source,
                                    MediaStreamRequestResult result,
                                    const blink::WebString& result_name) {}
 
   base::MessageLoop message_loop_;
   std::unique_ptr<ChildProcess> child_process_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
+  scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
   std::unique_ptr<WebRtcMediaStreamAdapter> adapter_;
   MockAudioDeviceFactory mock_audio_device_factory_;
 };
 
 TEST_F(WebRtcMediaStreamAdapterTest, CreateWebRtcMediaStream) {
   blink::WebMediaStream blink_stream = CreateBlinkMediaStream(true, true);
   CreateWebRtcMediaStream(blink_stream, 1, 1);
 }
 
 // Test that we don't crash if a MediaStream is created in Blink with an unknown
@@ skipping 38 matching lines @@
   EXPECT_TRUE(webrtc_stream()->GetVideoTracks().empty());
 
   native_stream->AddTrack(audio_tracks[0]);
   EXPECT_EQ(1u, webrtc_stream()->GetAudioTracks().size());
 
   native_stream->AddTrack(video_tracks[0]);
   EXPECT_EQ(1u, webrtc_stream()->GetVideoTracks().size());
 }
 
 }  // namespace content