Update MediaStreamTrack::Stop to latest draft.

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/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_impl.h"
+#include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_dispatcher.h"
 #include "content/renderer/media/mock_media_stream_video_source.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/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
@@ skipping 17 matching lines @@
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
     REQUEST_FAILED,
   };
 
   MediaStreamImplUnderTest(MediaStreamDispatcher* media_stream_dispatcher,
                            MediaStreamDependencyFactory* dependency_factory)
       : MediaStreamImpl(NULL, media_stream_dispatcher, dependency_factory),
         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);
   }
 
-  virtual void CompleteGetUserMediaRequest(
+  virtual void GetUserMediaRequestSucceeded(
       const blink::WebMediaStream& stream,
-      blink::WebUserMediaRequest* request_info,
-      content::MediaStreamRequestResult result) OVERRIDE {
+      blink::WebUserMediaRequest* request_info) OVERRIDE {
     last_generated_stream_ = stream;
-    result_ = result;
-    state_ = (result == MEDIA_DEVICE_OK ? REQUEST_SUCCEEDED : REQUEST_FAILED);
+    state_ = REQUEST_SUCCEEDED;
   }
 
-  virtual blink::WebMediaStream GetMediaStream(
-      const GURL& url) OVERRIDE {
-    return last_generated_stream_;
+  virtual void GetUserMediaRequestFailed(
+        blink::WebUserMediaRequest* request_info,
+        content::MediaStreamRequestResult result) OVERRIDE {
+    last_generated_stream_.reset();
+    state_ =  REQUEST_FAILED;
+    result_ = result;
   }
 
   virtual MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback) OVERRIDE {
     video_source_ = new MockMediaStreamVideoCapturerSource(device,
                                                            stop_callback,
                                                            factory_);
     return video_source_;
   }
 
-  using MediaStreamImpl::OnLocalMediaStreamStop;
   using MediaStreamImpl::OnLocalSourceStopped;
 
   const blink::WebMediaStream& last_generated_stream() {
     return last_generated_stream_;
   }
 
+  void ClearLastGeneratedStream() {
+    last_generated_stream_.reset();
+  }
+
   MockMediaStreamVideoCapturerSource* last_created_video_source() const {
     return video_source_;
   }
 
   RequestState request_state() const { return state_; }
   content::MediaStreamRequestResult error_reason() const { return result_; }
 
  private:
   blink::WebMediaStream last_generated_stream_;
   RequestState state_;
@@ skipping 121 matching lines @@
   desc1.audioTracks(desc1_audio_tracks);
   blink::WebVector<blink::WebMediaStreamTrack> desc2_audio_tracks;
   desc2.audioTracks(desc2_audio_tracks);
   EXPECT_NE(desc1_audio_tracks[0].source().id(),
             desc2_audio_tracks[0].source().id());
 
   EXPECT_NE(desc1_audio_tracks[0].source().extraData(),
             desc2_audio_tracks[0].source().extraData());
 }
 
-TEST_F(MediaStreamImplTest, StopLocalMediaStream) {
+TEST_F(MediaStreamImplTest, StopLocalTracks) {

[no longer working on chromium, 2014/04/01 18:29:58]

does any of the test cases verify that the source will be stopped when the last
track is stopped ?
And the source won't be stopped if there is any active track?

[perkj_chrome, 2014/04/02 13:35:49]

These tests verify that the ms_dispatcher is notified that a source has been
stopped. It is the MediaStreamAudioSource and MediaStreamVideoSource that
trigger the callback when the last track has been stopped.

For testing with multiple tracks using the same source, see 
StopLocalTracksWhenTwoStreamUseSameDevices.

   // Generate a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
 
-  // Stop generated local streams.
-  ms_impl_->OnLocalMediaStreamStop(mixed_desc.id().utf8());
+  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
+  mixed_desc.audioTracks(audio_tracks);
+  MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]);
+  audio_track->StopTrack();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
+  mixed_desc.videoTracks(video_tracks);
+  MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]);
+  video_track->StopTrack();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
-// This test that a source is not stopped even if the MediaStream is stopped if
-// there are two MediaStreams using the same device. The source is stopped
-// if there are no more MediaStreams using the device.
-TEST_F(MediaStreamImplTest, StopLocalMediaStreamWhenTwoStreamUseSameDevices) {
+// This test that a source is not stopped even if the tracks in a
+// MediaStream is stopped if there are two MediaStreams with tracks using the
+// same device. The source is stopped
+// if there are no more MediaStream tracks using the device.
+TEST_F(MediaStreamImplTest, StopLocalTracksWhenTwoStreamUseSameDevices) {
   // Generate a stream with both audio and video.
   blink::WebMediaStream desc1 = RequestLocalMediaStream();
   blink::WebMediaStream desc2 = RequestLocalMediaStream();
 
-  ms_impl_->OnLocalMediaStreamStop(desc2.id().utf8());
+  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks1;
+  desc1.audioTracks(audio_tracks1);
+  MediaStreamTrack* audio_track1 = MediaStreamTrack::GetTrack(audio_tracks1[0]);
+  audio_track1->StopTrack();
   EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter());
+
+  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks2;
+  desc2.audioTracks(audio_tracks2);
+  MediaStreamTrack* audio_track2 = MediaStreamTrack::GetTrack(audio_tracks2[0]);
+  audio_track2->StopTrack();
+  EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks1;
+  desc1.videoTracks(video_tracks1);
+  MediaStreamTrack* video_track1 = MediaStreamTrack::GetTrack(video_tracks1[0]);
+  video_track1->StopTrack();
   EXPECT_EQ(0, ms_dispatcher_->stop_video_device_counter());
 
-  ms_impl_->OnLocalMediaStreamStop(desc1.id().utf8());
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks2;
+  desc2.videoTracks(video_tracks2);
+  MediaStreamTrack* video_track2 = MediaStreamTrack::GetTrack(video_tracks2[0]);
+  video_track2->StopTrack();
+  EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
+}
+
+TEST_F(MediaStreamImplTest, StopSourceWhenMediaStreamGoesOutOfScope) {
+  // Generate a stream with both audio and video.
+  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 source is stopped even if there are two MediaStreams using
-// the same source.
-TEST_F(MediaStreamImplTest, StopSource) {
-  // Generate a stream with both audio and video.
-  blink::WebMediaStream desc1 = RequestLocalMediaStream();
-  blink::WebMediaStream desc2 = RequestLocalMediaStream();
-
-  // Stop the video source.
-  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
-  desc1.videoTracks(video_tracks);
-  ms_impl_->OnLocalSourceStopped(video_tracks[0].source());
-  EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter());
-  EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
-
-  // Stop the audio source.
-  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
-  desc1.audioTracks(audio_tracks);
-  ms_impl_->OnLocalSourceStopped(audio_tracks[0].source());
-  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.
 // 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);
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 // This test what happens if a source to a MediaSteam fails to start.
 TEST_F(MediaStreamImplTest, MediaSourceFailToStart) {
   ms_impl_->RequestUserMedia();
   FakeMediaStreamDispatcherComplete();
   FailToStartMockedVideoSource();
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_FAILED,
             ms_impl_->request_state());
   EXPECT_EQ(MEDIA_DEVICE_TRACK_START_FAILURE,
             ms_impl_->error_reason());
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
-// This test what happens if MediaStreamImpl is deleted while the sources of a
-// MediaStream is being started.
+// This test what happens if MediaStreamImpl is deleted before a source has
+// started.
 TEST_F(MediaStreamImplTest, MediaStreamImplShutDown) {
   ms_impl_->RequestUserMedia();
   FakeMediaStreamDispatcherComplete();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_NOT_COMPLETE,
             ms_impl_->request_state());
-
-  MockMediaStreamVideoCapturerSource* video_source =
-      ms_impl_->last_created_video_source();
-  // Hold on to a blink reference to the source to guarantee that its not
-  // deleted when MediaStreamImpl is deleted.
-  blink::WebMediaStreamSource blink_source = video_source->owner();
   ms_impl_.reset();
-  video_source->StartMockedSource();
 }
 
 // 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);
   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();
   FakeMediaStreamDispatcherComplete();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   ms_impl_->FrameWillClose(NULL);
   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 stream after the frame has
+// This test what happens if stop is called on a track after the frame has
 // been reloaded.
-TEST_F(MediaStreamImplTest, StopStreamAfterReload) {
+TEST_F(MediaStreamImplTest, StopTrackAfterReload) {
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
   EXPECT_EQ(1, ms_dispatcher_->request_stream_counter());
   ms_impl_->FrameWillClose(NULL);
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
-  ms_impl_->OnLocalMediaStreamStop(mixed_desc.id().utf8());
+
+  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
+  mixed_desc.audioTracks(audio_tracks);
+  MediaStreamTrack* audio_track = MediaStreamTrack::GetTrack(audio_tracks[0]);
+  audio_track->StopTrack();
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
+  mixed_desc.videoTracks(video_tracks);
+  MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]);
+  video_track->StopTrack();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 }  // namespace content