Forward the SignalFirstPacketReceived to RtpReceiver.

webrtc/api/peerconnection_unittest.cc

Index: webrtc/api/peerconnection_unittest.cc
diff --git a/webrtc/api/peerconnection_unittest.cc b/webrtc/api/peerconnection_unittest.cc
index 24411ab729060c09c9658aab987b49e0b9db85f5..03c0624c99237041eb28aeaf6070adca2c938769 100644
--- a/webrtc/api/peerconnection_unittest.cc
+++ b/webrtc/api/peerconnection_unittest.cc
@@ -146,6 +146,37 @@ class SignalingMessageReceiver {
   virtual ~SignalingMessageReceiver() {}
 };
 
+class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
+ public:
+  MockRtpReceiverObserver()
+      : is_first_audio_packet_recevied_(false),
+        is_first_video_packet_recevied_(false),
+        kind_("unset") {}
+
+  void onFirstPacketReceived(cricket::MediaType media_type) override {

[pthatcher2, 2016/05/20 20:23:13]

OnFirstPacketReceived

+    if (media_type == cricket::MEDIA_TYPE_AUDIO) {
+      is_first_audio_packet_recevied_ = true;
+    } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
+      is_first_video_packet_recevied_ = true;
+    }
+  }
+
+  void SetKind(std::string kind) { kind_ = kind; }
+
+  std::string kind() { return kind_; }
+
+  bool IsFirstAudioPacketReceived() { return is_first_audio_packet_recevied_; }
+
+  bool IsFirstVideoPacketReceived() { return is_first_video_packet_recevied_; }
+
+  virtual ~MockRtpReceiverObserver() {}
+
+ private:
+  bool is_first_audio_packet_recevied_;
+  bool is_first_video_packet_recevied_;
+  std::string kind_;
+};
+
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
                                  public ObserverInterface {
@@ -777,6 +808,11 @@ class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
     return pc()->ice_gathering_state();
   }
 
+  std::vector<rtc::scoped_refptr<MockRtpReceiverObserver>>
+  RtpReceiverObservers() {

[pthatcher2, 2016/05/20 20:23:13]

rtp_receiver_observers()

[zhihuang1, 2016/05/24 01:01:44]

Done.

+    return rtp_receiver_observers_;
+  }
+
  private:
   class DummyDtmfObserver : public DtmfSenderObserverInterface {
    public:
@@ -867,6 +903,8 @@ class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
     std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("offer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
+    // Register the RtpReceiverObserver after receivers are created.
+    DoRegisterRtpReceiverObservers();

[pthatcher2, 2016/05/20 20:23:13]

Why not just RegisterRtpReceiverObservers()?

[zhihuang1, 2016/05/24 01:01:44]

Done.

     std::unique_ptr<SessionDescriptionInterface> answer;
     EXPECT_TRUE(DoCreateAnswer(&answer));
     std::string sdp;
@@ -940,6 +978,16 @@ class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
     return true;
   }
 
+  void DoRegisterRtpReceiverObservers() {
+    for (auto receiver : pc()->GetReceivers()) {
+      rtc::scoped_refptr<MockRtpReceiverObserver> observer(
+          new rtc::RefCountedObject<MockRtpReceiverObserver>());
+      observer->SetKind(receiver->track()->kind());
+      receiver->RegisterRtpReceiverObserver(observer);
+      rtp_receiver_observers_.push_back(observer);
+    }
+  }
+
   bool DoSetRemoteDescription(SessionDescriptionInterface* desc) {
     rtc::scoped_refptr<MockSetSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
@@ -1023,6 +1071,9 @@ class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
 
   rtc::scoped_refptr<DataChannelInterface> data_channel_;
   std::unique_ptr<MockDataChannelObserver> data_observer_;
+
+  std::vector<rtc::scoped_refptr<MockRtpReceiverObserver>>
+      rtp_receiver_observers_;
 };
 
 class P2PTestConductor : public testing::Test {
@@ -1312,6 +1363,25 @@ class P2PTestConductor : public testing::Test {
     return old;
   }
 
+  // Only check the callee side because only callee can guarantee to register
+  // the observer before sending the data.

[pthatcher2, 2016/05/20 20:23:13]

Here's a simple solution:  whenever an observer is added after the event has
fired, tell the observer that the evern has fired by calling
OnFirstPacketReceived.

[zhihuang1, 2016/05/24 01:01:44]

This is a nice and easy solution.

+  void CheckRtpReceiverObserverAreCalled() {
+    for (auto observer : receiving_client_->RtpReceiverObservers()) {
+      if (observer->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) {
+        EXPECT_TRUE_WAIT(observer->IsFirstAudioPacketReceived(),
+                         kMaxWaitForFramesMs);
+        EXPECT_FALSE(observer->IsFirstVideoPacketReceived());
+      } else if (observer->kind() ==
+                 webrtc::MediaStreamTrackInterface::kVideoKind) {
+        EXPECT_FALSE(observer->IsFirstAudioPacketReceived());
+        EXPECT_TRUE_WAIT(observer->IsFirstVideoPacketReceived(),
+                         kMaxWaitForFramesMs);
+      } else {
+        EXPECT_TRUE(false);

[pthatcher2, 2016/05/20 20:23:13]

I think you can add a message to the EXPECT, like "Unknown RtpReceiver kind"

[zhihuang1, 2016/05/24 01:01:44]

Done.

+      }
+    }
+  }
+
  private:
   // |worker_thread_| is used by both |initiating_client_| and
   // |receiving_client_|. Must be destroyed last.
@@ -1329,6 +1399,12 @@ class P2PTestConductor : public testing::Test {
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
+TEST_F(P2PTestConductor, TestRtpReceiverObserverCallbackFunction) {
+  ASSERT_TRUE(CreateTestClients());
+  LocalP2PTest();
+  CheckRtpReceiverObserverAreCalled();

[pthatcher2, 2016/05/20 20:23:13]

If it's only called once, just put the code inline and don't bother with a
separate function.

[zhihuang1, 2016/05/24 01:01:44]

I will make it a helper function to check both the caller and callee side.

+}
+
 // This test sets up a Jsep call between two parties and test Dtmf.
 // TODO(holmer): Disabled due to sometimes crashing on buildbots.
 // See issue webrtc/2378.