VideoProcessor: mini-fixes in preparation for task queue CL.

webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h

 /*
  *  Copyright (c) 2012 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 248 matching lines @@
     perc_encoding_rate_mismatch_ = 0.0f;
     num_frames_to_hit_target_ = num_frames_to_hit_target;
     encoding_rate_within_target_ = false;
     sum_key_frame_size_mismatch_ = 0.0;
     num_key_frames_ = 0;
   }
 
   // For every encoded frame, update the rate control metrics.
   void UpdateRateControlMetrics(int frame_number) {
     RTC_CHECK_GE(frame_number, 0);
-    int tl_idx = TemporalLayerIndexForFrame(frame_number);
-    FrameType frame_type = processor_->EncodedFrameType(frame_number);
+
+    FrameType frame_type = stats_.stats_[frame_number].frame_type;
     float encoded_size_kbits =
-        processor_->EncodedFrameSize(frame_number) * 8.0f / 1000.0f;
+        stats_.stats_[frame_number].encoded_frame_length_in_bytes * 8.0f /
+        1000.0f;
+    const int tl_idx = TemporalLayerIndexForFrame(frame_number);
 
     // Update layer data.
     // Update rate mismatch relative to per-frame bandwidth for delta frames.
     if (frame_type == kVideoFrameDelta) {
       // TODO(marpan): Should we count dropped (zero size) frames in mismatch?
       sum_frame_size_mismatch_[tl_idx] +=
           fabs(encoded_size_kbits - per_frame_bandwidth_[tl_idx]) /
           per_frame_bandwidth_[tl_idx];
     } else {
       float target_size = (frame_number == 0) ? target_size_key_frame_initial_
@@ skipping 200 matching lines @@
     ResetRateControlMetrics(
         rate_profile.frame_index_rate_update[update_index + 1]);
 
     if (config_.batch_mode) {
       // In batch mode, we calculate the metrics for all frames after all frames
       // have been sent for encoding.
 
       // TODO(brandtr): Refactor "frame number accounting" so we don't have to
       // call ProcessFrame num_frames+1 times here.
       for (frame_number = 0; frame_number <= num_frames; ++frame_number) {
-        EXPECT_TRUE(processor_->ProcessFrame(frame_number));
+        processor_->ProcessFrame(frame_number);
       }
 
       for (frame_number = 0; frame_number < num_frames; ++frame_number) {
         const int tl_idx = TemporalLayerIndexForFrame(frame_number);
         ++num_frames_per_update_[tl_idx];
         ++num_frames_total_;
         UpdateRateControlMetrics(frame_number);
       }
     } else {
       // In online mode, we calculate the metrics for a given frame right after
       // it has been sent for encoding.
 
       if (config_.hw_codec) {
         LOG(LS_WARNING) << "HW codecs should mostly be run in batch mode, "
                            "since they may be pipelining.";
       }
 
       while (frame_number < num_frames) {
-        EXPECT_TRUE(processor_->ProcessFrame(frame_number));
+        processor_->ProcessFrame(frame_number);
         VerifyQpParser(frame_number);
         const int tl_idx = TemporalLayerIndexForFrame(frame_number);
         ++num_frames_per_update_[tl_idx];
         ++num_frames_total_;
         UpdateRateControlMetrics(frame_number);
 
         ++frame_number;
 
         // If we hit another/next update, verify stats for current state and
         // update layers and codec with new rates.
         if (frame_number ==
             rate_profile.frame_index_rate_update[update_index + 1]) {
           VerifyRateControlMetrics(update_index, rc_thresholds[update_index]);
 
           // Update layer rates and the codec with new rates.
           ++update_index;
           bit_rate_ = rate_profile.target_bit_rate[update_index];
           frame_rate_ = rate_profile.input_frame_rate[update_index];
           SetTemporalLayerRates();
           ResetRateControlMetrics(
               rate_profile.frame_index_rate_update[update_index + 1]);
           processor_->SetRates(bit_rate_, frame_rate_);
         }
       }
       // TODO(brandtr): Refactor "frame number accounting" so we don't have to
       // call ProcessFrame one extra time here.
-      EXPECT_TRUE(processor_->ProcessFrame(frame_number));
+      processor_->ProcessFrame(frame_number);
     }
 
     // Verify rate control metrics for all frames (if in batch mode), or for all
     // frames since the last rate update (if not in batch mode).
     VerifyRateControlMetrics(update_index, rc_thresholds[update_index]);
     EXPECT_EQ(num_frames, frame_number);
     EXPECT_EQ(num_frames + 1, static_cast<int>(stats_.stats_.size()));
 
     // Release encoder and decoder to make sure they have finished processing.
     processor_->Release();
@@ skipping 167 matching lines @@
   float target_size_key_frame_initial_;
   float target_size_key_frame_;
   float sum_key_frame_size_mismatch_;
   int num_key_frames_;
 };
 
 }  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_TEST_VIDEOPROCESSOR_INTEGRATIONTEST_H_