RTC Video Encoder: Use capturer timestamp

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 235 matching lines @@
       const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
       int32_t bits_per_second,
       media::VideoCodecProfile codec);
 
   // media::VideoEncodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32_t bitstream_buffer_id,
                             size_t payload_size,
-                            bool key_frame) override;
+                            bool key_frame,
+                            base::TimeDelta timestamp) override;
   void NotifyError(media::VideoEncodeAccelerator::Error error) override;
 
  private:
   using VideoFrameAndTimestamp =
       std::pair<scoped_refptr<VideoFrame>, base::TimeTicks>;
 
   void UseOutputBitstreamBufferId(int32_t bitstream_buffer_id);
   void FrameFinished(std::unique_ptr<base::SharedMemory> shm);
 
   // VideoTrackRecorder::Encoder implementation.
@@ skipping 151 matching lines @@
     if (shm)
       output_buffers_.push_back(base::WrapUnique(shm.release()));
   }
 
   for (size_t i = 0; i < output_buffers_.size(); ++i)
     UseOutputBitstreamBufferId(i);
 }
 
 void VEAEncoder::BitstreamBufferReady(int32_t bitstream_buffer_id,
                                       size_t payload_size,
-                                      bool keyframe) {
+                                      bool keyframe,
+                                      base::TimeDelta timestamp) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   base::SharedMemory* output_buffer =
       output_buffers_[bitstream_buffer_id].get();
 
   std::unique_ptr<std::string> data(new std::string);
   data->append(reinterpret_cast<char*>(output_buffer->memory()), payload_size);
 
   const auto front_frame = frames_in_encode_.front();
@@ skipping 542 matching lines @@
   encoder_->SetPaused(false);
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 }  // namespace content