Work on flexible mode and screen sharing.

webrtc/test/layer_filtering_transport.cc

Index: webrtc/test/layer_filtering_transport.cc
diff --git a/webrtc/test/layer_filtering_transport.cc b/webrtc/test/layer_filtering_transport.cc
index 102f63eb3f55d9d2f1319e0d44d73d3c02c183be..6eab3f686e691c119a2df4b307409ddf1e405760 100644
--- a/webrtc/test/layer_filtering_transport.cc
+++ b/webrtc/test/layer_filtering_transport.cc
@@ -39,6 +39,10 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet, size_t length) {
     return test::DirectTransport::SendRtp(packet, length);
   }
 
+  uint8_t temp_buffer[IP_PACKET_SIZE];
+  memcpy(temp_buffer, packet, length);
+
+  bool discard = false;
   bool set_marker_bit = false;
   rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
   RTPHeader header;
@@ -73,26 +77,58 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet, size_t length) {
            temporalIdx >= tl_discard_threshold_) ||
           (sl_discard_threshold_ > 0 && spatialIdx != kNoSpatialIdx &&
            spatialIdx >= sl_discard_threshold_)) {
-        return true;  // Discard the packet.
+        discard = true;
       }
     } else {
       RTC_NOTREACHED() << "Parse error";
     }
   }
 
-  uint8_t temp_buffer[IP_PACKET_SIZE];
-  memcpy(temp_buffer, packet, length);
-
   // We are discarding some of the packets (specifically, whole layers), so
   // make sure the marker bit is set properly, and that sequence numbers are
   // continuous.
-  if (set_marker_bit) {
+  if (set_marker_bit)
     temp_buffer[1] |= kRtpMarkerBitMask;
-  }
-  ByteWriter<uint16_t>::WriteBigEndian(&temp_buffer[2], current_seq_num_);
 
-  ++current_seq_num_;  // Increase only if packet not discarded.
+  if (discard && header.headerLength != length) {
+    // Min and max padding according to RTP specification.
+    const size_t kMaxPaddingBytes = 255;
+    const size_t kMinPaddingBytes = 1;
+    DCHECK_LT(header.headerLength, length);
+    temp_buffer[0] |= 0x20;  // Padding bit.
+    temp_buffer[1] &= ~kRtpMarkerBitMask;
+    size_t bytes_left = length;
+    while (bytes_left > 0) {
+      size_t padding_length;
+      if (bytes_left >=
+          kMaxPaddingBytes + kMinPaddingBytes + header.headerLength * 2) {
+        // Room left for another padding packet even after emitting one of
+        // maximum size.
+        padding_length = kMaxPaddingBytes;
+      } else if (bytes_left > kMaxPaddingBytes + header.headerLength) {
+        // If we make this padding packet the maximum size, the remained of the
+        // buffer won't fit a packet of minimum size.
+        padding_length =
+            kMaxPaddingBytes - header.headerLength - kMinPaddingBytes;
+      } else {
+        DCHECK_LT(header.headerLength, bytes_left);
+        padding_length = bytes_left - header.headerLength;
+      }
+      DCHECK_GE(padding_length, kMinPaddingBytes);
+      uint16_t seq_num = ++current_seq_num_;
+      ByteWriter<uint16_t>::WriteBigEndian(&temp_buffer[2], seq_num);
+      size_t packet_length = header.headerLength + padding_length;
+      temp_buffer[packet_length - 1] = static_cast<uint8_t>(padding_length);
+      bool result = test::DirectTransport::SendRtp(temp_buffer, packet_length);
+      DCHECK(result);
+      DCHECK_GE(bytes_left, packet_length);
+      bytes_left -= packet_length;
+    }
+    return true;
+  }
 
+  uint16_t seq_num = ++current_seq_num_;
+  ByteWriter<uint16_t>::WriteBigEndian(&temp_buffer[2], seq_num);
   return test::DirectTransport::SendRtp(temp_buffer, length);
 }