Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / third_party / webrtc / test / rtp_rtcp_observer.h

diff --git a/src/third_party/webrtc/test/rtp_rtcp_observer.h b/src/third_party/webrtc/test/rtp_rtcp_observer.h
index ee06e2a..11531b3 100644 (file)
--- a/src/third_party/webrtc/test/rtp_rtcp_observer.h
+++ b/src/third_party/webrtc/test/rtp_rtcp_observer.h
@@ -13,6 +13,10 @@
 #include <map>
 #include <vector>
 
+#include "testing/gtest/include/gtest/gtest.h"
+
+#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/test/direct_transport.h"
 #include "webrtc/typedefs.h"
 #include "webrtc/video_send_stream.h"
 
@@ -21,6 +25,7 @@ namespace test {
 
 class RtpRtcpObserver {
  public:
+  virtual ~RtpRtcpObserver() {}
   newapi::Transport* SendTransport() {
     return &send_transport_;
   }
@@ -29,8 +34,8 @@ class RtpRtcpObserver {
     return &receive_transport_;
   }
 
-  void SetReceivers(PacketReceiver* send_transport_receiver,
-                    PacketReceiver* receive_transport_receiver) {
+  virtual void SetReceivers(PacketReceiver* send_transport_receiver,
+                            PacketReceiver* receive_transport_receiver) {
     send_transport_.SetReceiver(send_transport_receiver);
     receive_transport_.SetReceiver(receive_transport_receiver);
   }
@@ -40,20 +45,44 @@ class RtpRtcpObserver {
     receive_transport_.StopSending();
   }
 
-  EventTypeWrapper Wait() { return observation_complete_->Wait(timeout_ms_); }
+  virtual EventTypeWrapper Wait() {
+    EventTypeWrapper result = observation_complete_->Wait(timeout_ms_);
+    observation_complete_->Reset();
+    return result;
+  }
 
  protected:
-  RtpRtcpObserver(unsigned int event_timeout_ms)
-      : lock_(CriticalSectionWrapper::CreateCriticalSection()),
+  RtpRtcpObserver(unsigned int event_timeout_ms,
+      const FakeNetworkPipe::Config& configuration)
+      : crit_(CriticalSectionWrapper::CreateCriticalSection()),
         observation_complete_(EventWrapper::Create()),
-        send_transport_(lock_.get(),
+        parser_(RtpHeaderParser::Create()),
+        send_transport_(crit_.get(),
                         this,
                         &RtpRtcpObserver::OnSendRtp,
-                        &RtpRtcpObserver::OnSendRtcp),
-        receive_transport_(lock_.get(),
+                        &RtpRtcpObserver::OnSendRtcp,
+                        configuration),
+        receive_transport_(crit_.get(),
                            this,
                            &RtpRtcpObserver::OnReceiveRtp,
-                           &RtpRtcpObserver::OnReceiveRtcp),
+                           &RtpRtcpObserver::OnReceiveRtcp,
+                           configuration),
+        timeout_ms_(event_timeout_ms) {}
+
+  explicit RtpRtcpObserver(unsigned int event_timeout_ms)
+      : crit_(CriticalSectionWrapper::CreateCriticalSection()),
+        observation_complete_(EventWrapper::Create()),
+        parser_(RtpHeaderParser::Create()),
+        send_transport_(crit_.get(),
+                        this,
+                        &RtpRtcpObserver::OnSendRtp,
+                        &RtpRtcpObserver::OnSendRtcp,
+                        FakeNetworkPipe::Config()),
+        receive_transport_(crit_.get(),
+                           this,
+                           &RtpRtcpObserver::OnReceiveRtp,
+                           &RtpRtcpObserver::OnReceiveRtcp,
+                           FakeNetworkPipe::Config()),
         timeout_ms_(event_timeout_ms) {}
 
   enum Action {
@@ -61,42 +90,49 @@ class RtpRtcpObserver {
     DROP_PACKET,
   };
 
-  virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
+  virtual Action OnSendRtp(const uint8_t* packet, size_t length)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     return SEND_PACKET;
   }
 
-  virtual Action OnSendRtcp(const uint8_t* packet, size_t length) {
+  virtual Action OnSendRtcp(const uint8_t* packet, size_t length)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     return SEND_PACKET;
   }
 
-  virtual Action OnReceiveRtp(const uint8_t* packet, size_t length) {
+  virtual Action OnReceiveRtp(const uint8_t* packet, size_t length)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     return SEND_PACKET;
   }
 
-  virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length) {
+  virtual Action OnReceiveRtcp(const uint8_t* packet, size_t length)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     return SEND_PACKET;
   }
 
-
  private:
   class PacketTransport : public test::DirectTransport {
    public:
     typedef Action (RtpRtcpObserver::*PacketTransportAction)(const uint8_t*,
                                                              size_t);
+
     PacketTransport(CriticalSectionWrapper* lock,
                     RtpRtcpObserver* observer,
                     PacketTransportAction on_rtp,
-                    PacketTransportAction on_rtcp)
-        : lock_(lock),
+                    PacketTransportAction on_rtcp,
+                    const FakeNetworkPipe::Config& configuration)
+        : test::DirectTransport(configuration),
+          crit_(lock),
           observer_(observer),
           on_rtp_(on_rtp),
           on_rtcp_(on_rtcp) {}
 
   private:
-    virtual bool SendRTP(const uint8_t* packet, size_t length) OVERRIDE {
+    virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE {
+      EXPECT_FALSE(RtpHeaderParser::IsRtcp(packet, length));
       Action action;
       {
-        CriticalSectionScoped crit_(lock_);
+        CriticalSectionScoped lock(crit_);
         action = (observer_->*on_rtp_)(packet, length);
       }
       switch (action) {
@@ -104,15 +140,16 @@ class RtpRtcpObserver {
           // Drop packet silently.
           return true;
         case SEND_PACKET:
-          return test::DirectTransport::SendRTP(packet, length);
+          return test::DirectTransport::SendRtp(packet, length);
       }
       return true;  // Will never happen, makes compiler happy.
     }
 
-    virtual bool SendRTCP(const uint8_t* packet, size_t length) OVERRIDE {
+    virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
+      EXPECT_TRUE(RtpHeaderParser::IsRtcp(packet, length));
       Action action;
       {
-        CriticalSectionScoped crit_(lock_);
+        CriticalSectionScoped lock(crit_);
         action = (observer_->*on_rtcp_)(packet, length);
       }
       switch (action) {
@@ -120,21 +157,22 @@ class RtpRtcpObserver {
           // Drop packet silently.
           return true;
         case SEND_PACKET:
-          return test::DirectTransport::SendRTCP(packet, length);
+          return test::DirectTransport::SendRtcp(packet, length);
       }
       return true;  // Will never happen, makes compiler happy.
     }
 
     // Pointer to shared lock instance protecting on_rtp_/on_rtcp_ calls.
-    CriticalSectionWrapper* lock_;
+    CriticalSectionWrapper* const crit_;
 
-    RtpRtcpObserver* observer_;
-    PacketTransportAction on_rtp_, on_rtcp_;
+    RtpRtcpObserver* const observer_;
+    const PacketTransportAction on_rtp_, on_rtcp_;
   };
 
  protected:
-  scoped_ptr<CriticalSectionWrapper> lock_;
-  scoped_ptr<EventWrapper> observation_complete_;
+  const scoped_ptr<CriticalSectionWrapper> crit_;
+  const scoped_ptr<EventWrapper> observation_complete_;
+  const scoped_ptr<RtpHeaderParser> parser_;
 
  private:
   PacketTransport send_transport_, receive_transport_;