Un-flaking TestSrtpError by using a fake clock.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/buffer.h"
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/fakertp.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/testutils.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/pc/channel.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
@@ skipping 1720 matching lines @@
     // So we need to pass in pl_type so that the packet can pass through
     // the bundle filter before it can be processed by the srtp filter.
     // The packet is not a valid srtp packet because it is too short.
     static unsigned const char kBadPacket[] = {
         0x84, static_cast<unsigned char>(pl_type),
         0x00, 0x01,
         0x00, 0x00,
         0x00, 0x00,
         0x00, 0x00,
         0x00, 0x01};
+
+    // Using fake clock because this tests that SRTP errors are signaled at
+    // specific times based on set_signal_silent_time.
+    rtc::ScopedFakeClock fake_clock;
+    // Some code uses a time of 0 as a special value, so we must start with
+    // a non-zero time.
+    // TODO(deadbeef): Fix this.
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromSeconds(1));
+
     CreateChannels(RTCP | SECURE, RTCP | SECURE);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(channel1_->secure());
     EXPECT_TRUE(channel2_->secure());
     channel2_->srtp_filter()->set_signal_silent_time(250);
     channel2_->srtp_filter()->SignalSrtpError.connect(
         &error_handler, &SrtpErrorHandler::OnSrtpError);
 
     // Testing failures in sending packets.
     media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
                              rtc::PacketOptions());
     WaitForThreads();
     // The first failure will trigger an error.
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
     error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
     error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
     // The next 250 ms failures will not trigger an error.
     media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
                              rtc::PacketOptions());
     // Wait for a while to ensure no message comes in.
     WaitForThreads();
-    rtc::Thread::Current()->ProcessMessages(200);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
     EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
     // Wait for a little more - the error will be triggered again.
-    rtc::Thread::Current()->ProcessMessages(200);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
     media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
                              rtc::PacketOptions());
     WaitForThreads();
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
 
     // Testing failures in receiving packets.
     error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
     error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       cricket::TransportChannel* transport_channel =
           channel2_->transport_channel();
       transport_channel->SignalReadPacket(
           transport_channel, reinterpret_cast<const char*>(kBadPacket),
           sizeof(kBadPacket), rtc::PacketTime(), 0);
     });
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
+    // Terminate channels before the fake clock is destroyed.
+    EXPECT_TRUE(SendTerminate());
   }
 
   void TestOnReadyToSend() {
     CreateChannels(RTCP, RTCP);
     TransportChannel* rtp = channel1_->transport_channel();
     TransportChannel* rtcp = channel1_->rtcp_transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtp] { rtp->SignalReadyToSend(rtp); });
@@ skipping 1780 matching lines @@
   };
   rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?