src/content/renderer/media/rtc_peer_connection_handler_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/values.h"
  11 #include "content/renderer/media/media_stream.h"
  12 #include "content/renderer/media/media_stream_audio_source.h"
  13 #include "content/renderer/media/media_stream_source.h"
  14 #include "content/renderer/media/media_stream_video_track.h"
  15 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
  16 #include "content/renderer/media/mock_media_stream_video_source.h"
  17 #include "content/renderer/media/mock_peer_connection_impl.h"
  18 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
  19 #include "content/renderer/media/peer_connection_tracker.h"
  20 #include "content/renderer/media/rtc_media_constraints.h"
  21 #include "content/renderer/media/rtc_peer_connection_handler.h"
  22 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
  23 #include "content/renderer/media/webrtc_audio_capturer.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
  27 #include "third_party/WebKit/public/platform/WebMediaStream.h"
  28 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  29 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  30 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
  31 #include "third_party/WebKit/public/platform/WebRTCDTMFSenderHandler.h"
  32 #include "third_party/WebKit/public/platform/WebRTCDataChannelHandler.h"
  33 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
  34 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
  35 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
  36 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
  37 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
  38 #include "third_party/WebKit/public/platform/WebRTCStatsRequest.h"
  39 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
  40 #include "third_party/WebKit/public/platform/WebURL.h"
  41 #include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
  42
  43 static const char kDummySdp[] = "dummy sdp";
  44 static const char kDummySdpType[] = "dummy type";
  45
  46 using blink::WebRTCPeerConnectionHandlerClient;
  47 using testing::NiceMock;
  48 using testing::_;
  49 using testing::Ref;
  50
  51 namespace content {
  52
  53 class MockRTCStatsResponse : public LocalRTCStatsResponse {
  54  public:
  55   MockRTCStatsResponse()
  56       : report_count_(0),
  57         statistic_count_(0) {
  58   }
  59
  60   virtual size_t addReport(blink::WebString type,
  61                            blink::WebString id,
  62                            double timestamp) OVERRIDE {
  63     ++report_count_;
  64     return report_count_;
  65   }
  66
  67   virtual void addStatistic(size_t report,
  68                             blink::WebString name, blink::WebString value)
  69       OVERRIDE {
  70     ++statistic_count_;
  71   }
  72   int report_count() const { return report_count_; }
  73
  74  private:
  75   int report_count_;
  76   int statistic_count_;
  77 };
  78
  79 // Mocked wrapper for blink::WebRTCStatsRequest
  80 class MockRTCStatsRequest : public LocalRTCStatsRequest {
  81  public:
  82   MockRTCStatsRequest()
  83       : has_selector_(false),
  84         request_succeeded_called_(false) {}
  85
  86   virtual bool hasSelector() const OVERRIDE {
  87     return has_selector_;
  88   }
  89   virtual blink::WebMediaStreamTrack component() const OVERRIDE {
  90     return component_;
  91   }
  92   virtual scoped_refptr<LocalRTCStatsResponse> createResponse() OVERRIDE {
  93     DCHECK(!response_.get());
  94     response_ = new talk_base::RefCountedObject<MockRTCStatsResponse>();
  95     return response_;
  96   }
  97
  98   virtual void requestSucceeded(const LocalRTCStatsResponse* response)
  99       OVERRIDE {
 100     EXPECT_EQ(response, response_.get());
 101     request_succeeded_called_ = true;
 102   }
 103
 104   // Function for setting whether or not a selector is available.
 105   void setSelector(const blink::WebMediaStreamTrack& component) {
 106     has_selector_ = true;
 107     component_ = component;
 108   }
 109
 110   // Function for inspecting the result of a stats request.
 111   MockRTCStatsResponse* result() {
 112     if (request_succeeded_called_) {
 113       return response_.get();
 114     } else {
 115       return NULL;
 116     }
 117   }
 118
 119  private:
 120   bool has_selector_;
 121   blink::WebMediaStreamTrack component_;
 122   scoped_refptr<MockRTCStatsResponse> response_;
 123   bool request_succeeded_called_;
 124 };
 125
 126 class MockPeerConnectionTracker : public PeerConnectionTracker {
 127  public:
 128   MOCK_METHOD1(UnregisterPeerConnection,
 129                void(RTCPeerConnectionHandler* pc_handler));
 130   // TODO(jiayl): add coverage for the following methods
 131   MOCK_METHOD2(TrackCreateOffer,
 132                void(RTCPeerConnectionHandler* pc_handler,
 133                     const RTCMediaConstraints& constraints));
 134   MOCK_METHOD2(TrackCreateAnswer,
 135                void(RTCPeerConnectionHandler* pc_handler,
 136                     const RTCMediaConstraints& constraints));
 137   MOCK_METHOD3(TrackSetSessionDescription,
 138                void(RTCPeerConnectionHandler* pc_handler,
 139                     const blink::WebRTCSessionDescription& desc,
 140                     Source source));
 141   MOCK_METHOD3(
 142       TrackUpdateIce,
 143       void(RTCPeerConnectionHandler* pc_handler,
 144            const std::vector<
 145                webrtc::PeerConnectionInterface::IceServer>& servers,
 146            const RTCMediaConstraints& options));
 147   MOCK_METHOD3(TrackAddIceCandidate,
 148                void(RTCPeerConnectionHandler* pc_handler,
 149                     const blink::WebRTCICECandidate& candidate,
 150                     Source source));
 151   MOCK_METHOD3(TrackAddStream,
 152                void(RTCPeerConnectionHandler* pc_handler,
 153                     const blink::WebMediaStream& stream,
 154                     Source source));
 155   MOCK_METHOD3(TrackRemoveStream,
 156                void(RTCPeerConnectionHandler* pc_handler,
 157                     const blink::WebMediaStream& stream,
 158                     Source source));
 159   MOCK_METHOD1(TrackOnIceComplete,
 160                void(RTCPeerConnectionHandler* pc_handler));
 161   MOCK_METHOD3(TrackCreateDataChannel,
 162                void(RTCPeerConnectionHandler* pc_handler,
 163                     const webrtc::DataChannelInterface* data_channel,
 164                     Source source));
 165   MOCK_METHOD1(TrackStop, void(RTCPeerConnectionHandler* pc_handler));
 166   MOCK_METHOD2(TrackSignalingStateChange,
 167                void(RTCPeerConnectionHandler* pc_handler,
 168                     WebRTCPeerConnectionHandlerClient::SignalingState state));
 169   MOCK_METHOD2(
 170       TrackIceConnectionStateChange,
 171       void(RTCPeerConnectionHandler* pc_handler,
 172            WebRTCPeerConnectionHandlerClient::ICEConnectionState state));
 173   MOCK_METHOD2(
 174       TrackIceGatheringStateChange,
 175       void(RTCPeerConnectionHandler* pc_handler,
 176            WebRTCPeerConnectionHandlerClient::ICEGatheringState state));
 177   MOCK_METHOD1(TrackOnRenegotiationNeeded,
 178                void(RTCPeerConnectionHandler* pc_handler));
 179   MOCK_METHOD2(TrackCreateDTMFSender,
 180                void(RTCPeerConnectionHandler* pc_handler,
 181                      const blink::WebMediaStreamTrack& track));
 182 };
 183
 184 class RTCPeerConnectionHandlerUnderTest : public RTCPeerConnectionHandler {
 185  public:
 186   RTCPeerConnectionHandlerUnderTest(
 187       WebRTCPeerConnectionHandlerClient* client,
 188       MediaStreamDependencyFactory* dependency_factory)
 189       : RTCPeerConnectionHandler(client, dependency_factory) {
 190   }
 191
 192   MockPeerConnectionImpl* native_peer_connection() {
 193     return static_cast<MockPeerConnectionImpl*>(native_peer_connection_.get());
 194   }
 195 };
 196
 197 class RTCPeerConnectionHandlerTest : public ::testing::Test {
 198  public:
 199   RTCPeerConnectionHandlerTest() : mock_peer_connection_(NULL) {
 200   }
 201
 202   virtual void SetUp() {
 203     mock_client_.reset(new NiceMock<MockWebRTCPeerConnectionHandlerClient>());
 204     mock_dependency_factory_.reset(new MockMediaStreamDependencyFactory());
 205     pc_handler_.reset(
 206         new RTCPeerConnectionHandlerUnderTest(mock_client_.get(),
 207                                               mock_dependency_factory_.get()));
 208     mock_tracker_.reset(new NiceMock<MockPeerConnectionTracker>());
 209     blink::WebRTCConfiguration config;
 210     blink::WebMediaConstraints constraints;
 211     EXPECT_TRUE(pc_handler_->InitializeForTest(config, constraints,
 212                                                mock_tracker_.get()));
 213
 214     mock_peer_connection_ = pc_handler_->native_peer_connection();
 215     ASSERT_TRUE(mock_peer_connection_);
 216   }
 217
 218   // Creates a WebKit local MediaStream.
 219   blink::WebMediaStream CreateLocalMediaStream(
 220       const std::string& stream_label) {
 221     std::string video_track_label("video-label");
 222     std::string audio_track_label("audio-label");
 223
 224     blink::WebMediaStreamSource audio_source;
 225     audio_source.initialize(blink::WebString::fromUTF8(audio_track_label),
 226                             blink::WebMediaStreamSource::TypeAudio,
 227                             blink::WebString::fromUTF8("audio_track"));
 228     audio_source.setExtraData(new MediaStreamAudioSource());
 229     blink::WebMediaStreamSource video_source;
 230     video_source.initialize(blink::WebString::fromUTF8(video_track_label),
 231                             blink::WebMediaStreamSource::TypeVideo,
 232                             blink::WebString::fromUTF8("video_track"));
 233     MockMediaStreamVideoSource* native_video_source =
 234         new MockMediaStreamVideoSource(mock_dependency_factory_.get(),
 235                                        false);
 236     video_source.setExtraData(native_video_source);
 237
 238
 239     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
 240         static_cast<size_t>(1));
 241     audio_tracks[0].initialize(audio_source.id(), audio_source);
 242     audio_tracks[0].setExtraData(
 243         new MediaStreamTrack(
 244             WebRtcLocalAudioTrackAdapter::Create(audio_track_label,
 245                                                  NULL),
 246                                                  true));
 247     blink::WebVector<blink::WebMediaStreamTrack> video_tracks(
 248         static_cast<size_t>(1));
 249     blink::WebMediaConstraints constraints;
 250     constraints.initialize();
 251     video_tracks[0] = MediaStreamVideoTrack::CreateVideoTrack(
 252         native_video_source, constraints,
 253         MediaStreamVideoSource::ConstraintsCallback(), true,
 254         mock_dependency_factory_.get());
 255
 256     blink::WebMediaStream local_stream;
 257     local_stream.initialize(base::UTF8ToUTF16(stream_label), audio_tracks,
 258                             video_tracks);
 259     local_stream.setExtraData(
 260         new MediaStream(mock_dependency_factory_.get(),
 261                         MediaStream::StreamStopCallback(),
 262                         local_stream));
 263     return local_stream;
 264   }
 265
 266   // Creates a remote MediaStream and adds it to the mocked native
 267   // peer connection.
 268   scoped_refptr<webrtc::MediaStreamInterface>
 269   AddRemoteMockMediaStream(const std::string& stream_label,
 270                            const std::string& video_track_label,
 271                            const std::string& audio_track_label) {
 272     scoped_refptr<webrtc::MediaStreamInterface> stream(
 273         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
 274     if (!video_track_label.empty()) {
 275       webrtc::VideoSourceInterface* source = NULL;
 276       scoped_refptr<webrtc::VideoTrackInterface> video_track(
 277           mock_dependency_factory_->CreateLocalVideoTrack(
 278               video_track_label, source));
 279       stream->AddTrack(video_track.get());
 280     }
 281     if (!audio_track_label.empty()) {
 282       scoped_refptr<WebRtcAudioCapturer> capturer;
 283       scoped_refptr<webrtc::AudioTrackInterface> audio_track(
 284           WebRtcLocalAudioTrackAdapter::Create(audio_track_label, NULL));
 285       stream->AddTrack(audio_track.get());
 286     }
 287     mock_peer_connection_->AddRemoteStream(stream.get());
 288     return stream;
 289   }
 290
 291   scoped_ptr<MockWebRTCPeerConnectionHandlerClient> mock_client_;
 292   scoped_ptr<MockMediaStreamDependencyFactory> mock_dependency_factory_;
 293   scoped_ptr<NiceMock<MockPeerConnectionTracker> > mock_tracker_;
 294   scoped_ptr<RTCPeerConnectionHandlerUnderTest> pc_handler_;
 295
 296   // Weak reference to the mocked native peer connection implementation.
 297   MockPeerConnectionImpl* mock_peer_connection_;
 298 };
 299
 300 TEST_F(RTCPeerConnectionHandlerTest, Destruct) {
 301   EXPECT_CALL(*mock_tracker_.get(), UnregisterPeerConnection(pc_handler_.get()))
 302       .Times(1);
 303   pc_handler_.reset(NULL);
 304 }
 305
 306 TEST_F(RTCPeerConnectionHandlerTest, CreateOffer) {
 307   blink::WebRTCSessionDescriptionRequest request;
 308   blink::WebMediaConstraints options;
 309   EXPECT_CALL(*mock_tracker_.get(), TrackCreateOffer(pc_handler_.get(), _));
 310
 311   // TODO(perkj): Can blink::WebRTCSessionDescriptionRequest be changed so
 312   // the |reqest| requestSucceeded can be tested? Currently the |request| object
 313   // can not be initialized from a unit test.
 314   EXPECT_FALSE(mock_peer_connection_->created_session_description() != NULL);
 315   pc_handler_->createOffer(request, options);
 316   EXPECT_TRUE(mock_peer_connection_->created_session_description() != NULL);
 317 }
 318
 319 TEST_F(RTCPeerConnectionHandlerTest, CreateAnswer) {
 320   blink::WebRTCSessionDescriptionRequest request;
 321   blink::WebMediaConstraints options;
 322   EXPECT_CALL(*mock_tracker_.get(), TrackCreateAnswer(pc_handler_.get(), _));
 323   // TODO(perkj): Can blink::WebRTCSessionDescriptionRequest be changed so
 324   // the |reqest| requestSucceeded can be tested? Currently the |request| object
 325   // can not be initialized from a unit test.
 326   EXPECT_FALSE(mock_peer_connection_->created_session_description() != NULL);
 327   pc_handler_->createAnswer(request, options);
 328   EXPECT_TRUE(mock_peer_connection_->created_session_description() != NULL);
 329 }
 330
 331 TEST_F(RTCPeerConnectionHandlerTest, setLocalDescription) {
 332   blink::WebRTCVoidRequest request;
 333   blink::WebRTCSessionDescription description;
 334   description.initialize(kDummySdpType, kDummySdp);
 335   // PeerConnectionTracker::TrackSetSessionDescription is expected to be called
 336   // before |mock_peer_connection| is called.
 337   testing::InSequence sequence;
 338   EXPECT_CALL(*mock_tracker_.get(),
 339               TrackSetSessionDescription(pc_handler_.get(), Ref(description),
 340                                          PeerConnectionTracker::SOURCE_LOCAL));
 341   EXPECT_CALL(*mock_peer_connection_, SetLocalDescription(_, _));
 342
 343   pc_handler_->setLocalDescription(request, description);
 344   EXPECT_EQ(description.type(), pc_handler_->localDescription().type());
 345   EXPECT_EQ(description.sdp(), pc_handler_->localDescription().sdp());
 346
 347   std::string sdp_string;
 348   ASSERT_TRUE(mock_peer_connection_->local_description() != NULL);
 349   EXPECT_EQ(kDummySdpType, mock_peer_connection_->local_description()->type());
 350   mock_peer_connection_->local_description()->ToString(&sdp_string);
 351   EXPECT_EQ(kDummySdp, sdp_string);
 352 }
 353
 354 TEST_F(RTCPeerConnectionHandlerTest, setRemoteDescription) {
 355   blink::WebRTCVoidRequest request;
 356   blink::WebRTCSessionDescription description;
 357   description.initialize(kDummySdpType, kDummySdp);
 358
 359   // PeerConnectionTracker::TrackSetSessionDescription is expected to be called
 360   // before |mock_peer_connection| is called.
 361   testing::InSequence sequence;
 362   EXPECT_CALL(*mock_tracker_.get(),
 363               TrackSetSessionDescription(pc_handler_.get(), Ref(description),
 364                                          PeerConnectionTracker::SOURCE_REMOTE));
 365   EXPECT_CALL(*mock_peer_connection_, SetRemoteDescription(_, _));
 366
 367   pc_handler_->setRemoteDescription(request, description);
 368   EXPECT_EQ(description.type(), pc_handler_->remoteDescription().type());
 369   EXPECT_EQ(description.sdp(), pc_handler_->remoteDescription().sdp());
 370
 371   std::string sdp_string;
 372   ASSERT_TRUE(mock_peer_connection_->remote_description() != NULL);
 373   EXPECT_EQ(kDummySdpType, mock_peer_connection_->remote_description()->type());
 374   mock_peer_connection_->remote_description()->ToString(&sdp_string);
 375   EXPECT_EQ(kDummySdp, sdp_string);
 376 }
 377
 378 TEST_F(RTCPeerConnectionHandlerTest, updateICE) {
 379   blink::WebRTCConfiguration config;
 380   blink::WebMediaConstraints constraints;
 381
 382   EXPECT_CALL(*mock_tracker_.get(), TrackUpdateIce(pc_handler_.get(), _, _));
 383   // TODO(perkj): Test that the parameters in |config| can be translated when a
 384   // WebRTCConfiguration can be constructed. It's WebKit class and can't be
 385   // initialized from a test.
 386   EXPECT_TRUE(pc_handler_->updateICE(config, constraints));
 387 }
 388
 389 TEST_F(RTCPeerConnectionHandlerTest, addICECandidate) {
 390   blink::WebRTCICECandidate candidate;
 391   candidate.initialize(kDummySdp, "mid", 1);
 392
 393   EXPECT_CALL(*mock_tracker_.get(),
 394               TrackAddIceCandidate(pc_handler_.get(),
 395                                    testing::Ref(candidate),
 396                                    PeerConnectionTracker::SOURCE_REMOTE));
 397   EXPECT_TRUE(pc_handler_->addICECandidate(candidate));
 398   EXPECT_EQ(kDummySdp, mock_peer_connection_->ice_sdp());
 399   EXPECT_EQ(1, mock_peer_connection_->sdp_mline_index());
 400   EXPECT_EQ("mid", mock_peer_connection_->sdp_mid());
 401 }
 402
 403 TEST_F(RTCPeerConnectionHandlerTest, addAndRemoveStream) {
 404   std::string stream_label = "local_stream";
 405   blink::WebMediaStream local_stream(
 406       CreateLocalMediaStream(stream_label));
 407   blink::WebMediaConstraints constraints;
 408
 409   EXPECT_CALL(*mock_tracker_.get(),
 410               TrackAddStream(pc_handler_.get(),
 411                              testing::Ref(local_stream),
 412                              PeerConnectionTracker::SOURCE_LOCAL));
 413   EXPECT_CALL(*mock_tracker_.get(),
 414               TrackRemoveStream(pc_handler_.get(),
 415                                 testing::Ref(local_stream),
 416                                 PeerConnectionTracker::SOURCE_LOCAL));
 417   EXPECT_TRUE(pc_handler_->addStream(local_stream, constraints));
 418   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
 419   EXPECT_EQ(1u,
 420       mock_peer_connection_->local_streams()->at(0)->GetAudioTracks().size());
 421   EXPECT_EQ(1u,
 422       mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
 423
 424   pc_handler_->removeStream(local_stream);
 425   EXPECT_EQ(0u, mock_peer_connection_->local_streams()->count());
 426 }
 427
 428 TEST_F(RTCPeerConnectionHandlerTest, addStreamWithStoppedAudioAndVideoTrack) {
 429   std::string stream_label = "local_stream";
 430   blink::WebMediaStream local_stream(
 431       CreateLocalMediaStream(stream_label));
 432   blink::WebMediaConstraints constraints;
 433
 434   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
 435   local_stream.audioTracks(audio_tracks);
 436   MediaStreamAudioSource* native_audio_source =
 437       static_cast<MediaStreamAudioSource*>(
 438           audio_tracks[0].source().extraData());
 439   native_audio_source->StopSource();
 440
 441   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
 442   local_stream.videoTracks(video_tracks);
 443   MediaStreamVideoSource* native_video_source =
 444       static_cast<MediaStreamVideoSource*>(
 445           video_tracks[0].source().extraData());
 446   native_video_source->StopSource();
 447
 448   EXPECT_TRUE(pc_handler_->addStream(local_stream, constraints));
 449   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
 450   EXPECT_EQ(
 451       1u,
 452       mock_peer_connection_->local_streams()->at(0)->GetAudioTracks().size());
 453   EXPECT_EQ(
 454       1u,
 455       mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
 456 }
 457
 458 TEST_F(RTCPeerConnectionHandlerTest, GetStatsNoSelector) {
 459   scoped_refptr<MockRTCStatsRequest> request(
 460       new talk_base::RefCountedObject<MockRTCStatsRequest>());
 461   pc_handler_->getStats(request.get());
 462   // Note that callback gets executed synchronously by mock.
 463   ASSERT_TRUE(request->result());
 464   EXPECT_LT(1, request->result()->report_count());
 465 }
 466
 467 TEST_F(RTCPeerConnectionHandlerTest, GetStatsAfterClose) {
 468   scoped_refptr<MockRTCStatsRequest> request(
 469       new talk_base::RefCountedObject<MockRTCStatsRequest>());
 470   pc_handler_->stop();
 471   pc_handler_->getStats(request.get());
 472   // Note that callback gets executed synchronously by mock.
 473   ASSERT_TRUE(request->result());
 474   EXPECT_LT(1, request->result()->report_count());
 475 }
 476
 477 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithLocalSelector) {
 478   blink::WebMediaStream local_stream(
 479       CreateLocalMediaStream("local_stream"));
 480   blink::WebMediaConstraints constraints;
 481   pc_handler_->addStream(local_stream, constraints);
 482   blink::WebVector<blink::WebMediaStreamTrack> tracks;
 483   local_stream.audioTracks(tracks);
 484   ASSERT_LE(1ul, tracks.size());
 485
 486   scoped_refptr<MockRTCStatsRequest> request(
 487       new talk_base::RefCountedObject<MockRTCStatsRequest>());
 488   request->setSelector(tracks[0]);
 489   pc_handler_->getStats(request.get());
 490   EXPECT_EQ(1, request->result()->report_count());
 491 }
 492
 493 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithRemoteSelector) {
 494   scoped_refptr<webrtc::MediaStreamInterface> stream(
 495       AddRemoteMockMediaStream("remote_stream", "video", "audio"));
 496   pc_handler_->OnAddStream(stream.get());
 497   const blink::WebMediaStream& remote_stream = mock_client_->remote_stream();
 498
 499   blink::WebVector<blink::WebMediaStreamTrack> tracks;
 500   remote_stream.audioTracks(tracks);
 501   ASSERT_LE(1ul, tracks.size());
 502
 503   scoped_refptr<MockRTCStatsRequest> request(
 504       new talk_base::RefCountedObject<MockRTCStatsRequest>());
 505   request->setSelector(tracks[0]);
 506   pc_handler_->getStats(request.get());
 507   EXPECT_EQ(1, request->result()->report_count());
 508 }
 509
 510 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithBadSelector) {
 511   // The setup is the same as GetStatsWithLocalSelector, but the stream is not
 512   // added to the PeerConnection.
 513   blink::WebMediaStream local_stream(
 514       CreateLocalMediaStream("local_stream_2"));
 515   blink::WebMediaConstraints constraints;
 516   blink::WebVector<blink::WebMediaStreamTrack> tracks;
 517
 518   local_stream.audioTracks(tracks);
 519   blink::WebMediaStreamTrack component = tracks[0];
 520   mock_peer_connection_->SetGetStatsResult(false);
 521
 522   scoped_refptr<MockRTCStatsRequest> request(
 523       new talk_base::RefCountedObject<MockRTCStatsRequest>());
 524   request->setSelector(component);
 525   pc_handler_->getStats(request.get());
 526   EXPECT_EQ(0, request->result()->report_count());
 527 }
 528
 529 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
 530   testing::InSequence sequence;
 531
 532   webrtc::PeerConnectionInterface::SignalingState new_state =
 533       webrtc::PeerConnectionInterface::kHaveRemoteOffer;
 534   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
 535       pc_handler_.get(),
 536       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
 537   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
 538       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
 539   pc_handler_->OnSignalingChange(new_state);
 540
 541   new_state = webrtc::PeerConnectionInterface::kHaveLocalPrAnswer;
 542   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
 543       pc_handler_.get(),
 544       WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalPrAnswer));
 545   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
 546       WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalPrAnswer));
 547   pc_handler_->OnSignalingChange(new_state);
 548
 549   new_state = webrtc::PeerConnectionInterface::kHaveLocalOffer;
 550   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
 551       pc_handler_.get(),
 552       WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalOffer));
 553   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
 554       WebRTCPeerConnectionHandlerClient::SignalingStateHaveLocalOffer));
 555   pc_handler_->OnSignalingChange(new_state);
 556
 557   new_state = webrtc::PeerConnectionInterface::kHaveRemotePrAnswer;
 558   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
 559       pc_handler_.get(),
 560       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemotePrAnswer));
 561   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
 562       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemotePrAnswer));
 563   pc_handler_->OnSignalingChange(new_state);
 564
 565   new_state = webrtc::PeerConnectionInterface::kClosed;
 566   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
 567       pc_handler_.get(),
 568       WebRTCPeerConnectionHandlerClient::SignalingStateClosed));
 569   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
 570       WebRTCPeerConnectionHandlerClient::SignalingStateClosed));
 571   pc_handler_->OnSignalingChange(new_state);
 572 }
 573
 574 TEST_F(RTCPeerConnectionHandlerTest, OnIceConnectionChange) {
 575   testing::InSequence sequence;
 576
 577   webrtc::PeerConnectionInterface::IceConnectionState new_state =
 578       webrtc::PeerConnectionInterface::kIceConnectionNew;
 579   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 580       pc_handler_.get(),
 581       WebRTCPeerConnectionHandlerClient::ICEConnectionStateStarting));
 582   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 583       WebRTCPeerConnectionHandlerClient::ICEConnectionStateStarting));
 584   pc_handler_->OnIceConnectionChange(new_state);
 585
 586   new_state = webrtc::PeerConnectionInterface::kIceConnectionChecking;
 587   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 588       pc_handler_.get(),
 589       WebRTCPeerConnectionHandlerClient::ICEConnectionStateChecking));
 590   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 591       WebRTCPeerConnectionHandlerClient::ICEConnectionStateChecking));
 592   pc_handler_->OnIceConnectionChange(new_state);
 593
 594   new_state = webrtc::PeerConnectionInterface::kIceConnectionConnected;
 595   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 596       pc_handler_.get(),
 597       WebRTCPeerConnectionHandlerClient::ICEConnectionStateConnected));
 598   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 599       WebRTCPeerConnectionHandlerClient::ICEConnectionStateConnected));
 600   pc_handler_->OnIceConnectionChange(new_state);
 601
 602   new_state = webrtc::PeerConnectionInterface::kIceConnectionCompleted;
 603   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 604       pc_handler_.get(),
 605       WebRTCPeerConnectionHandlerClient::ICEConnectionStateCompleted));
 606   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 607       WebRTCPeerConnectionHandlerClient::ICEConnectionStateCompleted));
 608   pc_handler_->OnIceConnectionChange(new_state);
 609
 610   new_state = webrtc::PeerConnectionInterface::kIceConnectionFailed;
 611   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 612       pc_handler_.get(),
 613       WebRTCPeerConnectionHandlerClient::ICEConnectionStateFailed));
 614   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 615       WebRTCPeerConnectionHandlerClient::ICEConnectionStateFailed));
 616   pc_handler_->OnIceConnectionChange(new_state);
 617
 618   new_state = webrtc::PeerConnectionInterface::kIceConnectionDisconnected;
 619   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 620       pc_handler_.get(),
 621       WebRTCPeerConnectionHandlerClient::ICEConnectionStateDisconnected));
 622   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 623       WebRTCPeerConnectionHandlerClient::ICEConnectionStateDisconnected));
 624   pc_handler_->OnIceConnectionChange(new_state);
 625
 626   new_state = webrtc::PeerConnectionInterface::kIceConnectionClosed;
 627   EXPECT_CALL(*mock_tracker_.get(), TrackIceConnectionStateChange(
 628       pc_handler_.get(),
 629       WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed));
 630   EXPECT_CALL(*mock_client_.get(), didChangeICEConnectionState(
 631       WebRTCPeerConnectionHandlerClient::ICEConnectionStateClosed));
 632   pc_handler_->OnIceConnectionChange(new_state);
 633 }
 634
 635 TEST_F(RTCPeerConnectionHandlerTest, OnIceGatheringChange) {
 636   testing::InSequence sequence;
 637   EXPECT_CALL(*mock_tracker_.get(), TrackIceGatheringStateChange(
 638       pc_handler_.get(),
 639       WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew));
 640   EXPECT_CALL(*mock_client_.get(), didChangeICEGatheringState(
 641       WebRTCPeerConnectionHandlerClient::ICEGatheringStateNew));
 642   EXPECT_CALL(*mock_tracker_.get(), TrackIceGatheringStateChange(
 643       pc_handler_.get(),
 644       WebRTCPeerConnectionHandlerClient::ICEGatheringStateGathering));
 645   EXPECT_CALL(*mock_client_.get(), didChangeICEGatheringState(
 646       WebRTCPeerConnectionHandlerClient::ICEGatheringStateGathering));
 647   EXPECT_CALL(*mock_tracker_.get(), TrackIceGatheringStateChange(
 648       pc_handler_.get(),
 649       WebRTCPeerConnectionHandlerClient::ICEGatheringStateComplete));
 650   EXPECT_CALL(*mock_client_.get(), didChangeICEGatheringState(
 651       WebRTCPeerConnectionHandlerClient::ICEGatheringStateComplete));
 652
 653   webrtc::PeerConnectionInterface::IceGatheringState new_state =
 654         webrtc::PeerConnectionInterface::kIceGatheringNew;
 655   pc_handler_->OnIceGatheringChange(new_state);
 656
 657   new_state = webrtc::PeerConnectionInterface::kIceGatheringGathering;
 658   pc_handler_->OnIceGatheringChange(new_state);
 659
 660   new_state = webrtc::PeerConnectionInterface::kIceGatheringComplete;
 661   pc_handler_->OnIceGatheringChange(new_state);
 662
 663   // Check NULL candidate after ice gathering is completed.
 664   EXPECT_EQ("", mock_client_->candidate_mid());
 665   EXPECT_EQ(-1, mock_client_->candidate_mlineindex());
 666   EXPECT_EQ("", mock_client_->candidate_sdp());
 667 }
 668
 669 TEST_F(RTCPeerConnectionHandlerTest, OnAddAndOnRemoveStream) {
 670   std::string remote_stream_label("remote_stream");
 671   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
 672       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 673
 674   testing::InSequence sequence;
 675   EXPECT_CALL(*mock_tracker_.get(), TrackAddStream(
 676       pc_handler_.get(),
 677       testing::Property(&blink::WebMediaStream::id,
 678                         base::UTF8ToUTF16(remote_stream_label)),
 679       PeerConnectionTracker::SOURCE_REMOTE));
 680   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
 681       testing::Property(&blink::WebMediaStream::id,
 682                         base::UTF8ToUTF16(remote_stream_label))));
 683
 684   EXPECT_CALL(*mock_tracker_.get(), TrackRemoveStream(
 685       pc_handler_.get(),
 686       testing::Property(&blink::WebMediaStream::id,
 687                         base::UTF8ToUTF16(remote_stream_label)),
 688       PeerConnectionTracker::SOURCE_REMOTE));
 689   EXPECT_CALL(*mock_client_.get(), didRemoveRemoteStream(
 690       testing::Property(&blink::WebMediaStream::id,
 691                         base::UTF8ToUTF16(remote_stream_label))));
 692
 693   pc_handler_->OnAddStream(remote_stream.get());
 694   pc_handler_->OnRemoveStream(remote_stream.get());
 695 }
 696
 697 // This test that WebKit is notified about remote track state changes.
 698 TEST_F(RTCPeerConnectionHandlerTest, RemoteTrackState) {
 699   std::string remote_stream_label("remote_stream");
 700   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
 701       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 702
 703   testing::InSequence sequence;
 704   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
 705       testing::Property(&blink::WebMediaStream::id,
 706                         base::UTF8ToUTF16(remote_stream_label))));
 707   pc_handler_->OnAddStream(remote_stream.get());
 708   const blink::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 709
 710   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
 711   webkit_stream.audioTracks(audio_tracks);
 712   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive,
 713             audio_tracks[0].source().readyState());
 714
 715   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
 716     webkit_stream.videoTracks(video_tracks);
 717   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive,
 718             video_tracks[0].source().readyState());
 719
 720   remote_stream->GetAudioTracks()[0]->set_state(
 721       webrtc::MediaStreamTrackInterface::kEnded);
 722   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded,
 723             audio_tracks[0].source().readyState());
 724
 725   remote_stream->GetVideoTracks()[0]->set_state(
 726       webrtc::MediaStreamTrackInterface::kEnded);
 727   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded,
 728             video_tracks[0].source().readyState());
 729 }
 730
 731 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddAudioTrackFromRemoteStream) {
 732   std::string remote_stream_label("remote_stream");
 733   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
 734       AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
 735
 736   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
 737       testing::Property(&blink::WebMediaStream::id,
 738                         base::UTF8ToUTF16(remote_stream_label))));
 739   pc_handler_->OnAddStream(remote_stream.get());
 740   const blink::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 741
 742   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
 743   webkit_stream.audioTracks(audio_tracks);
 744   EXPECT_EQ(1u, audio_tracks.size());
 745
 746   // Remove the Webrtc audio track from the Webrtc MediaStream.
 747   scoped_refptr<webrtc::AudioTrackInterface> webrtc_track =
 748       remote_stream->GetAudioTracks()[0].get();
 749   remote_stream->RemoveTrack(webrtc_track.get());
 750   blink::WebVector<blink::WebMediaStreamTrack> modified_audio_tracks1;
 751   webkit_stream.audioTracks(modified_audio_tracks1);
 752   EXPECT_EQ(0u, modified_audio_tracks1.size());
 753
 754   // Add the WebRtc audio track again.
 755   remote_stream->AddTrack(webrtc_track.get());
 756   blink::WebVector<blink::WebMediaStreamTrack> modified_audio_tracks2;
 757   webkit_stream.audioTracks(modified_audio_tracks2);
 758   EXPECT_EQ(1u, modified_audio_tracks2.size());
 759 }
 760
 761 TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddVideoTrackFromRemoteStream) {
 762   std::string remote_stream_label("remote_stream");
 763   scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
 764       AddRemoteMockMediaStream(remote_stream_label, "video", "video"));
 765
 766   EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
 767       testing::Property(&blink::WebMediaStream::id,
 768                         base::UTF8ToUTF16(remote_stream_label))));
 769   pc_handler_->OnAddStream(remote_stream.get());
 770   const blink::WebMediaStream& webkit_stream = mock_client_->remote_stream();
 771
 772   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
 773   webkit_stream.videoTracks(video_tracks);
 774   EXPECT_EQ(1u, video_tracks.size());
 775
 776   // Remove the Webrtc video track from the Webrtc MediaStream.
 777   scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
 778       remote_stream->GetVideoTracks()[0].get();
 779   remote_stream->RemoveTrack(webrtc_track.get());
 780   blink::WebVector<blink::WebMediaStreamTrack> modified_video_tracks1;
 781   webkit_stream.videoTracks(modified_video_tracks1);
 782   EXPECT_EQ(0u, modified_video_tracks1.size());
 783
 784   // Add the WebRtc video track again.
 785   remote_stream->AddTrack(webrtc_track.get());
 786   blink::WebVector<blink::WebMediaStreamTrack> modified_video_tracks2;
 787   webkit_stream.videoTracks(modified_video_tracks2);
 788   EXPECT_EQ(1u, modified_video_tracks2.size());
 789 }
 790
 791 TEST_F(RTCPeerConnectionHandlerTest, OnIceCandidate) {
 792   testing::InSequence sequence;
 793   EXPECT_CALL(*mock_tracker_.get(),
 794               TrackAddIceCandidate(pc_handler_.get(), _,
 795                                    PeerConnectionTracker::SOURCE_LOCAL));
 796   EXPECT_CALL(*mock_client_.get(), didGenerateICECandidate(_));
 797
 798   scoped_ptr<webrtc::IceCandidateInterface> native_candidate(
 799       mock_dependency_factory_->CreateIceCandidate("mid", 1, kDummySdp));
 800   pc_handler_->OnIceCandidate(native_candidate.get());
 801   EXPECT_EQ("mid", mock_client_->candidate_mid());
 802   EXPECT_EQ(1, mock_client_->candidate_mlineindex());
 803   EXPECT_EQ(kDummySdp, mock_client_->candidate_sdp());
 804 }
 805
 806 TEST_F(RTCPeerConnectionHandlerTest, OnRenegotiationNeeded) {
 807   testing::InSequence sequence;
 808   EXPECT_CALL(*mock_tracker_.get(),
 809               TrackOnRenegotiationNeeded(pc_handler_.get()));
 810   EXPECT_CALL(*mock_client_.get(), negotiationNeeded());
 811   pc_handler_->OnRenegotiationNeeded();
 812 }
 813
 814 TEST_F(RTCPeerConnectionHandlerTest, CreateDataChannel) {
 815   blink::WebString label = "d1";
 816   EXPECT_CALL(*mock_tracker_.get(),
 817               TrackCreateDataChannel(pc_handler_.get(),
 818                                      testing::NotNull(),
 819                                      PeerConnectionTracker::SOURCE_LOCAL));
 820   scoped_ptr<blink::WebRTCDataChannelHandler> channel(
 821       pc_handler_->createDataChannel("d1", blink::WebRTCDataChannelInit()));
 822   EXPECT_TRUE(channel.get() != NULL);
 823   EXPECT_EQ(label, channel->label());
 824 }
 825
 826 TEST_F(RTCPeerConnectionHandlerTest, CreateDtmfSender) {
 827   std::string stream_label = "local_stream";
 828   blink::WebMediaStream local_stream(CreateLocalMediaStream(stream_label));
 829   blink::WebMediaConstraints constraints;
 830   pc_handler_->addStream(local_stream, constraints);
 831
 832   blink::WebVector<blink::WebMediaStreamTrack> tracks;
 833   local_stream.videoTracks(tracks);
 834
 835   ASSERT_LE(1ul, tracks.size());
 836   EXPECT_FALSE(pc_handler_->createDTMFSender(tracks[0]));
 837
 838   local_stream.audioTracks(tracks);
 839   ASSERT_LE(1ul, tracks.size());
 840
 841   EXPECT_CALL(*mock_tracker_.get(),
 842               TrackCreateDTMFSender(pc_handler_.get(),
 843                                     testing::Ref(tracks[0])));
 844
 845   scoped_ptr<blink::WebRTCDTMFSenderHandler> sender(
 846       pc_handler_->createDTMFSender(tracks[0]));
 847   EXPECT_TRUE(sender.get());
 848 }
 849
 850 }  // namespace content