Eliminate a few uses of IsZeroSize.

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 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.
  */
 #include <stdio.h>
@@ skipping 197 matching lines @@
 
   void OnFrame(const VideoFrame& video_frame) override {
     int64_t render_time_ms =
         Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
 
     rtc::CritScope lock(&crit_);
     int64_t send_timestamp =
         wrap_handler_.Unwrap(video_frame.timestamp() - rtp_timestamp_delta_);
 
     while (wrap_handler_.Unwrap(frames_.front().timestamp()) < send_timestamp) {
-      if (last_rendered_frame_.IsZeroSize()) {
+      if (!last_rendered_frame_) {
         // No previous frame rendered, this one was dropped after sending but
         // before rendering.
         ++dropped_frames_before_rendering_;
         frames_.pop_front();
         RTC_CHECK(!frames_.empty());
         continue;
       }
-      AddFrameComparison(frames_.front(), last_rendered_frame_, true,
+      AddFrameComparison(frames_.front(), *last_rendered_frame_, true,
                          render_time_ms);
       frames_.pop_front();
       RTC_DCHECK(!frames_.empty());
     }
 
     VideoFrame reference_frame = frames_.front();
     frames_.pop_front();
-    assert(!reference_frame.IsZeroSize());
     int64_t reference_timestamp =
         wrap_handler_.Unwrap(reference_frame.timestamp());
     if (send_timestamp == reference_timestamp - 1) {
       // TODO(ivica): Make this work for > 2 streams.
       // Look at RTPSender::BuildRTPHeader.
       ++send_timestamp;
     }
     ASSERT_EQ(reference_timestamp, send_timestamp);
 
     AddFrameComparison(reference_frame, video_frame, false, render_time_ms);
 
-    last_rendered_frame_ = video_frame;
+    last_rendered_frame_ = rtc::Optional<VideoFrame>(video_frame);
   }
 
   void Wait() {
     // Frame comparisons can be very expensive. Wait for test to be done, but
     // at time-out check if frames_processed is going up. If so, give it more
     // time, otherwise fail. Hopefully this will reduce test flakiness.
 
     stats_polling_thread_.Start();
 
     int last_frames_processed = -1;
@@ skipping 129 matching lines @@
 
    private:
     VideoAnalyzer* const parent_;
   };
 
   void AddFrameComparison(const VideoFrame& reference,
                           const VideoFrame& render,
                           bool dropped,
                           int64_t render_time_ms)
       EXCLUSIVE_LOCKS_REQUIRED(crit_) {
-    RTC_DCHECK(!render.IsZeroSize());
     int64_t reference_timestamp = wrap_handler_.Unwrap(reference.timestamp());
     int64_t send_time_ms = send_times_[reference_timestamp];
     send_times_.erase(reference_timestamp);
     int64_t recv_time_ms = recv_times_[reference_timestamp];
     recv_times_.erase(reference_timestamp);
 
     // TODO(ivica): Make this work for > 2 streams.
     auto it = encoded_frame_sizes_.find(reference_timestamp);
     if (it == encoded_frame_sizes_.end())
       it = encoded_frame_sizes_.find(reference_timestamp - 1);
@@ skipping 250 matching lines @@
   int frames_recorded_;
   int frames_processed_;
   int dropped_frames_;
   int dropped_frames_before_first_encode_;
   int dropped_frames_before_rendering_;
   int64_t last_render_time_;
   uint32_t rtp_timestamp_delta_;
 
   rtc::CriticalSection crit_;
   std::deque<VideoFrame> frames_ GUARDED_BY(crit_);
-  VideoFrame last_rendered_frame_ GUARDED_BY(crit_);
+  rtc::Optional<VideoFrame> last_rendered_frame_ GUARDED_BY(crit_);
   rtc::TimestampWrapAroundHandler wrap_handler_ GUARDED_BY(crit_);
   std::map<int64_t, int64_t> send_times_ GUARDED_BY(crit_);
   std::map<int64_t, int64_t> recv_times_ GUARDED_BY(crit_);
   std::map<int64_t, size_t> encoded_frame_sizes_ GUARDED_BY(crit_);
   rtc::Optional<uint32_t> first_send_timestamp_ GUARDED_BY(crit_);
   const double avg_psnr_threshold_;
   const double avg_ssim_threshold_;
 
   rtc::CriticalSection comparison_lock_;
   std::vector<rtc::PlatformThread*> comparison_thread_pool_;
@@ skipping 477 matching lines @@
   video_send_stream_->Stop();
   receive_stream->Stop();
 
   call->DestroyVideoReceiveStream(receive_stream);
   call->DestroyVideoSendStream(video_send_stream_);
 
   transport.StopSending();
 }
 
 }  // namespace webrtc