Unify FrameType and VideoFrameType.

Prevents some heap allocation and frame-type conversion since interfaces
mismatch. Also it's less confusing to have one type for this.

BUG=webrtc:5042
R=magjed@webrtc.org, mflodman@webrtc.org, henrik.lundin@webrtc.org, solenberg@webrtc.org, stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1371043003

Cr-Commit-Position: refs/heads/master@{#10320}

32 files changed, 83 insertions, 140 deletions

diff --git a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
index 69e52a5b27..22ace500ff 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
+++ b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
@@ -242,7 +242,7 @@ int H264VideoToolboxEncoder::InitEncode(const VideoCodec* codec_settings,
 int H264VideoToolboxEncoder::Encode(
     const VideoFrame& input_image,
     const CodecSpecificInfo* codec_specific_info,
-    const std::vector<VideoFrameType>* frame_types) {
+    const std::vector<FrameType>* frame_types) {
   if (input_image.IsZeroSize()) {
     // It's possible to get zero sizes as a signal to produce keyframes (this
     // happens for internal sources). But this shouldn't happen in
diff --git a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h
index 28cd63ed29..f4fb86fa04 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h
+++ b/webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h
@@ -38,7 +38,7 @@ class H264VideoToolboxEncoder : public H264Encoder {
 
   int Encode(const VideoFrame& input_image,
              const CodecSpecificInfo* codec_specific_info,
-             const std::vector<VideoFrameType>* frame_types) override;
+             const std::vector<FrameType>* frame_types) override;
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
diff --git a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
index 35f7b3e1b9..e54e78db57 100644
--- a/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
+++ b/webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
@@ -50,7 +50,7 @@ class I420Encoder : public VideoEncoder {
 //                                <0 - Error
   int Encode(const VideoFrame& inputImage,
              const CodecSpecificInfo* /*codecSpecificInfo*/,
-             const std::vector<VideoFrameType>* /*frame_types*/) override;
+             const std::vector<FrameType>* /*frame_types*/) override;
 
 // Register an encode complete callback object.
 //
diff --git a/webrtc/modules/video_coding/codecs/i420/main/source/i420.cc b/webrtc/modules/video_coding/codecs/i420/main/source/i420.cc
index 5ac785a24a..065a2d76cc 100644
--- a/webrtc/modules/video_coding/codecs/i420/main/source/i420.cc
+++ b/webrtc/modules/video_coding/codecs/i420/main/source/i420.cc
@@ -74,7 +74,7 @@ int I420Encoder::InitEncode(const VideoCodec* codecSettings,
 
 int I420Encoder::Encode(const VideoFrame& inputImage,
                         const CodecSpecificInfo* /*codecSpecificInfo*/,
-                        const std::vector<VideoFrameType>* /*frame_types*/) {
+                        const std::vector<FrameType>* /*frame_types*/) {
   if (!_inited) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
diff --git a/webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h b/webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
index 5710446f16..5243d9afb8 100644
--- a/webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
+++ b/webrtc/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
@@ -35,7 +35,7 @@ class MockVideoEncoder : public VideoEncoder {
   MOCK_METHOD3(Encode,
                int32_t(const VideoFrame& inputImage,
                        const CodecSpecificInfo* codecSpecificInfo,
-                       const std::vector<VideoFrameType>* frame_types));
+                       const std::vector<FrameType>* frame_types));
   MOCK_METHOD1(RegisterEncodeCompleteCallback,
                int32_t(EncodedImageCallback* callback));
   MOCK_METHOD0(Release, int32_t());
diff --git a/webrtc/modules/video_coding/codecs/test/stats.h b/webrtc/modules/video_coding/codecs/test/stats.h
index 8dc8f159fe..83ba108bb7 100644
--- a/webrtc/modules/video_coding/codecs/test/stats.h
+++ b/webrtc/modules/video_coding/codecs/test/stats.h
@@ -39,7 +39,7 @@ struct FrameStatistic {
 
   // Copied from EncodedImage
   size_t encoded_frame_length_in_bytes;
-  webrtc::VideoFrameType frame_type;
+  webrtc::FrameType frame_type;
 };
 
 // Handles statistics from a single video processing run.
diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.cc b/webrtc/modules/video_coding/codecs/test/videoprocessor.cc
index 888adb8939..3bb6b7a749 100644
--- a/webrtc/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.cc
@@ -162,7 +162,7 @@ size_t VideoProcessorImpl::EncodedFrameSize() {
   return encoded_frame_size_;
 }
 
-VideoFrameType VideoProcessorImpl::EncodedFrameType() {
+FrameType VideoProcessorImpl::EncodedFrameType() {
   return encoded_frame_type_;
 }
 
@@ -199,7 +199,7 @@ bool VideoProcessorImpl::ProcessFrame(int frame_number) {
     source_frame_.set_timestamp(frame_number);
 
     // Decide if we're going to force a keyframe:
-    std::vector<VideoFrameType> frame_types(1, kDeltaFrame);
+    std::vector<FrameType> frame_types(1, kDeltaFrame);
     if (config_.keyframe_interval > 0 &&
         frame_number % config_.keyframe_interval == 0) {
       frame_types[0] = kKeyFrame;
diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.h b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
index 8c9cb1211a..4b6aed1d5b 100644
--- a/webrtc/modules/video_coding/codecs/test/videoprocessor.h
+++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.h
@@ -147,7 +147,7 @@ class VideoProcessor {
   virtual size_t EncodedFrameSize() = 0;
 
   // Return the encoded frame type (key or delta).
-  virtual VideoFrameType EncodedFrameType() = 0;
+  virtual FrameType EncodedFrameType() = 0;
 
   // Return the number of dropped frames.
   virtual int NumberDroppedFrames() = 0;
@@ -183,7 +183,7 @@ class VideoProcessorImpl : public VideoProcessor {
   // Return the size of the encoded frame in bytes.
   size_t EncodedFrameSize() override;
   // Return the encoded frame type (key or delta).
-  VideoFrameType EncodedFrameType() override;
+  FrameType EncodedFrameType() override;
   // Return the number of dropped frames.
   int NumberDroppedFrames() override;
   // Return the number of spatial resizes.
@@ -212,7 +212,7 @@ class VideoProcessorImpl : public VideoProcessor {
   // If Init() has executed successfully.
   bool initialized_;
   size_t encoded_frame_size_;
-  VideoFrameType encoded_frame_type_;
+  FrameType encoded_frame_type_;
   int prev_time_stamp_;
   int num_dropped_frames_;
   int num_spatial_resizes_;
diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc b/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc
index 9f8ff49bee..ec9d7567ce 100644
--- a/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc
+++ b/webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.cc
@@ -268,7 +268,7 @@ class VideoProcessorIntegrationTest: public testing::Test {
   }
 
   // For every encoded frame, update the rate control metrics.
-  void UpdateRateControlMetrics(int frame_num, VideoFrameType frame_type) {
+  void UpdateRateControlMetrics(int frame_num, FrameType frame_type) {
     float encoded_size_kbits = processor_->EncodedFrameSize() * 8.0f / 1000.0f;
     // Update layer data.
     // Update rate mismatch relative to per-frame bandwidth for delta frames.
@@ -450,7 +450,7 @@ class VideoProcessorIntegrationTest: public testing::Test {
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
     int frame_number = 0;
-    VideoFrameType frame_type = kDeltaFrame;
+    FrameType frame_type = kDeltaFrame;
     while (processor_->ProcessFrame(frame_number) &&
         frame_number < num_frames) {
       // Get the layer index for the frame |frame_number|.
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
index 9ac2efabe6..4439267cd2 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
@@ -233,7 +233,7 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst,
 int SimulcastEncoderAdapter::Encode(
     const VideoFrame& input_image,
     const CodecSpecificInfo* codec_specific_info,
-    const std::vector<VideoFrameType>* frame_types) {
+    const std::vector<FrameType>* frame_types) {
   if (!Initialized()) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
@@ -267,7 +267,7 @@ int SimulcastEncoderAdapter::Encode(
     if (!streaminfos_[stream_idx].send_stream)
       continue;
 
-    std::vector<VideoFrameType> stream_frame_types;
+    std::vector<FrameType> stream_frame_types;
     if (send_key_frame) {
       stream_frame_types.push_back(kKeyFrame);
       streaminfos_[stream_idx].key_frame_request = false;
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
index c00d8fb80a..afec024abc 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
@@ -42,7 +42,7 @@ class SimulcastEncoderAdapter : public VP8Encoder {
                  size_t max_payload_size) override;
   int Encode(const VideoFrame& input_image,
              const CodecSpecificInfo* codec_specific_info,
-             const std::vector<VideoFrameType>* frame_types) override;
+             const std::vector<FrameType>* frame_types) override;
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
   int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
   int SetRates(uint32_t new_bitrate_kbit, uint32_t new_framerate) override;
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
index ed6541c3a8..218b5e2d1a 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
@@ -117,7 +117,7 @@ class MockVideoEncoder : public VideoEncoder {
 
   int32_t Encode(const VideoFrame& inputImage,
                  const CodecSpecificInfo* codecSpecificInfo,
-                 const std::vector<VideoFrameType>* frame_types) override {
+                 const std::vector<FrameType>* frame_types) override {
     return 0;
   }
 
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
index 672fa3aa89..a3d9e5a061 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
@@ -338,7 +338,7 @@ class TestVp8Simulcast : public ::testing::Test {
     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) {
@@ -389,8 +389,7 @@ class TestVp8Simulcast : public ::testing::Test {
   // 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));
 
@@ -424,8 +423,7 @@ class TestVp8Simulcast : public ::testing::Test {
   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));
 
@@ -437,8 +435,7 @@ class TestVp8Simulcast : public ::testing::Test {
   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));
 
@@ -451,8 +448,7 @@ class TestVp8Simulcast : public ::testing::Test {
     // 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));
 
@@ -464,8 +460,7 @@ class TestVp8Simulcast : public ::testing::Test {
   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));
 
@@ -479,8 +474,7 @@ class TestVp8Simulcast : public ::testing::Test {
     // 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));
 
@@ -493,8 +487,7 @@ class TestVp8Simulcast : public ::testing::Test {
     // 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));
 
@@ -507,8 +500,7 @@ class TestVp8Simulcast : public ::testing::Test {
     // 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));
 
@@ -589,8 +581,7 @@ class TestVp8Simulcast : public ::testing::Test {
 
     // 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),
diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
index 2885bb88f6..d6f36f2d27 100644
--- a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
@@ -706,7 +706,7 @@ uint32_t VP8EncoderImpl::MaxIntraTarget(uint32_t optimalBuffersize) {
 
 int VP8EncoderImpl::Encode(const VideoFrame& frame,
                            const CodecSpecificInfo* codec_specific_info,
-                           const std::vector<VideoFrameType>* frame_types) {
+                           const std::vector<FrameType>* frame_types) {
   TRACE_EVENT1("webrtc", "VP8::Encode", "timestamp", frame.timestamp());
 
   if (!inited_)
diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.h b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.h
index 5ff1485ed5..ba14ed5841 100644
--- a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.h
+++ b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.h
@@ -48,7 +48,7 @@ class VP8EncoderImpl : public VP8Encoder {
 
   virtual int Encode(const VideoFrame& input_image,
                      const CodecSpecificInfo* codec_specific_info,
-                     const std::vector<VideoFrameType>* frame_types);
+                     const std::vector<FrameType>* frame_types);
 
   virtual int RegisterEncodeCompleteCallback(EncodedImageCallback* callback);
 
diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
index deb3bca5e4..1a2137139b 100644
--- a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
+++ b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc
@@ -422,7 +422,7 @@ uint32_t VP9EncoderImpl::MaxIntraTarget(uint32_t optimal_buffer_size) {
 
 int VP9EncoderImpl::Encode(const VideoFrame& input_image,
                            const CodecSpecificInfo* codec_specific_info,
-                           const std::vector<VideoFrameType>* frame_types) {
+                           const std::vector<FrameType>* frame_types) {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
@@ -432,7 +432,7 @@ int VP9EncoderImpl::Encode(const VideoFrame& input_image,
   if (encoded_complete_callback_ == NULL) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  VideoFrameType frame_type = kDeltaFrame;
+  FrameType frame_type = kDeltaFrame;
   // We only support one stream at the moment.
   if (frame_types && frame_types->size() > 0) {
     frame_type = (*frame_types)[0];
diff --git a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
index c164a63980..f9c123079e 100644
--- a/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
+++ b/webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
@@ -35,7 +35,7 @@ class VP9EncoderImpl : public VP9Encoder {
 
   int Encode(const VideoFrame& input_image,
              const CodecSpecificInfo* codec_specific_info,
-             const std::vector<VideoFrameType>* frame_types) override;
+             const std::vector<FrameType>* frame_types) override;
 
   int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
 
diff --git a/webrtc/modules/video_coding/main/source/decoding_state_unittest.cc b/webrtc/modules/video_coding/main/source/decoding_state_unittest.cc
index 10f1d6e4dd..feae701a65 100644
--- a/webrtc/modules/video_coding/main/source/decoding_state_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/decoding_state_unittest.cc
@@ -181,7 +181,7 @@ TEST(TestDecodingState, UpdateOldPacket) {
   // Now insert empty packet belonging to the same frame.
   packet.timestamp = 1;
   packet.seqNum = 2;
-  packet.frameType = kFrameEmpty;
+  packet.frameType = kEmptyFrame;
   packet.sizeBytes = 0;
   dec_state.UpdateOldPacket(&packet);
   EXPECT_EQ(dec_state.sequence_num(), 2);
@@ -196,7 +196,7 @@ TEST(TestDecodingState, UpdateOldPacket) {
   // sequence number.
   packet.timestamp = 0;
   packet.seqNum = 4;
-  packet.frameType = kFrameEmpty;
+  packet.frameType = kEmptyFrame;
   packet.sizeBytes = 0;
   dec_state.UpdateOldPacket(&packet);
   EXPECT_EQ(dec_state.sequence_num(), 3);
diff --git a/webrtc/modules/video_coding/main/source/encoded_frame.cc b/webrtc/modules/video_coding/main/source/encoded_frame.cc
index 646dae32ed..92d2cd003d 100644
--- a/webrtc/modules/video_coding/main/source/encoded_frame.cc
+++ b/webrtc/modules/video_coding/main/source/encoded_frame.cc
@@ -226,38 +226,4 @@ void VCMEncodedFrame::VerifyAndAllocate(size_t minimumSize)
     }
 }
 
-webrtc::FrameType VCMEncodedFrame::ConvertFrameType(VideoFrameType frameType)
-{
-  switch(frameType) {
-    case kKeyFrame:
-      return  kVideoFrameKey;
-    case kDeltaFrame:
-      return kVideoFrameDelta;
-  }
-  // Bogus default return value.
-  return kVideoFrameDelta;
-}
-
-VideoFrameType VCMEncodedFrame::ConvertFrameType(webrtc::FrameType frame_type) {
-  switch (frame_type) {
-    case kVideoFrameKey:
-      return kKeyFrame;
-    case kVideoFrameDelta:
-      return kDeltaFrame;
-    default:
-      assert(false);
-      return kDeltaFrame;
-  }
-}
-
-void VCMEncodedFrame::ConvertFrameTypes(
-    const std::vector<webrtc::FrameType>& frame_types,
-    std::vector<VideoFrameType>* video_frame_types) {
-  assert(video_frame_types);
-  video_frame_types->reserve(frame_types.size());
-  for (size_t i = 0; i < frame_types.size(); ++i) {
-    (*video_frame_types)[i] = ConvertFrameType(frame_types[i]);
-  }
-}
-
-}
+}  // namespace webrtc
diff --git a/webrtc/modules/video_coding/main/source/encoded_frame.h b/webrtc/modules/video_coding/main/source/encoded_frame.h
index 6caaf42ff6..608578c35d 100644
--- a/webrtc/modules/video_coding/main/source/encoded_frame.h
+++ b/webrtc/modules/video_coding/main/source/encoded_frame.h
@@ -68,7 +68,7 @@ public:
     /**
     *   Get frame type
     */
-    webrtc::FrameType FrameType() const {return ConvertFrameType(_frameType);}
+    webrtc::FrameType FrameType() const { return _frameType; }
     /**
     *   Get frame rotation
     */
@@ -95,12 +95,6 @@ public:
 
     const RTPFragmentationHeader* FragmentationHeader() const;
 
-    static webrtc::FrameType ConvertFrameType(VideoFrameType frameType);
-    static VideoFrameType ConvertFrameType(webrtc::FrameType frameType);
-    static void ConvertFrameTypes(
-        const std::vector<webrtc::FrameType>& frame_types,
-        std::vector<VideoFrameType>* video_frame_types);
-
 protected:
     /**
     * Verifies that current allocated buffer size is larger than or equal to the input size.
diff --git a/webrtc/modules/video_coding/main/source/frame_buffer.cc b/webrtc/modules/video_coding/main/source/frame_buffer.cc
index 82a755ab4f..192febe2a6 100644
--- a/webrtc/modules/video_coding/main/source/frame_buffer.cc
+++ b/webrtc/modules/video_coding/main/source/frame_buffer.cc
@@ -98,7 +98,7 @@ VCMFrameBuffer::InsertPacket(const VCMPacket& packet,
         // We only take the ntp timestamp of the first packet of a frame.
         ntp_time_ms_ = packet.ntp_time_ms_;
         _codec = packet.codec;
-        if (packet.frameType != kFrameEmpty) {
+        if (packet.frameType != kEmptyFrame) {
             // first media packet
             SetState(kStateIncomplete);
         }
@@ -280,7 +280,7 @@ VCMFrameBuffer::PrepareForDecode(bool continuous) {
 #endif
     // Transfer frame information to EncodedFrame and create any codec
     // specific information.
-    _frameType = ConvertFrameType(_sessionInfo.FrameType());
+    _frameType = _sessionInfo.FrameType();
     _completeFrame = _sessionInfo.complete();
     _missingFrame = !continuous;
 }
diff --git a/webrtc/modules/video_coding/main/source/generic_encoder.cc b/webrtc/modules/video_coding/main/source/generic_encoder.cc
index 31c3f1715f..fe3d5cb991 100644
--- a/webrtc/modules/video_coding/main/source/generic_encoder.cc
+++ b/webrtc/modules/video_coding/main/source/generic_encoder.cc
@@ -140,9 +140,8 @@ VCMGenericEncoder::InitEncode(const VideoCodec* settings,
 int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
                                   const CodecSpecificInfo* codecSpecificInfo,
                                   const std::vector<FrameType>& frameTypes) {
-  std::vector<VideoFrameType> video_frame_types(frameTypes.size(),
-                                                kDeltaFrame);
-  VCMEncodedFrame::ConvertFrameTypes(frameTypes, &video_frame_types);
+  for (FrameType frame_type : frameTypes)
+    RTC_DCHECK(frame_type == kVideoFrameKey || frame_type == kVideoFrameDelta);
 
   rotation_ = inputFrame.rotation();
 
@@ -153,12 +152,11 @@ int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
     vcm_encoded_frame_callback_->SetRotation(rotation_);
   }
 
-  int32_t result =
-      encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+  int32_t result = encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
-    return encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+    return encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   }
 
   return result;
@@ -223,10 +221,7 @@ VCMGenericEncoder::SetPeriodicKeyFrames(bool enable)
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
   VideoFrame image;
-  std::vector<VideoFrameType> video_frame_types(frame_types.size(),
-                                                kDeltaFrame);
-  VCMEncodedFrame::ConvertFrameTypes(frame_types, &video_frame_types);
-  return encoder_->Encode(image, NULL, &video_frame_types);
+  return encoder_->Encode(image, NULL, &frame_types);
 }
 
 int32_t
@@ -294,6 +289,8 @@ int32_t VCMEncodedFrameCallback::Encoded(
     const EncodedImage& encodedImage,
     const CodecSpecificInfo* codecSpecificInfo,
     const RTPFragmentationHeader* fragmentationHeader) {
+  RTC_DCHECK(encodedImage._frameType == kVideoFrameKey ||
+             encodedImage._frameType == kVideoFrameDelta);
   post_encode_callback_->Encoded(encodedImage, NULL, NULL);
 
   if (_sendCallback == NULL) {
diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer.cc b/webrtc/modules/video_coding/main/source/jitter_buffer.cc
index 49c2325d80..92ffbc9120 100644
--- a/webrtc/modules/video_coding/main/source/jitter_buffer.cc
+++ b/webrtc/modules/video_coding/main/source/jitter_buffer.cc
@@ -643,7 +643,7 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
 
   // Empty packets may bias the jitter estimate (lacking size component),
   // therefore don't let empty packet trigger the following updates:
-  if (packet.frameType != kFrameEmpty) {
+  if (packet.frameType != kEmptyFrame) {
     if (waiting_for_completion_.timestamp == packet.timestamp) {
       // This can get bad if we have a lot of duplicate packets,
       // we will then count some packet multiple times.
diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc b/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc
index 7ba4d68b5c..ab4d8cd4d9 100644
--- a/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc
@@ -168,10 +168,9 @@ class TestRunningJitterBuffer : public ::testing::Test {
   }
 
   VCMFrameBufferEnum InsertFrame(FrameType frame_type) {
-    stream_generator_->GenerateFrame(frame_type,
-                                    (frame_type != kFrameEmpty) ? 1 : 0,
-                                    (frame_type == kFrameEmpty) ? 1 : 0,
-                                    clock_->TimeInMilliseconds());
+    stream_generator_->GenerateFrame(
+        frame_type, (frame_type != kEmptyFrame) ? 1 : 0,
+        (frame_type == kEmptyFrame) ? 1 : 0, clock_->TimeInMilliseconds());
     VCMFrameBufferEnum ret = InsertPacketAndPop(0);
     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
     return ret;
@@ -1050,7 +1049,7 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->completeNALU = kNaluEnd;
-    packet_->frameType = kFrameEmpty;
+    packet_->frameType = kEmptyFrame;
 
     EXPECT_EQ(jitter_buffer_->InsertPacket(*packet_, &retransmitted),
               kDecodableSession);
@@ -1524,7 +1523,7 @@ TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
-    packet_->frameType = kFrameEmpty;
+    packet_->frameType = kEmptyFrame;
 
     EXPECT_EQ(kNoError, jitter_buffer_->InsertPacket(*packet_,
                                                      &retransmitted));
@@ -1895,7 +1894,7 @@ TEST_F(TestRunningJitterBuffer, TwoPacketsNonContinuous) {
 TEST_F(TestJitterBufferNack, EmptyPackets) {
   // Make sure empty packets doesn't clog the jitter buffer.
   jitter_buffer_->SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
-  EXPECT_GE(InsertFrames(kMaxNumberOfFrames, kFrameEmpty), kNoError);
+  EXPECT_GE(InsertFrames(kMaxNumberOfFrames, kEmptyFrame), kNoError);
   InsertFrame(kVideoFrameKey);
   EXPECT_TRUE(DecodeCompleteFrame());
 }
diff --git a/webrtc/modules/video_coding/main/source/packet.cc b/webrtc/modules/video_coding/main/source/packet.cc
index 88838f35f8..fd5a6abb8c 100644
--- a/webrtc/modules/video_coding/main/source/packet.cc
+++ b/webrtc/modules/video_coding/main/source/packet.cc
@@ -16,23 +16,21 @@
 namespace webrtc {
 
 VCMPacket::VCMPacket()
-  :
-    payloadType(0),
-    timestamp(0),
-    ntp_time_ms_(0),
-    seqNum(0),
-    dataPtr(NULL),
-    sizeBytes(0),
-    markerBit(false),
-    frameType(kFrameEmpty),
-    codec(kVideoCodecUnknown),
-    isFirstPacket(false),
-    completeNALU(kNaluUnset),
-    insertStartCode(false),
-    width(0),
-    height(0),
-    codecSpecificHeader() {
-}
+    : payloadType(0),
+      timestamp(0),
+      ntp_time_ms_(0),
+      seqNum(0),
+      dataPtr(NULL),
+      sizeBytes(0),
+      markerBit(false),
+      frameType(kEmptyFrame),
+      codec(kVideoCodecUnknown),
+      isFirstPacket(false),
+      completeNALU(kNaluUnset),
+      insertStartCode(false),
+      width(0),
+      height(0),
+      codecSpecificHeader() {}
 
 VCMPacket::VCMPacket(const uint8_t* ptr,
                      const size_t size,
@@ -88,7 +86,7 @@ void VCMPacket::Reset() {
   dataPtr = NULL;
   sizeBytes = 0;
   markerBit = false;
-  frameType = kFrameEmpty;
+  frameType = kEmptyFrame;
   codec = kVideoCodecUnknown;
   isFirstPacket = false;
   completeNALU = kNaluUnset;
diff --git a/webrtc/modules/video_coding/main/source/receiver_unittest.cc b/webrtc/modules/video_coding/main/source/receiver_unittest.cc
index eb5e4718ce..707e1f1d79 100644
--- a/webrtc/modules/video_coding/main/source/receiver_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/receiver_unittest.cc
@@ -63,10 +63,8 @@ class TestVCMReceiver : public ::testing::Test {
   int32_t InsertFrame(FrameType frame_type, bool complete) {
     int num_of_packets = complete ? 1 : 2;
     stream_generator_->GenerateFrame(
-        frame_type,
-        (frame_type != kFrameEmpty) ? num_of_packets : 0,
-        (frame_type == kFrameEmpty) ? 1 : 0,
-        clock_->TimeInMilliseconds());
+        frame_type, (frame_type != kEmptyFrame) ? num_of_packets : 0,
+        (frame_type == kEmptyFrame) ? 1 : 0, clock_->TimeInMilliseconds());
     int32_t ret = InsertPacketAndPop(0);
     if (!complete) {
       // Drop the second packet.
diff --git a/webrtc/modules/video_coding/main/source/session_info.cc b/webrtc/modules/video_coding/main/source/session_info.cc
index bf6bcb3c00..7a32504b00 100644
--- a/webrtc/modules/video_coding/main/source/session_info.cc
+++ b/webrtc/modules/video_coding/main/source/session_info.cc
@@ -464,7 +464,7 @@ int VCMSessionInfo::InsertPacket(const VCMPacket& packet,
                                  uint8_t* frame_buffer,
                                  VCMDecodeErrorMode decode_error_mode,
                                  const FrameData& frame_data) {
-  if (packet.frameType == kFrameEmpty) {
+  if (packet.frameType == kEmptyFrame) {
     // Update sequence number of an empty packet.
     // Only media packets are inserted into the packet list.
     InformOfEmptyPacket(packet.seqNum);
@@ -516,7 +516,7 @@ int VCMSessionInfo::InsertPacket(const VCMPacket& packet,
       LOG(LS_WARNING) << "Received packet with a sequence number which is out "
                          "of frame boundaries";
       return -3;
-    } else if (frame_type_ == kFrameEmpty && packet.frameType != kFrameEmpty) {
+    } else if (frame_type_ == kEmptyFrame && packet.frameType != kEmptyFrame) {
       // Update the frame type with the type of the first media packet.
       // TODO(mikhal): Can this trigger?
       frame_type_ = packet.frameType;
diff --git a/webrtc/modules/video_coding/main/source/session_info_unittest.cc b/webrtc/modules/video_coding/main/source/session_info_unittest.cc
index fae55f4252..58c352d3fc 100644
--- a/webrtc/modules/video_coding/main/source/session_info_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/session_info_unittest.cc
@@ -175,7 +175,7 @@ TEST_F(TestSessionInfo, TestSimpleAPIs) {
   packet_.markerBit = true;
   packet_.seqNum  = 2;
   packet_.sizeBytes = 0;
-  packet_.frameType = kFrameEmpty;
+  packet_.frameType = kEmptyFrame;
   EXPECT_EQ(0,
             session_.InsertPacket(packet_,
                                   frame_buffer_,
@@ -888,7 +888,7 @@ TEST_F(TestVP8Partitions, AggregationOverTwoPackets) {
 TEST_F(TestNalUnits, OnlyReceivedEmptyPacket) {
   packet_.isFirstPacket = false;
   packet_.completeNALU = kNaluComplete;
-  packet_.frameType = kFrameEmpty;
+  packet_.frameType = kEmptyFrame;
   packet_.sizeBytes = 0;
   packet_.seqNum = 0;
   packet_.markerBit = false;
diff --git a/webrtc/modules/video_coding/main/source/test/stream_generator.cc b/webrtc/modules/video_coding/main/source/test/stream_generator.cc
index dcf9b68602..664764a36a 100644
--- a/webrtc/modules/video_coding/main/source/test/stream_generator.cc
+++ b/webrtc/modules/video_coding/main/source/test/stream_generator.cc
@@ -46,8 +46,8 @@ void StreamGenerator::GenerateFrame(FrameType type,
     ++sequence_number_;
   }
   for (int i = 0; i < num_empty_packets; ++i) {
-    packets_.push_back(GeneratePacket(
-        sequence_number_, timestamp, 0, false, false, kFrameEmpty));
+    packets_.push_back(GeneratePacket(sequence_number_, timestamp, 0, false,
+                                      false, kEmptyFrame));
     ++sequence_number_;
   }
 }
diff --git a/webrtc/modules/video_coding/main/source/video_receiver_unittest.cc b/webrtc/modules/video_coding/main/source/video_receiver_unittest.cc
index 1f1996ecdd..16eaed344d 100644
--- a/webrtc/modules/video_coding/main/source/video_receiver_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/video_receiver_unittest.cc
@@ -88,7 +88,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFrames) {
   const uint8_t payload[kPaddingSize] = {0};
   WebRtcRTPHeader header;
   memset(&header, 0, sizeof(header));
-  header.frameType = kFrameEmpty;
+  header.frameType = kEmptyFrame;
   header.header.markerBit = false;
   header.header.paddingLength = kPaddingSize;
   header.header.payloadType = kUnusedPayloadType;
@@ -112,7 +112,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
   const uint8_t payload[kFrameSize] = {0};
   WebRtcRTPHeader header;
   memset(&header, 0, sizeof(header));
-  header.frameType = kFrameEmpty;
+  header.frameType = kEmptyFrame;
   header.header.markerBit = false;
   header.header.paddingLength = kPaddingSize;
   header.header.payloadType = kUnusedPayloadType;
@@ -127,7 +127,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
   clock_.AdvanceTimeMilliseconds(33);
   header.header.timestamp += 3000;
 
-  header.frameType = kFrameEmpty;
+  header.frameType = kEmptyFrame;
   header.type.Video.isFirstPacket = false;
   header.header.markerBit = false;
   // Insert padding frames.
@@ -163,7 +163,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
   const uint8_t payload[kFrameSize] = {0};
   WebRtcRTPHeader header;
   memset(&header, 0, sizeof(header));
-  header.frameType = kFrameEmpty;
+  header.frameType = kEmptyFrame;
   header.type.Video.isFirstPacket = false;
   header.header.markerBit = false;
   header.header.paddingLength = kPaddingSize;
@@ -188,7 +188,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
     }
 
     // Insert 2 padding only frames.
-    header.frameType = kFrameEmpty;
+    header.frameType = kEmptyFrame;
     header.type.Video.isFirstPacket = false;
     header.header.markerBit = false;
     for (int j = 0; j < 2; ++j) {
diff --git a/webrtc/modules/video_coding/main/source/video_sender.cc b/webrtc/modules/video_coding/main/source/video_sender.cc
index a5ef22a46e..8401cb2ac0 100644
--- a/webrtc/modules/video_coding/main/source/video_sender.cc
+++ b/webrtc/modules/video_coding/main/source/video_sender.cc
@@ -313,7 +313,7 @@ int32_t VideoSender::AddVideoFrame(const VideoFrame& videoFrame,
   }
   // TODO(holmer): Add support for dropping frames per stream. Currently we
   // only have one frame dropper for all streams.
-  if (_nextFrameTypes[0] == kFrameEmpty) {
+  if (_nextFrameTypes[0] == kEmptyFrame) {
     return VCM_OK;
   }
   if (_mediaOpt.DropFrame()) {
diff --git a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
index 31c7173c6a..13e6b99735 100644
--- a/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
+++ b/webrtc/modules/video_coding/main/source/video_sender_unittest.cc
@@ -244,7 +244,7 @@ class TestVideoSenderWithMockEncoder : public TestVideoSender {
     }
     assert(stream >= 0);
     assert(stream < kNumberOfStreams);
-    std::vector<VideoFrameType> frame_types(kNumberOfStreams, kDeltaFrame);
+    std::vector<FrameType> frame_types(kNumberOfStreams, kDeltaFrame);
     frame_types[stream] = kKeyFrame;
     EXPECT_CALL(
         encoder_,