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