Enable video stats reporting when using WebRTC

remoting/protocol/webrtc_video_encoder_factory.cc

 // Copyright 2016 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 "remoting/protocol/webrtc_video_encoder_factory.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 72 matching lines @@
 int32_t WebrtcVideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) {
   VLOG(1) << "WebrtcVideoEncoder::SetRates bitrate:framerate " << bitrate << ":"
           << framerate;
   if (!target_bitrate_cb_.is_null())
     target_bitrate_cb_.Run(bitrate);
   // framerate is not expected to be valid given we never report captured
   // frames
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-int WebrtcVideoEncoder::SendEncodedFrame(std::unique_ptr<VideoPacket> frame) {
+webrtc::EncodedImageCallback::Result WebrtcVideoEncoder::SendEncodedFrame(
+    std::unique_ptr<VideoPacket> frame,
+    base::TimeTicks capture_time) {
   uint8_t* buffer =
       reinterpret_cast<uint8_t*>(const_cast<char*>(frame->data().data()));
   size_t buffer_size = frame->data().size();
   base::AutoLock lock(lock_);
   if (state_ == kUninitialized) {
     LOG(ERROR) << "encoder interface uninitialized";
-    return -1;
+    return webrtc::EncodedImageCallback::Result(
+        webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED);
   }
 
   webrtc::EncodedImage encoded_image(buffer, buffer_size, buffer_size);
   encoded_image._encodedWidth = frame->format().screen_width();
   encoded_image._encodedHeight = frame->format().screen_height();
   encoded_image._completeFrame = true;
   encoded_image._frameType =
       frame->key_frame() ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta;
-  encoded_image.capture_time_ms_ = frame->capture_time_ms();
-  encoded_image._timeStamp =
-      static_cast<uint32_t>(frame->capture_time_ms() * 90);
+  int64_t capture_time_ms = (capture_time - base::TimeTicks()).InMilliseconds();
+  encoded_image.capture_time_ms_ = capture_time_ms;
+  encoded_image._timeStamp = static_cast<uint32_t>(capture_time_ms * 90);
   encoded_image.playout_delay_.min_ms = 0;
   encoded_image.playout_delay_.max_ms = 0;
 
   webrtc::CodecSpecificInfo codec_specific_info;
   memset(&codec_specific_info, 0, sizeof(codec_specific_info));
   codec_specific_info.codecType = webrtc::kVideoCodecVP8;
 
   webrtc::RTPFragmentationHeader header;
   memset(&header, 0, sizeof(header));
 
   codec_specific_info.codecSpecific.VP8.simulcastIdx = 0;
   codec_specific_info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx;
   codec_specific_info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx;
   codec_specific_info.codecSpecific.VP8.pictureId = webrtc::kNoPictureId;
 
   header.VerifyAndAllocateFragmentationHeader(1);
   header.fragmentationOffset[0] = 0;
   header.fragmentationLength[0] = buffer_size;
   header.fragmentationPlType[0] = 0;
   header.fragmentationTimeDiff[0] = 0;
 
-  int result =
-      encoded_callback_->Encoded(encoded_image, &codec_specific_info, &header);
-  if (result < 0) {
-    LOG(ERROR) << "Encoded callback failed: " << result;
-  } else if (result > 0) {
-    VLOG(1) << "Drop request from webrtc";
-  }
-  return result;
+  return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info,
+                                           &header);
 }
 
 void WebrtcVideoEncoder::SetKeyFrameRequestCallback(
     const base::Closure& key_frame_request) {
   base::AutoLock lock(lock_);
   key_frame_request_ = key_frame_request;
 }
 
 void WebrtcVideoEncoder::SetTargetBitrateCallback(
     const TargetBitrateCallback& target_bitrate_cb) {
@@ skipping 46 matching lines @@
   }
   for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) {
     if ((*pos).get() == encoder) {
       encoders_.erase(pos);
       return;
     }
   }
   DCHECK(false) << "Asked to remove encoder not owned by factory";
 }
 
-int WebrtcVideoEncoderFactory::SendEncodedFrame(
-    std::unique_ptr<VideoPacket> frame) {
+webrtc::EncodedImageCallback::Result
+WebrtcVideoEncoderFactory::SendEncodedFrame(std::unique_ptr<VideoPacket> frame,
+                                            base::TimeTicks capture_time) {
   if (encoders_.size() != 1) {
     LOG(ERROR) << "Unexpected number of encoders " << encoders_.size();
-    return -1;
+    return webrtc::EncodedImageCallback::Result(
+        webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED);
   }
-  return encoders_.front()->SendEncodedFrame(std::move(frame));
+  return encoders_.front()->SendEncodedFrame(std::move(frame), capture_time);
 }
 
 void WebrtcVideoEncoderFactory::SetKeyFrameRequestCallback(
     const base::Closure& key_frame_request) {
   base::AutoLock lock(lock_);
   key_frame_request_ = key_frame_request;
   if (encoders_.size() == 1) {
     encoders_.front()->SetKeyFrameRequestCallback(key_frame_request);
   } else {
     LOG(ERROR) << "Dropping key frame request callback with unexpected"
                   " number of encoders: "
                << encoders_.size();
   }
 }
 
 void WebrtcVideoEncoderFactory::SetTargetBitrateCallback(
     const TargetBitrateCallback& target_bitrate_cb) {
   base::AutoLock lock(lock_);
   target_bitrate_cb_ = target_bitrate_cb;
   if (encoders_.size() == 1) {
     encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb);
   } else {
     LOG(ERROR) << "Dropping target bitrate request callback with unexpected"
                   " number of encoders: "
                << encoders_.size();
   }
 }
+
 }  // namespace remoting