FrameBuffer::NextFrame now return pair<frame, reason>.

webrtc/modules/video_coding/frame_buffer2.cc

 /*
  *  Copyright (c) 2016 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 34 matching lines @@
                          VCMTiming* timing)
     : clock_(clock),
       frame_inserted_event_(false, false),
       jitter_estimator_(jitter_estimator),
       timing_(timing),
       inter_frame_delay_(clock_->TimeInMilliseconds()),
       newest_picture_id_(-1),
       stopped_(false),
       protection_mode_(kProtectionNack) {}
 
-std::unique_ptr<FrameObject> FrameBuffer::NextFrame(int64_t max_wait_time_ms) {
+FrameBuffer::ReturnReason FrameBuffer::NextFrame(
+    int64_t max_wait_time_ms,
+    std::unique_ptr<FrameObject>* frame_out) {
   int64_t latest_return_time = clock_->TimeInMilliseconds() + max_wait_time_ms;
   int64_t now = clock_->TimeInMilliseconds();
   int64_t wait_ms = max_wait_time_ms;
   while (true) {
     std::map<FrameKey, std::unique_ptr<FrameObject>, FrameComp>::iterator
         next_frame_it;
     {
       rtc::CritScope lock(&crit_);
       frame_inserted_event_.Reset();
       if (stopped_)
-        return std::unique_ptr<FrameObject>();
+        return kStopped;
 
       now = clock_->TimeInMilliseconds();
       wait_ms = max_wait_time_ms;
       next_frame_it = frames_.end();
       for (auto frame_it = frames_.begin(); frame_it != frames_.end();
            ++frame_it) {
         const FrameObject& frame = *frame_it->second;
         if (IsContinuous(frame)) {
           next_frame_it = frame_it;
           int64_t render_time =
@@ skipping 31 matching lines @@
                                             next_frame_it->second->size);
         }
         float rtt_mult = protection_mode_ == kProtectionNackFEC ? 0.0 : 1.0;
         timing_->SetJitterDelay(jitter_estimator_->GetJitterEstimate(rtt_mult));
         timing_->UpdateCurrentDelay(next_frame_it->second->RenderTime(),
                                     clock_->TimeInMilliseconds());
 
         decoded_frames_.insert(next_frame_it->first);
         std::unique_ptr<FrameObject> frame = std::move(next_frame_it->second);
         frames_.erase(frames_.begin(), ++next_frame_it);
-        return frame;
+        *frame_out = std::move(frame);
+        return kFrameFound;
       } else {
-        return std::unique_ptr<FrameObject>();
+        return kTimeout;
       }
     }
   }
 }
 
 void FrameBuffer::SetProtectionMode(VCMVideoProtection mode) {
   rtc::CritScope lock(&crit_);
   protection_mode_ = mode;
 }
 
@@ skipping 54 matching lines @@
     FrameKey ref_key(frame.picture_id, frame.spatial_layer - 1);
     if (decoded_frames_.find(ref_key) == decoded_frames_.end())
       return false;
   }
 
   return true;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc