Effects Pepper Plugin and MediaStream Glue.

content/renderer/media/rtc_peer_connection_handler_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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 109 matching lines @@
   WebKit::WebMediaStream stream_;
   WebKit::WebMediaStreamTrack component_;
   scoped_refptr<MockRTCStatsResponse> response_;
   bool request_succeeded_called_;
 };
 
 class MockPeerConnectionTracker : public PeerConnectionTracker {
  public:
   MOCK_METHOD1(UnregisterPeerConnection,
                void(RTCPeerConnectionHandler* pc_handler));
-  // TODO (jiayl): add coverage for the following methods
+  // TODO(jiayl): add coverage for the following methods
   MOCK_METHOD2(TrackCreateOffer,
                void(RTCPeerConnectionHandler* pc_handler,
                     const RTCMediaConstraints& constraints));
   MOCK_METHOD2(TrackCreateAnswer,
                void(RTCPeerConnectionHandler* pc_handler,
                     const RTCMediaConstraints& constraints));
   MOCK_METHOD3(TrackSetSessionDescription,
                void(RTCPeerConnectionHandler* pc_handler,
                     const WebKit::WebRTCSessionDescription& desc,
                     Source source));
@@ skipping 29 matching lines @@
       TrackIceConnectionStateChange,
       void(RTCPeerConnectionHandler* pc_handler,
            WebRTCPeerConnectionHandlerClient::ICEConnectionState state));
   MOCK_METHOD2(
       TrackIceGatheringStateChange,
       void(RTCPeerConnectionHandler* pc_handler,
            WebRTCPeerConnectionHandlerClient::ICEGatheringState state));
   MOCK_METHOD1(TrackOnRenegotiationNeeded,
                void(RTCPeerConnectionHandler* pc_handler));
   MOCK_METHOD2(TrackCreateDTMFSender,
-               void (RTCPeerConnectionHandler* pc_handler,
+               void(RTCPeerConnectionHandler* pc_handler,
                      const WebKit::WebMediaStreamTrack& track));
 };
 
 class RTCPeerConnectionHandlerUnderTest : public RTCPeerConnectionHandler {
  public:
   RTCPeerConnectionHandlerUnderTest(
       WebRTCPeerConnectionHandlerClient* client,
       MediaStreamDependencyFactory* dependency_factory)
       : RTCPeerConnectionHandler(client, dependency_factory) {
   }
@@ skipping 50 matching lines @@
     WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
     local_stream.audioSources(audio_tracks);
     const std::string audio_track_id = UTF16ToUTF8(audio_tracks[0].id());
     scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         mock_dependency_factory_->CreateLocalAudioTrack(audio_track_id,
                                                         NULL));
     native_stream->AddTrack(audio_track);
     WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
     local_stream.audioSources(video_tracks);
     const std::string video_track_id = UTF16ToUTF8(video_tracks[0].id());
+    webrtc::VideoSourceInterface* source = NULL;
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         mock_dependency_factory_->CreateLocalVideoTrack(
-            video_track_id, 0));
+            video_track_id, source));
     native_stream->AddTrack(video_track);
 
     local_stream.setExtraData(new MediaStreamExtraData(native_stream, true));
     return local_stream;
   }
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   scoped_refptr<webrtc::MediaStreamInterface>
   AddRemoteMockMediaStream(const std::string& stream_label,
                            const std::string& video_track_label,
                            const std::string& audio_track_label) {
     scoped_refptr<webrtc::MediaStreamInterface> stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     if (!video_track_label.empty()) {
+      webrtc::VideoSourceInterface* source = NULL;
       scoped_refptr<webrtc::VideoTrackInterface> video_track(
           mock_dependency_factory_->CreateLocalVideoTrack(
-              video_track_label, 0));
+              video_track_label, source));
       stream->AddTrack(video_track);
     }
     if (!audio_track_label.empty()) {
       scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
                                                           NULL));
       stream->AddTrack(audio_track);
     }
     mock_peer_connection_->AddRemoteStream(stream);
     return stream;
@@ skipping 522 matching lines @@
   EXPECT_CALL(*mock_tracker_.get(),
               TrackCreateDTMFSender(pc_handler_.get(),
                                     testing::Ref(tracks[0])));
 
   scoped_ptr<WebKit::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 }
 
 }  // namespace content