Unify FrameType and VideoFrameType.

webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h

 /*
  *  Copyright (c) 2014 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 320 matching lines @@
         input_frame_.allocated_size(kUPlane));
     memset(input_frame_.buffer(kVPlane), 0,
         input_frame_.allocated_size(kVPlane));
   }
 
   virtual void TearDown() {
     encoder_->Release();
     decoder_->Release();
   }
 
-  void ExpectStreams(VideoFrameType frame_type, int expected_video_streams) {
+  void ExpectStreams(FrameType frame_type, int expected_video_streams) {
     ASSERT_GE(expected_video_streams, 0);
     ASSERT_LE(expected_video_streams, kNumberOfSimulcastStreams);
     if (expected_video_streams >= 1) {
       EXPECT_CALL(encoder_callback_, Encoded(
           AllOf(Field(&EncodedImage::_frameType, frame_type),
                 Field(&EncodedImage::_encodedWidth, kDefaultWidth / 4),
                 Field(&EncodedImage::_encodedHeight, kDefaultHeight / 4)), _, _)
                   )
           .Times(1)
           .WillRepeatedly(Return(0));
@@ skipping 30 matching lines @@
                                                 &layer_sync, i);
       EXPECT_EQ(expected_temporal_idx[i], temporal_layer);
       EXPECT_EQ(expected_layer_sync[i], layer_sync);
     }
   }
 
   // We currently expect all active streams to generate a key frame even though
   // a key frame was only requested for some of them.
   void TestKeyFrameRequestsOnAllStreams() {
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, kNumberOfSimulcastStreams);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, kNumberOfSimulcastStreams);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     frame_types[0] = kKeyFrame;
     ExpectStreams(kKeyFrame, kNumberOfSimulcastStreams);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
@@ skipping 13 matching lines @@
 
     std::fill(frame_types.begin(), frame_types.end(), kDeltaFrame);
     ExpectStreams(kDeltaFrame, kNumberOfSimulcastStreams);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingAllStreams() {
     // We should always encode the base layer.
     encoder_->SetRates(kMinBitrates[0] - 1, 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 1);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 1);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreams() {
     // We have just enough to get only the first stream and padding for two.
     encoder_->SetRates(kMinBitrates[0], 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 1);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 1);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreamsOneMaxedOut() {
     // We are just below limit of sending second stream, so we should get
     // the first stream maxed out (at |maxBitrate|), and padding for two.
     encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1] - 1, 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 1);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 1);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStream() {
     // We have just enough to send two streams, so padding for one stream.
     encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1], 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 2);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 2);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStreamTwoMaxedOut() {
     // We are just below limit of sending third stream, so we should get
     // first stream's rate maxed out at |targetBitrate|, second at |maxBitrate|.
     encoder_->SetRates(kTargetBitrates[0] + kTargetBitrates[1] +
                        kMinBitrates[2] - 1, 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 2);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 2);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestSendAllStreams() {
     // We have just enough to send all streams.
     encoder_->SetRates(kTargetBitrates[0] + kTargetBitrates[1] +
                        kMinBitrates[2], 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 3);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 3);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestDisablingStreams() {
     // We should get three media streams.
     encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1] +
                        kMaxBitrates[2], 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     ExpectStreams(kKeyFrame, 3);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     ExpectStreams(kDeltaFrame, 3);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     // We should only get two streams and padding for one.
     encoder_->SetRates(kTargetBitrates[0] + kTargetBitrates[1] +
                        kMinBitrates[2] / 2, 30);
@@ skipping 60 matching lines @@
         maxBitrate = 0;
     // The highest layer has to correspond to the non-simulcast resolution.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].
         width = settings_.width;
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].
         height = settings_.height;
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
 
     // Encode one frame and verify.
     encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
-    std::vector<VideoFrameType> frame_types(kNumberOfSimulcastStreams,
-                                            kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfSimulcastStreams, kDeltaFrame);
     EXPECT_CALL(encoder_callback_, Encoded(
         AllOf(Field(&EncodedImage::_frameType, kKeyFrame),
               Field(&EncodedImage::_encodedWidth, width),
               Field(&EncodedImage::_encodedHeight, height)), _, _))
         .Times(1)
         .WillRepeatedly(Return(0));
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     // Switch back.
     DefaultSettings(&settings_, kDefaultTemporalLayerProfile);
@@ skipping 386 matching lines @@
   rtc::scoped_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
   VideoFrame input_frame_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_