Add video frame refresh to MediaStream and VideoCapture stacks.

content/renderer/media/media_stream_video_source_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 104 matching lines @@
                            int capture_height,
                            const blink::WebMediaConstraints& constraints,
                            int expected_width,
                            int expected_height) {
     // Expect the source to start capture with the supported resolution.
     blink::WebMediaStreamTrack track =
         CreateTrackAndStartSource(constraints, capture_width, capture_height,
                                   30);
 
     MockMediaStreamVideoSink sink;
-    MediaStreamVideoSink::AddToVideoTrack(
-        &sink, sink.GetDeliverFrameCB(), track);
+    sink.ConnectToTrack(track);
     DeliverVideoFrameAndWaitForRenderer(capture_width, capture_height, &sink);
     EXPECT_EQ(1, sink.number_of_frames());
 
     // Expect the delivered frame to be cropped.
     EXPECT_EQ(expected_height, sink.frame_size().height());
     EXPECT_EQ(expected_width, sink.frame_size().width());
-    MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
+    sink.DisconnectFromTrack();
   }
 
   void DeliverVideoFrameAndWaitForRenderer(int width, int height,
                                            MockMediaStreamVideoSink* sink) {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
     EXPECT_CALL(*sink, OnVideoFrame()).WillOnce(
         RunClosure(quit_closure));
     scoped_refptr<media::VideoFrame> frame =
               media::VideoFrame::CreateBlackFrame(gfx::Size(width, height));
@@ skipping 26 matching lines @@
       int expected_height1,
       int expected_width2,
       int expected_height2) {
     blink::WebMediaStreamTrack track1 =
         CreateTrackAndStartSource(constraints1, capture_width, capture_height,
                                   MediaStreamVideoSource::kDefaultFrameRate);
 
     blink::WebMediaStreamTrack track2 = CreateTrack("dummy", constraints2);
 
     MockMediaStreamVideoSink sink1;
-    MediaStreamVideoSink::AddToVideoTrack(&sink1, sink1.GetDeliverFrameCB(),
-                                          track1);
+    sink1.ConnectToTrack(track1);
     EXPECT_EQ(0, sink1.number_of_frames());
 
     MockMediaStreamVideoSink sink2;
-    MediaStreamVideoSink::AddToVideoTrack(&sink2, sink2.GetDeliverFrameCB(),
-                                          track2);
+    sink2.ConnectToTrack(track2);
     EXPECT_EQ(0, sink2.number_of_frames());
 
     DeliverVideoFrameAndWaitForTwoRenderers(capture_width,
                                             capture_height,
                                             &sink1,
                                             &sink2);
 
     EXPECT_EQ(1, sink1.number_of_frames());
     EXPECT_EQ(expected_width1, sink1.frame_size().width());
     EXPECT_EQ(expected_height1, sink1.frame_size().height());
 
     EXPECT_EQ(1, sink2.number_of_frames());
     EXPECT_EQ(expected_width2, sink2.frame_size().width());
     EXPECT_EQ(expected_height2, sink2.frame_size().height());
 
-    MediaStreamVideoSink::RemoveFromVideoTrack(&sink1, track1);
-    MediaStreamVideoSink::RemoveFromVideoTrack(&sink2, track2);
+    sink1.DisconnectFromTrack();
+    sink2.DisconnectFromTrack();
   }
 
   void SetSourceSupportedFormats(const media::VideoCaptureFormats& formats) {
     mock_source_->SetSupportedFormats(formats);
   }
 
   void ReleaseTrackAndSourceOnAddTrackCallback(
       const blink::WebMediaStreamTrack& track_to_release) {
     track_to_release_ = track_to_release;
   }
@@ skipping 437 matching lines @@
   MockConstraintFactory factory;
   factory.AddAdvanced().width.setMax(800);
   factory.AddAdvanced().height.setMax(700);
 
   // Expect the source to start capture with the supported resolution.
   blink::WebMediaStreamTrack track =
       CreateTrackAndStartSource(factory.CreateWebMediaConstraints(),
                                 640, 480, 30);
 
   MockMediaStreamVideoSink sink;
-  MediaStreamVideoSink::AddToVideoTrack(
-      &sink, sink.GetDeliverFrameCB(), track);
+  sink.ConnectToTrack(track);
   EXPECT_EQ(0, sink.number_of_frames());
   DeliverVideoFrameAndWaitForRenderer(320, 240, &sink);
   EXPECT_EQ(1, sink.number_of_frames());
   // Expect the delivered frame to be passed unchanged since its smaller than
   // max requested.
   EXPECT_EQ(320, sink.frame_size().width());
   EXPECT_EQ(240, sink.frame_size().height());
 
   DeliverVideoFrameAndWaitForRenderer(640, 480, &sink);
   EXPECT_EQ(2, sink.number_of_frames());
   // Expect the delivered frame to be passed unchanged since its smaller than
   // max requested.
   EXPECT_EQ(640, sink.frame_size().width());
   EXPECT_EQ(480, sink.frame_size().height());
 
   DeliverVideoFrameAndWaitForRenderer(1280, 720, &sink);
 
   EXPECT_EQ(3, sink.number_of_frames());
   // Expect a frame to be cropped since its larger than max requested.
   EXPECT_EQ(800, sink.frame_size().width());
   EXPECT_EQ(700, sink.frame_size().height());
 
-  MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
+  sink.DisconnectFromTrack();
 }
 
 TEST_F(MediaStreamVideoSourceTest, IsConstraintSupported) {
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
           MediaStreamVideoSource::kMaxFrameRate));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
         MediaStreamVideoSource::kMinFrameRate));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
       MediaStreamVideoSource::kMaxWidth));
   EXPECT_TRUE(MediaStreamVideoSource::IsConstraintSupported(
@@ skipping 21 matching lines @@
   mock_source()->SetSupportedFormats(formats);
 
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   blink::WebMediaStreamTrack track = CreateTrack("123", constraints);
   mock_source()->CompleteGetSupportedFormats();
   mock_source()->StartMockedSource();
   EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks());
 
   MockMediaStreamVideoSink sink;
-  MediaStreamVideoSink::AddToVideoTrack(
-      &sink, sink.GetDeliverFrameCB(), track);
+  sink.ConnectToTrack(track);
   EXPECT_EQ(0, sink.number_of_frames());
   DeliverVideoFrameAndWaitForRenderer(320, 240, &sink);
   EXPECT_EQ(1, sink.number_of_frames());
   // Expect the delivered frame to be passed unchanged since its smaller than
   // max requested.
   EXPECT_EQ(320, sink.frame_size().width());
   EXPECT_EQ(240, sink.frame_size().height());
-  MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
+  sink.DisconnectFromTrack();
 }
 
 // Test that a source producing no frames change the source ReadyState to muted.
 // that in a reasonable time frame the muted state turns to false.
 TEST_F(MediaStreamVideoSourceTest, MutedSource) {
   // Setup the source for support a frame rate of 999 fps in order to test
   // the muted event faster. This is since the frame monitoring uses
   // PostDelayedTask that is dependent on the source frame rate.
   // Note that media::limits::kMaxFramesPerSecond is 1000.
   media::VideoCaptureFormats formats;
   formats.push_back(media::VideoCaptureFormat(
       gfx::Size(640, 480), media::limits::kMaxFramesPerSecond - 1,
       media::PIXEL_FORMAT_I420));
   SetSourceSupportedFormats(formats);
 
   MockConstraintFactory factory;
   blink::WebMediaStreamTrack track =
       CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480,
                                 media::limits::kMaxFramesPerSecond - 1);
   MockMediaStreamVideoSink sink;
-  MediaStreamVideoSink::AddToVideoTrack(&sink, sink.GetDeliverFrameCB(), track);
+  sink.ConnectToTrack(track);
   EXPECT_EQ(track.source().getReadyState(),
             blink::WebMediaStreamSource::ReadyStateLive);
 
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
   bool muted_state = false;
   EXPECT_CALL(*mock_source(), DoSetMutedState(_))
       .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure)));
   run_loop.Run();
   EXPECT_EQ(muted_state, true);
 
   EXPECT_EQ(track.source().getReadyState(),
             blink::WebMediaStreamSource::ReadyStateMuted);
 
   base::RunLoop run_loop2;
   base::Closure quit_closure2 = run_loop2.QuitClosure();
   EXPECT_CALL(*mock_source(), DoSetMutedState(_))
       .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure2)));
   DeliverVideoFrameAndWaitForRenderer(640, 480, &sink);
   run_loop2.Run();
 
   EXPECT_EQ(muted_state, false);
   EXPECT_EQ(track.source().getReadyState(),
             blink::WebMediaStreamSource::ReadyStateLive);
 
-  MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
+  sink.DisconnectFromTrack();
 }
 
 }  // namespace content