[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

content/renderer/media/media_stream_impl_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_impl.h"
@@ skipping 25 matching lines @@
 
 class MediaStreamImplUnderTest : public MediaStreamImpl {
  public:
   enum RequestState {
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
     REQUEST_FAILED,
   };
 
-  MediaStreamImplUnderTest(MediaStreamDispatcher* media_stream_dispatcher,
-                           PeerConnectionDependencyFactory* dependency_factory)
-      : MediaStreamImpl(NULL, media_stream_dispatcher, dependency_factory),
+  MediaStreamImplUnderTest(
+      PeerConnectionDependencyFactory* dependency_factory,
+      scoped_ptr<MediaStreamDispatcher> media_stream_dispatcher)
+      : MediaStreamImpl(
+            NULL, dependency_factory, media_stream_dispatcher.Pass()),
         state_(REQUEST_NOT_STARTED),
         result_(NUM_MEDIA_REQUEST_RESULTS),
         factory_(dependency_factory),
         video_source_(NULL) {
   }
 
   void RequestUserMedia() {
     blink::WebUserMediaRequest user_media_request;
     state_ = REQUEST_NOT_COMPLETE;
     requestUserMedia(user_media_request);
@@ skipping 62 matching lines @@
   blink::WebVector<blink::WebMediaDeviceInfo> last_devices_;
   PeerConnectionDependencyFactory* factory_;
   MockMediaStreamVideoCapturerSource* video_source_;
 };
 
 class MediaStreamImplTest : public ::testing::Test {
  public:
   virtual void SetUp() {
     // Create our test object.
     child_process_.reset(new ChildProcess());
-    ms_dispatcher_.reset(new MockMediaStreamDispatcher());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
-    ms_impl_.reset(new MediaStreamImplUnderTest(ms_dispatcher_.get(),
-                                                dependency_factory_.get()));
+    ms_dispatcher_ = new MockMediaStreamDispatcher();
+    ms_impl_.reset(new MediaStreamImplUnderTest(
+        dependency_factory_.get(),
+        scoped_ptr<MediaStreamDispatcher>(ms_dispatcher_).Pass()));
   }
 
   blink::WebMediaStream RequestLocalMediaStream() {
     ms_impl_->RequestUserMedia();
     FakeMediaStreamDispatcherRequestUserMediaComplete();
     StartMockedVideoSource();
 
     EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_SUCCEEDED,
               ms_impl_->request_state());
 
@@ skipping 47 matching lines @@
       video_source->FailToStartMockedSource();
   }
 
   void FailToCreateNextAudioCapturer() {
     dependency_factory_->FailToCreateNextAudioCapturer();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_ptr<ChildProcess> child_process_;
-  scoped_ptr<MockMediaStreamDispatcher> ms_dispatcher_;
+  MockMediaStreamDispatcher* ms_dispatcher_;  // Owned my |ms_impl_|.
   scoped_ptr<MediaStreamImplUnderTest> ms_impl_;
   scoped_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
 };
 
 TEST_F(MediaStreamImplTest, GenerateMediaStream) {
   // Generate a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
 }
 
 // Test that the same source object is used if two MediaStreams are generated
@@ skipping 109 matching lines @@
   RequestLocalMediaStream();
   // Makes sure the test itself don't hold a reference to the created
   // MediaStream.
   ms_impl_->ClearLastGeneratedStream();
 
   // Expect the sources to be stopped when the MediaStream goes out of scope.
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
-// Test that the MediaStreams are deleted if the owning WebFrame is deleted.
+// Test that the MediaStreams are deleted if the owning WebFrame is closing.
 // In the unit test the owning frame is NULL.
 TEST_F(MediaStreamImplTest, FrameWillClose) {
   // Test a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
   blink::WebMediaStream desc2 = RequestLocalMediaStream();
-
-  // Test that the MediaStreams are deleted if the owning WebFrame is deleted.
-  // In the unit test the owning frame is NULL.
-  ms_impl_->FrameWillClose(NULL);
+  ms_impl_->FrameWillClose();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 // This test what happens if a video source to a MediaSteam fails to start.
 TEST_F(MediaStreamImplTest, MediaVideoSourceFailToStart) {
   ms_impl_->RequestUserMedia();
   FakeMediaStreamDispatcherRequestUserMediaComplete();
   FailToStartMockedVideoSource();
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_FAILED,
@@ skipping 28 matching lines @@
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_NOT_COMPLETE,
             ms_impl_->request_state());
   ms_impl_.reset();
 }
 
 // This test what happens if the WebFrame is closed while the MediaStream is
 // being generated by the MediaStreamDispatcher.
 TEST_F(MediaStreamImplTest, ReloadFrameWhileGeneratingStream) {
   ms_impl_->RequestUserMedia();
-  ms_impl_->FrameWillClose(NULL);
+  ms_impl_->FrameWillClose();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter());
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_NOT_COMPLETE,
             ms_impl_->request_state());
 }
 
 // This test what happens if the WebFrame is closed while the sources are being
 // started.
 TEST_F(MediaStreamImplTest, ReloadFrameWhileGeneratingSources) {
   ms_impl_->RequestUserMedia();
   FakeMediaStreamDispatcherRequestUserMediaComplete();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
-  ms_impl_->FrameWillClose(NULL);
+  ms_impl_->FrameWillClose();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_NOT_COMPLETE,
             ms_impl_->request_state());
 }
 
 // This test what happens if stop is called on a track after the frame has
 // been reloaded.
 TEST_F(MediaStreamImplTest, StopTrackAfterReload) {
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
-  ms_impl_->FrameWillClose(NULL);
+  ms_impl_->FrameWillClose();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
   mixed_desc.audioTracks(audio_tracks);
   MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]);
   audio_track->Stop();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
@@ skipping 39 matching lines @@
   EXPECT_FALSE(ms_impl_->last_devices()[3].groupId().isEmpty());
 
   // Verfify group IDs.
   EXPECT_TRUE(ms_impl_->last_devices()[0].groupId().equals(
                   ms_impl_->last_devices()[3].groupId()));
   EXPECT_FALSE(ms_impl_->last_devices()[1].groupId().equals(
                    ms_impl_->last_devices()[3].groupId()));
 }
 
 }  // namespace content