Revert of Remove ignored return code from modules.

webrtc/modules/video_coding/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 45 matching lines @@
 #endif
 }
 
 VideoReceiver::~VideoReceiver() {
   delete _receiveCritSect;
 #ifdef DEBUG_DECODER_BIT_STREAM
   fclose(_bitStreamBeforeDecoder);
 #endif
 }
 
-void VideoReceiver::Process() {
+int32_t VideoReceiver::Process() {
+  int32_t returnValue = VCM_OK;
+
   // Receive-side statistics
   if (_receiveStatsTimer.TimeUntilProcess() == 0) {
     _receiveStatsTimer.Processed();
     CriticalSectionScoped cs(process_crit_sect_.get());
     if (_receiveStatsCallback != NULL) {
       uint32_t bitRate;
       uint32_t frameRate;
       _receiver.ReceiveStatistics(&bitRate, &frameRate);
       _receiveStatsCallback->OnReceiveRatesUpdated(bitRate, frameRate);
     }
@@ skipping 22 matching lines @@
   }
 
   // Key frame requests
   if (_keyRequestTimer.TimeUntilProcess() == 0) {
     _keyRequestTimer.Processed();
     bool request_key_frame = false;
     {
       CriticalSectionScoped cs(process_crit_sect_.get());
       request_key_frame = _scheduleKeyRequest && _frameTypeCallback != NULL;
     }
-    if (request_key_frame)
-      RequestKeyFrame();
+    if (request_key_frame) {
+      const int32_t ret = RequestKeyFrame();
+      if (ret != VCM_OK && returnValue == VCM_OK) {
+        returnValue = ret;
+      }
+    }
   }
 
   // Packet retransmission requests
   // TODO(holmer): Add API for changing Process interval and make sure it's
   // disabled when NACK is off.
   if (_retransmissionTimer.TimeUntilProcess() == 0) {
     _retransmissionTimer.Processed();
     bool callback_registered = false;
     uint16_t length;
     {
       CriticalSectionScoped cs(process_crit_sect_.get());
       length = max_nack_list_size_;
       callback_registered = _packetRequestCallback != NULL;
     }
     if (callback_registered && length > 0) {
       // Collect sequence numbers from the default receiver.
       bool request_key_frame = false;
       std::vector<uint16_t> nackList = _receiver.NackList(&request_key_frame);
       int32_t ret = VCM_OK;
       if (request_key_frame) {
         ret = RequestKeyFrame();
+        if (ret != VCM_OK && returnValue == VCM_OK) {
+          returnValue = ret;
+        }
       }
       if (ret == VCM_OK && !nackList.empty()) {
         CriticalSectionScoped cs(process_crit_sect_.get());
         if (_packetRequestCallback != NULL) {
           _packetRequestCallback->ResendPackets(&nackList[0], nackList.size());
         }
       }
     }
   }
+
+  return returnValue;
 }
 
 int64_t VideoReceiver::TimeUntilNextProcess() {
   int64_t timeUntilNextProcess = _receiveStatsTimer.TimeUntilProcess();
   if (_receiver.NackMode() != kNoNack) {
     // We need a Process call more often if we are relying on
     // retransmissions
     timeUntilNextProcess =
         VCM_MIN(timeUntilNextProcess, _retransmissionTimer.TimeUntilProcess());
   }
@@ skipping 376 matching lines @@
 }
 
 void VideoReceiver::RegisterPreDecodeImageCallback(
     EncodedImageCallback* observer) {
   CriticalSectionScoped cs(_receiveCritSect);
   pre_decode_image_callback_ = observer;
 }
 
 }  // namespace vcm
 }  // namespace webrtc