Remove kProtectionKey* and VCMKeyRequestMode.

webrtc/modules/video_coding/main/source/video_receiver.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 24 matching lines @@
       _frameTypeCallback(NULL),
       _receiveStatsCallback(NULL),
       _decoderTimingCallback(NULL),
       _packetRequestCallback(NULL),
       render_buffer_callback_(NULL),
       _decoder(NULL),
 #ifdef DEBUG_DECODER_BIT_STREAM
       _bitStreamBeforeDecoder(NULL),
 #endif
       _frameFromFile(),
-      _keyRequestMode(kKeyOnError),
       _scheduleKeyRequest(false),
       max_nack_list_size_(0),
       pre_decode_image_callback_(NULL),
       _codecDataBase(NULL),
       _receiveStatsTimer(1000, clock_),
       _retransmissionTimer(10, clock_),
       _keyRequestTimer(500, clock_) {
   assert(clock_);
 #ifdef DEBUG_DECODER_BIT_STREAM
   _bitStreamBeforeDecoder = fopen("decoderBitStream.bit", "wb");
@@ skipping 131 matching lines @@
                                           bool enable) {
   // By default, do not decode with errors.
   _receiver.SetDecodeErrorMode(kNoErrors);
   switch (videoProtection) {
     case kProtectionNack: {
       DCHECK(enable);
       _receiver.SetNackMode(kNack, -1, -1);
       break;
     }
 
-    case kProtectionKeyOnLoss: {
-      CriticalSectionScoped cs(_receiveCritSect);
-      if (enable) {
-        _keyRequestMode = kKeyOnLoss;
-        _receiver.SetDecodeErrorMode(kWithErrors);
-      } else if (_keyRequestMode == kKeyOnLoss) {
-        _keyRequestMode = kKeyOnError;  // default mode
-      } else {
-        return VCM_PARAMETER_ERROR;
-      }
-      break;
-    }
-
-    case kProtectionKeyOnKeyLoss: {
-      CriticalSectionScoped cs(_receiveCritSect);
-      if (enable) {
-        _keyRequestMode = kKeyOnKeyLoss;
-      } else if (_keyRequestMode == kKeyOnKeyLoss) {
-        _keyRequestMode = kKeyOnError;  // default mode
-      } else {
-        return VCM_PARAMETER_ERROR;
-      }
-      break;
-    }
-
     case kProtectionNackFEC: {
       CriticalSectionScoped cs(_receiveCritSect);
       DCHECK(enable);
       _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
       _receiver.SetDecodeErrorMode(kNoErrors);
       break;
     }
     case kProtectionFEC:
     case kProtectionNone:
       // No receiver-side protection.
@@ skipping 180 matching lines @@
       return RequestSliceLossIndication(
           _decodedFrameCallback.LastReceivedPictureID() + 1);
     } else {
       request_key_frame = true;
     }
   } else if (ret == VCM_REQUEST_SLI) {
     ret = RequestSliceLossIndication(
         _decodedFrameCallback.LastReceivedPictureID() + 1);
   }
   if (!frame.Complete() || frame.MissingFrame()) {
-    switch (_keyRequestMode) {
-      case kKeyOnKeyLoss: {
-        if (frame.FrameType() == kVideoFrameKey) {
-          request_key_frame = true;
-          ret = VCM_OK;
-        }
-        break;
-      }
-      case kKeyOnLoss: {
-        request_key_frame = true;
-        ret = VCM_OK;
-        break;
-      }
-      default:
-        break;
-    }
+    request_key_frame = true;

[stefan-webrtc, 2015/07/27 13:01:08]

Not sure about this change. I think I'd prefer for the default to be that we
rely on the decoder to return an error and have that as a signal to request a
key frame.

[pbos-webrtc, 2015/07/27 13:05:11]

Right now it's a no-op since this mode was always configured to be used in
ViEChannel.

+    ret = VCM_OK;
   }
   if (request_key_frame) {
     CriticalSectionScoped cs(process_crit_sect_.get());
     _scheduleKeyRequest = true;
   }
   TRACE_EVENT_ASYNC_END0("webrtc", "Video", frame.TimeStamp());
   return ret;
 }
 
 // Reset the decoder state
@@ skipping 97 matching lines @@
   return _receiver.DiscardedPackets();
 }
 
 int VideoReceiver::SetReceiverRobustnessMode(
     ReceiverRobustness robustnessMode,
     VCMDecodeErrorMode decode_error_mode) {
   CriticalSectionScoped cs(_receiveCritSect);
   switch (robustnessMode) {
     case VideoCodingModule::kNone:
       _receiver.SetNackMode(kNoNack, -1, -1);
-      if (decode_error_mode == kNoErrors) {
-        _keyRequestMode = kKeyOnLoss;
-      } else {
-        _keyRequestMode = kKeyOnError;
-      }
       break;
     case VideoCodingModule::kHardNack:
       // Always wait for retransmissions (except when decoding with errors).
       _receiver.SetNackMode(kNack, -1, -1);
-      _keyRequestMode = kKeyOnError;  // TODO(hlundin): On long NACK list?
       break;
     case VideoCodingModule::kSoftNack:
 #if 1
       assert(false);  // TODO(hlundin): Not completed.
       return VCM_NOT_IMPLEMENTED;
 #else
       // Enable hybrid NACK/FEC. Always wait for retransmissions and don't add
       // extra delay when RTT is above kLowRttNackMs.
       _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
-      _keyRequestMode = kKeyOnError;
       break;
 #endif
     case VideoCodingModule::kReferenceSelection:
 #if 1
       assert(false);  // TODO(hlundin): Not completed.
       return VCM_NOT_IMPLEMENTED;
 #else
       if (decode_error_mode == kNoErrors) {
         return VCM_PARAMETER_ERROR;
       }
@@ skipping 26 matching lines @@
 }
 
 void VideoReceiver::RegisterPreDecodeImageCallback(
     EncodedImageCallback* observer) {
   CriticalSectionScoped cs(_receiveCritSect);
   pre_decode_image_callback_ = observer;
 }
 
 }  // namespace vcm
 }  // namespace webrtc