Add content type information to encoded images and corresponding rtp extension header

webrtc/video/overuse_frame_detector_unittest.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 80 matching lines @@
     return ((options_.low_encode_usage_threshold_percent +
              options_.high_encode_usage_threshold_percent) / 2.0f) + 0.5;
   }
 
   void InsertAndSendFramesWithInterval(int num_frames,
                                        int interval_us,
                                        int width,
                                        int height,
                                        int delay_us) {
     VideoFrame frame(I420Buffer::Create(width, height),
-                     webrtc::kVideoRotation_0, 0);
+                     webrtc::kVideoRotation_0, webrtc::kVideoContent_Default,
+                     0);
     uint32_t timestamp = 0;
     while (num_frames-- > 0) {
       frame.set_timestamp(timestamp);
       overuse_detector_->FrameCaptured(frame, rtc::TimeMicros());
       clock_.AdvanceTimeMicros(delay_us);
       overuse_detector_->FrameSent(timestamp, rtc::TimeMicros());
       clock_.AdvanceTimeMicros(interval_us - delay_us);
       timestamp += interval_us * 90 / 1000;
     }
   }
@@ skipping 167 matching lines @@
   ForceUpdate(kWidth, kHeight);
   EXPECT_EQ(InitialUsage(), UsagePercent());
 }
 
 TEST_F(OveruseFrameDetectorTest, MeasuresMultipleConcurrentSamples) {
   EXPECT_CALL(*(observer_.get()), AdaptDown(reason_))
       .Times(testing::AtLeast(1));
   static const int kIntervalUs = 33 * rtc::kNumMicrosecsPerMillisec;
   static const size_t kNumFramesEncodingDelay = 3;
   VideoFrame frame(I420Buffer::Create(kWidth, kHeight),
-                   webrtc::kVideoRotation_0, 0);
+                   webrtc::kVideoRotation_0, webrtc::kVideoContent_Default, 0);
   for (size_t i = 0; i < 1000; ++i) {
     // Unique timestamps.
     frame.set_timestamp(static_cast<uint32_t>(i));
     overuse_detector_->FrameCaptured(frame, rtc::TimeMicros());
     clock_.AdvanceTimeMicros(kIntervalUs);
     if (i > kNumFramesEncodingDelay) {
       overuse_detector_->FrameSent(
           static_cast<uint32_t>(i - kNumFramesEncodingDelay),
           rtc::TimeMicros());
     }
     overuse_detector_->CheckForOveruse();
   }
 }
 
 TEST_F(OveruseFrameDetectorTest, UpdatesExistingSamples) {
   // >85% encoding time should trigger overuse.
   EXPECT_CALL(*(observer_.get()), AdaptDown(reason_))
       .Times(testing::AtLeast(1));
   static const int kIntervalUs = 33 * rtc::kNumMicrosecsPerMillisec;
   static const int kDelayUs = 30 * rtc::kNumMicrosecsPerMillisec;
   VideoFrame frame(I420Buffer::Create(kWidth, kHeight),
-                   webrtc::kVideoRotation_0, 0);
+                   webrtc::kVideoRotation_0, webrtc::kVideoContent_Default, 0);
   uint32_t timestamp = 0;
   for (size_t i = 0; i < 1000; ++i) {
     frame.set_timestamp(timestamp);
     overuse_detector_->FrameCaptured(frame, rtc::TimeMicros());
     // Encode and send first parts almost instantly.
     clock_.AdvanceTimeMicros(rtc::kNumMicrosecsPerMillisec);
     overuse_detector_->FrameSent(timestamp, rtc::TimeMicros());
     // Encode heavier part, resulting in >85% usage total.
     clock_.AdvanceTimeMicros(kDelayUs - rtc::kNumMicrosecsPerMillisec);
     overuse_detector_->FrameSent(timestamp, rtc::TimeMicros());
@@ skipping 27 matching lines @@
     InsertAndSendFramesWithInterval(1300, kFrameIntervalUs, kWidth, kHeight,
                                     kDelayUs1);
     InsertAndSendFramesWithInterval(1, kFrameIntervalUs, kWidth, kHeight,
                                     kDelayUs2);
   });
 
   EXPECT_TRUE(event.Wait(10000));
 }
 
 }  // namespace webrtc