Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/talk/session/media/channel_unittest.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 100.5 KB
Line 
1// libjingle
2// Copyright 2009 Google Inc.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are met:
6//
7//  1. Redistributions of source code must retain the above copyright notice,
8//     this list of conditions and the following disclaimer.
9//  2. Redistributions in binary form must reproduce the above copyright notice,
10//     this list of conditions and the following disclaimer in the documentation
11//     and/or other materials provided with the distribution.
12//  3. The name of the author may not be used to endorse or promote products
13//     derived from this software without specific prior written permission.
14//
15// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
16// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
17// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
18// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
24// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25
26#include "talk/base/fileutils.h"
27#include "talk/base/gunit.h"
28#include "talk/base/helpers.h"
29#include "talk/base/logging.h"
30#include "talk/base/pathutils.h"
31#include "talk/base/signalthread.h"
32#include "talk/base/ssladapter.h"
33#include "talk/base/sslidentity.h"
34#include "talk/base/window.h"
35#include "talk/media/base/fakemediaengine.h"
36#include "talk/media/base/fakertp.h"
37#include "talk/media/base/fakevideocapturer.h"
38#include "talk/media/base/mediachannel.h"
39#include "talk/media/base/rtpdump.h"
40#include "talk/media/base/screencastid.h"
41#include "talk/media/base/testutils.h"
42#include "talk/p2p/base/fakesession.h"
43#include "talk/session/media/channel.h"
44#include "talk/session/media/mediamessages.h"
45#include "talk/session/media/mediarecorder.h"
46#include "talk/session/media/mediasessionclient.h"
47#include "talk/session/media/typingmonitor.h"
48
49#define MAYBE_SKIP_TEST(feature)                    \
50  if (!(talk_base::SSLStreamAdapter::feature())) {  \
51    LOG(LS_INFO) << "Feature disabled... skipping"; \
52    return;                                         \
53  }
54
55using cricket::CA_OFFER;
56using cricket::CA_PRANSWER;
57using cricket::CA_ANSWER;
58using cricket::CA_UPDATE;
59using cricket::FakeVoiceMediaChannel;
60using cricket::ScreencastId;
61using cricket::StreamParams;
62using cricket::TransportChannel;
63using talk_base::WindowId;
64
65static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1, 0);
66static const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1, 0);
67static const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1, 0);
68static const cricket::VideoCodec kH264Codec(97, "H264", 640, 400, 30, 0);
69static const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC", 320, 200, 15, 0);
70static const cricket::DataCodec kGoogleDataCodec(101, "google-data", 0);
71static const uint32 kSsrc1 = 0x1111;
72static const uint32 kSsrc2 = 0x2222;
73static const uint32 kSsrc3 = 0x3333;
74static const char kCName[] = "a@b.com";
75
76template<class ChannelT,
77         class MediaChannelT,
78         class ContentT,
79         class CodecT,
80         class MediaInfoT>
81class Traits {
82 public:
83  typedef ChannelT Channel;
84  typedef MediaChannelT MediaChannel;
85  typedef ContentT Content;
86  typedef CodecT Codec;
87  typedef MediaInfoT MediaInfo;
88};
89
90class FakeScreenCaptureFactory
91    : public cricket::VideoChannel::ScreenCapturerFactory,
92      public sigslot::has_slots<> {
93 public:
94  FakeScreenCaptureFactory()
95      : window_capturer_(NULL),
96        capture_state_(cricket::CS_STOPPED) {}
97
98  virtual cricket::VideoCapturer* CreateScreenCapturer(
99      const ScreencastId& window) {
100    if (window_capturer_ != NULL) {
101      // Class is only designed to handle one fake screencapturer.
102      ADD_FAILURE();
103      return NULL;
104    }
105    window_capturer_ = new cricket::FakeVideoCapturer;
106    window_capturer_->SignalDestroyed.connect(
107        this,
108        &FakeScreenCaptureFactory::OnWindowCapturerDestroyed);
109    window_capturer_->SignalStateChange.connect(
110        this,
111        &FakeScreenCaptureFactory::OnStateChange);
112    return window_capturer_;
113  }
114
115  cricket::FakeVideoCapturer* window_capturer() { return window_capturer_; }
116
117  cricket::CaptureState capture_state() { return capture_state_; }
118
119 private:
120  void OnWindowCapturerDestroyed(cricket::FakeVideoCapturer* capturer) {
121    if (capturer == window_capturer_) {
122      window_capturer_ = NULL;
123    }
124  }
125  void OnStateChange(cricket::VideoCapturer*, cricket::CaptureState state) {
126    capture_state_ = state;
127  }
128
129  cricket::FakeVideoCapturer* window_capturer_;
130  cricket::CaptureState capture_state_;
131};
132
133// Controls how long we wait for a session to send messages that we
134// expect, in milliseconds.  We put it high to avoid flaky tests.
135static const int kEventTimeout = 5000;
136
137class VoiceTraits : public Traits<cricket::VoiceChannel,
138                                  cricket::FakeVoiceMediaChannel,
139                                  cricket::AudioContentDescription,
140                                  cricket::AudioCodec,
141                                  cricket::VoiceMediaInfo> {
142};
143
144class VideoTraits : public Traits<cricket::VideoChannel,
145                                  cricket::FakeVideoMediaChannel,
146                                  cricket::VideoContentDescription,
147                                  cricket::VideoCodec,
148                                  cricket::VideoMediaInfo> {
149};
150
151class DataTraits : public Traits<cricket::DataChannel,
152                                 cricket::FakeDataMediaChannel,
153                                 cricket::DataContentDescription,
154                                 cricket::DataCodec,
155                                 cricket::DataMediaInfo> {
156};
157
158
159talk_base::StreamInterface* Open(const std::string& path) {
160  return talk_base::Filesystem::OpenFile(
161      talk_base::Pathname(path), "wb");
162}
163
164// Base class for Voice/VideoChannel tests
165template<class T>
166class ChannelTest : public testing::Test, public sigslot::has_slots<> {
167 public:
168  enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8,
169               DTLS = 0x10 };
170
171  ChannelTest(const uint8* rtp_data, int rtp_len,
172              const uint8* rtcp_data, int rtcp_len)
173      : session1_(true),
174        session2_(false),
175        media_channel1_(NULL),
176        media_channel2_(NULL),
177        rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
178        rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
179        media_info_callbacks1_(),
180        media_info_callbacks2_(),
181        mute_callback_recved_(false),
182        mute_callback_value_(false),
183        ssrc_(0),
184        error_(T::MediaChannel::ERROR_NONE) {
185  }
186
187  static void SetUpTestCase() {
188    talk_base::InitializeSSL();
189  }
190
191  static void TearDownTestCase() {
192    talk_base::CleanupSSL();
193  }
194
195  void CreateChannels(int flags1, int flags2) {
196    CreateChannels(new typename T::MediaChannel(NULL),
197                   new typename T::MediaChannel(NULL),
198                   flags1, flags2, talk_base::Thread::Current());
199  }
200  void CreateChannels(int flags) {
201     CreateChannels(new typename T::MediaChannel(NULL),
202                    new typename T::MediaChannel(NULL),
203                    flags, talk_base::Thread::Current());
204  }
205  void CreateChannels(int flags1, int flags2,
206                      talk_base::Thread* thread) {
207    CreateChannels(new typename T::MediaChannel(NULL),
208                   new typename T::MediaChannel(NULL),
209                   flags1, flags2, thread);
210  }
211  void CreateChannels(int flags,
212                      talk_base::Thread* thread) {
213    CreateChannels(new typename T::MediaChannel(NULL),
214                   new typename T::MediaChannel(NULL),
215                   flags, thread);
216  }
217  void CreateChannels(
218      typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
219      int flags1, int flags2, talk_base::Thread* thread) {
220    media_channel1_ = ch1;
221    media_channel2_ = ch2;
222    channel1_.reset(CreateChannel(thread, &media_engine_, ch1, &session1_,
223                                  (flags1 & RTCP) != 0));
224    channel2_.reset(CreateChannel(thread, &media_engine_, ch2, &session2_,
225                                  (flags2 & RTCP) != 0));
226    channel1_->SignalMediaMonitor.connect(
227        this, &ChannelTest<T>::OnMediaMonitor);
228    channel2_->SignalMediaMonitor.connect(
229        this, &ChannelTest<T>::OnMediaMonitor);
230    channel1_->SignalMediaError.connect(
231        this, &ChannelTest<T>::OnMediaChannelError);
232    channel2_->SignalMediaError.connect(
233        this, &ChannelTest<T>::OnMediaChannelError);
234    channel1_->SignalAutoMuted.connect(
235        this, &ChannelTest<T>::OnMediaMuted);
236    if ((flags1 & DTLS) && (flags2 & DTLS)) {
237      flags1 = (flags1 & ~SECURE);
238      flags2 = (flags2 & ~SECURE);
239    }
240    CreateContent(flags1, kPcmuCodec, kH264Codec,
241                  &local_media_content1_);
242    CreateContent(flags2, kPcmuCodec, kH264Codec,
243                  &local_media_content2_);
244    CopyContent(local_media_content1_, &remote_media_content1_);
245    CopyContent(local_media_content2_, &remote_media_content2_);
246
247    if (flags1 & DTLS) {
248      identity1_.reset(talk_base::SSLIdentity::Generate("session1"));
249      session1_.set_ssl_identity(identity1_.get());
250    }
251    if (flags2 & DTLS) {
252      identity2_.reset(talk_base::SSLIdentity::Generate("session2"));
253      session2_.set_ssl_identity(identity2_.get());
254    }
255
256    // Add stream information (SSRC) to the local content but not to the remote
257    // content. This means that we per default know the SSRC of what we send but
258    // not what we receive.
259    AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_);
260    AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_);
261
262    // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
263    if (flags1 & SSRC_MUX) {
264      AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_);
265    }
266    if (flags2 & SSRC_MUX) {
267      AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
268    }
269  }
270
271  void CreateChannels(
272      typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
273      int flags, talk_base::Thread* thread) {
274    media_channel1_ = ch1;
275    media_channel2_ = ch2;
276
277    channel1_.reset(CreateChannel(thread, &media_engine_, ch1, &session1_,
278                                  (flags & RTCP) != 0));
279    channel2_.reset(CreateChannel(thread, &media_engine_, ch2, &session1_,
280                                  (flags & RTCP) != 0));
281    channel1_->SignalMediaMonitor.connect(
282        this, &ChannelTest<T>::OnMediaMonitor);
283    channel2_->SignalMediaMonitor.connect(
284        this, &ChannelTest<T>::OnMediaMonitor);
285    channel2_->SignalMediaError.connect(
286        this, &ChannelTest<T>::OnMediaChannelError);
287    CreateContent(flags, kPcmuCodec, kH264Codec,
288                  &local_media_content1_);
289    CreateContent(flags, kPcmuCodec, kH264Codec,
290                  &local_media_content2_);
291    CopyContent(local_media_content1_, &remote_media_content1_);
292    CopyContent(local_media_content2_, &remote_media_content2_);
293    // Add stream information (SSRC) to the local content but not to the remote
294    // content. This means that we per default know the SSRC of what we send but
295    // not what we receive.
296    AddLegacyStreamInContent(kSsrc1, flags, &local_media_content1_);
297    AddLegacyStreamInContent(kSsrc2, flags, &local_media_content2_);
298
299    // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
300    if (flags & SSRC_MUX) {
301      AddLegacyStreamInContent(kSsrc1, flags, &remote_media_content1_);
302      AddLegacyStreamInContent(kSsrc2, flags, &remote_media_content2_);
303    }
304  }
305
306  typename T::Channel* CreateChannel(talk_base::Thread* thread,
307                                     cricket::MediaEngineInterface* engine,
308                                     typename T::MediaChannel* ch,
309                                     cricket::BaseSession* session,
310                                     bool rtcp) {
311    typename T::Channel* channel = new typename T::Channel(
312        thread, engine, ch, session, cricket::CN_AUDIO, rtcp);
313    if (!channel->Init()) {
314      delete channel;
315      channel = NULL;
316    }
317    return channel;
318  }
319
320  bool SendInitiate() {
321    bool result = channel1_->SetLocalContent(&local_media_content1_, CA_OFFER);
322    if (result) {
323      channel1_->Enable(true);
324      result = channel2_->SetRemoteContent(&remote_media_content1_, CA_OFFER);
325      if (result) {
326        session1_.Connect(&session2_);
327
328        result = channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER);
329      }
330    }
331    return result;
332  }
333
334  bool SendAccept() {
335    channel2_->Enable(true);
336    return channel1_->SetRemoteContent(&remote_media_content2_, CA_ANSWER);
337  }
338
339  bool SendOffer() {
340    bool result = channel1_->SetLocalContent(&local_media_content1_, CA_OFFER);
341    if (result) {
342      channel1_->Enable(true);
343      result = channel2_->SetRemoteContent(&remote_media_content1_, CA_OFFER);
344    }
345    return result;
346  }
347
348  bool SendProvisionalAnswer() {
349    bool result = channel2_->SetLocalContent(&local_media_content2_,
350                                             CA_PRANSWER);
351    if (result) {
352      channel2_->Enable(true);
353      result = channel1_->SetRemoteContent(&remote_media_content2_,
354                                           CA_PRANSWER);
355      session1_.Connect(&session2_);
356    }
357    return result;
358  }
359
360  bool SendFinalAnswer() {
361    bool result = channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER);
362    if (result)
363      result = channel1_->SetRemoteContent(&remote_media_content2_, CA_ANSWER);
364    return result;
365  }
366
367  bool SendTerminate() {
368    channel1_.reset();
369    channel2_.reset();
370    return true;
371  }
372
373  bool AddStream1(int id) {
374    return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
375  }
376  bool RemoveStream1(int id) {
377    return channel1_->RemoveRecvStream(id);
378  }
379
380  cricket::FakeTransport* GetTransport1() {
381    return session1_.GetTransport(channel1_->content_name());
382  }
383  cricket::FakeTransport* GetTransport2() {
384    return session2_.GetTransport(channel2_->content_name());
385  }
386
387  bool SendRtp1() {
388    return media_channel1_->SendRtp(rtp_packet_.c_str(),
389                                    static_cast<int>(rtp_packet_.size()));
390  }
391  bool SendRtp2() {
392    return media_channel2_->SendRtp(rtp_packet_.c_str(),
393                                    static_cast<int>(rtp_packet_.size()));
394  }
395  bool SendRtcp1() {
396    return media_channel1_->SendRtcp(rtcp_packet_.c_str(),
397                                     static_cast<int>(rtcp_packet_.size()));
398  }
399  bool SendRtcp2() {
400    return media_channel2_->SendRtcp(rtcp_packet_.c_str(),
401                                     static_cast<int>(rtcp_packet_.size()));
402  }
403  // Methods to send custom data.
404  bool SendCustomRtp1(uint32 ssrc, int sequence_number) {
405    std::string data(CreateRtpData(ssrc, sequence_number));
406    return media_channel1_->SendRtp(data.c_str(),
407                                    static_cast<int>(data.size()));
408  }
409  bool SendCustomRtp2(uint32 ssrc, int sequence_number) {
410    std::string data(CreateRtpData(ssrc, sequence_number));
411    return media_channel2_->SendRtp(data.c_str(),
412                                    static_cast<int>(data.size()));
413  }
414  bool SendCustomRtcp1(uint32 ssrc) {
415    std::string data(CreateRtcpData(ssrc));
416    return media_channel1_->SendRtcp(data.c_str(),
417                                     static_cast<int>(data.size()));
418  }
419  bool SendCustomRtcp2(uint32 ssrc) {
420    std::string data(CreateRtcpData(ssrc));
421    return media_channel2_->SendRtcp(data.c_str(),
422                                     static_cast<int>(data.size()));
423  }
424  bool CheckRtp1() {
425    return media_channel1_->CheckRtp(rtp_packet_.c_str(),
426                                     static_cast<int>(rtp_packet_.size()));
427  }
428  bool CheckRtp2() {
429    return media_channel2_->CheckRtp(rtp_packet_.c_str(),
430                                     static_cast<int>(rtp_packet_.size()));
431  }
432  bool CheckRtcp1() {
433    return media_channel1_->CheckRtcp(rtcp_packet_.c_str(),
434                                      static_cast<int>(rtcp_packet_.size()));
435  }
436  bool CheckRtcp2() {
437    return media_channel2_->CheckRtcp(rtcp_packet_.c_str(),
438                                      static_cast<int>(rtcp_packet_.size()));
439  }
440  // Methods to check custom data.
441  bool CheckCustomRtp1(uint32 ssrc, int sequence_number) {
442    std::string data(CreateRtpData(ssrc, sequence_number));
443    return media_channel1_->CheckRtp(data.c_str(),
444                                     static_cast<int>(data.size()));
445  }
446  bool CheckCustomRtp2(uint32 ssrc, int sequence_number) {
447    std::string data(CreateRtpData(ssrc, sequence_number));
448    return media_channel2_->CheckRtp(data.c_str(),
449                                     static_cast<int>(data.size()));
450  }
451  bool CheckCustomRtcp1(uint32 ssrc) {
452    std::string data(CreateRtcpData(ssrc));
453    return media_channel1_->CheckRtcp(data.c_str(),
454                                      static_cast<int>(data.size()));
455  }
456  bool CheckCustomRtcp2(uint32 ssrc) {
457    std::string data(CreateRtcpData(ssrc));
458    return media_channel2_->CheckRtcp(data.c_str(),
459                                      static_cast<int>(data.size()));
460  }
461  std::string CreateRtpData(uint32 ssrc, int sequence_number) {
462    std::string data(rtp_packet_);
463    // Set SSRC in the rtp packet copy.
464    talk_base::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
465    talk_base::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number);
466    return data;
467  }
468  std::string CreateRtcpData(uint32 ssrc) {
469    std::string data(rtcp_packet_);
470    // Set SSRC in the rtcp packet copy.
471    talk_base::SetBE32(const_cast<char*>(data.c_str()) + 4, ssrc);
472    return data;
473  }
474
475  bool CheckNoRtp1() {
476    return media_channel1_->CheckNoRtp();
477  }
478  bool CheckNoRtp2() {
479    return media_channel2_->CheckNoRtp();
480  }
481  bool CheckNoRtcp1() {
482    return media_channel1_->CheckNoRtcp();
483  }
484  bool CheckNoRtcp2() {
485    return media_channel2_->CheckNoRtcp();
486  }
487
488  void CreateContent(int flags,
489                     const cricket::AudioCodec& audio_codec,
490                     const cricket::VideoCodec& video_codec,
491                     typename T::Content* content) {
492    // overridden in specialized classes
493  }
494  void CopyContent(const typename T::Content& source,
495                   typename T::Content* content) {
496    // overridden in specialized classes
497  }
498
499  // Creates a cricket::SessionDescription with one MediaContent and one stream.
500  // kPcmuCodec is used as audio codec and kH264Codec is used as video codec.
501  cricket::SessionDescription* CreateSessionDescriptionWithStream(uint32 ssrc) {
502     typename T::Content content;
503     cricket::SessionDescription* sdesc = new cricket::SessionDescription();
504     CreateContent(SECURE, kPcmuCodec, kH264Codec, &content);
505     AddLegacyStreamInContent(ssrc, 0, &content);
506     sdesc->AddContent("DUMMY_CONTENT_NAME",
507                       cricket::NS_JINGLE_RTP, content.Copy());
508     return sdesc;
509  }
510
511  class CallThread : public talk_base::SignalThread {
512   public:
513    typedef bool (ChannelTest<T>::*Method)();
514    CallThread(ChannelTest<T>* obj, Method method, bool* result)
515        : obj_(obj),
516          method_(method),
517          result_(result) {
518      *result = false;
519    }
520    virtual void DoWork() {
521      bool result = (*obj_.*method_)();
522      if (result_) {
523        *result_ = result;
524      }
525    }
526   private:
527    ChannelTest<T>* obj_;
528    Method method_;
529    bool* result_;
530  };
531  void CallOnThread(typename CallThread::Method method, bool* result) {
532    CallThread* thread = new CallThread(this, method, result);
533    thread->Start();
534    thread->Release();
535  }
536
537  void CallOnThreadAndWaitForDone(typename CallThread::Method method,
538                                  bool* result) {
539    CallThread* thread = new CallThread(this, method, result);
540    thread->Start();
541    thread->Destroy(true);
542  }
543
544  bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) {
545    return false;  // overridden in specialized classes
546  }
547
548  void OnMediaMonitor(typename T::Channel* channel,
549                      const typename T::MediaInfo& info) {
550    if (channel == channel1_.get()) {
551      media_info_callbacks1_++;
552    } else if (channel == channel2_.get()) {
553      media_info_callbacks2_++;
554    }
555  }
556
557  void OnMediaChannelError(typename T::Channel* channel,
558                           uint32 ssrc,
559                           typename T::MediaChannel::Error error) {
560    ssrc_ = ssrc;
561    error_ = error;
562  }
563
564  void OnMediaMuted(cricket::BaseChannel* channel, bool muted) {
565    mute_callback_recved_ = true;
566    mute_callback_value_ = muted;
567  }
568
569  void AddLegacyStreamInContent(uint32 ssrc, int flags,
570                        typename T::Content* content) {
571    // Base implementation.
572  }
573
574  // Tests that can be used by derived classes.
575
576  // Basic sanity check.
577  void TestInit() {
578    CreateChannels(0, 0);
579    EXPECT_FALSE(channel1_->secure());
580    EXPECT_FALSE(media_channel1_->sending());
581    EXPECT_FALSE(media_channel1_->playout());
582    EXPECT_TRUE(media_channel1_->codecs().empty());
583    EXPECT_TRUE(media_channel1_->recv_streams().empty());
584    EXPECT_TRUE(media_channel1_->rtp_packets().empty());
585    EXPECT_TRUE(media_channel1_->rtcp_packets().empty());
586  }
587
588  // Test that SetLocalContent and SetRemoteContent properly configure
589  // the codecs.
590  void TestSetContents() {
591    CreateChannels(0, 0);
592    typename T::Content content;
593    CreateContent(0, kPcmuCodec, kH264Codec, &content);
594    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
595    EXPECT_EQ(0U, media_channel1_->codecs().size());
596    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
597    ASSERT_EQ(1U, media_channel1_->codecs().size());
598    EXPECT_TRUE(CodecMatches(content.codecs()[0],
599                             media_channel1_->codecs()[0]));
600  }
601
602  // Test that SetLocalContent and SetRemoteContent properly deals
603  // with an empty offer.
604  void TestSetContentsNullOffer() {
605    CreateChannels(0, 0);
606    typename T::Content content;
607    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
608    CreateContent(0, kPcmuCodec, kH264Codec, &content);
609    EXPECT_EQ(0U, media_channel1_->codecs().size());
610    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
611    ASSERT_EQ(1U, media_channel1_->codecs().size());
612    EXPECT_TRUE(CodecMatches(content.codecs()[0],
613                             media_channel1_->codecs()[0]));
614  }
615
616  // Test that SetLocalContent and SetRemoteContent properly set RTCP
617  // mux.
618  void TestSetContentsRtcpMux() {
619    CreateChannels(RTCP, RTCP);
620    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
621    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
622    typename T::Content content;
623    CreateContent(0, kPcmuCodec, kH264Codec, &content);
624    // Both sides agree on mux. Should no longer be a separate RTCP channel.
625    content.set_rtcp_mux(true);
626    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
627    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
628    EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
629    // Only initiator supports mux. Should still have a separate RTCP channel.
630    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER));
631    content.set_rtcp_mux(false);
632    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER));
633    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
634  }
635
636  // Test that SetLocalContent and SetRemoteContent properly set RTCP
637  // mux when a provisional answer is received.
638  void TestSetContentsRtcpMuxWithPrAnswer() {
639    CreateChannels(RTCP, RTCP);
640    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
641    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
642    typename T::Content content;
643    CreateContent(0, kPcmuCodec, kH264Codec, &content);
644    content.set_rtcp_mux(true);
645    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
646    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER));
647    EXPECT_TRUE(channel1_->rtcp_transport_channel() != NULL);
648    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
649    // Both sides agree on mux. Should no longer be a separate RTCP channel.
650    EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
651    // Only initiator supports mux. Should still have a separate RTCP channel.
652    EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER));
653    content.set_rtcp_mux(false);
654    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER));
655    EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER));
656    EXPECT_TRUE(channel2_->rtcp_transport_channel() != NULL);
657  }
658
659  // Test that SetLocalContent and SetRemoteContent properly set
660  // video options to the media channel.
661  void TestSetContentsVideoOptions() {
662    CreateChannels(0, 0);
663    typename T::Content content;
664    CreateContent(0, kPcmuCodec, kH264Codec, &content);
665    content.set_buffered_mode_latency(101);
666    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
667    EXPECT_EQ(0U, media_channel1_->codecs().size());
668    cricket::VideoOptions options;
669    ASSERT_TRUE(media_channel1_->GetOptions(&options));
670    int latency = 0;
671    EXPECT_TRUE(options.buffered_mode_latency.Get(&latency));
672    EXPECT_EQ(101, latency);
673    content.set_buffered_mode_latency(102);
674    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
675    ASSERT_EQ(1U, media_channel1_->codecs().size());
676    EXPECT_TRUE(CodecMatches(content.codecs()[0],
677                             media_channel1_->codecs()[0]));
678    ASSERT_TRUE(media_channel1_->GetOptions(&options));
679    EXPECT_TRUE(options.buffered_mode_latency.Get(&latency));
680    EXPECT_EQ(102, latency);
681  }
682
683  // Test that SetRemoteContent properly deals with a content update.
684  void TestSetRemoteContentUpdate() {
685    CreateChannels(0, 0);
686    typename T::Content content;
687    CreateContent(RTCP | RTCP_MUX | SECURE,
688                  kPcmuCodec, kH264Codec,
689                  &content);
690    EXPECT_EQ(0U, media_channel1_->codecs().size());
691    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
692    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
693    ASSERT_EQ(1U, media_channel1_->codecs().size());
694    EXPECT_TRUE(CodecMatches(content.codecs()[0],
695                             media_channel1_->codecs()[0]));
696    // Now update with other codecs.
697    typename T::Content update_content;
698    update_content.set_partial(true);
699    CreateContent(0, kIsacCodec, kH264SvcCodec,
700                  &update_content);
701    EXPECT_TRUE(channel1_->SetRemoteContent(&update_content, CA_UPDATE));
702    ASSERT_EQ(1U, media_channel1_->codecs().size());
703    EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
704                             media_channel1_->codecs()[0]));
705    // Now update without any codecs. This is ignored.
706    typename T::Content empty_content;
707    empty_content.set_partial(true);
708    EXPECT_TRUE(channel1_->SetRemoteContent(&empty_content, CA_UPDATE));
709    ASSERT_EQ(1U, media_channel1_->codecs().size());
710    EXPECT_TRUE(CodecMatches(update_content.codecs()[0],
711                             media_channel1_->codecs()[0]));
712  }
713
714  // Test that Add/RemoveStream properly forward to the media channel.
715  void TestStreams() {
716    CreateChannels(0, 0);
717    EXPECT_TRUE(AddStream1(1));
718    EXPECT_TRUE(AddStream1(2));
719    EXPECT_EQ(2U, media_channel1_->recv_streams().size());
720    EXPECT_TRUE(RemoveStream1(2));
721    EXPECT_EQ(1U, media_channel1_->recv_streams().size());
722    EXPECT_TRUE(RemoveStream1(1));
723    EXPECT_EQ(0U, media_channel1_->recv_streams().size());
724  }
725
726  // Test that SetLocalContent properly handles adding and removing StreamParams
727  // to the local content description.
728  // This test uses the CA_UPDATE action that don't require a full
729  // MediaContentDescription to do an update.
730  void TestUpdateStreamsInLocalContent() {
731    cricket::StreamParams stream1;
732    stream1.groupid = "group1";
733    stream1.id = "stream1";
734    stream1.ssrcs.push_back(kSsrc1);
735    stream1.cname = "stream1_cname";
736
737    cricket::StreamParams stream2;
738    stream2.groupid = "group2";
739    stream2.id = "stream2";
740    stream2.ssrcs.push_back(kSsrc2);
741    stream2.cname = "stream2_cname";
742
743    cricket::StreamParams stream3;
744    stream3.groupid = "group3";
745    stream3.id = "stream3";
746    stream3.ssrcs.push_back(kSsrc3);
747    stream3.cname = "stream3_cname";
748
749    CreateChannels(0, 0);
750    typename T::Content content1;
751    CreateContent(0, kPcmuCodec, kH264Codec, &content1);
752    content1.AddStream(stream1);
753    EXPECT_EQ(0u, media_channel1_->send_streams().size());
754    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER));
755
756    ASSERT_EQ(1u, media_channel1_->send_streams().size());
757    EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
758
759    // Update the local streams by adding another sending stream.
760    // Use a partial updated session description.
761    typename T::Content content2;
762    content2.AddStream(stream2);
763    content2.AddStream(stream3);
764    content2.set_partial(true);
765    EXPECT_TRUE(channel1_->SetLocalContent(&content2, CA_UPDATE));
766    ASSERT_EQ(3u, media_channel1_->send_streams().size());
767    EXPECT_EQ(stream1, media_channel1_->send_streams()[0]);
768    EXPECT_EQ(stream2, media_channel1_->send_streams()[1]);
769    EXPECT_EQ(stream3, media_channel1_->send_streams()[2]);
770
771    // Update the local streams by removing the first sending stream.
772    // This is done by removing all SSRCS for this particular stream.
773    typename T::Content content3;
774    stream1.ssrcs.clear();
775    content3.AddStream(stream1);
776    content3.set_partial(true);
777    EXPECT_TRUE(channel1_->SetLocalContent(&content3, CA_UPDATE));
778    ASSERT_EQ(2u, media_channel1_->send_streams().size());
779    EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
780    EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
781
782    // Update the local streams with a stream that does not change.
783    // THe update is ignored.
784    typename T::Content content4;
785    content4.AddStream(stream2);
786    content4.set_partial(true);
787    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_UPDATE));
788    ASSERT_EQ(2u, media_channel1_->send_streams().size());
789    EXPECT_EQ(stream2, media_channel1_->send_streams()[0]);
790    EXPECT_EQ(stream3, media_channel1_->send_streams()[1]);
791  }
792
793  // Test that SetRemoteContent properly handles adding and removing
794  // StreamParams to the remote content description.
795  // This test uses the CA_UPDATE action that don't require a full
796  // MediaContentDescription to do an update.
797  void TestUpdateStreamsInRemoteContent() {
798    cricket::StreamParams stream1;
799    stream1.id = "Stream1";
800    stream1.groupid = "1";
801    stream1.ssrcs.push_back(kSsrc1);
802    stream1.cname = "stream1_cname";
803
804    cricket::StreamParams stream2;
805    stream2.id = "Stream2";
806    stream2.groupid = "2";
807    stream2.ssrcs.push_back(kSsrc2);
808    stream2.cname = "stream2_cname";
809
810    cricket::StreamParams stream3;
811    stream3.id = "Stream3";
812    stream3.groupid = "3";
813    stream3.ssrcs.push_back(kSsrc3);
814    stream3.cname = "stream3_cname";
815
816    CreateChannels(0, 0);
817    typename T::Content content1;
818    CreateContent(0, kPcmuCodec, kH264Codec, &content1);
819    content1.AddStream(stream1);
820    EXPECT_EQ(0u, media_channel1_->recv_streams().size());
821    EXPECT_TRUE(channel1_->SetRemoteContent(&content1, CA_OFFER));
822
823    ASSERT_EQ(1u, media_channel1_->codecs().size());
824    ASSERT_EQ(1u, media_channel1_->recv_streams().size());
825    EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
826
827    // Update the remote streams by adding another sending stream.
828    // Use a partial updated session description.
829    typename T::Content content2;
830    content2.AddStream(stream2);
831    content2.AddStream(stream3);
832    content2.set_partial(true);
833    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_UPDATE));
834    ASSERT_EQ(3u, media_channel1_->recv_streams().size());
835    EXPECT_EQ(stream1, media_channel1_->recv_streams()[0]);
836    EXPECT_EQ(stream2, media_channel1_->recv_streams()[1]);
837    EXPECT_EQ(stream3, media_channel1_->recv_streams()[2]);
838
839    // Update the remote streams by removing the first stream.
840    // This is done by removing all SSRCS for this particular stream.
841    typename T::Content content3;
842    stream1.ssrcs.clear();
843    content3.AddStream(stream1);
844    content3.set_partial(true);
845    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_UPDATE));
846    ASSERT_EQ(2u, media_channel1_->recv_streams().size());
847    EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
848    EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
849
850    // Update the remote streams with a stream that does not change.
851    // The update is ignored.
852    typename T::Content content4;
853    content4.AddStream(stream2);
854    content4.set_partial(true);
855    EXPECT_TRUE(channel1_->SetRemoteContent(&content4, CA_UPDATE));
856    ASSERT_EQ(2u, media_channel1_->recv_streams().size());
857    EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
858    EXPECT_EQ(stream3, media_channel1_->recv_streams()[1]);
859  }
860
861  // Test that SetLocalContent and SetRemoteContent properly
862  // handles adding and removing StreamParams when the action is a full
863  // CA_OFFER / CA_ANSWER.
864  void TestChangeStreamParamsInContent() {
865    cricket::StreamParams stream1;
866    stream1.groupid = "group1";
867    stream1.id = "stream1";
868    stream1.ssrcs.push_back(kSsrc1);
869    stream1.cname = "stream1_cname";
870
871    cricket::StreamParams stream2;
872    stream2.groupid = "group1";
873    stream2.id = "stream2";
874    stream2.ssrcs.push_back(kSsrc2);
875    stream2.cname = "stream2_cname";
876
877    // Setup a call where channel 1 send |stream1| to channel 2.
878    CreateChannels(0, 0);
879    typename T::Content content1;
880    CreateContent(0, kPcmuCodec, kH264Codec, &content1);
881    content1.AddStream(stream1);
882    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER));
883    EXPECT_TRUE(channel1_->Enable(true));
884    EXPECT_EQ(1u, media_channel1_->send_streams().size());
885
886    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER));
887    EXPECT_EQ(1u, media_channel2_->recv_streams().size());
888    session1_.Connect(&session2_);
889
890    // Channel 2 do not send anything.
891    typename T::Content content2;
892    CreateContent(0, kPcmuCodec, kH264Codec, &content2);
893    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER));
894    EXPECT_EQ(0u, media_channel1_->recv_streams().size());
895    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER));
896    EXPECT_TRUE(channel2_->Enable(true));
897    EXPECT_EQ(0u, media_channel2_->send_streams().size());
898
899    EXPECT_TRUE(SendCustomRtp1(kSsrc1, 0));
900    EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
901
902    // Let channel 2 update the content by sending |stream2| and enable SRTP.
903    typename T::Content content3;
904    CreateContent(SECURE, kPcmuCodec, kH264Codec, &content3);
905    content3.AddStream(stream2);
906    EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER));
907    ASSERT_EQ(1u, media_channel2_->send_streams().size());
908    EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
909
910    EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER));
911    ASSERT_EQ(1u, media_channel1_->recv_streams().size());
912    EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
913
914    // Channel 1 replies but stop sending stream1.
915    typename T::Content content4;
916    CreateContent(SECURE, kPcmuCodec, kH264Codec, &content4);
917    EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER));
918    EXPECT_EQ(0u, media_channel1_->send_streams().size());
919
920    EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER));
921    EXPECT_EQ(0u, media_channel2_->recv_streams().size());
922
923    EXPECT_TRUE(channel1_->secure());
924    EXPECT_TRUE(channel2_->secure());
925    EXPECT_TRUE(SendCustomRtp2(kSsrc2, 0));
926    EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
927  }
928
929  // Test that we only start playout and sending at the right times.
930  void TestPlayoutAndSendingStates() {
931    CreateChannels(0, 0);
932    EXPECT_FALSE(media_channel1_->playout());
933    EXPECT_FALSE(media_channel1_->sending());
934    EXPECT_FALSE(media_channel2_->playout());
935    EXPECT_FALSE(media_channel2_->sending());
936    EXPECT_TRUE(channel1_->Enable(true));
937    EXPECT_FALSE(media_channel1_->playout());
938    EXPECT_FALSE(media_channel1_->sending());
939    EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_, CA_OFFER));
940    EXPECT_TRUE(media_channel1_->playout());
941    EXPECT_FALSE(media_channel1_->sending());
942    EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_, CA_OFFER));
943    EXPECT_FALSE(media_channel2_->playout());
944    EXPECT_FALSE(media_channel2_->sending());
945    EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_, CA_ANSWER));
946    EXPECT_FALSE(media_channel2_->playout());
947    EXPECT_FALSE(media_channel2_->sending());
948    session1_.Connect(&session2_);
949    EXPECT_TRUE(media_channel1_->playout());
950    EXPECT_FALSE(media_channel1_->sending());
951    EXPECT_FALSE(media_channel2_->playout());
952    EXPECT_FALSE(media_channel2_->sending());
953    EXPECT_TRUE(channel2_->Enable(true));
954    EXPECT_TRUE(media_channel2_->playout());
955    EXPECT_TRUE(media_channel2_->sending());
956    EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_, CA_ANSWER));
957    EXPECT_TRUE(media_channel1_->playout());
958    EXPECT_TRUE(media_channel1_->sending());
959  }
960
961  void TestMuteStream() {
962    CreateChannels(0, 0);
963    // Test that we can Mute the default channel even though the sending SSRC is
964    // unknown.
965    EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
966    EXPECT_TRUE(channel1_->MuteStream(0, true));
967    EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
968    EXPECT_TRUE(channel1_->MuteStream(0, false));
969    EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
970
971    // Test that we can not mute an unknown SSRC.
972    EXPECT_FALSE(channel1_->MuteStream(kSsrc1, true));
973
974    SendInitiate();
975    // After the local session description has been set, we can mute a stream
976    // with its SSRC.
977    EXPECT_TRUE(channel1_->MuteStream(kSsrc1, true));
978    EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
979    EXPECT_TRUE(channel1_->MuteStream(kSsrc1, false));
980    EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
981  }
982
983  // Test that changing the MediaContentDirection in the local and remote
984  // session description start playout and sending at the right time.
985  void TestMediaContentDirection() {
986    CreateChannels(0, 0);
987    typename T::Content content1;
988    CreateContent(0, kPcmuCodec, kH264Codec, &content1);
989    typename T::Content content2;
990    CreateContent(0, kPcmuCodec, kH264Codec, &content2);
991    // Set |content2| to be InActive.
992    content2.set_direction(cricket::MD_INACTIVE);
993
994    EXPECT_TRUE(channel1_->Enable(true));
995    EXPECT_TRUE(channel2_->Enable(true));
996    EXPECT_FALSE(media_channel1_->playout());
997    EXPECT_FALSE(media_channel1_->sending());
998    EXPECT_FALSE(media_channel2_->playout());
999    EXPECT_FALSE(media_channel2_->sending());
1000
1001    EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER));
1002    EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER));
1003    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER));
1004    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER));
1005    session1_.Connect(&session2_);
1006
1007    EXPECT_TRUE(media_channel1_->playout());
1008    EXPECT_FALSE(media_channel1_->sending());  // remote InActive
1009    EXPECT_FALSE(media_channel2_->playout());  // local InActive
1010    EXPECT_FALSE(media_channel2_->sending());  // local InActive
1011
1012    // Update |content2| to be RecvOnly.
1013    content2.set_direction(cricket::MD_RECVONLY);
1014    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER));
1015    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER));
1016
1017    EXPECT_TRUE(media_channel1_->playout());
1018    EXPECT_TRUE(media_channel1_->sending());
1019    EXPECT_TRUE(media_channel2_->playout());  // local RecvOnly
1020    EXPECT_FALSE(media_channel2_->sending());  // local RecvOnly
1021
1022    // Update |content2| to be SendRecv.
1023    content2.set_direction(cricket::MD_SENDRECV);
1024    EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER));
1025    EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER));
1026
1027    EXPECT_TRUE(media_channel1_->playout());
1028    EXPECT_TRUE(media_channel1_->sending());
1029    EXPECT_TRUE(media_channel2_->playout());
1030    EXPECT_TRUE(media_channel2_->sending());
1031  }
1032
1033  // Test setting up a call.
1034  void TestCallSetup() {
1035    CreateChannels(0, 0);
1036    EXPECT_FALSE(channel1_->secure());
1037    EXPECT_TRUE(SendInitiate());
1038    EXPECT_TRUE(media_channel1_->playout());
1039    EXPECT_FALSE(media_channel1_->sending());
1040    EXPECT_TRUE(SendAccept());
1041    EXPECT_FALSE(channel1_->secure());
1042    EXPECT_TRUE(media_channel1_->sending());
1043    EXPECT_EQ(1U, media_channel1_->codecs().size());
1044    EXPECT_TRUE(media_channel2_->playout());
1045    EXPECT_TRUE(media_channel2_->sending());
1046    EXPECT_EQ(1U, media_channel2_->codecs().size());
1047  }
1048
1049  // Test that we don't crash if packets are sent during call teardown
1050  // when RTCP mux is enabled. This is a regression test against a specific
1051  // race condition that would only occur when a RTCP packet was sent during
1052  // teardown of a channel on which RTCP mux was enabled.
1053  void TestCallTeardownRtcpMux() {
1054    class LastWordMediaChannel : public T::MediaChannel {
1055     public:
1056      LastWordMediaChannel() : T::MediaChannel(NULL) {}
1057      ~LastWordMediaChannel() {
1058        T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame));
1059        T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
1060      }
1061    };
1062    CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
1063                   RTCP | RTCP_MUX, RTCP | RTCP_MUX,
1064                   talk_base::Thread::Current());
1065    EXPECT_TRUE(SendInitiate());
1066    EXPECT_TRUE(SendAccept());
1067    EXPECT_TRUE(SendTerminate());
1068  }
1069
1070  // Send voice RTP data to the other side and ensure it gets there.
1071  void SendRtpToRtp() {
1072    CreateChannels(0, 0);
1073    EXPECT_TRUE(SendInitiate());
1074    EXPECT_TRUE(SendAccept());
1075    EXPECT_EQ(1U, GetTransport1()->channels().size());
1076    EXPECT_EQ(1U, GetTransport2()->channels().size());
1077    EXPECT_TRUE(SendRtp1());
1078    EXPECT_TRUE(SendRtp2());
1079    EXPECT_TRUE(CheckRtp1());
1080    EXPECT_TRUE(CheckRtp2());
1081    EXPECT_TRUE(CheckNoRtp1());
1082    EXPECT_TRUE(CheckNoRtp2());
1083  }
1084
1085  // Check that RTCP is not transmitted if both sides don't support RTCP.
1086  void SendNoRtcpToNoRtcp() {
1087    CreateChannels(0, 0);
1088    EXPECT_TRUE(SendInitiate());
1089    EXPECT_TRUE(SendAccept());
1090    EXPECT_EQ(1U, GetTransport1()->channels().size());
1091    EXPECT_EQ(1U, GetTransport2()->channels().size());
1092    EXPECT_FALSE(SendRtcp1());
1093    EXPECT_FALSE(SendRtcp2());
1094    EXPECT_TRUE(CheckNoRtcp1());
1095    EXPECT_TRUE(CheckNoRtcp2());
1096  }
1097
1098  // Check that RTCP is not transmitted if the callee doesn't support RTCP.
1099  void SendNoRtcpToRtcp() {
1100    CreateChannels(0, RTCP);
1101    EXPECT_TRUE(SendInitiate());
1102    EXPECT_TRUE(SendAccept());
1103    EXPECT_EQ(1U, GetTransport1()->channels().size());
1104    EXPECT_EQ(2U, GetTransport2()->channels().size());
1105    EXPECT_FALSE(SendRtcp1());
1106    EXPECT_FALSE(SendRtcp2());
1107    EXPECT_TRUE(CheckNoRtcp1());
1108    EXPECT_TRUE(CheckNoRtcp2());
1109  }
1110
1111  // Check that RTCP is not transmitted if the caller doesn't support RTCP.
1112  void SendRtcpToNoRtcp() {
1113    CreateChannels(RTCP, 0);
1114    EXPECT_TRUE(SendInitiate());
1115    EXPECT_TRUE(SendAccept());
1116    EXPECT_EQ(2U, GetTransport1()->channels().size());
1117    EXPECT_EQ(1U, GetTransport2()->channels().size());
1118    EXPECT_FALSE(SendRtcp1());
1119    EXPECT_FALSE(SendRtcp2());
1120    EXPECT_TRUE(CheckNoRtcp1());
1121    EXPECT_TRUE(CheckNoRtcp2());
1122  }
1123
1124  // Check that RTCP is transmitted if both sides support RTCP.
1125  void SendRtcpToRtcp() {
1126    CreateChannels(RTCP, RTCP);
1127    EXPECT_TRUE(SendInitiate());
1128    EXPECT_TRUE(SendAccept());
1129    EXPECT_EQ(2U, GetTransport1()->channels().size());
1130    EXPECT_EQ(2U, GetTransport2()->channels().size());
1131    EXPECT_TRUE(SendRtcp1());
1132    EXPECT_TRUE(SendRtcp2());
1133    EXPECT_TRUE(CheckRtcp1());
1134    EXPECT_TRUE(CheckRtcp2());
1135    EXPECT_TRUE(CheckNoRtcp1());
1136    EXPECT_TRUE(CheckNoRtcp2());
1137  }
1138
1139  // Check that RTCP is transmitted if only the initiator supports mux.
1140  void SendRtcpMuxToRtcp() {
1141    CreateChannels(RTCP | RTCP_MUX, RTCP);
1142    EXPECT_TRUE(SendInitiate());
1143    EXPECT_TRUE(SendAccept());
1144    EXPECT_EQ(2U, GetTransport1()->channels().size());
1145    EXPECT_EQ(2U, GetTransport2()->channels().size());
1146    EXPECT_TRUE(SendRtcp1());
1147    EXPECT_TRUE(SendRtcp2());
1148    EXPECT_TRUE(CheckRtcp1());
1149    EXPECT_TRUE(CheckRtcp2());
1150    EXPECT_TRUE(CheckNoRtcp1());
1151    EXPECT_TRUE(CheckNoRtcp2());
1152  }
1153
1154  // Check that RTP and RTCP are transmitted ok when both sides support mux.
1155  void SendRtcpMuxToRtcpMux() {
1156    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
1157    EXPECT_TRUE(SendInitiate());
1158    EXPECT_EQ(2U, GetTransport1()->channels().size());
1159    EXPECT_EQ(1U, GetTransport2()->channels().size());
1160    EXPECT_TRUE(SendAccept());
1161    EXPECT_EQ(1U, GetTransport1()->channels().size());
1162    EXPECT_TRUE(SendRtp1());
1163    EXPECT_TRUE(SendRtp2());
1164    EXPECT_TRUE(SendRtcp1());
1165    EXPECT_TRUE(SendRtcp2());
1166    EXPECT_TRUE(CheckRtp1());
1167    EXPECT_TRUE(CheckRtp2());
1168    EXPECT_TRUE(CheckNoRtp1());
1169    EXPECT_TRUE(CheckNoRtp2());
1170    EXPECT_TRUE(CheckRtcp1());
1171    EXPECT_TRUE(CheckRtcp2());
1172    EXPECT_TRUE(CheckNoRtcp1());
1173    EXPECT_TRUE(CheckNoRtcp2());
1174  }
1175
1176  // Check that RTCP data sent by the initiator before the accept is not muxed.
1177  void SendEarlyRtcpMuxToRtcp() {
1178    CreateChannels(RTCP | RTCP_MUX, RTCP);
1179    EXPECT_TRUE(SendInitiate());
1180    EXPECT_EQ(2U, GetTransport1()->channels().size());
1181    EXPECT_EQ(2U, GetTransport2()->channels().size());
1182
1183    // RTCP can be sent before the call is accepted, if the transport is ready.
1184    // It should not be muxed though, as the remote side doesn't support mux.
1185    EXPECT_TRUE(SendRtcp1());
1186    EXPECT_TRUE(CheckNoRtp2());
1187    EXPECT_TRUE(CheckRtcp2());
1188
1189    // Send RTCP packet from callee and verify that it is received.
1190    EXPECT_TRUE(SendRtcp2());
1191    EXPECT_TRUE(CheckNoRtp1());
1192    EXPECT_TRUE(CheckRtcp1());
1193
1194    // Complete call setup and ensure everything is still OK.
1195    EXPECT_TRUE(SendAccept());
1196    EXPECT_EQ(2U, GetTransport1()->channels().size());
1197    EXPECT_TRUE(SendRtcp1());
1198    EXPECT_TRUE(CheckRtcp2());
1199    EXPECT_TRUE(SendRtcp2());
1200    EXPECT_TRUE(CheckRtcp1());
1201  }
1202
1203
1204  // Check that RTCP data is not muxed until both sides have enabled muxing,
1205  // but that we properly demux before we get the accept message, since there
1206  // is a race between RTP data and the jingle accept.
1207  void SendEarlyRtcpMuxToRtcpMux() {
1208    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
1209    EXPECT_TRUE(SendInitiate());
1210    EXPECT_EQ(2U, GetTransport1()->channels().size());
1211    EXPECT_EQ(1U, GetTransport2()->channels().size());
1212
1213    // RTCP can't be sent yet, since the RTCP transport isn't writable, and
1214    // we haven't yet received the accept that says we should mux.
1215    EXPECT_FALSE(SendRtcp1());
1216
1217    // Send muxed RTCP packet from callee and verify that it is received.
1218    EXPECT_TRUE(SendRtcp2());
1219    EXPECT_TRUE(CheckNoRtp1());
1220    EXPECT_TRUE(CheckRtcp1());
1221
1222    // Complete call setup and ensure everything is still OK.
1223    EXPECT_TRUE(SendAccept());
1224    EXPECT_EQ(1U, GetTransport1()->channels().size());
1225    EXPECT_TRUE(SendRtcp1());
1226    EXPECT_TRUE(CheckRtcp2());
1227    EXPECT_TRUE(SendRtcp2());
1228    EXPECT_TRUE(CheckRtcp1());
1229  }
1230
1231  // Test that we properly send SRTP with RTCP in both directions.
1232  // You can pass in DTLS and/or RTCP_MUX as flags.
1233  void SendSrtpToSrtp(int flags1_in = 0, int flags2_in = 0) {
1234    ASSERT((flags1_in & ~(RTCP_MUX | DTLS)) == 0);
1235    ASSERT((flags2_in & ~(RTCP_MUX | DTLS)) == 0);
1236
1237    int flags1 = RTCP | SECURE | flags1_in;
1238    int flags2 = RTCP | SECURE | flags2_in;
1239    bool dtls1 = !!(flags1_in & DTLS);
1240    bool dtls2 = !!(flags2_in & DTLS);
1241    CreateChannels(flags1, flags2);
1242    EXPECT_FALSE(channel1_->secure());
1243    EXPECT_FALSE(channel2_->secure());
1244    EXPECT_TRUE(SendInitiate());
1245    EXPECT_TRUE_WAIT(channel1_->writable(), kEventTimeout);
1246    EXPECT_TRUE_WAIT(channel2_->writable(), kEventTimeout);
1247    EXPECT_TRUE(SendAccept());
1248    EXPECT_TRUE(channel1_->secure());
1249    EXPECT_TRUE(channel2_->secure());
1250    EXPECT_EQ(dtls1 && dtls2, channel1_->secure_dtls());
1251    EXPECT_EQ(dtls1 && dtls2, channel2_->secure_dtls());
1252    EXPECT_TRUE(SendRtp1());
1253    EXPECT_TRUE(SendRtp2());
1254    EXPECT_TRUE(SendRtcp1());
1255    EXPECT_TRUE(SendRtcp2());
1256    EXPECT_TRUE(CheckRtp1());
1257    EXPECT_TRUE(CheckRtp2());
1258    EXPECT_TRUE(CheckNoRtp1());
1259    EXPECT_TRUE(CheckNoRtp2());
1260    EXPECT_TRUE(CheckRtcp1());
1261    EXPECT_TRUE(CheckRtcp2());
1262    EXPECT_TRUE(CheckNoRtcp1());
1263    EXPECT_TRUE(CheckNoRtcp2());
1264  }
1265
1266  // Test that we properly handling SRTP negotiating down to RTP.
1267  void SendSrtpToRtp() {
1268    CreateChannels(RTCP | SECURE, RTCP);
1269    EXPECT_FALSE(channel1_->secure());
1270    EXPECT_FALSE(channel2_->secure());
1271    EXPECT_TRUE(SendInitiate());
1272    EXPECT_TRUE(SendAccept());
1273    EXPECT_FALSE(channel1_->secure());
1274    EXPECT_FALSE(channel2_->secure());
1275    EXPECT_TRUE(SendRtp1());
1276    EXPECT_TRUE(SendRtp2());
1277    EXPECT_TRUE(SendRtcp1());
1278    EXPECT_TRUE(SendRtcp2());
1279    EXPECT_TRUE(CheckRtp1());
1280    EXPECT_TRUE(CheckRtp2());
1281    EXPECT_TRUE(CheckNoRtp1());
1282    EXPECT_TRUE(CheckNoRtp2());
1283    EXPECT_TRUE(CheckRtcp1());
1284    EXPECT_TRUE(CheckRtcp2());
1285    EXPECT_TRUE(CheckNoRtcp1());
1286    EXPECT_TRUE(CheckNoRtcp2());
1287  }
1288
1289  // Test that we can send and receive early media when a provisional answer is
1290  // sent and received. The test uses SRTP, RTCP mux and SSRC mux.
1291  void SendEarlyMediaUsingRtcpMuxSrtp() {
1292      int sequence_number1_1 = 0, sequence_number2_2 = 0;
1293
1294      CreateChannels(SSRC_MUX | RTCP | RTCP_MUX | SECURE,
1295                     SSRC_MUX | RTCP | RTCP_MUX | SECURE);
1296      EXPECT_TRUE(SendOffer());
1297      EXPECT_TRUE(SendProvisionalAnswer());
1298      EXPECT_TRUE(channel1_->secure());
1299      EXPECT_TRUE(channel2_->secure());
1300      EXPECT_EQ(2U, GetTransport1()->channels().size());
1301      EXPECT_EQ(2U, GetTransport2()->channels().size());
1302      EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
1303      EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
1304      EXPECT_TRUE(SendCustomRtp1(kSsrc1, ++sequence_number1_1));
1305      EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
1306
1307      // Send packets from callee and verify that it is received.
1308      EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
1309      EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
1310      EXPECT_TRUE(SendCustomRtp2(kSsrc2, ++sequence_number2_2));
1311      EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1312
1313      // Complete call setup and ensure everything is still OK.
1314      EXPECT_TRUE(SendFinalAnswer());
1315      EXPECT_EQ(1U, GetTransport1()->channels().size());
1316      EXPECT_EQ(1U, GetTransport2()->channels().size());
1317      EXPECT_TRUE(channel1_->secure());
1318      EXPECT_TRUE(channel2_->secure());
1319      EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
1320      EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
1321      EXPECT_TRUE(SendCustomRtp1(kSsrc1, ++sequence_number1_1));
1322      EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
1323      EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
1324      EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
1325      EXPECT_TRUE(SendCustomRtp2(kSsrc2, ++sequence_number2_2));
1326      EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1327  }
1328
1329  // Test that we properly send RTP without SRTP from a thread.
1330  void SendRtpToRtpOnThread() {
1331    bool sent_rtp1, sent_rtp2, sent_rtcp1, sent_rtcp2;
1332    CreateChannels(RTCP, RTCP);
1333    EXPECT_TRUE(SendInitiate());
1334    EXPECT_TRUE(SendAccept());
1335    CallOnThread(&ChannelTest<T>::SendRtp1, &sent_rtp1);
1336    CallOnThread(&ChannelTest<T>::SendRtp2, &sent_rtp2);
1337    CallOnThread(&ChannelTest<T>::SendRtcp1, &sent_rtcp1);
1338    CallOnThread(&ChannelTest<T>::SendRtcp2, &sent_rtcp2);
1339    EXPECT_TRUE_WAIT(CheckRtp1(), 1000);
1340    EXPECT_TRUE_WAIT(CheckRtp2(), 1000);
1341    EXPECT_TRUE_WAIT(sent_rtp1, 1000);
1342    EXPECT_TRUE_WAIT(sent_rtp2, 1000);
1343    EXPECT_TRUE(CheckNoRtp1());
1344    EXPECT_TRUE(CheckNoRtp2());
1345    EXPECT_TRUE_WAIT(CheckRtcp1(), 1000);
1346    EXPECT_TRUE_WAIT(CheckRtcp2(), 1000);
1347    EXPECT_TRUE_WAIT(sent_rtcp1, 1000);
1348    EXPECT_TRUE_WAIT(sent_rtcp2, 1000);
1349    EXPECT_TRUE(CheckNoRtcp1());
1350    EXPECT_TRUE(CheckNoRtcp2());
1351  }
1352
1353  // Test that we properly send SRTP with RTCP from a thread.
1354  void SendSrtpToSrtpOnThread() {
1355    bool sent_rtp1, sent_rtp2, sent_rtcp1, sent_rtcp2;
1356    CreateChannels(RTCP | SECURE, RTCP | SECURE);
1357    EXPECT_TRUE(SendInitiate());
1358    EXPECT_TRUE(SendAccept());
1359    CallOnThread(&ChannelTest<T>::SendRtp1, &sent_rtp1);
1360    CallOnThread(&ChannelTest<T>::SendRtp2, &sent_rtp2);
1361    CallOnThread(&ChannelTest<T>::SendRtcp1, &sent_rtcp1);
1362    CallOnThread(&ChannelTest<T>::SendRtcp2, &sent_rtcp2);
1363    EXPECT_TRUE_WAIT(CheckRtp1(), 1000);
1364    EXPECT_TRUE_WAIT(CheckRtp2(), 1000);
1365    EXPECT_TRUE_WAIT(sent_rtp1, 1000);
1366    EXPECT_TRUE_WAIT(sent_rtp2, 1000);
1367    EXPECT_TRUE(CheckNoRtp1());
1368    EXPECT_TRUE(CheckNoRtp2());
1369    EXPECT_TRUE_WAIT(CheckRtcp1(), 1000);
1370    EXPECT_TRUE_WAIT(CheckRtcp2(), 1000);
1371    EXPECT_TRUE_WAIT(sent_rtcp1, 1000);
1372    EXPECT_TRUE_WAIT(sent_rtcp2, 1000);
1373    EXPECT_TRUE(CheckNoRtcp1());
1374    EXPECT_TRUE(CheckNoRtcp2());
1375  }
1376
1377  // Test that the mediachannel retains its sending state after the transport
1378  // becomes non-writable.
1379  void SendWithWritabilityLoss() {
1380    CreateChannels(0, 0);
1381    EXPECT_TRUE(SendInitiate());
1382    EXPECT_TRUE(SendAccept());
1383    EXPECT_EQ(1U, GetTransport1()->channels().size());
1384    EXPECT_EQ(1U, GetTransport2()->channels().size());
1385    EXPECT_TRUE(SendRtp1());
1386    EXPECT_TRUE(SendRtp2());
1387    EXPECT_TRUE(CheckRtp1());
1388    EXPECT_TRUE(CheckRtp2());
1389    EXPECT_TRUE(CheckNoRtp1());
1390    EXPECT_TRUE(CheckNoRtp2());
1391
1392    // Lose writability, which should fail.
1393    GetTransport1()->SetWritable(false);
1394    EXPECT_FALSE(SendRtp1());
1395    EXPECT_TRUE(SendRtp2());
1396    EXPECT_TRUE(CheckRtp1());
1397    EXPECT_TRUE(CheckNoRtp2());
1398
1399    // Regain writability
1400    GetTransport1()->SetWritable(true);
1401    EXPECT_TRUE(media_channel1_->sending());
1402    EXPECT_TRUE(SendRtp1());
1403    EXPECT_TRUE(SendRtp2());
1404    EXPECT_TRUE(CheckRtp1());
1405    EXPECT_TRUE(CheckRtp2());
1406    EXPECT_TRUE(CheckNoRtp1());
1407    EXPECT_TRUE(CheckNoRtp2());
1408
1409    // Lose writability completely
1410    GetTransport1()->SetDestination(NULL);
1411    EXPECT_TRUE(media_channel1_->sending());
1412
1413    // Should fail also.
1414    EXPECT_FALSE(SendRtp1());
1415    EXPECT_TRUE(SendRtp2());
1416    EXPECT_TRUE(CheckRtp1());
1417    EXPECT_TRUE(CheckNoRtp2());
1418
1419    // Gain writability back
1420    GetTransport1()->SetDestination(GetTransport2());
1421    EXPECT_TRUE(media_channel1_->sending());
1422    EXPECT_TRUE(SendRtp1());
1423    EXPECT_TRUE(SendRtp2());
1424    EXPECT_TRUE(CheckRtp1());
1425    EXPECT_TRUE(CheckRtp2());
1426    EXPECT_TRUE(CheckNoRtp1());
1427    EXPECT_TRUE(CheckNoRtp2());
1428  }
1429
1430  void SendSsrcMuxToSsrcMuxWithRtcpMux() {
1431    int sequence_number1_1 = 0, sequence_number2_2 = 0;
1432    CreateChannels(SSRC_MUX | RTCP | RTCP_MUX, SSRC_MUX | RTCP | RTCP_MUX);
1433    EXPECT_TRUE(SendInitiate());
1434    EXPECT_EQ(2U, GetTransport1()->channels().size());
1435    EXPECT_EQ(1U, GetTransport2()->channels().size());
1436    EXPECT_TRUE(SendAccept());
1437    EXPECT_EQ(1U, GetTransport1()->channels().size());
1438    EXPECT_EQ(1U, GetTransport2()->channels().size());
1439    EXPECT_TRUE(channel1_->ssrc_filter()->IsActive());
1440    // channel1 - should have media_content2 as remote. i.e. kSsrc2
1441    EXPECT_TRUE(channel1_->ssrc_filter()->FindStream(kSsrc2));
1442    EXPECT_TRUE(channel2_->ssrc_filter()->IsActive());
1443    // channel2 - should have media_content1 as remote. i.e. kSsrc1
1444    EXPECT_TRUE(channel2_->ssrc_filter()->FindStream(kSsrc1));
1445    EXPECT_TRUE(SendCustomRtp1(kSsrc1, ++sequence_number1_1));
1446    EXPECT_TRUE(SendCustomRtp2(kSsrc2, ++sequence_number2_2));
1447    EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
1448    EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
1449    EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1450    EXPECT_TRUE(CheckNoRtp1());
1451    EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
1452    EXPECT_TRUE(CheckNoRtp2());
1453    EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
1454    EXPECT_TRUE(CheckNoRtcp1());
1455    EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
1456    EXPECT_TRUE(CheckNoRtcp2());
1457  }
1458
1459  void SendSsrcMuxToSsrcMux() {
1460    int sequence_number1_1 = 0, sequence_number2_2 = 0;
1461    CreateChannels(SSRC_MUX | RTCP, SSRC_MUX | RTCP);
1462    EXPECT_TRUE(SendInitiate());
1463    EXPECT_EQ(2U, GetTransport1()->channels().size());
1464    EXPECT_EQ(2U, GetTransport2()->channels().size());
1465    EXPECT_TRUE(SendAccept());
1466    EXPECT_EQ(2U, GetTransport1()->channels().size());
1467    EXPECT_EQ(2U, GetTransport2()->channels().size());
1468    EXPECT_TRUE(channel1_->ssrc_filter()->IsActive());
1469    // channel1 - should have media_content2 as remote. i.e. kSsrc2
1470    EXPECT_TRUE(channel1_->ssrc_filter()->FindStream(kSsrc2));
1471    EXPECT_TRUE(channel2_->ssrc_filter()->IsActive());
1472    // channel2 - should have media_content1 as remote. i.e. kSsrc1
1473    EXPECT_TRUE(SendCustomRtp1(kSsrc1, ++sequence_number1_1));
1474    EXPECT_TRUE(SendCustomRtp2(kSsrc2, ++sequence_number2_2));
1475    EXPECT_TRUE(SendCustomRtcp1(kSsrc1));
1476    EXPECT_TRUE(SendCustomRtcp2(kSsrc2));
1477    EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1478    EXPECT_FALSE(CheckCustomRtp1(kSsrc1, sequence_number2_2));
1479    EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
1480    EXPECT_FALSE(CheckCustomRtp2(kSsrc2, sequence_number1_1));
1481    EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
1482    EXPECT_FALSE(CheckCustomRtcp1(kSsrc1));
1483    EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
1484    EXPECT_FALSE(CheckCustomRtcp2(kSsrc2));
1485  }
1486
1487  // Test that the media monitor can be run and gives timely callbacks.
1488  void TestMediaMonitor() {
1489    static const int kTimeout = 500;
1490    CreateChannels(0, 0);
1491    EXPECT_TRUE(SendInitiate());
1492    EXPECT_TRUE(SendAccept());
1493    channel1_->StartMediaMonitor(100);
1494    channel2_->StartMediaMonitor(100);
1495    // Ensure we get callbacks and stop.
1496    EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kTimeout);
1497    EXPECT_TRUE_WAIT(media_info_callbacks2_ > 0, kTimeout);
1498    channel1_->StopMediaMonitor();
1499    channel2_->StopMediaMonitor();
1500    // Ensure a restart of a stopped monitor works.
1501    channel1_->StartMediaMonitor(100);
1502    EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kTimeout);
1503    channel1_->StopMediaMonitor();
1504    // Ensure stopping a stopped monitor is OK.
1505    channel1_->StopMediaMonitor();
1506  }
1507
1508  void TestMediaSinks() {
1509    CreateChannels(0, 0);
1510    EXPECT_TRUE(SendInitiate());
1511    EXPECT_TRUE(SendAccept());
1512    EXPECT_FALSE(channel1_->HasSendSinks(cricket::SINK_POST_CRYPTO));
1513    EXPECT_FALSE(channel1_->HasRecvSinks(cricket::SINK_POST_CRYPTO));
1514    EXPECT_FALSE(channel1_->HasSendSinks(cricket::SINK_PRE_CRYPTO));
1515    EXPECT_FALSE(channel1_->HasRecvSinks(cricket::SINK_PRE_CRYPTO));
1516
1517    talk_base::Pathname path;
1518    EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
1519    path.SetFilename("sink-test.rtpdump");
1520    talk_base::scoped_ptr<cricket::RtpDumpSink> sink(
1521        new cricket::RtpDumpSink(Open(path.pathname())));
1522    sink->set_packet_filter(cricket::PF_ALL);
1523    EXPECT_TRUE(sink->Enable(true));
1524    channel1_->RegisterSendSink(
1525        sink.get(), &cricket::RtpDumpSink::OnPacket, cricket::SINK_POST_CRYPTO);
1526    EXPECT_TRUE(channel1_->HasSendSinks(cricket::SINK_POST_CRYPTO));
1527    EXPECT_FALSE(channel1_->HasRecvSinks(cricket::SINK_POST_CRYPTO));
1528    EXPECT_FALSE(channel1_->HasSendSinks(cricket::SINK_PRE_CRYPTO));
1529    EXPECT_FALSE(channel1_->HasRecvSinks(cricket::SINK_PRE_CRYPTO));
1530
1531    // The first packet is recorded with header + data.
1532    EXPECT_TRUE(SendRtp1());
1533    // The second packet is recorded with header only.
1534    sink->set_packet_filter(cricket::PF_RTPHEADER);
1535    EXPECT_TRUE(SendRtp1());
1536    // The third packet is not recorded since sink is disabled.
1537    EXPECT_TRUE(sink->Enable(false));
1538    EXPECT_TRUE(SendRtp1());
1539     // The fourth packet is not recorded since sink is unregistered.
1540    EXPECT_TRUE(sink->Enable(true));
1541    channel1_->UnregisterSendSink(sink.get(), cricket::SINK_POST_CRYPTO);
1542    EXPECT_TRUE(SendRtp1());
1543    sink.reset();  // This will close the file.
1544
1545    // Read the recorded file and verify two packets.
1546    talk_base::scoped_ptr<talk_base::StreamInterface> stream(
1547        talk_base::Filesystem::OpenFile(path, "rb"));
1548
1549    cricket::RtpDumpReader reader(stream.get());
1550    cricket::RtpDumpPacket packet;
1551    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
1552    std::string read_packet(reinterpret_cast<const char*>(&packet.data[0]),
1553        packet.data.size());
1554    EXPECT_EQ(rtp_packet_, read_packet);
1555
1556    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
1557    size_t len = 0;
1558    packet.GetRtpHeaderLen(&len);
1559    EXPECT_EQ(len, packet.data.size());
1560    EXPECT_EQ(0, memcmp(&packet.data[0], rtp_packet_.c_str(), len));
1561
1562    EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
1563
1564    // Delete the file for media recording.
1565    stream.reset();
1566    EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path));
1567  }
1568
1569  void TestSetContentFailure() {
1570    CreateChannels(0, 0);
1571    typename T::Content content;
1572    cricket::SessionDescription* sdesc_loc = new cricket::SessionDescription();
1573    cricket::SessionDescription* sdesc_rem = new cricket::SessionDescription();
1574
1575    // Set up the session description.
1576    CreateContent(0, kPcmuCodec, kH264Codec, &content);
1577    sdesc_loc->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
1578                          new cricket::AudioContentDescription());
1579    sdesc_loc->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
1580                          new cricket::VideoContentDescription());
1581    EXPECT_TRUE(session1_.set_local_description(sdesc_loc));
1582    sdesc_rem->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP,
1583                          new cricket::AudioContentDescription());
1584    sdesc_rem->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP,
1585                          new cricket::VideoContentDescription());
1586    EXPECT_TRUE(session1_.set_remote_description(sdesc_rem));
1587
1588    // Test failures in SetLocalContent.
1589    media_channel1_->set_fail_set_recv_codecs(true);
1590    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1591    session1_.SetState(cricket::Session::STATE_SENTINITIATE);
1592    EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
1593    media_channel1_->set_fail_set_recv_codecs(true);
1594    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1595    session1_.SetState(cricket::Session::STATE_SENTACCEPT);
1596    EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
1597
1598    // Test failures in SetRemoteContent.
1599    media_channel1_->set_fail_set_send_codecs(true);
1600    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1601    session1_.SetState(cricket::Session::STATE_RECEIVEDINITIATE);
1602    EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
1603    media_channel1_->set_fail_set_send_codecs(true);
1604    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1605    session1_.SetState(cricket::Session::STATE_RECEIVEDACCEPT);
1606    EXPECT_EQ(cricket::BaseSession::ERROR_CONTENT, session1_.error());
1607  }
1608
1609  void TestSendTwoOffers() {
1610    CreateChannels(0, 0);
1611
1612    // Set up the initial session description.
1613    cricket::SessionDescription* sdesc = CreateSessionDescriptionWithStream(1);
1614    EXPECT_TRUE(session1_.set_local_description(sdesc));
1615
1616    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1617    session1_.SetState(cricket::Session::STATE_SENTINITIATE);
1618    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1619    EXPECT_TRUE(media_channel1_->HasSendStream(1));
1620
1621    // Update the local description and set the state again.
1622    sdesc = CreateSessionDescriptionWithStream(2);
1623    EXPECT_TRUE(session1_.set_local_description(sdesc));
1624
1625    session1_.SetState(cricket::Session::STATE_SENTINITIATE);
1626    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1627    EXPECT_FALSE(media_channel1_->HasSendStream(1));
1628    EXPECT_TRUE(media_channel1_->HasSendStream(2));
1629  }
1630
1631  void TestReceiveTwoOffers() {
1632    CreateChannels(0, 0);
1633
1634    // Set up the initial session description.
1635    cricket::SessionDescription* sdesc = CreateSessionDescriptionWithStream(1);
1636    EXPECT_TRUE(session1_.set_remote_description(sdesc));
1637
1638    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1639    session1_.SetState(cricket::Session::STATE_RECEIVEDINITIATE);
1640    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1641    EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1642
1643    sdesc = CreateSessionDescriptionWithStream(2);
1644    EXPECT_TRUE(session1_.set_remote_description(sdesc));
1645    session1_.SetState(cricket::Session::STATE_RECEIVEDINITIATE);
1646    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1647    EXPECT_FALSE(media_channel1_->HasRecvStream(1));
1648    EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1649  }
1650
1651  void TestSendPrAnswer() {
1652    CreateChannels(0, 0);
1653
1654    // Set up the initial session description.
1655    cricket::SessionDescription* sdesc = CreateSessionDescriptionWithStream(1);
1656    EXPECT_TRUE(session1_.set_remote_description(sdesc));
1657
1658    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1659    session1_.SetState(cricket::Session::STATE_RECEIVEDINITIATE);
1660    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1661    EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1662
1663    // Send PRANSWER
1664    sdesc = CreateSessionDescriptionWithStream(2);
1665    EXPECT_TRUE(session1_.set_local_description(sdesc));
1666
1667    session1_.SetState(cricket::Session::STATE_SENTPRACCEPT);
1668    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1669    EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1670    EXPECT_TRUE(media_channel1_->HasSendStream(2));
1671
1672    // Send ACCEPT
1673    sdesc = CreateSessionDescriptionWithStream(3);
1674    EXPECT_TRUE(session1_.set_local_description(sdesc));
1675
1676    session1_.SetState(cricket::Session::STATE_SENTACCEPT);
1677    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1678    EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1679    EXPECT_FALSE(media_channel1_->HasSendStream(2));
1680    EXPECT_TRUE(media_channel1_->HasSendStream(3));
1681  }
1682
1683  void TestReceivePrAnswer() {
1684    CreateChannels(0, 0);
1685
1686    // Set up the initial session description.
1687    cricket::SessionDescription* sdesc = CreateSessionDescriptionWithStream(1);
1688    EXPECT_TRUE(session1_.set_local_description(sdesc));
1689
1690    session1_.SetError(cricket::BaseSession::ERROR_NONE);
1691    session1_.SetState(cricket::Session::STATE_SENTINITIATE);
1692    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1693    EXPECT_TRUE(media_channel1_->HasSendStream(1));
1694
1695    // Receive PRANSWER
1696    sdesc = CreateSessionDescriptionWithStream(2);
1697    EXPECT_TRUE(session1_.set_remote_description(sdesc));
1698
1699    session1_.SetState(cricket::Session::STATE_RECEIVEDPRACCEPT);
1700    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1701    EXPECT_TRUE(media_channel1_->HasSendStream(1));
1702    EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1703
1704    // Receive ACCEPT
1705    sdesc = CreateSessionDescriptionWithStream(3);
1706    EXPECT_TRUE(session1_.set_remote_description(sdesc));
1707
1708    session1_.SetState(cricket::Session::STATE_RECEIVEDACCEPT);
1709    EXPECT_EQ(cricket::BaseSession::ERROR_NONE, session1_.error());
1710    EXPECT_TRUE(media_channel1_->HasSendStream(1));
1711    EXPECT_FALSE(media_channel1_->HasRecvStream(2));
1712    EXPECT_TRUE(media_channel1_->HasRecvStream(3));
1713  }
1714
1715  void TestFlushRtcp() {
1716    bool send_rtcp1;
1717
1718    CreateChannels(RTCP, RTCP);
1719    EXPECT_TRUE(SendInitiate());
1720    EXPECT_TRUE(SendAccept());
1721    EXPECT_EQ(2U, GetTransport1()->channels().size());
1722    EXPECT_EQ(2U, GetTransport2()->channels().size());
1723
1724    // Send RTCP1 from a different thread.
1725    CallOnThreadAndWaitForDone(&ChannelTest<T>::SendRtcp1, &send_rtcp1);
1726    EXPECT_TRUE(send_rtcp1);
1727    // The sending message is only posted.  channel2_ should be empty.
1728    EXPECT_TRUE(CheckNoRtcp2());
1729
1730    // When channel1_ is deleted, the RTCP packet should be sent out to
1731    // channel2_.
1732    channel1_.reset();
1733    EXPECT_TRUE(CheckRtcp2());
1734  }
1735
1736  void TestChangeStateError() {
1737    CreateChannels(RTCP, RTCP);
1738    EXPECT_TRUE(SendInitiate());
1739    media_channel2_->set_fail_set_send(true);
1740    EXPECT_TRUE(channel2_->Enable(true));
1741    EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED,
1742              error_);
1743  }
1744
1745  void TestSrtpError() {
1746    static const unsigned char kBadPacket[] = {
1747      0x84, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
1748    };
1749    CreateChannels(RTCP | SECURE, RTCP | SECURE);
1750    EXPECT_FALSE(channel1_->secure());
1751    EXPECT_FALSE(channel2_->secure());
1752    EXPECT_TRUE(SendInitiate());
1753    EXPECT_TRUE(SendAccept());
1754    EXPECT_TRUE(channel1_->secure());
1755    EXPECT_TRUE(channel2_->secure());
1756    channel2_->set_srtp_signal_silent_time(200);
1757
1758    // Testing failures in sending packets.
1759    EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
1760    // The first failure will trigger an error.
1761    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
1762    error_ = T::MediaChannel::ERROR_NONE;
1763    // The next 1 sec failures will not trigger an error.
1764    EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
1765    // Wait for a while to ensure no message comes in.
1766    talk_base::Thread::Current()->ProcessMessages(210);
1767    EXPECT_EQ(T::MediaChannel::ERROR_NONE, error_);
1768    // The error will be triggered again.
1769    EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
1770    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
1771
1772    // Testing failures in receiving packets.
1773    error_ = T::MediaChannel::ERROR_NONE;
1774    cricket::TransportChannel* transport_channel =
1775        channel2_->transport_channel();
1776    transport_channel->SignalReadPacket(
1777        transport_channel, reinterpret_cast<const char*>(kBadPacket),
1778        sizeof(kBadPacket), 0);
1779    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_PLAY_SRTP_ERROR, error_, 500);
1780  }
1781
1782  void TestOnReadyToSend() {
1783    CreateChannels(RTCP, RTCP);
1784    TransportChannel* rtp = channel1_->transport_channel();
1785    TransportChannel* rtcp = channel1_->rtcp_transport_channel();
1786    EXPECT_FALSE(media_channel1_->ready_to_send());
1787    rtp->SignalReadyToSend(rtp);
1788    EXPECT_FALSE(media_channel1_->ready_to_send());
1789    rtcp->SignalReadyToSend(rtcp);
1790    // MediaChannel::OnReadyToSend only be called when both rtp and rtcp
1791    // channel are ready to send.
1792    EXPECT_TRUE(media_channel1_->ready_to_send());
1793
1794    // rtp channel becomes not ready to send will be propagated to mediachannel
1795    channel1_->SetReadyToSend(rtp, false);
1796    EXPECT_FALSE(media_channel1_->ready_to_send());
1797    channel1_->SetReadyToSend(rtp, true);
1798    EXPECT_TRUE(media_channel1_->ready_to_send());
1799
1800    // rtcp channel becomes not ready to send will be propagated to mediachannel
1801    channel1_->SetReadyToSend(rtcp, false);
1802    EXPECT_FALSE(media_channel1_->ready_to_send());
1803    channel1_->SetReadyToSend(rtcp, true);
1804    EXPECT_TRUE(media_channel1_->ready_to_send());
1805  }
1806
1807  void TestOnReadyToSendWithRtcpMux() {
1808    CreateChannels(RTCP, RTCP);
1809    typename T::Content content;
1810    CreateContent(0, kPcmuCodec, kH264Codec, &content);
1811    // Both sides agree on mux. Should no longer be a separate RTCP channel.
1812    content.set_rtcp_mux(true);
1813    EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER));
1814    EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER));
1815    EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
1816    TransportChannel* rtp = channel1_->transport_channel();
1817    EXPECT_FALSE(media_channel1_->ready_to_send());
1818    // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
1819    // should trigger the MediaChannel's OnReadyToSend.
1820    rtp->SignalReadyToSend(rtp);
1821    EXPECT_TRUE(media_channel1_->ready_to_send());
1822    channel1_->SetReadyToSend(rtp, false);
1823    EXPECT_FALSE(media_channel1_->ready_to_send());
1824  }
1825
1826 protected:
1827  cricket::FakeSession session1_;
1828  cricket::FakeSession session2_;
1829  cricket::FakeMediaEngine media_engine_;
1830  // The media channels are owned by the voice channel objects below.
1831  typename T::MediaChannel* media_channel1_;
1832  typename T::MediaChannel* media_channel2_;
1833  talk_base::scoped_ptr<typename T::Channel> channel1_;
1834  talk_base::scoped_ptr<typename T::Channel> channel2_;
1835  typename T::Content local_media_content1_;
1836  typename T::Content local_media_content2_;
1837  typename T::Content remote_media_content1_;
1838  typename T::Content remote_media_content2_;
1839  talk_base::scoped_ptr<talk_base::SSLIdentity> identity1_;
1840  talk_base::scoped_ptr<talk_base::SSLIdentity> identity2_;
1841  // The RTP and RTCP packets to send in the tests.
1842  std::string rtp_packet_;
1843  std::string rtcp_packet_;
1844  int media_info_callbacks1_;
1845  int media_info_callbacks2_;
1846  bool mute_callback_recved_;
1847  bool mute_callback_value_;
1848
1849  uint32 ssrc_;
1850  typename T::MediaChannel::Error error_;
1851};
1852
1853
1854template<>
1855void ChannelTest<VoiceTraits>::CreateContent(
1856    int flags,
1857    const cricket::AudioCodec& audio_codec,
1858    const cricket::VideoCodec& video_codec,
1859    cricket::AudioContentDescription* audio) {
1860  audio->AddCodec(audio_codec);
1861  audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
1862  if (flags & SECURE) {
1863    audio->AddCrypto(cricket::CryptoParams(
1864        1, cricket::CS_AES_CM_128_HMAC_SHA1_32,
1865        "inline:" + talk_base::CreateRandomString(40), ""));
1866  }
1867}
1868
1869template<>
1870void ChannelTest<VoiceTraits>::CopyContent(
1871    const cricket::AudioContentDescription& source,
1872    cricket::AudioContentDescription* audio) {
1873  *audio = source;
1874}
1875
1876template<>
1877bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1,
1878                                            const cricket::AudioCodec& c2) {
1879  return c1.name == c2.name && c1.clockrate == c2.clockrate &&
1880      c1.bitrate == c2.bitrate && c1.channels == c2.channels;
1881}
1882
1883template<>
1884void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
1885    uint32 ssrc, int flags, cricket::AudioContentDescription* audio) {
1886  audio->AddLegacyStream(ssrc);
1887}
1888
1889class VoiceChannelTest
1890    : public ChannelTest<VoiceTraits> {
1891 public:
1892  typedef ChannelTest<VoiceTraits>
1893  Base;
1894  VoiceChannelTest() : Base(kPcmuFrame, sizeof(kPcmuFrame),
1895                            kRtcpReport, sizeof(kRtcpReport)) {
1896  }
1897
1898  void TestSetChannelOptions() {
1899    CreateChannels(0, 0);
1900
1901    cricket::AudioOptions options1;
1902    options1.echo_cancellation.Set(false);
1903    cricket::AudioOptions options2;
1904    options2.echo_cancellation.Set(true);
1905
1906    channel1_->SetChannelOptions(options1);
1907    channel2_->SetChannelOptions(options1);
1908    cricket::AudioOptions actual_options;
1909    ASSERT_TRUE(media_channel1_->GetOptions(&actual_options));
1910    EXPECT_EQ(options1, actual_options);
1911    ASSERT_TRUE(media_channel2_->GetOptions(&actual_options));
1912    EXPECT_EQ(options1, actual_options);
1913
1914    channel1_->SetChannelOptions(options2);
1915    channel2_->SetChannelOptions(options2);
1916    ASSERT_TRUE(media_channel1_->GetOptions(&actual_options));
1917    EXPECT_EQ(options2, actual_options);
1918    ASSERT_TRUE(media_channel2_->GetOptions(&actual_options));
1919    EXPECT_EQ(options2, actual_options);
1920  }
1921};
1922
1923// override to add NULL parameter
1924template<>
1925cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
1926    talk_base::Thread* thread, cricket::MediaEngineInterface* engine,
1927    cricket::FakeVideoMediaChannel* ch, cricket::BaseSession* session,
1928    bool rtcp) {
1929  cricket::VideoChannel* channel = new cricket::VideoChannel(
1930      thread, engine, ch, session, cricket::CN_VIDEO, rtcp, NULL);
1931  if (!channel->Init()) {
1932    delete channel;
1933    channel = NULL;
1934  }
1935  return channel;
1936}
1937
1938// override to add 0 parameter
1939template<>
1940bool ChannelTest<VideoTraits>::AddStream1(int id) {
1941  return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
1942}
1943
1944template<>
1945void ChannelTest<VideoTraits>::CreateContent(
1946    int flags,
1947    const cricket::AudioCodec& audio_codec,
1948    const cricket::VideoCodec& video_codec,
1949    cricket::VideoContentDescription* video) {
1950  video->AddCodec(video_codec);
1951  video->set_rtcp_mux((flags & RTCP_MUX) != 0);
1952  if (flags & SECURE) {
1953    video->AddCrypto(cricket::CryptoParams(
1954        1, cricket::CS_AES_CM_128_HMAC_SHA1_80,
1955        "inline:" + talk_base::CreateRandomString(40), ""));
1956  }
1957}
1958
1959template<>
1960void ChannelTest<VideoTraits>::CopyContent(
1961    const cricket::VideoContentDescription& source,
1962    cricket::VideoContentDescription* video) {
1963  *video = source;
1964}
1965
1966template<>
1967bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1,
1968                                            const cricket::VideoCodec& c2) {
1969  return c1.name == c2.name && c1.width == c2.width && c1.height == c2.height &&
1970      c1.framerate == c2.framerate;
1971}
1972
1973template<>
1974void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
1975    uint32 ssrc, int flags, cricket::VideoContentDescription* video) {
1976  video->AddLegacyStream(ssrc);
1977}
1978
1979class VideoChannelTest
1980    : public ChannelTest<VideoTraits> {
1981 public:
1982  typedef ChannelTest<VideoTraits>
1983  Base;
1984  VideoChannelTest() : Base(kH264Packet, sizeof(kH264Packet),
1985                            kRtcpReport, sizeof(kRtcpReport)) {
1986  }
1987
1988  void TestSetChannelOptions() {
1989    CreateChannels(0, 0);
1990
1991    cricket::VideoOptions o1, o2;
1992    o1.video_noise_reduction.Set(true);
1993
1994    channel1_->SetChannelOptions(o1);
1995    channel2_->SetChannelOptions(o1);
1996    EXPECT_TRUE(media_channel1_->GetOptions(&o2));
1997    EXPECT_EQ(o1, o2);
1998    EXPECT_TRUE(media_channel2_->GetOptions(&o2));
1999    EXPECT_EQ(o1, o2);
2000
2001    o1.video_leaky_bucket.Set(true);
2002    channel1_->SetChannelOptions(o1);
2003    channel2_->SetChannelOptions(o1);
2004    EXPECT_TRUE(media_channel1_->GetOptions(&o2));
2005    EXPECT_EQ(o1, o2);
2006    EXPECT_TRUE(media_channel2_->GetOptions(&o2));
2007    EXPECT_EQ(o1, o2);
2008  }
2009};
2010
2011
2012// VoiceChannelTest
2013
2014TEST_F(VoiceChannelTest, TestInit) {
2015  Base::TestInit();
2016  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2017  EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
2018}
2019
2020TEST_F(VoiceChannelTest, TestSetContents) {
2021  Base::TestSetContents();
2022}
2023
2024TEST_F(VoiceChannelTest, TestSetContentsNullOffer) {
2025  Base::TestSetContentsNullOffer();
2026}
2027
2028TEST_F(VoiceChannelTest, TestSetContentsRtcpMux) {
2029  Base::TestSetContentsRtcpMux();
2030}
2031
2032TEST_F(VoiceChannelTest, TestSetContentsRtcpMuxWithPrAnswer) {
2033  Base::TestSetContentsRtcpMux();
2034}
2035
2036TEST_F(VoiceChannelTest, TestSetRemoteContentUpdate) {
2037  Base::TestSetRemoteContentUpdate();
2038}
2039
2040TEST_F(VoiceChannelTest, TestStreams) {
2041  Base::TestStreams();
2042}
2043
2044TEST_F(VoiceChannelTest, TestUpdateStreamsInLocalContent) {
2045  Base::TestUpdateStreamsInLocalContent();
2046}
2047
2048TEST_F(VoiceChannelTest, TestUpdateRemoteStreamsInContent) {
2049  Base::TestUpdateStreamsInRemoteContent();
2050}
2051
2052TEST_F(VoiceChannelTest, TestChangeStreamParamsInContent) {
2053  Base::TestChangeStreamParamsInContent();
2054}
2055
2056TEST_F(VoiceChannelTest, TestPlayoutAndSendingStates) {
2057  Base::TestPlayoutAndSendingStates();
2058}
2059
2060TEST_F(VoiceChannelTest, TestMuteStream) {
2061  Base::TestMuteStream();
2062}
2063
2064TEST_F(VoiceChannelTest, TestMediaContentDirection) {
2065  Base::TestMediaContentDirection();
2066}
2067
2068TEST_F(VoiceChannelTest, TestCallSetup) {
2069  Base::TestCallSetup();
2070}
2071
2072TEST_F(VoiceChannelTest, TestCallTeardownRtcpMux) {
2073  Base::TestCallTeardownRtcpMux();
2074}
2075
2076TEST_F(VoiceChannelTest, SendRtpToRtp) {
2077  Base::SendRtpToRtp();
2078}
2079
2080TEST_F(VoiceChannelTest, SendNoRtcpToNoRtcp) {
2081  Base::SendNoRtcpToNoRtcp();
2082}
2083
2084TEST_F(VoiceChannelTest, SendNoRtcpToRtcp) {
2085  Base::SendNoRtcpToRtcp();
2086}
2087
2088TEST_F(VoiceChannelTest, SendRtcpToNoRtcp) {
2089  Base::SendRtcpToNoRtcp();
2090}
2091
2092TEST_F(VoiceChannelTest, SendRtcpToRtcp) {
2093  Base::SendRtcpToRtcp();
2094}
2095
2096TEST_F(VoiceChannelTest, SendRtcpMuxToRtcp) {
2097  Base::SendRtcpMuxToRtcp();
2098}
2099
2100TEST_F(VoiceChannelTest, SendRtcpMuxToRtcpMux) {
2101  Base::SendRtcpMuxToRtcpMux();
2102}
2103
2104TEST_F(VoiceChannelTest, SendEarlyRtcpMuxToRtcp) {
2105  Base::SendEarlyRtcpMuxToRtcp();
2106}
2107
2108TEST_F(VoiceChannelTest, SendEarlyRtcpMuxToRtcpMux) {
2109  Base::SendEarlyRtcpMuxToRtcpMux();
2110}
2111
2112TEST_F(VoiceChannelTest, SendSrtpToSrtpRtcpMux) {
2113  Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2114}
2115
2116TEST_F(VoiceChannelTest, SendSrtpToRtp) {
2117  Base::SendSrtpToSrtp();
2118}
2119
2120TEST_F(VoiceChannelTest, SendSrtcpMux) {
2121  Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2122}
2123
2124TEST_F(VoiceChannelTest, SendDtlsSrtpToSrtp) {
2125  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2126  Base::SendSrtpToSrtp(DTLS, 0);
2127}
2128
2129TEST_F(VoiceChannelTest, SendDtlsSrtpToDtlsSrtp) {
2130  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2131  Base::SendSrtpToSrtp(DTLS, DTLS);
2132}
2133
2134TEST_F(VoiceChannelTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
2135  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2136  Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
2137}
2138
2139TEST_F(VoiceChannelTest, SendEarlyMediaUsingRtcpMuxSrtp) {
2140  Base::SendEarlyMediaUsingRtcpMuxSrtp();
2141}
2142
2143TEST_F(VoiceChannelTest, SendRtpToRtpOnThread) {
2144  Base::SendRtpToRtpOnThread();
2145}
2146
2147TEST_F(VoiceChannelTest, SendSrtpToSrtpOnThread) {
2148  Base::SendSrtpToSrtpOnThread();
2149}
2150
2151TEST_F(VoiceChannelTest, SendWithWritabilityLoss) {
2152  Base::SendWithWritabilityLoss();
2153}
2154
2155TEST_F(VoiceChannelTest, TestMediaMonitor) {
2156  Base::TestMediaMonitor();
2157}
2158
2159// Test that MuteStream properly forwards to the media channel and does
2160// not signal.
2161TEST_F(VoiceChannelTest, TestVoiceSpecificMuteStream) {
2162  CreateChannels(0, 0);
2163  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2164  EXPECT_FALSE(mute_callback_recved_);
2165  EXPECT_TRUE(channel1_->MuteStream(0, true));
2166  EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
2167  EXPECT_FALSE(mute_callback_recved_);
2168  EXPECT_TRUE(channel1_->MuteStream(0, false));
2169  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2170  EXPECT_FALSE(mute_callback_recved_);
2171}
2172
2173// Test that keyboard automute works correctly and signals upwards.
2174TEST_F(VoiceChannelTest, DISABLED_TestKeyboardMute) {
2175  CreateChannels(0, 0);
2176  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2177  EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_NONE, error_);
2178
2179  cricket::VoiceMediaChannel::Error e =
2180      cricket::VoiceMediaChannel::ERROR_REC_TYPING_NOISE_DETECTED;
2181
2182  // Typing doesn't mute automatically unless typing monitor has been installed
2183  media_channel1_->TriggerError(0, e);
2184  talk_base::Thread::Current()->ProcessMessages(0);
2185  EXPECT_EQ(e, error_);
2186  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2187  EXPECT_FALSE(mute_callback_recved_);
2188
2189  cricket::TypingMonitorOptions o = {0};
2190  o.mute_period = 1500;
2191  channel1_->StartTypingMonitor(o);
2192  media_channel1_->TriggerError(0, e);
2193  talk_base::Thread::Current()->ProcessMessages(0);
2194  EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
2195  EXPECT_TRUE(mute_callback_recved_);
2196}
2197
2198// Test that PressDTMF properly forwards to the media channel.
2199TEST_F(VoiceChannelTest, TestDtmf) {
2200  CreateChannels(0, 0);
2201  EXPECT_TRUE(SendInitiate());
2202  EXPECT_TRUE(SendAccept());
2203  EXPECT_EQ(0U, media_channel1_->dtmf_info_queue().size());
2204
2205  EXPECT_TRUE(channel1_->PressDTMF(1, true));
2206  EXPECT_TRUE(channel1_->PressDTMF(8, false));
2207
2208  ASSERT_EQ(2U, media_channel1_->dtmf_info_queue().size());
2209  EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[0],
2210                              0, 1, 160, cricket::DF_PLAY | cricket::DF_SEND));
2211  EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[1],
2212                              0, 8, 160, cricket::DF_SEND));
2213}
2214
2215// Test that InsertDtmf properly forwards to the media channel.
2216TEST_F(VoiceChannelTest, TestInsertDtmf) {
2217  CreateChannels(0, 0);
2218  EXPECT_TRUE(SendInitiate());
2219  EXPECT_TRUE(SendAccept());
2220  EXPECT_EQ(0U, media_channel1_->dtmf_info_queue().size());
2221
2222  EXPECT_TRUE(channel1_->InsertDtmf(1, 3, 100, cricket::DF_SEND));
2223  EXPECT_TRUE(channel1_->InsertDtmf(2, 5, 110, cricket::DF_PLAY));
2224  EXPECT_TRUE(channel1_->InsertDtmf(3, 7, 120,
2225                                    cricket::DF_PLAY | cricket::DF_SEND));
2226
2227  ASSERT_EQ(3U, media_channel1_->dtmf_info_queue().size());
2228  EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[0],
2229                              1, 3, 100, cricket::DF_SEND));
2230  EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[1],
2231                              2, 5, 110, cricket::DF_PLAY));
2232  EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[2],
2233                              3, 7, 120, cricket::DF_PLAY | cricket::DF_SEND));
2234}
2235
2236TEST_F(VoiceChannelTest, TestMediaSinks) {
2237  Base::TestMediaSinks();
2238}
2239
2240TEST_F(VoiceChannelTest, TestSetContentFailure) {
2241  Base::TestSetContentFailure();
2242}
2243
2244TEST_F(VoiceChannelTest, TestSendTwoOffers) {
2245  Base::TestSendTwoOffers();
2246}
2247
2248TEST_F(VoiceChannelTest, TestReceiveTwoOffers) {
2249  Base::TestReceiveTwoOffers();
2250}
2251
2252TEST_F(VoiceChannelTest, TestSendPrAnswer) {
2253  Base::TestSendPrAnswer();
2254}
2255
2256TEST_F(VoiceChannelTest, TestReceivePrAnswer) {
2257  Base::TestReceivePrAnswer();
2258}
2259
2260TEST_F(VoiceChannelTest, TestFlushRtcp) {
2261  Base::TestFlushRtcp();
2262}
2263
2264TEST_F(VoiceChannelTest, TestChangeStateError) {
2265  Base::TestChangeStateError();
2266}
2267
2268TEST_F(VoiceChannelTest, TestSrtpError) {
2269  Base::TestSrtpError();
2270}
2271
2272TEST_F(VoiceChannelTest, TestOnReadyToSend) {
2273  Base::TestOnReadyToSend();
2274}
2275
2276TEST_F(VoiceChannelTest, TestOnReadyToSendWithRtcpMux) {
2277  Base::TestOnReadyToSendWithRtcpMux();
2278}
2279
2280// Test that we can play a ringback tone properly.
2281TEST_F(VoiceChannelTest, TestRingbackTone) {
2282  CreateChannels(RTCP, RTCP);
2283  EXPECT_FALSE(media_channel1_->ringback_tone_play());
2284  EXPECT_TRUE(channel1_->SetRingbackTone("RIFF", 4));
2285  EXPECT_TRUE(SendInitiate());
2286  EXPECT_TRUE(SendAccept());
2287  // Play ringback tone, no loop.
2288  EXPECT_TRUE(channel1_->PlayRingbackTone(0, true, false));
2289  EXPECT_EQ(0U, media_channel1_->ringback_tone_ssrc());
2290  EXPECT_TRUE(media_channel1_->ringback_tone_play());
2291  EXPECT_FALSE(media_channel1_->ringback_tone_loop());
2292  // Stop the ringback tone.
2293  EXPECT_TRUE(channel1_->PlayRingbackTone(0, false, false));
2294  EXPECT_FALSE(media_channel1_->ringback_tone_play());
2295  // Add a stream.
2296  EXPECT_TRUE(AddStream1(1));
2297  // Play ringback tone, looping, on the new stream.
2298  EXPECT_TRUE(channel1_->PlayRingbackTone(1, true, true));
2299  EXPECT_EQ(1U, media_channel1_->ringback_tone_ssrc());
2300  EXPECT_TRUE(media_channel1_->ringback_tone_play());
2301  EXPECT_TRUE(media_channel1_->ringback_tone_loop());
2302  // Stop the ringback tone.
2303  EXPECT_TRUE(channel1_->PlayRingbackTone(1, false, false));
2304  EXPECT_FALSE(media_channel1_->ringback_tone_play());
2305}
2306
2307// Test that we can scale the output volume properly for 1:1 calls.
2308TEST_F(VoiceChannelTest, TestScaleVolume1to1Call) {
2309  CreateChannels(RTCP, RTCP);
2310  EXPECT_TRUE(SendInitiate());
2311  EXPECT_TRUE(SendAccept());
2312  double left, right;
2313
2314  // Default is (1.0, 1.0).
2315  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2316  EXPECT_DOUBLE_EQ(1.0, left);
2317  EXPECT_DOUBLE_EQ(1.0, right);
2318  // invalid ssrc.
2319  EXPECT_FALSE(media_channel1_->GetOutputScaling(3, &left, &right));
2320
2321  // Set scale to (1.5, 0.5).
2322  EXPECT_TRUE(channel1_->SetOutputScaling(0, 1.5, 0.5));
2323  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2324  EXPECT_DOUBLE_EQ(1.5, left);
2325  EXPECT_DOUBLE_EQ(0.5, right);
2326
2327  // Set scale to (0, 0).
2328  EXPECT_TRUE(channel1_->SetOutputScaling(0, 0.0, 0.0));
2329  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2330  EXPECT_DOUBLE_EQ(0.0, left);
2331  EXPECT_DOUBLE_EQ(0.0, right);
2332}
2333
2334// Test that we can scale the output volume properly for multiway calls.
2335TEST_F(VoiceChannelTest, TestScaleVolumeMultiwayCall) {
2336  CreateChannels(RTCP, RTCP);
2337  EXPECT_TRUE(SendInitiate());
2338  EXPECT_TRUE(SendAccept());
2339  EXPECT_TRUE(AddStream1(1));
2340  EXPECT_TRUE(AddStream1(2));
2341
2342  double left, right;
2343  // Default is (1.0, 1.0).
2344  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2345  EXPECT_DOUBLE_EQ(1.0, left);
2346  EXPECT_DOUBLE_EQ(1.0, right);
2347  EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
2348  EXPECT_DOUBLE_EQ(1.0, left);
2349  EXPECT_DOUBLE_EQ(1.0, right);
2350  EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
2351  EXPECT_DOUBLE_EQ(1.0, left);
2352  EXPECT_DOUBLE_EQ(1.0, right);
2353  // invalid ssrc.
2354  EXPECT_FALSE(media_channel1_->GetOutputScaling(3, &left, &right));
2355
2356  // Set scale to (1.5, 0.5) for ssrc = 1.
2357  EXPECT_TRUE(channel1_->SetOutputScaling(1, 1.5, 0.5));
2358  EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
2359  EXPECT_DOUBLE_EQ(1.5, left);
2360  EXPECT_DOUBLE_EQ(0.5, right);
2361  EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
2362  EXPECT_DOUBLE_EQ(1.0, left);
2363  EXPECT_DOUBLE_EQ(1.0, right);
2364  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2365  EXPECT_DOUBLE_EQ(1.0, left);
2366  EXPECT_DOUBLE_EQ(1.0, right);
2367
2368  // Set scale to (0, 0) for all ssrcs.
2369  EXPECT_TRUE(channel1_->SetOutputScaling(0,  0.0, 0.0));
2370  EXPECT_TRUE(media_channel1_->GetOutputScaling(0, &left, &right));
2371  EXPECT_DOUBLE_EQ(0.0, left);
2372  EXPECT_DOUBLE_EQ(0.0, right);
2373  EXPECT_TRUE(media_channel1_->GetOutputScaling(1, &left, &right));
2374  EXPECT_DOUBLE_EQ(0.0, left);
2375  EXPECT_DOUBLE_EQ(0.0, right);
2376  EXPECT_TRUE(media_channel1_->GetOutputScaling(2, &left, &right));
2377  EXPECT_DOUBLE_EQ(0.0, left);
2378  EXPECT_DOUBLE_EQ(0.0, right);
2379}
2380
2381TEST_F(VoiceChannelTest, SendSsrcMuxToSsrcMux) {
2382  Base::SendSsrcMuxToSsrcMux();
2383}
2384
2385TEST_F(VoiceChannelTest, SendSsrcMuxToSsrcMuxWithRtcpMux) {
2386  Base::SendSsrcMuxToSsrcMuxWithRtcpMux();
2387}
2388
2389TEST_F(VoiceChannelTest, TestSetChannelOptions) {
2390  TestSetChannelOptions();
2391}
2392
2393// VideoChannelTest
2394TEST_F(VideoChannelTest, TestInit) {
2395  Base::TestInit();
2396}
2397
2398TEST_F(VideoChannelTest, TestSetContents) {
2399  Base::TestSetContents();
2400}
2401
2402TEST_F(VideoChannelTest, TestSetContentsNullOffer) {
2403  Base::TestSetContentsNullOffer();
2404}
2405
2406TEST_F(VideoChannelTest, TestSetContentsRtcpMux) {
2407  Base::TestSetContentsRtcpMux();
2408}
2409
2410TEST_F(VideoChannelTest, TestSetContentsRtcpMuxWithPrAnswer) {
2411  Base::TestSetContentsRtcpMux();
2412}
2413
2414TEST_F(VideoChannelTest, TestSetContentsVideoOptions) {
2415  Base::TestSetContentsVideoOptions();
2416}
2417
2418TEST_F(VideoChannelTest, TestSetRemoteContentUpdate) {
2419  Base::TestSetRemoteContentUpdate();
2420}
2421
2422TEST_F(VideoChannelTest, TestStreams) {
2423  Base::TestStreams();
2424}
2425
2426TEST_F(VideoChannelTest, TestScreencastEvents) {
2427  const int kTimeoutMs = 500;
2428  TestInit();
2429  FakeScreenCaptureFactory* screencapture_factory =
2430      new FakeScreenCaptureFactory();
2431  channel1_->SetScreenCaptureFactory(screencapture_factory);
2432  cricket::ScreencastEventCatcher catcher;
2433  channel1_->SignalScreencastWindowEvent.connect(
2434      &catcher,
2435      &cricket::ScreencastEventCatcher::OnEvent);
2436  EXPECT_TRUE(channel1_->AddScreencast(0, ScreencastId(WindowId(0))) != NULL);
2437  ASSERT_TRUE(screencapture_factory->window_capturer() != NULL);
2438  EXPECT_EQ_WAIT(cricket::CS_STOPPED, screencapture_factory->capture_state(),
2439                 kTimeoutMs);
2440  screencapture_factory->window_capturer()->SignalStateChange(
2441      screencapture_factory->window_capturer(), cricket::CS_PAUSED);
2442  EXPECT_EQ_WAIT(talk_base::WE_MINIMIZE, catcher.event(), kTimeoutMs);
2443  screencapture_factory->window_capturer()->SignalStateChange(
2444      screencapture_factory->window_capturer(), cricket::CS_RUNNING);
2445  EXPECT_EQ_WAIT(talk_base::WE_RESTORE, catcher.event(), kTimeoutMs);
2446  screencapture_factory->window_capturer()->SignalStateChange(
2447      screencapture_factory->window_capturer(), cricket::CS_STOPPED);
2448  EXPECT_EQ_WAIT(talk_base::WE_CLOSE, catcher.event(), kTimeoutMs);
2449  EXPECT_TRUE(channel1_->RemoveScreencast(0));
2450  ASSERT_TRUE(screencapture_factory->window_capturer() == NULL);
2451}
2452
2453TEST_F(VideoChannelTest, TestUpdateStreamsInLocalContent) {
2454  Base::TestUpdateStreamsInLocalContent();
2455}
2456
2457TEST_F(VideoChannelTest, TestUpdateRemoteStreamsInContent) {
2458  Base::TestUpdateStreamsInRemoteContent();
2459}
2460
2461TEST_F(VideoChannelTest, TestChangeStreamParamsInContent) {
2462  Base::TestChangeStreamParamsInContent();
2463}
2464
2465TEST_F(VideoChannelTest, TestPlayoutAndSendingStates) {
2466  Base::TestPlayoutAndSendingStates();
2467}
2468
2469TEST_F(VideoChannelTest, TestMuteStream) {
2470  Base::TestMuteStream();
2471}
2472
2473TEST_F(VideoChannelTest, TestMediaContentDirection) {
2474  Base::TestMediaContentDirection();
2475}
2476
2477TEST_F(VideoChannelTest, TestCallSetup) {
2478  Base::TestCallSetup();
2479}
2480
2481TEST_F(VideoChannelTest, TestCallTeardownRtcpMux) {
2482  Base::TestCallTeardownRtcpMux();
2483}
2484
2485TEST_F(VideoChannelTest, SendRtpToRtp) {
2486  Base::SendRtpToRtp();
2487}
2488
2489TEST_F(VideoChannelTest, SendNoRtcpToNoRtcp) {
2490  Base::SendNoRtcpToNoRtcp();
2491}
2492
2493TEST_F(VideoChannelTest, SendNoRtcpToRtcp) {
2494  Base::SendNoRtcpToRtcp();
2495}
2496
2497TEST_F(VideoChannelTest, SendRtcpToNoRtcp) {
2498  Base::SendRtcpToNoRtcp();
2499}
2500
2501TEST_F(VideoChannelTest, SendRtcpToRtcp) {
2502  Base::SendRtcpToRtcp();
2503}
2504
2505TEST_F(VideoChannelTest, SendRtcpMuxToRtcp) {
2506  Base::SendRtcpMuxToRtcp();
2507}
2508
2509TEST_F(VideoChannelTest, SendRtcpMuxToRtcpMux) {
2510  Base::SendRtcpMuxToRtcpMux();
2511}
2512
2513TEST_F(VideoChannelTest, SendEarlyRtcpMuxToRtcp) {
2514  Base::SendEarlyRtcpMuxToRtcp();
2515}
2516
2517TEST_F(VideoChannelTest, SendEarlyRtcpMuxToRtcpMux) {
2518  Base::SendEarlyRtcpMuxToRtcpMux();
2519}
2520
2521TEST_F(VideoChannelTest, SendSrtpToSrtp) {
2522  Base::SendSrtpToSrtp();
2523}
2524
2525TEST_F(VideoChannelTest, SendSrtpToRtp) {
2526  Base::SendSrtpToSrtp();
2527}
2528
2529TEST_F(VideoChannelTest, SendDtlsSrtpToSrtp) {
2530  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2531  Base::SendSrtpToSrtp(DTLS, 0);
2532}
2533
2534TEST_F(VideoChannelTest, SendDtlsSrtpToDtlsSrtp) {
2535  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2536  Base::SendSrtpToSrtp(DTLS, DTLS);
2537}
2538
2539TEST_F(VideoChannelTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
2540  MAYBE_SKIP_TEST(HaveDtlsSrtp);
2541  Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
2542}
2543
2544TEST_F(VideoChannelTest, SendSrtcpMux) {
2545  Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2546}
2547
2548TEST_F(VideoChannelTest, SendEarlyMediaUsingRtcpMuxSrtp) {
2549  Base::SendEarlyMediaUsingRtcpMuxSrtp();
2550}
2551
2552TEST_F(VideoChannelTest, SendRtpToRtpOnThread) {
2553  Base::SendRtpToRtpOnThread();
2554}
2555
2556TEST_F(VideoChannelTest, SendSrtpToSrtpOnThread) {
2557  Base::SendSrtpToSrtpOnThread();
2558}
2559
2560TEST_F(VideoChannelTest, SendWithWritabilityLoss) {
2561  Base::SendWithWritabilityLoss();
2562}
2563
2564TEST_F(VideoChannelTest, TestMediaMonitor) {
2565  Base::TestMediaMonitor();
2566}
2567
2568TEST_F(VideoChannelTest, TestMediaSinks) {
2569  Base::TestMediaSinks();
2570}
2571
2572TEST_F(VideoChannelTest, TestSetContentFailure) {
2573  Base::TestSetContentFailure();
2574}
2575
2576TEST_F(VideoChannelTest, TestSendTwoOffers) {
2577  Base::TestSendTwoOffers();
2578}
2579
2580TEST_F(VideoChannelTest, TestReceiveTwoOffers) {
2581  Base::TestReceiveTwoOffers();
2582}
2583
2584TEST_F(VideoChannelTest, TestSendPrAnswer) {
2585  Base::TestSendPrAnswer();
2586}
2587
2588TEST_F(VideoChannelTest, TestReceivePrAnswer) {
2589  Base::TestReceivePrAnswer();
2590}
2591
2592TEST_F(VideoChannelTest, TestFlushRtcp) {
2593  Base::TestFlushRtcp();
2594}
2595
2596TEST_F(VideoChannelTest, SendSsrcMuxToSsrcMux) {
2597  Base::SendSsrcMuxToSsrcMux();
2598}
2599
2600TEST_F(VideoChannelTest, SendSsrcMuxToSsrcMuxWithRtcpMux) {
2601  Base::SendSsrcMuxToSsrcMuxWithRtcpMux();
2602}
2603
2604// TODO(gangji): Add VideoChannelTest.TestChangeStateError.
2605
2606TEST_F(VideoChannelTest, TestSrtpError) {
2607  Base::TestSrtpError();
2608}
2609
2610TEST_F(VideoChannelTest, TestOnReadyToSend) {
2611  Base::TestOnReadyToSend();
2612}
2613
2614TEST_F(VideoChannelTest, TestOnReadyToSendWithRtcpMux) {
2615  Base::TestOnReadyToSendWithRtcpMux();
2616}
2617
2618TEST_F(VideoChannelTest, TestApplyViewRequest) {
2619  CreateChannels(0, 0);
2620  cricket::StreamParams stream2;
2621  stream2.id = "stream2";
2622  stream2.ssrcs.push_back(2222);
2623  local_media_content1_.AddStream(stream2);
2624
2625  EXPECT_TRUE(SendInitiate());
2626  EXPECT_TRUE(SendAccept());
2627
2628  cricket::VideoFormat send_format;
2629  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
2630  EXPECT_EQ(640, send_format.width);
2631  EXPECT_EQ(400, send_format.height);
2632  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), send_format.interval);
2633
2634  cricket::ViewRequest request;
2635  // stream1: 320x200x15; stream2: 0x0x0
2636  request.static_video_views.push_back(cricket::StaticVideoView(
2637      cricket::StreamSelector(kSsrc1), 320, 200, 15));
2638  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
2639  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
2640  EXPECT_EQ(320, send_format.width);
2641  EXPECT_EQ(200, send_format.height);
2642  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(15), send_format.interval);
2643  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(2222, &send_format));
2644  EXPECT_EQ(0, send_format.width);
2645  EXPECT_EQ(0, send_format.height);
2646
2647  // stream1: 160x100x8; stream2: 0x0x0
2648  request.static_video_views.clear();
2649  request.static_video_views.push_back(cricket::StaticVideoView(
2650      cricket::StreamSelector(kSsrc1), 160, 100, 8));
2651  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
2652  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
2653  EXPECT_EQ(160, send_format.width);
2654  EXPECT_EQ(100, send_format.height);
2655  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(8), send_format.interval);
2656
2657  // stream1: 0x0x0; stream2: 640x400x30
2658  request.static_video_views.clear();
2659  request.static_video_views.push_back(cricket::StaticVideoView(
2660      cricket::StreamSelector("", stream2.id), 640, 400, 30));
2661  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
2662  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
2663  EXPECT_EQ(0, send_format.width);
2664  EXPECT_EQ(0, send_format.height);
2665  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(2222, &send_format));
2666  EXPECT_EQ(640, send_format.width);
2667  EXPECT_EQ(400, send_format.height);
2668  EXPECT_EQ(cricket::VideoFormat::FpsToInterval(30), send_format.interval);
2669
2670  // stream1: 0x0x0; stream2: 0x0x0
2671  request.static_video_views.clear();
2672  EXPECT_TRUE(channel1_->ApplyViewRequest(request));
2673  EXPECT_TRUE(media_channel1_->GetSendStreamFormat(kSsrc1, &send_format));
2674  EXPECT_EQ(0, send_format.width);
2675  EXPECT_EQ(0, send_format.height);
2676}
2677
2678TEST_F(VideoChannelTest, TestSetChannelOptions) {
2679  TestSetChannelOptions();
2680}
2681
2682
2683// DataChannelTest
2684
2685class DataChannelTest
2686    : public ChannelTest<DataTraits> {
2687 public:
2688  typedef ChannelTest<DataTraits>
2689  Base;
2690  DataChannelTest() : Base(kDataPacket, sizeof(kDataPacket),
2691                           kRtcpReport, sizeof(kRtcpReport)) {
2692  }
2693};
2694
2695// Override to avoid engine channel parameter.
2696template<>
2697cricket::DataChannel* ChannelTest<DataTraits>::CreateChannel(
2698    talk_base::Thread* thread, cricket::MediaEngineInterface* engine,
2699    cricket::FakeDataMediaChannel* ch, cricket::BaseSession* session,
2700    bool rtcp) {
2701  cricket::DataChannel* channel = new cricket::DataChannel(
2702      thread, ch, session, cricket::CN_DATA, rtcp);
2703  if (!channel->Init()) {
2704    delete channel;
2705    channel = NULL;
2706  }
2707  return channel;
2708}
2709
2710template<>
2711void ChannelTest<DataTraits>::CreateContent(
2712    int flags,
2713    const cricket::AudioCodec& audio_codec,
2714    const cricket::VideoCodec& video_codec,
2715    cricket::DataContentDescription* data) {
2716  data->AddCodec(kGoogleDataCodec);
2717  data->set_rtcp_mux((flags & RTCP_MUX) != 0);
2718  if (flags & SECURE) {
2719    data->AddCrypto(cricket::CryptoParams(
2720        1, cricket::CS_AES_CM_128_HMAC_SHA1_32,
2721        "inline:" + talk_base::CreateRandomString(40), ""));
2722  }
2723}
2724
2725template<>
2726void ChannelTest<DataTraits>::CopyContent(
2727    const cricket::DataContentDescription& source,
2728    cricket::DataContentDescription* data) {
2729  *data = source;
2730}
2731
2732template<>
2733bool ChannelTest<DataTraits>::CodecMatches(const cricket::DataCodec& c1,
2734                                           const cricket::DataCodec& c2) {
2735  return c1.name == c2.name;
2736}
2737
2738template<>
2739void ChannelTest<DataTraits>::AddLegacyStreamInContent(
2740    uint32 ssrc, int flags, cricket::DataContentDescription* data) {
2741  data->AddLegacyStream(ssrc);
2742}
2743
2744TEST_F(DataChannelTest, TestInit) {
2745  Base::TestInit();
2746  EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2747}
2748
2749TEST_F(DataChannelTest, TestSetContents) {
2750  Base::TestSetContents();
2751}
2752
2753TEST_F(DataChannelTest, TestSetContentsNullOffer) {
2754  Base::TestSetContentsNullOffer();
2755}
2756
2757TEST_F(DataChannelTest, TestSetContentsRtcpMux) {
2758  Base::TestSetContentsRtcpMux();
2759}
2760
2761TEST_F(DataChannelTest, TestSetRemoteContentUpdate) {
2762  Base::TestSetRemoteContentUpdate();
2763}
2764
2765TEST_F(DataChannelTest, TestStreams) {
2766  Base::TestStreams();
2767}
2768
2769TEST_F(DataChannelTest, TestUpdateStreamsInLocalContent) {
2770  Base::TestUpdateStreamsInLocalContent();
2771}
2772
2773TEST_F(DataChannelTest, TestUpdateRemoteStreamsInContent) {
2774  Base::TestUpdateStreamsInRemoteContent();
2775}
2776
2777TEST_F(DataChannelTest, TestChangeStreamParamsInContent) {
2778  Base::TestChangeStreamParamsInContent();
2779}
2780
2781TEST_F(DataChannelTest, TestPlayoutAndSendingStates) {
2782  Base::TestPlayoutAndSendingStates();
2783}
2784
2785TEST_F(DataChannelTest, TestMediaContentDirection) {
2786  Base::TestMediaContentDirection();
2787}
2788
2789TEST_F(DataChannelTest, TestCallSetup) {
2790  Base::TestCallSetup();
2791}
2792
2793TEST_F(DataChannelTest, TestCallTeardownRtcpMux) {
2794  Base::TestCallTeardownRtcpMux();
2795}
2796
2797TEST_F(DataChannelTest, TestOnReadyToSend) {
2798  Base::TestOnReadyToSend();
2799}
2800
2801TEST_F(DataChannelTest, TestOnReadyToSendWithRtcpMux) {
2802  Base::TestOnReadyToSendWithRtcpMux();
2803}
2804
2805TEST_F(DataChannelTest, SendRtpToRtp) {
2806  Base::SendRtpToRtp();
2807}
2808
2809TEST_F(DataChannelTest, SendNoRtcpToNoRtcp) {
2810  Base::SendNoRtcpToNoRtcp();
2811}
2812
2813TEST_F(DataChannelTest, SendNoRtcpToRtcp) {
2814  Base::SendNoRtcpToRtcp();
2815}
2816
2817TEST_F(DataChannelTest, SendRtcpToNoRtcp) {
2818  Base::SendRtcpToNoRtcp();
2819}
2820
2821TEST_F(DataChannelTest, SendRtcpToRtcp) {
2822  Base::SendRtcpToRtcp();
2823}
2824
2825TEST_F(DataChannelTest, SendRtcpMuxToRtcp) {
2826  Base::SendRtcpMuxToRtcp();
2827}
2828
2829TEST_F(DataChannelTest, SendRtcpMuxToRtcpMux) {
2830  Base::SendRtcpMuxToRtcpMux();
2831}
2832
2833TEST_F(DataChannelTest, SendEarlyRtcpMuxToRtcp) {
2834  Base::SendEarlyRtcpMuxToRtcp();
2835}
2836
2837TEST_F(DataChannelTest, SendEarlyRtcpMuxToRtcpMux) {
2838  Base::SendEarlyRtcpMuxToRtcpMux();
2839}
2840
2841TEST_F(DataChannelTest, SendSrtpToSrtp) {
2842  Base::SendSrtpToSrtp();
2843}
2844
2845TEST_F(DataChannelTest, SendSrtpToRtp) {
2846  Base::SendSrtpToSrtp();
2847}
2848
2849TEST_F(DataChannelTest, SendSrtcpMux) {
2850  Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2851}
2852
2853TEST_F(DataChannelTest, SendRtpToRtpOnThread) {
2854  Base::SendRtpToRtpOnThread();
2855}
2856
2857TEST_F(DataChannelTest, SendSrtpToSrtpOnThread) {
2858  Base::SendSrtpToSrtpOnThread();
2859}
2860
2861TEST_F(DataChannelTest, SendWithWritabilityLoss) {
2862  Base::SendWithWritabilityLoss();
2863}
2864
2865TEST_F(DataChannelTest, TestMediaMonitor) {
2866  Base::TestMediaMonitor();
2867}
2868
2869TEST_F(DataChannelTest, TestSendData) {
2870  CreateChannels(0, 0);
2871  EXPECT_TRUE(SendInitiate());
2872  EXPECT_TRUE(SendAccept());
2873
2874  cricket::SendDataParams params;
2875  params.ssrc = 42;
2876  unsigned char data[] = {
2877    'f', 'o', 'o'
2878  };
2879  talk_base::Buffer payload(data, 3);
2880  cricket::SendDataResult result;
2881  ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
2882  EXPECT_EQ(params.ssrc,
2883            media_channel1_->last_sent_data_params().ssrc);
2884  EXPECT_EQ("foo", media_channel1_->last_sent_data());
2885}
2886
2887// TODO(pthatcher): TestSetReceiver?
Note: See TracBrowser for help on using the repository browser.