Remove SendStreamFormat and ViewRequests.

talk/media/base/videoengine_unittest.h

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 215 matching lines @@
       success = channel_->SetSendParameters(parameters);
     }
     if (success) {
       success = SetSend(sending);
     }
     return success;
   }
   bool SetSend(bool send) {
     return channel_->SetSend(send);
   }
-  bool SetSendStreamFormat(uint32_t ssrc, const cricket::VideoCodec& codec) {
-    return channel_->SetSendStreamFormat(ssrc, cricket::VideoFormat(
-        codec.width, codec.height,
-        cricket::VideoFormat::FpsToInterval(codec.framerate),
-        cricket::FOURCC_ANY));
-  }
   int DrainOutgoingPackets() {
     int packets = 0;
     do {
       packets = NumRtpPackets();
       // 100 ms should be long enough.
       rtc::Thread::Current()->ProcessMessages(100);
     } while (NumRtpPackets() > packets);
     return NumRtpPackets();
   }
   bool SendFrame() {
@@ skipping 398 matching lines @@
     cricket::VideoSendParameters parameters;
     parameters.codecs.push_back(DefaultCodec());
     parameters.max_bandwidth_bps = -1;  // <= 0 means unlimited.
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     parameters.max_bandwidth_bps = 128 * 1024;
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
   }
   // Test that we can set the SSRC for the default send source.
   void SetSendSsrc() {
     EXPECT_TRUE(SetDefaultCodec());
-    EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     uint32_t ssrc = 0;
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
     // Packets are being paced out, so these can mismatch between the first and
     // second call to NumRtpPackets until pending packets are paced out.
     EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(ssrc), kTimeout);
     EXPECT_EQ_WAIT(NumRtpBytes(), NumRtpBytes(ssrc), kTimeout);
     EXPECT_EQ(1, NumSentSsrcs());
     EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
     EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
   }
   // Test that we can set the SSRC even after codecs are set.
   void SetSendSsrcAfterSetCodecs() {
     // Remove stream added in Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(999)));
     EXPECT_TRUE(channel_->SetCapturer(999u, video_capturer_.get()));
-    EXPECT_TRUE(SetSendStreamFormat(999u, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(WaitAndSendFrame(0));
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     uint32_t ssrc = 0;
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(999u, ssrc);
     // Packets are being paced out, so these can mismatch between the first and
     // second call to NumRtpPackets until pending packets are paced out.
     EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(ssrc), kTimeout);
@@ skipping 396 matching lines @@
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
 
     // Check that we send smaller frames at the new resolution.
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(33));
     EXPECT_TRUE(video_capturer_->CaptureCustomFrame(
         codec.width / 2, codec.height / 2, cricket::FOURCC_I420));
     EXPECT_FRAME_WAIT(2, codec.width / 2, codec.height / 2, kTimeout);
   }
-  // Tests that we can set the send stream format properly.
-  void SetSendStreamFormat() {
-    cricket::VideoCodec codec(DefaultCodec());
-    SendAndReceive(codec);
-    int frame_count = 1;
-    EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
-
-    // Adapt the resolution and frame rate to half.
-    cricket::VideoFormat format(
-        codec.width / 2,
-        codec.height / 2,
-        cricket::VideoFormat::FpsToInterval(codec.framerate / 2),
-        cricket::FOURCC_I420);
-    // The SSRC differs from the send SSRC.
-    EXPECT_FALSE(channel_->SetSendStreamFormat(kSsrc - 1, format));
-    EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
-
-    EXPECT_TRUE(WaitAndSendFrame(30));  // Should be dropped.
-    EXPECT_TRUE(WaitAndSendFrame(30));  // Should be rendered.
-    EXPECT_TRUE(WaitAndSendFrame(30));  // Should be dropped.
-    frame_count += 1;
-    EXPECT_FRAME_WAIT(frame_count, format.width, format.height, kTimeout);
-
-    // Adapt the resolution to 0x0, which should drop all frames.
-    format.width = 0;
-    format.height = 0;
-    EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
-    EXPECT_TRUE(SendFrame());
-    EXPECT_TRUE(SendFrame());
-    rtc::Thread::Current()->ProcessMessages(500);
-    EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
-  }
-  // Test that setting send stream format to 0x0 resolution will result in
-  // frames being dropped.
-  void SetSendStreamFormat0x0() {
-    EXPECT_TRUE(SetOneCodec(DefaultCodec()));
-    EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
-    EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
-    EXPECT_EQ(0, renderer_.num_rendered_frames());
-    // This frame should be received.
-    EXPECT_TRUE(SendFrame());
-    EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
-    const int64_t interval =
-        cricket::VideoFormat::FpsToInterval(DefaultCodec().framerate);
-    cricket::VideoFormat format(
-        0,
-        0,
-        interval,
-        cricket::FOURCC_I420);
-    EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
-    // This frame should not be received.
-    EXPECT_TRUE(WaitAndSendFrame(
-        static_cast<int>(interval/rtc::kNumNanosecsPerMillisec)));
-    rtc::Thread::Current()->ProcessMessages(500);
-    EXPECT_EQ(1, renderer_.num_rendered_frames());
-  }
 
   // Tests that we can mute and unmute the channel properly.
   void MuteStream() {
     EXPECT_TRUE(SetDefaultCodec());
     cricket::FakeVideoCapturer video_capturer;
     video_capturer.Start(
         cricket::VideoFormat(
             640, 480,
             cricket::VideoFormat::FpsToInterval(30),
             cricket::FOURCC_I420));
@@ skipping 111 matching lines @@
   rtc::scoped_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
 
   // Used by test cases where 2 streams are run on the same channel.
   cricket::FakeVideoRenderer renderer2_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT